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