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