1 /* DVB USB compliant linux driver for
2 *
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
8 *
9 * MVB7395 (LME2510C+SHARP:BS2F7HZ7395)
10 * SHARP:BS2F7HZ7395 = (STV0288+Sharp IX2505V)
11 *
12 * MV001F (LME2510+LGTDQY-P001F)
13 * LG TDQY - P001F =(TDA8263 + TDA10086H)
14 *
15 * MVB0001F (LME2510C+LGTDQT-P001F)
16 *
17 * MV0194 (LME2510+SHARP:BS2F7HZ0194)
18 * SHARP:BS2F7HZ0194 = (STV0299+IX2410)
19 *
20 * MVB0194 (LME2510C+SHARP0194)
21 *
22 * LME2510C + M88RS2000
23 *
24 * For firmware see Documentation/dvb/lmedm04.txt
25 *
26 * I2C addresses:
27 * 0xd0 - STV0288 - Demodulator
28 * 0xc0 - Sharp IX2505V - Tuner
29 * --
30 * 0x1c - TDA10086 - Demodulator
31 * 0xc0 - TDA8263 - Tuner
32 * --
33 * 0xd0 - STV0299 - Demodulator
34 * 0xc0 - IX2410 - Tuner
35 *
36 *
37 * VID = 3344 PID LME2510=1122 LME2510C=1120
38 *
39 * Copyright (C) 2010 Malcolm Priestley (tvboxspy@gmail.com)
40 * LME2510(C)(C) Leaguerme (Shenzhen) MicroElectronics Co., Ltd.
41 *
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.
45 *
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.
50 *
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.
54 *
55 *
56 * see Documentation/dvb/README.dvb-usb for more information
57 *
58 * Known Issues :
59 * LME2510: Non Intel USB chipsets fail to maintain High Speed on
60 * Boot or Hot Plug.
61 *
62 * QQbox suffers from noise on LNB voltage.
63 *
64 * LME2510: SHARP:BS2F7HZ0194(MV0194) cannot cold reset and share system
65 * with other tuners. After a cold reset streaming will not start.
66 *
67 * M88RS2000 suffers from loss of lock.
68 */
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>
73
74 #include "dvb_usb.h"
75 #include "lmedm04.h"
76 #include "tda826x.h"
77 #include "tda10086.h"
78 #include "stv0288.h"
79 #include "ix2505v.h"
80 #include "stv0299.h"
81 #include "dvb-pll.h"
82 #include "z0194a.h"
83 #include "m88rs2000.h"
84 #include "ts2020.h"
85
86
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";
93
94 /* debug */
95 static int dvb_usb_lme2510_debug;
96 #define lme_debug(var, level, args...) do { \
97 if ((var >= level)) \
98 pr_debug(DVB_USB_LOG_PREFIX": " args); \
99 } while (0)
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)
106
107 module_param_named(debug, dvb_usb_lme2510_debug, int, 0644);
108 MODULE_PARM_DESC(debug, "set debugging level (1=info (or-able)).");
109
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");
113
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");
117
118
119 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
120
121 #define TUNER_DEFAULT 0x0
122 #define TUNER_LG 0x1
123 #define TUNER_S7395 0x2
124 #define TUNER_S0194 0x3
125 #define TUNER_RS2000 0x4
126
127 struct lme2510_state {
128 unsigned long int_urb_due;
129 u8 id;
130 u8 tuner_config;
131 u8 signal_lock;
132 u8 signal_level;
133 u8 signal_sn;
134 u8 time_key;
135 u8 i2c_talk_onoff;
136 u8 i2c_gate;
137 u8 i2c_tuner_gate_w;
138 u8 i2c_tuner_gate_r;
139 u8 i2c_tuner_addr;
140 u8 stream_on;
141 u8 pid_size;
142 u8 pid_off;
143 void *buffer;
144 struct urb *lme_urb;
145 void *usb_buffer;
146 int (*fe_set_voltage)(struct dvb_frontend *, fe_sec_voltage_t);
147 u8 dvb_usb_lme2510_firmware;
148 };
149
lme2510_bulk_write(struct usb_device * dev,u8 * snd,int len,u8 pipe)150 static int lme2510_bulk_write(struct usb_device *dev,
151 u8 *snd, int len, u8 pipe)
152 {
153 int ret, actual_l;
154
155 ret = usb_bulk_msg(dev, usb_sndbulkpipe(dev, pipe),
156 snd, len , &actual_l, 100);
157 return ret;
158 }
159
lme2510_bulk_read(struct usb_device * dev,u8 * rev,int len,u8 pipe)160 static int lme2510_bulk_read(struct usb_device *dev,
161 u8 *rev, int len, u8 pipe)
162 {
163 int ret, actual_l;
164
165 ret = usb_bulk_msg(dev, usb_rcvbulkpipe(dev, pipe),
166 rev, len , &actual_l, 200);
167 return ret;
168 }
169
lme2510_usb_talk(struct dvb_usb_device * d,u8 * wbuf,int wlen,u8 * rbuf,int rlen)170 static int lme2510_usb_talk(struct dvb_usb_device *d,
171 u8 *wbuf, int wlen, u8 *rbuf, int rlen)
172 {
173 struct lme2510_state *st = d->priv;
174 u8 *buff;
175 int ret = 0;
176
177 if (st->usb_buffer == NULL) {
178 st->usb_buffer = kmalloc(64, GFP_KERNEL);
179 if (st->usb_buffer == NULL) {
180 info("MEM Error no memory");
181 return -ENOMEM;
182 }
183 }
184 buff = st->usb_buffer;
185
186 ret = mutex_lock_interruptible(&d->usb_mutex);
187
188 if (ret < 0)
189 return -EAGAIN;
190
191 /* the read/write capped at 64 */
192 memcpy(buff, wbuf, (wlen < 64) ? wlen : 64);
193
194 ret |= lme2510_bulk_write(d->udev, buff, wlen , 0x01);
195
196 ret |= lme2510_bulk_read(d->udev, buff, (rlen < 64) ?
197 rlen : 64 , 0x01);
198
199 if (rlen > 0)
200 memcpy(rbuf, buff, rlen);
201
202 mutex_unlock(&d->usb_mutex);
203
204 return (ret < 0) ? -ENODEV : 0;
205 }
206
lme2510_stream_restart(struct dvb_usb_device * d)207 static int lme2510_stream_restart(struct dvb_usb_device *d)
208 {
209 struct lme2510_state *st = d->priv;
210 u8 all_pids[] = LME_ALL_PIDS;
211 u8 stream_on[] = LME_ST_ON_W;
212 int ret;
213 u8 rbuff[1];
214 if (st->pid_off)
215 ret = lme2510_usb_talk(d, all_pids, sizeof(all_pids),
216 rbuff, sizeof(rbuff));
217 /*Restart Stream Command*/
218 ret = lme2510_usb_talk(d, stream_on, sizeof(stream_on),
219 rbuff, sizeof(rbuff));
220 return ret;
221 }
222
lme2510_enable_pid(struct dvb_usb_device * d,u8 index,u16 pid_out)223 static int lme2510_enable_pid(struct dvb_usb_device *d, u8 index, u16 pid_out)
224 {
225 struct lme2510_state *st = d->priv;
226 static u8 pid_buff[] = LME_ZERO_PID;
227 static u8 rbuf[1];
228 u8 pid_no = index * 2;
229 u8 pid_len = pid_no + 2;
230 int ret = 0;
231 deb_info(1, "PID Setting Pid %04x", pid_out);
232
233 if (st->pid_size == 0)
234 ret |= lme2510_stream_restart(d);
235
236 pid_buff[2] = pid_no;
237 pid_buff[3] = (u8)pid_out & 0xff;
238 pid_buff[4] = pid_no + 1;
239 pid_buff[5] = (u8)(pid_out >> 8);
240
241 if (pid_len > st->pid_size)
242 st->pid_size = pid_len;
243 pid_buff[7] = 0x80 + st->pid_size;
244
245 ret |= lme2510_usb_talk(d, pid_buff ,
246 sizeof(pid_buff) , rbuf, sizeof(rbuf));
247
248 if (st->stream_on)
249 ret |= lme2510_stream_restart(d);
250
251 return ret;
252 }
253
lme2510_int_response(struct urb * lme_urb)254 static void lme2510_int_response(struct urb *lme_urb)
255 {
256 struct dvb_usb_adapter *adap = lme_urb->context;
257 struct lme2510_state *st = adap_to_priv(adap);
258 static u8 *ibuf, *rbuf;
259 int i = 0, offset;
260 u32 key;
261
262 switch (lme_urb->status) {
263 case 0:
264 case -ETIMEDOUT:
265 break;
266 case -ECONNRESET:
267 case -ENOENT:
268 case -ESHUTDOWN:
269 return;
270 default:
271 info("Error %x", lme_urb->status);
272 break;
273 }
274
275 rbuf = (u8 *) lme_urb->transfer_buffer;
276
277 offset = ((lme_urb->actual_length/8) > 4)
278 ? 4 : (lme_urb->actual_length/8) ;
279
280 for (i = 0; i < offset; ++i) {
281 ibuf = (u8 *)&rbuf[i*8];
282 deb_info(5, "INT O/S C =%02x C/O=%02x Type =%02x%02x",
283 offset, i, ibuf[0], ibuf[1]);
284
285 switch (ibuf[0]) {
286 case 0xaa:
287 debug_data_snipet(1, "INT Remote data snipet", ibuf);
288 if ((ibuf[4] + ibuf[5]) == 0xff) {
289 key = RC_SCANCODE_NECX((ibuf[2] ^ 0xff) << 8 |
290 (ibuf[3] > 0) ? (ibuf[3] ^ 0xff) : 0,
291 ibuf[5]);
292 deb_info(1, "INT Key =%08x", key);
293 if (adap_to_d(adap)->rc_dev != NULL)
294 rc_keydown(adap_to_d(adap)->rc_dev,
295 RC_TYPE_NEC, key, 0);
296 }
297 break;
298 case 0xbb:
299 switch (st->tuner_config) {
300 case TUNER_LG:
301 if (ibuf[2] > 0)
302 st->signal_lock = ibuf[2];
303 st->signal_level = ibuf[4];
304 st->signal_sn = ibuf[3];
305 st->time_key = ibuf[7];
306 break;
307 case TUNER_S7395:
308 case TUNER_S0194:
309 /* Tweak for earlier firmware*/
310 if (ibuf[1] == 0x03) {
311 if (ibuf[2] > 1)
312 st->signal_lock = ibuf[2];
313 st->signal_level = ibuf[3];
314 st->signal_sn = ibuf[4];
315 } else {
316 st->signal_level = ibuf[4];
317 st->signal_sn = ibuf[5];
318 st->signal_lock =
319 (st->signal_lock & 0xf7) +
320 ((ibuf[2] & 0x01) << 0x03);
321 }
322 break;
323 case TUNER_RS2000:
324 if (ibuf[2] & 0x1)
325 st->signal_lock = 0xff;
326 else
327 st->signal_lock = 0x00;
328 st->signal_level = ibuf[5];
329 st->signal_sn = ibuf[4];
330 st->time_key = ibuf[7];
331 default:
332 break;
333 }
334 debug_data_snipet(5, "INT Remote data snipet in", ibuf);
335 break;
336 case 0xcc:
337 debug_data_snipet(1, "INT Control data snipet", ibuf);
338 break;
339 default:
340 debug_data_snipet(1, "INT Unknown data snipet", ibuf);
341 break;
342 }
343 }
344
345 usb_submit_urb(lme_urb, GFP_ATOMIC);
346
347 /* Interrupt urb is due every 48 msecs while streaming the buffer
348 * stores up to 4 periods if missed. Allow 200 msec for next interrupt.
349 */
350 st->int_urb_due = jiffies + msecs_to_jiffies(200);
351 }
352
lme2510_int_read(struct dvb_usb_adapter * adap)353 static int lme2510_int_read(struct dvb_usb_adapter *adap)
354 {
355 struct dvb_usb_device *d = adap_to_d(adap);
356 struct lme2510_state *lme_int = adap_to_priv(adap);
357 struct usb_host_endpoint *ep;
358
359 lme_int->lme_urb = usb_alloc_urb(0, GFP_ATOMIC);
360
361 if (lme_int->lme_urb == NULL)
362 return -ENOMEM;
363
364 lme_int->buffer = usb_alloc_coherent(d->udev, 128, GFP_ATOMIC,
365 &lme_int->lme_urb->transfer_dma);
366
367 if (lme_int->buffer == NULL)
368 return -ENOMEM;
369
370 usb_fill_int_urb(lme_int->lme_urb,
371 d->udev,
372 usb_rcvintpipe(d->udev, 0xa),
373 lme_int->buffer,
374 128,
375 lme2510_int_response,
376 adap,
377 8);
378
379 /* Quirk of pipe reporting PIPE_BULK but behaves as interrupt */
380 ep = usb_pipe_endpoint(d->udev, lme_int->lme_urb->pipe);
381
382 if (usb_endpoint_type(&ep->desc) == USB_ENDPOINT_XFER_BULK)
383 lme_int->lme_urb->pipe = usb_rcvbulkpipe(d->udev, 0xa),
384
385 lme_int->lme_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
386
387 usb_submit_urb(lme_int->lme_urb, GFP_ATOMIC);
388 info("INT Interrupt Service Started");
389
390 return 0;
391 }
392
lme2510_pid_filter_ctrl(struct dvb_usb_adapter * adap,int onoff)393 static int lme2510_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff)
394 {
395 struct dvb_usb_device *d = adap_to_d(adap);
396 struct lme2510_state *st = adap_to_priv(adap);
397 static u8 clear_pid_reg[] = LME_ALL_PIDS;
398 static u8 rbuf[1];
399 int ret = 0;
400
401 deb_info(1, "PID Clearing Filter");
402
403 mutex_lock(&d->i2c_mutex);
404
405 if (!onoff) {
406 ret |= lme2510_usb_talk(d, clear_pid_reg,
407 sizeof(clear_pid_reg), rbuf, sizeof(rbuf));
408 st->pid_off = true;
409 } else
410 st->pid_off = false;
411
412 st->pid_size = 0;
413
414 mutex_unlock(&d->i2c_mutex);
415
416 return 0;
417 }
418
lme2510_pid_filter(struct dvb_usb_adapter * adap,int index,u16 pid,int onoff)419 static int lme2510_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid,
420 int onoff)
421 {
422 struct dvb_usb_device *d = adap_to_d(adap);
423 int ret = 0;
424
425 deb_info(3, "%s PID=%04x Index=%04x onoff=%02x", __func__,
426 pid, index, onoff);
427
428 if (onoff) {
429 mutex_lock(&d->i2c_mutex);
430 ret |= lme2510_enable_pid(d, index, pid);
431 mutex_unlock(&d->i2c_mutex);
432 }
433
434
435 return ret;
436 }
437
438
lme2510_return_status(struct dvb_usb_device * d)439 static int lme2510_return_status(struct dvb_usb_device *d)
440 {
441 int ret = 0;
442 u8 *data;
443
444 data = kzalloc(10, GFP_KERNEL);
445 if (!data)
446 return -ENOMEM;
447
448 ret |= usb_control_msg(d->udev, usb_rcvctrlpipe(d->udev, 0),
449 0x06, 0x80, 0x0302, 0x00, data, 0x0006, 200);
450 info("Firmware Status: %x (%x)", ret , data[2]);
451
452 ret = (ret < 0) ? -ENODEV : data[2];
453 kfree(data);
454 return ret;
455 }
456
lme2510_msg(struct dvb_usb_device * d,u8 * wbuf,int wlen,u8 * rbuf,int rlen)457 static int lme2510_msg(struct dvb_usb_device *d,
458 u8 *wbuf, int wlen, u8 *rbuf, int rlen)
459 {
460 int ret = 0;
461 struct lme2510_state *st = d->priv;
462
463 if (st->i2c_talk_onoff == 1) {
464
465 ret = lme2510_usb_talk(d, wbuf, wlen, rbuf, rlen);
466
467 switch (st->tuner_config) {
468 case TUNER_LG:
469 if (wbuf[2] == 0x1c) {
470 if (wbuf[3] == 0x0e) {
471 st->signal_lock = rbuf[1];
472 if ((st->stream_on & 1) &&
473 (st->signal_lock & 0x10)) {
474 lme2510_stream_restart(d);
475 st->i2c_talk_onoff = 0;
476 }
477 msleep(80);
478 }
479 }
480 break;
481 case TUNER_S7395:
482 if (wbuf[2] == 0xd0) {
483 if (wbuf[3] == 0x24) {
484 st->signal_lock = rbuf[1];
485 if ((st->stream_on & 1) &&
486 (st->signal_lock & 0x8)) {
487 lme2510_stream_restart(d);
488 st->i2c_talk_onoff = 0;
489 }
490 }
491 }
492 break;
493 case TUNER_S0194:
494 if (wbuf[2] == 0xd0) {
495 if (wbuf[3] == 0x1b) {
496 st->signal_lock = rbuf[1];
497 if ((st->stream_on & 1) &&
498 (st->signal_lock & 0x8)) {
499 lme2510_stream_restart(d);
500 st->i2c_talk_onoff = 0;
501 }
502 }
503 }
504 break;
505 case TUNER_RS2000:
506 default:
507 break;
508 }
509 } else {
510 /* TODO rewrite this section */
511 switch (st->tuner_config) {
512 case TUNER_LG:
513 switch (wbuf[3]) {
514 case 0x0e:
515 rbuf[0] = 0x55;
516 rbuf[1] = st->signal_lock;
517 break;
518 case 0x43:
519 rbuf[0] = 0x55;
520 rbuf[1] = st->signal_level;
521 break;
522 case 0x1c:
523 rbuf[0] = 0x55;
524 rbuf[1] = st->signal_sn;
525 break;
526 case 0x15:
527 case 0x16:
528 case 0x17:
529 case 0x18:
530 rbuf[0] = 0x55;
531 rbuf[1] = 0x00;
532 break;
533 default:
534 lme2510_usb_talk(d, wbuf, wlen, rbuf, rlen);
535 st->i2c_talk_onoff = 1;
536 break;
537 }
538 break;
539 case TUNER_S7395:
540 switch (wbuf[3]) {
541 case 0x10:
542 rbuf[0] = 0x55;
543 rbuf[1] = (st->signal_level & 0x80)
544 ? 0 : (st->signal_level * 2);
545 break;
546 case 0x2d:
547 rbuf[0] = 0x55;
548 rbuf[1] = st->signal_sn;
549 break;
550 case 0x24:
551 rbuf[0] = 0x55;
552 rbuf[1] = st->signal_lock;
553 break;
554 case 0x2e:
555 case 0x26:
556 case 0x27:
557 rbuf[0] = 0x55;
558 rbuf[1] = 0x00;
559 break;
560 default:
561 lme2510_usb_talk(d, wbuf, wlen, rbuf, rlen);
562 st->i2c_talk_onoff = 1;
563 break;
564 }
565 break;
566 case TUNER_S0194:
567 switch (wbuf[3]) {
568 case 0x18:
569 rbuf[0] = 0x55;
570 rbuf[1] = (st->signal_level & 0x80)
571 ? 0 : (st->signal_level * 2);
572 break;
573 case 0x24:
574 rbuf[0] = 0x55;
575 rbuf[1] = st->signal_sn;
576 break;
577 case 0x1b:
578 rbuf[0] = 0x55;
579 rbuf[1] = st->signal_lock;
580 break;
581 case 0x19:
582 case 0x25:
583 case 0x1e:
584 case 0x1d:
585 rbuf[0] = 0x55;
586 rbuf[1] = 0x00;
587 break;
588 default:
589 lme2510_usb_talk(d, wbuf, wlen, rbuf, rlen);
590 st->i2c_talk_onoff = 1;
591 break;
592 }
593 break;
594 case TUNER_RS2000:
595 switch (wbuf[3]) {
596 case 0x8c:
597 rbuf[0] = 0x55;
598 rbuf[1] = st->signal_lock;
599
600 /* If int_urb_due overdue
601 * set rbuf[1] to 0 to clear lock */
602 if (time_after(jiffies, st->int_urb_due))
603 rbuf[1] = 0;
604
605 break;
606 default:
607 lme2510_usb_talk(d, wbuf, wlen, rbuf, rlen);
608 st->i2c_talk_onoff = 1;
609 break;
610 }
611 default:
612 break;
613 }
614
615 deb_info(4, "I2C From Interrupt Message out(%02x) in(%02x)",
616 wbuf[3], rbuf[1]);
617
618 }
619
620 return ret;
621 }
622
623
lme2510_i2c_xfer(struct i2c_adapter * adap,struct i2c_msg msg[],int num)624 static int lme2510_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
625 int num)
626 {
627 struct dvb_usb_device *d = i2c_get_adapdata(adap);
628 struct lme2510_state *st = d->priv;
629 static u8 obuf[64], ibuf[64];
630 int i, read, read_o;
631 u16 len;
632 u8 gate = st->i2c_gate;
633
634 mutex_lock(&d->i2c_mutex);
635
636 if (gate == 0)
637 gate = 5;
638
639 for (i = 0; i < num; i++) {
640 read_o = msg[i].flags & I2C_M_RD;
641 read = i + 1 < num && msg[i + 1].flags & I2C_M_RD;
642 read |= read_o;
643 gate = (msg[i].addr == st->i2c_tuner_addr)
644 ? (read) ? st->i2c_tuner_gate_r
645 : st->i2c_tuner_gate_w
646 : st->i2c_gate;
647 obuf[0] = gate | (read << 7);
648
649 if (gate == 5)
650 obuf[1] = (read) ? 2 : msg[i].len + 1;
651 else
652 obuf[1] = msg[i].len + read + 1;
653
654 obuf[2] = msg[i].addr << 1;
655
656 if (read) {
657 if (read_o)
658 len = 3;
659 else {
660 memcpy(&obuf[3], msg[i].buf, msg[i].len);
661 obuf[msg[i].len+3] = msg[i+1].len;
662 len = msg[i].len+4;
663 }
664 } else {
665 memcpy(&obuf[3], msg[i].buf, msg[i].len);
666 len = msg[i].len+3;
667 }
668
669 if (lme2510_msg(d, obuf, len, ibuf, 64) < 0) {
670 deb_info(1, "i2c transfer failed.");
671 mutex_unlock(&d->i2c_mutex);
672 return -EAGAIN;
673 }
674
675 if (read) {
676 if (read_o)
677 memcpy(msg[i].buf, &ibuf[1], msg[i].len);
678 else {
679 memcpy(msg[i+1].buf, &ibuf[1], msg[i+1].len);
680 i++;
681 }
682 }
683 }
684
685 mutex_unlock(&d->i2c_mutex);
686 return i;
687 }
688
lme2510_i2c_func(struct i2c_adapter * adapter)689 static u32 lme2510_i2c_func(struct i2c_adapter *adapter)
690 {
691 return I2C_FUNC_I2C;
692 }
693
694 static struct i2c_algorithm lme2510_i2c_algo = {
695 .master_xfer = lme2510_i2c_xfer,
696 .functionality = lme2510_i2c_func,
697 };
698
lme2510_streaming_ctrl(struct dvb_frontend * fe,int onoff)699 static int lme2510_streaming_ctrl(struct dvb_frontend *fe, int onoff)
700 {
701 struct dvb_usb_adapter *adap = fe_to_adap(fe);
702 struct dvb_usb_device *d = adap_to_d(adap);
703 struct lme2510_state *st = adap_to_priv(adap);
704 static u8 clear_reg_3[] = LME_ALL_PIDS;
705 static u8 rbuf[1];
706 int ret = 0, rlen = sizeof(rbuf);
707
708 deb_info(1, "STM (%02x)", onoff);
709
710 /* Streaming is started by FE_HAS_LOCK */
711 if (onoff == 1)
712 st->stream_on = 1;
713 else {
714 deb_info(1, "STM Steam Off");
715 /* mutex is here only to avoid collision with I2C */
716 mutex_lock(&d->i2c_mutex);
717
718 ret = lme2510_usb_talk(d, clear_reg_3,
719 sizeof(clear_reg_3), rbuf, rlen);
720 st->stream_on = 0;
721 st->i2c_talk_onoff = 1;
722
723 mutex_unlock(&d->i2c_mutex);
724 }
725
726 return (ret < 0) ? -ENODEV : 0;
727 }
728
check_sum(u8 * p,u8 len)729 static u8 check_sum(u8 *p, u8 len)
730 {
731 u8 sum = 0;
732 while (len--)
733 sum += *p++;
734 return sum;
735 }
736
lme2510_download_firmware(struct dvb_usb_device * d,const struct firmware * fw)737 static int lme2510_download_firmware(struct dvb_usb_device *d,
738 const struct firmware *fw)
739 {
740 int ret = 0;
741 u8 *data;
742 u16 j, wlen, len_in, start, end;
743 u8 packet_size, dlen, i;
744 u8 *fw_data;
745
746 packet_size = 0x31;
747 len_in = 1;
748
749 data = kzalloc(128, GFP_KERNEL);
750 if (!data) {
751 info("FRM Could not start Firmware Download"\
752 "(Buffer allocation failed)");
753 return -ENOMEM;
754 }
755
756 info("FRM Starting Firmware Download");
757
758 for (i = 1; i < 3; i++) {
759 start = (i == 1) ? 0 : 512;
760 end = (i == 1) ? 512 : fw->size;
761 for (j = start; j < end; j += (packet_size+1)) {
762 fw_data = (u8 *)(fw->data + j);
763 if ((end - j) > packet_size) {
764 data[0] = i;
765 dlen = packet_size;
766 } else {
767 data[0] = i | 0x80;
768 dlen = (u8)(end - j)-1;
769 }
770 data[1] = dlen;
771 memcpy(&data[2], fw_data, dlen+1);
772 wlen = (u8) dlen + 4;
773 data[wlen-1] = check_sum(fw_data, dlen+1);
774 deb_info(1, "Data S=%02x:E=%02x CS= %02x", data[3],
775 data[dlen+2], data[dlen+3]);
776 lme2510_usb_talk(d, data, wlen, data, len_in);
777 ret |= (data[0] == 0x88) ? 0 : -1;
778 }
779 }
780
781 data[0] = 0x8a;
782 len_in = 1;
783 msleep(2000);
784 lme2510_usb_talk(d, data, len_in, data, len_in);
785 msleep(400);
786
787 if (ret < 0)
788 info("FRM Firmware Download Failed (%04x)" , ret);
789 else
790 info("FRM Firmware Download Completed - Resetting Device");
791
792 kfree(data);
793 return RECONNECTS_USB;
794 }
795
lme_coldreset(struct dvb_usb_device * d)796 static void lme_coldreset(struct dvb_usb_device *d)
797 {
798 u8 data[1] = {0};
799 data[0] = 0x0a;
800 info("FRM Firmware Cold Reset");
801
802 lme2510_usb_talk(d, data, sizeof(data), data, sizeof(data));
803
804 return;
805 }
806
807 static const char fw_c_s7395[] = LME2510_C_S7395;
808 static const char fw_c_lg[] = LME2510_C_LG;
809 static const char fw_c_s0194[] = LME2510_C_S0194;
810 static const char fw_c_rs2000[] = LME2510_C_RS2000;
811 static const char fw_lg[] = LME2510_LG;
812 static const char fw_s0194[] = LME2510_S0194;
813
lme_firmware_switch(struct dvb_usb_device * d,int cold)814 static const char *lme_firmware_switch(struct dvb_usb_device *d, int cold)
815 {
816 struct lme2510_state *st = d->priv;
817 struct usb_device *udev = d->udev;
818 const struct firmware *fw = NULL;
819 const char *fw_lme;
820 int ret = 0;
821
822 cold = (cold > 0) ? (cold & 1) : 0;
823
824 switch (le16_to_cpu(udev->descriptor.idProduct)) {
825 case 0x1122:
826 switch (st->dvb_usb_lme2510_firmware) {
827 default:
828 st->dvb_usb_lme2510_firmware = TUNER_S0194;
829 case TUNER_S0194:
830 fw_lme = fw_s0194;
831 ret = request_firmware(&fw, fw_lme, &udev->dev);
832 if (ret == 0) {
833 cold = 0;
834 break;
835 }
836 st->dvb_usb_lme2510_firmware = TUNER_LG;
837 case TUNER_LG:
838 fw_lme = fw_lg;
839 ret = request_firmware(&fw, fw_lme, &udev->dev);
840 if (ret == 0)
841 break;
842 st->dvb_usb_lme2510_firmware = TUNER_DEFAULT;
843 break;
844 }
845 break;
846 case 0x1120:
847 switch (st->dvb_usb_lme2510_firmware) {
848 default:
849 st->dvb_usb_lme2510_firmware = TUNER_S7395;
850 case TUNER_S7395:
851 fw_lme = fw_c_s7395;
852 ret = request_firmware(&fw, fw_lme, &udev->dev);
853 if (ret == 0) {
854 cold = 0;
855 break;
856 }
857 st->dvb_usb_lme2510_firmware = TUNER_LG;
858 case TUNER_LG:
859 fw_lme = fw_c_lg;
860 ret = request_firmware(&fw, fw_lme, &udev->dev);
861 if (ret == 0)
862 break;
863 st->dvb_usb_lme2510_firmware = TUNER_S0194;
864 case TUNER_S0194:
865 fw_lme = fw_c_s0194;
866 ret = request_firmware(&fw, fw_lme, &udev->dev);
867 if (ret == 0)
868 break;
869 st->dvb_usb_lme2510_firmware = TUNER_DEFAULT;
870 cold = 0;
871 break;
872 }
873 break;
874 case 0x22f0:
875 fw_lme = fw_c_rs2000;
876 st->dvb_usb_lme2510_firmware = TUNER_RS2000;
877 break;
878 default:
879 fw_lme = fw_c_s7395;
880 }
881
882 release_firmware(fw);
883
884 if (cold) {
885 dvb_usb_lme2510_firmware = st->dvb_usb_lme2510_firmware;
886 info("FRM Changing to %s firmware", fw_lme);
887 lme_coldreset(d);
888 return NULL;
889 }
890
891 return fw_lme;
892 }
893
lme2510_kill_urb(struct usb_data_stream * stream)894 static int lme2510_kill_urb(struct usb_data_stream *stream)
895 {
896 int i;
897
898 for (i = 0; i < stream->urbs_submitted; i++) {
899 deb_info(3, "killing URB no. %d.", i);
900 /* stop the URB */
901 usb_kill_urb(stream->urb_list[i]);
902 }
903 stream->urbs_submitted = 0;
904
905 return 0;
906 }
907
908 static struct tda10086_config tda10086_config = {
909 .demod_address = 0x0e,
910 .invert = 0,
911 .diseqc_tone = 1,
912 .xtal_freq = TDA10086_XTAL_16M,
913 };
914
915 static struct stv0288_config lme_config = {
916 .demod_address = 0x68,
917 .min_delay_ms = 15,
918 .inittab = s7395_inittab,
919 };
920
921 static struct ix2505v_config lme_tuner = {
922 .tuner_address = 0x60,
923 .min_delay_ms = 100,
924 .tuner_gain = 0x0,
925 .tuner_chargepump = 0x3,
926 };
927
928 static struct stv0299_config sharp_z0194_config = {
929 .demod_address = 0x68,
930 .inittab = sharp_z0194a_inittab,
931 .mclk = 88000000UL,
932 .invert = 0,
933 .skip_reinit = 0,
934 .lock_output = STV0299_LOCKOUTPUT_1,
935 .volt13_op0_op1 = STV0299_VOLT13_OP1,
936 .min_delay_ms = 100,
937 .set_symbol_rate = sharp_z0194a_set_symbol_rate,
938 };
939
dm04_rs2000_set_ts_param(struct dvb_frontend * fe,int caller)940 static int dm04_rs2000_set_ts_param(struct dvb_frontend *fe,
941 int caller)
942 {
943 struct dvb_usb_adapter *adap = fe_to_adap(fe);
944 struct dvb_usb_device *d = adap_to_d(adap);
945 struct lme2510_state *st = d->priv;
946
947 mutex_lock(&d->i2c_mutex);
948 if ((st->i2c_talk_onoff == 1) && (st->stream_on & 1)) {
949 st->i2c_talk_onoff = 0;
950 lme2510_stream_restart(d);
951 }
952 mutex_unlock(&d->i2c_mutex);
953
954 return 0;
955 }
956
957 static struct m88rs2000_config m88rs2000_config = {
958 .demod_addr = 0x68,
959 .set_ts_params = dm04_rs2000_set_ts_param,
960 };
961
962 static struct ts2020_config ts2020_config = {
963 .tuner_address = 0x60,
964 .clk_out_div = 7,
965 };
966
dm04_lme2510_set_voltage(struct dvb_frontend * fe,fe_sec_voltage_t voltage)967 static int dm04_lme2510_set_voltage(struct dvb_frontend *fe,
968 fe_sec_voltage_t voltage)
969 {
970 struct dvb_usb_device *d = fe_to_d(fe);
971 struct lme2510_state *st = fe_to_priv(fe);
972 static u8 voltage_low[] = LME_VOLTAGE_L;
973 static u8 voltage_high[] = LME_VOLTAGE_H;
974 static u8 rbuf[1];
975 int ret = 0, len = 3, rlen = 1;
976
977 mutex_lock(&d->i2c_mutex);
978
979 switch (voltage) {
980 case SEC_VOLTAGE_18:
981 ret |= lme2510_usb_talk(d,
982 voltage_high, len, rbuf, rlen);
983 break;
984
985 case SEC_VOLTAGE_OFF:
986 case SEC_VOLTAGE_13:
987 default:
988 ret |= lme2510_usb_talk(d,
989 voltage_low, len, rbuf, rlen);
990 break;
991 }
992
993 mutex_unlock(&d->i2c_mutex);
994
995 if (st->tuner_config == TUNER_RS2000)
996 if (st->fe_set_voltage)
997 st->fe_set_voltage(fe, voltage);
998
999
1000 return (ret < 0) ? -ENODEV : 0;
1001 }
1002
dm04_rs2000_read_signal_strength(struct dvb_frontend * fe,u16 * strength)1003 static int dm04_rs2000_read_signal_strength(struct dvb_frontend *fe,
1004 u16 *strength)
1005 {
1006 struct lme2510_state *st = fe_to_priv(fe);
1007
1008 *strength = (u16)((u32)st->signal_level * 0xffff / 0xff);
1009
1010 return 0;
1011 }
1012
dm04_rs2000_read_snr(struct dvb_frontend * fe,u16 * snr)1013 static int dm04_rs2000_read_snr(struct dvb_frontend *fe, u16 *snr)
1014 {
1015 struct lme2510_state *st = fe_to_priv(fe);
1016
1017 *snr = (u16)((u32)st->signal_sn * 0xffff / 0x7f);
1018
1019 return 0;
1020 }
1021
dm04_read_ber(struct dvb_frontend * fe,u32 * ber)1022 static int dm04_read_ber(struct dvb_frontend *fe, u32 *ber)
1023 {
1024 *ber = 0;
1025
1026 return 0;
1027 }
1028
dm04_read_ucblocks(struct dvb_frontend * fe,u32 * ucblocks)1029 static int dm04_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
1030 {
1031 *ucblocks = 0;
1032
1033 return 0;
1034 }
1035
lme_name(struct dvb_usb_adapter * adap)1036 static int lme_name(struct dvb_usb_adapter *adap)
1037 {
1038 struct dvb_usb_device *d = adap_to_d(adap);
1039 struct lme2510_state *st = adap_to_priv(adap);
1040 const char *desc = d->name;
1041 char *fe_name[] = {"", " LG TDQY-P001F", " SHARP:BS2F7HZ7395",
1042 " SHARP:BS2F7HZ0194", " RS2000"};
1043 char *name = adap->fe[0]->ops.info.name;
1044
1045 strlcpy(name, desc, 128);
1046 strlcat(name, fe_name[st->tuner_config], 128);
1047
1048 return 0;
1049 }
1050
dm04_lme2510_frontend_attach(struct dvb_usb_adapter * adap)1051 static int dm04_lme2510_frontend_attach(struct dvb_usb_adapter *adap)
1052 {
1053 struct dvb_usb_device *d = adap_to_d(adap);
1054 struct lme2510_state *st = d->priv;
1055 int ret = 0;
1056
1057 st->i2c_talk_onoff = 1;
1058 switch (le16_to_cpu(d->udev->descriptor.idProduct)) {
1059 case 0x1122:
1060 case 0x1120:
1061 st->i2c_gate = 4;
1062 adap->fe[0] = dvb_attach(tda10086_attach,
1063 &tda10086_config, &d->i2c_adap);
1064 if (adap->fe[0]) {
1065 info("TUN Found Frontend TDA10086");
1066 st->i2c_tuner_gate_w = 4;
1067 st->i2c_tuner_gate_r = 4;
1068 st->i2c_tuner_addr = 0x60;
1069 st->tuner_config = TUNER_LG;
1070 if (st->dvb_usb_lme2510_firmware != TUNER_LG) {
1071 st->dvb_usb_lme2510_firmware = TUNER_LG;
1072 ret = lme_firmware_switch(d, 1) ? 0 : -ENODEV;
1073 }
1074 break;
1075 }
1076
1077 st->i2c_gate = 4;
1078 adap->fe[0] = dvb_attach(stv0299_attach,
1079 &sharp_z0194_config, &d->i2c_adap);
1080 if (adap->fe[0]) {
1081 info("FE Found Stv0299");
1082 st->i2c_tuner_gate_w = 4;
1083 st->i2c_tuner_gate_r = 5;
1084 st->i2c_tuner_addr = 0x60;
1085 st->tuner_config = TUNER_S0194;
1086 if (st->dvb_usb_lme2510_firmware != TUNER_S0194) {
1087 st->dvb_usb_lme2510_firmware = TUNER_S0194;
1088 ret = lme_firmware_switch(d, 1) ? 0 : -ENODEV;
1089 }
1090 break;
1091 }
1092
1093 st->i2c_gate = 5;
1094 adap->fe[0] = dvb_attach(stv0288_attach, &lme_config,
1095 &d->i2c_adap);
1096
1097 if (adap->fe[0]) {
1098 info("FE Found Stv0288");
1099 st->i2c_tuner_gate_w = 4;
1100 st->i2c_tuner_gate_r = 5;
1101 st->i2c_tuner_addr = 0x60;
1102 st->tuner_config = TUNER_S7395;
1103 if (st->dvb_usb_lme2510_firmware != TUNER_S7395) {
1104 st->dvb_usb_lme2510_firmware = TUNER_S7395;
1105 ret = lme_firmware_switch(d, 1) ? 0 : -ENODEV;
1106 }
1107 break;
1108 }
1109 case 0x22f0:
1110 st->i2c_gate = 5;
1111 adap->fe[0] = dvb_attach(m88rs2000_attach,
1112 &m88rs2000_config, &d->i2c_adap);
1113
1114 if (adap->fe[0]) {
1115 info("FE Found M88RS2000");
1116 dvb_attach(ts2020_attach, adap->fe[0], &ts2020_config,
1117 &d->i2c_adap);
1118 st->i2c_tuner_gate_w = 5;
1119 st->i2c_tuner_gate_r = 5;
1120 st->i2c_tuner_addr = 0x60;
1121 st->tuner_config = TUNER_RS2000;
1122 st->fe_set_voltage =
1123 adap->fe[0]->ops.set_voltage;
1124
1125 adap->fe[0]->ops.read_signal_strength =
1126 dm04_rs2000_read_signal_strength;
1127 adap->fe[0]->ops.read_snr =
1128 dm04_rs2000_read_snr;
1129 adap->fe[0]->ops.read_ber =
1130 dm04_read_ber;
1131 adap->fe[0]->ops.read_ucblocks =
1132 dm04_read_ucblocks;
1133 }
1134 break;
1135 }
1136
1137 if (adap->fe[0] == NULL) {
1138 info("DM04/QQBOX Not Powered up or not Supported");
1139 return -ENODEV;
1140 }
1141
1142 if (ret) {
1143 if (adap->fe[0]) {
1144 dvb_frontend_detach(adap->fe[0]);
1145 adap->fe[0] = NULL;
1146 }
1147 d->rc_map = NULL;
1148 return -ENODEV;
1149 }
1150
1151 adap->fe[0]->ops.set_voltage = dm04_lme2510_set_voltage;
1152 ret = lme_name(adap);
1153 return ret;
1154 }
1155
dm04_lme2510_tuner(struct dvb_usb_adapter * adap)1156 static int dm04_lme2510_tuner(struct dvb_usb_adapter *adap)
1157 {
1158 struct dvb_usb_device *d = adap_to_d(adap);
1159 struct lme2510_state *st = adap_to_priv(adap);
1160 char *tun_msg[] = {"", "TDA8263", "IX2505V", "DVB_PLL_OPERA", "RS2000"};
1161 int ret = 0;
1162
1163 switch (st->tuner_config) {
1164 case TUNER_LG:
1165 if (dvb_attach(tda826x_attach, adap->fe[0], 0x60,
1166 &d->i2c_adap, 1))
1167 ret = st->tuner_config;
1168 break;
1169 case TUNER_S7395:
1170 if (dvb_attach(ix2505v_attach , adap->fe[0], &lme_tuner,
1171 &d->i2c_adap))
1172 ret = st->tuner_config;
1173 break;
1174 case TUNER_S0194:
1175 if (dvb_attach(dvb_pll_attach , adap->fe[0], 0x60,
1176 &d->i2c_adap, DVB_PLL_OPERA1))
1177 ret = st->tuner_config;
1178 break;
1179 case TUNER_RS2000:
1180 ret = st->tuner_config;
1181 break;
1182 default:
1183 break;
1184 }
1185
1186 if (ret)
1187 info("TUN Found %s tuner", tun_msg[ret]);
1188 else {
1189 info("TUN No tuner found --- resetting device");
1190 lme_coldreset(d);
1191 return -ENODEV;
1192 }
1193
1194 /* Start the Interrupt*/
1195 ret = lme2510_int_read(adap);
1196 if (ret < 0) {
1197 info("INT Unable to start Interrupt Service");
1198 return -ENODEV;
1199 }
1200
1201 return ret;
1202 }
1203
lme2510_powerup(struct dvb_usb_device * d,int onoff)1204 static int lme2510_powerup(struct dvb_usb_device *d, int onoff)
1205 {
1206 struct lme2510_state *st = d->priv;
1207 static u8 lnb_on[] = LNB_ON;
1208 static u8 lnb_off[] = LNB_OFF;
1209 static u8 rbuf[1];
1210 int ret = 0, len = 3, rlen = 1;
1211
1212 mutex_lock(&d->i2c_mutex);
1213
1214 if (onoff)
1215 ret = lme2510_usb_talk(d, lnb_on, len, rbuf, rlen);
1216 else
1217 ret = lme2510_usb_talk(d, lnb_off, len, rbuf, rlen);
1218
1219 st->i2c_talk_onoff = 1;
1220
1221 mutex_unlock(&d->i2c_mutex);
1222
1223 return ret;
1224 }
1225
lme2510_get_adapter_count(struct dvb_usb_device * d)1226 static int lme2510_get_adapter_count(struct dvb_usb_device *d)
1227 {
1228 return 1;
1229 }
1230
lme2510_identify_state(struct dvb_usb_device * d,const char ** name)1231 static int lme2510_identify_state(struct dvb_usb_device *d, const char **name)
1232 {
1233 struct lme2510_state *st = d->priv;
1234
1235 usb_reset_configuration(d->udev);
1236
1237 usb_set_interface(d->udev,
1238 d->props->bInterfaceNumber, 1);
1239
1240 st->dvb_usb_lme2510_firmware = dvb_usb_lme2510_firmware;
1241
1242 if (lme2510_return_status(d) == 0x44) {
1243 *name = lme_firmware_switch(d, 0);
1244 return COLD;
1245 }
1246
1247 return 0;
1248 }
1249
lme2510_get_stream_config(struct dvb_frontend * fe,u8 * ts_type,struct usb_data_stream_properties * stream)1250 static int lme2510_get_stream_config(struct dvb_frontend *fe, u8 *ts_type,
1251 struct usb_data_stream_properties *stream)
1252 {
1253 struct dvb_usb_adapter *adap = fe_to_adap(fe);
1254 struct dvb_usb_device *d;
1255
1256 if (adap == NULL)
1257 return 0;
1258
1259 d = adap_to_d(adap);
1260
1261 /* Turn PID filter on the fly by module option */
1262 if (pid_filter == 2) {
1263 adap->pid_filtering = true;
1264 adap->max_feed_count = 15;
1265 }
1266
1267 if (!(le16_to_cpu(d->udev->descriptor.idProduct)
1268 == 0x1122))
1269 stream->endpoint = 0x8;
1270
1271 return 0;
1272 }
1273
lme2510_get_rc_config(struct dvb_usb_device * d,struct dvb_usb_rc * rc)1274 static int lme2510_get_rc_config(struct dvb_usb_device *d,
1275 struct dvb_usb_rc *rc)
1276 {
1277 rc->allowed_protos = RC_BIT_NEC;
1278 return 0;
1279 }
1280
lme2510_exit_int(struct dvb_usb_device * d)1281 static void *lme2510_exit_int(struct dvb_usb_device *d)
1282 {
1283 struct lme2510_state *st = d->priv;
1284 struct dvb_usb_adapter *adap = &d->adapter[0];
1285 void *buffer = NULL;
1286
1287 if (adap != NULL) {
1288 lme2510_kill_urb(&adap->stream);
1289 }
1290
1291 if (st->usb_buffer != NULL) {
1292 st->i2c_talk_onoff = 1;
1293 st->signal_lock = 0;
1294 st->signal_level = 0;
1295 st->signal_sn = 0;
1296 buffer = st->usb_buffer;
1297 }
1298
1299 if (st->lme_urb != NULL) {
1300 usb_kill_urb(st->lme_urb);
1301 usb_free_coherent(d->udev, 128, st->buffer,
1302 st->lme_urb->transfer_dma);
1303 info("Interrupt Service Stopped");
1304 }
1305
1306 return buffer;
1307 }
1308
lme2510_exit(struct dvb_usb_device * d)1309 static void lme2510_exit(struct dvb_usb_device *d)
1310 {
1311 void *usb_buffer;
1312
1313 if (d != NULL) {
1314 usb_buffer = lme2510_exit_int(d);
1315 kfree(usb_buffer);
1316 }
1317 }
1318
1319 static struct dvb_usb_device_properties lme2510_props = {
1320 .driver_name = KBUILD_MODNAME,
1321 .owner = THIS_MODULE,
1322 .bInterfaceNumber = 0,
1323 .adapter_nr = adapter_nr,
1324 .size_of_priv = sizeof(struct lme2510_state),
1325
1326 .download_firmware = lme2510_download_firmware,
1327
1328 .power_ctrl = lme2510_powerup,
1329 .identify_state = lme2510_identify_state,
1330 .i2c_algo = &lme2510_i2c_algo,
1331
1332 .frontend_attach = dm04_lme2510_frontend_attach,
1333 .tuner_attach = dm04_lme2510_tuner,
1334 .get_stream_config = lme2510_get_stream_config,
1335 .get_adapter_count = lme2510_get_adapter_count,
1336 .streaming_ctrl = lme2510_streaming_ctrl,
1337
1338 .get_rc_config = lme2510_get_rc_config,
1339
1340 .exit = lme2510_exit,
1341 .adapter = {
1342 {
1343 .caps = DVB_USB_ADAP_HAS_PID_FILTER|
1344 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1345 .pid_filter_count = 15,
1346 .pid_filter = lme2510_pid_filter,
1347 .pid_filter_ctrl = lme2510_pid_filter_ctrl,
1348 .stream =
1349 DVB_USB_STREAM_BULK(0x86, 10, 4096),
1350 },
1351 {
1352 }
1353 },
1354 };
1355
1356 static const struct usb_device_id lme2510_id_table[] = {
1357 { DVB_USB_DEVICE(0x3344, 0x1122, &lme2510_props,
1358 "DM04_LME2510_DVB-S", RC_MAP_LME2510) },
1359 { DVB_USB_DEVICE(0x3344, 0x1120, &lme2510_props,
1360 "DM04_LME2510C_DVB-S", RC_MAP_LME2510) },
1361 { DVB_USB_DEVICE(0x3344, 0x22f0, &lme2510_props,
1362 "DM04_LME2510C_DVB-S RS2000", RC_MAP_LME2510) },
1363 {} /* Terminating entry */
1364 };
1365
1366 MODULE_DEVICE_TABLE(usb, lme2510_id_table);
1367
1368 static struct usb_driver lme2510_driver = {
1369 .name = KBUILD_MODNAME,
1370 .probe = dvb_usbv2_probe,
1371 .disconnect = dvb_usbv2_disconnect,
1372 .id_table = lme2510_id_table,
1373 .no_dynamic_id = 1,
1374 .soft_unbind = 1,
1375 };
1376
1377 module_usb_driver(lme2510_driver);
1378
1379 MODULE_AUTHOR("Malcolm Priestley <tvboxspy@gmail.com>");
1380 MODULE_DESCRIPTION("LME2510(C) DVB-S USB2.0");
1381 MODULE_VERSION("2.06");
1382 MODULE_LICENSE("GPL");
1383 MODULE_FIRMWARE(LME2510_C_S7395);
1384 MODULE_FIRMWARE(LME2510_C_LG);
1385 MODULE_FIRMWARE(LME2510_C_S0194);
1386 MODULE_FIRMWARE(LME2510_C_RS2000);
1387 MODULE_FIRMWARE(LME2510_LG);
1388 MODULE_FIRMWARE(LME2510_S0194);
1389
1390