1 /* DVB USB compliant linux driver for
3 * DM04/QQBOX DVB-S USB BOX LME2510C + SHARP:BS2F7HZ7395
4 * LME2510C + LG TDQY-P001F
5 * LME2510C + BS2F7HZ0194
6 * LME2510 + LG TDQY-P001F
7 * LME2510 + BS2F7HZ0194
9 * MVB7395 (LME2510C+SHARP:BS2F7HZ7395)
10 * SHARP:BS2F7HZ7395 = (STV0288+Sharp IX2505V)
12 * MV001F (LME2510+LGTDQY-P001F)
13 * LG TDQY - P001F =(TDA8263 + TDA10086H)
15 * MVB0001F (LME2510C+LGTDQT-P001F)
17 * MV0194 (LME2510+SHARP:BS2F7HZ0194)
18 * SHARP:BS2F7HZ0194 = (STV0299+IX2410)
20 * MVB0194 (LME2510C+SHARP0194)
22 * LME2510C + M88RS2000
24 * For firmware see Documentation/dvb/lmedm04.txt
27 * 0xd0 - STV0288 - Demodulator
28 * 0xc0 - Sharp IX2505V - Tuner
30 * 0x1c - TDA10086 - Demodulator
31 * 0xc0 - TDA8263 - Tuner
33 * 0xd0 - STV0299 - Demodulator
34 * 0xc0 - IX2410 - Tuner
37 * VID = 3344 PID LME2510=1122 LME2510C=1120
39 * Copyright (C) 2010 Malcolm Priestley (tvboxspy@gmail.com)
40 * LME2510(C)(C) Leaguerme (Shenzhen) MicroElectronics Co., Ltd.
42 * This program is free software; you can redistribute it and/or modify
43 * it under the terms of the GNU General Public License Version 2, as
44 * published by the Free Software Foundation.
46 * This program is distributed in the hope that it will be useful,
47 * but WITHOUT ANY WARRANTY; without even the implied warranty of
48 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
49 * GNU General Public License for more details.
51 * You should have received a copy of the GNU General Public License
52 * along with this program; if not, write to the Free Software
53 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
56 * see Documentation/dvb/README.dvb-usb for more information
59 * LME2510: Non Intel USB chipsets fail to maintain High Speed on
62 * QQbox suffers from noise on LNB voltage.
64 * LME2510: SHARP:BS2F7HZ0194(MV0194) cannot cold reset and share system
65 * with other tuners. After a cold reset streaming will not start.
67 * M88RS2000 suffers from loss of lock.
69 #define DVB_USB_LOG_PREFIX "LME2510(C)"
70 #include <linux/usb.h>
71 #include <linux/usb/input.h>
72 #include <media/rc-core.h>
83 #include "m88rs2000.h"
87 #define LME2510_C_S7395 "dvb-usb-lme2510c-s7395.fw";
88 #define LME2510_C_LG "dvb-usb-lme2510c-lg.fw";
89 #define LME2510_C_S0194 "dvb-usb-lme2510c-s0194.fw";
90 #define LME2510_C_RS2000 "dvb-usb-lme2510c-rs2000.fw";
91 #define LME2510_LG "dvb-usb-lme2510-lg.fw";
92 #define LME2510_S0194 "dvb-usb-lme2510-s0194.fw";
95 static int dvb_usb_lme2510_debug
;
96 #define lme_debug(var, level, args...) do { \
98 pr_debug(DVB_USB_LOG_PREFIX": " args); \
100 #define deb_info(level, args...) lme_debug(dvb_usb_lme2510_debug, level, args)
101 #define debug_data_snipet(level, name, p) \
102 deb_info(level, name" (%02x%02x%02x%02x%02x%02x%02x%02x)", \
103 *p, *(p+1), *(p+2), *(p+3), *(p+4), \
104 *(p+5), *(p+6), *(p+7));
105 #define info(args...) pr_info(DVB_USB_LOG_PREFIX": "args)
107 module_param_named(debug
, dvb_usb_lme2510_debug
, int, 0644);
108 MODULE_PARM_DESC(debug
, "set debugging level (1=info (or-able)).");
110 static int dvb_usb_lme2510_firmware
;
111 module_param_named(firmware
, dvb_usb_lme2510_firmware
, int, 0644);
112 MODULE_PARM_DESC(firmware
, "set default firmware 0=Sharp7395 1=LG");
114 static int pid_filter
;
115 module_param_named(pid
, pid_filter
, int, 0644);
116 MODULE_PARM_DESC(pid
, "set default 0=default 1=off 2=on");
119 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr
);
121 #define TUNER_DEFAULT 0x0
123 #define TUNER_S7395 0x2
124 #define TUNER_S0194 0x3
125 #define TUNER_RS2000 0x4
127 struct lme2510_state
{
128 unsigned long int_urb_due
;
129 enum fe_status lock_status
;
146 /* Frontend original calls */
147 int (*fe_read_status
)(struct dvb_frontend
*, enum fe_status
*);
148 int (*fe_read_signal_strength
)(struct dvb_frontend
*, u16
*);
149 int (*fe_read_snr
)(struct dvb_frontend
*, u16
*);
150 int (*fe_read_ber
)(struct dvb_frontend
*, u32
*);
151 int (*fe_read_ucblocks
)(struct dvb_frontend
*, u32
*);
152 int (*fe_set_voltage
)(struct dvb_frontend
*, enum fe_sec_voltage
);
153 u8 dvb_usb_lme2510_firmware
;
156 static int lme2510_bulk_write(struct usb_device
*dev
,
157 u8
*snd
, int len
, u8 pipe
)
161 ret
= usb_bulk_msg(dev
, usb_sndbulkpipe(dev
, pipe
),
162 snd
, len
, &actual_l
, 100);
166 static int lme2510_bulk_read(struct usb_device
*dev
,
167 u8
*rev
, int len
, u8 pipe
)
171 ret
= usb_bulk_msg(dev
, usb_rcvbulkpipe(dev
, pipe
),
172 rev
, len
, &actual_l
, 200);
176 static int lme2510_usb_talk(struct dvb_usb_device
*d
,
177 u8
*wbuf
, int wlen
, u8
*rbuf
, int rlen
)
179 struct lme2510_state
*st
= d
->priv
;
183 if (st
->usb_buffer
== NULL
) {
184 st
->usb_buffer
= kmalloc(64, GFP_KERNEL
);
185 if (st
->usb_buffer
== NULL
) {
186 info("MEM Error no memory");
190 buff
= st
->usb_buffer
;
192 ret
= mutex_lock_interruptible(&d
->usb_mutex
);
197 /* the read/write capped at 64 */
198 memcpy(buff
, wbuf
, (wlen
< 64) ? wlen
: 64);
200 ret
|= lme2510_bulk_write(d
->udev
, buff
, wlen
, 0x01);
202 ret
|= lme2510_bulk_read(d
->udev
, buff
, (rlen
< 64) ?
206 memcpy(rbuf
, buff
, rlen
);
208 mutex_unlock(&d
->usb_mutex
);
210 return (ret
< 0) ? -ENODEV
: 0;
213 static int lme2510_stream_restart(struct dvb_usb_device
*d
)
215 struct lme2510_state
*st
= d
->priv
;
216 u8 all_pids
[] = LME_ALL_PIDS
;
217 u8 stream_on
[] = LME_ST_ON_W
;
221 ret
= lme2510_usb_talk(d
, all_pids
, sizeof(all_pids
),
222 rbuff
, sizeof(rbuff
));
223 /*Restart Stream Command*/
224 ret
= lme2510_usb_talk(d
, stream_on
, sizeof(stream_on
),
225 rbuff
, sizeof(rbuff
));
229 static int lme2510_enable_pid(struct dvb_usb_device
*d
, u8 index
, u16 pid_out
)
231 struct lme2510_state
*st
= d
->priv
;
232 static u8 pid_buff
[] = LME_ZERO_PID
;
234 u8 pid_no
= index
* 2;
235 u8 pid_len
= pid_no
+ 2;
237 deb_info(1, "PID Setting Pid %04x", pid_out
);
239 if (st
->pid_size
== 0)
240 ret
|= lme2510_stream_restart(d
);
242 pid_buff
[2] = pid_no
;
243 pid_buff
[3] = (u8
)pid_out
& 0xff;
244 pid_buff
[4] = pid_no
+ 1;
245 pid_buff
[5] = (u8
)(pid_out
>> 8);
247 if (pid_len
> st
->pid_size
)
248 st
->pid_size
= pid_len
;
249 pid_buff
[7] = 0x80 + st
->pid_size
;
251 ret
|= lme2510_usb_talk(d
, pid_buff
,
252 sizeof(pid_buff
) , rbuf
, sizeof(rbuf
));
255 ret
|= lme2510_stream_restart(d
);
260 static void lme2510_update_stats(struct dvb_usb_adapter
*adap
)
262 struct lme2510_state
*st
= adap_to_priv(adap
);
263 struct dvb_frontend
*fe
= adap
->fe
[0];
264 struct dtv_frontend_properties
*c
;
265 u32 s_tmp
= 0, c_tmp
= 0;
270 c
= &fe
->dtv_property_cache
;
272 c
->block_count
.len
= 1;
273 c
->block_count
.stat
[0].scale
= FE_SCALE_NOT_AVAILABLE
;
274 c
->block_error
.len
= 1;
275 c
->block_error
.stat
[0].scale
= FE_SCALE_NOT_AVAILABLE
;
276 c
->post_bit_count
.len
= 1;
277 c
->post_bit_count
.stat
[0].scale
= FE_SCALE_NOT_AVAILABLE
;
278 c
->post_bit_error
.len
= 1;
279 c
->post_bit_error
.stat
[0].scale
= FE_SCALE_NOT_AVAILABLE
;
281 if (st
->i2c_talk_onoff
) {
283 c
->strength
.stat
[0].scale
= FE_SCALE_NOT_AVAILABLE
;
285 c
->cnr
.stat
[0].scale
= FE_SCALE_NOT_AVAILABLE
;
289 switch (st
->tuner_config
) {
291 s_tmp
= 0xff - st
->signal_level
;
294 c_tmp
= 0xff - st
->signal_sn
;
300 s_tmp
= 0xffff - (((st
->signal_level
* 2) << 8) * 5 / 4);
302 c_tmp
= ((0xff - st
->signal_sn
- 0xa1) * 3) << 8;
305 s_tmp
= st
->signal_level
* 0xffff / 0xff;
307 c_tmp
= st
->signal_sn
* 0xffff / 0x7f;
311 c
->strength
.stat
[0].scale
= FE_SCALE_RELATIVE
;
312 c
->strength
.stat
[0].uvalue
= (u64
)s_tmp
;
315 c
->cnr
.stat
[0].scale
= FE_SCALE_RELATIVE
;
316 c
->cnr
.stat
[0].uvalue
= (u64
)c_tmp
;
319 static void lme2510_int_response(struct urb
*lme_urb
)
321 struct dvb_usb_adapter
*adap
= lme_urb
->context
;
322 struct lme2510_state
*st
= adap_to_priv(adap
);
323 static u8
*ibuf
, *rbuf
;
328 switch (lme_urb
->status
) {
337 info("Error %x", lme_urb
->status
);
341 rbuf
= (u8
*) lme_urb
->transfer_buffer
;
343 offset
= ((lme_urb
->actual_length
/8) > 4)
344 ? 4 : (lme_urb
->actual_length
/8) ;
346 for (i
= 0; i
< offset
; ++i
) {
347 ibuf
= (u8
*)&rbuf
[i
*8];
348 deb_info(5, "INT O/S C =%02x C/O=%02x Type =%02x%02x",
349 offset
, i
, ibuf
[0], ibuf
[1]);
353 debug_data_snipet(1, "INT Remote data snipet", ibuf
);
354 if ((ibuf
[4] + ibuf
[5]) == 0xff) {
355 key
= RC_SCANCODE_NECX((ibuf
[2] ^ 0xff) << 8 |
356 (ibuf
[3] > 0) ? (ibuf
[3] ^ 0xff) : 0,
358 deb_info(1, "INT Key =%08x", key
);
359 if (adap_to_d(adap
)->rc_dev
!= NULL
)
360 rc_keydown(adap_to_d(adap
)->rc_dev
,
361 RC_TYPE_NEC
, key
, 0);
365 switch (st
->tuner_config
) {
367 signal_lock
= ibuf
[2] & BIT(5);
368 st
->signal_level
= ibuf
[4];
369 st
->signal_sn
= ibuf
[3];
370 st
->time_key
= ibuf
[7];
374 /* Tweak for earlier firmware*/
375 if (ibuf
[1] == 0x03) {
376 signal_lock
= ibuf
[2] & BIT(4);
377 st
->signal_level
= ibuf
[3];
378 st
->signal_sn
= ibuf
[4];
380 st
->signal_level
= ibuf
[4];
381 st
->signal_sn
= ibuf
[5];
385 signal_lock
= ibuf
[2] & 0xee;
386 st
->signal_level
= ibuf
[5];
387 st
->signal_sn
= ibuf
[4];
388 st
->time_key
= ibuf
[7];
393 /* Interrupt will also throw just BIT 0 as lock */
394 signal_lock
|= ibuf
[2] & BIT(0);
397 st
->lock_status
&= ~FE_HAS_LOCK
;
399 lme2510_update_stats(adap
);
401 debug_data_snipet(5, "INT Remote data snipet in", ibuf
);
404 debug_data_snipet(1, "INT Control data snipet", ibuf
);
407 debug_data_snipet(1, "INT Unknown data snipet", ibuf
);
412 usb_submit_urb(lme_urb
, GFP_ATOMIC
);
414 /* Interrupt urb is due every 48 msecs while streaming the buffer
415 * stores up to 4 periods if missed. Allow 200 msec for next interrupt.
417 st
->int_urb_due
= jiffies
+ msecs_to_jiffies(200);
420 static int lme2510_int_read(struct dvb_usb_adapter
*adap
)
422 struct dvb_usb_device
*d
= adap_to_d(adap
);
423 struct lme2510_state
*lme_int
= adap_to_priv(adap
);
424 struct usb_host_endpoint
*ep
;
426 lme_int
->lme_urb
= usb_alloc_urb(0, GFP_ATOMIC
);
428 if (lme_int
->lme_urb
== NULL
)
431 lme_int
->buffer
= usb_alloc_coherent(d
->udev
, 128, GFP_ATOMIC
,
432 &lme_int
->lme_urb
->transfer_dma
);
434 if (lme_int
->buffer
== NULL
)
437 usb_fill_int_urb(lme_int
->lme_urb
,
439 usb_rcvintpipe(d
->udev
, 0xa),
442 lme2510_int_response
,
446 /* Quirk of pipe reporting PIPE_BULK but behaves as interrupt */
447 ep
= usb_pipe_endpoint(d
->udev
, lme_int
->lme_urb
->pipe
);
449 if (usb_endpoint_type(&ep
->desc
) == USB_ENDPOINT_XFER_BULK
)
450 lme_int
->lme_urb
->pipe
= usb_rcvbulkpipe(d
->udev
, 0xa),
452 lme_int
->lme_urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
454 usb_submit_urb(lme_int
->lme_urb
, GFP_ATOMIC
);
455 info("INT Interrupt Service Started");
460 static int lme2510_pid_filter_ctrl(struct dvb_usb_adapter
*adap
, int onoff
)
462 struct dvb_usb_device
*d
= adap_to_d(adap
);
463 struct lme2510_state
*st
= adap_to_priv(adap
);
464 static u8 clear_pid_reg
[] = LME_ALL_PIDS
;
468 deb_info(1, "PID Clearing Filter");
470 mutex_lock(&d
->i2c_mutex
);
473 ret
|= lme2510_usb_talk(d
, clear_pid_reg
,
474 sizeof(clear_pid_reg
), rbuf
, sizeof(rbuf
));
481 mutex_unlock(&d
->i2c_mutex
);
486 static int lme2510_pid_filter(struct dvb_usb_adapter
*adap
, int index
, u16 pid
,
489 struct dvb_usb_device
*d
= adap_to_d(adap
);
492 deb_info(3, "%s PID=%04x Index=%04x onoff=%02x", __func__
,
496 mutex_lock(&d
->i2c_mutex
);
497 ret
|= lme2510_enable_pid(d
, index
, pid
);
498 mutex_unlock(&d
->i2c_mutex
);
506 static int lme2510_return_status(struct dvb_usb_device
*d
)
511 data
= kzalloc(10, GFP_KERNEL
);
515 ret
|= usb_control_msg(d
->udev
, usb_rcvctrlpipe(d
->udev
, 0),
516 0x06, 0x80, 0x0302, 0x00, data
, 0x0006, 200);
517 info("Firmware Status: %x (%x)", ret
, data
[2]);
519 ret
= (ret
< 0) ? -ENODEV
: data
[2];
524 static int lme2510_msg(struct dvb_usb_device
*d
,
525 u8
*wbuf
, int wlen
, u8
*rbuf
, int rlen
)
527 struct lme2510_state
*st
= d
->priv
;
529 st
->i2c_talk_onoff
= 1;
531 return lme2510_usb_talk(d
, wbuf
, wlen
, rbuf
, rlen
);
534 static int lme2510_i2c_xfer(struct i2c_adapter
*adap
, struct i2c_msg msg
[],
537 struct dvb_usb_device
*d
= i2c_get_adapdata(adap
);
538 struct lme2510_state
*st
= d
->priv
;
539 static u8 obuf
[64], ibuf
[64];
542 u8 gate
= st
->i2c_gate
;
544 mutex_lock(&d
->i2c_mutex
);
549 for (i
= 0; i
< num
; i
++) {
550 read_o
= msg
[i
].flags
& I2C_M_RD
;
551 read
= i
+ 1 < num
&& msg
[i
+ 1].flags
& I2C_M_RD
;
553 gate
= (msg
[i
].addr
== st
->i2c_tuner_addr
)
554 ? (read
) ? st
->i2c_tuner_gate_r
555 : st
->i2c_tuner_gate_w
557 obuf
[0] = gate
| (read
<< 7);
560 obuf
[1] = (read
) ? 2 : msg
[i
].len
+ 1;
562 obuf
[1] = msg
[i
].len
+ read
+ 1;
564 obuf
[2] = msg
[i
].addr
<< 1;
570 memcpy(&obuf
[3], msg
[i
].buf
, msg
[i
].len
);
571 obuf
[msg
[i
].len
+3] = msg
[i
+1].len
;
575 memcpy(&obuf
[3], msg
[i
].buf
, msg
[i
].len
);
579 if (lme2510_msg(d
, obuf
, len
, ibuf
, 64) < 0) {
580 deb_info(1, "i2c transfer failed.");
581 mutex_unlock(&d
->i2c_mutex
);
587 memcpy(msg
[i
].buf
, &ibuf
[1], msg
[i
].len
);
589 memcpy(msg
[i
+1].buf
, &ibuf
[1], msg
[i
+1].len
);
595 mutex_unlock(&d
->i2c_mutex
);
599 static u32
lme2510_i2c_func(struct i2c_adapter
*adapter
)
604 static struct i2c_algorithm lme2510_i2c_algo
= {
605 .master_xfer
= lme2510_i2c_xfer
,
606 .functionality
= lme2510_i2c_func
,
609 static int lme2510_streaming_ctrl(struct dvb_frontend
*fe
, int onoff
)
611 struct dvb_usb_adapter
*adap
= fe_to_adap(fe
);
612 struct dvb_usb_device
*d
= adap_to_d(adap
);
613 struct lme2510_state
*st
= adap_to_priv(adap
);
614 static u8 clear_reg_3
[] = LME_ALL_PIDS
;
616 int ret
= 0, rlen
= sizeof(rbuf
);
618 deb_info(1, "STM (%02x)", onoff
);
620 /* Streaming is started by FE_HAS_LOCK */
624 deb_info(1, "STM Steam Off");
625 /* mutex is here only to avoid collision with I2C */
626 mutex_lock(&d
->i2c_mutex
);
628 ret
= lme2510_usb_talk(d
, clear_reg_3
,
629 sizeof(clear_reg_3
), rbuf
, rlen
);
631 st
->i2c_talk_onoff
= 1;
633 mutex_unlock(&d
->i2c_mutex
);
636 return (ret
< 0) ? -ENODEV
: 0;
639 static u8
check_sum(u8
*p
, u8 len
)
647 static int lme2510_download_firmware(struct dvb_usb_device
*d
,
648 const struct firmware
*fw
)
652 u16 j
, wlen
, len_in
, start
, end
;
653 u8 packet_size
, dlen
, i
;
659 data
= kzalloc(128, GFP_KERNEL
);
661 info("FRM Could not start Firmware Download"\
662 "(Buffer allocation failed)");
666 info("FRM Starting Firmware Download");
668 for (i
= 1; i
< 3; i
++) {
669 start
= (i
== 1) ? 0 : 512;
670 end
= (i
== 1) ? 512 : fw
->size
;
671 for (j
= start
; j
< end
; j
+= (packet_size
+1)) {
672 fw_data
= (u8
*)(fw
->data
+ j
);
673 if ((end
- j
) > packet_size
) {
678 dlen
= (u8
)(end
- j
)-1;
681 memcpy(&data
[2], fw_data
, dlen
+1);
682 wlen
= (u8
) dlen
+ 4;
683 data
[wlen
-1] = check_sum(fw_data
, dlen
+1);
684 deb_info(1, "Data S=%02x:E=%02x CS= %02x", data
[3],
685 data
[dlen
+2], data
[dlen
+3]);
686 lme2510_usb_talk(d
, data
, wlen
, data
, len_in
);
687 ret
|= (data
[0] == 0x88) ? 0 : -1;
694 lme2510_usb_talk(d
, data
, len_in
, data
, len_in
);
698 info("FRM Firmware Download Failed (%04x)" , ret
);
700 info("FRM Firmware Download Completed - Resetting Device");
703 return RECONNECTS_USB
;
706 static void lme_coldreset(struct dvb_usb_device
*d
)
710 info("FRM Firmware Cold Reset");
712 lme2510_usb_talk(d
, data
, sizeof(data
), data
, sizeof(data
));
717 static const char fw_c_s7395
[] = LME2510_C_S7395
;
718 static const char fw_c_lg
[] = LME2510_C_LG
;
719 static const char fw_c_s0194
[] = LME2510_C_S0194
;
720 static const char fw_c_rs2000
[] = LME2510_C_RS2000
;
721 static const char fw_lg
[] = LME2510_LG
;
722 static const char fw_s0194
[] = LME2510_S0194
;
724 static const char *lme_firmware_switch(struct dvb_usb_device
*d
, int cold
)
726 struct lme2510_state
*st
= d
->priv
;
727 struct usb_device
*udev
= d
->udev
;
728 const struct firmware
*fw
= NULL
;
732 cold
= (cold
> 0) ? (cold
& 1) : 0;
734 switch (le16_to_cpu(udev
->descriptor
.idProduct
)) {
736 switch (st
->dvb_usb_lme2510_firmware
) {
740 ret
= request_firmware(&fw
, fw_lme
, &udev
->dev
);
742 st
->dvb_usb_lme2510_firmware
= TUNER_S0194
;
749 ret
= request_firmware(&fw
, fw_lme
, &udev
->dev
);
751 st
->dvb_usb_lme2510_firmware
= TUNER_LG
;
754 st
->dvb_usb_lme2510_firmware
= TUNER_DEFAULT
;
759 switch (st
->dvb_usb_lme2510_firmware
) {
763 ret
= request_firmware(&fw
, fw_lme
, &udev
->dev
);
765 st
->dvb_usb_lme2510_firmware
= TUNER_S7395
;
772 ret
= request_firmware(&fw
, fw_lme
, &udev
->dev
);
774 st
->dvb_usb_lme2510_firmware
= TUNER_LG
;
780 ret
= request_firmware(&fw
, fw_lme
, &udev
->dev
);
782 st
->dvb_usb_lme2510_firmware
= TUNER_S0194
;
785 st
->dvb_usb_lme2510_firmware
= TUNER_DEFAULT
;
791 fw_lme
= fw_c_rs2000
;
792 st
->dvb_usb_lme2510_firmware
= TUNER_RS2000
;
798 release_firmware(fw
);
801 dvb_usb_lme2510_firmware
= st
->dvb_usb_lme2510_firmware
;
802 info("FRM Changing to %s firmware", fw_lme
);
810 static int lme2510_kill_urb(struct usb_data_stream
*stream
)
814 for (i
= 0; i
< stream
->urbs_submitted
; i
++) {
815 deb_info(3, "killing URB no. %d.", i
);
817 usb_kill_urb(stream
->urb_list
[i
]);
819 stream
->urbs_submitted
= 0;
824 static struct tda10086_config tda10086_config
= {
825 .demod_address
= 0x0e,
828 .xtal_freq
= TDA10086_XTAL_16M
,
831 static struct stv0288_config lme_config
= {
832 .demod_address
= 0x68,
834 .inittab
= s7395_inittab
,
837 static struct ix2505v_config lme_tuner
= {
838 .tuner_address
= 0x60,
841 .tuner_chargepump
= 0x3,
844 static struct stv0299_config sharp_z0194_config
= {
845 .demod_address
= 0x68,
846 .inittab
= sharp_z0194a_inittab
,
850 .lock_output
= STV0299_LOCKOUTPUT_1
,
851 .volt13_op0_op1
= STV0299_VOLT13_OP1
,
853 .set_symbol_rate
= sharp_z0194a_set_symbol_rate
,
856 static struct m88rs2000_config m88rs2000_config
= {
860 static struct ts2020_config ts2020_config
= {
861 .tuner_address
= 0x60,
866 static int dm04_lme2510_set_voltage(struct dvb_frontend
*fe
,
867 enum fe_sec_voltage voltage
)
869 struct dvb_usb_device
*d
= fe_to_d(fe
);
870 struct lme2510_state
*st
= fe_to_priv(fe
);
871 static u8 voltage_low
[] = LME_VOLTAGE_L
;
872 static u8 voltage_high
[] = LME_VOLTAGE_H
;
874 int ret
= 0, len
= 3, rlen
= 1;
876 mutex_lock(&d
->i2c_mutex
);
880 ret
|= lme2510_usb_talk(d
,
881 voltage_high
, len
, rbuf
, rlen
);
884 case SEC_VOLTAGE_OFF
:
887 ret
|= lme2510_usb_talk(d
,
888 voltage_low
, len
, rbuf
, rlen
);
892 mutex_unlock(&d
->i2c_mutex
);
894 if (st
->tuner_config
== TUNER_RS2000
)
895 if (st
->fe_set_voltage
)
896 st
->fe_set_voltage(fe
, voltage
);
899 return (ret
< 0) ? -ENODEV
: 0;
902 static int dm04_read_status(struct dvb_frontend
*fe
, enum fe_status
*status
)
904 struct dvb_usb_device
*d
= fe_to_d(fe
);
905 struct lme2510_state
*st
= d
->priv
;
908 if (st
->i2c_talk_onoff
) {
909 if (st
->fe_read_status
) {
910 ret
= st
->fe_read_status(fe
, status
);
915 st
->lock_status
= *status
;
917 if (*status
& FE_HAS_LOCK
&& st
->stream_on
) {
918 mutex_lock(&d
->i2c_mutex
);
920 st
->i2c_talk_onoff
= 0;
921 ret
= lme2510_stream_restart(d
);
923 mutex_unlock(&d
->i2c_mutex
);
929 /* Timeout of interrupt reached on RS2000 */
930 if (st
->tuner_config
== TUNER_RS2000
&&
931 time_after(jiffies
, st
->int_urb_due
))
932 st
->lock_status
&= ~FE_HAS_LOCK
;
934 *status
= st
->lock_status
;
936 if (!(*status
& FE_HAS_LOCK
)) {
937 struct dvb_usb_adapter
*adap
= fe_to_adap(fe
);
939 st
->i2c_talk_onoff
= 1;
941 lme2510_update_stats(adap
);
947 static int dm04_read_signal_strength(struct dvb_frontend
*fe
, u16
*strength
)
949 struct dtv_frontend_properties
*c
= &fe
->dtv_property_cache
;
950 struct lme2510_state
*st
= fe_to_priv(fe
);
952 if (st
->fe_read_signal_strength
&& !st
->stream_on
)
953 return st
->fe_read_signal_strength(fe
, strength
);
955 if (c
->strength
.stat
[0].scale
== FE_SCALE_RELATIVE
)
956 *strength
= (u16
)c
->strength
.stat
[0].uvalue
;
963 static int dm04_read_snr(struct dvb_frontend
*fe
, u16
*snr
)
965 struct dtv_frontend_properties
*c
= &fe
->dtv_property_cache
;
966 struct lme2510_state
*st
= fe_to_priv(fe
);
968 if (st
->fe_read_snr
&& !st
->stream_on
)
969 return st
->fe_read_snr(fe
, snr
);
971 if (c
->cnr
.stat
[0].scale
== FE_SCALE_RELATIVE
)
972 *snr
= (u16
)c
->cnr
.stat
[0].uvalue
;
979 static int dm04_read_ber(struct dvb_frontend
*fe
, u32
*ber
)
981 struct lme2510_state
*st
= fe_to_priv(fe
);
983 if (st
->fe_read_ber
&& !st
->stream_on
)
984 return st
->fe_read_ber(fe
, ber
);
991 static int dm04_read_ucblocks(struct dvb_frontend
*fe
, u32
*ucblocks
)
993 struct lme2510_state
*st
= fe_to_priv(fe
);
995 if (st
->fe_read_ucblocks
&& !st
->stream_on
)
996 return st
->fe_read_ucblocks(fe
, ucblocks
);
1003 static int lme_name(struct dvb_usb_adapter
*adap
)
1005 struct dvb_usb_device
*d
= adap_to_d(adap
);
1006 struct lme2510_state
*st
= adap_to_priv(adap
);
1007 const char *desc
= d
->name
;
1008 char *fe_name
[] = {"", " LG TDQY-P001F", " SHARP:BS2F7HZ7395",
1009 " SHARP:BS2F7HZ0194", " RS2000"};
1010 char *name
= adap
->fe
[0]->ops
.info
.name
;
1012 strlcpy(name
, desc
, 128);
1013 strlcat(name
, fe_name
[st
->tuner_config
], 128);
1018 static int dm04_lme2510_frontend_attach(struct dvb_usb_adapter
*adap
)
1020 struct dvb_usb_device
*d
= adap_to_d(adap
);
1021 struct lme2510_state
*st
= d
->priv
;
1024 st
->i2c_talk_onoff
= 1;
1025 switch (le16_to_cpu(d
->udev
->descriptor
.idProduct
)) {
1029 adap
->fe
[0] = dvb_attach(tda10086_attach
,
1030 &tda10086_config
, &d
->i2c_adap
);
1032 info("TUN Found Frontend TDA10086");
1033 st
->i2c_tuner_gate_w
= 4;
1034 st
->i2c_tuner_gate_r
= 4;
1035 st
->i2c_tuner_addr
= 0x60;
1036 st
->tuner_config
= TUNER_LG
;
1037 if (st
->dvb_usb_lme2510_firmware
!= TUNER_LG
) {
1038 st
->dvb_usb_lme2510_firmware
= TUNER_LG
;
1039 ret
= lme_firmware_switch(d
, 1) ? 0 : -ENODEV
;
1045 adap
->fe
[0] = dvb_attach(stv0299_attach
,
1046 &sharp_z0194_config
, &d
->i2c_adap
);
1048 info("FE Found Stv0299");
1049 st
->i2c_tuner_gate_w
= 4;
1050 st
->i2c_tuner_gate_r
= 5;
1051 st
->i2c_tuner_addr
= 0x60;
1052 st
->tuner_config
= TUNER_S0194
;
1053 if (st
->dvb_usb_lme2510_firmware
!= TUNER_S0194
) {
1054 st
->dvb_usb_lme2510_firmware
= TUNER_S0194
;
1055 ret
= lme_firmware_switch(d
, 1) ? 0 : -ENODEV
;
1061 adap
->fe
[0] = dvb_attach(stv0288_attach
, &lme_config
,
1065 info("FE Found Stv0288");
1066 st
->i2c_tuner_gate_w
= 4;
1067 st
->i2c_tuner_gate_r
= 5;
1068 st
->i2c_tuner_addr
= 0x60;
1069 st
->tuner_config
= TUNER_S7395
;
1070 if (st
->dvb_usb_lme2510_firmware
!= TUNER_S7395
) {
1071 st
->dvb_usb_lme2510_firmware
= TUNER_S7395
;
1072 ret
= lme_firmware_switch(d
, 1) ? 0 : -ENODEV
;
1078 adap
->fe
[0] = dvb_attach(m88rs2000_attach
,
1079 &m88rs2000_config
, &d
->i2c_adap
);
1082 info("FE Found M88RS2000");
1083 dvb_attach(ts2020_attach
, adap
->fe
[0], &ts2020_config
,
1085 st
->i2c_tuner_gate_w
= 5;
1086 st
->i2c_tuner_gate_r
= 5;
1087 st
->i2c_tuner_addr
= 0x60;
1088 st
->tuner_config
= TUNER_RS2000
;
1089 st
->fe_set_voltage
=
1090 adap
->fe
[0]->ops
.set_voltage
;
1095 if (adap
->fe
[0] == NULL
) {
1096 info("DM04/QQBOX Not Powered up or not Supported");
1102 dvb_frontend_detach(adap
->fe
[0]);
1109 st
->fe_read_status
= adap
->fe
[0]->ops
.read_status
;
1110 st
->fe_read_signal_strength
= adap
->fe
[0]->ops
.read_signal_strength
;
1111 st
->fe_read_snr
= adap
->fe
[0]->ops
.read_snr
;
1112 st
->fe_read_ber
= adap
->fe
[0]->ops
.read_ber
;
1113 st
->fe_read_ucblocks
= adap
->fe
[0]->ops
.read_ucblocks
;
1115 adap
->fe
[0]->ops
.read_status
= dm04_read_status
;
1116 adap
->fe
[0]->ops
.read_signal_strength
= dm04_read_signal_strength
;
1117 adap
->fe
[0]->ops
.read_snr
= dm04_read_snr
;
1118 adap
->fe
[0]->ops
.read_ber
= dm04_read_ber
;
1119 adap
->fe
[0]->ops
.read_ucblocks
= dm04_read_ucblocks
;
1120 adap
->fe
[0]->ops
.set_voltage
= dm04_lme2510_set_voltage
;
1122 ret
= lme_name(adap
);
1126 static int dm04_lme2510_tuner(struct dvb_usb_adapter
*adap
)
1128 struct dvb_usb_device
*d
= adap_to_d(adap
);
1129 struct lme2510_state
*st
= adap_to_priv(adap
);
1130 char *tun_msg
[] = {"", "TDA8263", "IX2505V", "DVB_PLL_OPERA", "RS2000"};
1133 switch (st
->tuner_config
) {
1135 if (dvb_attach(tda826x_attach
, adap
->fe
[0], 0x60,
1137 ret
= st
->tuner_config
;
1140 if (dvb_attach(ix2505v_attach
, adap
->fe
[0], &lme_tuner
,
1142 ret
= st
->tuner_config
;
1145 if (dvb_attach(dvb_pll_attach
, adap
->fe
[0], 0x60,
1146 &d
->i2c_adap
, DVB_PLL_OPERA1
))
1147 ret
= st
->tuner_config
;
1150 ret
= st
->tuner_config
;
1157 info("TUN Found %s tuner", tun_msg
[ret
]);
1159 info("TUN No tuner found --- resetting device");
1164 /* Start the Interrupt*/
1165 ret
= lme2510_int_read(adap
);
1167 info("INT Unable to start Interrupt Service");
1174 static int lme2510_powerup(struct dvb_usb_device
*d
, int onoff
)
1176 struct lme2510_state
*st
= d
->priv
;
1177 static u8 lnb_on
[] = LNB_ON
;
1178 static u8 lnb_off
[] = LNB_OFF
;
1180 int ret
= 0, len
= 3, rlen
= 1;
1182 mutex_lock(&d
->i2c_mutex
);
1185 ret
= lme2510_usb_talk(d
, lnb_on
, len
, rbuf
, rlen
);
1187 ret
= lme2510_usb_talk(d
, lnb_off
, len
, rbuf
, rlen
);
1189 st
->i2c_talk_onoff
= 1;
1191 mutex_unlock(&d
->i2c_mutex
);
1196 static int lme2510_get_adapter_count(struct dvb_usb_device
*d
)
1201 static int lme2510_identify_state(struct dvb_usb_device
*d
, const char **name
)
1203 struct lme2510_state
*st
= d
->priv
;
1205 usb_reset_configuration(d
->udev
);
1207 usb_set_interface(d
->udev
,
1208 d
->props
->bInterfaceNumber
, 1);
1210 st
->dvb_usb_lme2510_firmware
= dvb_usb_lme2510_firmware
;
1212 if (lme2510_return_status(d
) == 0x44) {
1213 *name
= lme_firmware_switch(d
, 0);
1220 static int lme2510_get_stream_config(struct dvb_frontend
*fe
, u8
*ts_type
,
1221 struct usb_data_stream_properties
*stream
)
1223 struct dvb_usb_adapter
*adap
= fe_to_adap(fe
);
1224 struct dvb_usb_device
*d
;
1229 d
= adap_to_d(adap
);
1231 /* Turn PID filter on the fly by module option */
1232 if (pid_filter
== 2) {
1233 adap
->pid_filtering
= true;
1234 adap
->max_feed_count
= 15;
1237 if (!(le16_to_cpu(d
->udev
->descriptor
.idProduct
)
1239 stream
->endpoint
= 0x8;
1244 static int lme2510_get_rc_config(struct dvb_usb_device
*d
,
1245 struct dvb_usb_rc
*rc
)
1247 rc
->allowed_protos
= RC_BIT_NEC
;
1251 static void *lme2510_exit_int(struct dvb_usb_device
*d
)
1253 struct lme2510_state
*st
= d
->priv
;
1254 struct dvb_usb_adapter
*adap
= &d
->adapter
[0];
1255 void *buffer
= NULL
;
1258 lme2510_kill_urb(&adap
->stream
);
1261 if (st
->usb_buffer
!= NULL
) {
1262 st
->i2c_talk_onoff
= 1;
1263 st
->signal_level
= 0;
1265 buffer
= st
->usb_buffer
;
1268 if (st
->lme_urb
!= NULL
) {
1269 usb_kill_urb(st
->lme_urb
);
1270 usb_free_coherent(d
->udev
, 128, st
->buffer
,
1271 st
->lme_urb
->transfer_dma
);
1272 info("Interrupt Service Stopped");
1278 static void lme2510_exit(struct dvb_usb_device
*d
)
1283 usb_buffer
= lme2510_exit_int(d
);
1288 static struct dvb_usb_device_properties lme2510_props
= {
1289 .driver_name
= KBUILD_MODNAME
,
1290 .owner
= THIS_MODULE
,
1291 .bInterfaceNumber
= 0,
1292 .adapter_nr
= adapter_nr
,
1293 .size_of_priv
= sizeof(struct lme2510_state
),
1295 .download_firmware
= lme2510_download_firmware
,
1297 .power_ctrl
= lme2510_powerup
,
1298 .identify_state
= lme2510_identify_state
,
1299 .i2c_algo
= &lme2510_i2c_algo
,
1301 .frontend_attach
= dm04_lme2510_frontend_attach
,
1302 .tuner_attach
= dm04_lme2510_tuner
,
1303 .get_stream_config
= lme2510_get_stream_config
,
1304 .get_adapter_count
= lme2510_get_adapter_count
,
1305 .streaming_ctrl
= lme2510_streaming_ctrl
,
1307 .get_rc_config
= lme2510_get_rc_config
,
1309 .exit
= lme2510_exit
,
1312 .caps
= DVB_USB_ADAP_HAS_PID_FILTER
|
1313 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF
,
1314 .pid_filter_count
= 15,
1315 .pid_filter
= lme2510_pid_filter
,
1316 .pid_filter_ctrl
= lme2510_pid_filter_ctrl
,
1318 DVB_USB_STREAM_BULK(0x86, 10, 4096),
1325 static const struct usb_device_id lme2510_id_table
[] = {
1326 { DVB_USB_DEVICE(0x3344, 0x1122, &lme2510_props
,
1327 "DM04_LME2510_DVB-S", RC_MAP_LME2510
) },
1328 { DVB_USB_DEVICE(0x3344, 0x1120, &lme2510_props
,
1329 "DM04_LME2510C_DVB-S", RC_MAP_LME2510
) },
1330 { DVB_USB_DEVICE(0x3344, 0x22f0, &lme2510_props
,
1331 "DM04_LME2510C_DVB-S RS2000", RC_MAP_LME2510
) },
1332 {} /* Terminating entry */
1335 MODULE_DEVICE_TABLE(usb
, lme2510_id_table
);
1337 static struct usb_driver lme2510_driver
= {
1338 .name
= KBUILD_MODNAME
,
1339 .probe
= dvb_usbv2_probe
,
1340 .disconnect
= dvb_usbv2_disconnect
,
1341 .id_table
= lme2510_id_table
,
1346 module_usb_driver(lme2510_driver
);
1348 MODULE_AUTHOR("Malcolm Priestley <tvboxspy@gmail.com>");
1349 MODULE_DESCRIPTION("LME2510(C) DVB-S USB2.0");
1350 MODULE_VERSION("2.06");
1351 MODULE_LICENSE("GPL");
1352 MODULE_FIRMWARE(LME2510_C_S7395
);
1353 MODULE_FIRMWARE(LME2510_C_LG
);
1354 MODULE_FIRMWARE(LME2510_C_S0194
);
1355 MODULE_FIRMWARE(LME2510_C_RS2000
);
1356 MODULE_FIRMWARE(LME2510_LG
);
1357 MODULE_FIRMWARE(LME2510_S0194
);