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