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