projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'merge' of git://git.kernel.org/pub/scm/linux/kernel/git/benh/powerpc
[linux-2.6-block.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) },
db02d9dc
AP		 795 { 0xa3703d00,
796 af9015_rc_keys_a_link, ARRAY_SIZE(af9015_rc_keys_a_link),
797 af9015_ir_table_a_link, ARRAY_SIZE(af9015_ir_table_a_link) },
58c811df
AP		 798 { 0x9b7dc64e,
799 af9015_rc_keys_mygictv, ARRAY_SIZE(af9015_rc_keys_mygictv),
800 af9015_ir_table_mygictv, ARRAY_SIZE(af9015_ir_table_mygictv) },
e3a0cc62
JS		 801 { }
802};
803
634d2d75
JS		 804static void af9015_set_remote_config(struct usb_device *udev,
805 struct dvb_usb_device_properties *props)
806{
26c3b8b0
JS		 807 const struct af9015_setup *table = NULL;
808
634d2d75
JS		 809 if (dvb_usb_af9015_remote) {
810 /* load remote defined as module param */
26c3b8b0
JS		 811 table = af9015_setup_match(dvb_usb_af9015_remote,
812 af9015_setup_modparam);
634d2d75 813 } else {
26c3b8b0
JS		 814 u16 vendor = le16_to_cpu(udev->descriptor.idVendor);
815
e3a0cc62
JS		 816 table = af9015_setup_match(af9015_config.eeprom_sum,
817 af9015_setup_hashes);
818
819 if (!table && vendor == USB_VID_AFATECH) {
26c3b8b0
JS		 820 /* Check USB manufacturer and product strings and try
821 to determine correct remote in case of chip vendor
822 reference IDs are used.
823 DO NOT ADD ANYTHING NEW HERE. Use hashes instead.
824 */
634d2d75
JS		 825 char manufacturer[10];
826 memset(manufacturer, 0, sizeof(manufacturer));
827 usb_string(udev, udev->descriptor.iManufacturer,
828 manufacturer, sizeof(manufacturer));
58c811df 829 if (!strcmp("MSI", manufacturer)) {
634d2d75
JS		 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;
8ef4c211
AP		 1005 case AF9013_TUNER_TDA18218:
1006 warn("tuner NXP TDA18218 not supported yet");
1007 return -ENODEV;
80619de8
AP		 1008 default:
1009 warn("tuner id:%d not supported, please report!", val);
1010 return -ENODEV;
1011 };
1012
1013 af9015_af9013_config[i].tuner = val;
1014 deb_info("%s: [%d] tuner id:%d\n", __func__, i, val);
1015 }
1016
1017error:
1018 if (ret)
1019 err("eeprom read failed:%d", ret);
1020
3956fefc
AP		 1021 /* AverMedia AVerTV Volar Black HD (A850) device have bad EEPROM
1022 content :-( Override some wrong values here. */
1023 if (le16_to_cpu(udev->descriptor.idVendor) == USB_VID_AVERMEDIA &&
1024 le16_to_cpu(udev->descriptor.idProduct) == USB_PID_AVERMEDIA_A850) {
1025 deb_info("%s: AverMedia A850: overriding config\n", __func__);
1026 /* disable dual mode */
1027 af9015_config.dual_mode = 0;
1028 /* disable 2nd adapter */
1029 for (i = 0; i < af9015_properties_count; i++)
1030 af9015_properties[i].num_adapters = 1;
1031
1032 /* set correct IF */
1033 af9015_af9013_config[0].tuner_if = 4570;
1034 }
1035
80619de8
AP		 1036 return ret;
1037}
1038
1039static int af9015_identify_state(struct usb_device *udev,
1040 struct dvb_usb_device_properties *props,
1041 struct dvb_usb_device_description **desc,
1042 int *cold)
1043{
1044 int ret;
1045 u8 reply;
1046 struct req_t req = {GET_CONFIG, 0, 0, 0, 0, 1, &reply};
1047
1048 ret = af9015_rw_udev(udev, &req);
1049 if (ret)
1050 return ret;
1051
1052 deb_info("%s: reply:%02x\n", __func__, reply);
1053 if (reply == 0x02)
1054 *cold = 0;
1055 else
1056 *cold = 1;
1057
1058 return ret;
1059}
1060
1061static int af9015_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
1062{
1063 u8 buf[8];
1064 struct req_t req = {GET_IR_CODE, 0, 0, 0, 0, sizeof(buf), buf};
1065 struct dvb_usb_rc_key *keymap = d->props.rc_key_map;
1066 int i, ret;
1067
1068 memset(buf, 0, sizeof(buf));
1069
1070 ret = af9015_ctrl_msg(d, &req);
1071 if (ret)
1072 return ret;
1073
1074 *event = 0;
1075 *state = REMOTE_NO_KEY_PRESSED;
1076
1077 for (i = 0; i < d->props.rc_key_map_size; i++) {
2e365883
MCC		 1078 if (!buf[1] && rc5_custom(&keymap[i]) == buf[0] &&
1079 rc5_data(&keymap[i]) == buf[2]) {
80619de8
AP		 1080 *event = keymap[i].event;
1081 *state = REMOTE_KEY_PRESSED;
1082 break;
1083 }
1084 }
1085 if (!buf[1])
1086 deb_rc("%s: %02x %02x %02x %02x %02x %02x %02x %02x\n",
1087 __func__, buf[0], buf[1], buf[2], buf[3], buf[4],
1088 buf[5], buf[6], buf[7]);
1089
1090 return 0;
1091}
1092
1093/* init 2nd I2C adapter */
349d042f 1094static int af9015_i2c_init(struct dvb_usb_device *d)
80619de8
AP		 1095{
1096 int ret;
1097 struct af9015_state *state = d->priv;
1098 deb_info("%s:\n", __func__);
1099
1100 strncpy(state->i2c_adap.name, d->desc->name,
1101 sizeof(state->i2c_adap.name));
1102#ifdef I2C_ADAP_CLASS_TV_DIGITAL
1103 state->i2c_adap.class = I2C_ADAP_CLASS_TV_DIGITAL,
1104#else
1105 state->i2c_adap.class = I2C_CLASS_TV_DIGITAL,
1106#endif
1107 state->i2c_adap.algo = d->props.i2c_algo;
1108 state->i2c_adap.algo_data = NULL;
1109 state->i2c_adap.dev.parent = &d->udev->dev;
1110
1111 i2c_set_adapdata(&state->i2c_adap, d);
1112
1113 ret = i2c_add_adapter(&state->i2c_adap);
1114 if (ret < 0)
1115 err("could not add i2c adapter");
1116
1117 return ret;
1118}
1119
1120static int af9015_af9013_frontend_attach(struct dvb_usb_adapter *adap)
1121{
1122 int ret;
1123 struct af9015_state *state = adap->dev->priv;
1124 struct i2c_adapter *i2c_adap;
1125
1126 if (adap->id == 0) {
1127 /* select I2C adapter */
1128 i2c_adap = &adap->dev->i2c_adap;
1129
1130 deb_info("%s: init I2C\n", __func__);
1131 ret = af9015_i2c_init(adap->dev);
80619de8
AP		 1132 } else {
1133 /* select I2C adapter */
1134 i2c_adap = &state->i2c_adap;
1135
1136 /* copy firmware to 2nd demodulator */
1137 if (af9015_config.dual_mode) {
1138 ret = af9015_copy_firmware(adap->dev);
1139 if (ret) {
1140 err("firmware copy to 2nd frontend " \
1141 "failed, will disable it");
1142 af9015_config.dual_mode = 0;
1143 return -ENODEV;
1144 }
1145 } else {
1146 return -ENODEV;
1147 }
1148 }
1149
1150 /* attach demodulator */
1151 adap->fe = dvb_attach(af9013_attach, &af9015_af9013_config[adap->id],
1152 i2c_adap);
1153
1154 return adap->fe == NULL ? -ENODEV : 0;
1155}
1156
1157static struct mt2060_config af9015_mt2060_config = {
1158 .i2c_address = 0xc0,
1159 .clock_out = 0,
1160};
1161
1162static struct qt1010_config af9015_qt1010_config = {
1163 .i2c_address = 0xc4,
1164};
1165
1166static struct tda18271_config af9015_tda18271_config = {
1167 .gate = TDA18271_GATE_DIGITAL,
1168 .small_i2c = 1,
1169};
1170
1171static struct mxl5005s_config af9015_mxl5003_config = {
1172 .i2c_address = 0xc6,
1173 .if_freq = IF_FREQ_4570000HZ,
1174 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
1175 .agc_mode = MXL_SINGLE_AGC,
1176 .tracking_filter = MXL_TF_DEFAULT,
a131077d 1177 .rssi_enable = MXL_RSSI_ENABLE,
80619de8
AP		 1178 .cap_select = MXL_CAP_SEL_ENABLE,
1179 .div_out = MXL_DIV_OUT_4,
1180 .clock_out = MXL_CLOCK_OUT_DISABLE,
1181 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
1182 .top = MXL5005S_TOP_25P2,
1183 .mod_mode = MXL_DIGITAL_MODE,
1184 .if_mode = MXL_ZERO_IF,
1185 .AgcMasterByte = 0x00,
1186};
1187
1188static struct mxl5005s_config af9015_mxl5005_config = {
1189 .i2c_address = 0xc6,
1190 .if_freq = IF_FREQ_4570000HZ,
1191 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
1192 .agc_mode = MXL_SINGLE_AGC,
1193 .tracking_filter = MXL_TF_OFF,
a131077d 1194 .rssi_enable = MXL_RSSI_ENABLE,
80619de8
AP		 1195 .cap_select = MXL_CAP_SEL_ENABLE,
1196 .div_out = MXL_DIV_OUT_4,
1197 .clock_out = MXL_CLOCK_OUT_DISABLE,
1198 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
1199 .top = MXL5005S_TOP_25P2,
1200 .mod_mode = MXL_DIGITAL_MODE,
1201 .if_mode = MXL_ZERO_IF,
1202 .AgcMasterByte = 0x00,
1203};
1204
d5633998
JF		 1205static struct mc44s803_config af9015_mc44s803_config = {
1206 .i2c_address = 0xc0,
1207 .dig_out = 1,
1208};
1209
80619de8
AP		 1210static int af9015_tuner_attach(struct dvb_usb_adapter *adap)
1211{
1212 struct af9015_state *state = adap->dev->priv;
1213 struct i2c_adapter *i2c_adap;
1214 int ret;
1215 deb_info("%s: \n", __func__);
1216
1217 /* select I2C adapter */
1218 if (adap->id == 0)
1219 i2c_adap = &adap->dev->i2c_adap;
1220 else
1221 i2c_adap = &state->i2c_adap;
1222
1223 switch (af9015_af9013_config[adap->id].tuner) {
1224 case AF9013_TUNER_MT2060:
1225 case AF9013_TUNER_MT2060_2:
1226 ret = dvb_attach(mt2060_attach, adap->fe, i2c_adap,
1227 &af9015_mt2060_config,
1228 af9015_config.mt2060_if1[adap->id])
1229 == NULL ? -ENODEV : 0;
1230 break;
1231 case AF9013_TUNER_QT1010:
1232 case AF9013_TUNER_QT1010A:
1233 ret = dvb_attach(qt1010_attach, adap->fe, i2c_adap,
1234 &af9015_qt1010_config) == NULL ? -ENODEV : 0;
1235 break;
1236 case AF9013_TUNER_TDA18271:
1237 ret = dvb_attach(tda18271_attach, adap->fe, 0xc0, i2c_adap,
1238 &af9015_tda18271_config) == NULL ? -ENODEV : 0;
1239 break;
1240 case AF9013_TUNER_MXL5003D:
1241 ret = dvb_attach(mxl5005s_attach, adap->fe, i2c_adap,
1242 &af9015_mxl5003_config) == NULL ? -ENODEV : 0;
1243 break;
1244 case AF9013_TUNER_MXL5005D:
1245 case AF9013_TUNER_MXL5005R:
1246 ret = dvb_attach(mxl5005s_attach, adap->fe, i2c_adap,
1247 &af9015_mxl5005_config) == NULL ? -ENODEV : 0;
1248 break;
1249 case AF9013_TUNER_ENV77H11D5:
1250 ret = dvb_attach(dvb_pll_attach, adap->fe, 0xc0, i2c_adap,
1251 DVB_PLL_TDA665X) == NULL ? -ENODEV : 0;
1252 break;
1253 case AF9013_TUNER_MC44S803:
d5633998
JF		 1254 ret = dvb_attach(mc44s803_attach, adap->fe, i2c_adap,
1255 &af9015_mc44s803_config) == NULL ? -ENODEV : 0;
80619de8
AP		 1256 break;
1257 case AF9013_TUNER_UNKNOWN:
1258 default:
1259 ret = -ENODEV;
1260 err("Unknown tuner id:%d",
1261 af9015_af9013_config[adap->id].tuner);
1262 }
1263 return ret;
1264}
1265
1266static struct usb_device_id af9015_usb_table[] = {
1267/* 0 */{USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9015_9015)},
1268 {USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9015_9016)},
1269 {USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_GOLD)},
1270 {USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV71E)},
1271 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_399U)},
1272/* 5 */{USB_DEVICE(USB_VID_VISIONPLUS,
1273 USB_PID_TINYTWIN)},
1274 {USB_DEVICE(USB_VID_VISIONPLUS,
1275 USB_PID_AZUREWAVE_AD_TU700)},
1276 {USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_USB_XE_REV2)},
1277 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_PC160_2T)},
1278 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X)},
1279/* 10 */{USB_DEVICE(USB_VID_XTENSIONS, USB_PID_XTENSIONS_XD_380)},
1280 {USB_DEVICE(USB_VID_MSI_2, USB_PID_MSI_DIGIVOX_DUO)},
1281 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X_2)},
a3765888 1282 {USB_DEVICE(USB_VID_TELESTAR, USB_PID_TELESTAR_STARSTICK_2)},
05c1cab5 1283 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A309)},
641015ab 1284/* 15 */{USB_DEVICE(USB_VID_MSI_2, USB_PID_MSI_DIGI_VOX_MINI_III)},
163e9cd0 1285 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U)},
71bf2e08 1286 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_2)},
58fe1595 1287 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_3)},
26144840 1288 {USB_DEVICE(USB_VID_AFATECH, USB_PID_TREKSTOR_DVBT)},
1ed5fade
AP		 1289/* 20 */{USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A850)},
1290 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A805)},
734dd236 1291 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_CONCEPTRONIC_CTVDIGRCU)},
6e9c1a2a 1292 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_MC810)},
22d46453 1293 {USB_DEVICE(USB_VID_KYE, USB_PID_GENIUS_TVGO_DVB_T03)},
c92f0563 1294/* 25 */{USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_399U_2)},
486ba12b 1295 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_PC160_T)},
5232263a 1296 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV20)},
fa1df55c 1297 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_TINYTWIN_2)},
809c1e8a 1298 {USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV2000DS)},
80619de8
AP		 1299 {0},
1300};
1301MODULE_DEVICE_TABLE(usb, af9015_usb_table);
1302
1303static struct dvb_usb_device_properties af9015_properties[] = {
1304 {
1305 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1306
1307 .usb_ctrl = DEVICE_SPECIFIC,
1308 .download_firmware = af9015_download_firmware,
1309 .firmware = "dvb-usb-af9015.fw",
cce25710 1310 .no_reconnect = 1,
80619de8 1311
0254294f 1312 .size_of_priv = sizeof(struct af9015_state),
80619de8
AP		 1313
1314 .num_adapters = 2,
1315 .adapter = {
1316 {
1317 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1318 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1319
1320 .pid_filter_count = 32,
1321 .pid_filter = af9015_pid_filter,
1322 .pid_filter_ctrl = af9015_pid_filter_ctrl,
1323
1324 .frontend_attach =
1325 af9015_af9013_frontend_attach,
1326 .tuner_attach = af9015_tuner_attach,
1327 .stream = {
1328 .type = USB_BULK,
1329 .count = 6,
1330 .endpoint = 0x84,
1331 },
1332 },
1333 {
1334 .frontend_attach =
1335 af9015_af9013_frontend_attach,
1336 .tuner_attach = af9015_tuner_attach,
1337 .stream = {
1338 .type = USB_BULK,
1339 .count = 6,
1340 .endpoint = 0x85,
f0830ebe
AP		 1341 .u = {
1342 .bulk = {
1343 .buffersize =
353330c3 1344 TS_USB20_FRAME_SIZE,
f0830ebe
AP		 1345 }
1346 }
80619de8
AP		 1347 },
1348 }
1349 },
1350
1351 .identify_state = af9015_identify_state,
1352
1353 .rc_query = af9015_rc_query,
1354 .rc_interval = 150,
1355
1356 .i2c_algo = &af9015_i2c_algo,
1357
85d7d7ca 1358 .num_device_descs = 9, /* max 9 */
80619de8
AP		 1359 .devices = {
1360 {
1361 .name = "Afatech AF9015 DVB-T USB2.0 stick",
1362 .cold_ids = {&af9015_usb_table[0],
1363 &af9015_usb_table[1], NULL},
1364 .warm_ids = {NULL},
1365 },
1366 {
1367 .name = "Leadtek WinFast DTV Dongle Gold",
1368 .cold_ids = {&af9015_usb_table[2], NULL},
1369 .warm_ids = {NULL},
1370 },
1371 {
1372 .name = "Pinnacle PCTV 71e",
1373 .cold_ids = {&af9015_usb_table[3], NULL},
1374 .warm_ids = {NULL},
1375 },
1376 {
1377 .name = "KWorld PlusTV Dual DVB-T Stick " \
1378 "(DVB-T 399U)",
c92f0563
MR		 1379 .cold_ids = {&af9015_usb_table[4],
1380 &af9015_usb_table[25], NULL},
80619de8
AP		 1381 .warm_ids = {NULL},
1382 },
1383 {
1384 .name = "DigitalNow TinyTwin DVB-T Receiver",
fa1df55c
AP		 1385 .cold_ids = {&af9015_usb_table[5],
1386 &af9015_usb_table[28], NULL},
80619de8
AP		 1387 .warm_ids = {NULL},
1388 },
1389 {
1390 .name = "TwinHan AzureWave AD-TU700(704J)",
1391 .cold_ids = {&af9015_usb_table[6], NULL},
1392 .warm_ids = {NULL},
1393 },
1394 {
1395 .name = "TerraTec Cinergy T USB XE",
1396 .cold_ids = {&af9015_usb_table[7], NULL},
1397 .warm_ids = {NULL},
1398 },
1399 {
1400 .name = "KWorld PlusTV Dual DVB-T PCI " \
1401 "(DVB-T PC160-2T)",
1402 .cold_ids = {&af9015_usb_table[8], NULL},
1403 .warm_ids = {NULL},
1404 },
1405 {
1406 .name = "AVerMedia AVerTV DVB-T Volar X",
1407 .cold_ids = {&af9015_usb_table[9], NULL},
1408 .warm_ids = {NULL},
1409 },
1410 }
1411 }, {
1412 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1413
1414 .usb_ctrl = DEVICE_SPECIFIC,
1415 .download_firmware = af9015_download_firmware,
1416 .firmware = "dvb-usb-af9015.fw",
cce25710 1417 .no_reconnect = 1,
80619de8 1418
0254294f 1419 .size_of_priv = sizeof(struct af9015_state),
80619de8
AP		 1420
1421 .num_adapters = 2,
1422 .adapter = {
1423 {
1424 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1425 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1426
1427 .pid_filter_count = 32,
1428 .pid_filter = af9015_pid_filter,
1429 .pid_filter_ctrl = af9015_pid_filter_ctrl,
1430
1431 .frontend_attach =
1432 af9015_af9013_frontend_attach,
1433 .tuner_attach = af9015_tuner_attach,
1434 .stream = {
1435 .type = USB_BULK,
1436 .count = 6,
1437 .endpoint = 0x84,
1438 },
1439 },
1440 {
1441 .frontend_attach =
1442 af9015_af9013_frontend_attach,
1443 .tuner_attach = af9015_tuner_attach,
1444 .stream = {
1445 .type = USB_BULK,
1446 .count = 6,
1447 .endpoint = 0x85,
f0830ebe
AP		 1448 .u = {
1449 .bulk = {
1450 .buffersize =
353330c3 1451 TS_USB20_FRAME_SIZE,
f0830ebe
AP		 1452 }
1453 }
80619de8
AP		 1454 },
1455 }
1456 },
1457
1458 .identify_state = af9015_identify_state,
1459
1460 .rc_query = af9015_rc_query,
1461 .rc_interval = 150,
1462
1463 .i2c_algo = &af9015_i2c_algo,
1464
85d7d7ca 1465 .num_device_descs = 9, /* max 9 */
80619de8
AP		 1466 .devices = {
1467 {
1468 .name = "Xtensions XD-380",
1469 .cold_ids = {&af9015_usb_table[10], NULL},
1470 .warm_ids = {NULL},
1471 },
1472 {
1473 .name = "MSI DIGIVOX Duo",
1474 .cold_ids = {&af9015_usb_table[11], NULL},
1475 .warm_ids = {NULL},
1476 },
1477 {
1478 .name = "Fujitsu-Siemens Slim Mobile USB DVB-T",
1479 .cold_ids = {&af9015_usb_table[12], NULL},
1480 .warm_ids = {NULL},
1481 },
111f9ecf 1482 {
a3765888 1483 .name = "Telestar Starstick 2",
111f9ecf
MO		 1484 .cold_ids = {&af9015_usb_table[13], NULL},
1485 .warm_ids = {NULL},
1486 },
05c1cab5
AP		 1487 {
1488 .name = "AVerMedia A309",
1489 .cold_ids = {&af9015_usb_table[14], NULL},
1490 .warm_ids = {NULL},
1491 },
641015ab
HG		 1492 {
1493 .name = "MSI Digi VOX mini III",
1494 .cold_ids = {&af9015_usb_table[15], NULL},
1495 .warm_ids = {NULL},
1496 },
163e9cd0
AP		 1497 {
1498 .name = "KWorld USB DVB-T TV Stick II " \
1499 "(VS-DVB-T 395U)",
71bf2e08 1500 .cold_ids = {&af9015_usb_table[16],
58fe1595
AP		 1501 &af9015_usb_table[17],
1502 &af9015_usb_table[18], NULL},
163e9cd0
AP		 1503 .warm_ids = {NULL},
1504 },
26144840
MS		 1505 {
1506 .name = "TrekStor DVB-T USB Stick",
1507 .cold_ids = {&af9015_usb_table[19], NULL},
1508 .warm_ids = {NULL},
1509 },
3956fefc
AP		 1510 {
1511 .name = "AverMedia AVerTV Volar Black HD " \
1512 "(A850)",
1513 .cold_ids = {&af9015_usb_table[20], NULL},
1514 .warm_ids = {NULL},
1515 },
80619de8 1516 }
85d7d7ca
AP		 1517 }, {
1518 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1519
1520 .usb_ctrl = DEVICE_SPECIFIC,
1521 .download_firmware = af9015_download_firmware,
1522 .firmware = "dvb-usb-af9015.fw",
1523 .no_reconnect = 1,
1524
0254294f 1525 .size_of_priv = sizeof(struct af9015_state),
85d7d7ca
AP		 1526
1527 .num_adapters = 2,
1528 .adapter = {
1529 {
1530 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1531 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1532
1533 .pid_filter_count = 32,
1534 .pid_filter = af9015_pid_filter,
1535 .pid_filter_ctrl = af9015_pid_filter_ctrl,
1536
1537 .frontend_attach =
1538 af9015_af9013_frontend_attach,
1539 .tuner_attach = af9015_tuner_attach,
1540 .stream = {
1541 .type = USB_BULK,
1542 .count = 6,
1543 .endpoint = 0x84,
1544 },
1545 },
1546 {
1547 .frontend_attach =
1548 af9015_af9013_frontend_attach,
1549 .tuner_attach = af9015_tuner_attach,
1550 .stream = {
1551 .type = USB_BULK,
1552 .count = 6,
1553 .endpoint = 0x85,
1554 .u = {
1555 .bulk = {
1556 .buffersize =
353330c3 1557 TS_USB20_FRAME_SIZE,
85d7d7ca
AP		 1558 }
1559 }
1560 },
1561 }
1562 },
1563
1564 .identify_state = af9015_identify_state,
1565
1566 .rc_query = af9015_rc_query,
1567 .rc_interval = 150,
1568
1569 .i2c_algo = &af9015_i2c_algo,
1570
809c1e8a 1571 .num_device_descs = 7, /* max 9 */
85d7d7ca 1572 .devices = {
1ed5fade
AP		 1573 {
1574 .name = "AverMedia AVerTV Volar GPS 805 (A805)",
1575 .cold_ids = {&af9015_usb_table[21], NULL},
1576 .warm_ids = {NULL},
1577 },
734dd236
MJ		 1578 {
1579 .name = "Conceptronic USB2.0 DVB-T CTVDIGRCU " \
1580 "V3.0",
1581 .cold_ids = {&af9015_usb_table[22], NULL},
1582 .warm_ids = {NULL},
1583 },
6e9c1a2a
WJS		 1584 {
1585 .name = "KWorld Digial MC-810",
1586 .cold_ids = {&af9015_usb_table[23], NULL},
1587 .warm_ids = {NULL},
1588 },
22d46453
AP		 1589 {
1590 .name = "Genius TVGo DVB-T03",
1591 .cold_ids = {&af9015_usb_table[24], NULL},
1592 .warm_ids = {NULL},
1593 },
486ba12b
AP		 1594 {
1595 .name = "KWorld PlusTV DVB-T PCI Pro Card " \
1596 "(DVB-T PC160-T)",
1597 .cold_ids = {&af9015_usb_table[26], NULL},
1598 .warm_ids = {NULL},
1599 },
5232263a
IMD		 1600 {
1601 .name = "Sveon STV20 Tuner USB DVB-T HDTV",
1602 .cold_ids = {&af9015_usb_table[27], NULL},
1603 .warm_ids = {NULL},
1604 },
809c1e8a
AP		 1605 {
1606 .name = "Leadtek WinFast DTV2000DS",
1607 .cold_ids = {&af9015_usb_table[29], NULL},
1608 .warm_ids = {NULL},
1609 },
85d7d7ca
AP		 1610 }
1611 },
80619de8 1612};
80619de8
AP		 1613
1614static int af9015_usb_probe(struct usb_interface *intf,
1615 const struct usb_device_id *id)
1616{
1617 int ret = 0;
1618 struct dvb_usb_device *d = NULL;
1619 struct usb_device *udev = interface_to_usbdev(intf);
1620 u8 i;
1621
1622 deb_info("%s: interface:%d\n", __func__,
1623 intf->cur_altsetting->desc.bInterfaceNumber);
1624
1625 /* interface 0 is used by DVB-T receiver and
1626 interface 1 is for remote controller (HID) */
1627 if (intf->cur_altsetting->desc.bInterfaceNumber == 0) {
1628 ret = af9015_read_config(udev);
1629 if (ret)
1630 return ret;
1631
1632 for (i = 0; i < af9015_properties_count; i++) {
1633 ret = dvb_usb_device_init(intf, &af9015_properties[i],
1634 THIS_MODULE, &d, adapter_nr);
1635 if (!ret)
1636 break;
1637 if (ret != -ENODEV)
1638 return ret;
1639 }
1640 if (ret)
1641 return ret;
1642
1643 if (d)
1644 ret = af9015_init(d);
1645 }
1646
1647 return ret;
1648}
1649
349d042f 1650static void af9015_i2c_exit(struct dvb_usb_device *d)
80619de8
AP		 1651{
1652 struct af9015_state *state = d->priv;
1653 deb_info("%s: \n", __func__);
1654
1655 /* remove 2nd I2C adapter */
1656 if (d->state & DVB_USB_STATE_I2C)
1657 i2c_del_adapter(&state->i2c_adap);
1658}
1659
1660static void af9015_usb_device_exit(struct usb_interface *intf)
1661{
1662 struct dvb_usb_device *d = usb_get_intfdata(intf);
1663 deb_info("%s: \n", __func__);
1664
1665 /* remove 2nd I2C adapter */
1666 if (d != NULL && d->desc != NULL)
1667 af9015_i2c_exit(d);
1668
1669 dvb_usb_device_exit(intf);
1670}
1671
1672/* usb specific object needed to register this driver with the usb subsystem */
1673static struct usb_driver af9015_usb_driver = {
1674 .name = "dvb_usb_af9015",
1675 .probe = af9015_usb_probe,
1676 .disconnect = af9015_usb_device_exit,
1677 .id_table = af9015_usb_table,
1678};
1679
1680/* module stuff */
1681static int __init af9015_usb_module_init(void)
1682{
1683 int ret;
1684 ret = usb_register(&af9015_usb_driver);
1685 if (ret)
1686 err("module init failed:%d", ret);
1687
1688 return ret;
1689}
1690
1691static void __exit af9015_usb_module_exit(void)
1692{
1693 /* deregister this driver from the USB subsystem */
1694 usb_deregister(&af9015_usb_driver);
1695}
1696
1697module_init(af9015_usb_module_init);
1698module_exit(af9015_usb_module_exit);
1699
1700MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1701MODULE_DESCRIPTION("Driver for Afatech AF9015 DVB-T");
1702MODULE_LICENSE("GPL");
Linux 6.x block layer and io_uring tree(s)