2 * DVB USB Linux driver for Afatech AF9015 DVB-T USB2.0 receiver
4 * Copyright (C) 2007 Antti Palosaari <crope@iki.fi>
6 * Thanks to Afatech who kindly provided information.
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.
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.
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.
24 #include <linux/hash.h>
25 #include <linux/slab.h>
35 static int dvb_usb_af9015_debug
;
36 module_param_named(debug
, dvb_usb_af9015_debug
, int, 0644);
37 MODULE_PARM_DESC(debug
, "set debugging level" DVB_USB_DEBUG_STATUS
);
38 static int dvb_usb_af9015_remote
;
39 module_param_named(remote
, dvb_usb_af9015_remote
, int, 0644);
40 MODULE_PARM_DESC(remote
, "select remote");
41 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr
);
43 static DEFINE_MUTEX(af9015_usb_mutex
);
45 static struct af9015_config af9015_config
;
46 static struct dvb_usb_device_properties af9015_properties
[3];
47 static int af9015_properties_count
= ARRAY_SIZE(af9015_properties
);
49 static struct af9013_config af9015_af9013_config
[] = {
51 .demod_address
= AF9015_I2C_DEMOD
,
52 .output_mode
= AF9013_OUTPUT_MODE_USB
,
53 .api_version
= { 0, 1, 9, 0 },
54 .gpio
[0] = AF9013_GPIO_HI
,
55 .gpio
[3] = AF9013_GPIO_TUNER_ON
,
58 .output_mode
= AF9013_OUTPUT_MODE_SERIAL
,
59 .api_version
= { 0, 1, 9, 0 },
60 .gpio
[0] = AF9013_GPIO_TUNER_ON
,
61 .gpio
[1] = AF9013_GPIO_LO
,
65 static int af9015_rw_udev(struct usb_device
*udev
, struct req_t
*req
)
68 #define REQ_HDR_LEN 8 /* send header size */
69 #define ACK_HDR_LEN 2 /* rece header size */
73 u8 msg_len
= REQ_HDR_LEN
;
74 static u8 seq
; /* packet sequence number */
76 if (mutex_lock_interruptible(&af9015_usb_mutex
) < 0)
81 buf
[2] = req
->i2c_addr
;
82 buf
[3] = req
->addr
>> 8;
83 buf
[4] = req
->addr
& 0xff;
85 buf
[6] = req
->addr_len
;
86 buf
[7] = req
->data_len
;
97 buf
[2] |= 0x01; /* set I2C direction */
99 buf
[0] = READ_WRITE_I2C
;
102 if (((req
->addr
& 0xff00) == 0xff00) ||
103 ((req
->addr
& 0xff00) == 0xae00))
104 buf
[0] = WRITE_VIRTUAL_MEMORY
;
105 case WRITE_VIRTUAL_MEMORY
:
107 case DOWNLOAD_FIRMWARE
:
111 err("unknown command:%d", req
->cmd
);
116 /* buffer overflow check */
117 if ((write
&& (req
->data_len
> BUF_LEN
- REQ_HDR_LEN
)) ||
118 (!write
&& (req
->data_len
> BUF_LEN
- ACK_HDR_LEN
))) {
119 err("too much data; cmd:%d len:%d", req
->cmd
, req
->data_len
);
124 /* write requested */
126 memcpy(&buf
[REQ_HDR_LEN
], req
->data
, req
->data_len
);
127 msg_len
+= req
->data_len
;
131 debug_dump(buf
, msg_len
, deb_xfer
);
134 ret
= usb_bulk_msg(udev
, usb_sndbulkpipe(udev
, 0x02), buf
, msg_len
,
135 &act_len
, AF9015_USB_TIMEOUT
);
137 err("bulk message failed:%d (%d/%d)", ret
, msg_len
, act_len
);
139 if (act_len
!= msg_len
)
140 ret
= -1; /* all data is not send */
144 /* no ack for those packets */
145 if (req
->cmd
== DOWNLOAD_FIRMWARE
|| req
->cmd
== RECONNECT_USB
)
148 /* write receives seq + status = 2 bytes
149 read receives seq + status + data = 2 + N bytes */
150 msg_len
= ACK_HDR_LEN
;
152 msg_len
+= req
->data_len
;
154 ret
= usb_bulk_msg(udev
, usb_rcvbulkpipe(udev
, 0x81), buf
, msg_len
,
155 &act_len
, AF9015_USB_TIMEOUT
);
157 err("recv bulk message failed:%d", ret
);
163 debug_dump(buf
, act_len
, deb_xfer
);
165 /* remote controller query status is 1 if remote code is not received */
166 if (req
->cmd
== GET_IR_CODE
&& buf
[1] == 1) {
167 buf
[1] = 0; /* clear command "error" status */
168 memset(&buf
[2], 0, req
->data_len
);
169 buf
[3] = 1; /* no remote code received mark */
174 err("command failed:%d", buf
[1]);
179 /* read request, copy returned data to return buf */
181 memcpy(req
->data
, &buf
[ACK_HDR_LEN
], req
->data_len
);
185 mutex_unlock(&af9015_usb_mutex
);
190 static int af9015_ctrl_msg(struct dvb_usb_device
*d
, struct req_t
*req
)
192 return af9015_rw_udev(d
->udev
, req
);
195 static int af9015_write_regs(struct dvb_usb_device
*d
, u16 addr
, u8
*val
,
198 struct req_t req
= {WRITE_MEMORY
, AF9015_I2C_DEMOD
, addr
, 0, 0, len
,
200 return af9015_ctrl_msg(d
, &req
);
203 static int af9015_write_reg(struct dvb_usb_device
*d
, u16 addr
, u8 val
)
205 return af9015_write_regs(d
, addr
, &val
, 1);
208 static int af9015_read_reg(struct dvb_usb_device
*d
, u16 addr
, u8
*val
)
210 struct req_t req
= {READ_MEMORY
, AF9015_I2C_DEMOD
, addr
, 0, 0, 1, val
};
211 return af9015_ctrl_msg(d
, &req
);
214 static int af9015_write_reg_i2c(struct dvb_usb_device
*d
, u8 addr
, u16 reg
,
217 struct req_t req
= {WRITE_I2C
, addr
, reg
, 1, 1, 1, &val
};
219 if (addr
== af9015_af9013_config
[0].demod_address
||
220 addr
== af9015_af9013_config
[1].demod_address
)
223 return af9015_ctrl_msg(d
, &req
);
226 static int af9015_read_reg_i2c(struct dvb_usb_device
*d
, u8 addr
, u16 reg
,
229 struct req_t req
= {READ_I2C
, addr
, reg
, 0, 1, 1, val
};
231 if (addr
== af9015_af9013_config
[0].demod_address
||
232 addr
== af9015_af9013_config
[1].demod_address
)
235 return af9015_ctrl_msg(d
, &req
);
238 static int af9015_i2c_xfer(struct i2c_adapter
*adap
, struct i2c_msg msg
[],
241 struct dvb_usb_device
*d
= i2c_get_adapdata(adap
);
247 /* TODO: implement bus lock
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.
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 |____________| |____________|
270 if (mutex_lock_interruptible(&d
->i2c_mutex
) < 0)
274 if (msg
[i
].addr
== af9015_af9013_config
[0].demod_address
||
275 msg
[i
].addr
== af9015_af9013_config
[1].demod_address
) {
276 addr
= msg
[i
].buf
[0] << 8;
277 addr
+= msg
[i
].buf
[1];
278 mbox
= msg
[i
].buf
[2];
281 addr
= msg
[i
].buf
[0];
286 if (num
> i
+ 1 && (msg
[i
+1].flags
& I2C_M_RD
)) {
288 af9015_af9013_config
[0].demod_address
)
289 req
.cmd
= READ_MEMORY
;
292 req
.i2c_addr
= msg
[i
].addr
;
295 req
.addr_len
= addr_len
;
296 req
.data_len
= msg
[i
+1].len
;
297 req
.data
= &msg
[i
+1].buf
[0];
298 ret
= af9015_ctrl_msg(d
, &req
);
300 } else if (msg
[i
].flags
& I2C_M_RD
) {
303 af9015_af9013_config
[0].demod_address
)
307 req
.i2c_addr
= msg
[i
].addr
;
310 req
.addr_len
= addr_len
;
311 req
.data_len
= msg
[i
].len
;
312 req
.data
= &msg
[i
].buf
[0];
313 ret
= af9015_ctrl_msg(d
, &req
);
317 af9015_af9013_config
[0].demod_address
)
318 req
.cmd
= WRITE_MEMORY
;
321 req
.i2c_addr
= msg
[i
].addr
;
324 req
.addr_len
= addr_len
;
325 req
.data_len
= msg
[i
].len
-addr_len
;
326 req
.data
= &msg
[i
].buf
[addr_len
];
327 ret
= af9015_ctrl_msg(d
, &req
);
337 mutex_unlock(&d
->i2c_mutex
);
342 static u32
af9015_i2c_func(struct i2c_adapter
*adapter
)
347 static struct i2c_algorithm af9015_i2c_algo
= {
348 .master_xfer
= af9015_i2c_xfer
,
349 .functionality
= af9015_i2c_func
,
352 static int af9015_do_reg_bit(struct dvb_usb_device
*d
, u16 addr
, u8 bit
, u8 op
)
357 ret
= af9015_read_reg(d
, addr
, &val
);
371 return af9015_write_reg(d
, addr
, val
);
374 static int af9015_set_reg_bit(struct dvb_usb_device
*d
, u16 addr
, u8 bit
)
376 return af9015_do_reg_bit(d
, addr
, bit
, 1);
379 static int af9015_clear_reg_bit(struct dvb_usb_device
*d
, u16 addr
, u8 bit
)
381 return af9015_do_reg_bit(d
, addr
, bit
, 0);
384 static int af9015_init_endpoint(struct dvb_usb_device
*d
)
389 deb_info("%s: USB speed:%d\n", __func__
, d
->udev
->speed
);
391 /* Windows driver uses packet count 21 for USB1.1 and 348 for USB2.0.
392 We use smaller - about 1/4 from the original, 5 and 87. */
393 #define TS_PACKET_SIZE 188
395 #define TS_USB20_PACKET_COUNT 87
396 #define TS_USB20_FRAME_SIZE (TS_PACKET_SIZE*TS_USB20_PACKET_COUNT)
398 #define TS_USB11_PACKET_COUNT 5
399 #define TS_USB11_FRAME_SIZE (TS_PACKET_SIZE*TS_USB11_PACKET_COUNT)
401 #define TS_USB20_MAX_PACKET_SIZE 512
402 #define TS_USB11_MAX_PACKET_SIZE 64
404 if (d
->udev
->speed
== USB_SPEED_FULL
) {
405 frame_size
= TS_USB11_FRAME_SIZE
/4;
406 packet_size
= TS_USB11_MAX_PACKET_SIZE
/4;
408 frame_size
= TS_USB20_FRAME_SIZE
/4;
409 packet_size
= TS_USB20_MAX_PACKET_SIZE
/4;
412 ret
= af9015_set_reg_bit(d
, 0xd507, 2); /* assert EP4 reset */
415 ret
= af9015_set_reg_bit(d
, 0xd50b, 1); /* assert EP5 reset */
418 ret
= af9015_clear_reg_bit(d
, 0xdd11, 5); /* disable EP4 */
421 ret
= af9015_clear_reg_bit(d
, 0xdd11, 6); /* disable EP5 */
424 ret
= af9015_set_reg_bit(d
, 0xdd11, 5); /* enable EP4 */
427 if (af9015_config
.dual_mode
) {
428 ret
= af9015_set_reg_bit(d
, 0xdd11, 6); /* enable EP5 */
432 ret
= af9015_clear_reg_bit(d
, 0xdd13, 5); /* disable EP4 NAK */
435 if (af9015_config
.dual_mode
) {
436 ret
= af9015_clear_reg_bit(d
, 0xdd13, 6); /* disable EP5 NAK */
440 /* EP4 xfer length */
441 ret
= af9015_write_reg(d
, 0xdd88, frame_size
& 0xff);
444 ret
= af9015_write_reg(d
, 0xdd89, frame_size
>> 8);
447 /* EP5 xfer length */
448 ret
= af9015_write_reg(d
, 0xdd8a, frame_size
& 0xff);
451 ret
= af9015_write_reg(d
, 0xdd8b, frame_size
>> 8);
454 ret
= af9015_write_reg(d
, 0xdd0c, packet_size
); /* EP4 packet size */
457 ret
= af9015_write_reg(d
, 0xdd0d, packet_size
); /* EP5 packet size */
460 ret
= af9015_clear_reg_bit(d
, 0xd507, 2); /* negate EP4 reset */
463 if (af9015_config
.dual_mode
) {
464 ret
= af9015_clear_reg_bit(d
, 0xd50b, 1); /* negate EP5 reset */
469 /* enable / disable mp2if2 */
470 if (af9015_config
.dual_mode
)
471 ret
= af9015_set_reg_bit(d
, 0xd50b, 0);
473 ret
= af9015_clear_reg_bit(d
, 0xd50b, 0);
476 err("endpoint init failed:%d", ret
);
480 static int af9015_copy_firmware(struct dvb_usb_device
*d
)
485 struct req_t req
= {COPY_FIRMWARE
, 0, 0x5100, 0, 0, sizeof(fw_params
),
487 deb_info("%s:\n", __func__
);
489 fw_params
[0] = af9015_config
.firmware_size
>> 8;
490 fw_params
[1] = af9015_config
.firmware_size
& 0xff;
491 fw_params
[2] = af9015_config
.firmware_checksum
>> 8;
492 fw_params
[3] = af9015_config
.firmware_checksum
& 0xff;
494 /* wait 2nd demodulator ready */
497 ret
= af9015_read_reg_i2c(d
, 0x3a, 0x98be, &val
);
501 deb_info("%s: firmware status:%02x\n", __func__
, val
);
503 if (val
== 0x0c) /* fw is running, no need for download */
506 /* set I2C master clock to fast (to speed up firmware copy) */
507 ret
= af9015_write_reg(d
, 0xd416, 0x04); /* 0x04 * 400ns */
514 ret
= af9015_ctrl_msg(d
, &req
);
516 err("firmware copy cmd failed:%d", ret
);
517 deb_info("%s: firmware copy done\n", __func__
);
519 /* set I2C master clock back to normal */
520 ret
= af9015_write_reg(d
, 0xd416, 0x14); /* 0x14 * 400ns */
524 /* request boot firmware */
525 ret
= af9015_write_reg_i2c(d
, af9015_af9013_config
[1].demod_address
,
527 deb_info("%s: firmware boot cmd status:%d\n", __func__
, ret
);
531 for (i
= 0; i
< 15; i
++) {
534 /* check firmware status */
535 ret
= af9015_read_reg_i2c(d
,
536 af9015_af9013_config
[1].demod_address
, 0x98be, &val
);
537 deb_info("%s: firmware status cmd status:%d fw status:%02x\n",
542 if (val
== 0x0c || val
== 0x04) /* success or fail */
547 err("firmware did not run");
549 } else if (val
!= 0x0c) {
550 err("firmware boot timeout");
559 /* hash (and dump) eeprom */
560 static int af9015_eeprom_hash(struct usb_device
*udev
)
562 static const unsigned int eeprom_size
= 256;
566 struct req_t req
= {READ_I2C
, AF9015_I2C_EEPROM
, 0, 0, 1, 1, &val
};
568 eeprom
= kmalloc(eeprom_size
, GFP_KERNEL
);
572 for (reg
= 0; reg
< eeprom_size
; reg
++) {
574 ret
= af9015_rw_udev(udev
, &req
);
580 if (dvb_usb_af9015_debug
& 0x01)
581 print_hex_dump_bytes("", DUMP_PREFIX_OFFSET
, eeprom
,
584 BUG_ON(eeprom_size
% 4);
586 af9015_config
.eeprom_sum
= 0;
587 for (reg
= 0; reg
< eeprom_size
/ sizeof(u32
); reg
++) {
588 af9015_config
.eeprom_sum
*= GOLDEN_RATIO_PRIME_32
;
589 af9015_config
.eeprom_sum
+= le32_to_cpu(((u32
*)eeprom
)[reg
]);
592 deb_info("%s: eeprom sum=%.8x\n", __func__
, af9015_config
.eeprom_sum
);
600 static int af9015_download_ir_table(struct dvb_usb_device
*d
)
602 int i
, packets
= 0, ret
;
603 u16 addr
= 0x9a56; /* ir-table start address */
604 struct req_t req
= {WRITE_MEMORY
, 0, 0, 0, 0, 1, NULL
};
606 deb_info("%s:\n", __func__
);
608 data
= af9015_config
.ir_table
;
609 packets
= af9015_config
.ir_table_size
;
615 /* load remote ir-table */
616 for (i
= 0; i
< packets
; i
++) {
619 ret
= af9015_ctrl_msg(d
, &req
);
621 err("ir-table download failed at packet %d with " \
631 static int af9015_init(struct dvb_usb_device
*d
)
634 deb_info("%s:\n", __func__
);
636 ret
= af9015_init_endpoint(d
);
640 ret
= af9015_download_ir_table(d
);
648 static int af9015_pid_filter_ctrl(struct dvb_usb_adapter
*adap
, int onoff
)
651 deb_info("%s: onoff:%d\n", __func__
, onoff
);
654 ret
= af9015_set_reg_bit(adap
->dev
, 0xd503, 0);
656 ret
= af9015_clear_reg_bit(adap
->dev
, 0xd503, 0);
661 static int af9015_pid_filter(struct dvb_usb_adapter
*adap
, int index
, u16 pid
,
667 deb_info("%s: set pid filter, index %d, pid %x, onoff %d\n",
668 __func__
, index
, pid
, onoff
);
670 ret
= af9015_write_reg(adap
->dev
, 0xd505, (pid
& 0xff));
674 ret
= af9015_write_reg(adap
->dev
, 0xd506, (pid
>> 8));
678 idx
= ((index
& 0x1f) | (1 << 5));
679 ret
= af9015_write_reg(adap
->dev
, 0xd504, idx
);
685 static int af9015_download_firmware(struct usb_device
*udev
,
686 const struct firmware
*fw
)
688 int i
, len
, packets
, remainder
, ret
;
689 struct req_t req
= {DOWNLOAD_FIRMWARE
, 0, 0, 0, 0, 0, NULL
};
690 u16 addr
= 0x5100; /* firmware start address */
693 deb_info("%s:\n", __func__
);
696 for (i
= 0; i
< fw
->size
; i
++)
697 checksum
+= fw
->data
[i
];
699 af9015_config
.firmware_size
= fw
->size
;
700 af9015_config
.firmware_checksum
= checksum
;
702 #define FW_PACKET_MAX_DATA 55
704 packets
= fw
->size
/ FW_PACKET_MAX_DATA
;
705 remainder
= fw
->size
% FW_PACKET_MAX_DATA
;
706 len
= FW_PACKET_MAX_DATA
;
707 for (i
= 0; i
<= packets
; i
++) {
708 if (i
== packets
) /* set size of the last packet */
712 req
.data
= (u8
*)(fw
->data
+ i
* FW_PACKET_MAX_DATA
);
714 addr
+= FW_PACKET_MAX_DATA
;
716 ret
= af9015_rw_udev(udev
, &req
);
718 err("firmware download failed at packet %d with " \
724 /* firmware loaded, request boot */
726 ret
= af9015_rw_udev(udev
, &req
);
728 err("firmware boot failed:%d", ret
);
736 struct af9015_setup
{
738 struct dvb_usb_rc_key
*rc_key_map
;
739 unsigned int rc_key_map_size
;
741 unsigned int ir_table_size
;
744 static const struct af9015_setup
*af9015_setup_match(unsigned int id
,
745 const struct af9015_setup
*table
)
747 for (; table
->rc_key_map
; table
++)
753 static const struct af9015_setup af9015_setup_modparam
[] = {
754 { AF9015_REMOTE_A_LINK_DTU_M
,
755 af9015_rc_keys_a_link
, ARRAY_SIZE(af9015_rc_keys_a_link
),
756 af9015_ir_table_a_link
, ARRAY_SIZE(af9015_ir_table_a_link
) },
757 { AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3
,
758 af9015_rc_keys_msi
, ARRAY_SIZE(af9015_rc_keys_msi
),
759 af9015_ir_table_msi
, ARRAY_SIZE(af9015_ir_table_msi
) },
760 { AF9015_REMOTE_MYGICTV_U718
,
761 af9015_rc_keys_mygictv
, ARRAY_SIZE(af9015_rc_keys_mygictv
),
762 af9015_ir_table_mygictv
, ARRAY_SIZE(af9015_ir_table_mygictv
) },
763 { AF9015_REMOTE_DIGITTRADE_DVB_T
,
764 af9015_rc_keys_digittrade
, ARRAY_SIZE(af9015_rc_keys_digittrade
),
765 af9015_ir_table_digittrade
, ARRAY_SIZE(af9015_ir_table_digittrade
) },
766 { AF9015_REMOTE_AVERMEDIA_KS
,
767 af9015_rc_keys_avermedia
, ARRAY_SIZE(af9015_rc_keys_avermedia
),
768 af9015_ir_table_avermedia_ks
, ARRAY_SIZE(af9015_ir_table_avermedia_ks
) },
772 /* don't add new entries here anymore, use hashes instead */
773 static const struct af9015_setup af9015_setup_usbids
[] = {
775 af9015_rc_keys_leadtek
, ARRAY_SIZE(af9015_rc_keys_leadtek
),
776 af9015_ir_table_leadtek
, ARRAY_SIZE(af9015_ir_table_leadtek
) },
777 { USB_VID_VISIONPLUS
,
778 af9015_rc_keys_twinhan
, ARRAY_SIZE(af9015_rc_keys_twinhan
),
779 af9015_ir_table_twinhan
, ARRAY_SIZE(af9015_ir_table_twinhan
) },
780 { USB_VID_KWORLD_2
, /* TODO: use correct rc keys */
781 af9015_rc_keys_twinhan
, ARRAY_SIZE(af9015_rc_keys_twinhan
),
782 af9015_ir_table_kworld
, ARRAY_SIZE(af9015_ir_table_kworld
) },
784 af9015_rc_keys_avermedia
, ARRAY_SIZE(af9015_rc_keys_avermedia
),
785 af9015_ir_table_avermedia
, ARRAY_SIZE(af9015_ir_table_avermedia
) },
787 af9015_rc_keys_msi_digivox_iii
, ARRAY_SIZE(af9015_rc_keys_msi_digivox_iii
),
788 af9015_ir_table_msi_digivox_iii
, ARRAY_SIZE(af9015_ir_table_msi_digivox_iii
) },
792 static const struct af9015_setup af9015_setup_hashes
[] = {
794 af9015_rc_keys_msi
, ARRAY_SIZE(af9015_rc_keys_msi
),
795 af9015_ir_table_msi
, ARRAY_SIZE(af9015_ir_table_msi
) },
797 af9015_rc_keys_a_link
, ARRAY_SIZE(af9015_rc_keys_a_link
),
798 af9015_ir_table_a_link
, ARRAY_SIZE(af9015_ir_table_a_link
) },
800 af9015_rc_keys_mygictv
, ARRAY_SIZE(af9015_rc_keys_mygictv
),
801 af9015_ir_table_mygictv
, ARRAY_SIZE(af9015_ir_table_mygictv
) },
805 static void af9015_set_remote_config(struct usb_device
*udev
,
806 struct dvb_usb_device_properties
*props
)
808 const struct af9015_setup
*table
= NULL
;
810 if (dvb_usb_af9015_remote
) {
811 /* load remote defined as module param */
812 table
= af9015_setup_match(dvb_usb_af9015_remote
,
813 af9015_setup_modparam
);
815 u16 vendor
= le16_to_cpu(udev
->descriptor
.idVendor
);
817 table
= af9015_setup_match(af9015_config
.eeprom_sum
,
818 af9015_setup_hashes
);
820 if (!table
&& vendor
== USB_VID_AFATECH
) {
821 /* Check USB manufacturer and product strings and try
822 to determine correct remote in case of chip vendor
823 reference IDs are used.
824 DO NOT ADD ANYTHING NEW HERE. Use hashes instead.
826 char manufacturer
[10];
827 memset(manufacturer
, 0, sizeof(manufacturer
));
828 usb_string(udev
, udev
->descriptor
.iManufacturer
,
829 manufacturer
, sizeof(manufacturer
));
830 if (!strcmp("MSI", manufacturer
)) {
831 /* iManufacturer 1 MSI
832 iProduct 2 MSI K-VOX */
833 table
= af9015_setup_match(
834 AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3
,
835 af9015_setup_modparam
);
836 } else if (udev
->descriptor
.idProduct
==
837 cpu_to_le16(USB_PID_TREKSTOR_DVBT
)) {
838 table
= &(const struct af9015_setup
){ 0,
839 af9015_rc_keys_trekstor
,
840 ARRAY_SIZE(af9015_rc_keys_trekstor
),
841 af9015_ir_table_trekstor
,
842 ARRAY_SIZE(af9015_ir_table_trekstor
)
846 table
= af9015_setup_match(vendor
, af9015_setup_usbids
);
850 props
->rc_key_map
= table
->rc_key_map
;
851 props
->rc_key_map_size
= table
->rc_key_map_size
;
852 af9015_config
.ir_table
= table
->ir_table
;
853 af9015_config
.ir_table_size
= table
->ir_table_size
;
857 static int af9015_read_config(struct usb_device
*udev
)
860 u8 val
, i
, offset
= 0;
861 struct req_t req
= {READ_I2C
, AF9015_I2C_EEPROM
, 0, 0, 1, 1, &val
};
863 /* IR remote controller */
864 req
.addr
= AF9015_EEPROM_IR_MODE
;
865 /* first message will timeout often due to possible hw bug */
866 for (i
= 0; i
< 4; i
++) {
867 ret
= af9015_rw_udev(udev
, &req
);
874 ret
= af9015_eeprom_hash(udev
);
878 deb_info("%s: IR mode:%d\n", __func__
, val
);
879 for (i
= 0; i
< af9015_properties_count
; i
++) {
880 if (val
== AF9015_IR_MODE_DISABLED
) {
881 af9015_properties
[i
].rc_key_map
= NULL
;
882 af9015_properties
[i
].rc_key_map_size
= 0;
884 af9015_set_remote_config(udev
, &af9015_properties
[i
]);
887 /* TS mode - one or two receivers */
888 req
.addr
= AF9015_EEPROM_TS_MODE
;
889 ret
= af9015_rw_udev(udev
, &req
);
892 af9015_config
.dual_mode
= val
;
893 deb_info("%s: TS mode:%d\n", __func__
, af9015_config
.dual_mode
);
895 /* Set adapter0 buffer size according to USB port speed, adapter1 buffer
896 size can be static because it is enabled only USB2.0 */
897 for (i
= 0; i
< af9015_properties_count
; i
++) {
898 /* USB1.1 set smaller buffersize and disable 2nd adapter */
899 if (udev
->speed
== USB_SPEED_FULL
) {
900 af9015_properties
[i
].adapter
[0].stream
.u
.bulk
.buffersize
901 = TS_USB11_FRAME_SIZE
;
902 /* disable 2nd adapter because we don't have
904 af9015_config
.dual_mode
= 0;
906 af9015_properties
[i
].adapter
[0].stream
.u
.bulk
.buffersize
907 = TS_USB20_FRAME_SIZE
;
911 if (af9015_config
.dual_mode
) {
912 /* read 2nd demodulator I2C address */
913 req
.addr
= AF9015_EEPROM_DEMOD2_I2C
;
914 ret
= af9015_rw_udev(udev
, &req
);
917 af9015_af9013_config
[1].demod_address
= val
;
919 /* enable 2nd adapter */
920 for (i
= 0; i
< af9015_properties_count
; i
++)
921 af9015_properties
[i
].num_adapters
= 2;
924 /* disable 2nd adapter */
925 for (i
= 0; i
< af9015_properties_count
; i
++)
926 af9015_properties
[i
].num_adapters
= 1;
929 for (i
= 0; i
< af9015_properties
[0].num_adapters
; i
++) {
931 offset
= AF9015_EEPROM_OFFSET
;
933 req
.addr
= AF9015_EEPROM_XTAL_TYPE1
+ offset
;
934 ret
= af9015_rw_udev(udev
, &req
);
939 af9015_af9013_config
[i
].adc_clock
= 28800;
942 af9015_af9013_config
[i
].adc_clock
= 20480;
945 af9015_af9013_config
[i
].adc_clock
= 28000;
948 af9015_af9013_config
[i
].adc_clock
= 25000;
951 deb_info("%s: [%d] xtal:%d set adc_clock:%d\n", __func__
, i
,
952 val
, af9015_af9013_config
[i
].adc_clock
);
955 req
.addr
= AF9015_EEPROM_IF1H
+ offset
;
956 ret
= af9015_rw_udev(udev
, &req
);
959 af9015_af9013_config
[i
].tuner_if
= val
<< 8;
960 req
.addr
= AF9015_EEPROM_IF1L
+ offset
;
961 ret
= af9015_rw_udev(udev
, &req
);
964 af9015_af9013_config
[i
].tuner_if
+= val
;
965 deb_info("%s: [%d] IF1:%d\n", __func__
, i
,
966 af9015_af9013_config
[0].tuner_if
);
969 req
.addr
= AF9015_EEPROM_MT2060_IF1H
+ offset
;
970 ret
= af9015_rw_udev(udev
, &req
);
973 af9015_config
.mt2060_if1
[i
] = val
<< 8;
974 req
.addr
= AF9015_EEPROM_MT2060_IF1L
+ offset
;
975 ret
= af9015_rw_udev(udev
, &req
);
978 af9015_config
.mt2060_if1
[i
] += val
;
979 deb_info("%s: [%d] MT2060 IF1:%d\n", __func__
, i
,
980 af9015_config
.mt2060_if1
[i
]);
983 req
.addr
= AF9015_EEPROM_TUNER_ID1
+ offset
;
984 ret
= af9015_rw_udev(udev
, &req
);
988 case AF9013_TUNER_ENV77H11D5
:
989 case AF9013_TUNER_MT2060
:
990 case AF9013_TUNER_QT1010
:
991 case AF9013_TUNER_UNKNOWN
:
992 case AF9013_TUNER_MT2060_2
:
993 case AF9013_TUNER_TDA18271
:
994 case AF9013_TUNER_QT1010A
:
995 af9015_af9013_config
[i
].rf_spec_inv
= 1;
997 case AF9013_TUNER_MXL5003D
:
998 case AF9013_TUNER_MXL5005D
:
999 case AF9013_TUNER_MXL5005R
:
1000 af9015_af9013_config
[i
].rf_spec_inv
= 0;
1002 case AF9013_TUNER_MC44S803
:
1003 af9015_af9013_config
[i
].gpio
[1] = AF9013_GPIO_LO
;
1004 af9015_af9013_config
[i
].rf_spec_inv
= 1;
1006 case AF9013_TUNER_TDA18218
:
1007 warn("tuner NXP TDA18218 not supported yet");
1010 warn("tuner id:%d not supported, please report!", val
);
1014 af9015_af9013_config
[i
].tuner
= val
;
1015 deb_info("%s: [%d] tuner id:%d\n", __func__
, i
, val
);
1020 err("eeprom read failed:%d", ret
);
1022 /* AverMedia AVerTV Volar Black HD (A850) device have bad EEPROM
1023 content :-( Override some wrong values here. */
1024 if (le16_to_cpu(udev
->descriptor
.idVendor
) == USB_VID_AVERMEDIA
&&
1025 le16_to_cpu(udev
->descriptor
.idProduct
) == USB_PID_AVERMEDIA_A850
) {
1026 deb_info("%s: AverMedia A850: overriding config\n", __func__
);
1027 /* disable dual mode */
1028 af9015_config
.dual_mode
= 0;
1029 /* disable 2nd adapter */
1030 for (i
= 0; i
< af9015_properties_count
; i
++)
1031 af9015_properties
[i
].num_adapters
= 1;
1033 /* set correct IF */
1034 af9015_af9013_config
[0].tuner_if
= 4570;
1040 static int af9015_identify_state(struct usb_device
*udev
,
1041 struct dvb_usb_device_properties
*props
,
1042 struct dvb_usb_device_description
**desc
,
1047 struct req_t req
= {GET_CONFIG
, 0, 0, 0, 0, 1, &reply
};
1049 ret
= af9015_rw_udev(udev
, &req
);
1053 deb_info("%s: reply:%02x\n", __func__
, reply
);
1062 static int af9015_rc_query(struct dvb_usb_device
*d
, u32
*event
, int *state
)
1065 struct req_t req
= {GET_IR_CODE
, 0, 0, 0, 0, sizeof(buf
), buf
};
1066 struct dvb_usb_rc_key
*keymap
= d
->props
.rc_key_map
;
1069 memset(buf
, 0, sizeof(buf
));
1071 ret
= af9015_ctrl_msg(d
, &req
);
1076 *state
= REMOTE_NO_KEY_PRESSED
;
1078 for (i
= 0; i
< d
->props
.rc_key_map_size
; i
++) {
1079 if (!buf
[1] && rc5_custom(&keymap
[i
]) == buf
[0] &&
1080 rc5_data(&keymap
[i
]) == buf
[2]) {
1081 *event
= keymap
[i
].event
;
1082 *state
= REMOTE_KEY_PRESSED
;
1087 deb_rc("%s: %02x %02x %02x %02x %02x %02x %02x %02x\n",
1088 __func__
, buf
[0], buf
[1], buf
[2], buf
[3], buf
[4],
1089 buf
[5], buf
[6], buf
[7]);
1094 /* init 2nd I2C adapter */
1095 static int af9015_i2c_init(struct dvb_usb_device
*d
)
1098 struct af9015_state
*state
= d
->priv
;
1099 deb_info("%s:\n", __func__
);
1101 strncpy(state
->i2c_adap
.name
, d
->desc
->name
,
1102 sizeof(state
->i2c_adap
.name
));
1103 #ifdef I2C_ADAP_CLASS_TV_DIGITAL
1104 state
->i2c_adap
.class = I2C_ADAP_CLASS_TV_DIGITAL
,
1106 state
->i2c_adap
.class = I2C_CLASS_TV_DIGITAL
,
1108 state
->i2c_adap
.algo
= d
->props
.i2c_algo
;
1109 state
->i2c_adap
.algo_data
= NULL
;
1110 state
->i2c_adap
.dev
.parent
= &d
->udev
->dev
;
1112 i2c_set_adapdata(&state
->i2c_adap
, d
);
1114 ret
= i2c_add_adapter(&state
->i2c_adap
);
1116 err("could not add i2c adapter");
1121 static int af9015_af9013_frontend_attach(struct dvb_usb_adapter
*adap
)
1124 struct af9015_state
*state
= adap
->dev
->priv
;
1125 struct i2c_adapter
*i2c_adap
;
1127 if (adap
->id
== 0) {
1128 /* select I2C adapter */
1129 i2c_adap
= &adap
->dev
->i2c_adap
;
1131 deb_info("%s: init I2C\n", __func__
);
1132 ret
= af9015_i2c_init(adap
->dev
);
1134 /* select I2C adapter */
1135 i2c_adap
= &state
->i2c_adap
;
1137 /* copy firmware to 2nd demodulator */
1138 if (af9015_config
.dual_mode
) {
1139 ret
= af9015_copy_firmware(adap
->dev
);
1141 err("firmware copy to 2nd frontend " \
1142 "failed, will disable it");
1143 af9015_config
.dual_mode
= 0;
1151 /* attach demodulator */
1152 adap
->fe
= dvb_attach(af9013_attach
, &af9015_af9013_config
[adap
->id
],
1155 return adap
->fe
== NULL
? -ENODEV
: 0;
1158 static struct mt2060_config af9015_mt2060_config
= {
1159 .i2c_address
= 0xc0,
1163 static struct qt1010_config af9015_qt1010_config
= {
1164 .i2c_address
= 0xc4,
1167 static struct tda18271_config af9015_tda18271_config
= {
1168 .gate
= TDA18271_GATE_DIGITAL
,
1172 static struct mxl5005s_config af9015_mxl5003_config
= {
1173 .i2c_address
= 0xc6,
1174 .if_freq
= IF_FREQ_4570000HZ
,
1175 .xtal_freq
= CRYSTAL_FREQ_16000000HZ
,
1176 .agc_mode
= MXL_SINGLE_AGC
,
1177 .tracking_filter
= MXL_TF_DEFAULT
,
1178 .rssi_enable
= MXL_RSSI_ENABLE
,
1179 .cap_select
= MXL_CAP_SEL_ENABLE
,
1180 .div_out
= MXL_DIV_OUT_4
,
1181 .clock_out
= MXL_CLOCK_OUT_DISABLE
,
1182 .output_load
= MXL5005S_IF_OUTPUT_LOAD_200_OHM
,
1183 .top
= MXL5005S_TOP_25P2
,
1184 .mod_mode
= MXL_DIGITAL_MODE
,
1185 .if_mode
= MXL_ZERO_IF
,
1186 .AgcMasterByte
= 0x00,
1189 static struct mxl5005s_config af9015_mxl5005_config
= {
1190 .i2c_address
= 0xc6,
1191 .if_freq
= IF_FREQ_4570000HZ
,
1192 .xtal_freq
= CRYSTAL_FREQ_16000000HZ
,
1193 .agc_mode
= MXL_SINGLE_AGC
,
1194 .tracking_filter
= MXL_TF_OFF
,
1195 .rssi_enable
= MXL_RSSI_ENABLE
,
1196 .cap_select
= MXL_CAP_SEL_ENABLE
,
1197 .div_out
= MXL_DIV_OUT_4
,
1198 .clock_out
= MXL_CLOCK_OUT_DISABLE
,
1199 .output_load
= MXL5005S_IF_OUTPUT_LOAD_200_OHM
,
1200 .top
= MXL5005S_TOP_25P2
,
1201 .mod_mode
= MXL_DIGITAL_MODE
,
1202 .if_mode
= MXL_ZERO_IF
,
1203 .AgcMasterByte
= 0x00,
1206 static struct mc44s803_config af9015_mc44s803_config
= {
1207 .i2c_address
= 0xc0,
1211 static int af9015_tuner_attach(struct dvb_usb_adapter
*adap
)
1213 struct af9015_state
*state
= adap
->dev
->priv
;
1214 struct i2c_adapter
*i2c_adap
;
1216 deb_info("%s: \n", __func__
);
1218 /* select I2C adapter */
1220 i2c_adap
= &adap
->dev
->i2c_adap
;
1222 i2c_adap
= &state
->i2c_adap
;
1224 switch (af9015_af9013_config
[adap
->id
].tuner
) {
1225 case AF9013_TUNER_MT2060
:
1226 case AF9013_TUNER_MT2060_2
:
1227 ret
= dvb_attach(mt2060_attach
, adap
->fe
, i2c_adap
,
1228 &af9015_mt2060_config
,
1229 af9015_config
.mt2060_if1
[adap
->id
])
1230 == NULL
? -ENODEV
: 0;
1232 case AF9013_TUNER_QT1010
:
1233 case AF9013_TUNER_QT1010A
:
1234 ret
= dvb_attach(qt1010_attach
, adap
->fe
, i2c_adap
,
1235 &af9015_qt1010_config
) == NULL
? -ENODEV
: 0;
1237 case AF9013_TUNER_TDA18271
:
1238 ret
= dvb_attach(tda18271_attach
, adap
->fe
, 0xc0, i2c_adap
,
1239 &af9015_tda18271_config
) == NULL
? -ENODEV
: 0;
1241 case AF9013_TUNER_MXL5003D
:
1242 ret
= dvb_attach(mxl5005s_attach
, adap
->fe
, i2c_adap
,
1243 &af9015_mxl5003_config
) == NULL
? -ENODEV
: 0;
1245 case AF9013_TUNER_MXL5005D
:
1246 case AF9013_TUNER_MXL5005R
:
1247 ret
= dvb_attach(mxl5005s_attach
, adap
->fe
, i2c_adap
,
1248 &af9015_mxl5005_config
) == NULL
? -ENODEV
: 0;
1250 case AF9013_TUNER_ENV77H11D5
:
1251 ret
= dvb_attach(dvb_pll_attach
, adap
->fe
, 0xc0, i2c_adap
,
1252 DVB_PLL_TDA665X
) == NULL
? -ENODEV
: 0;
1254 case AF9013_TUNER_MC44S803
:
1255 ret
= dvb_attach(mc44s803_attach
, adap
->fe
, i2c_adap
,
1256 &af9015_mc44s803_config
) == NULL
? -ENODEV
: 0;
1258 case AF9013_TUNER_UNKNOWN
:
1261 err("Unknown tuner id:%d",
1262 af9015_af9013_config
[adap
->id
].tuner
);
1267 static struct usb_device_id af9015_usb_table
[] = {
1268 /* 0 */{USB_DEVICE(USB_VID_AFATECH
, USB_PID_AFATECH_AF9015_9015
)},
1269 {USB_DEVICE(USB_VID_AFATECH
, USB_PID_AFATECH_AF9015_9016
)},
1270 {USB_DEVICE(USB_VID_LEADTEK
, USB_PID_WINFAST_DTV_DONGLE_GOLD
)},
1271 {USB_DEVICE(USB_VID_PINNACLE
, USB_PID_PINNACLE_PCTV71E
)},
1272 {USB_DEVICE(USB_VID_KWORLD_2
, USB_PID_KWORLD_399U
)},
1273 /* 5 */{USB_DEVICE(USB_VID_VISIONPLUS
,
1275 {USB_DEVICE(USB_VID_VISIONPLUS
,
1276 USB_PID_AZUREWAVE_AD_TU700
)},
1277 {USB_DEVICE(USB_VID_TERRATEC
, USB_PID_TERRATEC_CINERGY_T_USB_XE_REV2
)},
1278 {USB_DEVICE(USB_VID_KWORLD_2
, USB_PID_KWORLD_PC160_2T
)},
1279 {USB_DEVICE(USB_VID_AVERMEDIA
, USB_PID_AVERMEDIA_VOLAR_X
)},
1280 /* 10 */{USB_DEVICE(USB_VID_XTENSIONS
, USB_PID_XTENSIONS_XD_380
)},
1281 {USB_DEVICE(USB_VID_MSI_2
, USB_PID_MSI_DIGIVOX_DUO
)},
1282 {USB_DEVICE(USB_VID_AVERMEDIA
, USB_PID_AVERMEDIA_VOLAR_X_2
)},
1283 {USB_DEVICE(USB_VID_TELESTAR
, USB_PID_TELESTAR_STARSTICK_2
)},
1284 {USB_DEVICE(USB_VID_AVERMEDIA
, USB_PID_AVERMEDIA_A309
)},
1285 /* 15 */{USB_DEVICE(USB_VID_MSI_2
, USB_PID_MSI_DIGI_VOX_MINI_III
)},
1286 {USB_DEVICE(USB_VID_KWORLD_2
, USB_PID_KWORLD_395U
)},
1287 {USB_DEVICE(USB_VID_KWORLD_2
, USB_PID_KWORLD_395U_2
)},
1288 {USB_DEVICE(USB_VID_KWORLD_2
, USB_PID_KWORLD_395U_3
)},
1289 {USB_DEVICE(USB_VID_AFATECH
, USB_PID_TREKSTOR_DVBT
)},
1290 /* 20 */{USB_DEVICE(USB_VID_AVERMEDIA
, USB_PID_AVERMEDIA_A850
)},
1291 {USB_DEVICE(USB_VID_AVERMEDIA
, USB_PID_AVERMEDIA_A805
)},
1292 {USB_DEVICE(USB_VID_KWORLD_2
, USB_PID_CONCEPTRONIC_CTVDIGRCU
)},
1293 {USB_DEVICE(USB_VID_KWORLD_2
, USB_PID_KWORLD_MC810
)},
1294 {USB_DEVICE(USB_VID_KYE
, USB_PID_GENIUS_TVGO_DVB_T03
)},
1295 /* 25 */{USB_DEVICE(USB_VID_KWORLD_2
, USB_PID_KWORLD_399U_2
)},
1296 {USB_DEVICE(USB_VID_KWORLD_2
, USB_PID_KWORLD_PC160_T
)},
1297 {USB_DEVICE(USB_VID_KWORLD_2
, USB_PID_SVEON_STV20
)},
1298 {USB_DEVICE(USB_VID_KWORLD_2
, USB_PID_TINYTWIN_2
)},
1299 {USB_DEVICE(USB_VID_LEADTEK
, USB_PID_WINFAST_DTV2000DS
)},
1302 MODULE_DEVICE_TABLE(usb
, af9015_usb_table
);
1304 static struct dvb_usb_device_properties af9015_properties
[] = {
1306 .caps
= DVB_USB_IS_AN_I2C_ADAPTER
,
1308 .usb_ctrl
= DEVICE_SPECIFIC
,
1309 .download_firmware
= af9015_download_firmware
,
1310 .firmware
= "dvb-usb-af9015.fw",
1313 .size_of_priv
= sizeof(struct af9015_state
),
1318 .caps
= DVB_USB_ADAP_HAS_PID_FILTER
|
1319 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF
,
1321 .pid_filter_count
= 32,
1322 .pid_filter
= af9015_pid_filter
,
1323 .pid_filter_ctrl
= af9015_pid_filter_ctrl
,
1326 af9015_af9013_frontend_attach
,
1327 .tuner_attach
= af9015_tuner_attach
,
1336 af9015_af9013_frontend_attach
,
1337 .tuner_attach
= af9015_tuner_attach
,
1345 TS_USB20_FRAME_SIZE
,
1352 .identify_state
= af9015_identify_state
,
1354 .rc_query
= af9015_rc_query
,
1357 .i2c_algo
= &af9015_i2c_algo
,
1359 .num_device_descs
= 9, /* max 9 */
1362 .name
= "Afatech AF9015 DVB-T USB2.0 stick",
1363 .cold_ids
= {&af9015_usb_table
[0],
1364 &af9015_usb_table
[1], NULL
},
1368 .name
= "Leadtek WinFast DTV Dongle Gold",
1369 .cold_ids
= {&af9015_usb_table
[2], NULL
},
1373 .name
= "Pinnacle PCTV 71e",
1374 .cold_ids
= {&af9015_usb_table
[3], NULL
},
1378 .name
= "KWorld PlusTV Dual DVB-T Stick " \
1380 .cold_ids
= {&af9015_usb_table
[4],
1381 &af9015_usb_table
[25], NULL
},
1385 .name
= "DigitalNow TinyTwin DVB-T Receiver",
1386 .cold_ids
= {&af9015_usb_table
[5],
1387 &af9015_usb_table
[28], NULL
},
1391 .name
= "TwinHan AzureWave AD-TU700(704J)",
1392 .cold_ids
= {&af9015_usb_table
[6], NULL
},
1396 .name
= "TerraTec Cinergy T USB XE",
1397 .cold_ids
= {&af9015_usb_table
[7], NULL
},
1401 .name
= "KWorld PlusTV Dual DVB-T PCI " \
1403 .cold_ids
= {&af9015_usb_table
[8], NULL
},
1407 .name
= "AVerMedia AVerTV DVB-T Volar X",
1408 .cold_ids
= {&af9015_usb_table
[9], NULL
},
1413 .caps
= DVB_USB_IS_AN_I2C_ADAPTER
,
1415 .usb_ctrl
= DEVICE_SPECIFIC
,
1416 .download_firmware
= af9015_download_firmware
,
1417 .firmware
= "dvb-usb-af9015.fw",
1420 .size_of_priv
= sizeof(struct af9015_state
),
1425 .caps
= DVB_USB_ADAP_HAS_PID_FILTER
|
1426 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF
,
1428 .pid_filter_count
= 32,
1429 .pid_filter
= af9015_pid_filter
,
1430 .pid_filter_ctrl
= af9015_pid_filter_ctrl
,
1433 af9015_af9013_frontend_attach
,
1434 .tuner_attach
= af9015_tuner_attach
,
1443 af9015_af9013_frontend_attach
,
1444 .tuner_attach
= af9015_tuner_attach
,
1452 TS_USB20_FRAME_SIZE
,
1459 .identify_state
= af9015_identify_state
,
1461 .rc_query
= af9015_rc_query
,
1464 .i2c_algo
= &af9015_i2c_algo
,
1466 .num_device_descs
= 9, /* max 9 */
1469 .name
= "Xtensions XD-380",
1470 .cold_ids
= {&af9015_usb_table
[10], NULL
},
1474 .name
= "MSI DIGIVOX Duo",
1475 .cold_ids
= {&af9015_usb_table
[11], NULL
},
1479 .name
= "Fujitsu-Siemens Slim Mobile USB DVB-T",
1480 .cold_ids
= {&af9015_usb_table
[12], NULL
},
1484 .name
= "Telestar Starstick 2",
1485 .cold_ids
= {&af9015_usb_table
[13], NULL
},
1489 .name
= "AVerMedia A309",
1490 .cold_ids
= {&af9015_usb_table
[14], NULL
},
1494 .name
= "MSI Digi VOX mini III",
1495 .cold_ids
= {&af9015_usb_table
[15], NULL
},
1499 .name
= "KWorld USB DVB-T TV Stick II " \
1501 .cold_ids
= {&af9015_usb_table
[16],
1502 &af9015_usb_table
[17],
1503 &af9015_usb_table
[18], NULL
},
1507 .name
= "TrekStor DVB-T USB Stick",
1508 .cold_ids
= {&af9015_usb_table
[19], NULL
},
1512 .name
= "AverMedia AVerTV Volar Black HD " \
1514 .cold_ids
= {&af9015_usb_table
[20], NULL
},
1519 .caps
= DVB_USB_IS_AN_I2C_ADAPTER
,
1521 .usb_ctrl
= DEVICE_SPECIFIC
,
1522 .download_firmware
= af9015_download_firmware
,
1523 .firmware
= "dvb-usb-af9015.fw",
1526 .size_of_priv
= sizeof(struct af9015_state
),
1531 .caps
= DVB_USB_ADAP_HAS_PID_FILTER
|
1532 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF
,
1534 .pid_filter_count
= 32,
1535 .pid_filter
= af9015_pid_filter
,
1536 .pid_filter_ctrl
= af9015_pid_filter_ctrl
,
1539 af9015_af9013_frontend_attach
,
1540 .tuner_attach
= af9015_tuner_attach
,
1549 af9015_af9013_frontend_attach
,
1550 .tuner_attach
= af9015_tuner_attach
,
1558 TS_USB20_FRAME_SIZE
,
1565 .identify_state
= af9015_identify_state
,
1567 .rc_query
= af9015_rc_query
,
1570 .i2c_algo
= &af9015_i2c_algo
,
1572 .num_device_descs
= 7, /* max 9 */
1575 .name
= "AverMedia AVerTV Volar GPS 805 (A805)",
1576 .cold_ids
= {&af9015_usb_table
[21], NULL
},
1580 .name
= "Conceptronic USB2.0 DVB-T CTVDIGRCU " \
1582 .cold_ids
= {&af9015_usb_table
[22], NULL
},
1586 .name
= "KWorld Digial MC-810",
1587 .cold_ids
= {&af9015_usb_table
[23], NULL
},
1591 .name
= "Genius TVGo DVB-T03",
1592 .cold_ids
= {&af9015_usb_table
[24], NULL
},
1596 .name
= "KWorld PlusTV DVB-T PCI Pro Card " \
1598 .cold_ids
= {&af9015_usb_table
[26], NULL
},
1602 .name
= "Sveon STV20 Tuner USB DVB-T HDTV",
1603 .cold_ids
= {&af9015_usb_table
[27], NULL
},
1607 .name
= "Leadtek WinFast DTV2000DS",
1608 .cold_ids
= {&af9015_usb_table
[29], NULL
},
1615 static int af9015_usb_probe(struct usb_interface
*intf
,
1616 const struct usb_device_id
*id
)
1619 struct dvb_usb_device
*d
= NULL
;
1620 struct usb_device
*udev
= interface_to_usbdev(intf
);
1623 deb_info("%s: interface:%d\n", __func__
,
1624 intf
->cur_altsetting
->desc
.bInterfaceNumber
);
1626 /* interface 0 is used by DVB-T receiver and
1627 interface 1 is for remote controller (HID) */
1628 if (intf
->cur_altsetting
->desc
.bInterfaceNumber
== 0) {
1629 ret
= af9015_read_config(udev
);
1633 for (i
= 0; i
< af9015_properties_count
; i
++) {
1634 ret
= dvb_usb_device_init(intf
, &af9015_properties
[i
],
1635 THIS_MODULE
, &d
, adapter_nr
);
1645 ret
= af9015_init(d
);
1651 static void af9015_i2c_exit(struct dvb_usb_device
*d
)
1653 struct af9015_state
*state
= d
->priv
;
1654 deb_info("%s: \n", __func__
);
1656 /* remove 2nd I2C adapter */
1657 if (d
->state
& DVB_USB_STATE_I2C
)
1658 i2c_del_adapter(&state
->i2c_adap
);
1661 static void af9015_usb_device_exit(struct usb_interface
*intf
)
1663 struct dvb_usb_device
*d
= usb_get_intfdata(intf
);
1664 deb_info("%s: \n", __func__
);
1666 /* remove 2nd I2C adapter */
1667 if (d
!= NULL
&& d
->desc
!= NULL
)
1670 dvb_usb_device_exit(intf
);
1673 /* usb specific object needed to register this driver with the usb subsystem */
1674 static struct usb_driver af9015_usb_driver
= {
1675 .name
= "dvb_usb_af9015",
1676 .probe
= af9015_usb_probe
,
1677 .disconnect
= af9015_usb_device_exit
,
1678 .id_table
= af9015_usb_table
,
1682 static int __init
af9015_usb_module_init(void)
1685 ret
= usb_register(&af9015_usb_driver
);
1687 err("module init failed:%d", ret
);
1692 static void __exit
af9015_usb_module_exit(void)
1694 /* deregister this driver from the USB subsystem */
1695 usb_deregister(&af9015_usb_driver
);
1698 module_init(af9015_usb_module_init
);
1699 module_exit(af9015_usb_module_exit
);
1701 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1702 MODULE_DESCRIPTION("Driver for Afatech AF9015 DVB-T");
1703 MODULE_LICENSE("GPL");