1 /*
2 * DVB USB Linux driver for Afatech AF9015 DVB-T USB2.0 receiver
3 *
4 * Copyright (C) 2007 Antti Palosaari <crope@iki.fi>
5 *
6 * Thanks to Afatech who kindly provided information.
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 *
22 */
23
24 #include <linux/hash.h>
25 #include <linux/slab.h>
26
27 #include "af9015.h"
28 #include "af9013.h"
29 #include "mt2060.h"
30 #include "qt1010.h"
31 #include "tda18271.h"
32 #include "mxl5005s.h"
33 #include "mc44s803.h"
34 #include "tda18218.h"
35 #include "mxl5007t.h"
36
37 static int dvb_usb_af9015_debug;
38 module_param_named(debug, dvb_usb_af9015_debug, int, 0644);
39 MODULE_PARM_DESC(debug, "set debugging level" DVB_USB_DEBUG_STATUS);
40 static int dvb_usb_af9015_remote;
41 module_param_named(remote, dvb_usb_af9015_remote, int, 0644);
42 MODULE_PARM_DESC(remote, "select remote");
43 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
44
45 static DEFINE_MUTEX(af9015_usb_mutex);
46
47 static struct af9015_config af9015_config;
48 static struct dvb_usb_device_properties af9015_properties[3];
49 static int af9015_properties_count = ARRAY_SIZE(af9015_properties);
50
51 static struct af9013_config af9015_af9013_config[] = {
52 {
53 .i2c_addr = AF9015_I2C_DEMOD,
54 .ts_mode = AF9013_TS_USB,
55 .api_version = { 0, 1, 9, 0 },
56 .gpio[0] = AF9013_GPIO_HI,
57 .gpio[3] = AF9013_GPIO_TUNER_ON,
58
59 }, {
60 .ts_mode = AF9013_TS_SERIAL,
61 .api_version = { 0, 1, 9, 0 },
62 .gpio[0] = AF9013_GPIO_TUNER_ON,
63 .gpio[1] = AF9013_GPIO_LO,
64 }
65 };
66
af9015_rw_udev(struct usb_device * udev,struct req_t * req)67 static int af9015_rw_udev(struct usb_device *udev, struct req_t *req)
68 {
69 #define BUF_LEN 63
70 #define REQ_HDR_LEN 8 /* send header size */
71 #define ACK_HDR_LEN 2 /* rece header size */
72 int act_len, ret;
73 u8 buf[BUF_LEN];
74 u8 write = 1;
75 u8 msg_len = REQ_HDR_LEN;
76 static u8 seq; /* packet sequence number */
77
78 if (mutex_lock_interruptible(&af9015_usb_mutex) < 0)
79 return -EAGAIN;
80
81 buf[0] = req->cmd;
82 buf[1] = seq++;
83 buf[2] = req->i2c_addr;
84 buf[3] = req->addr >> 8;
85 buf[4] = req->addr & 0xff;
86 buf[5] = req->mbox;
87 buf[6] = req->addr_len;
88 buf[7] = req->data_len;
89
90 switch (req->cmd) {
91 case GET_CONFIG:
92 case READ_MEMORY:
93 case RECONNECT_USB:
94 write = 0;
95 break;
96 case READ_I2C:
97 write = 0;
98 buf[2] |= 0x01; /* set I2C direction */
99 case WRITE_I2C:
100 buf[0] = READ_WRITE_I2C;
101 break;
102 case WRITE_MEMORY:
103 if (((req->addr & 0xff00) == 0xff00) ||
104 ((req->addr & 0xff00) == 0xae00))
105 buf[0] = WRITE_VIRTUAL_MEMORY;
106 case WRITE_VIRTUAL_MEMORY:
107 case COPY_FIRMWARE:
108 case DOWNLOAD_FIRMWARE:
109 case BOOT:
110 break;
111 default:
112 err("unknown command:%d", req->cmd);
113 ret = -1;
114 goto error_unlock;
115 }
116
117 /* buffer overflow check */
118 if ((write && (req->data_len > BUF_LEN - REQ_HDR_LEN)) ||
119 (!write && (req->data_len > BUF_LEN - ACK_HDR_LEN))) {
120 err("too much data; cmd:%d len:%d", req->cmd, req->data_len);
121 ret = -EINVAL;
122 goto error_unlock;
123 }
124
125 /* write requested */
126 if (write) {
127 memcpy(&buf[REQ_HDR_LEN], req->data, req->data_len);
128 msg_len += req->data_len;
129 }
130
131 deb_xfer(">>> ");
132 debug_dump(buf, msg_len, deb_xfer);
133
134 /* send req */
135 ret = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 0x02), buf, msg_len,
136 &act_len, AF9015_USB_TIMEOUT);
137 if (ret)
138 err("bulk message failed:%d (%d/%d)", ret, msg_len, act_len);
139 else
140 if (act_len != msg_len)
141 ret = -1; /* all data is not send */
142 if (ret)
143 goto error_unlock;
144
145 /* no ack for those packets */
146 if (req->cmd == DOWNLOAD_FIRMWARE || req->cmd == RECONNECT_USB)
147 goto exit_unlock;
148
149 /* write receives seq + status = 2 bytes
150 read receives seq + status + data = 2 + N bytes */
151 msg_len = ACK_HDR_LEN;
152 if (!write)
153 msg_len += req->data_len;
154
155 ret = usb_bulk_msg(udev, usb_rcvbulkpipe(udev, 0x81), buf, msg_len,
156 &act_len, AF9015_USB_TIMEOUT);
157 if (ret) {
158 err("recv bulk message failed:%d", ret);
159 ret = -1;
160 goto error_unlock;
161 }
162
163 deb_xfer("<<< ");
164 debug_dump(buf, act_len, deb_xfer);
165
166 /* check status */
167 if (buf[1]) {
168 err("command failed:%d", buf[1]);
169 ret = -1;
170 goto error_unlock;
171 }
172
173 /* read request, copy returned data to return buf */
174 if (!write)
175 memcpy(req->data, &buf[ACK_HDR_LEN], req->data_len);
176
177 error_unlock:
178 exit_unlock:
179 mutex_unlock(&af9015_usb_mutex);
180
181 return ret;
182 }
183
af9015_ctrl_msg(struct dvb_usb_device * d,struct req_t * req)184 static int af9015_ctrl_msg(struct dvb_usb_device *d, struct req_t *req)
185 {
186 return af9015_rw_udev(d->udev, req);
187 }
188
af9015_write_regs(struct dvb_usb_device * d,u16 addr,u8 * val,u8 len)189 static int af9015_write_regs(struct dvb_usb_device *d, u16 addr, u8 *val,
190 u8 len)
191 {
192 struct req_t req = {WRITE_MEMORY, AF9015_I2C_DEMOD, addr, 0, 0, len,
193 val};
194 return af9015_ctrl_msg(d, &req);
195 }
196
af9015_write_reg(struct dvb_usb_device * d,u16 addr,u8 val)197 static int af9015_write_reg(struct dvb_usb_device *d, u16 addr, u8 val)
198 {
199 return af9015_write_regs(d, addr, &val, 1);
200 }
201
af9015_read_regs(struct dvb_usb_device * d,u16 addr,u8 * val,u8 len)202 static int af9015_read_regs(struct dvb_usb_device *d, u16 addr, u8 *val, u8 len)
203 {
204 struct req_t req = {READ_MEMORY, AF9015_I2C_DEMOD, addr, 0, 0, len,
205 val};
206 return af9015_ctrl_msg(d, &req);
207 }
208
af9015_read_reg(struct dvb_usb_device * d,u16 addr,u8 * val)209 static int af9015_read_reg(struct dvb_usb_device *d, u16 addr, u8 *val)
210 {
211 return af9015_read_regs(d, addr, val, 1);
212 }
213
af9015_write_reg_i2c(struct dvb_usb_device * d,u8 addr,u16 reg,u8 val)214 static int af9015_write_reg_i2c(struct dvb_usb_device *d, u8 addr, u16 reg,
215 u8 val)
216 {
217 struct req_t req = {WRITE_I2C, addr, reg, 1, 1, 1, &val};
218
219 if (addr == af9015_af9013_config[0].i2c_addr ||
220 addr == af9015_af9013_config[1].i2c_addr)
221 req.addr_len = 3;
222
223 return af9015_ctrl_msg(d, &req);
224 }
225
af9015_read_reg_i2c(struct dvb_usb_device * d,u8 addr,u16 reg,u8 * val)226 static int af9015_read_reg_i2c(struct dvb_usb_device *d, u8 addr, u16 reg,
227 u8 *val)
228 {
229 struct req_t req = {READ_I2C, addr, reg, 0, 1, 1, val};
230
231 if (addr == af9015_af9013_config[0].i2c_addr ||
232 addr == af9015_af9013_config[1].i2c_addr)
233 req.addr_len = 3;
234
235 return af9015_ctrl_msg(d, &req);
236 }
237
af9015_i2c_xfer(struct i2c_adapter * adap,struct i2c_msg msg[],int num)238 static int af9015_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
239 int num)
240 {
241 struct dvb_usb_device *d = i2c_get_adapdata(adap);
242 int ret = 0, i = 0;
243 u16 addr;
244 u8 uninitialized_var(mbox), addr_len;
245 struct req_t req;
246
247 /* TODO: implement bus lock
248
249 The bus lock is needed because there is two tuners both using same I2C-address.
250 Due to that the only way to select correct tuner is use demodulator I2C-gate.
251
252 ................................................
253 . AF9015 includes integrated AF9013 demodulator.
254 . ____________ ____________ . ____________
255 .| uC | | demod | . | tuner |
256 .|------------| |------------| . |------------|
257 .| AF9015 | | AF9013/5 | . | MXL5003 |
258 .| |--+----I2C-------|-----/ -----|-.-----I2C-------| |
259 .| | | | addr 0x38 | . | addr 0xc6 |
260 .|____________| | |____________| . |____________|
261 .................|..............................
262 | ____________ ____________
263 | | demod | | tuner |
264 | |------------| |------------|
265 | | AF9013 | | MXL5003 |
266 +----I2C-------|-----/ -----|-------I2C-------| |
267 | addr 0x3a | | addr 0xc6 |
268 |____________| |____________|
269 */
270 if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
271 return -EAGAIN;
272
273 while (i < num) {
274 if (msg[i].addr == af9015_af9013_config[0].i2c_addr ||
275 msg[i].addr == af9015_af9013_config[1].i2c_addr) {
276 addr = msg[i].buf[0] << 8;
277 addr += msg[i].buf[1];
278 mbox = msg[i].buf[2];
279 addr_len = 3;
280 } else {
281 addr = msg[i].buf[0];
282 addr_len = 1;
283 /* mbox is don't care in that case */
284 }
285
286 if (num > i + 1 && (msg[i+1].flags & I2C_M_RD)) {
287 if (msg[i].len > 3 || msg[i+1].len > 61) {
288 ret = -EOPNOTSUPP;
289 goto error;
290 }
291 if (msg[i].addr == af9015_af9013_config[0].i2c_addr)
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;
303 } else if (msg[i].flags & I2C_M_RD) {
304 if (msg[i].len > 61) {
305 ret = -EOPNOTSUPP;
306 goto error;
307 }
308 if (msg[i].addr ==
309 af9015_af9013_config[0].i2c_addr) {
310 ret = -EINVAL;
311 goto error;
312 }
313 req.cmd = READ_I2C;
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;
322 } else {
323 if (msg[i].len > 21) {
324 ret = -EOPNOTSUPP;
325 goto error;
326 }
327 if (msg[i].addr == af9015_af9013_config[0].i2c_addr)
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
346 error:
347 mutex_unlock(&d->i2c_mutex);
348
349 return ret;
350 }
351
af9015_i2c_func(struct i2c_adapter * adapter)352 static u32 af9015_i2c_func(struct i2c_adapter *adapter)
353 {
354 return I2C_FUNC_I2C;
355 }
356
357 static struct i2c_algorithm af9015_i2c_algo = {
358 .master_xfer = af9015_i2c_xfer,
359 .functionality = af9015_i2c_func,
360 };
361
af9015_do_reg_bit(struct dvb_usb_device * d,u16 addr,u8 bit,u8 op)362 static 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
af9015_set_reg_bit(struct dvb_usb_device * d,u16 addr,u8 bit)384 static 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
af9015_clear_reg_bit(struct dvb_usb_device * d,u16 addr,u8 bit)389 static 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
af9015_init_endpoint(struct dvb_usb_device * d)394 static 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
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. */
403 #define TS_PACKET_SIZE 188
404
405 #define TS_USB20_PACKET_COUNT 87
406 #define TS_USB20_FRAME_SIZE (TS_PACKET_SIZE*TS_USB20_PACKET_COUNT)
407
408 #define TS_USB11_PACKET_COUNT 5
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);
484
485 error:
486 if (ret)
487 err("endpoint init failed:%d", ret);
488 return ret;
489 }
490
af9015_copy_firmware(struct dvb_usb_device * d)491 static 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
508 ret = af9015_read_reg_i2c(d,
509 af9015_af9013_config[1].i2c_addr, 0x98be, &val);
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 */
537 ret = af9015_write_reg_i2c(d, af9015_af9013_config[1].i2c_addr,
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,
548 af9015_af9013_config[1].i2c_addr, 0x98be, &val);
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
566 error:
567 exit:
568 return ret;
569 }
570
571 /* hash (and dump) eeprom */
af9015_eeprom_hash(struct usb_device * udev)572 static int af9015_eeprom_hash(struct usb_device *udev)
573 {
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};
579
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;
590 }
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;
607 free:
608 kfree(eeprom);
609 return ret;
610 }
611
af9015_init(struct dvb_usb_device * d)612 static int af9015_init(struct dvb_usb_device *d)
613 {
614 int ret;
615 deb_info("%s:\n", __func__);
616
617 /* init RC canary */
618 ret = af9015_write_reg(d, 0x98e9, 0xff);
619 if (ret)
620 goto error;
621
622 ret = af9015_init_endpoint(d);
623 if (ret)
624 goto error;
625
626 error:
627 return ret;
628 }
629
af9015_pid_filter_ctrl(struct dvb_usb_adapter * adap,int onoff)630 static 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
af9015_pid_filter(struct dvb_usb_adapter * adap,int index,u16 pid,int onoff)643 static 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
663 error:
664 return ret;
665 }
666
af9015_download_firmware(struct usb_device * udev,const struct firmware * fw)667 static int af9015_download_firmware(struct usb_device *udev,
668 const struct firmware *fw)
669 {
670 int i, len, remaining, ret;
671 struct req_t req = {DOWNLOAD_FIRMWARE, 0, 0, 0, 0, 0, NULL};
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
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;
689
690 req.data_len = len;
691 req.data = (u8 *) &fw->data[fw->size - remaining];
692 req.addr = FW_ADDR + fw->size - remaining;
693
694 ret = af9015_rw_udev(udev, &req);
695 if (ret) {
696 err("firmware download failed:%d", ret);
697 goto error;
698 }
699 }
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
709 error:
710 return ret;
711 }
712
713 struct af9015_rc_setup {
714 unsigned int id;
715 char *rc_codes;
716 };
717
af9015_rc_setup_match(unsigned int id,const struct af9015_rc_setup * table)718 static char *af9015_rc_setup_match(unsigned int id,
719 const struct af9015_rc_setup *table)
720 {
721 for (; table->rc_codes; table++)
722 if (table->id == id)
723 return table->rc_codes;
724 return NULL;
725 }
726
727 static 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 },
733 { }
734 };
735
736 static 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 */
740 { 0x5d49e3db, RC_MAP_DIGITTRADE }, /* LC-Power LC-USB-DVBT */
741 { }
742 };
743
744 static const struct af9015_rc_setup af9015_rc_setup_usbids[] = {
745 { (USB_VID_TERRATEC << 16) | USB_PID_TERRATEC_CINERGY_T_STICK_RC,
746 RC_MAP_TERRATEC_SLIM_2 },
747 { (USB_VID_TERRATEC << 16) | USB_PID_TERRATEC_CINERGY_T_STICK_DUAL_RC,
748 RC_MAP_TERRATEC_SLIM },
749 { (USB_VID_VISIONPLUS << 16) | USB_PID_AZUREWAVE_AD_TU700,
750 RC_MAP_AZUREWAVE_AD_TU700 },
751 { (USB_VID_VISIONPLUS << 16) | USB_PID_TINYTWIN,
752 RC_MAP_AZUREWAVE_AD_TU700 },
753 { (USB_VID_MSI_2 << 16) | USB_PID_MSI_DIGI_VOX_MINI_III,
754 RC_MAP_MSI_DIGIVOX_III },
755 { (USB_VID_MSI_2 << 16) | USB_PID_MSI_DIGIVOX_DUO,
756 RC_MAP_MSI_DIGIVOX_III },
757 { (USB_VID_LEADTEK << 16) | USB_PID_WINFAST_DTV_DONGLE_GOLD,
758 RC_MAP_LEADTEK_Y04G0051 },
759 { (USB_VID_LEADTEK << 16) | USB_PID_WINFAST_DTV2000DS,
760 RC_MAP_LEADTEK_Y04G0051 },
761 { (USB_VID_AVERMEDIA << 16) | USB_PID_AVERMEDIA_VOLAR_X,
762 RC_MAP_AVERMEDIA_M135A },
763 { (USB_VID_AFATECH << 16) | USB_PID_TREKSTOR_DVBT,
764 RC_MAP_TREKSTOR },
765 { (USB_VID_KWORLD_2 << 16) | USB_PID_TINYTWIN_2,
766 RC_MAP_DIGITALNOW_TINYTWIN },
767 { (USB_VID_GTEK << 16) | USB_PID_TINYTWIN_3,
768 RC_MAP_DIGITALNOW_TINYTWIN },
769 { (USB_VID_KWORLD_2 << 16) | USB_PID_SVEON_STV22,
770 RC_MAP_MSI_DIGIVOX_III },
771 { }
772 };
773
af9015_set_remote_config(struct usb_device * udev,struct dvb_usb_device_properties * props)774 static void af9015_set_remote_config(struct usb_device *udev,
775 struct dvb_usb_device_properties *props)
776 {
777 u16 vid = le16_to_cpu(udev->descriptor.idVendor);
778 u16 pid = le16_to_cpu(udev->descriptor.idProduct);
779
780 /* try to load remote based module param */
781 props->rc.core.rc_codes = af9015_rc_setup_match(
782 dvb_usb_af9015_remote, af9015_rc_setup_modparam);
783
784 /* try to load remote based eeprom hash */
785 if (!props->rc.core.rc_codes)
786 props->rc.core.rc_codes = af9015_rc_setup_match(
787 af9015_config.eeprom_sum, af9015_rc_setup_hashes);
788
789 /* try to load remote based USB ID */
790 if (!props->rc.core.rc_codes)
791 props->rc.core.rc_codes = af9015_rc_setup_match(
792 (vid << 16) + pid, af9015_rc_setup_usbids);
793
794 /* try to load remote based USB iManufacturer string */
795 if (!props->rc.core.rc_codes && vid == USB_VID_AFATECH) {
796 /* Check USB manufacturer and product strings and try
797 to determine correct remote in case of chip vendor
798 reference IDs are used.
799 DO NOT ADD ANYTHING NEW HERE. Use hashes instead. */
800 char manufacturer[10];
801 memset(manufacturer, 0, sizeof(manufacturer));
802 usb_string(udev, udev->descriptor.iManufacturer,
803 manufacturer, sizeof(manufacturer));
804 if (!strcmp("MSI", manufacturer)) {
805 /* iManufacturer 1 MSI
806 iProduct 2 MSI K-VOX */
807 props->rc.core.rc_codes = af9015_rc_setup_match(
808 AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3,
809 af9015_rc_setup_modparam);
810 }
811 }
812
813 /* finally load "empty" just for leaving IR receiver enabled */
814 if (!props->rc.core.rc_codes)
815 props->rc.core.rc_codes = RC_MAP_EMPTY;
816
817 return;
818 }
819
af9015_read_config(struct usb_device * udev)820 static int af9015_read_config(struct usb_device *udev)
821 {
822 int ret;
823 u8 val, i, offset = 0;
824 struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, &val};
825
826 /* IR remote controller */
827 req.addr = AF9015_EEPROM_IR_MODE;
828 /* first message will timeout often due to possible hw bug */
829 for (i = 0; i < 4; i++) {
830 ret = af9015_rw_udev(udev, &req);
831 if (!ret)
832 break;
833 }
834 if (ret)
835 goto error;
836
837 ret = af9015_eeprom_hash(udev);
838 if (ret)
839 goto error;
840
841 deb_info("%s: IR mode=%d\n", __func__, val);
842 for (i = 0; i < af9015_properties_count; i++) {
843 if (val == AF9015_IR_MODE_DISABLED)
844 af9015_properties[i].rc.core.rc_codes = NULL;
845 else
846 af9015_set_remote_config(udev, &af9015_properties[i]);
847 }
848
849 /* TS mode - one or two receivers */
850 req.addr = AF9015_EEPROM_TS_MODE;
851 ret = af9015_rw_udev(udev, &req);
852 if (ret)
853 goto error;
854 af9015_config.dual_mode = val;
855 deb_info("%s: TS mode=%d\n", __func__, af9015_config.dual_mode);
856
857 /* Set adapter0 buffer size according to USB port speed, adapter1 buffer
858 size can be static because it is enabled only USB2.0 */
859 for (i = 0; i < af9015_properties_count; i++) {
860 /* USB1.1 set smaller buffersize and disable 2nd adapter */
861 if (udev->speed == USB_SPEED_FULL) {
862 af9015_properties[i].adapter[0].fe[0].stream.u.bulk.buffersize
863 = TS_USB11_FRAME_SIZE;
864 /* disable 2nd adapter because we don't have
865 PID-filters */
866 af9015_config.dual_mode = 0;
867 } else {
868 af9015_properties[i].adapter[0].fe[0].stream.u.bulk.buffersize
869 = TS_USB20_FRAME_SIZE;
870 }
871 }
872
873 if (af9015_config.dual_mode) {
874 /* read 2nd demodulator I2C address */
875 req.addr = AF9015_EEPROM_DEMOD2_I2C;
876 ret = af9015_rw_udev(udev, &req);
877 if (ret)
878 goto error;
879 af9015_af9013_config[1].i2c_addr = val;
880
881 /* enable 2nd adapter */
882 for (i = 0; i < af9015_properties_count; i++)
883 af9015_properties[i].num_adapters = 2;
884
885 } else {
886 /* disable 2nd adapter */
887 for (i = 0; i < af9015_properties_count; i++)
888 af9015_properties[i].num_adapters = 1;
889 }
890
891 for (i = 0; i < af9015_properties[0].num_adapters; i++) {
892 if (i == 1)
893 offset = AF9015_EEPROM_OFFSET;
894 /* xtal */
895 req.addr = AF9015_EEPROM_XTAL_TYPE1 + offset;
896 ret = af9015_rw_udev(udev, &req);
897 if (ret)
898 goto error;
899 switch (val) {
900 case 0:
901 af9015_af9013_config[i].clock = 28800000;
902 break;
903 case 1:
904 af9015_af9013_config[i].clock = 20480000;
905 break;
906 case 2:
907 af9015_af9013_config[i].clock = 28000000;
908 break;
909 case 3:
910 af9015_af9013_config[i].clock = 25000000;
911 break;
912 };
913 deb_info("%s: [%d] xtal=%d set clock=%d\n", __func__, i,
914 val, af9015_af9013_config[i].clock);
915
916 /* IF frequency */
917 req.addr = AF9015_EEPROM_IF1H + offset;
918 ret = af9015_rw_udev(udev, &req);
919 if (ret)
920 goto error;
921
922 af9015_af9013_config[i].if_frequency = val << 8;
923
924 req.addr = AF9015_EEPROM_IF1L + offset;
925 ret = af9015_rw_udev(udev, &req);
926 if (ret)
927 goto error;
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);
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;
945 deb_info("%s: [%d] MT2060 IF1=%d\n", __func__, i,
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:
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:
961 case AF9013_TUNER_TDA18218:
962 af9015_af9013_config[i].spec_inv = 1;
963 break;
964 case AF9013_TUNER_MXL5003D:
965 case AF9013_TUNER_MXL5005D:
966 case AF9013_TUNER_MXL5005R:
967 case AF9013_TUNER_MXL5007T:
968 af9015_af9013_config[i].spec_inv = 0;
969 break;
970 case AF9013_TUNER_MC44S803:
971 af9015_af9013_config[i].gpio[1] = AF9013_GPIO_LO;
972 af9015_af9013_config[i].spec_inv = 1;
973 break;
974 default:
975 warn("tuner id=%d not supported, please report!", val);
976 return -ENODEV;
977 };
978
979 af9015_af9013_config[i].tuner = val;
980 deb_info("%s: [%d] tuner id=%d\n", __func__, i, val);
981 }
982
983 error:
984 if (ret)
985 err("eeprom read failed=%d", ret);
986
987 /* AverMedia AVerTV Volar Black HD (A850) device have bad EEPROM
988 content :-( Override some wrong values here. Ditto for the
989 AVerTV Red HD+ (A850T) device. */
990 if (le16_to_cpu(udev->descriptor.idVendor) == USB_VID_AVERMEDIA &&
991 ((le16_to_cpu(udev->descriptor.idProduct) ==
992 USB_PID_AVERMEDIA_A850) ||
993 (le16_to_cpu(udev->descriptor.idProduct) ==
994 USB_PID_AVERMEDIA_A850T))) {
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 */
1003 af9015_af9013_config[0].if_frequency = 4570000;
1004 }
1005
1006 return ret;
1007 }
1008
af9015_identify_state(struct usb_device * udev,struct dvb_usb_device_properties * props,struct dvb_usb_device_description ** desc,int * cold)1009 static 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
af9015_rc_query(struct dvb_usb_device * d)1031 static int af9015_rc_query(struct dvb_usb_device *d)
1032 {
1033 struct af9015_state *priv = d->priv;
1034 int ret;
1035 u8 buf[17];
1036
1037 /* read registers needed to detect remote controller code */
1038 ret = af9015_read_regs(d, 0x98d9, buf, sizeof(buf));
1039 if (ret)
1040 goto error;
1041
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) {
1057 deb_rc("%s: key pressed %02x %02x %02x %02x\n", __func__,
1058 buf[12], buf[13], buf[14], buf[15]);
1059
1060 /* Reset the canary */
1061 ret = af9015_write_reg(d, 0x98e9, 0xff);
1062 if (ret)
1063 goto error;
1064
1065 /* Remember this key */
1066 memcpy(priv->rc_last, &buf[12], 4);
1067 if (buf[14] == (u8) ~buf[15]) {
1068 if (buf[12] == (u8) ~buf[13]) {
1069 /* NEC */
1070 priv->rc_keycode = buf[12] << 8 | buf[14];
1071 } else {
1072 /* NEC extended*/
1073 priv->rc_keycode = buf[12] << 16 |
1074 buf[13] << 8 | buf[14];
1075 }
1076 } else {
1077 /* 32 bit NEC */
1078 priv->rc_keycode = buf[12] << 24 | buf[13] << 16 |
1079 buf[14] << 8 | buf[15];
1080 }
1081 rc_keydown(d->rc_dev, priv->rc_keycode, 0);
1082 } else {
1083 deb_rc("%s: no key press\n", __func__);
1084 /* Invalidate last keypress */
1085 /* Not really needed, but helps with debug */
1086 priv->rc_last[2] = priv->rc_last[3];
1087 }
1088
1089 priv->rc_repeat = buf[6];
1090
1091 error:
1092 if (ret)
1093 err("%s: failed:%d", __func__, ret);
1094
1095 return ret;
1096 }
1097
1098 /* override demod callbacks for resource locking */
af9015_af9013_set_frontend(struct dvb_frontend * fe)1099 static int af9015_af9013_set_frontend(struct dvb_frontend *fe)
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
1108 ret = priv->set_frontend[adap->id](fe);
1109
1110 mutex_unlock(&adap->dev->usb_mutex);
1111
1112 return ret;
1113 }
1114
1115 /* override demod callbacks for resource locking */
af9015_af9013_read_status(struct dvb_frontend * fe,fe_status_t * status)1116 static 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 */
af9015_af9013_init(struct dvb_frontend * fe)1134 static 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);
1144
1145 mutex_unlock(&adap->dev->usb_mutex);
1146
1147 return ret;
1148 }
1149
1150 /* override demod callbacks for resource locking */
af9015_af9013_sleep(struct dvb_frontend * fe)1151 static int af9015_af9013_sleep(struct dvb_frontend *fe)
1152 {
1153 int ret;
1154 struct dvb_usb_adapter *adap = fe->dvb->priv;
1155 struct af9015_state *priv = adap->dev->priv;
1156
1157 if (mutex_lock_interruptible(&adap->dev->usb_mutex))
1158 return -EAGAIN;
1159
1160 ret = priv->sleep[adap->id](fe);
1161
1162 mutex_unlock(&adap->dev->usb_mutex);
1163
1164 return ret;
1165 }
1166
1167 /* override tuner callbacks for resource locking */
af9015_tuner_init(struct dvb_frontend * fe)1168 static int af9015_tuner_init(struct dvb_frontend *fe)
1169 {
1170 int ret;
1171 struct dvb_usb_adapter *adap = fe->dvb->priv;
1172 struct af9015_state *priv = adap->dev->priv;
1173
1174 if (mutex_lock_interruptible(&adap->dev->usb_mutex))
1175 return -EAGAIN;
1176
1177 ret = priv->tuner_init[adap->id](fe);
1178
1179 mutex_unlock(&adap->dev->usb_mutex);
1180
1181 return ret;
1182 }
1183
1184 /* override tuner callbacks for resource locking */
af9015_tuner_sleep(struct dvb_frontend * fe)1185 static int af9015_tuner_sleep(struct dvb_frontend *fe)
1186 {
1187 int ret;
1188 struct dvb_usb_adapter *adap = fe->dvb->priv;
1189 struct af9015_state *priv = adap->dev->priv;
1190
1191 if (mutex_lock_interruptible(&adap->dev->usb_mutex))
1192 return -EAGAIN;
1193
1194 ret = priv->tuner_sleep[adap->id](fe);
1195
1196 mutex_unlock(&adap->dev->usb_mutex);
1197
1198 return ret;
1199 }
1200
1201
af9015_af9013_frontend_attach(struct dvb_usb_adapter * adap)1202 static int af9015_af9013_frontend_attach(struct dvb_usb_adapter *adap)
1203 {
1204 int ret;
1205 struct af9015_state *state = adap->dev->priv;
1206
1207 if (adap->id == 1) {
1208 /* copy firmware to 2nd demodulator */
1209 if (af9015_config.dual_mode) {
1210 ret = af9015_copy_firmware(adap->dev);
1211 if (ret) {
1212 err("firmware copy to 2nd frontend " \
1213 "failed, will disable it");
1214 af9015_config.dual_mode = 0;
1215 return -ENODEV;
1216 }
1217 } else {
1218 return -ENODEV;
1219 }
1220 }
1221
1222 /* attach demodulator */
1223 adap->fe_adap[0].fe = dvb_attach(af9013_attach, &af9015_af9013_config[adap->id],
1224 &adap->dev->i2c_adap);
1225
1226 /*
1227 * AF9015 firmware does not like if it gets interrupted by I2C adapter
1228 * request on some critical phases. During normal operation I2C adapter
1229 * is used only 2nd demodulator and tuner on dual tuner devices.
1230 * Override demodulator callbacks and use mutex for limit access to
1231 * those "critical" paths to keep AF9015 happy.
1232 * Note: we abuse unused usb_mutex here.
1233 */
1234 if (adap->fe_adap[0].fe) {
1235 state->set_frontend[adap->id] =
1236 adap->fe_adap[0].fe->ops.set_frontend;
1237 adap->fe_adap[0].fe->ops.set_frontend =
1238 af9015_af9013_set_frontend;
1239
1240 state->read_status[adap->id] =
1241 adap->fe_adap[0].fe->ops.read_status;
1242 adap->fe_adap[0].fe->ops.read_status =
1243 af9015_af9013_read_status;
1244
1245 state->init[adap->id] = adap->fe_adap[0].fe->ops.init;
1246 adap->fe_adap[0].fe->ops.init = af9015_af9013_init;
1247
1248 state->sleep[adap->id] = adap->fe_adap[0].fe->ops.sleep;
1249 adap->fe_adap[0].fe->ops.sleep = af9015_af9013_sleep;
1250 }
1251
1252 return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1253 }
1254
1255 static struct mt2060_config af9015_mt2060_config = {
1256 .i2c_address = 0xc0,
1257 .clock_out = 0,
1258 };
1259
1260 static struct qt1010_config af9015_qt1010_config = {
1261 .i2c_address = 0xc4,
1262 };
1263
1264 static struct tda18271_config af9015_tda18271_config = {
1265 .gate = TDA18271_GATE_DIGITAL,
1266 .small_i2c = TDA18271_16_BYTE_CHUNK_INIT,
1267 };
1268
1269 static struct mxl5005s_config af9015_mxl5003_config = {
1270 .i2c_address = 0xc6,
1271 .if_freq = IF_FREQ_4570000HZ,
1272 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
1273 .agc_mode = MXL_SINGLE_AGC,
1274 .tracking_filter = MXL_TF_DEFAULT,
1275 .rssi_enable = MXL_RSSI_ENABLE,
1276 .cap_select = MXL_CAP_SEL_ENABLE,
1277 .div_out = MXL_DIV_OUT_4,
1278 .clock_out = MXL_CLOCK_OUT_DISABLE,
1279 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
1280 .top = MXL5005S_TOP_25P2,
1281 .mod_mode = MXL_DIGITAL_MODE,
1282 .if_mode = MXL_ZERO_IF,
1283 .AgcMasterByte = 0x00,
1284 };
1285
1286 static struct mxl5005s_config af9015_mxl5005_config = {
1287 .i2c_address = 0xc6,
1288 .if_freq = IF_FREQ_4570000HZ,
1289 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
1290 .agc_mode = MXL_SINGLE_AGC,
1291 .tracking_filter = MXL_TF_OFF,
1292 .rssi_enable = MXL_RSSI_ENABLE,
1293 .cap_select = MXL_CAP_SEL_ENABLE,
1294 .div_out = MXL_DIV_OUT_4,
1295 .clock_out = MXL_CLOCK_OUT_DISABLE,
1296 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
1297 .top = MXL5005S_TOP_25P2,
1298 .mod_mode = MXL_DIGITAL_MODE,
1299 .if_mode = MXL_ZERO_IF,
1300 .AgcMasterByte = 0x00,
1301 };
1302
1303 static struct mc44s803_config af9015_mc44s803_config = {
1304 .i2c_address = 0xc0,
1305 .dig_out = 1,
1306 };
1307
1308 static struct tda18218_config af9015_tda18218_config = {
1309 .i2c_address = 0xc0,
1310 .i2c_wr_max = 21, /* max wr bytes AF9015 I2C adap can handle at once */
1311 };
1312
1313 static struct mxl5007t_config af9015_mxl5007t_config = {
1314 .xtal_freq_hz = MxL_XTAL_24_MHZ,
1315 .if_freq_hz = MxL_IF_4_57_MHZ,
1316 };
1317
af9015_tuner_attach(struct dvb_usb_adapter * adap)1318 static int af9015_tuner_attach(struct dvb_usb_adapter *adap)
1319 {
1320 int ret;
1321 struct af9015_state *state = adap->dev->priv;
1322 deb_info("%s:\n", __func__);
1323
1324 switch (af9015_af9013_config[adap->id].tuner) {
1325 case AF9013_TUNER_MT2060:
1326 case AF9013_TUNER_MT2060_2:
1327 ret = dvb_attach(mt2060_attach, adap->fe_adap[0].fe, &adap->dev->i2c_adap,
1328 &af9015_mt2060_config,
1329 af9015_config.mt2060_if1[adap->id])
1330 == NULL ? -ENODEV : 0;
1331 break;
1332 case AF9013_TUNER_QT1010:
1333 case AF9013_TUNER_QT1010A:
1334 ret = dvb_attach(qt1010_attach, adap->fe_adap[0].fe, &adap->dev->i2c_adap,
1335 &af9015_qt1010_config) == NULL ? -ENODEV : 0;
1336 break;
1337 case AF9013_TUNER_TDA18271:
1338 ret = dvb_attach(tda18271_attach, adap->fe_adap[0].fe, 0xc0,
1339 &adap->dev->i2c_adap,
1340 &af9015_tda18271_config) == NULL ? -ENODEV : 0;
1341 break;
1342 case AF9013_TUNER_TDA18218:
1343 ret = dvb_attach(tda18218_attach, adap->fe_adap[0].fe,
1344 &adap->dev->i2c_adap,
1345 &af9015_tda18218_config) == NULL ? -ENODEV : 0;
1346 break;
1347 case AF9013_TUNER_MXL5003D:
1348 ret = dvb_attach(mxl5005s_attach, adap->fe_adap[0].fe,
1349 &adap->dev->i2c_adap,
1350 &af9015_mxl5003_config) == NULL ? -ENODEV : 0;
1351 break;
1352 case AF9013_TUNER_MXL5005D:
1353 case AF9013_TUNER_MXL5005R:
1354 ret = dvb_attach(mxl5005s_attach, adap->fe_adap[0].fe,
1355 &adap->dev->i2c_adap,
1356 &af9015_mxl5005_config) == NULL ? -ENODEV : 0;
1357 break;
1358 case AF9013_TUNER_ENV77H11D5:
1359 ret = dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0xc0,
1360 &adap->dev->i2c_adap,
1361 DVB_PLL_TDA665X) == NULL ? -ENODEV : 0;
1362 break;
1363 case AF9013_TUNER_MC44S803:
1364 ret = dvb_attach(mc44s803_attach, adap->fe_adap[0].fe,
1365 &adap->dev->i2c_adap,
1366 &af9015_mc44s803_config) == NULL ? -ENODEV : 0;
1367 break;
1368 case AF9013_TUNER_MXL5007T:
1369 ret = dvb_attach(mxl5007t_attach, adap->fe_adap[0].fe,
1370 &adap->dev->i2c_adap,
1371 0xc0, &af9015_mxl5007t_config) == NULL ? -ENODEV : 0;
1372 break;
1373 case AF9013_TUNER_UNKNOWN:
1374 default:
1375 ret = -ENODEV;
1376 err("Unknown tuner id:%d",
1377 af9015_af9013_config[adap->id].tuner);
1378 }
1379
1380 if (adap->fe_adap[0].fe->ops.tuner_ops.init) {
1381 state->tuner_init[adap->id] =
1382 adap->fe_adap[0].fe->ops.tuner_ops.init;
1383 adap->fe_adap[0].fe->ops.tuner_ops.init = af9015_tuner_init;
1384 }
1385
1386 if (adap->fe_adap[0].fe->ops.tuner_ops.sleep) {
1387 state->tuner_sleep[adap->id] =
1388 adap->fe_adap[0].fe->ops.tuner_ops.sleep;
1389 adap->fe_adap[0].fe->ops.tuner_ops.sleep = af9015_tuner_sleep;
1390 }
1391
1392 return ret;
1393 }
1394
1395 enum af9015_usb_table_entry {
1396 AFATECH_9015,
1397 AFATECH_9016,
1398 WINFAST_DTV_GOLD,
1399 PINNACLE_PCTV_71E,
1400 KWORLD_PLUSTV_399U,
1401 TINYTWIN,
1402 AZUREWAVE_TU700,
1403 TERRATEC_AF9015,
1404 KWORLD_PLUSTV_PC160,
1405 AVERTV_VOLAR_X,
1406 XTENSIONS_380U,
1407 MSI_DIGIVOX_DUO,
1408 AVERTV_VOLAR_X_REV2,
1409 TELESTAR_STARSTICK_2,
1410 AVERMEDIA_A309_USB,
1411 MSI_DIGIVOX_MINI_III,
1412 KWORLD_E396,
1413 KWORLD_E39B,
1414 KWORLD_E395,
1415 TREKSTOR_DVBT,
1416 AVERTV_A850,
1417 AVERTV_A805,
1418 CONCEPTRONIC_CTVDIGRCU,
1419 KWORLD_MC810,
1420 GENIUS_TVGO_DVB_T03,
1421 KWORLD_399U_2,
1422 KWORLD_PC160_T,
1423 SVEON_STV20,
1424 TINYTWIN_2,
1425 WINFAST_DTV2000DS,
1426 KWORLD_UB383_T,
1427 KWORLD_E39A,
1428 AVERMEDIA_A815M,
1429 CINERGY_T_STICK_RC,
1430 CINERGY_T_DUAL_RC,
1431 AVERTV_A850T,
1432 TINYTWIN_3,
1433 SVEON_STV22,
1434 };
1435
1436 static struct usb_device_id af9015_usb_table[] = {
1437 [AFATECH_9015] =
1438 {USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9015_9015)},
1439 [AFATECH_9016] =
1440 {USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9015_9016)},
1441 [WINFAST_DTV_GOLD] =
1442 {USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_GOLD)},
1443 [PINNACLE_PCTV_71E] =
1444 {USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV71E)},
1445 [KWORLD_PLUSTV_399U] =
1446 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_399U)},
1447 [TINYTWIN] = {USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TINYTWIN)},
1448 [AZUREWAVE_TU700] =
1449 {USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_AZUREWAVE_AD_TU700)},
1450 [TERRATEC_AF9015] = {USB_DEVICE(USB_VID_TERRATEC,
1451 USB_PID_TERRATEC_CINERGY_T_USB_XE_REV2)},
1452 [KWORLD_PLUSTV_PC160] =
1453 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_PC160_2T)},
1454 [AVERTV_VOLAR_X] =
1455 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X)},
1456 [XTENSIONS_380U] =
1457 {USB_DEVICE(USB_VID_XTENSIONS, USB_PID_XTENSIONS_XD_380)},
1458 [MSI_DIGIVOX_DUO] =
1459 {USB_DEVICE(USB_VID_MSI_2, USB_PID_MSI_DIGIVOX_DUO)},
1460 [AVERTV_VOLAR_X_REV2] =
1461 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X_2)},
1462 [TELESTAR_STARSTICK_2] =
1463 {USB_DEVICE(USB_VID_TELESTAR, USB_PID_TELESTAR_STARSTICK_2)},
1464 [AVERMEDIA_A309_USB] =
1465 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A309)},
1466 [MSI_DIGIVOX_MINI_III] =
1467 {USB_DEVICE(USB_VID_MSI_2, USB_PID_MSI_DIGI_VOX_MINI_III)},
1468 [KWORLD_E396] = {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U)},
1469 [KWORLD_E39B] = {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_2)},
1470 [KWORLD_E395] = {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_3)},
1471 [TREKSTOR_DVBT] = {USB_DEVICE(USB_VID_AFATECH, USB_PID_TREKSTOR_DVBT)},
1472 [AVERTV_A850] = {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A850)},
1473 [AVERTV_A805] = {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A805)},
1474 [CONCEPTRONIC_CTVDIGRCU] =
1475 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_CONCEPTRONIC_CTVDIGRCU)},
1476 [KWORLD_MC810] = {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_MC810)},
1477 [GENIUS_TVGO_DVB_T03] =
1478 {USB_DEVICE(USB_VID_KYE, USB_PID_GENIUS_TVGO_DVB_T03)},
1479 [KWORLD_399U_2] = {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_399U_2)},
1480 [KWORLD_PC160_T] =
1481 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_PC160_T)},
1482 [SVEON_STV20] = {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV20)},
1483 [TINYTWIN_2] = {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_TINYTWIN_2)},
1484 [WINFAST_DTV2000DS] =
1485 {USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV2000DS)},
1486 [KWORLD_UB383_T] =
1487 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_UB383_T)},
1488 [KWORLD_E39A] =
1489 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_4)},
1490 [AVERMEDIA_A815M] =
1491 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A815M)},
1492 [CINERGY_T_STICK_RC] = {USB_DEVICE(USB_VID_TERRATEC,
1493 USB_PID_TERRATEC_CINERGY_T_STICK_RC)},
1494 [CINERGY_T_DUAL_RC] = {USB_DEVICE(USB_VID_TERRATEC,
1495 USB_PID_TERRATEC_CINERGY_T_STICK_DUAL_RC)},
1496 [AVERTV_A850T] =
1497 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A850T)},
1498 [TINYTWIN_3] = {USB_DEVICE(USB_VID_GTEK, USB_PID_TINYTWIN_3)},
1499 [SVEON_STV22] = {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV22)},
1500 { }
1501 };
1502 MODULE_DEVICE_TABLE(usb, af9015_usb_table);
1503
1504 #define AF9015_RC_INTERVAL 500
1505 static struct dvb_usb_device_properties af9015_properties[] = {
1506 {
1507 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1508
1509 .usb_ctrl = DEVICE_SPECIFIC,
1510 .download_firmware = af9015_download_firmware,
1511 .firmware = "dvb-usb-af9015.fw",
1512 .no_reconnect = 1,
1513
1514 .size_of_priv = sizeof(struct af9015_state),
1515
1516 .num_adapters = 2,
1517 .adapter = {
1518 {
1519 .num_frontends = 1,
1520 .fe = {{
1521 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1522 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1523
1524 .pid_filter_count = 32,
1525 .pid_filter = af9015_pid_filter,
1526 .pid_filter_ctrl = af9015_pid_filter_ctrl,
1527
1528 .frontend_attach =
1529 af9015_af9013_frontend_attach,
1530 .tuner_attach = af9015_tuner_attach,
1531 .stream = {
1532 .type = USB_BULK,
1533 .count = 6,
1534 .endpoint = 0x84,
1535 },
1536 }},
1537 },
1538 {
1539 .num_frontends = 1,
1540 .fe = {{
1541 .frontend_attach =
1542 af9015_af9013_frontend_attach,
1543 .tuner_attach = af9015_tuner_attach,
1544 .stream = {
1545 .type = USB_BULK,
1546 .count = 6,
1547 .endpoint = 0x85,
1548 .u = {
1549 .bulk = {
1550 .buffersize =
1551 TS_USB20_FRAME_SIZE,
1552 }
1553 }
1554 },
1555 }},
1556 }
1557 },
1558
1559 .identify_state = af9015_identify_state,
1560
1561 .rc.core = {
1562 .protocol = RC_TYPE_NEC,
1563 .module_name = "af9015",
1564 .rc_query = af9015_rc_query,
1565 .rc_interval = AF9015_RC_INTERVAL,
1566 .allowed_protos = RC_TYPE_NEC,
1567 },
1568
1569 .i2c_algo = &af9015_i2c_algo,
1570
1571 .num_device_descs = 12, /* check max from dvb-usb.h */
1572 .devices = {
1573 {
1574 .name = "Afatech AF9015 DVB-T USB2.0 stick",
1575 .cold_ids = {
1576 &af9015_usb_table[AFATECH_9015],
1577 &af9015_usb_table[AFATECH_9016],
1578 NULL
1579 },
1580 .warm_ids = {NULL},
1581 },
1582 {
1583 .name = "Leadtek WinFast DTV Dongle Gold",
1584 .cold_ids = {
1585 &af9015_usb_table[WINFAST_DTV_GOLD],
1586 NULL
1587 },
1588 .warm_ids = {NULL},
1589 },
1590 {
1591 .name = "Pinnacle PCTV 71e",
1592 .cold_ids = {
1593 &af9015_usb_table[PINNACLE_PCTV_71E],
1594 NULL
1595 },
1596 .warm_ids = {NULL},
1597 },
1598 {
1599 .name = "KWorld PlusTV Dual DVB-T Stick " \
1600 "(DVB-T 399U)",
1601 .cold_ids = {
1602 &af9015_usb_table[KWORLD_PLUSTV_399U],
1603 &af9015_usb_table[KWORLD_399U_2],
1604 NULL
1605 },
1606 .warm_ids = {NULL},
1607 },
1608 {
1609 .name = "DigitalNow TinyTwin DVB-T Receiver",
1610 .cold_ids = {
1611 &af9015_usb_table[TINYTWIN],
1612 &af9015_usb_table[TINYTWIN_2],
1613 &af9015_usb_table[TINYTWIN_3],
1614 NULL
1615 },
1616 .warm_ids = {NULL},
1617 },
1618 {
1619 .name = "TwinHan AzureWave AD-TU700(704J)",
1620 .cold_ids = {
1621 &af9015_usb_table[AZUREWAVE_TU700],
1622 NULL
1623 },
1624 .warm_ids = {NULL},
1625 },
1626 {
1627 .name = "TerraTec Cinergy T USB XE",
1628 .cold_ids = {
1629 &af9015_usb_table[TERRATEC_AF9015],
1630 NULL
1631 },
1632 .warm_ids = {NULL},
1633 },
1634 {
1635 .name = "KWorld PlusTV Dual DVB-T PCI " \
1636 "(DVB-T PC160-2T)",
1637 .cold_ids = {
1638 &af9015_usb_table[KWORLD_PLUSTV_PC160],
1639 NULL
1640 },
1641 .warm_ids = {NULL},
1642 },
1643 {
1644 .name = "AVerMedia AVerTV DVB-T Volar X",
1645 .cold_ids = {
1646 &af9015_usb_table[AVERTV_VOLAR_X],
1647 NULL
1648 },
1649 .warm_ids = {NULL},
1650 },
1651 {
1652 .name = "TerraTec Cinergy T Stick RC",
1653 .cold_ids = {
1654 &af9015_usb_table[CINERGY_T_STICK_RC],
1655 NULL
1656 },
1657 .warm_ids = {NULL},
1658 },
1659 {
1660 .name = "TerraTec Cinergy T Stick Dual RC",
1661 .cold_ids = {
1662 &af9015_usb_table[CINERGY_T_DUAL_RC],
1663 NULL
1664 },
1665 .warm_ids = {NULL},
1666 },
1667 {
1668 .name = "AverMedia AVerTV Red HD+ (A850T)",
1669 .cold_ids = {
1670 &af9015_usb_table[AVERTV_A850T],
1671 NULL
1672 },
1673 .warm_ids = {NULL},
1674 },
1675 }
1676 }, {
1677 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1678
1679 .usb_ctrl = DEVICE_SPECIFIC,
1680 .download_firmware = af9015_download_firmware,
1681 .firmware = "dvb-usb-af9015.fw",
1682 .no_reconnect = 1,
1683
1684 .size_of_priv = sizeof(struct af9015_state),
1685
1686 .num_adapters = 2,
1687 .adapter = {
1688 {
1689 .num_frontends = 1,
1690 .fe = {{
1691 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1692 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1693
1694 .pid_filter_count = 32,
1695 .pid_filter = af9015_pid_filter,
1696 .pid_filter_ctrl = af9015_pid_filter_ctrl,
1697
1698 .frontend_attach =
1699 af9015_af9013_frontend_attach,
1700 .tuner_attach = af9015_tuner_attach,
1701 .stream = {
1702 .type = USB_BULK,
1703 .count = 6,
1704 .endpoint = 0x84,
1705 },
1706 }},
1707 },
1708 {
1709 .num_frontends = 1,
1710 .fe = {{
1711 .frontend_attach =
1712 af9015_af9013_frontend_attach,
1713 .tuner_attach = af9015_tuner_attach,
1714 .stream = {
1715 .type = USB_BULK,
1716 .count = 6,
1717 .endpoint = 0x85,
1718 .u = {
1719 .bulk = {
1720 .buffersize =
1721 TS_USB20_FRAME_SIZE,
1722 }
1723 }
1724 },
1725 }},
1726 }
1727 },
1728
1729 .identify_state = af9015_identify_state,
1730
1731 .rc.core = {
1732 .protocol = RC_TYPE_NEC,
1733 .module_name = "af9015",
1734 .rc_query = af9015_rc_query,
1735 .rc_interval = AF9015_RC_INTERVAL,
1736 .allowed_protos = RC_TYPE_NEC,
1737 },
1738
1739 .i2c_algo = &af9015_i2c_algo,
1740
1741 .num_device_descs = 10, /* check max from dvb-usb.h */
1742 .devices = {
1743 {
1744 .name = "Xtensions XD-380",
1745 .cold_ids = {
1746 &af9015_usb_table[XTENSIONS_380U],
1747 NULL
1748 },
1749 .warm_ids = {NULL},
1750 },
1751 {
1752 .name = "MSI DIGIVOX Duo",
1753 .cold_ids = {
1754 &af9015_usb_table[MSI_DIGIVOX_DUO],
1755 NULL
1756 },
1757 .warm_ids = {NULL},
1758 },
1759 {
1760 .name = "Fujitsu-Siemens Slim Mobile USB DVB-T",
1761 .cold_ids = {
1762 &af9015_usb_table[AVERTV_VOLAR_X_REV2],
1763 NULL
1764 },
1765 .warm_ids = {NULL},
1766 },
1767 {
1768 .name = "Telestar Starstick 2",
1769 .cold_ids = {
1770 &af9015_usb_table[TELESTAR_STARSTICK_2],
1771 NULL
1772 },
1773 .warm_ids = {NULL},
1774 },
1775 {
1776 .name = "AVerMedia A309",
1777 .cold_ids = {
1778 &af9015_usb_table[AVERMEDIA_A309_USB],
1779 NULL
1780 },
1781 .warm_ids = {NULL},
1782 },
1783 {
1784 .name = "MSI Digi VOX mini III",
1785 .cold_ids = {
1786 &af9015_usb_table[MSI_DIGIVOX_MINI_III],
1787 NULL
1788 },
1789 .warm_ids = {NULL},
1790 },
1791 {
1792 .name = "KWorld USB DVB-T TV Stick II " \
1793 "(VS-DVB-T 395U)",
1794 .cold_ids = {
1795 &af9015_usb_table[KWORLD_E396],
1796 &af9015_usb_table[KWORLD_E39B],
1797 &af9015_usb_table[KWORLD_E395],
1798 &af9015_usb_table[KWORLD_E39A],
1799 NULL
1800 },
1801 .warm_ids = {NULL},
1802 },
1803 {
1804 .name = "TrekStor DVB-T USB Stick",
1805 .cold_ids = {
1806 &af9015_usb_table[TREKSTOR_DVBT],
1807 NULL
1808 },
1809 .warm_ids = {NULL},
1810 },
1811 {
1812 .name = "AverMedia AVerTV Volar Black HD " \
1813 "(A850)",
1814 .cold_ids = {
1815 &af9015_usb_table[AVERTV_A850],
1816 NULL
1817 },
1818 .warm_ids = {NULL},
1819 },
1820 {
1821 .name = "Sveon STV22 Dual USB DVB-T Tuner HDTV",
1822 .cold_ids = {
1823 &af9015_usb_table[SVEON_STV22],
1824 NULL
1825 },
1826 .warm_ids = {NULL},
1827 },
1828 }
1829 }, {
1830 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1831
1832 .usb_ctrl = DEVICE_SPECIFIC,
1833 .download_firmware = af9015_download_firmware,
1834 .firmware = "dvb-usb-af9015.fw",
1835 .no_reconnect = 1,
1836
1837 .size_of_priv = sizeof(struct af9015_state),
1838
1839 .num_adapters = 2,
1840 .adapter = {
1841 {
1842 .num_frontends = 1,
1843 .fe = {{
1844 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1845 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1846
1847 .pid_filter_count = 32,
1848 .pid_filter = af9015_pid_filter,
1849 .pid_filter_ctrl = af9015_pid_filter_ctrl,
1850
1851 .frontend_attach =
1852 af9015_af9013_frontend_attach,
1853 .tuner_attach = af9015_tuner_attach,
1854 .stream = {
1855 .type = USB_BULK,
1856 .count = 6,
1857 .endpoint = 0x84,
1858 },
1859 }},
1860 },
1861 {
1862 .num_frontends = 1,
1863 .fe = {{
1864 .frontend_attach =
1865 af9015_af9013_frontend_attach,
1866 .tuner_attach = af9015_tuner_attach,
1867 .stream = {
1868 .type = USB_BULK,
1869 .count = 6,
1870 .endpoint = 0x85,
1871 .u = {
1872 .bulk = {
1873 .buffersize =
1874 TS_USB20_FRAME_SIZE,
1875 }
1876 }
1877 },
1878 }},
1879 }
1880 },
1881
1882 .identify_state = af9015_identify_state,
1883
1884 .rc.core = {
1885 .protocol = RC_TYPE_NEC,
1886 .module_name = "af9015",
1887 .rc_query = af9015_rc_query,
1888 .rc_interval = AF9015_RC_INTERVAL,
1889 .allowed_protos = RC_TYPE_NEC,
1890 },
1891
1892 .i2c_algo = &af9015_i2c_algo,
1893
1894 .num_device_descs = 9, /* check max from dvb-usb.h */
1895 .devices = {
1896 {
1897 .name = "AverMedia AVerTV Volar GPS 805 (A805)",
1898 .cold_ids = {
1899 &af9015_usb_table[AVERTV_A805],
1900 NULL
1901 },
1902 .warm_ids = {NULL},
1903 },
1904 {
1905 .name = "Conceptronic USB2.0 DVB-T CTVDIGRCU " \
1906 "V3.0",
1907 .cold_ids = {
1908 &af9015_usb_table[CONCEPTRONIC_CTVDIGRCU],
1909 NULL
1910 },
1911 .warm_ids = {NULL},
1912 },
1913 {
1914 .name = "KWorld Digial MC-810",
1915 .cold_ids = {
1916 &af9015_usb_table[KWORLD_MC810],
1917 NULL
1918 },
1919 .warm_ids = {NULL},
1920 },
1921 {
1922 .name = "Genius TVGo DVB-T03",
1923 .cold_ids = {
1924 &af9015_usb_table[GENIUS_TVGO_DVB_T03],
1925 NULL
1926 },
1927 .warm_ids = {NULL},
1928 },
1929 {
1930 .name = "KWorld PlusTV DVB-T PCI Pro Card " \
1931 "(DVB-T PC160-T)",
1932 .cold_ids = {
1933 &af9015_usb_table[KWORLD_PC160_T],
1934 NULL
1935 },
1936 .warm_ids = {NULL},
1937 },
1938 {
1939 .name = "Sveon STV20 Tuner USB DVB-T HDTV",
1940 .cold_ids = {
1941 &af9015_usb_table[SVEON_STV20],
1942 NULL
1943 },
1944 .warm_ids = {NULL},
1945 },
1946 {
1947 .name = "Leadtek WinFast DTV2000DS",
1948 .cold_ids = {
1949 &af9015_usb_table[WINFAST_DTV2000DS],
1950 NULL
1951 },
1952 .warm_ids = {NULL},
1953 },
1954 {
1955 .name = "KWorld USB DVB-T Stick Mobile " \
1956 "(UB383-T)",
1957 .cold_ids = {
1958 &af9015_usb_table[KWORLD_UB383_T],
1959 NULL
1960 },
1961 .warm_ids = {NULL},
1962 },
1963 {
1964 .name = "AverMedia AVerTV Volar M (A815Mac)",
1965 .cold_ids = {
1966 &af9015_usb_table[AVERMEDIA_A815M],
1967 NULL
1968 },
1969 .warm_ids = {NULL},
1970 },
1971 }
1972 },
1973 };
1974
af9015_usb_probe(struct usb_interface * intf,const struct usb_device_id * id)1975 static int af9015_usb_probe(struct usb_interface *intf,
1976 const struct usb_device_id *id)
1977 {
1978 int ret = 0;
1979 struct dvb_usb_device *d = NULL;
1980 struct usb_device *udev = interface_to_usbdev(intf);
1981 u8 i;
1982
1983 deb_info("%s: interface:%d\n", __func__,
1984 intf->cur_altsetting->desc.bInterfaceNumber);
1985
1986 /* interface 0 is used by DVB-T receiver and
1987 interface 1 is for remote controller (HID) */
1988 if (intf->cur_altsetting->desc.bInterfaceNumber == 0) {
1989 ret = af9015_read_config(udev);
1990 if (ret)
1991 return ret;
1992
1993 for (i = 0; i < af9015_properties_count; i++) {
1994 ret = dvb_usb_device_init(intf, &af9015_properties[i],
1995 THIS_MODULE, &d, adapter_nr);
1996 if (!ret)
1997 break;
1998 if (ret != -ENODEV)
1999 return ret;
2000 }
2001 if (ret)
2002 return ret;
2003
2004 if (d)
2005 ret = af9015_init(d);
2006 }
2007
2008 return ret;
2009 }
2010
2011 /* usb specific object needed to register this driver with the usb subsystem */
2012 static struct usb_driver af9015_usb_driver = {
2013 .name = "dvb_usb_af9015",
2014 .probe = af9015_usb_probe,
2015 .disconnect = dvb_usb_device_exit,
2016 .id_table = af9015_usb_table,
2017 };
2018
2019 module_usb_driver(af9015_usb_driver);
2020
2021 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
2022 MODULE_DESCRIPTION("Driver for Afatech AF9015 DVB-T");
2023 MODULE_LICENSE("GPL");
2024