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