?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
RT-AC56 3.0.0.4.374.37 core
[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / drivers / media / dvb / dvb-usb / af9015.c
blobea1ed3b4592a1d0bcb4c81df90fdb0bdbe468823
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
35 static int dvb_usb_af9015_debug;
36 module_param_named(debug, dvb_usb_af9015_debug, int, 0644);
37 MODULE_PARM_DESC(debug, "set debugging level" DVB_USB_DEBUG_STATUS);
38 static int dvb_usb_af9015_remote;
39 module_param_named(remote, dvb_usb_af9015_remote, int, 0644);
40 MODULE_PARM_DESC(remote, "select remote");
41 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
42
43 static DEFINE_MUTEX(af9015_usb_mutex);
44
45 static struct af9015_config af9015_config;
46 static struct dvb_usb_device_properties af9015_properties[3];
47 static int af9015_properties_count = ARRAY_SIZE(af9015_properties);
48
49 static struct af9013_config af9015_af9013_config[] = {
50 {
51 .demod_address = AF9015_I2C_DEMOD,
52 .output_mode = AF9013_OUTPUT_MODE_USB,
53 .api_version = { 0, 1, 9, 0 },
54 .gpio[0] = AF9013_GPIO_HI,
55 .gpio[3] = AF9013_GPIO_TUNER_ON,
56
57 }, {
58 .output_mode = AF9013_OUTPUT_MODE_SERIAL,
59 .api_version = { 0, 1, 9, 0 },
60 .gpio[0] = AF9013_GPIO_TUNER_ON,
61 .gpio[1] = AF9013_GPIO_LO,
62 }
63 };
64
65 static int af9015_rw_udev(struct usb_device *udev, struct req_t *req)
66 {
67 #define BUF_LEN 63
68 #define REQ_HDR_LEN 8 /* send header size */
69 #define ACK_HDR_LEN 2 /* rece header size */
70 int act_len, ret;
71 u8 buf[BUF_LEN];
72 u8 write = 1;
73 u8 msg_len = REQ_HDR_LEN;
74 static u8 seq; /* packet sequence number */
75
76 if (mutex_lock_interruptible(&af9015_usb_mutex) < 0)
77 return -EAGAIN;
78
79 buf[0] = req->cmd;
80 buf[1] = seq++;
81 buf[2] = req->i2c_addr;
82 buf[3] = req->addr >> 8;
83 buf[4] = req->addr & 0xff;
84 buf[5] = req->mbox;
85 buf[6] = req->addr_len;
86 buf[7] = req->data_len;
87
88 switch (req->cmd) {
89 case GET_CONFIG:
90 case READ_MEMORY:
91 case RECONNECT_USB:
92 case GET_IR_CODE:
93 write = 0;
94 break;
95 case READ_I2C:
96 write = 0;
97 buf[2] |= 0x01; /* set I2C direction */
98 case WRITE_I2C:
99 buf[0] = READ_WRITE_I2C;
100 break;
101 case WRITE_MEMORY:
102 if (((req->addr & 0xff00) == 0xff00) ||
103 ((req->addr & 0xff00) == 0xae00))
104 buf[0] = WRITE_VIRTUAL_MEMORY;
105 case WRITE_VIRTUAL_MEMORY:
106 case COPY_FIRMWARE:
107 case DOWNLOAD_FIRMWARE:
108 case BOOT:
109 break;
110 default:
111 err("unknown command:%d", req->cmd);
112 ret = -1;
113 goto error_unlock;
114 }
115
116 /* buffer overflow check */
117 if ((write && (req->data_len > BUF_LEN - REQ_HDR_LEN)) ||
118 (!write && (req->data_len > BUF_LEN - ACK_HDR_LEN))) {
119 err("too much data; cmd:%d len:%d", req->cmd, req->data_len);
120 ret = -EINVAL;
121 goto error_unlock;
122 }
123
124 /* write requested */
125 if (write) {
126 memcpy(&buf[REQ_HDR_LEN], req->data, req->data_len);
127 msg_len += req->data_len;
128 }
129
130 deb_xfer(">>> ");
131 debug_dump(buf, msg_len, deb_xfer);
132
133 /* send req */
134 ret = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 0x02), buf, msg_len,
135 &act_len, AF9015_USB_TIMEOUT);
136 if (ret)
137 err("bulk message failed:%d (%d/%d)", ret, msg_len, act_len);
138 else
139 if (act_len != msg_len)
140 ret = -1; /* all data is not send */
141 if (ret)
142 goto error_unlock;
143
144 /* no ack for those packets */
145 if (req->cmd == DOWNLOAD_FIRMWARE || req->cmd == RECONNECT_USB)
146 goto exit_unlock;
147
148 /* write receives seq + status = 2 bytes
149 read receives seq + status + data = 2 + N bytes */
150 msg_len = ACK_HDR_LEN;
151 if (!write)
152 msg_len += req->data_len;
153
154 ret = usb_bulk_msg(udev, usb_rcvbulkpipe(udev, 0x81), buf, msg_len,
155 &act_len, AF9015_USB_TIMEOUT);
156 if (ret) {
157 err("recv bulk message failed:%d", ret);
158 ret = -1;
159 goto error_unlock;
160 }
161
162 deb_xfer("<<< ");
163 debug_dump(buf, act_len, deb_xfer);
164
165 /* remote controller query status is 1 if remote code is not received */
166 if (req->cmd == GET_IR_CODE && buf[1] == 1) {
167 buf[1] = 0; /* clear command "error" status */
168 memset(&buf[2], 0, req->data_len);
169 buf[3] = 1; /* no remote code received mark */
170 }
171
172 /* check status */
173 if (buf[1]) {
174 err("command failed:%d", buf[1]);
175 ret = -1;
176 goto error_unlock;
177 }
178
179 /* read request, copy returned data to return buf */
180 if (!write)
181 memcpy(req->data, &buf[ACK_HDR_LEN], req->data_len);
182
183 error_unlock:
184 exit_unlock:
185 mutex_unlock(&af9015_usb_mutex);
186
187 return ret;
188 }
189
190 static int af9015_ctrl_msg(struct dvb_usb_device *d, struct req_t *req)
191 {
192 return af9015_rw_udev(d->udev, req);
193 }
194
195 static int af9015_write_regs(struct dvb_usb_device *d, u16 addr, u8 *val,
196 u8 len)
197 {
198 struct req_t req = {WRITE_MEMORY, AF9015_I2C_DEMOD, addr, 0, 0, len,
199 val};
200 return af9015_ctrl_msg(d, &req);
201 }
202
203 static int af9015_write_reg(struct dvb_usb_device *d, u16 addr, u8 val)
204 {
205 return af9015_write_regs(d, addr, &val, 1);
206 }
207
208 static int af9015_read_reg(struct dvb_usb_device *d, u16 addr, u8 *val)
209 {
210 struct req_t req = {READ_MEMORY, AF9015_I2C_DEMOD, addr, 0, 0, 1, val};
211 return af9015_ctrl_msg(d, &req);
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].demod_address ||
220 addr == af9015_af9013_config[1].demod_address)
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].demod_address ||
232 addr == af9015_af9013_config[1].demod_address)
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 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].demod_address ||
275 msg[i].addr == af9015_af9013_config[1].demod_address) {
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 = 0;
284 }
285
286 if (num > i + 1 && (msg[i+1].flags & I2C_M_RD)) {
287 if (msg[i].addr ==
288 af9015_af9013_config[0].demod_address)
289 req.cmd = READ_MEMORY;
290 else
291 req.cmd = READ_I2C;
292 req.i2c_addr = msg[i].addr;
293 req.addr = addr;
294 req.mbox = mbox;
295 req.addr_len = addr_len;
296 req.data_len = msg[i+1].len;
297 req.data = &msg[i+1].buf[0];
298 ret = af9015_ctrl_msg(d, &req);
299 i += 2;
300 } else if (msg[i].flags & I2C_M_RD) {
301 ret = -EINVAL;
302 if (msg[i].addr ==
303 af9015_af9013_config[0].demod_address)
304 goto error;
305 else
306 req.cmd = READ_I2C;
307 req.i2c_addr = msg[i].addr;
308 req.addr = addr;
309 req.mbox = mbox;
310 req.addr_len = addr_len;
311 req.data_len = msg[i].len;
312 req.data = &msg[i].buf[0];
313 ret = af9015_ctrl_msg(d, &req);
314 i += 1;
315 } else {
316 if (msg[i].addr ==
317 af9015_af9013_config[0].demod_address)
318 req.cmd = WRITE_MEMORY;
319 else
320 req.cmd = WRITE_I2C;
321 req.i2c_addr = msg[i].addr;
322 req.addr = addr;
323 req.mbox = mbox;
324 req.addr_len = addr_len;
325 req.data_len = msg[i].len-addr_len;
326 req.data = &msg[i].buf[addr_len];
327 ret = af9015_ctrl_msg(d, &req);
328 i += 1;
329 }
330 if (ret)
331 goto error;
332
333 }
334 ret = i;
335
336 error:
337 mutex_unlock(&d->i2c_mutex);
338
339 return ret;
340 }
341
342 static u32 af9015_i2c_func(struct i2c_adapter *adapter)
343 {
344 return I2C_FUNC_I2C;
345 }
346
347 static struct i2c_algorithm af9015_i2c_algo = {
348 .master_xfer = af9015_i2c_xfer,
349 .functionality = af9015_i2c_func,
350 };
351
352 static int af9015_do_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit, u8 op)
353 {
354 int ret;
355 u8 val, mask = 0x01;
356
357 ret = af9015_read_reg(d, addr, &val);
358 if (ret)
359 return ret;
360
361 mask <<= bit;
362 if (op) {
363 /* set bit */
364 val |= mask;
365 } else {
366 /* clear bit */
367 mask ^= 0xff;
368 val &= mask;
369 }
370
371 return af9015_write_reg(d, addr, val);
372 }
373
374 static int af9015_set_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit)
375 {
376 return af9015_do_reg_bit(d, addr, bit, 1);
377 }
378
379 static int af9015_clear_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit)
380 {
381 return af9015_do_reg_bit(d, addr, bit, 0);
382 }
383
384 static int af9015_init_endpoint(struct dvb_usb_device *d)
385 {
386 int ret;
387 u16 frame_size;
388 u8 packet_size;
389 deb_info("%s: USB speed:%d\n", __func__, d->udev->speed);
390
391 /* Windows driver uses packet count 21 for USB1.1 and 348 for USB2.0.
392 We use smaller - about 1/4 from the original, 5 and 87. */
393 #define TS_PACKET_SIZE 188
394
395 #define TS_USB20_PACKET_COUNT 87
396 #define TS_USB20_FRAME_SIZE (TS_PACKET_SIZE*TS_USB20_PACKET_COUNT)
397
398 #define TS_USB11_PACKET_COUNT 5
399 #define TS_USB11_FRAME_SIZE (TS_PACKET_SIZE*TS_USB11_PACKET_COUNT)
400
401 #define TS_USB20_MAX_PACKET_SIZE 512
402 #define TS_USB11_MAX_PACKET_SIZE 64
403
404 if (d->udev->speed == USB_SPEED_FULL) {
405 frame_size = TS_USB11_FRAME_SIZE/4;
406 packet_size = TS_USB11_MAX_PACKET_SIZE/4;
407 } else {
408 frame_size = TS_USB20_FRAME_SIZE/4;
409 packet_size = TS_USB20_MAX_PACKET_SIZE/4;
410 }
411
412 ret = af9015_set_reg_bit(d, 0xd507, 2); /* assert EP4 reset */
413 if (ret)
414 goto error;
415 ret = af9015_set_reg_bit(d, 0xd50b, 1); /* assert EP5 reset */
416 if (ret)
417 goto error;
418 ret = af9015_clear_reg_bit(d, 0xdd11, 5); /* disable EP4 */
419 if (ret)
420 goto error;
421 ret = af9015_clear_reg_bit(d, 0xdd11, 6); /* disable EP5 */
422 if (ret)
423 goto error;
424 ret = af9015_set_reg_bit(d, 0xdd11, 5); /* enable EP4 */
425 if (ret)
426 goto error;
427 if (af9015_config.dual_mode) {
428 ret = af9015_set_reg_bit(d, 0xdd11, 6); /* enable EP5 */
429 if (ret)
430 goto error;
431 }
432 ret = af9015_clear_reg_bit(d, 0xdd13, 5); /* disable EP4 NAK */
433 if (ret)
434 goto error;
435 if (af9015_config.dual_mode) {
436 ret = af9015_clear_reg_bit(d, 0xdd13, 6); /* disable EP5 NAK */
437 if (ret)
438 goto error;
439 }
440 /* EP4 xfer length */
441 ret = af9015_write_reg(d, 0xdd88, frame_size & 0xff);
442 if (ret)
443 goto error;
444 ret = af9015_write_reg(d, 0xdd89, frame_size >> 8);
445 if (ret)
446 goto error;
447 /* EP5 xfer length */
448 ret = af9015_write_reg(d, 0xdd8a, frame_size & 0xff);
449 if (ret)
450 goto error;
451 ret = af9015_write_reg(d, 0xdd8b, frame_size >> 8);
452 if (ret)
453 goto error;
454 ret = af9015_write_reg(d, 0xdd0c, packet_size); /* EP4 packet size */
455 if (ret)
456 goto error;
457 ret = af9015_write_reg(d, 0xdd0d, packet_size); /* EP5 packet size */
458 if (ret)
459 goto error;
460 ret = af9015_clear_reg_bit(d, 0xd507, 2); /* negate EP4 reset */
461 if (ret)
462 goto error;
463 if (af9015_config.dual_mode) {
464 ret = af9015_clear_reg_bit(d, 0xd50b, 1); /* negate EP5 reset */
465 if (ret)
466 goto error;
467 }
468
469 /* enable / disable mp2if2 */
470 if (af9015_config.dual_mode)
471 ret = af9015_set_reg_bit(d, 0xd50b, 0);
472 else
473 ret = af9015_clear_reg_bit(d, 0xd50b, 0);
474 error:
475 if (ret)
476 err("endpoint init failed:%d", ret);
477 return ret;
478 }
479
480 static int af9015_copy_firmware(struct dvb_usb_device *d)
481 {
482 int ret;
483 u8 fw_params[4];
484 u8 val, i;
485 struct req_t req = {COPY_FIRMWARE, 0, 0x5100, 0, 0, sizeof(fw_params),
486 fw_params };
487 deb_info("%s:\n", __func__);
488
489 fw_params[0] = af9015_config.firmware_size >> 8;
490 fw_params[1] = af9015_config.firmware_size & 0xff;
491 fw_params[2] = af9015_config.firmware_checksum >> 8;
492 fw_params[3] = af9015_config.firmware_checksum & 0xff;
493
494 /* wait 2nd demodulator ready */
495 msleep(100);
496
497 ret = af9015_read_reg_i2c(d, 0x3a, 0x98be, &val);
498 if (ret)
499 goto error;
500 else
501 deb_info("%s: firmware status:%02x\n", __func__, val);
502
503 if (val == 0x0c) /* fw is running, no need for download */
504 goto exit;
505
506 /* set I2C master clock to fast (to speed up firmware copy) */
507 ret = af9015_write_reg(d, 0xd416, 0x04); /* 0x04 * 400ns */
508 if (ret)
509 goto error;
510
511 msleep(50);
512
513 /* copy firmware */
514 ret = af9015_ctrl_msg(d, &req);
515 if (ret)
516 err("firmware copy cmd failed:%d", ret);
517 deb_info("%s: firmware copy done\n", __func__);
518
519 /* set I2C master clock back to normal */
520 ret = af9015_write_reg(d, 0xd416, 0x14); /* 0x14 * 400ns */
521 if (ret)
522 goto error;
523
524 /* request boot firmware */
525 ret = af9015_write_reg_i2c(d, af9015_af9013_config[1].demod_address,
526 0xe205, 1);
527 deb_info("%s: firmware boot cmd status:%d\n", __func__, ret);
528 if (ret)
529 goto error;
530
531 for (i = 0; i < 15; i++) {
532 msleep(100);
533
534 /* check firmware status */
535 ret = af9015_read_reg_i2c(d,
536 af9015_af9013_config[1].demod_address, 0x98be, &val);
537 deb_info("%s: firmware status cmd status:%d fw status:%02x\n",
538 __func__, ret, val);
539 if (ret)
540 goto error;
541
542 if (val == 0x0c || val == 0x04) /* success or fail */
543 break;
544 }
545
546 if (val == 0x04) {
547 err("firmware did not run");
548 ret = -1;
549 } else if (val != 0x0c) {
550 err("firmware boot timeout");
551 ret = -1;
552 }
553
554 error:
555 exit:
556 return ret;
557 }
558
559 /* hash (and dump) eeprom */
560 static int af9015_eeprom_hash(struct usb_device *udev)
561 {
562 static const unsigned int eeprom_size = 256;
563 unsigned int reg;
564 int ret;
565 u8 val, *eeprom;
566 struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, &val};
567
568 eeprom = kmalloc(eeprom_size, GFP_KERNEL);
569 if (eeprom == NULL)
570 return -ENOMEM;
571
572 for (reg = 0; reg < eeprom_size; reg++) {
573 req.addr = reg;
574 ret = af9015_rw_udev(udev, &req);
575 if (ret)
576 goto free;
577 eeprom[reg] = val;
578 }
579
580 if (dvb_usb_af9015_debug & 0x01)
581 print_hex_dump_bytes("", DUMP_PREFIX_OFFSET, eeprom,
582 eeprom_size);
583
584 BUG_ON(eeprom_size % 4);
585
586 af9015_config.eeprom_sum = 0;
587 for (reg = 0; reg < eeprom_size / sizeof(u32); reg++) {
588 af9015_config.eeprom_sum *= GOLDEN_RATIO_PRIME_32;
589 af9015_config.eeprom_sum += le32_to_cpu(((u32 *)eeprom)[reg]);
590 }
591
592 deb_info("%s: eeprom sum=%.8x\n", __func__, af9015_config.eeprom_sum);
593
594 ret = 0;
595 free:
596 kfree(eeprom);
597 return ret;
598 }
599
600 static int af9015_download_ir_table(struct dvb_usb_device *d)
601 {
602 int i, packets = 0, ret;
603 u16 addr = 0x9a56; /* ir-table start address */
604 struct req_t req = {WRITE_MEMORY, 0, 0, 0, 0, 1, NULL};
605 u8 *data = NULL;
606 deb_info("%s:\n", __func__);
607
608 data = af9015_config.ir_table;
609 packets = af9015_config.ir_table_size;
610
611 /* no remote */
612 if (!packets)
613 goto exit;
614
615 /* load remote ir-table */
616 for (i = 0; i < packets; i++) {
617 req.addr = addr + i;
618 req.data = &data[i];
619 ret = af9015_ctrl_msg(d, &req);
620 if (ret) {
621 err("ir-table download failed at packet %d with " \
622 "code %d", i, ret);
623 return ret;
624 }
625 }
626
627 exit:
628 return 0;
629 }
630
631 static int af9015_init(struct dvb_usb_device *d)
632 {
633 int ret;
634 deb_info("%s:\n", __func__);
635
636 ret = af9015_init_endpoint(d);
637 if (ret)
638 goto error;
639
640 ret = af9015_download_ir_table(d);
641 if (ret)
642 goto error;
643
644 error:
645 return ret;
646 }
647
648 static int af9015_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff)
649 {
650 int ret;
651 deb_info("%s: onoff:%d\n", __func__, onoff);
652
653 if (onoff)
654 ret = af9015_set_reg_bit(adap->dev, 0xd503, 0);
655 else
656 ret = af9015_clear_reg_bit(adap->dev, 0xd503, 0);
657
658 return ret;
659 }
660
661 static int af9015_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid,
662 int onoff)
663 {
664 int ret;
665 u8 idx;
666
667 deb_info("%s: set pid filter, index %d, pid %x, onoff %d\n",
668 __func__, index, pid, onoff);
669
670 ret = af9015_write_reg(adap->dev, 0xd505, (pid & 0xff));
671 if (ret)
672 goto error;
673
674 ret = af9015_write_reg(adap->dev, 0xd506, (pid >> 8));
675 if (ret)
676 goto error;
677
678 idx = ((index & 0x1f) | (1 << 5));
679 ret = af9015_write_reg(adap->dev, 0xd504, idx);
680
681 error:
682 return ret;
683 }
684
685 static int af9015_download_firmware(struct usb_device *udev,
686 const struct firmware *fw)
687 {
688 int i, len, packets, remainder, ret;
689 struct req_t req = {DOWNLOAD_FIRMWARE, 0, 0, 0, 0, 0, NULL};
690 u16 addr = 0x5100; /* firmware start address */
691 u16 checksum = 0;
692
693 deb_info("%s:\n", __func__);
694
695 /* calc checksum */
696 for (i = 0; i < fw->size; i++)
697 checksum += fw->data[i];
698
699 af9015_config.firmware_size = fw->size;
700 af9015_config.firmware_checksum = checksum;
701
702 #define FW_PACKET_MAX_DATA 55
703
704 packets = fw->size / FW_PACKET_MAX_DATA;
705 remainder = fw->size % FW_PACKET_MAX_DATA;
706 len = FW_PACKET_MAX_DATA;
707 for (i = 0; i <= packets; i++) {
708 if (i == packets) /* set size of the last packet */
709 len = remainder;
710
711 req.data_len = len;
712 req.data = (u8 *)(fw->data + i * FW_PACKET_MAX_DATA);
713 req.addr = addr;
714 addr += FW_PACKET_MAX_DATA;
715
716 ret = af9015_rw_udev(udev, &req);
717 if (ret) {
718 err("firmware download failed at packet %d with " \
719 "code %d", i, ret);
720 goto error;
721 }
722 }
723
724 /* firmware loaded, request boot */
725 req.cmd = BOOT;
726 ret = af9015_rw_udev(udev, &req);
727 if (ret) {
728 err("firmware boot failed:%d", ret);
729 goto error;
730 }
731
732 error:
733 return ret;
734 }
735
736 struct af9015_setup {
737 unsigned int id;
738 struct ir_scancode *rc_key_map;
739 unsigned int rc_key_map_size;
740 u8 *ir_table;
741 unsigned int ir_table_size;
742 };
743
744 static const struct af9015_setup *af9015_setup_match(unsigned int id,
745 const struct af9015_setup *table)
746 {
747 for (; table->rc_key_map; table++)
748 if (table->id == id)
749 return table;
750 return NULL;
751 }
752
753 static const struct af9015_setup af9015_setup_modparam[] = {
754 { AF9015_REMOTE_A_LINK_DTU_M,
755 ir_codes_af9015_table_a_link, ARRAY_SIZE(ir_codes_af9015_table_a_link),
756 af9015_ir_table_a_link, ARRAY_SIZE(af9015_ir_table_a_link) },
757 { AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3,
758 ir_codes_af9015_table_msi, ARRAY_SIZE(ir_codes_af9015_table_msi),
759 af9015_ir_table_msi, ARRAY_SIZE(af9015_ir_table_msi) },
760 { AF9015_REMOTE_MYGICTV_U718,
761 ir_codes_af9015_table_mygictv, ARRAY_SIZE(ir_codes_af9015_table_mygictv),
762 af9015_ir_table_mygictv, ARRAY_SIZE(af9015_ir_table_mygictv) },
763 { AF9015_REMOTE_DIGITTRADE_DVB_T,
764 ir_codes_af9015_table_digittrade, ARRAY_SIZE(ir_codes_af9015_table_digittrade),
765 af9015_ir_table_digittrade, ARRAY_SIZE(af9015_ir_table_digittrade) },
766 { AF9015_REMOTE_AVERMEDIA_KS,
767 ir_codes_af9015_table_avermedia, ARRAY_SIZE(ir_codes_af9015_table_avermedia),
768 af9015_ir_table_avermedia_ks, ARRAY_SIZE(af9015_ir_table_avermedia_ks) },
769 { }
770 };
771
772 /* don't add new entries here anymore, use hashes instead */
773 static const struct af9015_setup af9015_setup_usbids[] = {
774 { USB_VID_LEADTEK,
775 ir_codes_af9015_table_leadtek, ARRAY_SIZE(ir_codes_af9015_table_leadtek),
776 af9015_ir_table_leadtek, ARRAY_SIZE(af9015_ir_table_leadtek) },
777 { USB_VID_VISIONPLUS,
778 ir_codes_af9015_table_twinhan, ARRAY_SIZE(ir_codes_af9015_table_twinhan),
779 af9015_ir_table_twinhan, ARRAY_SIZE(af9015_ir_table_twinhan) },
780 { USB_VID_KWORLD_2, /* TODO: use correct rc keys */
781 ir_codes_af9015_table_twinhan, ARRAY_SIZE(ir_codes_af9015_table_twinhan),
782 af9015_ir_table_kworld, ARRAY_SIZE(af9015_ir_table_kworld) },
783 { USB_VID_AVERMEDIA,
784 ir_codes_af9015_table_avermedia, ARRAY_SIZE(ir_codes_af9015_table_avermedia),
785 af9015_ir_table_avermedia, ARRAY_SIZE(af9015_ir_table_avermedia) },
786 { USB_VID_MSI_2,
787 ir_codes_af9015_table_msi_digivox_iii, ARRAY_SIZE(ir_codes_af9015_table_msi_digivox_iii),
788 af9015_ir_table_msi_digivox_iii, ARRAY_SIZE(af9015_ir_table_msi_digivox_iii) },
789 { }
790 };
791
792 static const struct af9015_setup af9015_setup_hashes[] = {
793 { 0xb8feb708,
794 ir_codes_af9015_table_msi, ARRAY_SIZE(ir_codes_af9015_table_msi),
795 af9015_ir_table_msi, ARRAY_SIZE(af9015_ir_table_msi) },
796 { 0xa3703d00,
797 ir_codes_af9015_table_a_link, ARRAY_SIZE(ir_codes_af9015_table_a_link),
798 af9015_ir_table_a_link, ARRAY_SIZE(af9015_ir_table_a_link) },
799 { 0x9b7dc64e,
800 ir_codes_af9015_table_mygictv, ARRAY_SIZE(ir_codes_af9015_table_mygictv),
801 af9015_ir_table_mygictv, ARRAY_SIZE(af9015_ir_table_mygictv) },
802 { }
803 };
804
805 static void af9015_set_remote_config(struct usb_device *udev,
806 struct dvb_usb_device_properties *props)
807 {
808 const struct af9015_setup *table = NULL;
809
810 if (dvb_usb_af9015_remote) {
811 /* load remote defined as module param */
812 table = af9015_setup_match(dvb_usb_af9015_remote,
813 af9015_setup_modparam);
814 } else {
815 u16 vendor = le16_to_cpu(udev->descriptor.idVendor);
816
817 table = af9015_setup_match(af9015_config.eeprom_sum,
818 af9015_setup_hashes);
819
820 if (!table && vendor == USB_VID_AFATECH) {
821 /* Check USB manufacturer and product strings and try
822 to determine correct remote in case of chip vendor
823 reference IDs are used.
824 DO NOT ADD ANYTHING NEW HERE. Use hashes instead.
825 */
826 char manufacturer[10];
827 memset(manufacturer, 0, sizeof(manufacturer));
828 usb_string(udev, udev->descriptor.iManufacturer,
829 manufacturer, sizeof(manufacturer));
830 if (!strcmp("MSI", manufacturer)) {
831 /* iManufacturer 1 MSI
832 iProduct 2 MSI K-VOX */
833 table = af9015_setup_match(
834 AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3,
835 af9015_setup_modparam);
836 } else if (udev->descriptor.idProduct ==
837 cpu_to_le16(USB_PID_TREKSTOR_DVBT)) {
838 table = &(const struct af9015_setup){ 0,
839 ir_codes_af9015_table_trekstor,
840 ARRAY_SIZE(ir_codes_af9015_table_trekstor),
841 af9015_ir_table_trekstor,
842 ARRAY_SIZE(af9015_ir_table_trekstor)
843 };
844 }
845 } else if (!table)
846 table = af9015_setup_match(vendor, af9015_setup_usbids);
847 }
848
849 if (table) {
850 props->rc.legacy.rc_key_map = table->rc_key_map;
851 props->rc.legacy.rc_key_map_size = table->rc_key_map_size;
852 af9015_config.ir_table = table->ir_table;
853 af9015_config.ir_table_size = table->ir_table_size;
854 }
855 }
856
857 static int af9015_read_config(struct usb_device *udev)
858 {
859 int ret;
860 u8 val, i, offset = 0;
861 struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, &val};
862
863 /* IR remote controller */
864 req.addr = AF9015_EEPROM_IR_MODE;
865 /* first message will timeout often due to possible hw bug */
866 for (i = 0; i < 4; i++) {
867 ret = af9015_rw_udev(udev, &req);
868 if (!ret)
869 break;
870 }
871 if (ret)
872 goto error;
873
874 ret = af9015_eeprom_hash(udev);
875 if (ret)
876 goto error;
877
878 deb_info("%s: IR mode:%d\n", __func__, val);
879 for (i = 0; i < af9015_properties_count; i++) {
880 if (val == AF9015_IR_MODE_DISABLED) {
881 af9015_properties[i].rc.legacy.rc_key_map = NULL;
882 af9015_properties[i].rc.legacy.rc_key_map_size = 0;
883 } else
884 af9015_set_remote_config(udev, &af9015_properties[i]);
885 }
886
887 /* TS mode - one or two receivers */
888 req.addr = AF9015_EEPROM_TS_MODE;
889 ret = af9015_rw_udev(udev, &req);
890 if (ret)
891 goto error;
892 af9015_config.dual_mode = val;
893 deb_info("%s: TS mode:%d\n", __func__, af9015_config.dual_mode);
894
895 /* Set adapter0 buffer size according to USB port speed, adapter1 buffer
896 size can be static because it is enabled only USB2.0 */
897 for (i = 0; i < af9015_properties_count; i++) {
898 /* USB1.1 set smaller buffersize and disable 2nd adapter */
899 if (udev->speed == USB_SPEED_FULL) {
900 af9015_properties[i].adapter[0].stream.u.bulk.buffersize
901 = TS_USB11_FRAME_SIZE;
902 /* disable 2nd adapter because we don't have
903 PID-filters */
904 af9015_config.dual_mode = 0;
905 } else {
906 af9015_properties[i].adapter[0].stream.u.bulk.buffersize
907 = TS_USB20_FRAME_SIZE;
908 }
909 }
910
911 if (af9015_config.dual_mode) {
912 /* read 2nd demodulator I2C address */
913 req.addr = AF9015_EEPROM_DEMOD2_I2C;
914 ret = af9015_rw_udev(udev, &req);
915 if (ret)
916 goto error;
917 af9015_af9013_config[1].demod_address = val;
918
919 /* enable 2nd adapter */
920 for (i = 0; i < af9015_properties_count; i++)
921 af9015_properties[i].num_adapters = 2;
922
923 } else {
924 /* disable 2nd adapter */
925 for (i = 0; i < af9015_properties_count; i++)
926 af9015_properties[i].num_adapters = 1;
927 }
928
929 for (i = 0; i < af9015_properties[0].num_adapters; i++) {
930 if (i == 1)
931 offset = AF9015_EEPROM_OFFSET;
932 /* xtal */
933 req.addr = AF9015_EEPROM_XTAL_TYPE1 + offset;
934 ret = af9015_rw_udev(udev, &req);
935 if (ret)
936 goto error;
937 switch (val) {
938 case 0:
939 af9015_af9013_config[i].adc_clock = 28800;
940 break;
941 case 1:
942 af9015_af9013_config[i].adc_clock = 20480;
943 break;
944 case 2:
945 af9015_af9013_config[i].adc_clock = 28000;
946 break;
947 case 3:
948 af9015_af9013_config[i].adc_clock = 25000;
949 break;
950 };
951 deb_info("%s: [%d] xtal:%d set adc_clock:%d\n", __func__, i,
952 val, af9015_af9013_config[i].adc_clock);
953
954 /* tuner IF */
955 req.addr = AF9015_EEPROM_IF1H + offset;
956 ret = af9015_rw_udev(udev, &req);
957 if (ret)
958 goto error;
959 af9015_af9013_config[i].tuner_if = val << 8;
960 req.addr = AF9015_EEPROM_IF1L + offset;
961 ret = af9015_rw_udev(udev, &req);
962 if (ret)
963 goto error;
964 af9015_af9013_config[i].tuner_if += val;
965 deb_info("%s: [%d] IF1:%d\n", __func__, i,
966 af9015_af9013_config[0].tuner_if);
967
968 /* MT2060 IF1 */
969 req.addr = AF9015_EEPROM_MT2060_IF1H + offset;
970 ret = af9015_rw_udev(udev, &req);
971 if (ret)
972 goto error;
973 af9015_config.mt2060_if1[i] = val << 8;
974 req.addr = AF9015_EEPROM_MT2060_IF1L + offset;
975 ret = af9015_rw_udev(udev, &req);
976 if (ret)
977 goto error;
978 af9015_config.mt2060_if1[i] += val;
979 deb_info("%s: [%d] MT2060 IF1:%d\n", __func__, i,
980 af9015_config.mt2060_if1[i]);
981
982 /* tuner */
983 req.addr = AF9015_EEPROM_TUNER_ID1 + offset;
984 ret = af9015_rw_udev(udev, &req);
985 if (ret)
986 goto error;
987 switch (val) {
988 case AF9013_TUNER_ENV77H11D5:
989 case AF9013_TUNER_MT2060:
990 case AF9013_TUNER_QT1010:
991 case AF9013_TUNER_UNKNOWN:
992 case AF9013_TUNER_MT2060_2:
993 case AF9013_TUNER_TDA18271:
994 case AF9013_TUNER_QT1010A:
995 af9015_af9013_config[i].rf_spec_inv = 1;
996 break;
997 case AF9013_TUNER_MXL5003D:
998 case AF9013_TUNER_MXL5005D:
999 case AF9013_TUNER_MXL5005R:
1000 af9015_af9013_config[i].rf_spec_inv = 0;
1001 break;
1002 case AF9013_TUNER_MC44S803:
1003 af9015_af9013_config[i].gpio[1] = AF9013_GPIO_LO;
1004 af9015_af9013_config[i].rf_spec_inv = 1;
1005 break;
1006 case AF9013_TUNER_TDA18218:
1007 warn("tuner NXP TDA18218 not supported yet");
1008 return -ENODEV;
1009 default:
1010 warn("tuner id:%d not supported, please report!", val);
1011 return -ENODEV;
1012 };
1013
1014 af9015_af9013_config[i].tuner = val;
1015 deb_info("%s: [%d] tuner id:%d\n", __func__, i, val);
1016 }
1017
1018 error:
1019 if (ret)
1020 err("eeprom read failed:%d", ret);
1021
1022 /* AverMedia AVerTV Volar Black HD (A850) device have bad EEPROM
1023 content :-( Override some wrong values here. */
1024 if (le16_to_cpu(udev->descriptor.idVendor) == USB_VID_AVERMEDIA &&
1025 le16_to_cpu(udev->descriptor.idProduct) == USB_PID_AVERMEDIA_A850) {
1026 deb_info("%s: AverMedia A850: overriding config\n", __func__);
1027 /* disable dual mode */
1028 af9015_config.dual_mode = 0;
1029 /* disable 2nd adapter */
1030 for (i = 0; i < af9015_properties_count; i++)
1031 af9015_properties[i].num_adapters = 1;
1032
1033 /* set correct IF */
1034 af9015_af9013_config[0].tuner_if = 4570;
1035 }
1036
1037 return ret;
1038 }
1039
1040 static int af9015_identify_state(struct usb_device *udev,
1041 struct dvb_usb_device_properties *props,
1042 struct dvb_usb_device_description **desc,
1043 int *cold)
1044 {
1045 int ret;
1046 u8 reply;
1047 struct req_t req = {GET_CONFIG, 0, 0, 0, 0, 1, &reply};
1048
1049 ret = af9015_rw_udev(udev, &req);
1050 if (ret)
1051 return ret;
1052
1053 deb_info("%s: reply:%02x\n", __func__, reply);
1054 if (reply == 0x02)
1055 *cold = 0;
1056 else
1057 *cold = 1;
1058
1059 return ret;
1060 }
1061
1062 static int af9015_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
1063 {
1064 u8 buf[8];
1065 struct req_t req = {GET_IR_CODE, 0, 0, 0, 0, sizeof(buf), buf};
1066 struct ir_scancode *keymap = d->props.rc.legacy.rc_key_map;
1067 int i, ret;
1068
1069 memset(buf, 0, sizeof(buf));
1070
1071 ret = af9015_ctrl_msg(d, &req);
1072 if (ret)
1073 return ret;
1074
1075 *event = 0;
1076 *state = REMOTE_NO_KEY_PRESSED;
1077
1078 for (i = 0; i < d->props.rc.legacy.rc_key_map_size; i++) {
1079 if (!buf[1] && rc5_custom(&keymap[i]) == buf[0] &&
1080 rc5_data(&keymap[i]) == buf[2]) {
1081 *event = keymap[i].keycode;
1082 *state = REMOTE_KEY_PRESSED;
1083 break;
1084 }
1085 }
1086 if (!buf[1])
1087 deb_rc("%s: %02x %02x %02x %02x %02x %02x %02x %02x\n",
1088 __func__, buf[0], buf[1], buf[2], buf[3], buf[4],
1089 buf[5], buf[6], buf[7]);
1090
1091 return 0;
1092 }
1093
1094 /* init 2nd I2C adapter */
1095 static int af9015_i2c_init(struct dvb_usb_device *d)
1096 {
1097 int ret;
1098 struct af9015_state *state = d->priv;
1099 deb_info("%s:\n", __func__);
1100
1101 strncpy(state->i2c_adap.name, d->desc->name,
1102 sizeof(state->i2c_adap.name));
1103 #ifdef I2C_ADAP_CLASS_TV_DIGITAL
1104 state->i2c_adap.class = I2C_ADAP_CLASS_TV_DIGITAL,
1105 #else
1106 state->i2c_adap.class = I2C_CLASS_TV_DIGITAL,
1107 #endif
1108 state->i2c_adap.algo = d->props.i2c_algo;
1109 state->i2c_adap.algo_data = NULL;
1110 state->i2c_adap.dev.parent = &d->udev->dev;
1111
1112 i2c_set_adapdata(&state->i2c_adap, d);
1113
1114 ret = i2c_add_adapter(&state->i2c_adap);
1115 if (ret < 0)
1116 err("could not add i2c adapter");
1117
1118 return ret;
1119 }
1120
1121 static int af9015_af9013_frontend_attach(struct dvb_usb_adapter *adap)
1122 {
1123 int ret;
1124 struct af9015_state *state = adap->dev->priv;
1125 struct i2c_adapter *i2c_adap;
1126
1127 if (adap->id == 0) {
1128 /* select I2C adapter */
1129 i2c_adap = &adap->dev->i2c_adap;
1130
1131 deb_info("%s: init I2C\n", __func__);
1132 ret = af9015_i2c_init(adap->dev);
1133 } else {
1134 /* select I2C adapter */
1135 i2c_adap = &state->i2c_adap;
1136
1137 /* copy firmware to 2nd demodulator */
1138 if (af9015_config.dual_mode) {
1139 ret = af9015_copy_firmware(adap->dev);
1140 if (ret) {
1141 err("firmware copy to 2nd frontend " \
1142 "failed, will disable it");
1143 af9015_config.dual_mode = 0;
1144 return -ENODEV;
1145 }
1146 } else {
1147 return -ENODEV;
1148 }
1149 }
1150
1151 /* attach demodulator */
1152 adap->fe = dvb_attach(af9013_attach, &af9015_af9013_config[adap->id],
1153 i2c_adap);
1154
1155 return adap->fe == NULL ? -ENODEV : 0;
1156 }
1157
1158 static struct mt2060_config af9015_mt2060_config = {
1159 .i2c_address = 0xc0,
1160 .clock_out = 0,
1161 };
1162
1163 static struct qt1010_config af9015_qt1010_config = {
1164 .i2c_address = 0xc4,
1165 };
1166
1167 static struct tda18271_config af9015_tda18271_config = {
1168 .gate = TDA18271_GATE_DIGITAL,
1169 .small_i2c = 1,
1170 };
1171
1172 static struct mxl5005s_config af9015_mxl5003_config = {
1173 .i2c_address = 0xc6,
1174 .if_freq = IF_FREQ_4570000HZ,
1175 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
1176 .agc_mode = MXL_SINGLE_AGC,
1177 .tracking_filter = MXL_TF_DEFAULT,
1178 .rssi_enable = MXL_RSSI_ENABLE,
1179 .cap_select = MXL_CAP_SEL_ENABLE,
1180 .div_out = MXL_DIV_OUT_4,
1181 .clock_out = MXL_CLOCK_OUT_DISABLE,
1182 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
1183 .top = MXL5005S_TOP_25P2,
1184 .mod_mode = MXL_DIGITAL_MODE,
1185 .if_mode = MXL_ZERO_IF,
1186 .AgcMasterByte = 0x00,
1187 };
1188
1189 static struct mxl5005s_config af9015_mxl5005_config = {
1190 .i2c_address = 0xc6,
1191 .if_freq = IF_FREQ_4570000HZ,
1192 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
1193 .agc_mode = MXL_SINGLE_AGC,
1194 .tracking_filter = MXL_TF_OFF,
1195 .rssi_enable = MXL_RSSI_ENABLE,
1196 .cap_select = MXL_CAP_SEL_ENABLE,
1197 .div_out = MXL_DIV_OUT_4,
1198 .clock_out = MXL_CLOCK_OUT_DISABLE,
1199 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
1200 .top = MXL5005S_TOP_25P2,
1201 .mod_mode = MXL_DIGITAL_MODE,
1202 .if_mode = MXL_ZERO_IF,
1203 .AgcMasterByte = 0x00,
1204 };
1205
1206 static struct mc44s803_config af9015_mc44s803_config = {
1207 .i2c_address = 0xc0,
1208 .dig_out = 1,
1209 };
1210
1211 static int af9015_tuner_attach(struct dvb_usb_adapter *adap)
1212 {
1213 struct af9015_state *state = adap->dev->priv;
1214 struct i2c_adapter *i2c_adap;
1215 int ret;
1216 deb_info("%s: \n", __func__);
1217
1218 /* select I2C adapter */
1219 if (adap->id == 0)
1220 i2c_adap = &adap->dev->i2c_adap;
1221 else
1222 i2c_adap = &state->i2c_adap;
1223
1224 switch (af9015_af9013_config[adap->id].tuner) {
1225 case AF9013_TUNER_MT2060:
1226 case AF9013_TUNER_MT2060_2:
1227 ret = dvb_attach(mt2060_attach, adap->fe, i2c_adap,
1228 &af9015_mt2060_config,
1229 af9015_config.mt2060_if1[adap->id])
1230 == NULL ? -ENODEV : 0;
1231 break;
1232 case AF9013_TUNER_QT1010:
1233 case AF9013_TUNER_QT1010A:
1234 ret = dvb_attach(qt1010_attach, adap->fe, i2c_adap,
1235 &af9015_qt1010_config) == NULL ? -ENODEV : 0;
1236 break;
1237 case AF9013_TUNER_TDA18271:
1238 ret = dvb_attach(tda18271_attach, adap->fe, 0xc0, i2c_adap,
1239 &af9015_tda18271_config) == NULL ? -ENODEV : 0;
1240 break;
1241 case AF9013_TUNER_MXL5003D:
1242 ret = dvb_attach(mxl5005s_attach, adap->fe, i2c_adap,
1243 &af9015_mxl5003_config) == NULL ? -ENODEV : 0;
1244 break;
1245 case AF9013_TUNER_MXL5005D:
1246 case AF9013_TUNER_MXL5005R:
1247 ret = dvb_attach(mxl5005s_attach, adap->fe, i2c_adap,
1248 &af9015_mxl5005_config) == NULL ? -ENODEV : 0;
1249 break;
1250 case AF9013_TUNER_ENV77H11D5:
1251 ret = dvb_attach(dvb_pll_attach, adap->fe, 0xc0, i2c_adap,
1252 DVB_PLL_TDA665X) == NULL ? -ENODEV : 0;
1253 break;
1254 case AF9013_TUNER_MC44S803:
1255 ret = dvb_attach(mc44s803_attach, adap->fe, i2c_adap,
1256 &af9015_mc44s803_config) == NULL ? -ENODEV : 0;
1257 break;
1258 case AF9013_TUNER_UNKNOWN:
1259 default:
1260 ret = -ENODEV;
1261 err("Unknown tuner id:%d",
1262 af9015_af9013_config[adap->id].tuner);
1263 }
1264 return ret;
1265 }
1266
1267 static struct usb_device_id af9015_usb_table[] = {
1268 /* 0 */{USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9015_9015)},
1269 {USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9015_9016)},
1270 {USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_GOLD)},
1271 {USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV71E)},
1272 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_399U)},
1273 /* 5 */{USB_DEVICE(USB_VID_VISIONPLUS,
1274 USB_PID_TINYTWIN)},
1275 {USB_DEVICE(USB_VID_VISIONPLUS,
1276 USB_PID_AZUREWAVE_AD_TU700)},
1277 {USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_USB_XE_REV2)},
1278 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_PC160_2T)},
1279 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X)},
1280 /* 10 */{USB_DEVICE(USB_VID_XTENSIONS, USB_PID_XTENSIONS_XD_380)},
1281 {USB_DEVICE(USB_VID_MSI_2, USB_PID_MSI_DIGIVOX_DUO)},
1282 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X_2)},
1283 {USB_DEVICE(USB_VID_TELESTAR, USB_PID_TELESTAR_STARSTICK_2)},
1284 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A309)},
1285 /* 15 */{USB_DEVICE(USB_VID_MSI_2, USB_PID_MSI_DIGI_VOX_MINI_III)},
1286 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U)},
1287 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_2)},
1288 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_3)},
1289 {USB_DEVICE(USB_VID_AFATECH, USB_PID_TREKSTOR_DVBT)},
1290 /* 20 */{USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A850)},
1291 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A805)},
1292 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_CONCEPTRONIC_CTVDIGRCU)},
1293 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_MC810)},
1294 {USB_DEVICE(USB_VID_KYE, USB_PID_GENIUS_TVGO_DVB_T03)},
1295 /* 25 */{USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_399U_2)},
1296 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_PC160_T)},
1297 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV20)},
1298 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_TINYTWIN_2)},
1299 {USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV2000DS)},
1300 /* 30 */{USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_UB383_T)},
1301 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_4)},
1302 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A815M)},
1303 {0},
1304 };
1305 MODULE_DEVICE_TABLE(usb, af9015_usb_table);
1306
1307 static struct dvb_usb_device_properties af9015_properties[] = {
1308 {
1309 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1310
1311 .usb_ctrl = DEVICE_SPECIFIC,
1312 .download_firmware = af9015_download_firmware,
1313 .firmware = "dvb-usb-af9015.fw",
1314 .no_reconnect = 1,
1315
1316 .size_of_priv = sizeof(struct af9015_state),
1317
1318 .num_adapters = 2,
1319 .adapter = {
1320 {
1321 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1322 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1323
1324 .pid_filter_count = 32,
1325 .pid_filter = af9015_pid_filter,
1326 .pid_filter_ctrl = af9015_pid_filter_ctrl,
1327
1328 .frontend_attach =
1329 af9015_af9013_frontend_attach,
1330 .tuner_attach = af9015_tuner_attach,
1331 .stream = {
1332 .type = USB_BULK,
1333 .count = 6,
1334 .endpoint = 0x84,
1335 },
1336 },
1337 {
1338 .frontend_attach =
1339 af9015_af9013_frontend_attach,
1340 .tuner_attach = af9015_tuner_attach,
1341 .stream = {
1342 .type = USB_BULK,
1343 .count = 6,
1344 .endpoint = 0x85,
1345 .u = {
1346 .bulk = {
1347 .buffersize =
1348 TS_USB20_FRAME_SIZE,
1349 }
1350 }
1351 },
1352 }
1353 },
1354
1355 .identify_state = af9015_identify_state,
1356
1357 .rc.legacy = {
1358 .rc_query = af9015_rc_query,
1359 .rc_interval = 150,
1360 },
1361
1362 .i2c_algo = &af9015_i2c_algo,
1363
1364 .num_device_descs = 9, /* max 9 */
1365 .devices = {
1366 {
1367 .name = "Afatech AF9015 DVB-T USB2.0 stick",
1368 .cold_ids = {&af9015_usb_table[0],
1369 &af9015_usb_table[1], NULL},
1370 .warm_ids = {NULL},
1371 },
1372 {
1373 .name = "Leadtek WinFast DTV Dongle Gold",
1374 .cold_ids = {&af9015_usb_table[2], NULL},
1375 .warm_ids = {NULL},
1376 },
1377 {
1378 .name = "Pinnacle PCTV 71e",
1379 .cold_ids = {&af9015_usb_table[3], NULL},
1380 .warm_ids = {NULL},
1381 },
1382 {
1383 .name = "KWorld PlusTV Dual DVB-T Stick " \
1384 "(DVB-T 399U)",
1385 .cold_ids = {&af9015_usb_table[4],
1386 &af9015_usb_table[25], NULL},
1387 .warm_ids = {NULL},
1388 },
1389 {
1390 .name = "DigitalNow TinyTwin DVB-T Receiver",
1391 .cold_ids = {&af9015_usb_table[5],
1392 &af9015_usb_table[28], NULL},
1393 .warm_ids = {NULL},
1394 },
1395 {
1396 .name = "TwinHan AzureWave AD-TU700(704J)",
1397 .cold_ids = {&af9015_usb_table[6], NULL},
1398 .warm_ids = {NULL},
1399 },
1400 {
1401 .name = "TerraTec Cinergy T USB XE",
1402 .cold_ids = {&af9015_usb_table[7], NULL},
1403 .warm_ids = {NULL},
1404 },
1405 {
1406 .name = "KWorld PlusTV Dual DVB-T PCI " \
1407 "(DVB-T PC160-2T)",
1408 .cold_ids = {&af9015_usb_table[8], NULL},
1409 .warm_ids = {NULL},
1410 },
1411 {
1412 .name = "AVerMedia AVerTV DVB-T Volar X",
1413 .cold_ids = {&af9015_usb_table[9], NULL},
1414 .warm_ids = {NULL},
1415 },
1416 }
1417 }, {
1418 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1419
1420 .usb_ctrl = DEVICE_SPECIFIC,
1421 .download_firmware = af9015_download_firmware,
1422 .firmware = "dvb-usb-af9015.fw",
1423 .no_reconnect = 1,
1424
1425 .size_of_priv = sizeof(struct af9015_state),
1426
1427 .num_adapters = 2,
1428 .adapter = {
1429 {
1430 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1431 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1432
1433 .pid_filter_count = 32,
1434 .pid_filter = af9015_pid_filter,
1435 .pid_filter_ctrl = af9015_pid_filter_ctrl,
1436
1437 .frontend_attach =
1438 af9015_af9013_frontend_attach,
1439 .tuner_attach = af9015_tuner_attach,
1440 .stream = {
1441 .type = USB_BULK,
1442 .count = 6,
1443 .endpoint = 0x84,
1444 },
1445 },
1446 {
1447 .frontend_attach =
1448 af9015_af9013_frontend_attach,
1449 .tuner_attach = af9015_tuner_attach,
1450 .stream = {
1451 .type = USB_BULK,
1452 .count = 6,
1453 .endpoint = 0x85,
1454 .u = {
1455 .bulk = {
1456 .buffersize =
1457 TS_USB20_FRAME_SIZE,
1458 }
1459 }
1460 },
1461 }
1462 },
1463
1464 .identify_state = af9015_identify_state,
1465
1466 .rc.legacy = {
1467 .rc_query = af9015_rc_query,
1468 .rc_interval = 150,
1469 },
1470
1471 .i2c_algo = &af9015_i2c_algo,
1472
1473 .num_device_descs = 9, /* max 9 */
1474 .devices = {
1475 {
1476 .name = "Xtensions XD-380",
1477 .cold_ids = {&af9015_usb_table[10], NULL},
1478 .warm_ids = {NULL},
1479 },
1480 {
1481 .name = "MSI DIGIVOX Duo",
1482 .cold_ids = {&af9015_usb_table[11], NULL},
1483 .warm_ids = {NULL},
1484 },
1485 {
1486 .name = "Fujitsu-Siemens Slim Mobile USB DVB-T",
1487 .cold_ids = {&af9015_usb_table[12], NULL},
1488 .warm_ids = {NULL},
1489 },
1490 {
1491 .name = "Telestar Starstick 2",
1492 .cold_ids = {&af9015_usb_table[13], NULL},
1493 .warm_ids = {NULL},
1494 },
1495 {
1496 .name = "AVerMedia A309",
1497 .cold_ids = {&af9015_usb_table[14], NULL},
1498 .warm_ids = {NULL},
1499 },
1500 {
1501 .name = "MSI Digi VOX mini III",
1502 .cold_ids = {&af9015_usb_table[15], NULL},
1503 .warm_ids = {NULL},
1504 },
1505 {
1506 .name = "KWorld USB DVB-T TV Stick II " \
1507 "(VS-DVB-T 395U)",
1508 .cold_ids = {&af9015_usb_table[16],
1509 &af9015_usb_table[17],
1510 &af9015_usb_table[18],
1511 &af9015_usb_table[31], NULL},
1512 .warm_ids = {NULL},
1513 },
1514 {
1515 .name = "TrekStor DVB-T USB Stick",
1516 .cold_ids = {&af9015_usb_table[19], NULL},
1517 .warm_ids = {NULL},
1518 },
1519 {
1520 .name = "AverMedia AVerTV Volar Black HD " \
1521 "(A850)",
1522 .cold_ids = {&af9015_usb_table[20], NULL},
1523 .warm_ids = {NULL},
1524 },
1525 }
1526 }, {
1527 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1528
1529 .usb_ctrl = DEVICE_SPECIFIC,
1530 .download_firmware = af9015_download_firmware,
1531 .firmware = "dvb-usb-af9015.fw",
1532 .no_reconnect = 1,
1533
1534 .size_of_priv = sizeof(struct af9015_state),
1535
1536 .num_adapters = 2,
1537 .adapter = {
1538 {
1539 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1540 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1541
1542 .pid_filter_count = 32,
1543 .pid_filter = af9015_pid_filter,
1544 .pid_filter_ctrl = af9015_pid_filter_ctrl,
1545
1546 .frontend_attach =
1547 af9015_af9013_frontend_attach,
1548 .tuner_attach = af9015_tuner_attach,
1549 .stream = {
1550 .type = USB_BULK,
1551 .count = 6,
1552 .endpoint = 0x84,
1553 },
1554 },
1555 {
1556 .frontend_attach =
1557 af9015_af9013_frontend_attach,
1558 .tuner_attach = af9015_tuner_attach,
1559 .stream = {
1560 .type = USB_BULK,
1561 .count = 6,
1562 .endpoint = 0x85,
1563 .u = {
1564 .bulk = {
1565 .buffersize =
1566 TS_USB20_FRAME_SIZE,
1567 }
1568 }
1569 },
1570 }
1571 },
1572
1573 .identify_state = af9015_identify_state,
1574
1575 .rc.legacy = {
1576 .rc_query = af9015_rc_query,
1577 .rc_interval = 150,
1578 },
1579
1580 .i2c_algo = &af9015_i2c_algo,
1581
1582 .num_device_descs = 9, /* max 9 */
1583 .devices = {
1584 {
1585 .name = "AverMedia AVerTV Volar GPS 805 (A805)",
1586 .cold_ids = {&af9015_usb_table[21], NULL},
1587 .warm_ids = {NULL},
1588 },
1589 {
1590 .name = "Conceptronic USB2.0 DVB-T CTVDIGRCU " \
1591 "V3.0",
1592 .cold_ids = {&af9015_usb_table[22], NULL},
1593 .warm_ids = {NULL},
1594 },
1595 {
1596 .name = "KWorld Digial MC-810",
1597 .cold_ids = {&af9015_usb_table[23], NULL},
1598 .warm_ids = {NULL},
1599 },
1600 {
1601 .name = "Genius TVGo DVB-T03",
1602 .cold_ids = {&af9015_usb_table[24], NULL},
1603 .warm_ids = {NULL},
1604 },
1605 {
1606 .name = "KWorld PlusTV DVB-T PCI Pro Card " \
1607 "(DVB-T PC160-T)",
1608 .cold_ids = {&af9015_usb_table[26], NULL},
1609 .warm_ids = {NULL},
1610 },
1611 {
1612 .name = "Sveon STV20 Tuner USB DVB-T HDTV",
1613 .cold_ids = {&af9015_usb_table[27], NULL},
1614 .warm_ids = {NULL},
1615 },
1616 {
1617 .name = "Leadtek WinFast DTV2000DS",
1618 .cold_ids = {&af9015_usb_table[29], NULL},
1619 .warm_ids = {NULL},
1620 },
1621 {
1622 .name = "KWorld USB DVB-T Stick Mobile " \
1623 "(UB383-T)",
1624 .cold_ids = {&af9015_usb_table[30], NULL},
1625 .warm_ids = {NULL},
1626 },
1627 {
1628 .name = "AverMedia AVerTV Volar M (A815Mac)",
1629 .cold_ids = {&af9015_usb_table[32], NULL},
1630 .warm_ids = {NULL},
1631 },
1632 }
1633 },
1634 };
1635
1636 static int af9015_usb_probe(struct usb_interface *intf,
1637 const struct usb_device_id *id)
1638 {
1639 int ret = 0;
1640 struct dvb_usb_device *d = NULL;
1641 struct usb_device *udev = interface_to_usbdev(intf);
1642 u8 i;
1643
1644 deb_info("%s: interface:%d\n", __func__,
1645 intf->cur_altsetting->desc.bInterfaceNumber);
1646
1647 /* interface 0 is used by DVB-T receiver and
1648 interface 1 is for remote controller (HID) */
1649 if (intf->cur_altsetting->desc.bInterfaceNumber == 0) {
1650 ret = af9015_read_config(udev);
1651 if (ret)
1652 return ret;
1653
1654 for (i = 0; i < af9015_properties_count; i++) {
1655 ret = dvb_usb_device_init(intf, &af9015_properties[i],
1656 THIS_MODULE, &d, adapter_nr);
1657 if (!ret)
1658 break;
1659 if (ret != -ENODEV)
1660 return ret;
1661 }
1662 if (ret)
1663 return ret;
1664
1665 if (d)
1666 ret = af9015_init(d);
1667 }
1668
1669 return ret;
1670 }
1671
1672 static void af9015_i2c_exit(struct dvb_usb_device *d)
1673 {
1674 struct af9015_state *state = d->priv;
1675 deb_info("%s: \n", __func__);
1676
1677 /* remove 2nd I2C adapter */
1678 if (d->state & DVB_USB_STATE_I2C)
1679 i2c_del_adapter(&state->i2c_adap);
1680 }
1681
1682 static void af9015_usb_device_exit(struct usb_interface *intf)
1683 {
1684 struct dvb_usb_device *d = usb_get_intfdata(intf);
1685 deb_info("%s: \n", __func__);
1686
1687 /* remove 2nd I2C adapter */
1688 if (d != NULL && d->desc != NULL)
1689 af9015_i2c_exit(d);
1690
1691 dvb_usb_device_exit(intf);
1692 }
1693
1694 /* usb specific object needed to register this driver with the usb subsystem */
1695 static struct usb_driver af9015_usb_driver = {
1696 .name = "dvb_usb_af9015",
1697 .probe = af9015_usb_probe,
1698 .disconnect = af9015_usb_device_exit,
1699 .id_table = af9015_usb_table,
1700 };
1701
1702 /* module stuff */
1703 static int __init af9015_usb_module_init(void)
1704 {
1705 int ret;
1706 ret = usb_register(&af9015_usb_driver);
1707 if (ret)
1708 err("module init failed:%d", ret);
1709
1710 return ret;
1711 }
1712
1713 static void __exit af9015_usb_module_exit(void)
1714 {
1715 /* deregister this driver from the USB subsystem */
1716 usb_deregister(&af9015_usb_driver);
1717 }
1718
1719 module_init(af9015_usb_module_init);
1720 module_exit(af9015_usb_module_exit);
1721
1722 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1723 MODULE_DESCRIPTION("Driver for Afatech AF9015 DVB-T");
1724 MODULE_LICENSE("GPL");
Tomato firmware and modifications.