projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.kernel.dk/linux-block
[deliverable/linux.git] / drivers / media / dvb / dvb-usb / af9015.c
1 /*
2 * DVB USB Linux driver for Afatech AF9015 DVB-T USB2.0 receiver
3 *
4 * Copyright (C) 2007 Antti Palosaari <crope@iki.fi>
5 *
6 * Thanks to Afatech who kindly provided information.
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 *
22 */
23
24 #include <linux/hash.h>
25 #include <linux/slab.h>
26
27 #include "af9015.h"
28 #include "af9013.h"
29 #include "mt2060.h"
30 #include "qt1010.h"
31 #include "tda18271.h"
32 #include "mxl5005s.h"
33 #include "mc44s803.h"
34 #include "tda18218.h"
35 #include "mxl5007t.h"
36
37 static int dvb_usb_af9015_debug;
38 module_param_named(debug, dvb_usb_af9015_debug, int, 0644);
39 MODULE_PARM_DESC(debug, "set debugging level" DVB_USB_DEBUG_STATUS);
40 static int dvb_usb_af9015_remote;
41 module_param_named(remote, dvb_usb_af9015_remote, int, 0644);
42 MODULE_PARM_DESC(remote, "select remote");
43 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
44
45 static DEFINE_MUTEX(af9015_usb_mutex);
46
47 static struct af9015_config af9015_config;
48 static struct dvb_usb_device_properties af9015_properties[3];
49 static int af9015_properties_count = ARRAY_SIZE(af9015_properties);
50
51 static struct af9013_config af9015_af9013_config[] = {
52 {
53 .i2c_addr = AF9015_I2C_DEMOD,
54 .ts_mode = AF9013_TS_USB,
55 .api_version = { 0, 1, 9, 0 },
56 .gpio[0] = AF9013_GPIO_HI,
57 .gpio[3] = AF9013_GPIO_TUNER_ON,
58
59 }, {
60 .ts_mode = AF9013_TS_SERIAL,
61 .api_version = { 0, 1, 9, 0 },
62 .gpio[0] = AF9013_GPIO_TUNER_ON,
63 .gpio[1] = AF9013_GPIO_LO,
64 }
65 };
66
67 static int af9015_rw_udev(struct usb_device *udev, struct req_t *req)
68 {
69 #define BUF_LEN 63
70 #define REQ_HDR_LEN 8 /* send header size */
71 #define ACK_HDR_LEN 2 /* rece header size */
72 int act_len, ret;
73 u8 buf[BUF_LEN];
74 u8 write = 1;
75 u8 msg_len = REQ_HDR_LEN;
76 static u8 seq; /* packet sequence number */
77
78 if (mutex_lock_interruptible(&af9015_usb_mutex) < 0)
79 return -EAGAIN;
80
81 buf[0] = req->cmd;
82 buf[1] = seq++;
83 buf[2] = req->i2c_addr;
84 buf[3] = req->addr >> 8;
85 buf[4] = req->addr & 0xff;
86 buf[5] = req->mbox;
87 buf[6] = req->addr_len;
88 buf[7] = req->data_len;
89
90 switch (req->cmd) {
91 case GET_CONFIG:
92 case READ_MEMORY:
93 case RECONNECT_USB:
94 write = 0;
95 break;
96 case READ_I2C:
97 write = 0;
98 buf[2] |= 0x01; /* set I2C direction */
99 case WRITE_I2C:
100 buf[0] = READ_WRITE_I2C;
101 break;
102 case WRITE_MEMORY:
103 if (((req->addr & 0xff00) == 0xff00) ||
104 ((req->addr & 0xff00) == 0xae00))
105 buf[0] = WRITE_VIRTUAL_MEMORY;
106 case WRITE_VIRTUAL_MEMORY:
107 case COPY_FIRMWARE:
108 case DOWNLOAD_FIRMWARE:
109 case BOOT:
110 break;
111 default:
112 err("unknown command:%d", req->cmd);
113 ret = -1;
114 goto error_unlock;
115 }
116
117 /* buffer overflow check */
118 if ((write && (req->data_len > BUF_LEN - REQ_HDR_LEN)) ||
119 (!write && (req->data_len > BUF_LEN - ACK_HDR_LEN))) {
120 err("too much data; cmd:%d len:%d", req->cmd, req->data_len);
121 ret = -EINVAL;
122 goto error_unlock;
123 }
124
125 /* write requested */
126 if (write) {
127 memcpy(&buf[REQ_HDR_LEN], req->data, req->data_len);
128 msg_len += req->data_len;
129 }
130
131 deb_xfer(">>> ");
132 debug_dump(buf, msg_len, deb_xfer);
133
134 /* send req */
135 ret = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 0x02), buf, msg_len,
136 &act_len, AF9015_USB_TIMEOUT);
137 if (ret)
138 err("bulk message failed:%d (%d/%d)", ret, msg_len, act_len);
139 else
140 if (act_len != msg_len)
141 ret = -1; /* all data is not send */
142 if (ret)
143 goto error_unlock;
144
145 /* no ack for those packets */
146 if (req->cmd == DOWNLOAD_FIRMWARE || req->cmd == RECONNECT_USB)
147 goto exit_unlock;
148
149 /* write receives seq + status = 2 bytes
150 read receives seq + status + data = 2 + N bytes */
151 msg_len = ACK_HDR_LEN;
152 if (!write)
153 msg_len += req->data_len;
154
155 ret = usb_bulk_msg(udev, usb_rcvbulkpipe(udev, 0x81), buf, msg_len,
156 &act_len, AF9015_USB_TIMEOUT);
157 if (ret) {
158 err("recv bulk message failed:%d", ret);
159 ret = -1;
160 goto error_unlock;
161 }
162
163 deb_xfer("<<< ");
164 debug_dump(buf, act_len, deb_xfer);
165
166 /* check status */
167 if (buf[1]) {
168 err("command failed:%d", buf[1]);
169 ret = -1;
170 goto error_unlock;
171 }
172
173 /* read request, copy returned data to return buf */
174 if (!write)
175 memcpy(req->data, &buf[ACK_HDR_LEN], req->data_len);
176
177 error_unlock:
178 exit_unlock:
179 mutex_unlock(&af9015_usb_mutex);
180
181 return ret;
182 }
183
184 static int af9015_ctrl_msg(struct dvb_usb_device *d, struct req_t *req)
185 {
186 return af9015_rw_udev(d->udev, req);
187 }
188
189 static int af9015_write_regs(struct dvb_usb_device *d, u16 addr, u8 *val,
190 u8 len)
191 {
192 struct req_t req = {WRITE_MEMORY, AF9015_I2C_DEMOD, addr, 0, 0, len,
193 val};
194 return af9015_ctrl_msg(d, &req);
195 }
196
197 static int af9015_write_reg(struct dvb_usb_device *d, u16 addr, u8 val)
198 {
199 return af9015_write_regs(d, addr, &val, 1);
200 }
201
202 static int af9015_read_regs(struct dvb_usb_device *d, u16 addr, u8 *val, u8 len)
203 {
204 struct req_t req = {READ_MEMORY, AF9015_I2C_DEMOD, addr, 0, 0, len,
205 val};
206 return af9015_ctrl_msg(d, &req);
207 }
208
209 static int af9015_read_reg(struct dvb_usb_device *d, u16 addr, u8 *val)
210 {
211 return af9015_read_regs(d, addr, val, 1);
212 }
213
214 static int af9015_write_reg_i2c(struct dvb_usb_device *d, u8 addr, u16 reg,
215 u8 val)
216 {
217 struct req_t req = {WRITE_I2C, addr, reg, 1, 1, 1, &val};
218
219 if (addr == af9015_af9013_config[0].i2c_addr ||
220 addr == af9015_af9013_config[1].i2c_addr)
221 req.addr_len = 3;
222
223 return af9015_ctrl_msg(d, &req);
224 }
225
226 static int af9015_read_reg_i2c(struct dvb_usb_device *d, u8 addr, u16 reg,
227 u8 *val)
228 {
229 struct req_t req = {READ_I2C, addr, reg, 0, 1, 1, val};
230
231 if (addr == af9015_af9013_config[0].i2c_addr ||
232 addr == af9015_af9013_config[1].i2c_addr)
233 req.addr_len = 3;
234
235 return af9015_ctrl_msg(d, &req);
236 }
237
238 static int af9015_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
239 int num)
240 {
241 struct dvb_usb_device *d = i2c_get_adapdata(adap);
242 int ret = 0, i = 0;
243 u16 addr;
244 u8 uninitialized_var(mbox), addr_len;
245 struct req_t req;
246
247 /* TODO: implement bus lock
248
249 The bus lock is needed because there is two tuners both using same I2C-address.
250 Due to that the only way to select correct tuner is use demodulator I2C-gate.
251
252 ................................................
253 . AF9015 includes integrated AF9013 demodulator.
254 . ____________ ____________ . ____________
255 .| uC | | demod | . | tuner |
256 .|------------| |------------| . |------------|
257 .| AF9015 | | AF9013/5 | . | MXL5003 |
258 .| |--+----I2C-------|-----/ -----|-.-----I2C-------| |
259 .| | | | addr 0x38 | . | addr 0xc6 |
260 .|____________| | |____________| . |____________|
261 .................|..............................
262 | ____________ ____________
263 | | demod | | tuner |
264 | |------------| |------------|
265 | | AF9013 | | MXL5003 |
266 +----I2C-------|-----/ -----|-------I2C-------| |
267 | addr 0x3a | | addr 0xc6 |
268 |____________| |____________|
269 */
270 if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
271 return -EAGAIN;
272
273 while (i < num) {
274 if (msg[i].addr == af9015_af9013_config[0].i2c_addr ||
275 msg[i].addr == af9015_af9013_config[1].i2c_addr) {
276 addr = msg[i].buf[0] << 8;
277 addr += msg[i].buf[1];
278 mbox = msg[i].buf[2];
279 addr_len = 3;
280 } else {
281 addr = msg[i].buf[0];
282 addr_len = 1;
283 /* mbox is don't care in that case */
284 }
285
286 if (num > i + 1 && (msg[i+1].flags & I2C_M_RD)) {
287 if (msg[i].len > 3 || msg[i+1].len > 61) {
288 ret = -EOPNOTSUPP;
289 goto error;
290 }
291 if (msg[i].addr == af9015_af9013_config[0].i2c_addr)
292 req.cmd = READ_MEMORY;
293 else
294 req.cmd = READ_I2C;
295 req.i2c_addr = msg[i].addr;
296 req.addr = addr;
297 req.mbox = mbox;
298 req.addr_len = addr_len;
299 req.data_len = msg[i+1].len;
300 req.data = &msg[i+1].buf[0];
301 ret = af9015_ctrl_msg(d, &req);
302 i += 2;
303 } else if (msg[i].flags & I2C_M_RD) {
304 if (msg[i].len > 61) {
305 ret = -EOPNOTSUPP;
306 goto error;
307 }
308 if (msg[i].addr ==
309 af9015_af9013_config[0].i2c_addr) {
310 ret = -EINVAL;
311 goto error;
312 }
313 req.cmd = READ_I2C;
314 req.i2c_addr = msg[i].addr;
315 req.addr = addr;
316 req.mbox = mbox;
317 req.addr_len = addr_len;
318 req.data_len = msg[i].len;
319 req.data = &msg[i].buf[0];
320 ret = af9015_ctrl_msg(d, &req);
321 i += 1;
322 } else {
323 if (msg[i].len > 21) {
324 ret = -EOPNOTSUPP;
325 goto error;
326 }
327 if (msg[i].addr == af9015_af9013_config[0].i2c_addr)
328 req.cmd = WRITE_MEMORY;
329 else
330 req.cmd = WRITE_I2C;
331 req.i2c_addr = msg[i].addr;
332 req.addr = addr;
333 req.mbox = mbox;
334 req.addr_len = addr_len;
335 req.data_len = msg[i].len-addr_len;
336 req.data = &msg[i].buf[addr_len];
337 ret = af9015_ctrl_msg(d, &req);
338 i += 1;
339 }
340 if (ret)
341 goto error;
342
343 }
344 ret = i;
345
346 error:
347 mutex_unlock(&d->i2c_mutex);
348
349 return ret;
350 }
351
352 static u32 af9015_i2c_func(struct i2c_adapter *adapter)
353 {
354 return I2C_FUNC_I2C;
355 }
356
357 static struct i2c_algorithm af9015_i2c_algo = {
358 .master_xfer = af9015_i2c_xfer,
359 .functionality = af9015_i2c_func,
360 };
361
362 static int af9015_do_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit, u8 op)
363 {
364 int ret;
365 u8 val, mask = 0x01;
366
367 ret = af9015_read_reg(d, addr, &val);
368 if (ret)
369 return ret;
370
371 mask <<= bit;
372 if (op) {
373 /* set bit */
374 val |= mask;
375 } else {
376 /* clear bit */
377 mask ^= 0xff;
378 val &= mask;
379 }
380
381 return af9015_write_reg(d, addr, val);
382 }
383
384 static int af9015_set_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit)
385 {
386 return af9015_do_reg_bit(d, addr, bit, 1);
387 }
388
389 static int af9015_clear_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit)
390 {
391 return af9015_do_reg_bit(d, addr, bit, 0);
392 }
393
394 static int af9015_init_endpoint(struct dvb_usb_device *d)
395 {
396 int ret;
397 u16 frame_size;
398 u8 packet_size;
399 deb_info("%s: USB speed:%d\n", __func__, d->udev->speed);
400
401 /* Windows driver uses packet count 21 for USB1.1 and 348 for USB2.0.
402 We use smaller - about 1/4 from the original, 5 and 87. */
403 #define TS_PACKET_SIZE 188
404
405 #define TS_USB20_PACKET_COUNT 87
406 #define TS_USB20_FRAME_SIZE (TS_PACKET_SIZE*TS_USB20_PACKET_COUNT)
407
408 #define TS_USB11_PACKET_COUNT 5
409 #define TS_USB11_FRAME_SIZE (TS_PACKET_SIZE*TS_USB11_PACKET_COUNT)
410
411 #define TS_USB20_MAX_PACKET_SIZE 512
412 #define TS_USB11_MAX_PACKET_SIZE 64
413
414 if (d->udev->speed == USB_SPEED_FULL) {
415 frame_size = TS_USB11_FRAME_SIZE/4;
416 packet_size = TS_USB11_MAX_PACKET_SIZE/4;
417 } else {
418 frame_size = TS_USB20_FRAME_SIZE/4;
419 packet_size = TS_USB20_MAX_PACKET_SIZE/4;
420 }
421
422 ret = af9015_set_reg_bit(d, 0xd507, 2); /* assert EP4 reset */
423 if (ret)
424 goto error;
425 ret = af9015_set_reg_bit(d, 0xd50b, 1); /* assert EP5 reset */
426 if (ret)
427 goto error;
428 ret = af9015_clear_reg_bit(d, 0xdd11, 5); /* disable EP4 */
429 if (ret)
430 goto error;
431 ret = af9015_clear_reg_bit(d, 0xdd11, 6); /* disable EP5 */
432 if (ret)
433 goto error;
434 ret = af9015_set_reg_bit(d, 0xdd11, 5); /* enable EP4 */
435 if (ret)
436 goto error;
437 if (af9015_config.dual_mode) {
438 ret = af9015_set_reg_bit(d, 0xdd11, 6); /* enable EP5 */
439 if (ret)
440 goto error;
441 }
442 ret = af9015_clear_reg_bit(d, 0xdd13, 5); /* disable EP4 NAK */
443 if (ret)
444 goto error;
445 if (af9015_config.dual_mode) {
446 ret = af9015_clear_reg_bit(d, 0xdd13, 6); /* disable EP5 NAK */
447 if (ret)
448 goto error;
449 }
450 /* EP4 xfer length */
451 ret = af9015_write_reg(d, 0xdd88, frame_size & 0xff);
452 if (ret)
453 goto error;
454 ret = af9015_write_reg(d, 0xdd89, frame_size >> 8);
455 if (ret)
456 goto error;
457 /* EP5 xfer length */
458 ret = af9015_write_reg(d, 0xdd8a, frame_size & 0xff);
459 if (ret)
460 goto error;
461 ret = af9015_write_reg(d, 0xdd8b, frame_size >> 8);
462 if (ret)
463 goto error;
464 ret = af9015_write_reg(d, 0xdd0c, packet_size); /* EP4 packet size */
465 if (ret)
466 goto error;
467 ret = af9015_write_reg(d, 0xdd0d, packet_size); /* EP5 packet size */
468 if (ret)
469 goto error;
470 ret = af9015_clear_reg_bit(d, 0xd507, 2); /* negate EP4 reset */
471 if (ret)
472 goto error;
473 if (af9015_config.dual_mode) {
474 ret = af9015_clear_reg_bit(d, 0xd50b, 1); /* negate EP5 reset */
475 if (ret)
476 goto error;
477 }
478
479 /* enable / disable mp2if2 */
480 if (af9015_config.dual_mode)
481 ret = af9015_set_reg_bit(d, 0xd50b, 0);
482 else
483 ret = af9015_clear_reg_bit(d, 0xd50b, 0);
484
485 error:
486 if (ret)
487 err("endpoint init failed:%d", ret);
488 return ret;
489 }
490
491 static int af9015_copy_firmware(struct dvb_usb_device *d)
492 {
493 int ret;
494 u8 fw_params[4];
495 u8 val, i;
496 struct req_t req = {COPY_FIRMWARE, 0, 0x5100, 0, 0, sizeof(fw_params),
497 fw_params };
498 deb_info("%s:\n", __func__);
499
500 fw_params[0] = af9015_config.firmware_size >> 8;
501 fw_params[1] = af9015_config.firmware_size & 0xff;
502 fw_params[2] = af9015_config.firmware_checksum >> 8;
503 fw_params[3] = af9015_config.firmware_checksum & 0xff;
504
505 /* wait 2nd demodulator ready */
506 msleep(100);
507
508 ret = af9015_read_reg_i2c(d,
509 af9015_af9013_config[1].i2c_addr, 0x98be, &val);
510 if (ret)
511 goto error;
512 else
513 deb_info("%s: firmware status:%02x\n", __func__, val);
514
515 if (val == 0x0c) /* fw is running, no need for download */
516 goto exit;
517
518 /* set I2C master clock to fast (to speed up firmware copy) */
519 ret = af9015_write_reg(d, 0xd416, 0x04); /* 0x04 * 400ns */
520 if (ret)
521 goto error;
522
523 msleep(50);
524
525 /* copy firmware */
526 ret = af9015_ctrl_msg(d, &req);
527 if (ret)
528 err("firmware copy cmd failed:%d", ret);
529 deb_info("%s: firmware copy done\n", __func__);
530
531 /* set I2C master clock back to normal */
532 ret = af9015_write_reg(d, 0xd416, 0x14); /* 0x14 * 400ns */
533 if (ret)
534 goto error;
535
536 /* request boot firmware */
537 ret = af9015_write_reg_i2c(d, af9015_af9013_config[1].i2c_addr,
538 0xe205, 1);
539 deb_info("%s: firmware boot cmd status:%d\n", __func__, ret);
540 if (ret)
541 goto error;
542
543 for (i = 0; i < 15; i++) {
544 msleep(100);
545
546 /* check firmware status */
547 ret = af9015_read_reg_i2c(d,
548 af9015_af9013_config[1].i2c_addr, 0x98be, &val);
549 deb_info("%s: firmware status cmd status:%d fw status:%02x\n",
550 __func__, ret, val);
551 if (ret)
552 goto error;
553
554 if (val == 0x0c || val == 0x04) /* success or fail */
555 break;
556 }
557
558 if (val == 0x04) {
559 err("firmware did not run");
560 ret = -1;
561 } else if (val != 0x0c) {
562 err("firmware boot timeout");
563 ret = -1;
564 }
565
566 error:
567 exit:
568 return ret;
569 }
570
571 /* hash (and dump) eeprom */
572 static int af9015_eeprom_hash(struct usb_device *udev)
573 {
574 static const unsigned int eeprom_size = 256;
575 unsigned int reg;
576 int ret;
577 u8 val, *eeprom;
578 struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, &val};
579
580 eeprom = kmalloc(eeprom_size, GFP_KERNEL);
581 if (eeprom == NULL)
582 return -ENOMEM;
583
584 for (reg = 0; reg < eeprom_size; reg++) {
585 req.addr = reg;
586 ret = af9015_rw_udev(udev, &req);
587 if (ret)
588 goto free;
589 eeprom[reg] = val;
590 }
591
592 if (dvb_usb_af9015_debug & 0x01)
593 print_hex_dump_bytes("", DUMP_PREFIX_OFFSET, eeprom,
594 eeprom_size);
595
596 BUG_ON(eeprom_size % 4);
597
598 af9015_config.eeprom_sum = 0;
599 for (reg = 0; reg < eeprom_size / sizeof(u32); reg++) {
600 af9015_config.eeprom_sum *= GOLDEN_RATIO_PRIME_32;
601 af9015_config.eeprom_sum += le32_to_cpu(((u32 *)eeprom)[reg]);
602 }
603
604 deb_info("%s: eeprom sum=%.8x\n", __func__, af9015_config.eeprom_sum);
605
606 ret = 0;
607 free:
608 kfree(eeprom);
609 return ret;
610 }
611
612 static int af9015_init(struct dvb_usb_device *d)
613 {
614 int ret;
615 deb_info("%s:\n", __func__);
616
617 /* init RC canary */
618 ret = af9015_write_reg(d, 0x98e9, 0xff);
619 if (ret)
620 goto error;
621
622 ret = af9015_init_endpoint(d);
623 if (ret)
624 goto error;
625
626 error:
627 return ret;
628 }
629
630 static int af9015_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff)
631 {
632 int ret;
633 deb_info("%s: onoff:%d\n", __func__, onoff);
634
635 if (onoff)
636 ret = af9015_set_reg_bit(adap->dev, 0xd503, 0);
637 else
638 ret = af9015_clear_reg_bit(adap->dev, 0xd503, 0);
639
640 return ret;
641 }
642
643 static int af9015_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid,
644 int onoff)
645 {
646 int ret;
647 u8 idx;
648
649 deb_info("%s: set pid filter, index %d, pid %x, onoff %d\n",
650 __func__, index, pid, onoff);
651
652 ret = af9015_write_reg(adap->dev, 0xd505, (pid & 0xff));
653 if (ret)
654 goto error;
655
656 ret = af9015_write_reg(adap->dev, 0xd506, (pid >> 8));
657 if (ret)
658 goto error;
659
660 idx = ((index & 0x1f) | (1 << 5));
661 ret = af9015_write_reg(adap->dev, 0xd504, idx);
662
663 error:
664 return ret;
665 }
666
667 static int af9015_download_firmware(struct usb_device *udev,
668 const struct firmware *fw)
669 {
670 int i, len, remaining, ret;
671 struct req_t req = {DOWNLOAD_FIRMWARE, 0, 0, 0, 0, 0, NULL};
672 u16 checksum = 0;
673
674 deb_info("%s:\n", __func__);
675
676 /* calc checksum */
677 for (i = 0; i < fw->size; i++)
678 checksum += fw->data[i];
679
680 af9015_config.firmware_size = fw->size;
681 af9015_config.firmware_checksum = checksum;
682
683 #define FW_ADDR 0x5100 /* firmware start address */
684 #define LEN_MAX 55 /* max packet size */
685 for (remaining = fw->size; remaining > 0; remaining -= LEN_MAX) {
686 len = remaining;
687 if (len > LEN_MAX)
688 len = LEN_MAX;
689
690 req.data_len = len;
691 req.data = (u8 *) &fw->data[fw->size - remaining];
692 req.addr = FW_ADDR + fw->size - remaining;
693
694 ret = af9015_rw_udev(udev, &req);
695 if (ret) {
696 err("firmware download failed:%d", ret);
697 goto error;
698 }
699 }
700
701 /* firmware loaded, request boot */
702 req.cmd = BOOT;
703 ret = af9015_rw_udev(udev, &req);
704 if (ret) {
705 err("firmware boot failed:%d", ret);
706 goto error;
707 }
708
709 error:
710 return ret;
711 }
712
713 struct af9015_rc_setup {
714 unsigned int id;
715 char *rc_codes;
716 };
717
718 static char *af9015_rc_setup_match(unsigned int id,
719 const struct af9015_rc_setup *table)
720 {
721 for (; table->rc_codes; table++)
722 if (table->id == id)
723 return table->rc_codes;
724 return NULL;
725 }
726
727 static const struct af9015_rc_setup af9015_rc_setup_modparam[] = {
728 { AF9015_REMOTE_A_LINK_DTU_M, RC_MAP_ALINK_DTU_M },
729 { AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3, RC_MAP_MSI_DIGIVOX_II },
730 { AF9015_REMOTE_MYGICTV_U718, RC_MAP_TOTAL_MEDIA_IN_HAND },
731 { AF9015_REMOTE_DIGITTRADE_DVB_T, RC_MAP_DIGITTRADE },
732 { AF9015_REMOTE_AVERMEDIA_KS, RC_MAP_AVERMEDIA_RM_KS },
733 { }
734 };
735
736 static const struct af9015_rc_setup af9015_rc_setup_hashes[] = {
737 { 0xb8feb708, RC_MAP_MSI_DIGIVOX_II },
738 { 0xa3703d00, RC_MAP_ALINK_DTU_M },
739 { 0x9b7dc64e, RC_MAP_TOTAL_MEDIA_IN_HAND }, /* MYGICTV U718 */
740 { 0x5d49e3db, RC_MAP_DIGITTRADE }, /* LC-Power LC-USB-DVBT */
741 { }
742 };
743
744 static const struct af9015_rc_setup af9015_rc_setup_usbids[] = {
745 { (USB_VID_TERRATEC << 16) | USB_PID_TERRATEC_CINERGY_T_STICK_RC,
746 RC_MAP_TERRATEC_SLIM_2 },
747 { (USB_VID_TERRATEC << 16) | USB_PID_TERRATEC_CINERGY_T_STICK_DUAL_RC,
748 RC_MAP_TERRATEC_SLIM },
749 { (USB_VID_VISIONPLUS << 16) | USB_PID_AZUREWAVE_AD_TU700,
750 RC_MAP_AZUREWAVE_AD_TU700 },
751 { (USB_VID_VISIONPLUS << 16) | USB_PID_TINYTWIN,
752 RC_MAP_AZUREWAVE_AD_TU700 },
753 { (USB_VID_MSI_2 << 16) | USB_PID_MSI_DIGI_VOX_MINI_III,
754 RC_MAP_MSI_DIGIVOX_III },
755 { (USB_VID_MSI_2 << 16) | USB_PID_MSI_DIGIVOX_DUO,
756 RC_MAP_MSI_DIGIVOX_III },
757 { (USB_VID_LEADTEK << 16) | USB_PID_WINFAST_DTV_DONGLE_GOLD,
758 RC_MAP_LEADTEK_Y04G0051 },
759 { (USB_VID_LEADTEK << 16) | USB_PID_WINFAST_DTV2000DS,
760 RC_MAP_LEADTEK_Y04G0051 },
761 { (USB_VID_AVERMEDIA << 16) | USB_PID_AVERMEDIA_VOLAR_X,
762 RC_MAP_AVERMEDIA_M135A },
763 { (USB_VID_AFATECH << 16) | USB_PID_TREKSTOR_DVBT,
764 RC_MAP_TREKSTOR },
765 { (USB_VID_KWORLD_2 << 16) | USB_PID_TINYTWIN_2,
766 RC_MAP_DIGITALNOW_TINYTWIN },
767 { (USB_VID_GTEK << 16) | USB_PID_TINYTWIN_3,
768 RC_MAP_DIGITALNOW_TINYTWIN },
769 { (USB_VID_KWORLD_2 << 16) | USB_PID_SVEON_STV22,
770 RC_MAP_MSI_DIGIVOX_III },
771 { }
772 };
773
774 static void af9015_set_remote_config(struct usb_device *udev,
775 struct dvb_usb_device_properties *props)
776 {
777 u16 vid = le16_to_cpu(udev->descriptor.idVendor);
778 u16 pid = le16_to_cpu(udev->descriptor.idProduct);
779
780 /* try to load remote based module param */
781 props->rc.core.rc_codes = af9015_rc_setup_match(
782 dvb_usb_af9015_remote, af9015_rc_setup_modparam);
783
784 /* try to load remote based eeprom hash */
785 if (!props->rc.core.rc_codes)
786 props->rc.core.rc_codes = af9015_rc_setup_match(
787 af9015_config.eeprom_sum, af9015_rc_setup_hashes);
788
789 /* try to load remote based USB ID */
790 if (!props->rc.core.rc_codes)
791 props->rc.core.rc_codes = af9015_rc_setup_match(
792 (vid << 16) + pid, af9015_rc_setup_usbids);
793
794 /* try to load remote based USB iManufacturer string */
795 if (!props->rc.core.rc_codes && vid == USB_VID_AFATECH) {
796 /* Check USB manufacturer and product strings and try
797 to determine correct remote in case of chip vendor
798 reference IDs are used.
799 DO NOT ADD ANYTHING NEW HERE. Use hashes instead. */
800 char manufacturer[10];
801 memset(manufacturer, 0, sizeof(manufacturer));
802 usb_string(udev, udev->descriptor.iManufacturer,
803 manufacturer, sizeof(manufacturer));
804 if (!strcmp("MSI", manufacturer)) {
805 /* iManufacturer 1 MSI
806 iProduct 2 MSI K-VOX */
807 props->rc.core.rc_codes = af9015_rc_setup_match(
808 AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3,
809 af9015_rc_setup_modparam);
810 }
811 }
812
813 /* finally load "empty" just for leaving IR receiver enabled */
814 if (!props->rc.core.rc_codes)
815 props->rc.core.rc_codes = RC_MAP_EMPTY;
816
817 return;
818 }
819
820 static int af9015_read_config(struct usb_device *udev)
821 {
822 int ret;
823 u8 val, i, offset = 0;
824 struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, &val};
825
826 /* IR remote controller */
827 req.addr = AF9015_EEPROM_IR_MODE;
828 /* first message will timeout often due to possible hw bug */
829 for (i = 0; i < 4; i++) {
830 ret = af9015_rw_udev(udev, &req);
831 if (!ret)
832 break;
833 }
834 if (ret)
835 goto error;
836
837 ret = af9015_eeprom_hash(udev);
838 if (ret)
839 goto error;
840
841 deb_info("%s: IR mode=%d\n", __func__, val);
842 for (i = 0; i < af9015_properties_count; i++) {
843 if (val == AF9015_IR_MODE_DISABLED)
844 af9015_properties[i].rc.core.rc_codes = NULL;
845 else
846 af9015_set_remote_config(udev, &af9015_properties[i]);
847 }
848
849 /* TS mode - one or two receivers */
850 req.addr = AF9015_EEPROM_TS_MODE;
851 ret = af9015_rw_udev(udev, &req);
852 if (ret)
853 goto error;
854 af9015_config.dual_mode = val;
855 deb_info("%s: TS mode=%d\n", __func__, af9015_config.dual_mode);
856
857 /* Set adapter0 buffer size according to USB port speed, adapter1 buffer
858 size can be static because it is enabled only USB2.0 */
859 for (i = 0; i < af9015_properties_count; i++) {
860 /* USB1.1 set smaller buffersize and disable 2nd adapter */
861 if (udev->speed == USB_SPEED_FULL) {
862 af9015_properties[i].adapter[0].fe[0].stream.u.bulk.buffersize
863 = TS_USB11_FRAME_SIZE;
864 /* disable 2nd adapter because we don't have
865 PID-filters */
866 af9015_config.dual_mode = 0;
867 } else {
868 af9015_properties[i].adapter[0].fe[0].stream.u.bulk.buffersize
869 = TS_USB20_FRAME_SIZE;
870 }
871 }
872
873 if (af9015_config.dual_mode) {
874 /* read 2nd demodulator I2C address */
875 req.addr = AF9015_EEPROM_DEMOD2_I2C;
876 ret = af9015_rw_udev(udev, &req);
877 if (ret)
878 goto error;
879 af9015_af9013_config[1].i2c_addr = val;
880
881 /* enable 2nd adapter */
882 for (i = 0; i < af9015_properties_count; i++)
883 af9015_properties[i].num_adapters = 2;
884
885 } else {
886 /* disable 2nd adapter */
887 for (i = 0; i < af9015_properties_count; i++)
888 af9015_properties[i].num_adapters = 1;
889 }
890
891 for (i = 0; i < af9015_properties[0].num_adapters; i++) {
892 if (i == 1)
893 offset = AF9015_EEPROM_OFFSET;
894 /* xtal */
895 req.addr = AF9015_EEPROM_XTAL_TYPE1 + offset;
896 ret = af9015_rw_udev(udev, &req);
897 if (ret)
898 goto error;
899 switch (val) {
900 case 0:
901 af9015_af9013_config[i].clock = 28800000;
902 break;
903 case 1:
904 af9015_af9013_config[i].clock = 20480000;
905 break;
906 case 2:
907 af9015_af9013_config[i].clock = 28000000;
908 break;
909 case 3:
910 af9015_af9013_config[i].clock = 25000000;
911 break;
912 };
913 deb_info("%s: [%d] xtal=%d set clock=%d\n", __func__, i,
914 val, af9015_af9013_config[i].clock);
915
916 /* IF frequency */
917 req.addr = AF9015_EEPROM_IF1H + offset;
918 ret = af9015_rw_udev(udev, &req);
919 if (ret)
920 goto error;
921
922 af9015_af9013_config[i].if_frequency = val << 8;
923
924 req.addr = AF9015_EEPROM_IF1L + offset;
925 ret = af9015_rw_udev(udev, &req);
926 if (ret)
927 goto error;
928
929 af9015_af9013_config[i].if_frequency += val;
930 af9015_af9013_config[i].if_frequency *= 1000;
931 deb_info("%s: [%d] IF frequency=%d\n", __func__, i,
932 af9015_af9013_config[0].if_frequency);
933
934 /* MT2060 IF1 */
935 req.addr = AF9015_EEPROM_MT2060_IF1H + offset;
936 ret = af9015_rw_udev(udev, &req);
937 if (ret)
938 goto error;
939 af9015_config.mt2060_if1[i] = val << 8;
940 req.addr = AF9015_EEPROM_MT2060_IF1L + offset;
941 ret = af9015_rw_udev(udev, &req);
942 if (ret)
943 goto error;
944 af9015_config.mt2060_if1[i] += val;
945 deb_info("%s: [%d] MT2060 IF1=%d\n", __func__, i,
946 af9015_config.mt2060_if1[i]);
947
948 /* tuner */
949 req.addr = AF9015_EEPROM_TUNER_ID1 + offset;
950 ret = af9015_rw_udev(udev, &req);
951 if (ret)
952 goto error;
953 switch (val) {
954 case AF9013_TUNER_ENV77H11D5:
955 case AF9013_TUNER_MT2060:
956 case AF9013_TUNER_QT1010:
957 case AF9013_TUNER_UNKNOWN:
958 case AF9013_TUNER_MT2060_2:
959 case AF9013_TUNER_TDA18271:
960 case AF9013_TUNER_QT1010A:
961 case AF9013_TUNER_TDA18218:
962 af9015_af9013_config[i].spec_inv = 1;
963 break;
964 case AF9013_TUNER_MXL5003D:
965 case AF9013_TUNER_MXL5005D:
966 case AF9013_TUNER_MXL5005R:
967 case AF9013_TUNER_MXL5007T:
968 af9015_af9013_config[i].spec_inv = 0;
969 break;
970 case AF9013_TUNER_MC44S803:
971 af9015_af9013_config[i].gpio[1] = AF9013_GPIO_LO;
972 af9015_af9013_config[i].spec_inv = 1;
973 break;
974 default:
975 warn("tuner id=%d not supported, please report!", val);
976 return -ENODEV;
977 };
978
979 af9015_af9013_config[i].tuner = val;
980 deb_info("%s: [%d] tuner id=%d\n", __func__, i, val);
981 }
982
983 error:
984 if (ret)
985 err("eeprom read failed=%d", ret);
986
987 /* AverMedia AVerTV Volar Black HD (A850) device have bad EEPROM
988 content :-( Override some wrong values here. Ditto for the
989 AVerTV Red HD+ (A850T) device. */
990 if (le16_to_cpu(udev->descriptor.idVendor) == USB_VID_AVERMEDIA &&
991 ((le16_to_cpu(udev->descriptor.idProduct) ==
992 USB_PID_AVERMEDIA_A850) ||
993 (le16_to_cpu(udev->descriptor.idProduct) ==
994 USB_PID_AVERMEDIA_A850T))) {
995 deb_info("%s: AverMedia A850: overriding config\n", __func__);
996 /* disable dual mode */
997 af9015_config.dual_mode = 0;
998 /* disable 2nd adapter */
999 for (i = 0; i < af9015_properties_count; i++)
1000 af9015_properties[i].num_adapters = 1;
1001
1002 /* set correct IF */
1003 af9015_af9013_config[0].if_frequency = 4570000;
1004 }
1005
1006 return ret;
1007 }
1008
1009 static int af9015_identify_state(struct usb_device *udev,
1010 struct dvb_usb_device_properties *props,
1011 struct dvb_usb_device_description **desc,
1012 int *cold)
1013 {
1014 int ret;
1015 u8 reply;
1016 struct req_t req = {GET_CONFIG, 0, 0, 0, 0, 1, &reply};
1017
1018 ret = af9015_rw_udev(udev, &req);
1019 if (ret)
1020 return ret;
1021
1022 deb_info("%s: reply:%02x\n", __func__, reply);
1023 if (reply == 0x02)
1024 *cold = 0;
1025 else
1026 *cold = 1;
1027
1028 return ret;
1029 }
1030
1031 static int af9015_rc_query(struct dvb_usb_device *d)
1032 {
1033 struct af9015_state *priv = d->priv;
1034 int ret;
1035 u8 buf[17];
1036
1037 /* read registers needed to detect remote controller code */
1038 ret = af9015_read_regs(d, 0x98d9, buf, sizeof(buf));
1039 if (ret)
1040 goto error;
1041
1042 /* If any of these are non-zero, assume invalid data */
1043 if (buf[1] || buf[2] || buf[3])
1044 return ret;
1045
1046 /* Check for repeat of previous code */
1047 if ((priv->rc_repeat != buf[6] || buf[0]) &&
1048 !memcmp(&buf[12], priv->rc_last, 4)) {
1049 deb_rc("%s: key repeated\n", __func__);
1050 rc_keydown(d->rc_dev, priv->rc_keycode, 0);
1051 priv->rc_repeat = buf[6];
1052 return ret;
1053 }
1054
1055 /* Only process key if canary killed */
1056 if (buf[16] != 0xff && buf[0] != 0x01) {
1057 deb_rc("%s: key pressed %02x %02x %02x %02x\n", __func__,
1058 buf[12], buf[13], buf[14], buf[15]);
1059
1060 /* Reset the canary */
1061 ret = af9015_write_reg(d, 0x98e9, 0xff);
1062 if (ret)
1063 goto error;
1064
1065 /* Remember this key */
1066 memcpy(priv->rc_last, &buf[12], 4);
1067 if (buf[14] == (u8) ~buf[15]) {
1068 if (buf[12] == (u8) ~buf[13]) {
1069 /* NEC */
1070 priv->rc_keycode = buf[12] << 8 | buf[14];
1071 } else {
1072 /* NEC extended*/
1073 priv->rc_keycode = buf[12] << 16 |
1074 buf[13] << 8 | buf[14];
1075 }
1076 } else {
1077 /* 32 bit NEC */
1078 priv->rc_keycode = buf[12] << 24 | buf[13] << 16 |
1079 buf[14] << 8 | buf[15];
1080 }
1081 rc_keydown(d->rc_dev, priv->rc_keycode, 0);
1082 } else {
1083 deb_rc("%s: no key press\n", __func__);
1084 /* Invalidate last keypress */
1085 /* Not really needed, but helps with debug */
1086 priv->rc_last[2] = priv->rc_last[3];
1087 }
1088
1089 priv->rc_repeat = buf[6];
1090
1091 error:
1092 if (ret)
1093 err("%s: failed:%d", __func__, ret);
1094
1095 return ret;
1096 }
1097
1098 /* override demod callbacks for resource locking */
1099 static int af9015_af9013_set_frontend(struct dvb_frontend *fe)
1100 {
1101 int ret;
1102 struct dvb_usb_adapter *adap = fe->dvb->priv;
1103 struct af9015_state *priv = adap->dev->priv;
1104
1105 if (mutex_lock_interruptible(&adap->dev->usb_mutex))
1106 return -EAGAIN;
1107
1108 ret = priv->set_frontend[adap->id](fe);
1109
1110 mutex_unlock(&adap->dev->usb_mutex);
1111
1112 return ret;
1113 }
1114
1115 /* override demod callbacks for resource locking */
1116 static int af9015_af9013_read_status(struct dvb_frontend *fe,
1117 fe_status_t *status)
1118 {
1119 int ret;
1120 struct dvb_usb_adapter *adap = fe->dvb->priv;
1121 struct af9015_state *priv = adap->dev->priv;
1122
1123 if (mutex_lock_interruptible(&adap->dev->usb_mutex))
1124 return -EAGAIN;
1125
1126 ret = priv->read_status[adap->id](fe, status);
1127
1128 mutex_unlock(&adap->dev->usb_mutex);
1129
1130 return ret;
1131 }
1132
1133 /* override demod callbacks for resource locking */
1134 static int af9015_af9013_init(struct dvb_frontend *fe)
1135 {
1136 int ret;
1137 struct dvb_usb_adapter *adap = fe->dvb->priv;
1138 struct af9015_state *priv = adap->dev->priv;
1139
1140 if (mutex_lock_interruptible(&adap->dev->usb_mutex))
1141 return -EAGAIN;
1142
1143 ret = priv->init[adap->id](fe);
1144
1145 mutex_unlock(&adap->dev->usb_mutex);
1146
1147 return ret;
1148 }
1149
1150 /* override demod callbacks for resource locking */
1151 static int af9015_af9013_sleep(struct dvb_frontend *fe)
1152 {
1153 int ret;
1154 struct dvb_usb_adapter *adap = fe->dvb->priv;
1155 struct af9015_state *priv = adap->dev->priv;
1156
1157 if (mutex_lock_interruptible(&adap->dev->usb_mutex))
1158 return -EAGAIN;
1159
1160 ret = priv->sleep[adap->id](fe);
1161
1162 mutex_unlock(&adap->dev->usb_mutex);
1163
1164 return ret;
1165 }
1166
1167 static int af9015_af9013_frontend_attach(struct dvb_usb_adapter *adap)
1168 {
1169 int ret;
1170 struct af9015_state *state = adap->dev->priv;
1171
1172 if (adap->id == 1) {
1173 /* copy firmware to 2nd demodulator */
1174 if (af9015_config.dual_mode) {
1175 ret = af9015_copy_firmware(adap->dev);
1176 if (ret) {
1177 err("firmware copy to 2nd frontend " \
1178 "failed, will disable it");
1179 af9015_config.dual_mode = 0;
1180 return -ENODEV;
1181 }
1182 } else {
1183 return -ENODEV;
1184 }
1185 }
1186
1187 /* attach demodulator */
1188 adap->fe_adap[0].fe = dvb_attach(af9013_attach, &af9015_af9013_config[adap->id],
1189 &adap->dev->i2c_adap);
1190
1191 /*
1192 * AF9015 firmware does not like if it gets interrupted by I2C adapter
1193 * request on some critical phases. During normal operation I2C adapter
1194 * is used only 2nd demodulator and tuner on dual tuner devices.
1195 * Override demodulator callbacks and use mutex for limit access to
1196 * those "critical" paths to keep AF9015 happy.
1197 * Note: we abuse unused usb_mutex here.
1198 */
1199 if (adap->fe_adap[0].fe) {
1200 state->set_frontend[adap->id] =
1201 adap->fe_adap[0].fe->ops.set_frontend;
1202 adap->fe_adap[0].fe->ops.set_frontend =
1203 af9015_af9013_set_frontend;
1204
1205 state->read_status[adap->id] =
1206 adap->fe_adap[0].fe->ops.read_status;
1207 adap->fe_adap[0].fe->ops.read_status =
1208 af9015_af9013_read_status;
1209
1210 state->init[adap->id] = adap->fe_adap[0].fe->ops.init;
1211 adap->fe_adap[0].fe->ops.init = af9015_af9013_init;
1212
1213 state->sleep[adap->id] = adap->fe_adap[0].fe->ops.sleep;
1214 adap->fe_adap[0].fe->ops.sleep = af9015_af9013_sleep;
1215 }
1216
1217 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1218 }
1219
1220 static struct mt2060_config af9015_mt2060_config = {
1221 .i2c_address = 0xc0,
1222 .clock_out = 0,
1223 };
1224
1225 static struct qt1010_config af9015_qt1010_config = {
1226 .i2c_address = 0xc4,
1227 };
1228
1229 static struct tda18271_config af9015_tda18271_config = {
1230 .gate = TDA18271_GATE_DIGITAL,
1231 .small_i2c = TDA18271_16_BYTE_CHUNK_INIT,
1232 };
1233
1234 static struct mxl5005s_config af9015_mxl5003_config = {
1235 .i2c_address = 0xc6,
1236 .if_freq = IF_FREQ_4570000HZ,
1237 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
1238 .agc_mode = MXL_SINGLE_AGC,
1239 .tracking_filter = MXL_TF_DEFAULT,
1240 .rssi_enable = MXL_RSSI_ENABLE,
1241 .cap_select = MXL_CAP_SEL_ENABLE,
1242 .div_out = MXL_DIV_OUT_4,
1243 .clock_out = MXL_CLOCK_OUT_DISABLE,
1244 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
1245 .top = MXL5005S_TOP_25P2,
1246 .mod_mode = MXL_DIGITAL_MODE,
1247 .if_mode = MXL_ZERO_IF,
1248 .AgcMasterByte = 0x00,
1249 };
1250
1251 static struct mxl5005s_config af9015_mxl5005_config = {
1252 .i2c_address = 0xc6,
1253 .if_freq = IF_FREQ_4570000HZ,
1254 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
1255 .agc_mode = MXL_SINGLE_AGC,
1256 .tracking_filter = MXL_TF_OFF,
1257 .rssi_enable = MXL_RSSI_ENABLE,
1258 .cap_select = MXL_CAP_SEL_ENABLE,
1259 .div_out = MXL_DIV_OUT_4,
1260 .clock_out = MXL_CLOCK_OUT_DISABLE,
1261 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
1262 .top = MXL5005S_TOP_25P2,
1263 .mod_mode = MXL_DIGITAL_MODE,
1264 .if_mode = MXL_ZERO_IF,
1265 .AgcMasterByte = 0x00,
1266 };
1267
1268 static struct mc44s803_config af9015_mc44s803_config = {
1269 .i2c_address = 0xc0,
1270 .dig_out = 1,
1271 };
1272
1273 static struct tda18218_config af9015_tda18218_config = {
1274 .i2c_address = 0xc0,
1275 .i2c_wr_max = 21, /* max wr bytes AF9015 I2C adap can handle at once */
1276 };
1277
1278 static struct mxl5007t_config af9015_mxl5007t_config = {
1279 .xtal_freq_hz = MxL_XTAL_24_MHZ,
1280 .if_freq_hz = MxL_IF_4_57_MHZ,
1281 };
1282
1283 static int af9015_tuner_attach(struct dvb_usb_adapter *adap)
1284 {
1285 int ret;
1286 deb_info("%s:\n", __func__);
1287
1288 switch (af9015_af9013_config[adap->id].tuner) {
1289 case AF9013_TUNER_MT2060:
1290 case AF9013_TUNER_MT2060_2:
1291 ret = dvb_attach(mt2060_attach, adap->fe_adap[0].fe, &adap->dev->i2c_adap,
1292 &af9015_mt2060_config,
1293 af9015_config.mt2060_if1[adap->id])
1294 == NULL ? -ENODEV : 0;
1295 break;
1296 case AF9013_TUNER_QT1010:
1297 case AF9013_TUNER_QT1010A:
1298 ret = dvb_attach(qt1010_attach, adap->fe_adap[0].fe, &adap->dev->i2c_adap,
1299 &af9015_qt1010_config) == NULL ? -ENODEV : 0;
1300 break;
1301 case AF9013_TUNER_TDA18271:
1302 ret = dvb_attach(tda18271_attach, adap->fe_adap[0].fe, 0xc0,
1303 &adap->dev->i2c_adap,
1304 &af9015_tda18271_config) == NULL ? -ENODEV : 0;
1305 break;
1306 case AF9013_TUNER_TDA18218:
1307 ret = dvb_attach(tda18218_attach, adap->fe_adap[0].fe,
1308 &adap->dev->i2c_adap,
1309 &af9015_tda18218_config) == NULL ? -ENODEV : 0;
1310 break;
1311 case AF9013_TUNER_MXL5003D:
1312 ret = dvb_attach(mxl5005s_attach, adap->fe_adap[0].fe,
1313 &adap->dev->i2c_adap,
1314 &af9015_mxl5003_config) == NULL ? -ENODEV : 0;
1315 break;
1316 case AF9013_TUNER_MXL5005D:
1317 case AF9013_TUNER_MXL5005R:
1318 ret = dvb_attach(mxl5005s_attach, adap->fe_adap[0].fe,
1319 &adap->dev->i2c_adap,
1320 &af9015_mxl5005_config) == NULL ? -ENODEV : 0;
1321 break;
1322 case AF9013_TUNER_ENV77H11D5:
1323 ret = dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0xc0,
1324 &adap->dev->i2c_adap,
1325 DVB_PLL_TDA665X) == NULL ? -ENODEV : 0;
1326 break;
1327 case AF9013_TUNER_MC44S803:
1328 ret = dvb_attach(mc44s803_attach, adap->fe_adap[0].fe,
1329 &adap->dev->i2c_adap,
1330 &af9015_mc44s803_config) == NULL ? -ENODEV : 0;
1331 break;
1332 case AF9013_TUNER_MXL5007T:
1333 ret = dvb_attach(mxl5007t_attach, adap->fe_adap[0].fe,
1334 &adap->dev->i2c_adap,
1335 0xc0, &af9015_mxl5007t_config) == NULL ? -ENODEV : 0;
1336 break;
1337 case AF9013_TUNER_UNKNOWN:
1338 default:
1339 ret = -ENODEV;
1340 err("Unknown tuner id:%d",
1341 af9015_af9013_config[adap->id].tuner);
1342 }
1343 return ret;
1344 }
1345
1346 enum af9015_usb_table_entry {
1347 AFATECH_9015,
1348 AFATECH_9016,
1349 WINFAST_DTV_GOLD,
1350 PINNACLE_PCTV_71E,
1351 KWORLD_PLUSTV_399U,
1352 TINYTWIN,
1353 AZUREWAVE_TU700,
1354 TERRATEC_AF9015,
1355 KWORLD_PLUSTV_PC160,
1356 AVERTV_VOLAR_X,
1357 XTENSIONS_380U,
1358 MSI_DIGIVOX_DUO,
1359 AVERTV_VOLAR_X_REV2,
1360 TELESTAR_STARSTICK_2,
1361 AVERMEDIA_A309_USB,
1362 MSI_DIGIVOX_MINI_III,
1363 KWORLD_E396,
1364 KWORLD_E39B,
1365 KWORLD_E395,
1366 TREKSTOR_DVBT,
1367 AVERTV_A850,
1368 AVERTV_A805,
1369 CONCEPTRONIC_CTVDIGRCU,
1370 KWORLD_MC810,
1371 GENIUS_TVGO_DVB_T03,
1372 KWORLD_399U_2,
1373 KWORLD_PC160_T,
1374 SVEON_STV20,
1375 TINYTWIN_2,
1376 WINFAST_DTV2000DS,
1377 KWORLD_UB383_T,
1378 KWORLD_E39A,
1379 AVERMEDIA_A815M,
1380 CINERGY_T_STICK_RC,
1381 CINERGY_T_DUAL_RC,
1382 AVERTV_A850T,
1383 TINYTWIN_3,
1384 SVEON_STV22,
1385 };
1386
1387 static struct usb_device_id af9015_usb_table[] = {
1388 [AFATECH_9015] =
1389 {USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9015_9015)},
1390 [AFATECH_9016] =
1391 {USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9015_9016)},
1392 [WINFAST_DTV_GOLD] =
1393 {USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_GOLD)},
1394 [PINNACLE_PCTV_71E] =
1395 {USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV71E)},
1396 [KWORLD_PLUSTV_399U] =
1397 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_399U)},
1398 [TINYTWIN] = {USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TINYTWIN)},
1399 [AZUREWAVE_TU700] =
1400 {USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_AZUREWAVE_AD_TU700)},
1401 [TERRATEC_AF9015] = {USB_DEVICE(USB_VID_TERRATEC,
1402 USB_PID_TERRATEC_CINERGY_T_USB_XE_REV2)},
1403 [KWORLD_PLUSTV_PC160] =
1404 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_PC160_2T)},
1405 [AVERTV_VOLAR_X] =
1406 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X)},
1407 [XTENSIONS_380U] =
1408 {USB_DEVICE(USB_VID_XTENSIONS, USB_PID_XTENSIONS_XD_380)},
1409 [MSI_DIGIVOX_DUO] =
1410 {USB_DEVICE(USB_VID_MSI_2, USB_PID_MSI_DIGIVOX_DUO)},
1411 [AVERTV_VOLAR_X_REV2] =
1412 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X_2)},
1413 [TELESTAR_STARSTICK_2] =
1414 {USB_DEVICE(USB_VID_TELESTAR, USB_PID_TELESTAR_STARSTICK_2)},
1415 [AVERMEDIA_A309_USB] =
1416 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A309)},
1417 [MSI_DIGIVOX_MINI_III] =
1418 {USB_DEVICE(USB_VID_MSI_2, USB_PID_MSI_DIGI_VOX_MINI_III)},
1419 [KWORLD_E396] = {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U)},
1420 [KWORLD_E39B] = {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_2)},
1421 [KWORLD_E395] = {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_3)},
1422 [TREKSTOR_DVBT] = {USB_DEVICE(USB_VID_AFATECH, USB_PID_TREKSTOR_DVBT)},
1423 [AVERTV_A850] = {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A850)},
1424 [AVERTV_A805] = {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A805)},
1425 [CONCEPTRONIC_CTVDIGRCU] =
1426 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_CONCEPTRONIC_CTVDIGRCU)},
1427 [KWORLD_MC810] = {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_MC810)},
1428 [GENIUS_TVGO_DVB_T03] =
1429 {USB_DEVICE(USB_VID_KYE, USB_PID_GENIUS_TVGO_DVB_T03)},
1430 [KWORLD_399U_2] = {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_399U_2)},
1431 [KWORLD_PC160_T] =
1432 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_PC160_T)},
1433 [SVEON_STV20] = {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV20)},
1434 [TINYTWIN_2] = {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_TINYTWIN_2)},
1435 [WINFAST_DTV2000DS] =
1436 {USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV2000DS)},
1437 [KWORLD_UB383_T] =
1438 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_UB383_T)},
1439 [KWORLD_E39A] =
1440 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_4)},
1441 [AVERMEDIA_A815M] =
1442 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A815M)},
1443 [CINERGY_T_STICK_RC] = {USB_DEVICE(USB_VID_TERRATEC,
1444 USB_PID_TERRATEC_CINERGY_T_STICK_RC)},
1445 [CINERGY_T_DUAL_RC] = {USB_DEVICE(USB_VID_TERRATEC,
1446 USB_PID_TERRATEC_CINERGY_T_STICK_DUAL_RC)},
1447 [AVERTV_A850T] =
1448 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A850T)},
1449 [TINYTWIN_3] = {USB_DEVICE(USB_VID_GTEK, USB_PID_TINYTWIN_3)},
1450 [SVEON_STV22] = {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV22)},
1451 { }
1452 };
1453 MODULE_DEVICE_TABLE(usb, af9015_usb_table);
1454
1455 #define AF9015_RC_INTERVAL 500
1456 static struct dvb_usb_device_properties af9015_properties[] = {
1457 {
1458 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1459
1460 .usb_ctrl = DEVICE_SPECIFIC,
1461 .download_firmware = af9015_download_firmware,
1462 .firmware = "dvb-usb-af9015.fw",
1463 .no_reconnect = 1,
1464
1465 .size_of_priv = sizeof(struct af9015_state),
1466
1467 .num_adapters = 2,
1468 .adapter = {
1469 {
1470 .num_frontends = 1,
1471 .fe = {{
1472 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1473 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1474
1475 .pid_filter_count = 32,
1476 .pid_filter = af9015_pid_filter,
1477 .pid_filter_ctrl = af9015_pid_filter_ctrl,
1478
1479 .frontend_attach =
1480 af9015_af9013_frontend_attach,
1481 .tuner_attach = af9015_tuner_attach,
1482 .stream = {
1483 .type = USB_BULK,
1484 .count = 6,
1485 .endpoint = 0x84,
1486 },
1487 }},
1488 },
1489 {
1490 .num_frontends = 1,
1491 .fe = {{
1492 .frontend_attach =
1493 af9015_af9013_frontend_attach,
1494 .tuner_attach = af9015_tuner_attach,
1495 .stream = {
1496 .type = USB_BULK,
1497 .count = 6,
1498 .endpoint = 0x85,
1499 .u = {
1500 .bulk = {
1501 .buffersize =
1502 TS_USB20_FRAME_SIZE,
1503 }
1504 }
1505 },
1506 }},
1507 }
1508 },
1509
1510 .identify_state = af9015_identify_state,
1511
1512 .rc.core = {
1513 .protocol = RC_TYPE_NEC,
1514 .module_name = "af9015",
1515 .rc_query = af9015_rc_query,
1516 .rc_interval = AF9015_RC_INTERVAL,
1517 .allowed_protos = RC_TYPE_NEC,
1518 },
1519
1520 .i2c_algo = &af9015_i2c_algo,
1521
1522 .num_device_descs = 12, /* check max from dvb-usb.h */
1523 .devices = {
1524 {
1525 .name = "Afatech AF9015 DVB-T USB2.0 stick",
1526 .cold_ids = {
1527 &af9015_usb_table[AFATECH_9015],
1528 &af9015_usb_table[AFATECH_9016],
1529 NULL
1530 },
1531 .warm_ids = {NULL},
1532 },
1533 {
1534 .name = "Leadtek WinFast DTV Dongle Gold",
1535 .cold_ids = {
1536 &af9015_usb_table[WINFAST_DTV_GOLD],
1537 NULL
1538 },
1539 .warm_ids = {NULL},
1540 },
1541 {
1542 .name = "Pinnacle PCTV 71e",
1543 .cold_ids = {
1544 &af9015_usb_table[PINNACLE_PCTV_71E],
1545 NULL
1546 },
1547 .warm_ids = {NULL},
1548 },
1549 {
1550 .name = "KWorld PlusTV Dual DVB-T Stick " \
1551 "(DVB-T 399U)",
1552 .cold_ids = {
1553 &af9015_usb_table[KWORLD_PLUSTV_399U],
1554 &af9015_usb_table[KWORLD_399U_2],
1555 NULL
1556 },
1557 .warm_ids = {NULL},
1558 },
1559 {
1560 .name = "DigitalNow TinyTwin DVB-T Receiver",
1561 .cold_ids = {
1562 &af9015_usb_table[TINYTWIN],
1563 &af9015_usb_table[TINYTWIN_2],
1564 &af9015_usb_table[TINYTWIN_3],
1565 NULL
1566 },
1567 .warm_ids = {NULL},
1568 },
1569 {
1570 .name = "TwinHan AzureWave AD-TU700(704J)",
1571 .cold_ids = {
1572 &af9015_usb_table[AZUREWAVE_TU700],
1573 NULL
1574 },
1575 .warm_ids = {NULL},
1576 },
1577 {
1578 .name = "TerraTec Cinergy T USB XE",
1579 .cold_ids = {
1580 &af9015_usb_table[TERRATEC_AF9015],
1581 NULL
1582 },
1583 .warm_ids = {NULL},
1584 },
1585 {
1586 .name = "KWorld PlusTV Dual DVB-T PCI " \
1587 "(DVB-T PC160-2T)",
1588 .cold_ids = {
1589 &af9015_usb_table[KWORLD_PLUSTV_PC160],
1590 NULL
1591 },
1592 .warm_ids = {NULL},
1593 },
1594 {
1595 .name = "AVerMedia AVerTV DVB-T Volar X",
1596 .cold_ids = {
1597 &af9015_usb_table[AVERTV_VOLAR_X],
1598 NULL
1599 },
1600 .warm_ids = {NULL},
1601 },
1602 {
1603 .name = "TerraTec Cinergy T Stick RC",
1604 .cold_ids = {
1605 &af9015_usb_table[CINERGY_T_STICK_RC],
1606 NULL
1607 },
1608 .warm_ids = {NULL},
1609 },
1610 {
1611 .name = "TerraTec Cinergy T Stick Dual RC",
1612 .cold_ids = {
1613 &af9015_usb_table[CINERGY_T_DUAL_RC],
1614 NULL
1615 },
1616 .warm_ids = {NULL},
1617 },
1618 {
1619 .name = "AverMedia AVerTV Red HD+ (A850T)",
1620 .cold_ids = {
1621 &af9015_usb_table[AVERTV_A850T],
1622 NULL
1623 },
1624 .warm_ids = {NULL},
1625 },
1626 }
1627 }, {
1628 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1629
1630 .usb_ctrl = DEVICE_SPECIFIC,
1631 .download_firmware = af9015_download_firmware,
1632 .firmware = "dvb-usb-af9015.fw",
1633 .no_reconnect = 1,
1634
1635 .size_of_priv = sizeof(struct af9015_state),
1636
1637 .num_adapters = 2,
1638 .adapter = {
1639 {
1640 .num_frontends = 1,
1641 .fe = {{
1642 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1643 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1644
1645 .pid_filter_count = 32,
1646 .pid_filter = af9015_pid_filter,
1647 .pid_filter_ctrl = af9015_pid_filter_ctrl,
1648
1649 .frontend_attach =
1650 af9015_af9013_frontend_attach,
1651 .tuner_attach = af9015_tuner_attach,
1652 .stream = {
1653 .type = USB_BULK,
1654 .count = 6,
1655 .endpoint = 0x84,
1656 },
1657 }},
1658 },
1659 {
1660 .num_frontends = 1,
1661 .fe = {{
1662 .frontend_attach =
1663 af9015_af9013_frontend_attach,
1664 .tuner_attach = af9015_tuner_attach,
1665 .stream = {
1666 .type = USB_BULK,
1667 .count = 6,
1668 .endpoint = 0x85,
1669 .u = {
1670 .bulk = {
1671 .buffersize =
1672 TS_USB20_FRAME_SIZE,
1673 }
1674 }
1675 },
1676 }},
1677 }
1678 },
1679
1680 .identify_state = af9015_identify_state,
1681
1682 .rc.core = {
1683 .protocol = RC_TYPE_NEC,
1684 .module_name = "af9015",
1685 .rc_query = af9015_rc_query,
1686 .rc_interval = AF9015_RC_INTERVAL,
1687 .allowed_protos = RC_TYPE_NEC,
1688 },
1689
1690 .i2c_algo = &af9015_i2c_algo,
1691
1692 .num_device_descs = 10, /* check max from dvb-usb.h */
1693 .devices = {
1694 {
1695 .name = "Xtensions XD-380",
1696 .cold_ids = {
1697 &af9015_usb_table[XTENSIONS_380U],
1698 NULL
1699 },
1700 .warm_ids = {NULL},
1701 },
1702 {
1703 .name = "MSI DIGIVOX Duo",
1704 .cold_ids = {
1705 &af9015_usb_table[MSI_DIGIVOX_DUO],
1706 NULL
1707 },
1708 .warm_ids = {NULL},
1709 },
1710 {
1711 .name = "Fujitsu-Siemens Slim Mobile USB DVB-T",
1712 .cold_ids = {
1713 &af9015_usb_table[AVERTV_VOLAR_X_REV2],
1714 NULL
1715 },
1716 .warm_ids = {NULL},
1717 },
1718 {
1719 .name = "Telestar Starstick 2",
1720 .cold_ids = {
1721 &af9015_usb_table[TELESTAR_STARSTICK_2],
1722 NULL
1723 },
1724 .warm_ids = {NULL},
1725 },
1726 {
1727 .name = "AVerMedia A309",
1728 .cold_ids = {
1729 &af9015_usb_table[AVERMEDIA_A309_USB],
1730 NULL
1731 },
1732 .warm_ids = {NULL},
1733 },
1734 {
1735 .name = "MSI Digi VOX mini III",
1736 .cold_ids = {
1737 &af9015_usb_table[MSI_DIGIVOX_MINI_III],
1738 NULL
1739 },
1740 .warm_ids = {NULL},
1741 },
1742 {
1743 .name = "KWorld USB DVB-T TV Stick II " \
1744 "(VS-DVB-T 395U)",
1745 .cold_ids = {
1746 &af9015_usb_table[KWORLD_E396],
1747 &af9015_usb_table[KWORLD_E39B],
1748 &af9015_usb_table[KWORLD_E395],
1749 &af9015_usb_table[KWORLD_E39A],
1750 NULL
1751 },
1752 .warm_ids = {NULL},
1753 },
1754 {
1755 .name = "TrekStor DVB-T USB Stick",
1756 .cold_ids = {
1757 &af9015_usb_table[TREKSTOR_DVBT],
1758 NULL
1759 },
1760 .warm_ids = {NULL},
1761 },
1762 {
1763 .name = "AverMedia AVerTV Volar Black HD " \
1764 "(A850)",
1765 .cold_ids = {
1766 &af9015_usb_table[AVERTV_A850],
1767 NULL
1768 },
1769 .warm_ids = {NULL},
1770 },
1771 {
1772 .name = "Sveon STV22 Dual USB DVB-T Tuner HDTV",
1773 .cold_ids = {
1774 &af9015_usb_table[SVEON_STV22],
1775 NULL
1776 },
1777 .warm_ids = {NULL},
1778 },
1779 }
1780 }, {
1781 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1782
1783 .usb_ctrl = DEVICE_SPECIFIC,
1784 .download_firmware = af9015_download_firmware,
1785 .firmware = "dvb-usb-af9015.fw",
1786 .no_reconnect = 1,
1787
1788 .size_of_priv = sizeof(struct af9015_state),
1789
1790 .num_adapters = 2,
1791 .adapter = {
1792 {
1793 .num_frontends = 1,
1794 .fe = {{
1795 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1796 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1797
1798 .pid_filter_count = 32,
1799 .pid_filter = af9015_pid_filter,
1800 .pid_filter_ctrl = af9015_pid_filter_ctrl,
1801
1802 .frontend_attach =
1803 af9015_af9013_frontend_attach,
1804 .tuner_attach = af9015_tuner_attach,
1805 .stream = {
1806 .type = USB_BULK,
1807 .count = 6,
1808 .endpoint = 0x84,
1809 },
1810 }},
1811 },
1812 {
1813 .num_frontends = 1,
1814 .fe = {{
1815 .frontend_attach =
1816 af9015_af9013_frontend_attach,
1817 .tuner_attach = af9015_tuner_attach,
1818 .stream = {
1819 .type = USB_BULK,
1820 .count = 6,
1821 .endpoint = 0x85,
1822 .u = {
1823 .bulk = {
1824 .buffersize =
1825 TS_USB20_FRAME_SIZE,
1826 }
1827 }
1828 },
1829 }},
1830 }
1831 },
1832
1833 .identify_state = af9015_identify_state,
1834
1835 .rc.core = {
1836 .protocol = RC_TYPE_NEC,
1837 .module_name = "af9015",
1838 .rc_query = af9015_rc_query,
1839 .rc_interval = AF9015_RC_INTERVAL,
1840 .allowed_protos = RC_TYPE_NEC,
1841 },
1842
1843 .i2c_algo = &af9015_i2c_algo,
1844
1845 .num_device_descs = 9, /* check max from dvb-usb.h */
1846 .devices = {
1847 {
1848 .name = "AverMedia AVerTV Volar GPS 805 (A805)",
1849 .cold_ids = {
1850 &af9015_usb_table[AVERTV_A805],
1851 NULL
1852 },
1853 .warm_ids = {NULL},
1854 },
1855 {
1856 .name = "Conceptronic USB2.0 DVB-T CTVDIGRCU " \
1857 "V3.0",
1858 .cold_ids = {
1859 &af9015_usb_table[CONCEPTRONIC_CTVDIGRCU],
1860 NULL
1861 },
1862 .warm_ids = {NULL},
1863 },
1864 {
1865 .name = "KWorld Digial MC-810",
1866 .cold_ids = {
1867 &af9015_usb_table[KWORLD_MC810],
1868 NULL
1869 },
1870 .warm_ids = {NULL},
1871 },
1872 {
1873 .name = "Genius TVGo DVB-T03",
1874 .cold_ids = {
1875 &af9015_usb_table[GENIUS_TVGO_DVB_T03],
1876 NULL
1877 },
1878 .warm_ids = {NULL},
1879 },
1880 {
1881 .name = "KWorld PlusTV DVB-T PCI Pro Card " \
1882 "(DVB-T PC160-T)",
1883 .cold_ids = {
1884 &af9015_usb_table[KWORLD_PC160_T],
1885 NULL
1886 },
1887 .warm_ids = {NULL},
1888 },
1889 {
1890 .name = "Sveon STV20 Tuner USB DVB-T HDTV",
1891 .cold_ids = {
1892 &af9015_usb_table[SVEON_STV20],
1893 NULL
1894 },
1895 .warm_ids = {NULL},
1896 },
1897 {
1898 .name = "Leadtek WinFast DTV2000DS",
1899 .cold_ids = {
1900 &af9015_usb_table[WINFAST_DTV2000DS],
1901 NULL
1902 },
1903 .warm_ids = {NULL},
1904 },
1905 {
1906 .name = "KWorld USB DVB-T Stick Mobile " \
1907 "(UB383-T)",
1908 .cold_ids = {
1909 &af9015_usb_table[KWORLD_UB383_T],
1910 NULL
1911 },
1912 .warm_ids = {NULL},
1913 },
1914 {
1915 .name = "AverMedia AVerTV Volar M (A815Mac)",
1916 .cold_ids = {
1917 &af9015_usb_table[AVERMEDIA_A815M],
1918 NULL
1919 },
1920 .warm_ids = {NULL},
1921 },
1922 }
1923 },
1924 };
1925
1926 static int af9015_usb_probe(struct usb_interface *intf,
1927 const struct usb_device_id *id)
1928 {
1929 int ret = 0;
1930 struct dvb_usb_device *d = NULL;
1931 struct usb_device *udev = interface_to_usbdev(intf);
1932 u8 i;
1933
1934 deb_info("%s: interface:%d\n", __func__,
1935 intf->cur_altsetting->desc.bInterfaceNumber);
1936
1937 /* interface 0 is used by DVB-T receiver and
1938 interface 1 is for remote controller (HID) */
1939 if (intf->cur_altsetting->desc.bInterfaceNumber == 0) {
1940 ret = af9015_read_config(udev);
1941 if (ret)
1942 return ret;
1943
1944 for (i = 0; i < af9015_properties_count; i++) {
1945 ret = dvb_usb_device_init(intf, &af9015_properties[i],
1946 THIS_MODULE, &d, adapter_nr);
1947 if (!ret)
1948 break;
1949 if (ret != -ENODEV)
1950 return ret;
1951 }
1952 if (ret)
1953 return ret;
1954
1955 if (d)
1956 ret = af9015_init(d);
1957 }
1958
1959 return ret;
1960 }
1961
1962 /* usb specific object needed to register this driver with the usb subsystem */
1963 static struct usb_driver af9015_usb_driver = {
1964 .name = "dvb_usb_af9015",
1965 .probe = af9015_usb_probe,
1966 .disconnect = dvb_usb_device_exit,
1967 .id_table = af9015_usb_table,
1968 };
1969
1970 module_usb_driver(af9015_usb_driver);
1971
1972 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1973 MODULE_DESCRIPTION("Driver for Afatech AF9015 DVB-T");
1974 MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.07791 seconds and 5 git commands to generate.