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