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.
34 static int dvb_usb_af9015_debug
;
35 module_param_named(debug
, dvb_usb_af9015_debug
, int, 0644);
36 MODULE_PARM_DESC(debug
, "set debugging level" DVB_USB_DEBUG_STATUS
);
37 static int dvb_usb_af9015_remote
;
38 module_param_named(remote
, dvb_usb_af9015_remote
, int, 0644);
39 MODULE_PARM_DESC(remote
, "select remote");
40 static int dvb_usb_af9015_dual_mode
;
41 module_param_named(dual_mode
, dvb_usb_af9015_dual_mode
, int, 0644);
42 MODULE_PARM_DESC(dual_mode
, "enable dual mode");
43 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr
);
45 static DEFINE_MUTEX(af9015_usb_mutex
);
47 static struct af9015_config af9015_config
;
48 static struct dvb_usb_device_properties af9015_properties
[2];
49 static int af9015_properties_count
= ARRAY_SIZE(af9015_properties
);
51 static struct af9013_config af9015_af9013_config
[] = {
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
[3] = AF9013_GPIO_TUNER_ON
,
60 .output_mode
= AF9013_OUTPUT_MODE_SERIAL
,
61 .api_version
= { 0, 1, 9, 0 },
62 .gpio
[0] = AF9013_GPIO_TUNER_ON
,
63 .gpio
[1] = AF9013_GPIO_LO
,
67 static int af9015_rw_udev(struct usb_device
*udev
, struct req_t
*req
)
73 static u8 seq
; /* packet sequence number */
75 if (mutex_lock_interruptible(&af9015_usb_mutex
) < 0)
80 buf
[2] = req
->i2c_addr
;
81 buf
[3] = req
->addr
>> 8;
82 buf
[4] = req
->addr
& 0xff;
84 buf
[6] = req
->addr_len
;
85 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
& 0xae00) == 0xae00))
104 buf
[0] = WRITE_VIRTUAL_MEMORY
;
105 case WRITE_VIRTUAL_MEMORY
:
107 case DOWNLOAD_FIRMWARE
:
110 err("unknown command:%d", req
->cmd
);
115 /* write requested */
117 memcpy(&buf
[8], req
->data
, req
->data_len
);
118 msg_len
+= req
->data_len
;
121 debug_dump(buf
, msg_len
, deb_xfer
);
124 ret
= usb_bulk_msg(udev
, usb_sndbulkpipe(udev
, 0x02), buf
, msg_len
,
125 &act_len
, AF9015_USB_TIMEOUT
);
127 err("bulk message failed:%d (%d/%d)", ret
, msg_len
, act_len
);
129 if (act_len
!= msg_len
)
130 ret
= -1; /* all data is not send */
134 /* no ack for those packets */
135 if (req
->cmd
== DOWNLOAD_FIRMWARE
|| req
->cmd
== RECONNECT_USB
)
138 /* receive ack and data if read req */
139 msg_len
= 1 + 1 + req
->data_len
; /* seq + status + data len */
140 ret
= usb_bulk_msg(udev
, usb_rcvbulkpipe(udev
, 0x81), buf
, msg_len
,
141 &act_len
, AF9015_USB_TIMEOUT
);
143 err("recv bulk message failed:%d", ret
);
149 debug_dump(buf
, act_len
, deb_xfer
);
151 /* remote controller query status is 1 if remote code is not received */
152 if (req
->cmd
== GET_IR_CODE
&& buf
[1] == 1) {
153 buf
[1] = 0; /* clear command "error" status */
154 memset(&buf
[2], 0, req
->data_len
);
155 buf
[3] = 1; /* no remote code received mark */
160 err("command failed:%d", buf
[1]);
165 /* read request, copy returned data to return buf */
167 memcpy(req
->data
, &buf
[2], req
->data_len
);
171 mutex_unlock(&af9015_usb_mutex
);
176 static int af9015_ctrl_msg(struct dvb_usb_device
*d
, struct req_t
*req
)
178 return af9015_rw_udev(d
->udev
, req
);
181 static int af9015_write_regs(struct dvb_usb_device
*d
, u16 addr
, u8
*val
,
184 struct req_t req
= {WRITE_MEMORY
, AF9015_I2C_DEMOD
, addr
, 0, 0, len
,
186 return af9015_ctrl_msg(d
, &req
);
189 static int af9015_write_reg(struct dvb_usb_device
*d
, u16 addr
, u8 val
)
191 return af9015_write_regs(d
, addr
, &val
, 1);
194 static int af9015_read_reg(struct dvb_usb_device
*d
, u16 addr
, u8
*val
)
196 struct req_t req
= {READ_MEMORY
, AF9015_I2C_DEMOD
, addr
, 0, 0, 1, val
};
197 return af9015_ctrl_msg(d
, &req
);
200 static int af9015_write_reg_i2c(struct dvb_usb_device
*d
, u8 addr
, u16 reg
,
203 struct req_t req
= {WRITE_I2C
, addr
, reg
, 1, 1, 1, &val
};
205 if (addr
== af9015_af9013_config
[0].demod_address
||
206 addr
== af9015_af9013_config
[1].demod_address
)
209 return af9015_ctrl_msg(d
, &req
);
212 static int af9015_read_reg_i2c(struct dvb_usb_device
*d
, u8 addr
, u16 reg
,
215 struct req_t req
= {READ_I2C
, addr
, reg
, 0, 1, 1, val
};
217 if (addr
== af9015_af9013_config
[0].demod_address
||
218 addr
== af9015_af9013_config
[1].demod_address
)
221 return af9015_ctrl_msg(d
, &req
);
224 static int af9015_i2c_xfer(struct i2c_adapter
*adap
, struct i2c_msg msg
[],
227 struct dvb_usb_device
*d
= i2c_get_adapdata(adap
);
233 /* TODO: implement bus lock
235 The bus lock is needed because there is two tuners both using same I2C-address.
236 Due to that the only way to select correct tuner is use demodulator I2C-gate.
238 ................................................
239 . AF9015 includes integrated AF9013 demodulator.
240 . ____________ ____________ . ____________
241 .| uC | | demod | . | tuner |
242 .|------------| |------------| . |------------|
243 .| AF9015 | | AF9013/5 | . | MXL5003 |
244 .| |--+----I2C-------|-----/ -----|-.-----I2C-------| |
245 .| | | | addr 0x38 | . | addr 0xc6 |
246 .|____________| | |____________| . |____________|
247 .................|..............................
248 | ____________ ____________
249 | | demod | | tuner |
250 | |------------| |------------|
251 | | AF9013 | | MXL5003 |
252 +----I2C-------|-----/ -----|-------I2C-------| |
253 | addr 0x3a | | addr 0xc6 |
254 |____________| |____________|
256 if (mutex_lock_interruptible(&d
->i2c_mutex
) < 0)
260 if (msg
[i
].addr
== af9015_af9013_config
[0].demod_address
||
261 msg
[i
].addr
== af9015_af9013_config
[1].demod_address
) {
262 addr
= msg
[i
].buf
[0] << 8;
263 addr
+= msg
[i
].buf
[1];
264 mbox
= msg
[i
].buf
[2];
267 addr
= msg
[i
].buf
[0];
272 if (num
> i
+ 1 && (msg
[i
+1].flags
& I2C_M_RD
)) {
274 af9015_af9013_config
[0].demod_address
)
275 req
.cmd
= READ_MEMORY
;
278 req
.i2c_addr
= msg
[i
].addr
;
281 req
.addr_len
= addr_len
;
282 req
.data_len
= msg
[i
+1].len
;
283 req
.data
= &msg
[i
+1].buf
[0];
284 ret
= af9015_ctrl_msg(d
, &req
);
288 af9015_af9013_config
[0].demod_address
)
289 req
.cmd
= WRITE_MEMORY
;
292 req
.i2c_addr
= msg
[i
].addr
;
295 req
.addr_len
= addr_len
;
296 req
.data_len
= msg
[i
].len
-addr_len
;
297 req
.data
= &msg
[i
].buf
[addr_len
];
298 ret
= af9015_ctrl_msg(d
, &req
);
308 mutex_unlock(&d
->i2c_mutex
);
313 static u32
af9015_i2c_func(struct i2c_adapter
*adapter
)
318 static struct i2c_algorithm af9015_i2c_algo
= {
319 .master_xfer
= af9015_i2c_xfer
,
320 .functionality
= af9015_i2c_func
,
323 static int af9015_do_reg_bit(struct dvb_usb_device
*d
, u16 addr
, u8 bit
, u8 op
)
328 ret
= af9015_read_reg(d
, addr
, &val
);
342 return af9015_write_reg(d
, addr
, val
);
345 static int af9015_set_reg_bit(struct dvb_usb_device
*d
, u16 addr
, u8 bit
)
347 return af9015_do_reg_bit(d
, addr
, bit
, 1);
350 static int af9015_clear_reg_bit(struct dvb_usb_device
*d
, u16 addr
, u8 bit
)
352 return af9015_do_reg_bit(d
, addr
, bit
, 0);
355 static int af9015_init_endpoint(struct dvb_usb_device
*d
)
360 deb_info("%s: USB speed:%d\n", __func__
, d
->udev
->speed
);
362 #define TS_PACKET_SIZE 188
364 #define TS_USB20_PACKET_COUNT 348
365 #define TS_USB20_FRAME_SIZE (TS_PACKET_SIZE*TS_USB20_PACKET_COUNT)
367 #define TS_USB11_PACKET_COUNT 21
368 #define TS_USB11_FRAME_SIZE (TS_PACKET_SIZE*TS_USB11_PACKET_COUNT)
370 #define TS_USB20_MAX_PACKET_SIZE 512
371 #define TS_USB11_MAX_PACKET_SIZE 64
373 if (d
->udev
->speed
== USB_SPEED_FULL
) {
374 frame_size
= TS_USB11_FRAME_SIZE
/4;
375 packet_size
= TS_USB11_MAX_PACKET_SIZE
/4;
377 frame_size
= TS_USB20_FRAME_SIZE
/4;
378 packet_size
= TS_USB20_MAX_PACKET_SIZE
/4;
381 ret
= af9015_set_reg_bit(d
, 0xd507, 2); /* assert EP4 reset */
384 ret
= af9015_set_reg_bit(d
, 0xd50b, 1); /* assert EP5 reset */
387 ret
= af9015_clear_reg_bit(d
, 0xdd11, 5); /* disable EP4 */
390 ret
= af9015_clear_reg_bit(d
, 0xdd11, 6); /* disable EP5 */
393 ret
= af9015_set_reg_bit(d
, 0xdd11, 5); /* enable EP4 */
396 if (af9015_config
.dual_mode
) {
397 ret
= af9015_set_reg_bit(d
, 0xdd11, 6); /* enable EP5 */
401 ret
= af9015_clear_reg_bit(d
, 0xdd13, 5); /* disable EP4 NAK */
404 if (af9015_config
.dual_mode
) {
405 ret
= af9015_clear_reg_bit(d
, 0xdd13, 6); /* disable EP5 NAK */
409 /* EP4 xfer length */
410 ret
= af9015_write_reg(d
, 0xdd88, frame_size
& 0xff);
413 ret
= af9015_write_reg(d
, 0xdd89, frame_size
>> 8);
416 /* EP5 xfer length */
417 ret
= af9015_write_reg(d
, 0xdd8a, frame_size
& 0xff);
420 ret
= af9015_write_reg(d
, 0xdd8b, frame_size
>> 8);
423 ret
= af9015_write_reg(d
, 0xdd0c, packet_size
); /* EP4 packet size */
426 ret
= af9015_write_reg(d
, 0xdd0d, packet_size
); /* EP5 packet size */
429 ret
= af9015_clear_reg_bit(d
, 0xd507, 2); /* negate EP4 reset */
432 if (af9015_config
.dual_mode
) {
433 ret
= af9015_clear_reg_bit(d
, 0xd50b, 1); /* negate EP5 reset */
438 /* enable / disable mp2if2 */
439 if (af9015_config
.dual_mode
)
440 ret
= af9015_set_reg_bit(d
, 0xd50b, 0);
442 ret
= af9015_clear_reg_bit(d
, 0xd50b, 0);
445 err("endpoint init failed:%d", ret
);
449 static int af9015_copy_firmware(struct dvb_usb_device
*d
)
454 struct req_t req
= {COPY_FIRMWARE
, 0, 0x5100, 0, 0, sizeof(fw_params
),
456 deb_info("%s:\n", __func__
);
458 fw_params
[0] = af9015_config
.firmware_size
>> 8;
459 fw_params
[1] = af9015_config
.firmware_size
& 0xff;
460 fw_params
[2] = af9015_config
.firmware_checksum
>> 8;
461 fw_params
[3] = af9015_config
.firmware_checksum
& 0xff;
463 /* wait 2nd demodulator ready */
466 ret
= af9015_read_reg_i2c(d
, 0x3a, 0x98be, &val
);
470 deb_info("%s: firmware status:%02x\n", __func__
, val
);
472 if (val
== 0x0c) /* fw is running, no need for download */
475 /* set I2C master clock to fast (to speed up firmware copy) */
476 ret
= af9015_write_reg(d
, 0xd416, 0x04); /* 0x04 * 400ns */
483 ret
= af9015_ctrl_msg(d
, &req
);
485 err("firmware copy cmd failed:%d", ret
);
486 deb_info("%s: firmware copy done\n", __func__
);
488 /* set I2C master clock back to normal */
489 ret
= af9015_write_reg(d
, 0xd416, 0x14); /* 0x14 * 400ns */
493 /* request boot firmware */
494 ret
= af9015_write_reg_i2c(d
, af9015_af9013_config
[1].demod_address
,
496 deb_info("%s: firmware boot cmd status:%d\n", __func__
, ret
);
500 for (i
= 0; i
< 15; i
++) {
503 /* check firmware status */
504 ret
= af9015_read_reg_i2c(d
,
505 af9015_af9013_config
[1].demod_address
, 0x98be, &val
);
506 deb_info("%s: firmware status cmd status:%d fw status:%02x\n",
511 if (val
== 0x0c || val
== 0x04) /* success or fail */
516 err("firmware did not run");
518 } else if (val
!= 0x0c) {
519 err("firmware boot timeout");
529 static int af9015_eeprom_dump(struct dvb_usb_device
*d
)
531 char buf
[52], buf2
[4];
534 for (reg
= 0; ; reg
++) {
537 deb_info("%s\n", buf
);
538 sprintf(buf
, "%02x: ", reg
);
540 if (af9015_read_reg_i2c(d
, AF9015_I2C_EEPROM
, reg
, &val
) == 0)
541 sprintf(buf2
, "%02x ", val
);
548 deb_info("%s\n", buf
);
552 static int af9015_download_ir_table(struct dvb_usb_device
*d
)
554 int i
, packets
= 0, ret
;
555 u16 addr
= 0x9a56; /* ir-table start address */
556 struct req_t req
= {WRITE_MEMORY
, 0, 0, 0, 0, 1, NULL
};
558 deb_info("%s:\n", __func__
);
560 data
= af9015_config
.ir_table
;
561 packets
= af9015_config
.ir_table_size
;
567 /* load remote ir-table */
568 for (i
= 0; i
< packets
; i
++) {
571 ret
= af9015_ctrl_msg(d
, &req
);
573 err("ir-table download failed at packet %d with " \
583 static int af9015_init(struct dvb_usb_device
*d
)
586 deb_info("%s:\n", __func__
);
588 ret
= af9015_init_endpoint(d
);
592 ret
= af9015_download_ir_table(d
);
600 static int af9015_pid_filter_ctrl(struct dvb_usb_adapter
*adap
, int onoff
)
603 deb_info("%s: onoff:%d\n", __func__
, onoff
);
606 ret
= af9015_set_reg_bit(adap
->dev
, 0xd503, 0);
608 ret
= af9015_clear_reg_bit(adap
->dev
, 0xd503, 0);
613 static int af9015_pid_filter(struct dvb_usb_adapter
*adap
, int index
, u16 pid
,
619 deb_info("%s: set pid filter, index %d, pid %x, onoff %d\n",
620 __func__
, index
, pid
, onoff
);
622 ret
= af9015_write_reg(adap
->dev
, 0xd505, (pid
& 0xff));
626 ret
= af9015_write_reg(adap
->dev
, 0xd506, (pid
>> 8));
630 idx
= ((index
& 0x1f) | (1 << 5));
631 ret
= af9015_write_reg(adap
->dev
, 0xd504, idx
);
637 static int af9015_download_firmware(struct usb_device
*udev
,
638 const struct firmware
*fw
)
640 int i
, len
, packets
, remainder
, ret
;
641 struct req_t req
= {DOWNLOAD_FIRMWARE
, 0, 0, 0, 0, 0, NULL
};
642 u16 addr
= 0x5100; /* firmware start address */
645 deb_info("%s:\n", __func__
);
648 for (i
= 0; i
< fw
->size
; i
++)
649 checksum
+= fw
->data
[i
];
651 af9015_config
.firmware_size
= fw
->size
;
652 af9015_config
.firmware_checksum
= checksum
;
654 #define FW_PACKET_MAX_DATA 55
656 packets
= fw
->size
/ FW_PACKET_MAX_DATA
;
657 remainder
= fw
->size
% FW_PACKET_MAX_DATA
;
658 len
= FW_PACKET_MAX_DATA
;
659 for (i
= 0; i
<= packets
; i
++) {
660 if (i
== packets
) /* set size of the last packet */
664 req
.data
= (u8
*)(fw
->data
+ i
* FW_PACKET_MAX_DATA
);
666 addr
+= FW_PACKET_MAX_DATA
;
668 ret
= af9015_rw_udev(udev
, &req
);
670 err("firmware download failed at packet %d with " \
676 /* firmware loaded, request boot */
678 ret
= af9015_rw_udev(udev
, &req
);
680 err("firmware boot failed:%d", ret
);
688 static int af9015_read_config(struct usb_device
*udev
)
691 u8 val
, i
, offset
= 0;
692 struct req_t req
= {READ_I2C
, AF9015_I2C_EEPROM
, 0, 0, 1, 1, &val
};
693 char manufacturer
[10];
695 /* IR remote controller */
696 req
.addr
= AF9015_EEPROM_IR_MODE
;
697 /* first message will timeout often due to possible hw bug */
698 for (i
= 0; i
< 4; i
++) {
699 ret
= af9015_rw_udev(udev
, &req
);
705 deb_info("%s: IR mode:%d\n", __func__
, val
);
706 for (i
= 0; i
< af9015_properties_count
; i
++) {
707 if (val
== AF9015_IR_MODE_DISABLED
|| val
== 0x04) {
708 af9015_properties
[i
].rc_key_map
= NULL
;
709 af9015_properties
[i
].rc_key_map_size
= 0;
710 } else if (dvb_usb_af9015_remote
) {
711 /* load remote defined as module param */
712 switch (dvb_usb_af9015_remote
) {
713 case AF9015_REMOTE_A_LINK_DTU_M
:
714 af9015_properties
[i
].rc_key_map
=
715 af9015_rc_keys_a_link
;
716 af9015_properties
[i
].rc_key_map_size
=
717 ARRAY_SIZE(af9015_rc_keys_a_link
);
718 af9015_config
.ir_table
= af9015_ir_table_a_link
;
719 af9015_config
.ir_table_size
=
720 ARRAY_SIZE(af9015_ir_table_a_link
);
722 case AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3
:
723 af9015_properties
[i
].rc_key_map
=
725 af9015_properties
[i
].rc_key_map_size
=
726 ARRAY_SIZE(af9015_rc_keys_msi
);
727 af9015_config
.ir_table
= af9015_ir_table_msi
;
728 af9015_config
.ir_table_size
=
729 ARRAY_SIZE(af9015_ir_table_msi
);
731 case AF9015_REMOTE_MYGICTV_U718
:
732 af9015_properties
[i
].rc_key_map
=
733 af9015_rc_keys_mygictv
;
734 af9015_properties
[i
].rc_key_map_size
=
735 ARRAY_SIZE(af9015_rc_keys_mygictv
);
736 af9015_config
.ir_table
=
737 af9015_ir_table_mygictv
;
738 af9015_config
.ir_table_size
=
739 ARRAY_SIZE(af9015_ir_table_mygictv
);
741 case AF9015_REMOTE_DIGITTRADE_DVB_T
:
742 af9015_properties
[i
].rc_key_map
=
743 af9015_rc_keys_digittrade
;
744 af9015_properties
[i
].rc_key_map_size
=
745 ARRAY_SIZE(af9015_rc_keys_digittrade
);
746 af9015_config
.ir_table
=
747 af9015_ir_table_digittrade
;
748 af9015_config
.ir_table_size
=
749 ARRAY_SIZE(af9015_ir_table_digittrade
);
753 switch (le16_to_cpu(udev
->descriptor
.idVendor
)) {
754 case USB_VID_LEADTEK
:
755 af9015_properties
[i
].rc_key_map
=
756 af9015_rc_keys_leadtek
;
757 af9015_properties
[i
].rc_key_map_size
=
758 ARRAY_SIZE(af9015_rc_keys_leadtek
);
759 af9015_config
.ir_table
=
760 af9015_ir_table_leadtek
;
761 af9015_config
.ir_table_size
=
762 ARRAY_SIZE(af9015_ir_table_leadtek
);
764 case USB_VID_VISIONPLUS
:
765 if (udev
->descriptor
.idProduct
==
766 cpu_to_le16(USB_PID_AZUREWAVE_AD_TU700
)) {
767 af9015_properties
[i
].rc_key_map
=
768 af9015_rc_keys_twinhan
;
769 af9015_properties
[i
].rc_key_map_size
=
770 ARRAY_SIZE(af9015_rc_keys_twinhan
);
771 af9015_config
.ir_table
=
772 af9015_ir_table_twinhan
;
773 af9015_config
.ir_table_size
=
774 ARRAY_SIZE(af9015_ir_table_twinhan
);
777 case USB_VID_KWORLD_2
:
778 /* TODO: use correct rc keys */
779 af9015_properties
[i
].rc_key_map
=
780 af9015_rc_keys_twinhan
;
781 af9015_properties
[i
].rc_key_map_size
=
782 ARRAY_SIZE(af9015_rc_keys_twinhan
);
783 af9015_config
.ir_table
= af9015_ir_table_kworld
;
784 af9015_config
.ir_table_size
=
785 ARRAY_SIZE(af9015_ir_table_kworld
);
787 /* Check USB manufacturer and product strings and try
788 to determine correct remote in case of chip vendor
789 reference IDs are used. */
790 case USB_VID_AFATECH
:
791 memset(manufacturer
, 0, sizeof(manufacturer
));
792 usb_string(udev
, udev
->descriptor
.iManufacturer
,
793 manufacturer
, sizeof(manufacturer
));
794 if (!strcmp("Geniatech", manufacturer
)) {
795 /* iManufacturer 1 Geniatech
797 af9015_properties
[i
].rc_key_map
=
798 af9015_rc_keys_mygictv
;
799 af9015_properties
[i
].rc_key_map_size
=
800 ARRAY_SIZE(af9015_rc_keys_mygictv
);
801 af9015_config
.ir_table
=
802 af9015_ir_table_mygictv
;
803 af9015_config
.ir_table_size
=
804 ARRAY_SIZE(af9015_ir_table_mygictv
);
805 } else if (!strcmp("MSI", manufacturer
)) {
806 /* iManufacturer 1 MSI
807 iProduct 2 MSI K-VOX */
808 af9015_properties
[i
].rc_key_map
=
810 af9015_properties
[i
].rc_key_map_size
=
811 ARRAY_SIZE(af9015_rc_keys_msi
);
812 af9015_config
.ir_table
=
814 af9015_config
.ir_table_size
=
815 ARRAY_SIZE(af9015_ir_table_msi
);
818 case USB_VID_AVERMEDIA
:
819 af9015_properties
[i
].rc_key_map
=
820 af9015_rc_keys_avermedia
;
821 af9015_properties
[i
].rc_key_map_size
=
822 ARRAY_SIZE(af9015_rc_keys_avermedia
);
823 af9015_config
.ir_table
=
824 af9015_ir_table_avermedia
;
825 af9015_config
.ir_table_size
=
826 ARRAY_SIZE(af9015_ir_table_avermedia
);
832 /* TS mode - one or two receivers */
833 req
.addr
= AF9015_EEPROM_TS_MODE
;
834 ret
= af9015_rw_udev(udev
, &req
);
837 af9015_config
.dual_mode
= val
;
838 deb_info("%s: TS mode:%d\n", __func__
, af9015_config
.dual_mode
);
839 /* disable dual mode by default because it is buggy */
840 if (!dvb_usb_af9015_dual_mode
)
841 af9015_config
.dual_mode
= 0;
843 /* Set adapter0 buffer size according to USB port speed, adapter1 buffer
844 size can be static because it is enabled only USB2.0 */
845 for (i
= 0; i
< af9015_properties_count
; i
++) {
846 /* USB1.1 set smaller buffersize and disable 2nd adapter */
847 if (udev
->speed
== USB_SPEED_FULL
) {
848 af9015_properties
[i
].adapter
[0].stream
.u
.bulk
.buffersize
849 = TS_USB11_MAX_PACKET_SIZE
;
850 /* disable 2nd adapter because we don't have
852 af9015_config
.dual_mode
= 0;
854 af9015_properties
[i
].adapter
[0].stream
.u
.bulk
.buffersize
855 = TS_USB20_MAX_PACKET_SIZE
;
859 if (af9015_config
.dual_mode
) {
860 /* read 2nd demodulator I2C address */
861 req
.addr
= AF9015_EEPROM_DEMOD2_I2C
;
862 ret
= af9015_rw_udev(udev
, &req
);
865 af9015_af9013_config
[1].demod_address
= val
;
867 /* enable 2nd adapter */
868 for (i
= 0; i
< af9015_properties_count
; i
++)
869 af9015_properties
[i
].num_adapters
= 2;
872 /* disable 2nd adapter */
873 for (i
= 0; i
< af9015_properties_count
; i
++)
874 af9015_properties
[i
].num_adapters
= 1;
877 for (i
= 0; i
< af9015_properties
[0].num_adapters
; i
++) {
879 offset
= AF9015_EEPROM_OFFSET
;
881 req
.addr
= AF9015_EEPROM_XTAL_TYPE1
+ offset
;
882 ret
= af9015_rw_udev(udev
, &req
);
887 af9015_af9013_config
[i
].adc_clock
= 28800;
890 af9015_af9013_config
[i
].adc_clock
= 20480;
893 af9015_af9013_config
[i
].adc_clock
= 28000;
896 af9015_af9013_config
[i
].adc_clock
= 25000;
899 deb_info("%s: [%d] xtal:%d set adc_clock:%d\n", __func__
, i
,
900 val
, af9015_af9013_config
[i
].adc_clock
);
903 req
.addr
= AF9015_EEPROM_IF1H
+ offset
;
904 ret
= af9015_rw_udev(udev
, &req
);
907 af9015_af9013_config
[i
].tuner_if
= val
<< 8;
908 req
.addr
= AF9015_EEPROM_IF1L
+ offset
;
909 ret
= af9015_rw_udev(udev
, &req
);
912 af9015_af9013_config
[i
].tuner_if
+= val
;
913 deb_info("%s: [%d] IF1:%d\n", __func__
, i
,
914 af9015_af9013_config
[0].tuner_if
);
917 req
.addr
= AF9015_EEPROM_MT2060_IF1H
+ offset
;
918 ret
= af9015_rw_udev(udev
, &req
);
921 af9015_config
.mt2060_if1
[i
] = val
<< 8;
922 req
.addr
= AF9015_EEPROM_MT2060_IF1L
+ offset
;
923 ret
= af9015_rw_udev(udev
, &req
);
926 af9015_config
.mt2060_if1
[i
] += val
;
927 deb_info("%s: [%d] MT2060 IF1:%d\n", __func__
, i
,
928 af9015_config
.mt2060_if1
[i
]);
931 req
.addr
= AF9015_EEPROM_TUNER_ID1
+ offset
;
932 ret
= af9015_rw_udev(udev
, &req
);
936 case AF9013_TUNER_ENV77H11D5
:
937 case AF9013_TUNER_MT2060
:
938 case AF9013_TUNER_MC44S803
:
939 case AF9013_TUNER_QT1010
:
940 case AF9013_TUNER_UNKNOWN
:
941 case AF9013_TUNER_MT2060_2
:
942 case AF9013_TUNER_TDA18271
:
943 case AF9013_TUNER_QT1010A
:
944 af9015_af9013_config
[i
].rf_spec_inv
= 1;
946 case AF9013_TUNER_MXL5003D
:
947 case AF9013_TUNER_MXL5005D
:
948 case AF9013_TUNER_MXL5005R
:
949 af9015_af9013_config
[i
].rf_spec_inv
= 0;
952 warn("tuner id:%d not supported, please report!", val
);
956 af9015_af9013_config
[i
].tuner
= val
;
957 deb_info("%s: [%d] tuner id:%d\n", __func__
, i
, val
);
962 err("eeprom read failed:%d", ret
);
967 static int af9015_identify_state(struct usb_device
*udev
,
968 struct dvb_usb_device_properties
*props
,
969 struct dvb_usb_device_description
**desc
,
974 struct req_t req
= {GET_CONFIG
, 0, 0, 0, 0, 1, &reply
};
976 ret
= af9015_rw_udev(udev
, &req
);
980 deb_info("%s: reply:%02x\n", __func__
, reply
);
989 static int af9015_rc_query(struct dvb_usb_device
*d
, u32
*event
, int *state
)
992 struct req_t req
= {GET_IR_CODE
, 0, 0, 0, 0, sizeof(buf
), buf
};
993 struct dvb_usb_rc_key
*keymap
= d
->props
.rc_key_map
;
996 memset(buf
, 0, sizeof(buf
));
998 ret
= af9015_ctrl_msg(d
, &req
);
1003 *state
= REMOTE_NO_KEY_PRESSED
;
1005 for (i
= 0; i
< d
->props
.rc_key_map_size
; i
++) {
1006 if (!buf
[1] && keymap
[i
].custom
== buf
[0] &&
1007 keymap
[i
].data
== buf
[2]) {
1008 *event
= keymap
[i
].event
;
1009 *state
= REMOTE_KEY_PRESSED
;
1014 deb_rc("%s: %02x %02x %02x %02x %02x %02x %02x %02x\n",
1015 __func__
, buf
[0], buf
[1], buf
[2], buf
[3], buf
[4],
1016 buf
[5], buf
[6], buf
[7]);
1021 /* init 2nd I2C adapter */
1022 static int af9015_i2c_init(struct dvb_usb_device
*d
)
1025 struct af9015_state
*state
= d
->priv
;
1026 deb_info("%s:\n", __func__
);
1028 strncpy(state
->i2c_adap
.name
, d
->desc
->name
,
1029 sizeof(state
->i2c_adap
.name
));
1030 #ifdef I2C_ADAP_CLASS_TV_DIGITAL
1031 state
->i2c_adap
.class = I2C_ADAP_CLASS_TV_DIGITAL
,
1033 state
->i2c_adap
.class = I2C_CLASS_TV_DIGITAL
,
1035 state
->i2c_adap
.algo
= d
->props
.i2c_algo
;
1036 state
->i2c_adap
.algo_data
= NULL
;
1037 state
->i2c_adap
.dev
.parent
= &d
->udev
->dev
;
1039 i2c_set_adapdata(&state
->i2c_adap
, d
);
1041 ret
= i2c_add_adapter(&state
->i2c_adap
);
1043 err("could not add i2c adapter");
1048 static int af9015_af9013_frontend_attach(struct dvb_usb_adapter
*adap
)
1051 struct af9015_state
*state
= adap
->dev
->priv
;
1052 struct i2c_adapter
*i2c_adap
;
1054 if (adap
->id
== 0) {
1055 /* select I2C adapter */
1056 i2c_adap
= &adap
->dev
->i2c_adap
;
1058 deb_info("%s: init I2C\n", __func__
);
1059 ret
= af9015_i2c_init(adap
->dev
);
1061 /* dump eeprom (debug) */
1062 ret
= af9015_eeprom_dump(adap
->dev
);
1066 /* select I2C adapter */
1067 i2c_adap
= &state
->i2c_adap
;
1069 /* copy firmware to 2nd demodulator */
1070 if (af9015_config
.dual_mode
) {
1071 ret
= af9015_copy_firmware(adap
->dev
);
1073 err("firmware copy to 2nd frontend " \
1074 "failed, will disable it");
1075 af9015_config
.dual_mode
= 0;
1083 /* attach demodulator */
1084 adap
->fe
= dvb_attach(af9013_attach
, &af9015_af9013_config
[adap
->id
],
1087 return adap
->fe
== NULL
? -ENODEV
: 0;
1090 static struct mt2060_config af9015_mt2060_config
= {
1091 .i2c_address
= 0xc0,
1095 static struct qt1010_config af9015_qt1010_config
= {
1096 .i2c_address
= 0xc4,
1099 static struct tda18271_config af9015_tda18271_config
= {
1100 .gate
= TDA18271_GATE_DIGITAL
,
1104 static struct mxl5005s_config af9015_mxl5003_config
= {
1105 .i2c_address
= 0xc6,
1106 .if_freq
= IF_FREQ_4570000HZ
,
1107 .xtal_freq
= CRYSTAL_FREQ_16000000HZ
,
1108 .agc_mode
= MXL_SINGLE_AGC
,
1109 .tracking_filter
= MXL_TF_DEFAULT
,
1110 .rssi_enable
= MXL_RSSI_ENABLE
,
1111 .cap_select
= MXL_CAP_SEL_ENABLE
,
1112 .div_out
= MXL_DIV_OUT_4
,
1113 .clock_out
= MXL_CLOCK_OUT_DISABLE
,
1114 .output_load
= MXL5005S_IF_OUTPUT_LOAD_200_OHM
,
1115 .top
= MXL5005S_TOP_25P2
,
1116 .mod_mode
= MXL_DIGITAL_MODE
,
1117 .if_mode
= MXL_ZERO_IF
,
1118 .AgcMasterByte
= 0x00,
1121 static struct mxl5005s_config af9015_mxl5005_config
= {
1122 .i2c_address
= 0xc6,
1123 .if_freq
= IF_FREQ_4570000HZ
,
1124 .xtal_freq
= CRYSTAL_FREQ_16000000HZ
,
1125 .agc_mode
= MXL_SINGLE_AGC
,
1126 .tracking_filter
= MXL_TF_OFF
,
1127 .rssi_enable
= MXL_RSSI_ENABLE
,
1128 .cap_select
= MXL_CAP_SEL_ENABLE
,
1129 .div_out
= MXL_DIV_OUT_4
,
1130 .clock_out
= MXL_CLOCK_OUT_DISABLE
,
1131 .output_load
= MXL5005S_IF_OUTPUT_LOAD_200_OHM
,
1132 .top
= MXL5005S_TOP_25P2
,
1133 .mod_mode
= MXL_DIGITAL_MODE
,
1134 .if_mode
= MXL_ZERO_IF
,
1135 .AgcMasterByte
= 0x00,
1138 static int af9015_tuner_attach(struct dvb_usb_adapter
*adap
)
1140 struct af9015_state
*state
= adap
->dev
->priv
;
1141 struct i2c_adapter
*i2c_adap
;
1143 deb_info("%s: \n", __func__
);
1145 /* select I2C adapter */
1147 i2c_adap
= &adap
->dev
->i2c_adap
;
1149 i2c_adap
= &state
->i2c_adap
;
1151 switch (af9015_af9013_config
[adap
->id
].tuner
) {
1152 case AF9013_TUNER_MT2060
:
1153 case AF9013_TUNER_MT2060_2
:
1154 ret
= dvb_attach(mt2060_attach
, adap
->fe
, i2c_adap
,
1155 &af9015_mt2060_config
,
1156 af9015_config
.mt2060_if1
[adap
->id
])
1157 == NULL
? -ENODEV
: 0;
1159 case AF9013_TUNER_QT1010
:
1160 case AF9013_TUNER_QT1010A
:
1161 ret
= dvb_attach(qt1010_attach
, adap
->fe
, i2c_adap
,
1162 &af9015_qt1010_config
) == NULL
? -ENODEV
: 0;
1164 case AF9013_TUNER_TDA18271
:
1165 ret
= dvb_attach(tda18271_attach
, adap
->fe
, 0xc0, i2c_adap
,
1166 &af9015_tda18271_config
) == NULL
? -ENODEV
: 0;
1168 case AF9013_TUNER_MXL5003D
:
1169 ret
= dvb_attach(mxl5005s_attach
, adap
->fe
, i2c_adap
,
1170 &af9015_mxl5003_config
) == NULL
? -ENODEV
: 0;
1172 case AF9013_TUNER_MXL5005D
:
1173 case AF9013_TUNER_MXL5005R
:
1174 ret
= dvb_attach(mxl5005s_attach
, adap
->fe
, i2c_adap
,
1175 &af9015_mxl5005_config
) == NULL
? -ENODEV
: 0;
1177 case AF9013_TUNER_ENV77H11D5
:
1178 ret
= dvb_attach(dvb_pll_attach
, adap
->fe
, 0xc0, i2c_adap
,
1179 DVB_PLL_TDA665X
) == NULL
? -ENODEV
: 0;
1181 case AF9013_TUNER_MC44S803
:
1183 ret
= dvb_attach(mc44s80x_attach
, adap
->fe
, i2c_adap
)
1184 == NULL
? -ENODEV
: 0;
1187 info("Freescale MC44S803 tuner found but no driver for that" \
1188 "tuner. Look at the Linuxtv.org for tuner driver" \
1192 case AF9013_TUNER_UNKNOWN
:
1195 err("Unknown tuner id:%d",
1196 af9015_af9013_config
[adap
->id
].tuner
);
1201 static struct usb_device_id af9015_usb_table
[] = {
1202 /* 0 */{USB_DEVICE(USB_VID_AFATECH
, USB_PID_AFATECH_AF9015_9015
)},
1203 {USB_DEVICE(USB_VID_AFATECH
, USB_PID_AFATECH_AF9015_9016
)},
1204 {USB_DEVICE(USB_VID_LEADTEK
, USB_PID_WINFAST_DTV_DONGLE_GOLD
)},
1205 {USB_DEVICE(USB_VID_PINNACLE
, USB_PID_PINNACLE_PCTV71E
)},
1206 {USB_DEVICE(USB_VID_KWORLD_2
, USB_PID_KWORLD_399U
)},
1207 /* 5 */{USB_DEVICE(USB_VID_VISIONPLUS
,
1209 {USB_DEVICE(USB_VID_VISIONPLUS
,
1210 USB_PID_AZUREWAVE_AD_TU700
)},
1211 {USB_DEVICE(USB_VID_TERRATEC
, USB_PID_TERRATEC_CINERGY_T_USB_XE_REV2
)},
1212 {USB_DEVICE(USB_VID_KWORLD_2
, USB_PID_KWORLD_PC160_2T
)},
1213 {USB_DEVICE(USB_VID_AVERMEDIA
, USB_PID_AVERMEDIA_VOLAR_X
)},
1214 /* 10 */{USB_DEVICE(USB_VID_XTENSIONS
, USB_PID_XTENSIONS_XD_380
)},
1215 {USB_DEVICE(USB_VID_MSI_2
, USB_PID_MSI_DIGIVOX_DUO
)},
1216 {USB_DEVICE(USB_VID_AVERMEDIA
, USB_PID_AVERMEDIA_VOLAR_X_2
)},
1217 {USB_DEVICE(USB_VID_TELESTAR
, USB_PID_TELESTAR_STARSTICK_2
)},
1218 {USB_DEVICE(USB_VID_AVERMEDIA
, USB_PID_AVERMEDIA_A309
)},
1219 /* 15 */{USB_DEVICE(USB_VID_MSI_2
, USB_PID_MSI_DIGI_VOX_MINI_III
)},
1220 {USB_DEVICE(USB_VID_KWORLD_2
, USB_PID_KWORLD_395U
)},
1223 MODULE_DEVICE_TABLE(usb
, af9015_usb_table
);
1225 static struct dvb_usb_device_properties af9015_properties
[] = {
1227 .caps
= DVB_USB_IS_AN_I2C_ADAPTER
,
1229 .usb_ctrl
= DEVICE_SPECIFIC
,
1230 .download_firmware
= af9015_download_firmware
,
1231 .firmware
= "dvb-usb-af9015.fw",
1234 .size_of_priv
= sizeof(struct af9015_state
), \
1239 .caps
= DVB_USB_ADAP_HAS_PID_FILTER
|
1240 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF
,
1242 .pid_filter_count
= 32,
1243 .pid_filter
= af9015_pid_filter
,
1244 .pid_filter_ctrl
= af9015_pid_filter_ctrl
,
1247 af9015_af9013_frontend_attach
,
1248 .tuner_attach
= af9015_tuner_attach
,
1257 af9015_af9013_frontend_attach
,
1258 .tuner_attach
= af9015_tuner_attach
,
1266 TS_USB20_MAX_PACKET_SIZE
,
1273 .identify_state
= af9015_identify_state
,
1275 .rc_query
= af9015_rc_query
,
1278 .i2c_algo
= &af9015_i2c_algo
,
1280 .num_device_descs
= 9,
1283 .name
= "Afatech AF9015 DVB-T USB2.0 stick",
1284 .cold_ids
= {&af9015_usb_table
[0],
1285 &af9015_usb_table
[1], NULL
},
1289 .name
= "Leadtek WinFast DTV Dongle Gold",
1290 .cold_ids
= {&af9015_usb_table
[2], NULL
},
1294 .name
= "Pinnacle PCTV 71e",
1295 .cold_ids
= {&af9015_usb_table
[3], NULL
},
1299 .name
= "KWorld PlusTV Dual DVB-T Stick " \
1301 .cold_ids
= {&af9015_usb_table
[4], NULL
},
1305 .name
= "DigitalNow TinyTwin DVB-T Receiver",
1306 .cold_ids
= {&af9015_usb_table
[5], NULL
},
1310 .name
= "TwinHan AzureWave AD-TU700(704J)",
1311 .cold_ids
= {&af9015_usb_table
[6], NULL
},
1315 .name
= "TerraTec Cinergy T USB XE",
1316 .cold_ids
= {&af9015_usb_table
[7], NULL
},
1320 .name
= "KWorld PlusTV Dual DVB-T PCI " \
1322 .cold_ids
= {&af9015_usb_table
[8], NULL
},
1326 .name
= "AVerMedia AVerTV DVB-T Volar X",
1327 .cold_ids
= {&af9015_usb_table
[9], NULL
},
1332 .caps
= DVB_USB_IS_AN_I2C_ADAPTER
,
1334 .usb_ctrl
= DEVICE_SPECIFIC
,
1335 .download_firmware
= af9015_download_firmware
,
1336 .firmware
= "dvb-usb-af9015.fw",
1339 .size_of_priv
= sizeof(struct af9015_state
), \
1344 .caps
= DVB_USB_ADAP_HAS_PID_FILTER
|
1345 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF
,
1347 .pid_filter_count
= 32,
1348 .pid_filter
= af9015_pid_filter
,
1349 .pid_filter_ctrl
= af9015_pid_filter_ctrl
,
1352 af9015_af9013_frontend_attach
,
1353 .tuner_attach
= af9015_tuner_attach
,
1362 af9015_af9013_frontend_attach
,
1363 .tuner_attach
= af9015_tuner_attach
,
1371 TS_USB20_MAX_PACKET_SIZE
,
1378 .identify_state
= af9015_identify_state
,
1380 .rc_query
= af9015_rc_query
,
1383 .i2c_algo
= &af9015_i2c_algo
,
1385 .num_device_descs
= 7,
1388 .name
= "Xtensions XD-380",
1389 .cold_ids
= {&af9015_usb_table
[10], NULL
},
1393 .name
= "MSI DIGIVOX Duo",
1394 .cold_ids
= {&af9015_usb_table
[11], NULL
},
1398 .name
= "Fujitsu-Siemens Slim Mobile USB DVB-T",
1399 .cold_ids
= {&af9015_usb_table
[12], NULL
},
1403 .name
= "Telestar Starstick 2",
1404 .cold_ids
= {&af9015_usb_table
[13], NULL
},
1408 .name
= "AVerMedia A309",
1409 .cold_ids
= {&af9015_usb_table
[14], NULL
},
1413 .name
= "MSI Digi VOX mini III",
1414 .cold_ids
= {&af9015_usb_table
[15], NULL
},
1418 .name
= "KWorld USB DVB-T TV Stick II " \
1420 .cold_ids
= {&af9015_usb_table
[16], NULL
},
1427 static int af9015_usb_probe(struct usb_interface
*intf
,
1428 const struct usb_device_id
*id
)
1431 struct dvb_usb_device
*d
= NULL
;
1432 struct usb_device
*udev
= interface_to_usbdev(intf
);
1435 deb_info("%s: interface:%d\n", __func__
,
1436 intf
->cur_altsetting
->desc
.bInterfaceNumber
);
1438 /* interface 0 is used by DVB-T receiver and
1439 interface 1 is for remote controller (HID) */
1440 if (intf
->cur_altsetting
->desc
.bInterfaceNumber
== 0) {
1441 ret
= af9015_read_config(udev
);
1445 for (i
= 0; i
< af9015_properties_count
; i
++) {
1446 ret
= dvb_usb_device_init(intf
, &af9015_properties
[i
],
1447 THIS_MODULE
, &d
, adapter_nr
);
1457 ret
= af9015_init(d
);
1463 static void af9015_i2c_exit(struct dvb_usb_device
*d
)
1465 struct af9015_state
*state
= d
->priv
;
1466 deb_info("%s: \n", __func__
);
1468 /* remove 2nd I2C adapter */
1469 if (d
->state
& DVB_USB_STATE_I2C
)
1470 i2c_del_adapter(&state
->i2c_adap
);
1473 static void af9015_usb_device_exit(struct usb_interface
*intf
)
1475 struct dvb_usb_device
*d
= usb_get_intfdata(intf
);
1476 deb_info("%s: \n", __func__
);
1478 /* remove 2nd I2C adapter */
1479 if (d
!= NULL
&& d
->desc
!= NULL
)
1482 dvb_usb_device_exit(intf
);
1485 /* usb specific object needed to register this driver with the usb subsystem */
1486 static struct usb_driver af9015_usb_driver
= {
1487 .name
= "dvb_usb_af9015",
1488 .probe
= af9015_usb_probe
,
1489 .disconnect
= af9015_usb_device_exit
,
1490 .id_table
= af9015_usb_table
,
1494 static int __init
af9015_usb_module_init(void)
1497 ret
= usb_register(&af9015_usb_driver
);
1499 err("module init failed:%d", ret
);
1504 static void __exit
af9015_usb_module_exit(void)
1506 /* deregister this driver from the USB subsystem */
1507 usb_deregister(&af9015_usb_driver
);
1510 module_init(af9015_usb_module_init
);
1511 module_exit(af9015_usb_module_exit
);
1513 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1514 MODULE_DESCRIPTION("Driver for Afatech AF9015 DVB-T");
1515 MODULE_LICENSE("GPL");