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 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 int dvb_usb_af9015_remote;
38 module_param_named(remote, dvb_usb_af9015_remote, int, 0644);
39 MODULE_PARM_DESC(remote, "select remote");
40 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 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 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 = (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 " \
675 #undef FW_PACKET_MAX_DATA
677 /* firmware loaded, request boot */
679 ret = af9015_rw_udev(udev, &req);
681 err("firmware boot failed:%d", ret);
685 /* firmware is running, reconnect device in the usb bus */
686 req.cmd = RECONNECT_USB;
687 ret = af9015_rw_udev(udev, &req);
689 err("reconnect failed: %d", ret);
695 static int af9015_read_config(struct usb_device *udev)
698 u8 val, i, offset = 0;
699 struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, &val};
700 char manufacturer[10];
702 /* IR remote controller */
703 req.addr = AF9015_EEPROM_IR_MODE;
704 ret = af9015_rw_udev(udev, &req);
707 deb_info("%s: IR mode:%d\n", __func__, val);
708 for (i = 0; i < af9015_properties_count; i++) {
709 if (val == AF9015_IR_MODE_DISABLED || val == 0x04) {
710 af9015_properties[i].rc_key_map = NULL;
711 af9015_properties[i].rc_key_map_size = 0;
712 } else if (dvb_usb_af9015_remote) {
713 /* load remote defined as module param */
714 switch (dvb_usb_af9015_remote) {
715 case AF9015_REMOTE_A_LINK_DTU_M:
716 af9015_properties[i].rc_key_map =
717 af9015_rc_keys_a_link;
718 af9015_properties[i].rc_key_map_size =
719 ARRAY_SIZE(af9015_rc_keys_a_link);
720 af9015_config.ir_table = af9015_ir_table_a_link;
721 af9015_config.ir_table_size =
722 ARRAY_SIZE(af9015_ir_table_a_link);
724 case AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3:
725 af9015_properties[i].rc_key_map =
727 af9015_properties[i].rc_key_map_size =
728 ARRAY_SIZE(af9015_rc_keys_msi);
729 af9015_config.ir_table = af9015_ir_table_msi;
730 af9015_config.ir_table_size =
731 ARRAY_SIZE(af9015_ir_table_msi);
733 case AF9015_REMOTE_MYGICTV_U718:
734 af9015_properties[i].rc_key_map =
735 af9015_rc_keys_mygictv;
736 af9015_properties[i].rc_key_map_size =
737 ARRAY_SIZE(af9015_rc_keys_mygictv);
738 af9015_config.ir_table =
739 af9015_ir_table_mygictv;
740 af9015_config.ir_table_size =
741 ARRAY_SIZE(af9015_ir_table_mygictv);
745 switch (udev->descriptor.idVendor) {
746 case cpu_to_le16(USB_VID_LEADTEK):
747 af9015_properties[i].rc_key_map =
748 af9015_rc_keys_leadtek;
749 af9015_properties[i].rc_key_map_size =
750 ARRAY_SIZE(af9015_rc_keys_leadtek);
751 af9015_config.ir_table =
752 af9015_ir_table_leadtek;
753 af9015_config.ir_table_size =
754 ARRAY_SIZE(af9015_ir_table_leadtek);
756 case cpu_to_le16(USB_VID_VISIONPLUS):
757 if (udev->descriptor.idProduct ==
758 cpu_to_le16(USB_PID_AZUREWAVE_AD_TU700)) {
759 af9015_properties[i].rc_key_map =
760 af9015_rc_keys_twinhan;
761 af9015_properties[i].rc_key_map_size =
762 ARRAY_SIZE(af9015_rc_keys_twinhan);
763 af9015_config.ir_table =
764 af9015_ir_table_twinhan;
765 af9015_config.ir_table_size =
766 ARRAY_SIZE(af9015_ir_table_twinhan);
769 case cpu_to_le16(USB_VID_KWORLD_2):
770 /* TODO: use correct rc keys */
771 af9015_properties[i].rc_key_map =
772 af9015_rc_keys_twinhan;
773 af9015_properties[i].rc_key_map_size =
774 ARRAY_SIZE(af9015_rc_keys_twinhan);
775 af9015_config.ir_table = af9015_ir_table_kworld;
776 af9015_config.ir_table_size =
777 ARRAY_SIZE(af9015_ir_table_kworld);
779 /* Check USB manufacturer and product strings and try
780 to determine correct remote in case of chip vendor
781 reference IDs are used. */
782 case cpu_to_le16(USB_VID_AFATECH):
783 memset(manufacturer, 0, sizeof(manufacturer));
784 usb_string(udev, udev->descriptor.iManufacturer,
785 manufacturer, sizeof(manufacturer));
786 if (!strcmp("Geniatech", manufacturer)) {
787 /* iManufacturer 1 Geniatech
789 af9015_properties[i].rc_key_map =
790 af9015_rc_keys_mygictv;
791 af9015_properties[i].rc_key_map_size =
792 ARRAY_SIZE(af9015_rc_keys_mygictv);
793 af9015_config.ir_table =
794 af9015_ir_table_mygictv;
795 af9015_config.ir_table_size =
796 ARRAY_SIZE(af9015_ir_table_mygictv);
797 } else if (!strcmp("MSI", manufacturer)) {
798 /* iManufacturer 1 MSI
799 iProduct 2 MSI K-VOX */
800 af9015_properties[i].rc_key_map =
802 af9015_properties[i].rc_key_map_size =
803 ARRAY_SIZE(af9015_rc_keys_msi);
804 af9015_config.ir_table =
806 af9015_config.ir_table_size =
807 ARRAY_SIZE(af9015_ir_table_msi);
814 /* TS mode - one or two receivers */
815 req.addr = AF9015_EEPROM_TS_MODE;
816 ret = af9015_rw_udev(udev, &req);
819 af9015_config.dual_mode = val;
820 deb_info("%s: TS mode:%d\n", __func__, af9015_config.dual_mode);
821 /* disable dual mode by default because it is buggy */
822 if (!dvb_usb_af9015_dual_mode)
823 af9015_config.dual_mode = 0;
825 /* set buffer size according to USB port speed */
826 for (i = 0; i < af9015_properties_count; i++) {
827 /* USB1.1 set smaller buffersize and disable 2nd adapter */
828 if (udev->speed == USB_SPEED_FULL) {
829 af9015_properties[i].adapter->stream.u.bulk.buffersize =
830 TS_USB11_MAX_PACKET_SIZE;
831 /* disable 2nd adapter because we don't have
833 af9015_config.dual_mode = 0;
835 af9015_properties[i].adapter->stream.u.bulk.buffersize =
836 TS_USB20_MAX_PACKET_SIZE;
840 if (af9015_config.dual_mode) {
841 /* read 2nd demodulator I2C address */
842 req.addr = AF9015_EEPROM_DEMOD2_I2C;
843 ret = af9015_rw_udev(udev, &req);
846 af9015_af9013_config[1].demod_address = val;
848 /* enable 2nd adapter */
849 for (i = 0; i < af9015_properties_count; i++)
850 af9015_properties[i].num_adapters = 2;
853 /* disable 2nd adapter */
854 for (i = 0; i < af9015_properties_count; i++)
855 af9015_properties[i].num_adapters = 1;
858 for (i = 0; i < af9015_properties[0].num_adapters; i++) {
860 offset = AF9015_EEPROM_OFFSET;
862 req.addr = AF9015_EEPROM_XTAL_TYPE1 + offset;
863 ret = af9015_rw_udev(udev, &req);
868 af9015_af9013_config[i].adc_clock = 28800;
871 af9015_af9013_config[i].adc_clock = 20480;
874 af9015_af9013_config[i].adc_clock = 28000;
877 af9015_af9013_config[i].adc_clock = 25000;
880 deb_info("%s: [%d] xtal:%d set adc_clock:%d\n", __func__, i,
881 val, af9015_af9013_config[i].adc_clock);
884 req.addr = AF9015_EEPROM_IF1H + offset;
885 ret = af9015_rw_udev(udev, &req);
888 af9015_af9013_config[i].tuner_if = val << 8;
889 req.addr = AF9015_EEPROM_IF1L + offset;
890 ret = af9015_rw_udev(udev, &req);
893 af9015_af9013_config[i].tuner_if += val;
894 deb_info("%s: [%d] IF1:%d\n", __func__, i,
895 af9015_af9013_config[0].tuner_if);
898 req.addr = AF9015_EEPROM_MT2060_IF1H + offset;
899 ret = af9015_rw_udev(udev, &req);
902 af9015_config.mt2060_if1[i] = val << 8;
903 req.addr = AF9015_EEPROM_MT2060_IF1L + offset;
904 ret = af9015_rw_udev(udev, &req);
907 af9015_config.mt2060_if1[i] += val;
908 deb_info("%s: [%d] MT2060 IF1:%d\n", __func__, i,
909 af9015_config.mt2060_if1[i]);
912 req.addr = AF9015_EEPROM_TUNER_ID1 + offset;
913 ret = af9015_rw_udev(udev, &req);
917 case AF9013_TUNER_ENV77H11D5:
918 case AF9013_TUNER_MT2060:
919 case AF9013_TUNER_MC44S803:
920 case AF9013_TUNER_QT1010:
921 case AF9013_TUNER_UNKNOWN:
922 case AF9013_TUNER_MT2060_2:
923 case AF9013_TUNER_TDA18271:
924 case AF9013_TUNER_QT1010A:
925 af9015_af9013_config[i].rf_spec_inv = 1;
927 case AF9013_TUNER_MXL5003D:
928 case AF9013_TUNER_MXL5005D:
929 case AF9013_TUNER_MXL5005R:
930 af9015_af9013_config[i].rf_spec_inv = 0;
933 warn("tuner id:%d not supported, please report!", val);
937 af9015_af9013_config[i].tuner = val;
938 deb_info("%s: [%d] tuner id:%d\n", __func__, i, val);
943 err("eeprom read failed:%d", ret);
948 static int af9015_identify_state(struct usb_device *udev,
949 struct dvb_usb_device_properties *props,
950 struct dvb_usb_device_description **desc,
955 struct req_t req = {GET_CONFIG, 0, 0, 0, 0, 1, &reply};
957 ret = af9015_rw_udev(udev, &req);
961 deb_info("%s: reply:%02x\n", __func__, reply);
970 static int af9015_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
973 struct req_t req = {GET_IR_CODE, 0, 0, 0, 0, sizeof(buf), buf};
974 struct dvb_usb_rc_key *keymap = d->props.rc_key_map;
977 memset(buf, 0, sizeof(buf));
979 ret = af9015_ctrl_msg(d, &req);
984 *state = REMOTE_NO_KEY_PRESSED;
986 for (i = 0; i < d->props.rc_key_map_size; i++) {
987 if (!buf[1] && keymap[i].custom == buf[0] &&
988 keymap[i].data == buf[2]) {
989 *event = keymap[i].event;
990 *state = REMOTE_KEY_PRESSED;
995 deb_rc("%s: %02x %02x %02x %02x %02x %02x %02x %02x\n",
996 __func__, buf[0], buf[1], buf[2], buf[3], buf[4],
997 buf[5], buf[6], buf[7]);
1002 /* init 2nd I2C adapter */
1003 int af9015_i2c_init(struct dvb_usb_device *d)
1006 struct af9015_state *state = d->priv;
1007 deb_info("%s:\n", __func__);
1009 strncpy(state->i2c_adap.name, d->desc->name,
1010 sizeof(state->i2c_adap.name));
1011 #ifdef I2C_ADAP_CLASS_TV_DIGITAL
1012 state->i2c_adap.class = I2C_ADAP_CLASS_TV_DIGITAL,
1014 state->i2c_adap.class = I2C_CLASS_TV_DIGITAL,
1016 state->i2c_adap.algo = d->props.i2c_algo;
1017 state->i2c_adap.algo_data = NULL;
1018 state->i2c_adap.dev.parent = &d->udev->dev;
1020 i2c_set_adapdata(&state->i2c_adap, d);
1022 ret = i2c_add_adapter(&state->i2c_adap);
1024 err("could not add i2c adapter");
1029 static int af9015_af9013_frontend_attach(struct dvb_usb_adapter *adap)
1032 struct af9015_state *state = adap->dev->priv;
1033 struct i2c_adapter *i2c_adap;
1035 if (adap->id == 0) {
1036 /* select I2C adapter */
1037 i2c_adap = &adap->dev->i2c_adap;
1039 deb_info("%s: init I2C\n", __func__);
1040 ret = af9015_i2c_init(adap->dev);
1042 /* dump eeprom (debug) */
1043 ret = af9015_eeprom_dump(adap->dev);
1047 /* select I2C adapter */
1048 i2c_adap = &state->i2c_adap;
1050 /* copy firmware to 2nd demodulator */
1051 if (af9015_config.dual_mode) {
1052 ret = af9015_copy_firmware(adap->dev);
1054 err("firmware copy to 2nd frontend " \
1055 "failed, will disable it");
1056 af9015_config.dual_mode = 0;
1064 /* attach demodulator */
1065 adap->fe = dvb_attach(af9013_attach, &af9015_af9013_config[adap->id],
1068 return adap->fe == NULL ? -ENODEV : 0;
1071 static struct mt2060_config af9015_mt2060_config = {
1072 .i2c_address = 0xc0,
1076 static struct qt1010_config af9015_qt1010_config = {
1077 .i2c_address = 0xc4,
1080 static struct tda18271_config af9015_tda18271_config = {
1081 .gate = TDA18271_GATE_DIGITAL,
1085 static struct mxl5005s_config af9015_mxl5003_config = {
1086 .i2c_address = 0xc6,
1087 .if_freq = IF_FREQ_4570000HZ,
1088 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
1089 .agc_mode = MXL_SINGLE_AGC,
1090 .tracking_filter = MXL_TF_DEFAULT,
1091 .rssi_enable = MXL_RSSI_ENABLE,
1092 .cap_select = MXL_CAP_SEL_ENABLE,
1093 .div_out = MXL_DIV_OUT_4,
1094 .clock_out = MXL_CLOCK_OUT_DISABLE,
1095 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
1096 .top = MXL5005S_TOP_25P2,
1097 .mod_mode = MXL_DIGITAL_MODE,
1098 .if_mode = MXL_ZERO_IF,
1099 .AgcMasterByte = 0x00,
1102 static struct mxl5005s_config af9015_mxl5005_config = {
1103 .i2c_address = 0xc6,
1104 .if_freq = IF_FREQ_4570000HZ,
1105 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
1106 .agc_mode = MXL_SINGLE_AGC,
1107 .tracking_filter = MXL_TF_OFF,
1108 .rssi_enable = MXL_RSSI_ENABLE,
1109 .cap_select = MXL_CAP_SEL_ENABLE,
1110 .div_out = MXL_DIV_OUT_4,
1111 .clock_out = MXL_CLOCK_OUT_DISABLE,
1112 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
1113 .top = MXL5005S_TOP_25P2,
1114 .mod_mode = MXL_DIGITAL_MODE,
1115 .if_mode = MXL_ZERO_IF,
1116 .AgcMasterByte = 0x00,
1119 static int af9015_tuner_attach(struct dvb_usb_adapter *adap)
1121 struct af9015_state *state = adap->dev->priv;
1122 struct i2c_adapter *i2c_adap;
1124 deb_info("%s: \n", __func__);
1126 /* select I2C adapter */
1128 i2c_adap = &adap->dev->i2c_adap;
1130 i2c_adap = &state->i2c_adap;
1132 switch (af9015_af9013_config[adap->id].tuner) {
1133 case AF9013_TUNER_MT2060:
1134 case AF9013_TUNER_MT2060_2:
1135 ret = dvb_attach(mt2060_attach, adap->fe, i2c_adap,
1136 &af9015_mt2060_config,
1137 af9015_config.mt2060_if1[adap->id])
1138 == NULL ? -ENODEV : 0;
1140 case AF9013_TUNER_QT1010:
1141 case AF9013_TUNER_QT1010A:
1142 ret = dvb_attach(qt1010_attach, adap->fe, i2c_adap,
1143 &af9015_qt1010_config) == NULL ? -ENODEV : 0;
1145 case AF9013_TUNER_TDA18271:
1146 ret = dvb_attach(tda18271_attach, adap->fe, 0xc0, i2c_adap,
1147 &af9015_tda18271_config) == NULL ? -ENODEV : 0;
1149 case AF9013_TUNER_MXL5003D:
1150 ret = dvb_attach(mxl5005s_attach, adap->fe, i2c_adap,
1151 &af9015_mxl5003_config) == NULL ? -ENODEV : 0;
1153 case AF9013_TUNER_MXL5005D:
1154 case AF9013_TUNER_MXL5005R:
1155 ret = dvb_attach(mxl5005s_attach, adap->fe, i2c_adap,
1156 &af9015_mxl5005_config) == NULL ? -ENODEV : 0;
1158 case AF9013_TUNER_ENV77H11D5:
1159 ret = dvb_attach(dvb_pll_attach, adap->fe, 0xc0, i2c_adap,
1160 DVB_PLL_TDA665X) == NULL ? -ENODEV : 0;
1162 case AF9013_TUNER_MC44S803:
1164 ret = dvb_attach(mc44s80x_attach, adap->fe, i2c_adap)
1165 == NULL ? -ENODEV : 0;
1168 info("Freescale MC44S803 tuner found but no driver for that" \
1169 "tuner. Look at the Linuxtv.org for tuner driver" \
1173 case AF9013_TUNER_UNKNOWN:
1176 err("Unknown tuner id:%d",
1177 af9015_af9013_config[adap->id].tuner);
1182 static struct usb_device_id af9015_usb_table[] = {
1183 /* 0 */{USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9015_9015)},
1184 {USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9015_9016)},
1185 {USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_GOLD)},
1186 {USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV71E)},
1187 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_399U)},
1188 /* 5 */{USB_DEVICE(USB_VID_VISIONPLUS,
1190 {USB_DEVICE(USB_VID_VISIONPLUS,
1191 USB_PID_AZUREWAVE_AD_TU700)},
1192 {USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_USB_XE_REV2)},
1193 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_PC160_2T)},
1194 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X)},
1195 /* 10 */{USB_DEVICE(USB_VID_XTENSIONS, USB_PID_XTENSIONS_XD_380)},
1196 {USB_DEVICE(USB_VID_MSI_2, USB_PID_MSI_DIGIVOX_DUO)},
1197 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X_2)},
1198 {USB_DEVICE(USB_VID_TELESTAR, USB_PID_TELESTAR_STARSTICK_2)},
1199 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A309)},
1202 MODULE_DEVICE_TABLE(usb, af9015_usb_table);
1204 static struct dvb_usb_device_properties af9015_properties[] = {
1206 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1208 .usb_ctrl = DEVICE_SPECIFIC,
1209 .download_firmware = af9015_download_firmware,
1210 .firmware = "dvb-usb-af9015.fw",
1212 .size_of_priv = sizeof(struct af9015_state), \
1217 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1218 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1220 .pid_filter_count = 32,
1221 .pid_filter = af9015_pid_filter,
1222 .pid_filter_ctrl = af9015_pid_filter_ctrl,
1225 af9015_af9013_frontend_attach,
1226 .tuner_attach = af9015_tuner_attach,
1235 af9015_af9013_frontend_attach,
1236 .tuner_attach = af9015_tuner_attach,
1245 .identify_state = af9015_identify_state,
1247 .rc_query = af9015_rc_query,
1250 .i2c_algo = &af9015_i2c_algo,
1252 .num_device_descs = 9,
1255 .name = "Afatech AF9015 DVB-T USB2.0 stick",
1256 .cold_ids = {&af9015_usb_table[0],
1257 &af9015_usb_table[1], NULL},
1261 .name = "Leadtek WinFast DTV Dongle Gold",
1262 .cold_ids = {&af9015_usb_table[2], NULL},
1266 .name = "Pinnacle PCTV 71e",
1267 .cold_ids = {&af9015_usb_table[3], NULL},
1271 .name = "KWorld PlusTV Dual DVB-T Stick " \
1273 .cold_ids = {&af9015_usb_table[4], NULL},
1277 .name = "DigitalNow TinyTwin DVB-T Receiver",
1278 .cold_ids = {&af9015_usb_table[5], NULL},
1282 .name = "TwinHan AzureWave AD-TU700(704J)",
1283 .cold_ids = {&af9015_usb_table[6], NULL},
1287 .name = "TerraTec Cinergy T USB XE",
1288 .cold_ids = {&af9015_usb_table[7], NULL},
1292 .name = "KWorld PlusTV Dual DVB-T PCI " \
1294 .cold_ids = {&af9015_usb_table[8], NULL},
1298 .name = "AVerMedia AVerTV DVB-T Volar X",
1299 .cold_ids = {&af9015_usb_table[9], NULL},
1304 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1306 .usb_ctrl = DEVICE_SPECIFIC,
1307 .download_firmware = af9015_download_firmware,
1308 .firmware = "dvb-usb-af9015.fw",
1310 .size_of_priv = sizeof(struct af9015_state), \
1315 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1316 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1318 .pid_filter_count = 32,
1319 .pid_filter = af9015_pid_filter,
1320 .pid_filter_ctrl = af9015_pid_filter_ctrl,
1323 af9015_af9013_frontend_attach,
1324 .tuner_attach = af9015_tuner_attach,
1333 af9015_af9013_frontend_attach,
1334 .tuner_attach = af9015_tuner_attach,
1343 .identify_state = af9015_identify_state,
1345 .rc_query = af9015_rc_query,
1348 .i2c_algo = &af9015_i2c_algo,
1350 .num_device_descs = 5,
1353 .name = "Xtensions XD-380",
1354 .cold_ids = {&af9015_usb_table[10], NULL},
1358 .name = "MSI DIGIVOX Duo",
1359 .cold_ids = {&af9015_usb_table[11], NULL},
1363 .name = "Fujitsu-Siemens Slim Mobile USB DVB-T",
1364 .cold_ids = {&af9015_usb_table[12], NULL},
1368 .name = "Telestar Starstick 2",
1369 .cold_ids = {&af9015_usb_table[13], NULL},
1373 .name = "AVerMedia A309",
1374 .cold_ids = {&af9015_usb_table[14], NULL},
1380 #undef AF9015_DEFAULT_PROPERTIES
1382 static int af9015_usb_probe(struct usb_interface *intf,
1383 const struct usb_device_id *id)
1386 struct dvb_usb_device *d = NULL;
1387 struct usb_device *udev = interface_to_usbdev(intf);
1390 deb_info("%s: interface:%d\n", __func__,
1391 intf->cur_altsetting->desc.bInterfaceNumber);
1393 /* interface 0 is used by DVB-T receiver and
1394 interface 1 is for remote controller (HID) */
1395 if (intf->cur_altsetting->desc.bInterfaceNumber == 0) {
1396 ret = af9015_read_config(udev);
1400 for (i = 0; i < af9015_properties_count; i++) {
1401 ret = dvb_usb_device_init(intf, &af9015_properties[i],
1402 THIS_MODULE, &d, adapter_nr);
1412 ret = af9015_init(d);
1418 void af9015_i2c_exit(struct dvb_usb_device *d)
1420 struct af9015_state *state = d->priv;
1421 deb_info("%s: \n", __func__);
1423 /* remove 2nd I2C adapter */
1424 if (d->state & DVB_USB_STATE_I2C)
1425 i2c_del_adapter(&state->i2c_adap);
1428 static void af9015_usb_device_exit(struct usb_interface *intf)
1430 struct dvb_usb_device *d = usb_get_intfdata(intf);
1431 deb_info("%s: \n", __func__);
1433 /* remove 2nd I2C adapter */
1434 if (d != NULL && d->desc != NULL)
1437 dvb_usb_device_exit(intf);
1440 /* usb specific object needed to register this driver with the usb subsystem */
1441 static struct usb_driver af9015_usb_driver = {
1442 .name = "dvb_usb_af9015",
1443 .probe = af9015_usb_probe,
1444 .disconnect = af9015_usb_device_exit,
1445 .id_table = af9015_usb_table,
1449 static int __init af9015_usb_module_init(void)
1452 ret = usb_register(&af9015_usb_driver);
1454 err("module init failed:%d", ret);
1459 static void __exit af9015_usb_module_exit(void)
1461 /* deregister this driver from the USB subsystem */
1462 usb_deregister(&af9015_usb_driver);
1465 module_init(af9015_usb_module_init);
1466 module_exit(af9015_usb_module_exit);
1468 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1469 MODULE_DESCRIPTION("Driver for Afatech AF9015 DVB-T");
1470 MODULE_LICENSE("GPL");