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[1] = AF9013_GPIO_LO,
58 .gpio[3] = AF9013_GPIO_TUNER_ON,
61 .output_mode = AF9013_OUTPUT_MODE_SERIAL,
62 .api_version = { 0, 1, 9, 0 },
63 .gpio[0] = AF9013_GPIO_TUNER_ON,
64 .gpio[1] = AF9013_GPIO_LO,
68 static int af9015_rw_udev(struct usb_device *udev, struct req_t *req)
74 static u8 seq; /* packet sequence number */
76 if (mutex_lock_interruptible(&af9015_usb_mutex) < 0)
81 buf[2] = req->i2c_addr;
82 buf[3] = req->addr >> 8;
83 buf[4] = req->addr & 0xff;
85 buf[6] = req->addr_len;
86 buf[7] = req->data_len;
98 buf[2] |= 0x01; /* set I2C direction */
100 buf[0] = READ_WRITE_I2C;
103 if (((req->addr & 0xff00) == 0xff00) ||
104 ((req->addr & 0xae00) == 0xae00))
105 buf[0] = WRITE_VIRTUAL_MEMORY;
106 case WRITE_VIRTUAL_MEMORY:
108 case DOWNLOAD_FIRMWARE:
111 err("unknown command:%d", req->cmd);
116 /* write requested */
118 memcpy(&buf[8], req->data, req->data_len);
119 msg_len += req->data_len;
122 debug_dump(buf, msg_len, deb_xfer);
125 ret = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 0x02), buf, msg_len,
126 &act_len, AF9015_USB_TIMEOUT);
128 err("bulk message failed:%d (%d/%d)", ret, msg_len, act_len);
130 if (act_len != msg_len)
131 ret = -1; /* all data is not send */
135 /* no ack for those packets */
136 if (req->cmd == DOWNLOAD_FIRMWARE || req->cmd == RECONNECT_USB)
139 /* receive ack and data if read req */
140 msg_len = 1 + 1 + req->data_len; /* seq + status + data len */
141 ret = usb_bulk_msg(udev, usb_rcvbulkpipe(udev, 0x81), buf, msg_len,
142 &act_len, AF9015_USB_TIMEOUT);
144 err("recv bulk message failed:%d", ret);
150 debug_dump(buf, act_len, deb_xfer);
152 /* remote controller query status is 1 if remote code is not received */
153 if (req->cmd == GET_IR_CODE && buf[1] == 1) {
154 buf[1] = 0; /* clear command "error" status */
155 memset(&buf[2], 0, req->data_len);
156 buf[3] = 1; /* no remote code received mark */
161 err("command failed:%d", buf[1]);
166 /* read request, copy returned data to return buf */
168 memcpy(req->data, &buf[2], req->data_len);
172 mutex_unlock(&af9015_usb_mutex);
177 static int af9015_ctrl_msg(struct dvb_usb_device *d, struct req_t *req)
179 return af9015_rw_udev(d->udev, req);
182 static int af9015_write_regs(struct dvb_usb_device *d, u16 addr, u8 *val,
185 struct req_t req = {WRITE_MEMORY, AF9015_I2C_DEMOD, addr, 0, 0, len,
187 return af9015_ctrl_msg(d, &req);
190 static int af9015_write_reg(struct dvb_usb_device *d, u16 addr, u8 val)
192 return af9015_write_regs(d, addr, &val, 1);
195 static int af9015_read_reg(struct dvb_usb_device *d, u16 addr, u8 *val)
197 struct req_t req = {READ_MEMORY, AF9015_I2C_DEMOD, addr, 0, 0, 1, val};
198 return af9015_ctrl_msg(d, &req);
201 static int af9015_write_reg_i2c(struct dvb_usb_device *d, u8 addr, u16 reg,
204 struct req_t req = {WRITE_I2C, addr, reg, 1, 1, 1, &val};
206 if (addr == af9015_af9013_config[0].demod_address ||
207 addr == af9015_af9013_config[1].demod_address)
210 return af9015_ctrl_msg(d, &req);
213 static int af9015_read_reg_i2c(struct dvb_usb_device *d, u8 addr, u16 reg,
216 struct req_t req = {READ_I2C, addr, reg, 0, 1, 1, val};
218 if (addr == af9015_af9013_config[0].demod_address ||
219 addr == af9015_af9013_config[1].demod_address)
222 return af9015_ctrl_msg(d, &req);
225 static int af9015_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
228 struct dvb_usb_device *d = i2c_get_adapdata(adap);
234 /* TODO: implement bus lock
236 The bus lock is needed because there is two tuners both using same I2C-address.
237 Due to that the only way to select correct tuner is use demodulator I2C-gate.
239 ................................................
240 . AF9015 includes integrated AF9013 demodulator.
241 . ____________ ____________ . ____________
242 .| uC | | demod | . | tuner |
243 .|------------| |------------| . |------------|
244 .| AF9015 | | AF9013/5 | . | MXL5003 |
245 .| |--+----I2C-------|-----/ -----|-.-----I2C-------| |
246 .| | | | addr 0x38 | . | addr 0xc6 |
247 .|____________| | |____________| . |____________|
248 .................|..............................
249 | ____________ ____________
250 | | demod | | tuner |
251 | |------------| |------------|
252 | | AF9013 | | MXL5003 |
253 +----I2C-------|-----/ -----|-------I2C-------| |
254 | addr 0x3a | | addr 0xc6 |
255 |____________| |____________|
257 if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
261 if (msg[i].addr == af9015_af9013_config[0].demod_address ||
262 msg[i].addr == af9015_af9013_config[1].demod_address) {
263 addr = msg[i].buf[0] << 8;
264 addr += msg[i].buf[1];
265 mbox = msg[i].buf[2];
268 addr = msg[i].buf[0];
273 if (num > i + 1 && (msg[i+1].flags & I2C_M_RD)) {
275 af9015_af9013_config[0].demod_address)
276 req.cmd = READ_MEMORY;
279 req.i2c_addr = msg[i].addr;
282 req.addr_len = addr_len;
283 req.data_len = msg[i+1].len;
284 req.data = &msg[i+1].buf[0];
285 ret = af9015_ctrl_msg(d, &req);
289 af9015_af9013_config[0].demod_address)
290 req.cmd = WRITE_MEMORY;
293 req.i2c_addr = msg[i].addr;
296 req.addr_len = addr_len;
297 req.data_len = msg[i].len-addr_len;
298 req.data = &msg[i].buf[addr_len];
299 ret = af9015_ctrl_msg(d, &req);
309 mutex_unlock(&d->i2c_mutex);
314 static u32 af9015_i2c_func(struct i2c_adapter *adapter)
319 static struct i2c_algorithm af9015_i2c_algo = {
320 .master_xfer = af9015_i2c_xfer,
321 .functionality = af9015_i2c_func,
324 static int af9015_do_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit, u8 op)
329 ret = af9015_read_reg(d, addr, &val);
343 return af9015_write_reg(d, addr, val);
346 static int af9015_set_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit)
348 return af9015_do_reg_bit(d, addr, bit, 1);
351 static int af9015_clear_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit)
353 return af9015_do_reg_bit(d, addr, bit, 0);
356 static int af9015_init_endpoint(struct dvb_usb_device *d)
361 deb_info("%s: USB speed:%d\n", __func__, d->udev->speed);
363 #define TS_PACKET_SIZE 188
365 #define TS_USB20_PACKET_COUNT 348
366 #define TS_USB20_FRAME_SIZE (TS_PACKET_SIZE*TS_USB20_PACKET_COUNT)
368 #define TS_USB11_PACKET_COUNT 21
369 #define TS_USB11_FRAME_SIZE (TS_PACKET_SIZE*TS_USB11_PACKET_COUNT)
371 #define TS_USB20_MAX_PACKET_SIZE 512
372 #define TS_USB11_MAX_PACKET_SIZE 64
374 if (d->udev->speed == USB_SPEED_FULL) {
375 frame_size = TS_USB11_FRAME_SIZE/4;
376 packet_size = TS_USB11_MAX_PACKET_SIZE/4;
378 frame_size = TS_USB20_FRAME_SIZE/4;
379 packet_size = TS_USB20_MAX_PACKET_SIZE/4;
382 ret = af9015_set_reg_bit(d, 0xd507, 2); /* assert EP4 reset */
385 ret = af9015_set_reg_bit(d, 0xd50b, 1); /* assert EP5 reset */
388 ret = af9015_clear_reg_bit(d, 0xdd11, 5); /* disable EP4 */
391 ret = af9015_clear_reg_bit(d, 0xdd11, 6); /* disable EP5 */
394 ret = af9015_set_reg_bit(d, 0xdd11, 5); /* enable EP4 */
397 if (af9015_config.dual_mode) {
398 ret = af9015_set_reg_bit(d, 0xdd11, 6); /* enable EP5 */
402 ret = af9015_clear_reg_bit(d, 0xdd13, 5); /* disable EP4 NAK */
405 if (af9015_config.dual_mode) {
406 ret = af9015_clear_reg_bit(d, 0xdd13, 6); /* disable EP5 NAK */
410 /* EP4 xfer length */
411 ret = af9015_write_reg(d, 0xdd88, frame_size & 0xff);
414 ret = af9015_write_reg(d, 0xdd89, frame_size >> 8);
417 /* EP5 xfer length */
418 ret = af9015_write_reg(d, 0xdd8a, frame_size & 0xff);
421 ret = af9015_write_reg(d, 0xdd8b, frame_size >> 8);
424 ret = af9015_write_reg(d, 0xdd0c, packet_size); /* EP4 packet size */
427 ret = af9015_write_reg(d, 0xdd0d, packet_size); /* EP5 packet size */
430 ret = af9015_clear_reg_bit(d, 0xd507, 2); /* negate EP4 reset */
433 if (af9015_config.dual_mode) {
434 ret = af9015_clear_reg_bit(d, 0xd50b, 1); /* negate EP5 reset */
439 /* enable / disable mp2if2 */
440 if (af9015_config.dual_mode)
441 ret = af9015_set_reg_bit(d, 0xd50b, 0);
443 ret = af9015_clear_reg_bit(d, 0xd50b, 0);
446 err("endpoint init failed:%d", ret);
450 static int af9015_copy_firmware(struct dvb_usb_device *d)
455 struct req_t req = {COPY_FIRMWARE, 0, 0x5100, 0, 0, sizeof(fw_params),
457 deb_info("%s:\n", __func__);
459 fw_params[0] = af9015_config.firmware_size >> 8;
460 fw_params[1] = af9015_config.firmware_size & 0xff;
461 fw_params[2] = af9015_config.firmware_checksum >> 8;
462 fw_params[3] = af9015_config.firmware_checksum & 0xff;
464 /* wait 2nd demodulator ready */
467 ret = af9015_read_reg_i2c(d, 0x3a, 0x98be, &val);
471 deb_info("%s: firmware status:%02x\n", __func__, val);
473 if (val == 0x0c) /* fw is running, no need for download */
476 /* set I2C master clock to fast (to speed up firmware copy) */
477 ret = af9015_write_reg(d, 0xd416, 0x04); /* 0x04 * 400ns */
484 ret = af9015_ctrl_msg(d, &req);
486 err("firmware copy cmd failed:%d", ret);
487 deb_info("%s: firmware copy done\n", __func__);
489 /* set I2C master clock back to normal */
490 ret = af9015_write_reg(d, 0xd416, 0x14); /* 0x14 * 400ns */
494 /* request boot firmware */
495 ret = af9015_write_reg_i2c(d, af9015_af9013_config[1].demod_address,
497 deb_info("%s: firmware boot cmd status:%d\n", __func__, ret);
501 for (i = 0; i < 15; i++) {
504 /* check firmware status */
505 ret = af9015_read_reg_i2c(d,
506 af9015_af9013_config[1].demod_address, 0x98be, &val);
507 deb_info("%s: firmware status cmd status:%d fw status:%02x\n",
512 if (val == 0x0c || val == 0x04) /* success or fail */
517 err("firmware did not run");
519 } else if (val != 0x0c) {
520 err("firmware boot timeout");
530 static int af9015_eeprom_dump(struct dvb_usb_device *d)
532 char buf[52], buf2[4];
535 for (reg = 0; ; reg++) {
538 deb_info("%s\n", buf);
539 sprintf(buf, "%02x: ", reg);
541 if (af9015_read_reg_i2c(d, AF9015_I2C_EEPROM, reg, &val) == 0)
542 sprintf(buf2, "%02x ", val);
549 deb_info("%s\n", buf);
553 int af9015_download_ir_table(struct dvb_usb_device *d)
555 int i, packets = 0, ret;
556 u16 addr = 0x9a56; /* ir-table start address */
557 struct req_t req = {WRITE_MEMORY, 0, 0, 0, 0, 1, NULL};
559 deb_info("%s:\n", __func__);
561 data = af9015_config.ir_table;
562 packets = af9015_config.ir_table_size;
568 /* load remote ir-table */
569 for (i = 0; i < packets; i++) {
572 ret = af9015_ctrl_msg(d, &req);
574 err("ir-table download failed at packet %d with " \
584 static int af9015_init(struct dvb_usb_device *d)
587 deb_info("%s:\n", __func__);
589 ret = af9015_init_endpoint(d);
593 ret = af9015_download_ir_table(d);
601 static int af9015_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff)
604 deb_info("%s: onoff:%d\n", __func__, onoff);
607 ret = af9015_set_reg_bit(adap->dev, 0xd503, 0);
609 ret = af9015_clear_reg_bit(adap->dev, 0xd503, 0);
614 static int af9015_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid,
620 deb_info("%s: set pid filter, index %d, pid %x, onoff %d\n",
621 __func__, index, pid, onoff);
623 ret = af9015_write_reg(adap->dev, 0xd505, (pid & 0xff));
627 ret = af9015_write_reg(adap->dev, 0xd506, (pid >> 8));
631 idx = ((index & 0x1f) | (1 << 5));
632 ret = af9015_write_reg(adap->dev, 0xd504, idx);
638 static int af9015_download_firmware(struct usb_device *udev,
639 const struct firmware *fw)
641 int i, len, packets, remainder, ret;
642 struct req_t req = {DOWNLOAD_FIRMWARE, 0, 0, 0, 0, 0, NULL};
643 u16 addr = 0x5100; /* firmware start address */
646 deb_info("%s:\n", __func__);
649 for (i = 0; i < fw->size; i++)
650 checksum += fw->data[i];
652 af9015_config.firmware_size = fw->size;
653 af9015_config.firmware_checksum = checksum;
655 #define FW_PACKET_MAX_DATA 55
657 packets = fw->size / FW_PACKET_MAX_DATA;
658 remainder = fw->size % FW_PACKET_MAX_DATA;
659 len = FW_PACKET_MAX_DATA;
660 for (i = 0; i <= packets; i++) {
661 if (i == packets) /* set size of the last packet */
665 req.data = (fw->data + i * FW_PACKET_MAX_DATA);
667 addr += FW_PACKET_MAX_DATA;
669 ret = af9015_rw_udev(udev, &req);
671 err("firmware download failed at packet %d with " \
676 #undef FW_PACKET_MAX_DATA
678 /* firmware loaded, request boot */
680 ret = af9015_rw_udev(udev, &req);
682 err("firmware boot failed:%d", ret);
686 /* firmware is running, reconnect device in the usb bus */
687 req.cmd = RECONNECT_USB;
688 ret = af9015_rw_udev(udev, &req);
690 err("reconnect failed: %d", ret);
696 static int af9015_read_config(struct usb_device *udev)
699 u8 val, i, offset = 0;
700 struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, &val};
701 char manufacturer[10];
703 /* IR remote controller */
704 req.addr = AF9015_EEPROM_IR_MODE;
705 ret = af9015_rw_udev(udev, &req);
708 deb_info("%s: IR mode:%d\n", __func__, val);
709 for (i = 0; i < af9015_properties_count; i++) {
710 if (val == AF9015_IR_MODE_DISABLED || val == 0x04) {
711 af9015_properties[i].rc_key_map = NULL;
712 af9015_properties[i].rc_key_map_size = 0;
713 } else if (dvb_usb_af9015_remote) {
714 /* load remote defined as module param */
715 switch (dvb_usb_af9015_remote) {
716 case AF9015_REMOTE_A_LINK_DTU_M:
717 af9015_properties[i].rc_key_map =
718 af9015_rc_keys_a_link;
719 af9015_properties[i].rc_key_map_size =
720 ARRAY_SIZE(af9015_rc_keys_a_link);
721 af9015_config.ir_table = af9015_ir_table_a_link;
722 af9015_config.ir_table_size =
723 ARRAY_SIZE(af9015_ir_table_a_link);
725 case AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3:
726 af9015_properties[i].rc_key_map =
728 af9015_properties[i].rc_key_map_size =
729 ARRAY_SIZE(af9015_rc_keys_msi);
730 af9015_config.ir_table = af9015_ir_table_msi;
731 af9015_config.ir_table_size =
732 ARRAY_SIZE(af9015_ir_table_msi);
734 case AF9015_REMOTE_MYGICTV_U718:
735 af9015_properties[i].rc_key_map =
736 af9015_rc_keys_mygictv;
737 af9015_properties[i].rc_key_map_size =
738 ARRAY_SIZE(af9015_rc_keys_mygictv);
739 af9015_config.ir_table =
740 af9015_ir_table_mygictv;
741 af9015_config.ir_table_size =
742 ARRAY_SIZE(af9015_ir_table_mygictv);
746 switch (udev->descriptor.idVendor) {
747 case cpu_to_le16(USB_VID_LEADTEK):
748 af9015_properties[i].rc_key_map =
749 af9015_rc_keys_leadtek;
750 af9015_properties[i].rc_key_map_size =
751 ARRAY_SIZE(af9015_rc_keys_leadtek);
752 af9015_config.ir_table =
753 af9015_ir_table_leadtek;
754 af9015_config.ir_table_size =
755 ARRAY_SIZE(af9015_ir_table_leadtek);
757 case cpu_to_le16(USB_VID_VISIONPLUS):
758 if (udev->descriptor.idProduct ==
759 cpu_to_le16(USB_PID_AZUREWAVE_AD_TU700)) {
760 af9015_properties[i].rc_key_map =
761 af9015_rc_keys_twinhan;
762 af9015_properties[i].rc_key_map_size =
763 ARRAY_SIZE(af9015_rc_keys_twinhan);
764 af9015_config.ir_table =
765 af9015_ir_table_twinhan;
766 af9015_config.ir_table_size =
767 ARRAY_SIZE(af9015_ir_table_twinhan);
770 case cpu_to_le16(USB_VID_KWORLD_2):
771 /* TODO: use correct rc keys */
772 af9015_properties[i].rc_key_map =
773 af9015_rc_keys_twinhan;
774 af9015_properties[i].rc_key_map_size =
775 ARRAY_SIZE(af9015_rc_keys_twinhan);
776 af9015_config.ir_table = af9015_ir_table_kworld;
777 af9015_config.ir_table_size =
778 ARRAY_SIZE(af9015_ir_table_kworld);
780 /* Check USB manufacturer and product strings and try
781 to determine correct remote in case of chip vendor
782 reference IDs are used. */
783 case cpu_to_le16(USB_VID_AFATECH):
784 memset(manufacturer, 0, sizeof(manufacturer));
785 usb_string(udev, udev->descriptor.iManufacturer,
786 manufacturer, sizeof(manufacturer));
787 if (!strcmp("Geniatech", manufacturer)) {
788 /* iManufacturer 1 Geniatech
790 af9015_properties[i].rc_key_map =
791 af9015_rc_keys_mygictv;
792 af9015_properties[i].rc_key_map_size =
793 ARRAY_SIZE(af9015_rc_keys_mygictv);
794 af9015_config.ir_table =
795 af9015_ir_table_mygictv;
796 af9015_config.ir_table_size =
797 ARRAY_SIZE(af9015_ir_table_mygictv);
798 } else if (!strcmp("MSI", manufacturer)) {
799 /* iManufacturer 1 MSI
800 iProduct 2 MSI K-VOX */
801 af9015_properties[i].rc_key_map =
803 af9015_properties[i].rc_key_map_size =
804 ARRAY_SIZE(af9015_rc_keys_msi);
805 af9015_config.ir_table =
807 af9015_config.ir_table_size =
808 ARRAY_SIZE(af9015_ir_table_msi);
815 /* TS mode - one or two receivers */
816 req.addr = AF9015_EEPROM_TS_MODE;
817 ret = af9015_rw_udev(udev, &req);
820 af9015_config.dual_mode = val;
821 deb_info("%s: TS mode:%d\n", __func__, af9015_config.dual_mode);
822 /* disable dual mode by default because it is buggy */
823 if (!dvb_usb_af9015_dual_mode)
824 af9015_config.dual_mode = 0;
826 /* set buffer size according to USB port speed */
827 for (i = 0; i < af9015_properties_count; i++) {
828 /* USB1.1 set smaller buffersize and disable 2nd adapter */
829 if (udev->speed == USB_SPEED_FULL) {
830 af9015_properties[i].adapter->stream.u.bulk.buffersize =
831 TS_USB11_MAX_PACKET_SIZE;
832 /* disable 2nd adapter because we don't have
834 af9015_config.dual_mode = 0;
836 af9015_properties[i].adapter->stream.u.bulk.buffersize =
837 TS_USB20_MAX_PACKET_SIZE;
841 if (af9015_config.dual_mode) {
842 /* read 2nd demodulator I2C address */
843 req.addr = AF9015_EEPROM_DEMOD2_I2C;
844 ret = af9015_rw_udev(udev, &req);
847 af9015_af9013_config[1].demod_address = val;
849 /* enable 2nd adapter */
850 for (i = 0; i < af9015_properties_count; i++)
851 af9015_properties[i].num_adapters = 2;
854 /* disable 2nd adapter */
855 for (i = 0; i < af9015_properties_count; i++)
856 af9015_properties[i].num_adapters = 1;
859 for (i = 0; i < af9015_properties[0].num_adapters; i++) {
861 offset = AF9015_EEPROM_OFFSET;
863 req.addr = AF9015_EEPROM_XTAL_TYPE1 + offset;
864 ret = af9015_rw_udev(udev, &req);
869 af9015_af9013_config[i].adc_clock = 28800;
872 af9015_af9013_config[i].adc_clock = 20480;
875 af9015_af9013_config[i].adc_clock = 28000;
878 af9015_af9013_config[i].adc_clock = 25000;
881 deb_info("%s: [%d] xtal:%d set adc_clock:%d\n", __func__, i,
882 val, af9015_af9013_config[i].adc_clock);
885 req.addr = AF9015_EEPROM_IF1H + offset;
886 ret = af9015_rw_udev(udev, &req);
889 af9015_af9013_config[i].tuner_if = val << 8;
890 req.addr = AF9015_EEPROM_IF1L + offset;
891 ret = af9015_rw_udev(udev, &req);
894 af9015_af9013_config[i].tuner_if += val;
895 deb_info("%s: [%d] IF1:%d\n", __func__, i,
896 af9015_af9013_config[0].tuner_if);
899 req.addr = AF9015_EEPROM_MT2060_IF1H + offset;
900 ret = af9015_rw_udev(udev, &req);
903 af9015_config.mt2060_if1[i] = val << 8;
904 req.addr = AF9015_EEPROM_MT2060_IF1L + offset;
905 ret = af9015_rw_udev(udev, &req);
908 af9015_config.mt2060_if1[i] += val;
909 deb_info("%s: [%d] MT2060 IF1:%d\n", __func__, i,
910 af9015_config.mt2060_if1[i]);
913 req.addr = AF9015_EEPROM_TUNER_ID1 + offset;
914 ret = af9015_rw_udev(udev, &req);
918 case AF9013_TUNER_ENV77H11D5:
919 case AF9013_TUNER_MT2060:
920 case AF9013_TUNER_MC44S803:
921 case AF9013_TUNER_QT1010:
922 case AF9013_TUNER_UNKNOWN:
923 case AF9013_TUNER_MT2060_2:
924 case AF9013_TUNER_TDA18271:
925 case AF9013_TUNER_QT1010A:
926 af9015_af9013_config[i].rf_spec_inv = 1;
928 case AF9013_TUNER_MXL5003D:
929 case AF9013_TUNER_MXL5005D:
930 case AF9013_TUNER_MXL5005R:
931 af9015_af9013_config[i].rf_spec_inv = 0;
934 warn("tuner id:%d not supported, please report!", val);
938 af9015_af9013_config[i].tuner = val;
939 deb_info("%s: [%d] tuner id:%d\n", __func__, i, val);
944 err("eeprom read failed:%d", ret);
949 static int af9015_identify_state(struct usb_device *udev,
950 struct dvb_usb_device_properties *props,
951 struct dvb_usb_device_description **desc,
956 struct req_t req = {GET_CONFIG, 0, 0, 0, 0, 1, &reply};
958 ret = af9015_rw_udev(udev, &req);
962 deb_info("%s: reply:%02x\n", __func__, reply);
971 static int af9015_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
974 struct req_t req = {GET_IR_CODE, 0, 0, 0, 0, sizeof(buf), buf};
975 struct dvb_usb_rc_key *keymap = d->props.rc_key_map;
978 memset(buf, 0, sizeof(buf));
980 ret = af9015_ctrl_msg(d, &req);
985 *state = REMOTE_NO_KEY_PRESSED;
987 for (i = 0; i < d->props.rc_key_map_size; i++) {
988 if (!buf[1] && keymap[i].custom == buf[0] &&
989 keymap[i].data == buf[2]) {
990 *event = keymap[i].event;
991 *state = REMOTE_KEY_PRESSED;
996 deb_rc("%s: %02x %02x %02x %02x %02x %02x %02x %02x\n",
997 __func__, buf[0], buf[1], buf[2], buf[3], buf[4],
998 buf[5], buf[6], buf[7]);
1003 /* init 2nd I2C adapter */
1004 int af9015_i2c_init(struct dvb_usb_device *d)
1007 struct af9015_state *state = d->priv;
1008 deb_info("%s:\n", __func__);
1010 strncpy(state->i2c_adap.name, d->desc->name,
1011 sizeof(state->i2c_adap.name));
1012 #ifdef I2C_ADAP_CLASS_TV_DIGITAL
1013 state->i2c_adap.class = I2C_ADAP_CLASS_TV_DIGITAL,
1015 state->i2c_adap.class = I2C_CLASS_TV_DIGITAL,
1017 state->i2c_adap.algo = d->props.i2c_algo;
1018 state->i2c_adap.algo_data = NULL;
1019 state->i2c_adap.dev.parent = &d->udev->dev;
1021 i2c_set_adapdata(&state->i2c_adap, d);
1023 ret = i2c_add_adapter(&state->i2c_adap);
1025 err("could not add i2c adapter");
1030 static int af9015_af9013_frontend_attach(struct dvb_usb_adapter *adap)
1033 struct af9015_state *state = adap->dev->priv;
1034 struct i2c_adapter *i2c_adap;
1036 if (adap->id == 0) {
1037 /* select I2C adapter */
1038 i2c_adap = &adap->dev->i2c_adap;
1040 deb_info("%s: init I2C\n", __func__);
1041 ret = af9015_i2c_init(adap->dev);
1043 /* dump eeprom (debug) */
1044 ret = af9015_eeprom_dump(adap->dev);
1048 /* select I2C adapter */
1049 i2c_adap = &state->i2c_adap;
1051 /* copy firmware to 2nd demodulator */
1052 if (af9015_config.dual_mode) {
1053 ret = af9015_copy_firmware(adap->dev);
1055 err("firmware copy to 2nd frontend " \
1056 "failed, will disable it");
1057 af9015_config.dual_mode = 0;
1065 /* attach demodulator */
1066 adap->fe = dvb_attach(af9013_attach, &af9015_af9013_config[adap->id],
1069 return adap->fe == NULL ? -ENODEV : 0;
1072 static struct mt2060_config af9015_mt2060_config = {
1073 .i2c_address = 0xc0,
1077 static struct qt1010_config af9015_qt1010_config = {
1078 .i2c_address = 0xc4,
1081 static struct tda18271_config af9015_tda18271_config = {
1082 .gate = TDA18271_GATE_DIGITAL,
1086 static struct mxl5005s_config af9015_mxl5003_config = {
1087 .i2c_address = 0xc6,
1088 .if_freq = IF_FREQ_4570000HZ,
1089 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
1090 .agc_mode = MXL_SINGLE_AGC,
1091 .tracking_filter = MXL_TF_DEFAULT,
1092 .rssi_enable = MXL_RSSI_DISABLE,
1093 .cap_select = MXL_CAP_SEL_ENABLE,
1094 .div_out = MXL_DIV_OUT_4,
1095 .clock_out = MXL_CLOCK_OUT_DISABLE,
1096 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
1097 .top = MXL5005S_TOP_25P2,
1098 .mod_mode = MXL_DIGITAL_MODE,
1099 .if_mode = MXL_ZERO_IF,
1100 .AgcMasterByte = 0x00,
1103 static struct mxl5005s_config af9015_mxl5005_config = {
1104 .i2c_address = 0xc6,
1105 .if_freq = IF_FREQ_4570000HZ,
1106 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
1107 .agc_mode = MXL_SINGLE_AGC,
1108 .tracking_filter = MXL_TF_OFF,
1109 .rssi_enable = MXL_RSSI_DISABLE,
1110 .cap_select = MXL_CAP_SEL_ENABLE,
1111 .div_out = MXL_DIV_OUT_4,
1112 .clock_out = MXL_CLOCK_OUT_DISABLE,
1113 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
1114 .top = MXL5005S_TOP_25P2,
1115 .mod_mode = MXL_DIGITAL_MODE,
1116 .if_mode = MXL_ZERO_IF,
1117 .AgcMasterByte = 0x00,
1120 static int af9015_tuner_attach(struct dvb_usb_adapter *adap)
1122 struct af9015_state *state = adap->dev->priv;
1123 struct i2c_adapter *i2c_adap;
1125 deb_info("%s: \n", __func__);
1127 /* select I2C adapter */
1129 i2c_adap = &adap->dev->i2c_adap;
1131 i2c_adap = &state->i2c_adap;
1133 switch (af9015_af9013_config[adap->id].tuner) {
1134 case AF9013_TUNER_MT2060:
1135 case AF9013_TUNER_MT2060_2:
1136 ret = dvb_attach(mt2060_attach, adap->fe, i2c_adap,
1137 &af9015_mt2060_config,
1138 af9015_config.mt2060_if1[adap->id])
1139 == NULL ? -ENODEV : 0;
1141 case AF9013_TUNER_QT1010:
1142 case AF9013_TUNER_QT1010A:
1143 ret = dvb_attach(qt1010_attach, adap->fe, i2c_adap,
1144 &af9015_qt1010_config) == NULL ? -ENODEV : 0;
1146 case AF9013_TUNER_TDA18271:
1147 ret = dvb_attach(tda18271_attach, adap->fe, 0xc0, i2c_adap,
1148 &af9015_tda18271_config) == NULL ? -ENODEV : 0;
1150 case AF9013_TUNER_MXL5003D:
1151 ret = dvb_attach(mxl5005s_attach, adap->fe, i2c_adap,
1152 &af9015_mxl5003_config) == NULL ? -ENODEV : 0;
1154 case AF9013_TUNER_MXL5005D:
1155 case AF9013_TUNER_MXL5005R:
1156 ret = dvb_attach(mxl5005s_attach, adap->fe, i2c_adap,
1157 &af9015_mxl5005_config) == NULL ? -ENODEV : 0;
1159 case AF9013_TUNER_ENV77H11D5:
1160 ret = dvb_attach(dvb_pll_attach, adap->fe, 0xc0, i2c_adap,
1161 DVB_PLL_TDA665X) == NULL ? -ENODEV : 0;
1163 case AF9013_TUNER_MC44S803:
1165 ret = dvb_attach(mc44s80x_attach, adap->fe, i2c_adap)
1166 == NULL ? -ENODEV : 0;
1169 info("Freescale MC44S803 tuner found but no driver for that" \
1170 "tuner. Look at the Linuxtv.org for tuner driver" \
1174 case AF9013_TUNER_UNKNOWN:
1177 err("Unknown tuner id:%d",
1178 af9015_af9013_config[adap->id].tuner);
1183 static struct usb_device_id af9015_usb_table[] = {
1184 /* 0 */{USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9015_9015)},
1185 {USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9015_9016)},
1186 {USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_GOLD)},
1187 {USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV71E)},
1188 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_399U)},
1189 /* 5 */{USB_DEVICE(USB_VID_VISIONPLUS,
1191 {USB_DEVICE(USB_VID_VISIONPLUS,
1192 USB_PID_AZUREWAVE_AD_TU700)},
1193 {USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_USB_XE_REV2)},
1194 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_PC160_2T)},
1195 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X)},
1196 /* 10 */{USB_DEVICE(USB_VID_XTENSIONS, USB_PID_XTENSIONS_XD_380)},
1197 {USB_DEVICE(USB_VID_MSI_2, USB_PID_MSI_DIGIVOX_DUO)},
1198 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X_2)},
1199 {USB_DEVICE(USB_VID_TELESTAR, USB_PID_TELESTAR_STARSTICK_2)},
1200 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A309)},
1203 MODULE_DEVICE_TABLE(usb, af9015_usb_table);
1205 static struct dvb_usb_device_properties af9015_properties[] = {
1207 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1209 .usb_ctrl = DEVICE_SPECIFIC,
1210 .download_firmware = af9015_download_firmware,
1211 .firmware = "dvb-usb-af9015.fw",
1213 .size_of_priv = sizeof(struct af9015_state), \
1218 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1219 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1221 .pid_filter_count = 32,
1222 .pid_filter = af9015_pid_filter,
1223 .pid_filter_ctrl = af9015_pid_filter_ctrl,
1226 af9015_af9013_frontend_attach,
1227 .tuner_attach = af9015_tuner_attach,
1236 af9015_af9013_frontend_attach,
1237 .tuner_attach = af9015_tuner_attach,
1246 .identify_state = af9015_identify_state,
1248 .rc_query = af9015_rc_query,
1251 .i2c_algo = &af9015_i2c_algo,
1253 .num_device_descs = 9,
1256 .name = "Afatech AF9015 DVB-T USB2.0 stick",
1257 .cold_ids = {&af9015_usb_table[0],
1258 &af9015_usb_table[1], NULL},
1262 .name = "Leadtek WinFast DTV Dongle Gold",
1263 .cold_ids = {&af9015_usb_table[2], NULL},
1267 .name = "Pinnacle PCTV 71e",
1268 .cold_ids = {&af9015_usb_table[3], NULL},
1272 .name = "KWorld PlusTV Dual DVB-T Stick " \
1274 .cold_ids = {&af9015_usb_table[4], NULL},
1278 .name = "DigitalNow TinyTwin DVB-T Receiver",
1279 .cold_ids = {&af9015_usb_table[5], NULL},
1283 .name = "TwinHan AzureWave AD-TU700(704J)",
1284 .cold_ids = {&af9015_usb_table[6], NULL},
1288 .name = "TerraTec Cinergy T USB XE",
1289 .cold_ids = {&af9015_usb_table[7], NULL},
1293 .name = "KWorld PlusTV Dual DVB-T PCI " \
1295 .cold_ids = {&af9015_usb_table[8], NULL},
1299 .name = "AVerMedia AVerTV DVB-T Volar X",
1300 .cold_ids = {&af9015_usb_table[9], NULL},
1305 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1307 .usb_ctrl = DEVICE_SPECIFIC,
1308 .download_firmware = af9015_download_firmware,
1309 .firmware = "dvb-usb-af9015.fw",
1311 .size_of_priv = sizeof(struct af9015_state), \
1316 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1317 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1319 .pid_filter_count = 32,
1320 .pid_filter = af9015_pid_filter,
1321 .pid_filter_ctrl = af9015_pid_filter_ctrl,
1324 af9015_af9013_frontend_attach,
1325 .tuner_attach = af9015_tuner_attach,
1334 af9015_af9013_frontend_attach,
1335 .tuner_attach = af9015_tuner_attach,
1344 .identify_state = af9015_identify_state,
1346 .rc_query = af9015_rc_query,
1349 .i2c_algo = &af9015_i2c_algo,
1351 .num_device_descs = 5,
1354 .name = "Xtensions XD-380",
1355 .cold_ids = {&af9015_usb_table[10], NULL},
1359 .name = "MSI DIGIVOX Duo",
1360 .cold_ids = {&af9015_usb_table[11], NULL},
1364 .name = "Fujitsu-Siemens Slim Mobile USB DVB-T",
1365 .cold_ids = {&af9015_usb_table[12], NULL},
1369 .name = "Telestar Starstick 2",
1370 .cold_ids = {&af9015_usb_table[13], NULL},
1374 .name = "AVerMedia A309",
1375 .cold_ids = {&af9015_usb_table[14], NULL},
1381 #undef AF9015_DEFAULT_PROPERTIES
1383 static int af9015_usb_probe(struct usb_interface *intf,
1384 const struct usb_device_id *id)
1387 struct dvb_usb_device *d = NULL;
1388 struct usb_device *udev = interface_to_usbdev(intf);
1391 deb_info("%s: interface:%d\n", __func__,
1392 intf->cur_altsetting->desc.bInterfaceNumber);
1394 /* interface 0 is used by DVB-T receiver and
1395 interface 1 is for remote controller (HID) */
1396 if (intf->cur_altsetting->desc.bInterfaceNumber == 0) {
1397 ret = af9015_read_config(udev);
1401 for (i = 0; i < af9015_properties_count; i++) {
1402 ret = dvb_usb_device_init(intf, &af9015_properties[i],
1403 THIS_MODULE, &d, adapter_nr);
1413 ret = af9015_init(d);
1419 void af9015_i2c_exit(struct dvb_usb_device *d)
1421 struct af9015_state *state = d->priv;
1422 deb_info("%s: \n", __func__);
1424 /* remove 2nd I2C adapter */
1425 if (d->state & DVB_USB_STATE_I2C)
1426 i2c_del_adapter(&state->i2c_adap);
1429 static void af9015_usb_device_exit(struct usb_interface *intf)
1431 struct dvb_usb_device *d = usb_get_intfdata(intf);
1432 deb_info("%s: \n", __func__);
1434 /* remove 2nd I2C adapter */
1435 if (d != NULL && d->desc != NULL)
1438 dvb_usb_device_exit(intf);
1441 /* usb specific object needed to register this driver with the usb subsystem */
1442 static struct usb_driver af9015_usb_driver = {
1443 .name = "dvb_usb_af9015",
1444 .probe = af9015_usb_probe,
1445 .disconnect = af9015_usb_device_exit,
1446 .id_table = af9015_usb_table,
1450 static int __init af9015_usb_module_init(void)
1453 ret = usb_register(&af9015_usb_driver);
1455 err("module init failed:%d", ret);
1460 static void __exit af9015_usb_module_exit(void)
1462 /* deregister this driver from the USB subsystem */
1463 usb_deregister(&af9015_usb_driver);
1466 module_init(af9015_usb_module_init);
1467 module_exit(af9015_usb_module_exit);
1469 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1470 MODULE_DESCRIPTION("Driver for Afatech AF9015 DVB-T");
1471 MODULE_LICENSE("GPL");