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 ret
= af9015_rw_udev(udev
, &req
);
700 deb_info("%s: IR mode:%d\n", __func__
, val
);
701 for (i
= 0; i
< af9015_properties_count
; i
++) {
702 if (val
== AF9015_IR_MODE_DISABLED
|| val
== 0x04) {
703 af9015_properties
[i
].rc_key_map
= NULL
;
704 af9015_properties
[i
].rc_key_map_size
= 0;
705 } else if (dvb_usb_af9015_remote
) {
706 /* load remote defined as module param */
707 switch (dvb_usb_af9015_remote
) {
708 case AF9015_REMOTE_A_LINK_DTU_M
:
709 af9015_properties
[i
].rc_key_map
=
710 af9015_rc_keys_a_link
;
711 af9015_properties
[i
].rc_key_map_size
=
712 ARRAY_SIZE(af9015_rc_keys_a_link
);
713 af9015_config
.ir_table
= af9015_ir_table_a_link
;
714 af9015_config
.ir_table_size
=
715 ARRAY_SIZE(af9015_ir_table_a_link
);
717 case AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3
:
718 af9015_properties
[i
].rc_key_map
=
720 af9015_properties
[i
].rc_key_map_size
=
721 ARRAY_SIZE(af9015_rc_keys_msi
);
722 af9015_config
.ir_table
= af9015_ir_table_msi
;
723 af9015_config
.ir_table_size
=
724 ARRAY_SIZE(af9015_ir_table_msi
);
726 case AF9015_REMOTE_MYGICTV_U718
:
727 af9015_properties
[i
].rc_key_map
=
728 af9015_rc_keys_mygictv
;
729 af9015_properties
[i
].rc_key_map_size
=
730 ARRAY_SIZE(af9015_rc_keys_mygictv
);
731 af9015_config
.ir_table
=
732 af9015_ir_table_mygictv
;
733 af9015_config
.ir_table_size
=
734 ARRAY_SIZE(af9015_ir_table_mygictv
);
736 case AF9015_REMOTE_DIGITTRADE_DVB_T
:
737 af9015_properties
[i
].rc_key_map
=
738 af9015_rc_keys_digittrade
;
739 af9015_properties
[i
].rc_key_map_size
=
740 ARRAY_SIZE(af9015_rc_keys_digittrade
);
741 af9015_config
.ir_table
=
742 af9015_ir_table_digittrade
;
743 af9015_config
.ir_table_size
=
744 ARRAY_SIZE(af9015_ir_table_digittrade
);
748 switch (le16_to_cpu(udev
->descriptor
.idVendor
)) {
749 case USB_VID_LEADTEK
:
750 af9015_properties
[i
].rc_key_map
=
751 af9015_rc_keys_leadtek
;
752 af9015_properties
[i
].rc_key_map_size
=
753 ARRAY_SIZE(af9015_rc_keys_leadtek
);
754 af9015_config
.ir_table
=
755 af9015_ir_table_leadtek
;
756 af9015_config
.ir_table_size
=
757 ARRAY_SIZE(af9015_ir_table_leadtek
);
759 case USB_VID_VISIONPLUS
:
760 if (udev
->descriptor
.idProduct
==
761 cpu_to_le16(USB_PID_AZUREWAVE_AD_TU700
)) {
762 af9015_properties
[i
].rc_key_map
=
763 af9015_rc_keys_twinhan
;
764 af9015_properties
[i
].rc_key_map_size
=
765 ARRAY_SIZE(af9015_rc_keys_twinhan
);
766 af9015_config
.ir_table
=
767 af9015_ir_table_twinhan
;
768 af9015_config
.ir_table_size
=
769 ARRAY_SIZE(af9015_ir_table_twinhan
);
772 case USB_VID_KWORLD_2
:
773 /* TODO: use correct rc keys */
774 af9015_properties
[i
].rc_key_map
=
775 af9015_rc_keys_twinhan
;
776 af9015_properties
[i
].rc_key_map_size
=
777 ARRAY_SIZE(af9015_rc_keys_twinhan
);
778 af9015_config
.ir_table
= af9015_ir_table_kworld
;
779 af9015_config
.ir_table_size
=
780 ARRAY_SIZE(af9015_ir_table_kworld
);
782 /* Check USB manufacturer and product strings and try
783 to determine correct remote in case of chip vendor
784 reference IDs are used. */
785 case USB_VID_AFATECH
:
786 memset(manufacturer
, 0, sizeof(manufacturer
));
787 usb_string(udev
, udev
->descriptor
.iManufacturer
,
788 manufacturer
, sizeof(manufacturer
));
789 if (!strcmp("Geniatech", manufacturer
)) {
790 /* iManufacturer 1 Geniatech
792 af9015_properties
[i
].rc_key_map
=
793 af9015_rc_keys_mygictv
;
794 af9015_properties
[i
].rc_key_map_size
=
795 ARRAY_SIZE(af9015_rc_keys_mygictv
);
796 af9015_config
.ir_table
=
797 af9015_ir_table_mygictv
;
798 af9015_config
.ir_table_size
=
799 ARRAY_SIZE(af9015_ir_table_mygictv
);
800 } else if (!strcmp("MSI", manufacturer
)) {
801 /* iManufacturer 1 MSI
802 iProduct 2 MSI K-VOX */
803 af9015_properties
[i
].rc_key_map
=
805 af9015_properties
[i
].rc_key_map_size
=
806 ARRAY_SIZE(af9015_rc_keys_msi
);
807 af9015_config
.ir_table
=
809 af9015_config
.ir_table_size
=
810 ARRAY_SIZE(af9015_ir_table_msi
);
813 case USB_VID_AVERMEDIA
:
814 af9015_properties
[i
].rc_key_map
=
815 af9015_rc_keys_avermedia
;
816 af9015_properties
[i
].rc_key_map_size
=
817 ARRAY_SIZE(af9015_rc_keys_avermedia
);
818 af9015_config
.ir_table
=
819 af9015_ir_table_avermedia
;
820 af9015_config
.ir_table_size
=
821 ARRAY_SIZE(af9015_ir_table_avermedia
);
827 /* TS mode - one or two receivers */
828 req
.addr
= AF9015_EEPROM_TS_MODE
;
829 ret
= af9015_rw_udev(udev
, &req
);
832 af9015_config
.dual_mode
= val
;
833 deb_info("%s: TS mode:%d\n", __func__
, af9015_config
.dual_mode
);
834 /* disable dual mode by default because it is buggy */
835 if (!dvb_usb_af9015_dual_mode
)
836 af9015_config
.dual_mode
= 0;
838 /* set buffer size according to USB port speed */
839 for (i
= 0; i
< af9015_properties_count
; i
++) {
840 /* USB1.1 set smaller buffersize and disable 2nd adapter */
841 if (udev
->speed
== USB_SPEED_FULL
) {
842 af9015_properties
[i
].adapter
->stream
.u
.bulk
.buffersize
=
843 TS_USB11_MAX_PACKET_SIZE
;
844 /* disable 2nd adapter because we don't have
846 af9015_config
.dual_mode
= 0;
848 af9015_properties
[i
].adapter
->stream
.u
.bulk
.buffersize
=
849 TS_USB20_MAX_PACKET_SIZE
;
853 if (af9015_config
.dual_mode
) {
854 /* read 2nd demodulator I2C address */
855 req
.addr
= AF9015_EEPROM_DEMOD2_I2C
;
856 ret
= af9015_rw_udev(udev
, &req
);
859 af9015_af9013_config
[1].demod_address
= val
;
861 /* enable 2nd adapter */
862 for (i
= 0; i
< af9015_properties_count
; i
++)
863 af9015_properties
[i
].num_adapters
= 2;
866 /* disable 2nd adapter */
867 for (i
= 0; i
< af9015_properties_count
; i
++)
868 af9015_properties
[i
].num_adapters
= 1;
871 for (i
= 0; i
< af9015_properties
[0].num_adapters
; i
++) {
873 offset
= AF9015_EEPROM_OFFSET
;
875 req
.addr
= AF9015_EEPROM_XTAL_TYPE1
+ offset
;
876 ret
= af9015_rw_udev(udev
, &req
);
881 af9015_af9013_config
[i
].adc_clock
= 28800;
884 af9015_af9013_config
[i
].adc_clock
= 20480;
887 af9015_af9013_config
[i
].adc_clock
= 28000;
890 af9015_af9013_config
[i
].adc_clock
= 25000;
893 deb_info("%s: [%d] xtal:%d set adc_clock:%d\n", __func__
, i
,
894 val
, af9015_af9013_config
[i
].adc_clock
);
897 req
.addr
= AF9015_EEPROM_IF1H
+ offset
;
898 ret
= af9015_rw_udev(udev
, &req
);
901 af9015_af9013_config
[i
].tuner_if
= val
<< 8;
902 req
.addr
= AF9015_EEPROM_IF1L
+ offset
;
903 ret
= af9015_rw_udev(udev
, &req
);
906 af9015_af9013_config
[i
].tuner_if
+= val
;
907 deb_info("%s: [%d] IF1:%d\n", __func__
, i
,
908 af9015_af9013_config
[0].tuner_if
);
911 req
.addr
= AF9015_EEPROM_MT2060_IF1H
+ offset
;
912 ret
= af9015_rw_udev(udev
, &req
);
915 af9015_config
.mt2060_if1
[i
] = val
<< 8;
916 req
.addr
= AF9015_EEPROM_MT2060_IF1L
+ offset
;
917 ret
= af9015_rw_udev(udev
, &req
);
920 af9015_config
.mt2060_if1
[i
] += val
;
921 deb_info("%s: [%d] MT2060 IF1:%d\n", __func__
, i
,
922 af9015_config
.mt2060_if1
[i
]);
925 req
.addr
= AF9015_EEPROM_TUNER_ID1
+ offset
;
926 ret
= af9015_rw_udev(udev
, &req
);
930 case AF9013_TUNER_ENV77H11D5
:
931 case AF9013_TUNER_MT2060
:
932 case AF9013_TUNER_MC44S803
:
933 case AF9013_TUNER_QT1010
:
934 case AF9013_TUNER_UNKNOWN
:
935 case AF9013_TUNER_MT2060_2
:
936 case AF9013_TUNER_TDA18271
:
937 case AF9013_TUNER_QT1010A
:
938 af9015_af9013_config
[i
].rf_spec_inv
= 1;
940 case AF9013_TUNER_MXL5003D
:
941 case AF9013_TUNER_MXL5005D
:
942 case AF9013_TUNER_MXL5005R
:
943 af9015_af9013_config
[i
].rf_spec_inv
= 0;
946 warn("tuner id:%d not supported, please report!", val
);
950 af9015_af9013_config
[i
].tuner
= val
;
951 deb_info("%s: [%d] tuner id:%d\n", __func__
, i
, val
);
956 err("eeprom read failed:%d", ret
);
961 static int af9015_identify_state(struct usb_device
*udev
,
962 struct dvb_usb_device_properties
*props
,
963 struct dvb_usb_device_description
**desc
,
968 struct req_t req
= {GET_CONFIG
, 0, 0, 0, 0, 1, &reply
};
970 ret
= af9015_rw_udev(udev
, &req
);
974 deb_info("%s: reply:%02x\n", __func__
, reply
);
983 static int af9015_rc_query(struct dvb_usb_device
*d
, u32
*event
, int *state
)
986 struct req_t req
= {GET_IR_CODE
, 0, 0, 0, 0, sizeof(buf
), buf
};
987 struct dvb_usb_rc_key
*keymap
= d
->props
.rc_key_map
;
990 memset(buf
, 0, sizeof(buf
));
992 ret
= af9015_ctrl_msg(d
, &req
);
997 *state
= REMOTE_NO_KEY_PRESSED
;
999 for (i
= 0; i
< d
->props
.rc_key_map_size
; i
++) {
1000 if (!buf
[1] && keymap
[i
].custom
== buf
[0] &&
1001 keymap
[i
].data
== buf
[2]) {
1002 *event
= keymap
[i
].event
;
1003 *state
= REMOTE_KEY_PRESSED
;
1008 deb_rc("%s: %02x %02x %02x %02x %02x %02x %02x %02x\n",
1009 __func__
, buf
[0], buf
[1], buf
[2], buf
[3], buf
[4],
1010 buf
[5], buf
[6], buf
[7]);
1015 /* init 2nd I2C adapter */
1016 static int af9015_i2c_init(struct dvb_usb_device
*d
)
1019 struct af9015_state
*state
= d
->priv
;
1020 deb_info("%s:\n", __func__
);
1022 strncpy(state
->i2c_adap
.name
, d
->desc
->name
,
1023 sizeof(state
->i2c_adap
.name
));
1024 #ifdef I2C_ADAP_CLASS_TV_DIGITAL
1025 state
->i2c_adap
.class = I2C_ADAP_CLASS_TV_DIGITAL
,
1027 state
->i2c_adap
.class = I2C_CLASS_TV_DIGITAL
,
1029 state
->i2c_adap
.algo
= d
->props
.i2c_algo
;
1030 state
->i2c_adap
.algo_data
= NULL
;
1031 state
->i2c_adap
.dev
.parent
= &d
->udev
->dev
;
1033 i2c_set_adapdata(&state
->i2c_adap
, d
);
1035 ret
= i2c_add_adapter(&state
->i2c_adap
);
1037 err("could not add i2c adapter");
1042 static int af9015_af9013_frontend_attach(struct dvb_usb_adapter
*adap
)
1045 struct af9015_state
*state
= adap
->dev
->priv
;
1046 struct i2c_adapter
*i2c_adap
;
1048 if (adap
->id
== 0) {
1049 /* select I2C adapter */
1050 i2c_adap
= &adap
->dev
->i2c_adap
;
1052 deb_info("%s: init I2C\n", __func__
);
1053 ret
= af9015_i2c_init(adap
->dev
);
1055 /* dump eeprom (debug) */
1056 ret
= af9015_eeprom_dump(adap
->dev
);
1060 /* select I2C adapter */
1061 i2c_adap
= &state
->i2c_adap
;
1063 /* copy firmware to 2nd demodulator */
1064 if (af9015_config
.dual_mode
) {
1065 ret
= af9015_copy_firmware(adap
->dev
);
1067 err("firmware copy to 2nd frontend " \
1068 "failed, will disable it");
1069 af9015_config
.dual_mode
= 0;
1077 /* attach demodulator */
1078 adap
->fe
= dvb_attach(af9013_attach
, &af9015_af9013_config
[adap
->id
],
1081 return adap
->fe
== NULL
? -ENODEV
: 0;
1084 static struct mt2060_config af9015_mt2060_config
= {
1085 .i2c_address
= 0xc0,
1089 static struct qt1010_config af9015_qt1010_config
= {
1090 .i2c_address
= 0xc4,
1093 static struct tda18271_config af9015_tda18271_config
= {
1094 .gate
= TDA18271_GATE_DIGITAL
,
1098 static struct mxl5005s_config af9015_mxl5003_config
= {
1099 .i2c_address
= 0xc6,
1100 .if_freq
= IF_FREQ_4570000HZ
,
1101 .xtal_freq
= CRYSTAL_FREQ_16000000HZ
,
1102 .agc_mode
= MXL_SINGLE_AGC
,
1103 .tracking_filter
= MXL_TF_DEFAULT
,
1104 .rssi_enable
= MXL_RSSI_ENABLE
,
1105 .cap_select
= MXL_CAP_SEL_ENABLE
,
1106 .div_out
= MXL_DIV_OUT_4
,
1107 .clock_out
= MXL_CLOCK_OUT_DISABLE
,
1108 .output_load
= MXL5005S_IF_OUTPUT_LOAD_200_OHM
,
1109 .top
= MXL5005S_TOP_25P2
,
1110 .mod_mode
= MXL_DIGITAL_MODE
,
1111 .if_mode
= MXL_ZERO_IF
,
1112 .AgcMasterByte
= 0x00,
1115 static struct mxl5005s_config af9015_mxl5005_config
= {
1116 .i2c_address
= 0xc6,
1117 .if_freq
= IF_FREQ_4570000HZ
,
1118 .xtal_freq
= CRYSTAL_FREQ_16000000HZ
,
1119 .agc_mode
= MXL_SINGLE_AGC
,
1120 .tracking_filter
= MXL_TF_OFF
,
1121 .rssi_enable
= MXL_RSSI_ENABLE
,
1122 .cap_select
= MXL_CAP_SEL_ENABLE
,
1123 .div_out
= MXL_DIV_OUT_4
,
1124 .clock_out
= MXL_CLOCK_OUT_DISABLE
,
1125 .output_load
= MXL5005S_IF_OUTPUT_LOAD_200_OHM
,
1126 .top
= MXL5005S_TOP_25P2
,
1127 .mod_mode
= MXL_DIGITAL_MODE
,
1128 .if_mode
= MXL_ZERO_IF
,
1129 .AgcMasterByte
= 0x00,
1132 static int af9015_tuner_attach(struct dvb_usb_adapter
*adap
)
1134 struct af9015_state
*state
= adap
->dev
->priv
;
1135 struct i2c_adapter
*i2c_adap
;
1137 deb_info("%s: \n", __func__
);
1139 /* select I2C adapter */
1141 i2c_adap
= &adap
->dev
->i2c_adap
;
1143 i2c_adap
= &state
->i2c_adap
;
1145 switch (af9015_af9013_config
[adap
->id
].tuner
) {
1146 case AF9013_TUNER_MT2060
:
1147 case AF9013_TUNER_MT2060_2
:
1148 ret
= dvb_attach(mt2060_attach
, adap
->fe
, i2c_adap
,
1149 &af9015_mt2060_config
,
1150 af9015_config
.mt2060_if1
[adap
->id
])
1151 == NULL
? -ENODEV
: 0;
1153 case AF9013_TUNER_QT1010
:
1154 case AF9013_TUNER_QT1010A
:
1155 ret
= dvb_attach(qt1010_attach
, adap
->fe
, i2c_adap
,
1156 &af9015_qt1010_config
) == NULL
? -ENODEV
: 0;
1158 case AF9013_TUNER_TDA18271
:
1159 ret
= dvb_attach(tda18271_attach
, adap
->fe
, 0xc0, i2c_adap
,
1160 &af9015_tda18271_config
) == NULL
? -ENODEV
: 0;
1162 case AF9013_TUNER_MXL5003D
:
1163 ret
= dvb_attach(mxl5005s_attach
, adap
->fe
, i2c_adap
,
1164 &af9015_mxl5003_config
) == NULL
? -ENODEV
: 0;
1166 case AF9013_TUNER_MXL5005D
:
1167 case AF9013_TUNER_MXL5005R
:
1168 ret
= dvb_attach(mxl5005s_attach
, adap
->fe
, i2c_adap
,
1169 &af9015_mxl5005_config
) == NULL
? -ENODEV
: 0;
1171 case AF9013_TUNER_ENV77H11D5
:
1172 ret
= dvb_attach(dvb_pll_attach
, adap
->fe
, 0xc0, i2c_adap
,
1173 DVB_PLL_TDA665X
) == NULL
? -ENODEV
: 0;
1175 case AF9013_TUNER_MC44S803
:
1177 ret
= dvb_attach(mc44s80x_attach
, adap
->fe
, i2c_adap
)
1178 == NULL
? -ENODEV
: 0;
1181 info("Freescale MC44S803 tuner found but no driver for that" \
1182 "tuner. Look at the Linuxtv.org for tuner driver" \
1186 case AF9013_TUNER_UNKNOWN
:
1189 err("Unknown tuner id:%d",
1190 af9015_af9013_config
[adap
->id
].tuner
);
1195 static struct usb_device_id af9015_usb_table
[] = {
1196 /* 0 */{USB_DEVICE(USB_VID_AFATECH
, USB_PID_AFATECH_AF9015_9015
)},
1197 {USB_DEVICE(USB_VID_AFATECH
, USB_PID_AFATECH_AF9015_9016
)},
1198 {USB_DEVICE(USB_VID_LEADTEK
, USB_PID_WINFAST_DTV_DONGLE_GOLD
)},
1199 {USB_DEVICE(USB_VID_PINNACLE
, USB_PID_PINNACLE_PCTV71E
)},
1200 {USB_DEVICE(USB_VID_KWORLD_2
, USB_PID_KWORLD_399U
)},
1201 /* 5 */{USB_DEVICE(USB_VID_VISIONPLUS
,
1203 {USB_DEVICE(USB_VID_VISIONPLUS
,
1204 USB_PID_AZUREWAVE_AD_TU700
)},
1205 {USB_DEVICE(USB_VID_TERRATEC
, USB_PID_TERRATEC_CINERGY_T_USB_XE_REV2
)},
1206 {USB_DEVICE(USB_VID_KWORLD_2
, USB_PID_KWORLD_PC160_2T
)},
1207 {USB_DEVICE(USB_VID_AVERMEDIA
, USB_PID_AVERMEDIA_VOLAR_X
)},
1208 /* 10 */{USB_DEVICE(USB_VID_XTENSIONS
, USB_PID_XTENSIONS_XD_380
)},
1209 {USB_DEVICE(USB_VID_MSI_2
, USB_PID_MSI_DIGIVOX_DUO
)},
1210 {USB_DEVICE(USB_VID_AVERMEDIA
, USB_PID_AVERMEDIA_VOLAR_X_2
)},
1211 {USB_DEVICE(USB_VID_TELESTAR
, USB_PID_TELESTAR_STARSTICK_2
)},
1212 {USB_DEVICE(USB_VID_AVERMEDIA
, USB_PID_AVERMEDIA_A309
)},
1213 /* 15 */{USB_DEVICE(USB_VID_MSI_2
, USB_PID_MSI_DIGI_VOX_MINI_III
)},
1214 {USB_DEVICE(USB_VID_KWORLD_2
, USB_PID_KWORLD_395U
)},
1217 MODULE_DEVICE_TABLE(usb
, af9015_usb_table
);
1219 static struct dvb_usb_device_properties af9015_properties
[] = {
1221 .caps
= DVB_USB_IS_AN_I2C_ADAPTER
,
1223 .usb_ctrl
= DEVICE_SPECIFIC
,
1224 .download_firmware
= af9015_download_firmware
,
1225 .firmware
= "dvb-usb-af9015.fw",
1228 .size_of_priv
= sizeof(struct af9015_state
), \
1233 .caps
= DVB_USB_ADAP_HAS_PID_FILTER
|
1234 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF
,
1236 .pid_filter_count
= 32,
1237 .pid_filter
= af9015_pid_filter
,
1238 .pid_filter_ctrl
= af9015_pid_filter_ctrl
,
1241 af9015_af9013_frontend_attach
,
1242 .tuner_attach
= af9015_tuner_attach
,
1251 af9015_af9013_frontend_attach
,
1252 .tuner_attach
= af9015_tuner_attach
,
1261 .identify_state
= af9015_identify_state
,
1263 .rc_query
= af9015_rc_query
,
1266 .i2c_algo
= &af9015_i2c_algo
,
1268 .num_device_descs
= 9,
1271 .name
= "Afatech AF9015 DVB-T USB2.0 stick",
1272 .cold_ids
= {&af9015_usb_table
[0],
1273 &af9015_usb_table
[1], NULL
},
1277 .name
= "Leadtek WinFast DTV Dongle Gold",
1278 .cold_ids
= {&af9015_usb_table
[2], NULL
},
1282 .name
= "Pinnacle PCTV 71e",
1283 .cold_ids
= {&af9015_usb_table
[3], NULL
},
1287 .name
= "KWorld PlusTV Dual DVB-T Stick " \
1289 .cold_ids
= {&af9015_usb_table
[4], NULL
},
1293 .name
= "DigitalNow TinyTwin DVB-T Receiver",
1294 .cold_ids
= {&af9015_usb_table
[5], NULL
},
1298 .name
= "TwinHan AzureWave AD-TU700(704J)",
1299 .cold_ids
= {&af9015_usb_table
[6], NULL
},
1303 .name
= "TerraTec Cinergy T USB XE",
1304 .cold_ids
= {&af9015_usb_table
[7], NULL
},
1308 .name
= "KWorld PlusTV Dual DVB-T PCI " \
1310 .cold_ids
= {&af9015_usb_table
[8], NULL
},
1314 .name
= "AVerMedia AVerTV DVB-T Volar X",
1315 .cold_ids
= {&af9015_usb_table
[9], NULL
},
1320 .caps
= DVB_USB_IS_AN_I2C_ADAPTER
,
1322 .usb_ctrl
= DEVICE_SPECIFIC
,
1323 .download_firmware
= af9015_download_firmware
,
1324 .firmware
= "dvb-usb-af9015.fw",
1327 .size_of_priv
= sizeof(struct af9015_state
), \
1332 .caps
= DVB_USB_ADAP_HAS_PID_FILTER
|
1333 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF
,
1335 .pid_filter_count
= 32,
1336 .pid_filter
= af9015_pid_filter
,
1337 .pid_filter_ctrl
= af9015_pid_filter_ctrl
,
1340 af9015_af9013_frontend_attach
,
1341 .tuner_attach
= af9015_tuner_attach
,
1350 af9015_af9013_frontend_attach
,
1351 .tuner_attach
= af9015_tuner_attach
,
1360 .identify_state
= af9015_identify_state
,
1362 .rc_query
= af9015_rc_query
,
1365 .i2c_algo
= &af9015_i2c_algo
,
1367 .num_device_descs
= 7,
1370 .name
= "Xtensions XD-380",
1371 .cold_ids
= {&af9015_usb_table
[10], NULL
},
1375 .name
= "MSI DIGIVOX Duo",
1376 .cold_ids
= {&af9015_usb_table
[11], NULL
},
1380 .name
= "Fujitsu-Siemens Slim Mobile USB DVB-T",
1381 .cold_ids
= {&af9015_usb_table
[12], NULL
},
1385 .name
= "Telestar Starstick 2",
1386 .cold_ids
= {&af9015_usb_table
[13], NULL
},
1390 .name
= "AVerMedia A309",
1391 .cold_ids
= {&af9015_usb_table
[14], NULL
},
1395 .name
= "MSI Digi VOX mini III",
1396 .cold_ids
= {&af9015_usb_table
[15], NULL
},
1400 .name
= "KWorld USB DVB-T TV Stick II " \
1402 .cold_ids
= {&af9015_usb_table
[16], NULL
},
1409 static int af9015_usb_probe(struct usb_interface
*intf
,
1410 const struct usb_device_id
*id
)
1413 struct dvb_usb_device
*d
= NULL
;
1414 struct usb_device
*udev
= interface_to_usbdev(intf
);
1417 deb_info("%s: interface:%d\n", __func__
,
1418 intf
->cur_altsetting
->desc
.bInterfaceNumber
);
1420 /* interface 0 is used by DVB-T receiver and
1421 interface 1 is for remote controller (HID) */
1422 if (intf
->cur_altsetting
->desc
.bInterfaceNumber
== 0) {
1423 ret
= af9015_read_config(udev
);
1427 for (i
= 0; i
< af9015_properties_count
; i
++) {
1428 ret
= dvb_usb_device_init(intf
, &af9015_properties
[i
],
1429 THIS_MODULE
, &d
, adapter_nr
);
1439 ret
= af9015_init(d
);
1445 static void af9015_i2c_exit(struct dvb_usb_device
*d
)
1447 struct af9015_state
*state
= d
->priv
;
1448 deb_info("%s: \n", __func__
);
1450 /* remove 2nd I2C adapter */
1451 if (d
->state
& DVB_USB_STATE_I2C
)
1452 i2c_del_adapter(&state
->i2c_adap
);
1455 static void af9015_usb_device_exit(struct usb_interface
*intf
)
1457 struct dvb_usb_device
*d
= usb_get_intfdata(intf
);
1458 deb_info("%s: \n", __func__
);
1460 /* remove 2nd I2C adapter */
1461 if (d
!= NULL
&& d
->desc
!= NULL
)
1464 dvb_usb_device_exit(intf
);
1467 /* usb specific object needed to register this driver with the usb subsystem */
1468 static struct usb_driver af9015_usb_driver
= {
1469 .name
= "dvb_usb_af9015",
1470 .probe
= af9015_usb_probe
,
1471 .disconnect
= af9015_usb_device_exit
,
1472 .id_table
= af9015_usb_table
,
1476 static int __init
af9015_usb_module_init(void)
1479 ret
= usb_register(&af9015_usb_driver
);
1481 err("module init failed:%d", ret
);
1486 static void __exit
af9015_usb_module_exit(void)
1488 /* deregister this driver from the USB subsystem */
1489 usb_deregister(&af9015_usb_driver
);
1492 module_init(af9015_usb_module_init
);
1493 module_exit(af9015_usb_module_exit
);
1495 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1496 MODULE_DESCRIPTION("Driver for Afatech AF9015 DVB-T");
1497 MODULE_LICENSE("GPL");