1 /* DVB USB compliant Linux driver for the Afatech 9005
2 * USB1.1 DVB-T receiver.
4 * Copyright (C) 2007 Luca Olivetti (luca@ventoso.org)
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.
22 * see Documentation/dvb/README.dvb-usb for more information
27 int dvb_usb_af9005_debug;
28 module_param_named(debug, dvb_usb_af9005_debug, int, 0644);
29 MODULE_PARM_DESC(debug,
30 "set debugging level (1=info,xfer=2,rc=4,reg=8,i2c=16,fw=32 (or-able))."
31 DVB_USB_DEBUG_STATUS);
32 /* enable obnoxious led */
33 bool dvb_usb_af9005_led = true;
34 module_param_named(led, dvb_usb_af9005_led, bool, 0644);
35 MODULE_PARM_DESC(led, "enable led (default: 1).");
38 static int dvb_usb_af9005_dump_eeprom;
39 module_param_named(dump_eeprom, dvb_usb_af9005_dump_eeprom, int, 0);
40 MODULE_PARM_DESC(dump_eeprom, "dump contents of the eeprom.");
42 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
44 /* remote control decoder */
45 static int (*rc_decode) (struct dvb_usb_device *d, u8 *data, int len,
46 u32 *event, int *state);
48 static int *rc_keys_size;
50 u8 regmask[8] = { 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
52 struct af9005_device_state {
55 unsigned char data[256];
58 static int af9005_generic_read_write(struct dvb_usb_device *d, u16 reg,
59 int readwrite, int type, u8 * values, int len)
61 struct af9005_device_state *st = d->priv;
66 err("generic read/write, less than 1 byte. Makes no sense.");
70 err("generic read/write, more than 8 bytes. Not supported.");
74 mutex_lock(&d->data_mutex);
75 st->data[0] = 14; /* rest of buffer length low */
76 st->data[1] = 0; /* rest of buffer length high */
78 st->data[2] = AF9005_REGISTER_RW; /* register operation */
79 st->data[3] = 12; /* rest of buffer length */
81 st->data[4] = seq = st->sequence++; /* sequence number */
83 st->data[5] = (u8) (reg >> 8); /* register address */
84 st->data[6] = (u8) (reg & 0xff);
86 if (type == AF9005_OFDM_REG) {
87 command = AF9005_CMD_OFDM_REG;
89 command = AF9005_CMD_TUNER;
94 AF9005_CMD_BURST | AF9005_CMD_AUTOINC | (len - 1) << 3;
96 if (readwrite == AF9005_CMD_WRITE)
97 for (i = 0; i < len; i++)
98 st->data[8 + i] = values[i];
99 else if (type == AF9005_TUNER_REG)
100 /* read command for tuner, the first byte contains the i2c address */
101 st->data[8] = values[0];
102 st->data[7] = command;
104 ret = dvb_usb_generic_rw(d, st->data, 16, st->data, 17, 0);
109 if (st->data[2] != AF9005_REGISTER_RW_ACK) {
110 err("generic read/write, wrong reply code.");
114 if (st->data[3] != 0x0d) {
115 err("generic read/write, wrong length in reply.");
119 if (st->data[4] != seq) {
120 err("generic read/write, wrong sequence in reply.");
125 * In thesis, both input and output buffers should have
126 * identical values for st->data[5] to st->data[8].
127 * However, windows driver doesn't check these fields, in fact
128 * sometimes the register in the reply is different that what
131 if (st->data[16] != 0x01) {
132 err("generic read/write wrong status code in reply.");
137 if (readwrite == AF9005_CMD_READ)
138 for (i = 0; i < len; i++)
139 values[i] = st->data[8 + i];
142 mutex_unlock(&d->data_mutex);
147 int af9005_read_ofdm_register(struct dvb_usb_device *d, u16 reg, u8 * value)
150 deb_reg("read register %x ", reg);
151 ret = af9005_generic_read_write(d, reg,
152 AF9005_CMD_READ, AF9005_OFDM_REG,
157 deb_reg("value %x\n", *value);
161 int af9005_read_ofdm_registers(struct dvb_usb_device *d, u16 reg,
162 u8 * values, int len)
165 deb_reg("read %d registers %x ", len, reg);
166 ret = af9005_generic_read_write(d, reg,
167 AF9005_CMD_READ, AF9005_OFDM_REG,
172 debug_dump(values, len, deb_reg);
176 int af9005_write_ofdm_register(struct dvb_usb_device *d, u16 reg, u8 value)
180 deb_reg("write register %x value %x ", reg, value);
181 ret = af9005_generic_read_write(d, reg,
182 AF9005_CMD_WRITE, AF9005_OFDM_REG,
191 int af9005_write_ofdm_registers(struct dvb_usb_device *d, u16 reg,
192 u8 * values, int len)
195 deb_reg("write %d registers %x values ", len, reg);
196 debug_dump(values, len, deb_reg);
198 ret = af9005_generic_read_write(d, reg,
199 AF9005_CMD_WRITE, AF9005_OFDM_REG,
208 int af9005_read_register_bits(struct dvb_usb_device *d, u16 reg, u8 pos,
213 deb_reg("read bits %x %x %x", reg, pos, len);
214 ret = af9005_read_ofdm_register(d, reg, &temp);
216 deb_reg(" failed\n");
219 *value = (temp >> pos) & regmask[len - 1];
220 deb_reg(" value %x\n", *value);
225 int af9005_write_register_bits(struct dvb_usb_device *d, u16 reg, u8 pos,
230 deb_reg("write bits %x %x %x value %x\n", reg, pos, len, value);
231 if (pos == 0 && len == 8)
232 return af9005_write_ofdm_register(d, reg, value);
233 ret = af9005_read_ofdm_register(d, reg, &temp);
236 mask = regmask[len - 1] << pos;
237 temp = (temp & ~mask) | ((value << pos) & mask);
238 return af9005_write_ofdm_register(d, reg, temp);
242 static int af9005_usb_read_tuner_registers(struct dvb_usb_device *d,
243 u16 reg, u8 * values, int len)
245 return af9005_generic_read_write(d, reg,
246 AF9005_CMD_READ, AF9005_TUNER_REG,
250 static int af9005_usb_write_tuner_registers(struct dvb_usb_device *d,
251 u16 reg, u8 * values, int len)
253 return af9005_generic_read_write(d, reg,
255 AF9005_TUNER_REG, values, len);
258 int af9005_write_tuner_registers(struct dvb_usb_device *d, u16 reg,
259 u8 * values, int len)
261 /* don't let the name of this function mislead you: it's just used
262 as an interface from the firmware to the i2c bus. The actual
263 i2c addresses are contained in the data */
264 int ret, i, done = 0, fail = 0;
266 ret = af9005_usb_write_tuner_registers(d, reg, values, len);
270 /* check if write done (0xa40d bit 1) or fail (0xa40d bit 2) */
271 for (i = 0; i < 200; i++) {
273 af9005_read_ofdm_register(d,
274 xd_I2C_i2c_m_status_wdat_done,
278 done = temp & (regmask[i2c_m_status_wdat_done_len - 1]
279 << i2c_m_status_wdat_done_pos);
282 fail = temp & (regmask[i2c_m_status_wdat_fail_len - 1]
283 << i2c_m_status_wdat_fail_pos);
291 /* clear write fail bit */
292 af9005_write_register_bits(d,
293 xd_I2C_i2c_m_status_wdat_fail,
294 i2c_m_status_wdat_fail_pos,
295 i2c_m_status_wdat_fail_len,
299 /* clear write done bit */
301 af9005_write_register_bits(d,
302 xd_I2C_i2c_m_status_wdat_fail,
303 i2c_m_status_wdat_done_pos,
304 i2c_m_status_wdat_done_len, 1);
311 int af9005_read_tuner_registers(struct dvb_usb_device *d, u16 reg, u8 addr,
312 u8 * values, int len)
314 /* don't let the name of this function mislead you: it's just used
315 as an interface from the firmware to the i2c bus. The actual
316 i2c addresses are contained in the data */
320 buf[0] = addr; /* tuner i2c address */
321 buf[1] = values[0]; /* tuner register */
323 values[0] = addr + 0x01; /* i2c read address */
325 if (reg == APO_REG_I2C_RW_SILICON_TUNER) {
326 /* write tuner i2c address to tuner, 0c00c0 undocumented, found by sniffing */
327 ret = af9005_write_tuner_registers(d, 0x00c0, buf, 2);
332 /* send read command to ofsm */
333 ret = af9005_usb_read_tuner_registers(d, reg, values, 1);
337 /* check if read done */
338 for (i = 0; i < 200; i++) {
339 ret = af9005_read_ofdm_register(d, 0xa408, &temp);
349 /* clear read done bit (by writing 1) */
350 ret = af9005_write_ofdm_register(d, xd_I2C_i2c_m_data8, 1);
354 /* get read data (available from 0xa400) */
355 for (i = 0; i < len; i++) {
356 ret = af9005_read_ofdm_register(d, 0xa400 + i, &temp);
364 static int af9005_i2c_write(struct dvb_usb_device *d, u8 i2caddr, u8 reg,
369 deb_i2c("i2c_write i2caddr %x, reg %x, len %d data ", i2caddr,
371 debug_dump(data, len, deb_i2c);
373 for (i = 0; i < len; i++) {
375 buf[1] = reg + (u8) i;
378 af9005_write_tuner_registers(d,
379 APO_REG_I2C_RW_SILICON_TUNER,
382 deb_i2c("i2c_write failed\n");
386 deb_i2c("i2c_write ok\n");
390 static int af9005_i2c_read(struct dvb_usb_device *d, u8 i2caddr, u8 reg,
395 deb_i2c("i2c_read i2caddr %x, reg %x, len %d\n ", i2caddr, reg, len);
396 for (i = 0; i < len; i++) {
399 af9005_read_tuner_registers(d,
400 APO_REG_I2C_RW_SILICON_TUNER,
403 deb_i2c("i2c_read failed\n");
408 deb_i2c("i2c data read: ");
409 debug_dump(data, len, deb_i2c);
413 static int af9005_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
416 /* only implements what the mt2060 module does, don't know how
417 to make it really generic */
418 struct dvb_usb_device *d = i2c_get_adapdata(adap);
423 if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
427 warn("more than 2 i2c messages at a time is not handled yet. TODO.");
430 /* reads a single register */
434 ret = af9005_i2c_read(d, addr, reg, value, 1);
438 /* write one or more registers */
441 value = &msg[0].buf[1];
442 ret = af9005_i2c_write(d, addr, reg, value, msg[0].len - 1);
447 mutex_unlock(&d->i2c_mutex);
451 static u32 af9005_i2c_func(struct i2c_adapter *adapter)
456 static struct i2c_algorithm af9005_i2c_algo = {
457 .master_xfer = af9005_i2c_xfer,
458 .functionality = af9005_i2c_func,
461 int af9005_send_command(struct dvb_usb_device *d, u8 command, u8 * wbuf,
462 int wlen, u8 * rbuf, int rlen)
464 struct af9005_device_state *st = d->priv;
466 int ret, i, packet_len;
470 err("send command, wlen less than 0 bytes. Makes no sense.");
474 err("send command, wlen more than 54 bytes. Not supported.");
478 err("send command, rlen more than 54 bytes. Not supported.");
481 packet_len = wlen + 5;
483 mutex_lock(&d->data_mutex);
485 st->data[0] = (u8) (packet_len & 0xff);
486 st->data[1] = (u8) ((packet_len & 0xff00) >> 8);
488 st->data[2] = 0x26; /* packet type */
489 st->data[3] = wlen + 3;
490 st->data[4] = seq = st->sequence++;
491 st->data[5] = command;
493 for (i = 0; i < wlen; i++)
494 st->data[7 + i] = wbuf[i];
495 ret = dvb_usb_generic_rw(d, st->data, wlen + 7, st->data, rlen + 7, 0);
496 if (st->data[2] != 0x27) {
497 err("send command, wrong reply code.");
499 } else if (st->data[4] != seq) {
500 err("send command, wrong sequence in reply.");
502 } else if (st->data[5] != 0x01) {
503 err("send command, wrong status code in reply.");
505 } else if (st->data[6] != rlen) {
506 err("send command, invalid data length in reply.");
510 for (i = 0; i < rlen; i++)
511 rbuf[i] = st->data[i + 7];
514 mutex_unlock(&d->data_mutex);
518 int af9005_read_eeprom(struct dvb_usb_device *d, u8 address, u8 * values,
521 struct af9005_device_state *st = d->priv;
525 mutex_lock(&d->data_mutex);
527 memset(st->data, 0, sizeof(st->data));
529 st->data[0] = 14; /* length of rest of packet low */
530 st->data[1] = 0; /* length of rest of packer high */
532 st->data[2] = 0x2a; /* read/write eeprom */
534 st->data[3] = 12; /* size */
536 st->data[4] = seq = st->sequence++;
538 st->data[5] = 0; /* read */
541 st->data[7] = address;
542 ret = dvb_usb_generic_rw(d, st->data, 16, st->data, 14, 0);
543 if (st->data[2] != 0x2b) {
544 err("Read eeprom, invalid reply code");
546 } else if (st->data[3] != 10) {
547 err("Read eeprom, invalid reply length");
549 } else if (st->data[4] != seq) {
550 err("Read eeprom, wrong sequence in reply ");
552 } else if (st->data[5] != 1) {
553 err("Read eeprom, wrong status in reply ");
558 for (i = 0; i < len; i++)
559 values[i] = st->data[6 + i];
561 mutex_unlock(&d->data_mutex);
566 static int af9005_boot_packet(struct usb_device *udev, int type, u8 *reply,
570 int act_len = 0, i, ret;
572 memset(buf, 0, size);
573 buf[0] = (u8) (FW_BULKOUT_SIZE & 0xff);
574 buf[1] = (u8) ((FW_BULKOUT_SIZE >> 8) & 0xff);
579 buf[4] = 0x00; /* sequence number, original driver doesn't increment it here */
581 checksum = buf[4] + buf[5];
582 buf[6] = (u8) ((checksum >> 8) & 0xff);
583 buf[7] = (u8) (checksum & 0xff);
588 buf[4] = 0x00; /* sequence number, original driver doesn't increment it here */
590 checksum = buf[4] + buf[5];
591 buf[6] = (u8) ((checksum >> 8) & 0xff);
592 buf[7] = (u8) (checksum & 0xff);
597 buf[4] = 0x00; /* sequence number, original driver doesn't increment it here */
604 for (i = 4; i <= 9; i++)
606 buf[10] = (u8) ((checksum >> 8) & 0xff);
607 buf[11] = (u8) (checksum & 0xff);
610 err("boot packet invalid boot packet type");
614 debug_dump(buf, FW_BULKOUT_SIZE + 2, deb_fw);
616 ret = usb_bulk_msg(udev,
617 usb_sndbulkpipe(udev, 0x02),
618 buf, FW_BULKOUT_SIZE + 2, &act_len, 2000);
620 err("boot packet bulk message failed: %d (%d/%d)", ret,
621 FW_BULKOUT_SIZE + 2, act_len);
623 ret = act_len != FW_BULKOUT_SIZE + 2 ? -1 : 0;
627 ret = usb_bulk_msg(udev,
628 usb_rcvbulkpipe(udev, 0x01), buf, 9, &act_len, 2000);
630 err("boot packet recv bulk message failed: %d", ret);
634 debug_dump(buf, act_len, deb_fw);
638 if (buf[2] != 0x11) {
639 err("boot bad config header.");
642 if (buf[3] != 0x05) {
643 err("boot bad config size.");
646 if (buf[4] != 0x00) {
647 err("boot bad config sequence.");
650 if (buf[5] != 0x04) {
651 err("boot bad config subtype.");
654 for (i = 4; i <= 6; i++)
656 if (buf[7] * 256 + buf[8] != checksum) {
657 err("boot bad config checksum.");
663 if (buf[2] != 0x11) {
664 err("boot bad confirm header.");
667 if (buf[3] != 0x05) {
668 err("boot bad confirm size.");
671 if (buf[4] != 0x00) {
672 err("boot bad confirm sequence.");
675 if (buf[5] != 0x02) {
676 err("boot bad confirm subtype.");
679 for (i = 4; i <= 6; i++)
681 if (buf[7] * 256 + buf[8] != checksum) {
682 err("boot bad confirm checksum.");
688 if (buf[2] != 0x10) {
689 err("boot bad boot header.");
692 if (buf[3] != 0x05) {
693 err("boot bad boot size.");
696 if (buf[4] != 0x00) {
697 err("boot bad boot sequence.");
700 if (buf[5] != 0x01) {
701 err("boot bad boot pattern 01.");
704 if (buf[6] != 0x10) {
705 err("boot bad boot pattern 10.");
708 for (i = 4; i <= 6; i++)
710 if (buf[7] * 256 + buf[8] != checksum) {
711 err("boot bad boot checksum.");
721 static int af9005_download_firmware(struct usb_device *udev, const struct firmware *fw)
723 int i, packets, ret, act_len;
728 buf = kmalloc(FW_BULKOUT_SIZE + 2, GFP_KERNEL);
732 ret = af9005_boot_packet(udev, FW_CONFIG, &reply, buf,
733 FW_BULKOUT_SIZE + 2);
737 err("before downloading firmware, FW_CONFIG expected 0x01, received 0x%x", reply);
741 packets = fw->size / FW_BULKOUT_SIZE;
742 buf[0] = (u8) (FW_BULKOUT_SIZE & 0xff);
743 buf[1] = (u8) ((FW_BULKOUT_SIZE >> 8) & 0xff);
744 for (i = 0; i < packets; i++) {
745 memcpy(&buf[2], fw->data + i * FW_BULKOUT_SIZE,
748 debug_dump(buf, FW_BULKOUT_SIZE + 2, deb_fw);
749 ret = usb_bulk_msg(udev,
750 usb_sndbulkpipe(udev, 0x02),
751 buf, FW_BULKOUT_SIZE + 2, &act_len, 1000);
753 err("firmware download failed at packet %d with code %d", i, ret);
757 ret = af9005_boot_packet(udev, FW_CONFIRM, &reply,
758 buf, FW_BULKOUT_SIZE + 2);
761 if (reply != (u8) (packets & 0xff)) {
762 err("after downloading firmware, FW_CONFIRM expected 0x%x, received 0x%x", packets & 0xff, reply);
766 ret = af9005_boot_packet(udev, FW_BOOT, &reply, buf,
767 FW_BULKOUT_SIZE + 2);
770 ret = af9005_boot_packet(udev, FW_CONFIG, &reply, buf,
771 FW_BULKOUT_SIZE + 2);
775 err("after downloading firmware, FW_CONFIG expected 0x02, received 0x%x", reply);
786 int af9005_led_control(struct dvb_usb_device *d, int onoff)
788 struct af9005_device_state *st = d->priv;
791 if (onoff && dvb_usb_af9005_led)
795 if (st->led_state != temp) {
797 af9005_write_register_bits(d, xd_p_reg_top_locken1,
799 reg_top_locken1_len, temp);
803 af9005_write_register_bits(d, xd_p_reg_top_lock1,
805 reg_top_lock1_len, temp);
808 st->led_state = temp;
813 static int af9005_frontend_attach(struct dvb_usb_adapter *adap)
818 /* without these calls the first commands after downloading
819 the firmware fail. I put these calls here to simulate
820 what it is done in dvb-usb-init.c.
822 struct usb_device *udev = adap->dev->udev;
823 usb_clear_halt(udev, usb_sndbulkpipe(udev, 2));
824 usb_clear_halt(udev, usb_rcvbulkpipe(udev, 1));
825 if (dvb_usb_af9005_dump_eeprom) {
826 printk("EEPROM DUMP\n");
827 for (i = 0; i < 255; i += 8) {
828 af9005_read_eeprom(adap->dev, i, buf, 8);
829 printk("ADDR %x ", i);
830 debug_dump(buf, 8, printk);
833 adap->fe_adap[0].fe = af9005_fe_attach(adap->dev);
837 static int af9005_rc_query(struct dvb_usb_device *d, u32 * event, int *state)
839 struct af9005_device_state *st = d->priv;
843 *state = REMOTE_NO_KEY_PRESSED;
844 if (rc_decode == NULL) {
845 /* it shouldn't never come here */
849 mutex_lock(&d->data_mutex);
851 /* deb_info("rc_query\n"); */
852 st->data[0] = 3; /* rest of packet length low */
853 st->data[1] = 0; /* rest of packet lentgh high */
854 st->data[2] = 0x40; /* read remote */
855 st->data[3] = 1; /* rest of packet length */
856 st->data[4] = seq = st->sequence++; /* sequence number */
857 ret = dvb_usb_generic_rw(d, st->data, 5, st->data, 256, 0);
859 err("rc query failed");
862 if (st->data[2] != 0x41) {
863 err("rc query bad header.");
866 } else if (st->data[4] != seq) {
867 err("rc query bad sequence.");
873 err("rc query invalid length");
878 deb_rc("rc data (%d) ", len);
879 debug_dump((st->data + 6), len, deb_rc);
880 ret = rc_decode(d, &st->data[6], len, event, state);
882 err("rc_decode failed");
885 deb_rc("rc_decode state %x event %x\n", *state, *event);
886 if (*state == REMOTE_KEY_REPEAT)
887 *event = d->last_event;
892 mutex_unlock(&d->data_mutex);
896 static int af9005_power_ctrl(struct dvb_usb_device *d, int onoff)
902 static int af9005_pid_filter_control(struct dvb_usb_adapter *adap, int onoff)
905 deb_info("pid filter control onoff %d\n", onoff);
908 af9005_write_ofdm_register(adap->dev, XD_MP2IF_DMX_CTRL, 1);
912 af9005_write_register_bits(adap->dev,
913 XD_MP2IF_DMX_CTRL, 1, 1, 1);
917 af9005_write_ofdm_register(adap->dev, XD_MP2IF_DMX_CTRL, 1);
920 af9005_write_ofdm_register(adap->dev, XD_MP2IF_DMX_CTRL, 0);
923 deb_info("pid filter control ok\n");
927 static int af9005_pid_filter(struct dvb_usb_adapter *adap, int index,
930 u8 cmd = index & 0x1f;
932 deb_info("set pid filter, index %d, pid %x, onoff %d\n", index,
935 /* cannot use it as pid_filter_ctrl since it has to be done
936 before setting the first pid */
937 if (adap->feedcount == 1) {
938 deb_info("first pid set, enable pid table\n");
939 ret = af9005_pid_filter_control(adap, onoff);
944 af9005_write_ofdm_register(adap->dev,
950 af9005_write_ofdm_register(adap->dev,
957 if (adap->feedcount == 0) {
958 deb_info("last pid unset, disable pid table\n");
959 ret = af9005_pid_filter_control(adap, onoff);
964 ret = af9005_write_ofdm_register(adap->dev, XD_MP2IF_PID_IDX, cmd);
967 deb_info("set pid ok\n");
971 static int af9005_identify_state(struct usb_device *udev,
972 struct dvb_usb_device_properties *props,
973 struct dvb_usb_device_description **desc,
979 buf = kmalloc(FW_BULKOUT_SIZE + 2, GFP_KERNEL);
983 ret = af9005_boot_packet(udev, FW_CONFIG, &reply,
984 buf, FW_BULKOUT_SIZE + 2);
987 deb_info("result of FW_CONFIG in identify state %d\n", reply);
990 else if (reply == 0x02)
995 deb_info("Identify state cold = %d\n", *cold);
1002 static struct dvb_usb_device_properties af9005_properties;
1004 static int af9005_usb_probe(struct usb_interface *intf,
1005 const struct usb_device_id *id)
1007 return dvb_usb_device_init(intf, &af9005_properties,
1008 THIS_MODULE, NULL, adapter_nr);
1011 enum af9005_usb_table_entry {
1017 static struct usb_device_id af9005_usb_table[] = {
1018 [AFATECH_AF9005] = {USB_DEVICE(USB_VID_AFATECH,
1019 USB_PID_AFATECH_AF9005)},
1020 [TERRATEC_AF9005] = {USB_DEVICE(USB_VID_TERRATEC,
1021 USB_PID_TERRATEC_CINERGY_T_USB_XE)},
1022 [ANSONIC_AF9005] = {USB_DEVICE(USB_VID_ANSONIC,
1023 USB_PID_ANSONIC_DVBT_USB)},
1027 MODULE_DEVICE_TABLE(usb, af9005_usb_table);
1029 static struct dvb_usb_device_properties af9005_properties = {
1030 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1032 .usb_ctrl = DEVICE_SPECIFIC,
1033 .firmware = "/*(DEBLOBBED)*/",
1034 .download_firmware = af9005_download_firmware,
1037 .size_of_priv = sizeof(struct af9005_device_state),
1045 DVB_USB_ADAP_HAS_PID_FILTER |
1046 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1047 .pid_filter_count = 32,
1048 .pid_filter = af9005_pid_filter,
1049 /* .pid_filter_ctrl = af9005_pid_filter_control, */
1050 .frontend_attach = af9005_frontend_attach,
1051 /* .tuner_attach = af9005_tuner_attach, */
1052 /* parameter for the MPEG2-data transfer */
1059 .buffersize = 4096, /* actual size seen is 3948 */
1066 .power_ctrl = af9005_power_ctrl,
1067 .identify_state = af9005_identify_state,
1069 .i2c_algo = &af9005_i2c_algo,
1073 .rc_map_table = NULL,
1075 .rc_query = af9005_rc_query,
1078 .generic_bulk_ctrl_endpoint = 2,
1079 .generic_bulk_ctrl_endpoint_response = 1,
1081 .num_device_descs = 3,
1083 {.name = "Afatech DVB-T USB1.1 stick",
1084 .cold_ids = {&af9005_usb_table[AFATECH_AF9005], NULL},
1087 {.name = "TerraTec Cinergy T USB XE",
1088 .cold_ids = {&af9005_usb_table[TERRATEC_AF9005], NULL},
1091 {.name = "Ansonic DVB-T USB1.1 stick",
1092 .cold_ids = {&af9005_usb_table[ANSONIC_AF9005], NULL},
1099 /* usb specific object needed to register this driver with the usb subsystem */
1100 static struct usb_driver af9005_usb_driver = {
1101 .name = "dvb_usb_af9005",
1102 .probe = af9005_usb_probe,
1103 .disconnect = dvb_usb_device_exit,
1104 .id_table = af9005_usb_table,
1108 static int __init af9005_usb_module_init(void)
1111 if ((result = usb_register(&af9005_usb_driver))) {
1112 err("usb_register failed. (%d)", result);
1115 #if IS_MODULE(CONFIG_DVB_USB_AF9005) || defined(CONFIG_DVB_USB_AF9005_REMOTE)
1116 /* FIXME: convert to todays kernel IR infrastructure */
1117 rc_decode = symbol_request(af9005_rc_decode);
1118 rc_keys = symbol_request(rc_map_af9005_table);
1119 rc_keys_size = symbol_request(rc_map_af9005_table_size);
1121 if (rc_decode == NULL || rc_keys == NULL || rc_keys_size == NULL) {
1122 err("af9005_rc_decode function not found, disabling remote");
1123 af9005_properties.rc.legacy.rc_query = NULL;
1125 af9005_properties.rc.legacy.rc_map_table = rc_keys;
1126 af9005_properties.rc.legacy.rc_map_size = *rc_keys_size;
1132 static void __exit af9005_usb_module_exit(void)
1134 /* release rc decode symbols */
1135 if (rc_decode != NULL)
1136 symbol_put(af9005_rc_decode);
1137 if (rc_keys != NULL)
1138 symbol_put(rc_map_af9005_table);
1139 if (rc_keys_size != NULL)
1140 symbol_put(rc_map_af9005_table_size);
1141 /* deregister this driver from the USB subsystem */
1142 usb_deregister(&af9005_usb_driver);
1145 module_init(af9005_usb_module_init);
1146 module_exit(af9005_usb_module_exit);
1148 MODULE_AUTHOR("Luca Olivetti <luca@ventoso.org>");
1149 MODULE_DESCRIPTION("Driver for Afatech 9005 DVB-T USB1.1 stick");
1150 MODULE_VERSION("1.0");
1151 MODULE_LICENSE("GPL");