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