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