Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /* DVB USB compliant Linux driver for the Afatech 9005
0003  * USB1.1 DVB-T receiver.
0004  *
0005  * Copyright (C) 2007 Luca Olivetti (luca@ventoso.org)
0006  *
0007  * Thanks to Afatech who kindly provided information.
0008  *
0009  * see Documentation/driver-api/media/drivers/dvb-usb.rst for more information
0010  */
0011 #include "af9005.h"
0012 
0013 /* debug */
0014 int dvb_usb_af9005_debug;
0015 module_param_named(debug, dvb_usb_af9005_debug, int, 0644);
0016 MODULE_PARM_DESC(debug,
0017          "set debugging level (1=info,xfer=2,rc=4,reg=8,i2c=16,fw=32 (or-able))."
0018          DVB_USB_DEBUG_STATUS);
0019 /* enable obnoxious led */
0020 bool dvb_usb_af9005_led = true;
0021 module_param_named(led, dvb_usb_af9005_led, bool, 0644);
0022 MODULE_PARM_DESC(led, "enable led (default: 1).");
0023 
0024 /* eeprom dump */
0025 static int dvb_usb_af9005_dump_eeprom;
0026 module_param_named(dump_eeprom, dvb_usb_af9005_dump_eeprom, int, 0);
0027 MODULE_PARM_DESC(dump_eeprom, "dump contents of the eeprom.");
0028 
0029 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
0030 
0031 /* remote control decoder */
0032 static int (*rc_decode) (struct dvb_usb_device *d, u8 *data, int len,
0033         u32 *event, int *state);
0034 static void *rc_keys;
0035 static int *rc_keys_size;
0036 
0037 u8 regmask[8] = { 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
0038 
0039 struct af9005_device_state {
0040     u8 sequence;
0041     int led_state;
0042     unsigned char data[256];
0043 };
0044 
0045 static int af9005_generic_read_write(struct dvb_usb_device *d, u16 reg,
0046                   int readwrite, int type, u8 * values, int len)
0047 {
0048     struct af9005_device_state *st = d->priv;
0049     u8 command, seq;
0050     int i, ret;
0051 
0052     if (len < 1) {
0053         err("generic read/write, less than 1 byte. Makes no sense.");
0054         return -EINVAL;
0055     }
0056     if (len > 8) {
0057         err("generic read/write, more than 8 bytes. Not supported.");
0058         return -EINVAL;
0059     }
0060 
0061     mutex_lock(&d->data_mutex);
0062     st->data[0] = 14;       /* rest of buffer length low */
0063     st->data[1] = 0;        /* rest of buffer length high */
0064 
0065     st->data[2] = AF9005_REGISTER_RW;   /* register operation */
0066     st->data[3] = 12;       /* rest of buffer length */
0067 
0068     st->data[4] = seq = st->sequence++; /* sequence number */
0069 
0070     st->data[5] = (u8) (reg >> 8);  /* register address */
0071     st->data[6] = (u8) (reg & 0xff);
0072 
0073     if (type == AF9005_OFDM_REG) {
0074         command = AF9005_CMD_OFDM_REG;
0075     } else {
0076         command = AF9005_CMD_TUNER;
0077     }
0078 
0079     if (len > 1)
0080         command |=
0081             AF9005_CMD_BURST | AF9005_CMD_AUTOINC | (len - 1) << 3;
0082     command |= readwrite;
0083     if (readwrite == AF9005_CMD_WRITE)
0084         for (i = 0; i < len; i++)
0085             st->data[8 + i] = values[i];
0086     else if (type == AF9005_TUNER_REG)
0087         /* read command for tuner, the first byte contains the i2c address */
0088         st->data[8] = values[0];
0089     st->data[7] = command;
0090 
0091     ret = dvb_usb_generic_rw(d, st->data, 16, st->data, 17, 0);
0092     if (ret)
0093         goto ret;
0094 
0095     /* sanity check */
0096     if (st->data[2] != AF9005_REGISTER_RW_ACK) {
0097         err("generic read/write, wrong reply code.");
0098         ret = -EIO;
0099         goto ret;
0100     }
0101     if (st->data[3] != 0x0d) {
0102         err("generic read/write, wrong length in reply.");
0103         ret = -EIO;
0104         goto ret;
0105     }
0106     if (st->data[4] != seq) {
0107         err("generic read/write, wrong sequence in reply.");
0108         ret = -EIO;
0109         goto ret;
0110     }
0111     /*
0112      * In thesis, both input and output buffers should have
0113      * identical values for st->data[5] to st->data[8].
0114      * However, windows driver doesn't check these fields, in fact
0115      * sometimes the register in the reply is different that what
0116      * has been sent
0117      */
0118     if (st->data[16] != 0x01) {
0119         err("generic read/write wrong status code in reply.");
0120         ret = -EIO;
0121         goto ret;
0122     }
0123 
0124     if (readwrite == AF9005_CMD_READ)
0125         for (i = 0; i < len; i++)
0126             values[i] = st->data[8 + i];
0127 
0128 ret:
0129     mutex_unlock(&d->data_mutex);
0130     return ret;
0131 
0132 }
0133 
0134 int af9005_read_ofdm_register(struct dvb_usb_device *d, u16 reg, u8 * value)
0135 {
0136     int ret;
0137     deb_reg("read register %x ", reg);
0138     ret = af9005_generic_read_write(d, reg,
0139                     AF9005_CMD_READ, AF9005_OFDM_REG,
0140                     value, 1);
0141     if (ret)
0142         deb_reg("failed\n");
0143     else
0144         deb_reg("value %x\n", *value);
0145     return ret;
0146 }
0147 
0148 int af9005_read_ofdm_registers(struct dvb_usb_device *d, u16 reg,
0149                    u8 * values, int len)
0150 {
0151     int ret;
0152     deb_reg("read %d registers %x ", len, reg);
0153     ret = af9005_generic_read_write(d, reg,
0154                     AF9005_CMD_READ, AF9005_OFDM_REG,
0155                     values, len);
0156     if (ret)
0157         deb_reg("failed\n");
0158     else
0159         debug_dump(values, len, deb_reg);
0160     return ret;
0161 }
0162 
0163 int af9005_write_ofdm_register(struct dvb_usb_device *d, u16 reg, u8 value)
0164 {
0165     int ret;
0166     u8 temp = value;
0167     deb_reg("write register %x value %x ", reg, value);
0168     ret = af9005_generic_read_write(d, reg,
0169                     AF9005_CMD_WRITE, AF9005_OFDM_REG,
0170                     &temp, 1);
0171     if (ret)
0172         deb_reg("failed\n");
0173     else
0174         deb_reg("ok\n");
0175     return ret;
0176 }
0177 
0178 int af9005_write_ofdm_registers(struct dvb_usb_device *d, u16 reg,
0179                 u8 * values, int len)
0180 {
0181     int ret;
0182     deb_reg("write %d registers %x values ", len, reg);
0183     debug_dump(values, len, deb_reg);
0184 
0185     ret = af9005_generic_read_write(d, reg,
0186                     AF9005_CMD_WRITE, AF9005_OFDM_REG,
0187                     values, len);
0188     if (ret)
0189         deb_reg("failed\n");
0190     else
0191         deb_reg("ok\n");
0192     return ret;
0193 }
0194 
0195 int af9005_read_register_bits(struct dvb_usb_device *d, u16 reg, u8 pos,
0196                   u8 len, u8 * value)
0197 {
0198     u8 temp;
0199     int ret;
0200     deb_reg("read bits %x %x %x", reg, pos, len);
0201     ret = af9005_read_ofdm_register(d, reg, &temp);
0202     if (ret) {
0203         deb_reg(" failed\n");
0204         return ret;
0205     }
0206     *value = (temp >> pos) & regmask[len - 1];
0207     deb_reg(" value %x\n", *value);
0208     return 0;
0209 
0210 }
0211 
0212 int af9005_write_register_bits(struct dvb_usb_device *d, u16 reg, u8 pos,
0213                    u8 len, u8 value)
0214 {
0215     u8 temp, mask;
0216     int ret;
0217     deb_reg("write bits %x %x %x value %x\n", reg, pos, len, value);
0218     if (pos == 0 && len == 8)
0219         return af9005_write_ofdm_register(d, reg, value);
0220     ret = af9005_read_ofdm_register(d, reg, &temp);
0221     if (ret)
0222         return ret;
0223     mask = regmask[len - 1] << pos;
0224     temp = (temp & ~mask) | ((value << pos) & mask);
0225     return af9005_write_ofdm_register(d, reg, temp);
0226 
0227 }
0228 
0229 static int af9005_usb_read_tuner_registers(struct dvb_usb_device *d,
0230                        u16 reg, u8 * values, int len)
0231 {
0232     return af9005_generic_read_write(d, reg,
0233                      AF9005_CMD_READ, AF9005_TUNER_REG,
0234                      values, len);
0235 }
0236 
0237 static int af9005_usb_write_tuner_registers(struct dvb_usb_device *d,
0238                         u16 reg, u8 * values, int len)
0239 {
0240     return af9005_generic_read_write(d, reg,
0241                      AF9005_CMD_WRITE,
0242                      AF9005_TUNER_REG, values, len);
0243 }
0244 
0245 int af9005_write_tuner_registers(struct dvb_usb_device *d, u16 reg,
0246                  u8 * values, int len)
0247 {
0248     /* don't let the name of this function mislead you: it's just used
0249        as an interface from the firmware to the i2c bus. The actual
0250        i2c addresses are contained in the data */
0251     int ret, i, done = 0, fail = 0;
0252     u8 temp;
0253     ret = af9005_usb_write_tuner_registers(d, reg, values, len);
0254     if (ret)
0255         return ret;
0256     if (reg != 0xffff) {
0257         /* check if write done (0xa40d bit 1) or fail (0xa40d bit 2) */
0258         for (i = 0; i < 200; i++) {
0259             ret =
0260                 af9005_read_ofdm_register(d,
0261                               xd_I2C_i2c_m_status_wdat_done,
0262                               &temp);
0263             if (ret)
0264                 return ret;
0265             done = temp & (regmask[i2c_m_status_wdat_done_len - 1]
0266                        << i2c_m_status_wdat_done_pos);
0267             if (done)
0268                 break;
0269             fail = temp & (regmask[i2c_m_status_wdat_fail_len - 1]
0270                        << i2c_m_status_wdat_fail_pos);
0271             if (fail)
0272                 break;
0273             msleep(50);
0274         }
0275         if (i == 200)
0276             return -ETIMEDOUT;
0277         if (fail) {
0278             /* clear write fail bit */
0279             af9005_write_register_bits(d,
0280                            xd_I2C_i2c_m_status_wdat_fail,
0281                            i2c_m_status_wdat_fail_pos,
0282                            i2c_m_status_wdat_fail_len,
0283                            1);
0284             return -EIO;
0285         }
0286         /* clear write done bit */
0287         ret =
0288             af9005_write_register_bits(d,
0289                            xd_I2C_i2c_m_status_wdat_fail,
0290                            i2c_m_status_wdat_done_pos,
0291                            i2c_m_status_wdat_done_len, 1);
0292         if (ret)
0293             return ret;
0294     }
0295     return 0;
0296 }
0297 
0298 int af9005_read_tuner_registers(struct dvb_usb_device *d, u16 reg, u8 addr,
0299                 u8 * values, int len)
0300 {
0301     /* don't let the name of this function mislead you: it's just used
0302        as an interface from the firmware to the i2c bus. The actual
0303        i2c addresses are contained in the data */
0304     int ret, i;
0305     u8 temp, buf[2];
0306 
0307     buf[0] = addr;      /* tuner i2c address */
0308     buf[1] = values[0]; /* tuner register */
0309 
0310     values[0] = addr + 0x01;    /* i2c read address */
0311 
0312     if (reg == APO_REG_I2C_RW_SILICON_TUNER) {
0313         /* write tuner i2c address to tuner, 0c00c0 undocumented, found by sniffing */
0314         ret = af9005_write_tuner_registers(d, 0x00c0, buf, 2);
0315         if (ret)
0316             return ret;
0317     }
0318 
0319     /* send read command to ofsm */
0320     ret = af9005_usb_read_tuner_registers(d, reg, values, 1);
0321     if (ret)
0322         return ret;
0323 
0324     /* check if read done */
0325     for (i = 0; i < 200; i++) {
0326         ret = af9005_read_ofdm_register(d, 0xa408, &temp);
0327         if (ret)
0328             return ret;
0329         if (temp & 0x01)
0330             break;
0331         msleep(50);
0332     }
0333     if (i == 200)
0334         return -ETIMEDOUT;
0335 
0336     /* clear read done bit (by writing 1) */
0337     ret = af9005_write_ofdm_register(d, xd_I2C_i2c_m_data8, 1);
0338     if (ret)
0339         return ret;
0340 
0341     /* get read data (available from 0xa400) */
0342     for (i = 0; i < len; i++) {
0343         ret = af9005_read_ofdm_register(d, 0xa400 + i, &temp);
0344         if (ret)
0345             return ret;
0346         values[i] = temp;
0347     }
0348     return 0;
0349 }
0350 
0351 static int af9005_i2c_write(struct dvb_usb_device *d, u8 i2caddr, u8 reg,
0352                 u8 * data, int len)
0353 {
0354     int ret, i;
0355     u8 buf[3];
0356     deb_i2c("i2c_write i2caddr %x, reg %x, len %d data ", i2caddr,
0357         reg, len);
0358     debug_dump(data, len, deb_i2c);
0359 
0360     for (i = 0; i < len; i++) {
0361         buf[0] = i2caddr;
0362         buf[1] = reg + (u8) i;
0363         buf[2] = data[i];
0364         ret =
0365             af9005_write_tuner_registers(d,
0366                          APO_REG_I2C_RW_SILICON_TUNER,
0367                          buf, 3);
0368         if (ret) {
0369             deb_i2c("i2c_write failed\n");
0370             return ret;
0371         }
0372     }
0373     deb_i2c("i2c_write ok\n");
0374     return 0;
0375 }
0376 
0377 static int af9005_i2c_read(struct dvb_usb_device *d, u8 i2caddr, u8 reg,
0378                u8 * data, int len)
0379 {
0380     int ret, i;
0381     u8 temp;
0382     deb_i2c("i2c_read i2caddr %x, reg %x, len %d\n ", i2caddr, reg, len);
0383     for (i = 0; i < len; i++) {
0384         temp = reg + i;
0385         ret =
0386             af9005_read_tuner_registers(d,
0387                         APO_REG_I2C_RW_SILICON_TUNER,
0388                         i2caddr, &temp, 1);
0389         if (ret) {
0390             deb_i2c("i2c_read failed\n");
0391             return ret;
0392         }
0393         data[i] = temp;
0394     }
0395     deb_i2c("i2c data read: ");
0396     debug_dump(data, len, deb_i2c);
0397     return 0;
0398 }
0399 
0400 static int af9005_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
0401                int num)
0402 {
0403     /* only implements what the mt2060 module does, don't know how
0404        to make it really generic */
0405     struct dvb_usb_device *d = i2c_get_adapdata(adap);
0406     int ret;
0407     u8 reg, addr;
0408     u8 *value;
0409 
0410     if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
0411         return -EAGAIN;
0412 
0413     if (num > 2)
0414         warn("more than 2 i2c messages at a time is not handled yet. TODO.");
0415 
0416     if (num == 2) {
0417         /* reads a single register */
0418         reg = *msg[0].buf;
0419         addr = msg[0].addr;
0420         value = msg[1].buf;
0421         ret = af9005_i2c_read(d, addr, reg, value, 1);
0422         if (ret == 0)
0423             ret = 2;
0424     } else {
0425         /* write one or more registers */
0426         reg = msg[0].buf[0];
0427         addr = msg[0].addr;
0428         value = &msg[0].buf[1];
0429         ret = af9005_i2c_write(d, addr, reg, value, msg[0].len - 1);
0430         if (ret == 0)
0431             ret = 1;
0432     }
0433 
0434     mutex_unlock(&d->i2c_mutex);
0435     return ret;
0436 }
0437 
0438 static u32 af9005_i2c_func(struct i2c_adapter *adapter)
0439 {
0440     return I2C_FUNC_I2C;
0441 }
0442 
0443 static struct i2c_algorithm af9005_i2c_algo = {
0444     .master_xfer = af9005_i2c_xfer,
0445     .functionality = af9005_i2c_func,
0446 };
0447 
0448 int af9005_send_command(struct dvb_usb_device *d, u8 command, u8 * wbuf,
0449             int wlen, u8 * rbuf, int rlen)
0450 {
0451     struct af9005_device_state *st = d->priv;
0452 
0453     int ret, i, packet_len;
0454     u8 seq;
0455 
0456     if (wlen < 0) {
0457         err("send command, wlen less than 0 bytes. Makes no sense.");
0458         return -EINVAL;
0459     }
0460     if (wlen > 54) {
0461         err("send command, wlen more than 54 bytes. Not supported.");
0462         return -EINVAL;
0463     }
0464     if (rlen > 54) {
0465         err("send command, rlen more than 54 bytes. Not supported.");
0466         return -EINVAL;
0467     }
0468     packet_len = wlen + 5;
0469 
0470     mutex_lock(&d->data_mutex);
0471 
0472     st->data[0] = (u8) (packet_len & 0xff);
0473     st->data[1] = (u8) ((packet_len & 0xff00) >> 8);
0474 
0475     st->data[2] = 0x26;     /* packet type */
0476     st->data[3] = wlen + 3;
0477     st->data[4] = seq = st->sequence++;
0478     st->data[5] = command;
0479     st->data[6] = wlen;
0480     for (i = 0; i < wlen; i++)
0481         st->data[7 + i] = wbuf[i];
0482     ret = dvb_usb_generic_rw(d, st->data, wlen + 7, st->data, rlen + 7, 0);
0483     if (st->data[2] != 0x27) {
0484         err("send command, wrong reply code.");
0485         ret = -EIO;
0486     } else if (st->data[4] != seq) {
0487         err("send command, wrong sequence in reply.");
0488         ret = -EIO;
0489     } else if (st->data[5] != 0x01) {
0490         err("send command, wrong status code in reply.");
0491         ret = -EIO;
0492     } else if (st->data[6] != rlen) {
0493         err("send command, invalid data length in reply.");
0494         ret = -EIO;
0495     }
0496     if (!ret) {
0497         for (i = 0; i < rlen; i++)
0498             rbuf[i] = st->data[i + 7];
0499     }
0500 
0501     mutex_unlock(&d->data_mutex);
0502     return ret;
0503 }
0504 
0505 int af9005_read_eeprom(struct dvb_usb_device *d, u8 address, u8 * values,
0506                int len)
0507 {
0508     struct af9005_device_state *st = d->priv;
0509     u8 seq;
0510     int ret, i;
0511 
0512     mutex_lock(&d->data_mutex);
0513 
0514     memset(st->data, 0, sizeof(st->data));
0515 
0516     st->data[0] = 14;       /* length of rest of packet low */
0517     st->data[1] = 0;        /* length of rest of packer high */
0518 
0519     st->data[2] = 0x2a;     /* read/write eeprom */
0520 
0521     st->data[3] = 12;       /* size */
0522 
0523     st->data[4] = seq = st->sequence++;
0524 
0525     st->data[5] = 0;        /* read */
0526 
0527     st->data[6] = len;
0528     st->data[7] = address;
0529     ret = dvb_usb_generic_rw(d, st->data, 16, st->data, 14, 0);
0530     if (st->data[2] != 0x2b) {
0531         err("Read eeprom, invalid reply code");
0532         ret = -EIO;
0533     } else if (st->data[3] != 10) {
0534         err("Read eeprom, invalid reply length");
0535         ret = -EIO;
0536     } else if (st->data[4] != seq) {
0537         err("Read eeprom, wrong sequence in reply ");
0538         ret = -EIO;
0539     } else if (st->data[5] != 1) {
0540         err("Read eeprom, wrong status in reply ");
0541         ret = -EIO;
0542     }
0543 
0544     if (!ret) {
0545         for (i = 0; i < len; i++)
0546             values[i] = st->data[6 + i];
0547     }
0548     mutex_unlock(&d->data_mutex);
0549 
0550     return ret;
0551 }
0552 
0553 static int af9005_boot_packet(struct usb_device *udev, int type, u8 *reply,
0554                   u8 *buf, int size)
0555 {
0556     u16 checksum;
0557     int act_len = 0, i, ret;
0558 
0559     memset(buf, 0, size);
0560     buf[0] = (u8) (FW_BULKOUT_SIZE & 0xff);
0561     buf[1] = (u8) ((FW_BULKOUT_SIZE >> 8) & 0xff);
0562     switch (type) {
0563     case FW_CONFIG:
0564         buf[2] = 0x11;
0565         buf[3] = 0x04;
0566         buf[4] = 0x00;  /* sequence number, original driver doesn't increment it here */
0567         buf[5] = 0x03;
0568         checksum = buf[4] + buf[5];
0569         buf[6] = (u8) ((checksum >> 8) & 0xff);
0570         buf[7] = (u8) (checksum & 0xff);
0571         break;
0572     case FW_CONFIRM:
0573         buf[2] = 0x11;
0574         buf[3] = 0x04;
0575         buf[4] = 0x00;  /* sequence number, original driver doesn't increment it here */
0576         buf[5] = 0x01;
0577         checksum = buf[4] + buf[5];
0578         buf[6] = (u8) ((checksum >> 8) & 0xff);
0579         buf[7] = (u8) (checksum & 0xff);
0580         break;
0581     case FW_BOOT:
0582         buf[2] = 0x10;
0583         buf[3] = 0x08;
0584         buf[4] = 0x00;  /* sequence number, original driver doesn't increment it here */
0585         buf[5] = 0x97;
0586         buf[6] = 0xaa;
0587         buf[7] = 0x55;
0588         buf[8] = 0xa5;
0589         buf[9] = 0x5a;
0590         checksum = 0;
0591         for (i = 4; i <= 9; i++)
0592             checksum += buf[i];
0593         buf[10] = (u8) ((checksum >> 8) & 0xff);
0594         buf[11] = (u8) (checksum & 0xff);
0595         break;
0596     default:
0597         err("boot packet invalid boot packet type");
0598         return -EINVAL;
0599     }
0600     deb_fw(">>> ");
0601     debug_dump(buf, FW_BULKOUT_SIZE + 2, deb_fw);
0602 
0603     ret = usb_bulk_msg(udev,
0604                usb_sndbulkpipe(udev, 0x02),
0605                buf, FW_BULKOUT_SIZE + 2, &act_len, 2000);
0606     if (ret)
0607         err("boot packet bulk message failed: %d (%d/%d)", ret,
0608             FW_BULKOUT_SIZE + 2, act_len);
0609     else
0610         ret = act_len != FW_BULKOUT_SIZE + 2 ? -1 : 0;
0611     if (ret)
0612         return ret;
0613     memset(buf, 0, 9);
0614     ret = usb_bulk_msg(udev,
0615                usb_rcvbulkpipe(udev, 0x01), buf, 9, &act_len, 2000);
0616     if (ret) {
0617         err("boot packet recv bulk message failed: %d", ret);
0618         return ret;
0619     }
0620     deb_fw("<<< ");
0621     debug_dump(buf, act_len, deb_fw);
0622     checksum = 0;
0623     switch (type) {
0624     case FW_CONFIG:
0625         if (buf[2] != 0x11) {
0626             err("boot bad config header.");
0627             return -EIO;
0628         }
0629         if (buf[3] != 0x05) {
0630             err("boot bad config size.");
0631             return -EIO;
0632         }
0633         if (buf[4] != 0x00) {
0634             err("boot bad config sequence.");
0635             return -EIO;
0636         }
0637         if (buf[5] != 0x04) {
0638             err("boot bad config subtype.");
0639             return -EIO;
0640         }
0641         for (i = 4; i <= 6; i++)
0642             checksum += buf[i];
0643         if (buf[7] * 256 + buf[8] != checksum) {
0644             err("boot bad config checksum.");
0645             return -EIO;
0646         }
0647         *reply = buf[6];
0648         break;
0649     case FW_CONFIRM:
0650         if (buf[2] != 0x11) {
0651             err("boot bad confirm header.");
0652             return -EIO;
0653         }
0654         if (buf[3] != 0x05) {
0655             err("boot bad confirm size.");
0656             return -EIO;
0657         }
0658         if (buf[4] != 0x00) {
0659             err("boot bad confirm sequence.");
0660             return -EIO;
0661         }
0662         if (buf[5] != 0x02) {
0663             err("boot bad confirm subtype.");
0664             return -EIO;
0665         }
0666         for (i = 4; i <= 6; i++)
0667             checksum += buf[i];
0668         if (buf[7] * 256 + buf[8] != checksum) {
0669             err("boot bad confirm checksum.");
0670             return -EIO;
0671         }
0672         *reply = buf[6];
0673         break;
0674     case FW_BOOT:
0675         if (buf[2] != 0x10) {
0676             err("boot bad boot header.");
0677             return -EIO;
0678         }
0679         if (buf[3] != 0x05) {
0680             err("boot bad boot size.");
0681             return -EIO;
0682         }
0683         if (buf[4] != 0x00) {
0684             err("boot bad boot sequence.");
0685             return -EIO;
0686         }
0687         if (buf[5] != 0x01) {
0688             err("boot bad boot pattern 01.");
0689             return -EIO;
0690         }
0691         if (buf[6] != 0x10) {
0692             err("boot bad boot pattern 10.");
0693             return -EIO;
0694         }
0695         for (i = 4; i <= 6; i++)
0696             checksum += buf[i];
0697         if (buf[7] * 256 + buf[8] != checksum) {
0698             err("boot bad boot checksum.");
0699             return -EIO;
0700         }
0701         break;
0702 
0703     }
0704 
0705     return 0;
0706 }
0707 
0708 static int af9005_download_firmware(struct usb_device *udev, const struct firmware *fw)
0709 {
0710     int i, packets, ret, act_len;
0711 
0712     u8 *buf;
0713     u8 reply;
0714 
0715     buf = kmalloc(FW_BULKOUT_SIZE + 2, GFP_KERNEL);
0716     if (!buf)
0717         return -ENOMEM;
0718 
0719     ret = af9005_boot_packet(udev, FW_CONFIG, &reply, buf,
0720                  FW_BULKOUT_SIZE + 2);
0721     if (ret)
0722         goto err;
0723     if (reply != 0x01) {
0724         err("before downloading firmware, FW_CONFIG expected 0x01, received 0x%x", reply);
0725         ret = -EIO;
0726         goto err;
0727     }
0728     packets = fw->size / FW_BULKOUT_SIZE;
0729     buf[0] = (u8) (FW_BULKOUT_SIZE & 0xff);
0730     buf[1] = (u8) ((FW_BULKOUT_SIZE >> 8) & 0xff);
0731     for (i = 0; i < packets; i++) {
0732         memcpy(&buf[2], fw->data + i * FW_BULKOUT_SIZE,
0733                FW_BULKOUT_SIZE);
0734         deb_fw(">>> ");
0735         debug_dump(buf, FW_BULKOUT_SIZE + 2, deb_fw);
0736         ret = usb_bulk_msg(udev,
0737                    usb_sndbulkpipe(udev, 0x02),
0738                    buf, FW_BULKOUT_SIZE + 2, &act_len, 1000);
0739         if (ret) {
0740             err("firmware download failed at packet %d with code %d", i, ret);
0741             goto err;
0742         }
0743     }
0744     ret = af9005_boot_packet(udev, FW_CONFIRM, &reply,
0745                  buf, FW_BULKOUT_SIZE + 2);
0746     if (ret)
0747         goto err;
0748     if (reply != (u8) (packets & 0xff)) {
0749         err("after downloading firmware, FW_CONFIRM expected 0x%x, received 0x%x", packets & 0xff, reply);
0750         ret = -EIO;
0751         goto err;
0752     }
0753     ret = af9005_boot_packet(udev, FW_BOOT, &reply, buf,
0754                  FW_BULKOUT_SIZE + 2);
0755     if (ret)
0756         goto err;
0757     ret = af9005_boot_packet(udev, FW_CONFIG, &reply, buf,
0758                  FW_BULKOUT_SIZE + 2);
0759     if (ret)
0760         goto err;
0761     if (reply != 0x02) {
0762         err("after downloading firmware, FW_CONFIG expected 0x02, received 0x%x", reply);
0763         ret = -EIO;
0764         goto err;
0765     }
0766 
0767 err:
0768     kfree(buf);
0769     return ret;
0770 
0771 }
0772 
0773 int af9005_led_control(struct dvb_usb_device *d, int onoff)
0774 {
0775     struct af9005_device_state *st = d->priv;
0776     int temp, ret;
0777 
0778     if (onoff && dvb_usb_af9005_led)
0779         temp = 1;
0780     else
0781         temp = 0;
0782     if (st->led_state != temp) {
0783         ret =
0784             af9005_write_register_bits(d, xd_p_reg_top_locken1,
0785                            reg_top_locken1_pos,
0786                            reg_top_locken1_len, temp);
0787         if (ret)
0788             return ret;
0789         ret =
0790             af9005_write_register_bits(d, xd_p_reg_top_lock1,
0791                            reg_top_lock1_pos,
0792                            reg_top_lock1_len, temp);
0793         if (ret)
0794             return ret;
0795         st->led_state = temp;
0796     }
0797     return 0;
0798 }
0799 
0800 static int af9005_frontend_attach(struct dvb_usb_adapter *adap)
0801 {
0802     u8 buf[8];
0803     int i;
0804 
0805     /* without these calls the first commands after downloading
0806        the firmware fail. I put these calls here to simulate
0807        what it is done in dvb-usb-init.c.
0808      */
0809     struct usb_device *udev = adap->dev->udev;
0810     usb_clear_halt(udev, usb_sndbulkpipe(udev, 2));
0811     usb_clear_halt(udev, usb_rcvbulkpipe(udev, 1));
0812     if (dvb_usb_af9005_dump_eeprom) {
0813         printk("EEPROM DUMP\n");
0814         for (i = 0; i < 255; i += 8) {
0815             af9005_read_eeprom(adap->dev, i, buf, 8);
0816             debug_dump(buf, 8, printk);
0817         }
0818     }
0819     adap->fe_adap[0].fe = af9005_fe_attach(adap->dev);
0820     return 0;
0821 }
0822 
0823 static int af9005_rc_query(struct dvb_usb_device *d, u32 * event, int *state)
0824 {
0825     struct af9005_device_state *st = d->priv;
0826     int ret, len;
0827     u8 seq;
0828 
0829     *state = REMOTE_NO_KEY_PRESSED;
0830     if (rc_decode == NULL) {
0831         /* it shouldn't never come here */
0832         return 0;
0833     }
0834 
0835     mutex_lock(&d->data_mutex);
0836 
0837     /* deb_info("rc_query\n"); */
0838     st->data[0] = 3;        /* rest of packet length low */
0839     st->data[1] = 0;        /* rest of packet length high */
0840     st->data[2] = 0x40;     /* read remote */
0841     st->data[3] = 1;        /* rest of packet length */
0842     st->data[4] = seq = st->sequence++; /* sequence number */
0843     ret = dvb_usb_generic_rw(d, st->data, 5, st->data, 256, 0);
0844     if (ret) {
0845         err("rc query failed");
0846         goto ret;
0847     }
0848     if (st->data[2] != 0x41) {
0849         err("rc query bad header.");
0850         ret = -EIO;
0851         goto ret;
0852     } else if (st->data[4] != seq) {
0853         err("rc query bad sequence.");
0854         ret = -EIO;
0855         goto ret;
0856     }
0857     len = st->data[5];
0858     if (len > 246) {
0859         err("rc query invalid length");
0860         ret = -EIO;
0861         goto ret;
0862     }
0863     if (len > 0) {
0864         deb_rc("rc data (%d) ", len);
0865         debug_dump((st->data + 6), len, deb_rc);
0866         ret = rc_decode(d, &st->data[6], len, event, state);
0867         if (ret) {
0868             err("rc_decode failed");
0869             goto ret;
0870         } else {
0871             deb_rc("rc_decode state %x event %x\n", *state, *event);
0872             if (*state == REMOTE_KEY_REPEAT)
0873                 *event = d->last_event;
0874         }
0875     }
0876 
0877 ret:
0878     mutex_unlock(&d->data_mutex);
0879     return ret;
0880 }
0881 
0882 static int af9005_power_ctrl(struct dvb_usb_device *d, int onoff)
0883 {
0884 
0885     return 0;
0886 }
0887 
0888 static int af9005_pid_filter_control(struct dvb_usb_adapter *adap, int onoff)
0889 {
0890     int ret;
0891     deb_info("pid filter control  onoff %d\n", onoff);
0892     if (onoff) {
0893         ret =
0894             af9005_write_ofdm_register(adap->dev, XD_MP2IF_DMX_CTRL, 1);
0895         if (ret)
0896             return ret;
0897         ret =
0898             af9005_write_register_bits(adap->dev,
0899                            XD_MP2IF_DMX_CTRL, 1, 1, 1);
0900         if (ret)
0901             return ret;
0902         ret =
0903             af9005_write_ofdm_register(adap->dev, XD_MP2IF_DMX_CTRL, 1);
0904     } else
0905         ret =
0906             af9005_write_ofdm_register(adap->dev, XD_MP2IF_DMX_CTRL, 0);
0907     if (ret)
0908         return ret;
0909     deb_info("pid filter control ok\n");
0910     return 0;
0911 }
0912 
0913 static int af9005_pid_filter(struct dvb_usb_adapter *adap, int index,
0914                  u16 pid, int onoff)
0915 {
0916     u8 cmd = index & 0x1f;
0917     int ret;
0918     deb_info("set pid filter, index %d, pid %x, onoff %d\n", index,
0919          pid, onoff);
0920     if (onoff) {
0921         /* cannot use it as pid_filter_ctrl since it has to be done
0922            before setting the first pid */
0923         if (adap->feedcount == 1) {
0924             deb_info("first pid set, enable pid table\n");
0925             ret = af9005_pid_filter_control(adap, onoff);
0926             if (ret)
0927                 return ret;
0928         }
0929         ret =
0930             af9005_write_ofdm_register(adap->dev,
0931                            XD_MP2IF_PID_DATA_L,
0932                            (u8) (pid & 0xff));
0933         if (ret)
0934             return ret;
0935         ret =
0936             af9005_write_ofdm_register(adap->dev,
0937                            XD_MP2IF_PID_DATA_H,
0938                            (u8) (pid >> 8));
0939         if (ret)
0940             return ret;
0941         cmd |= 0x20 | 0x40;
0942     } else {
0943         if (adap->feedcount == 0) {
0944             deb_info("last pid unset, disable pid table\n");
0945             ret = af9005_pid_filter_control(adap, onoff);
0946             if (ret)
0947                 return ret;
0948         }
0949     }
0950     ret = af9005_write_ofdm_register(adap->dev, XD_MP2IF_PID_IDX, cmd);
0951     if (ret)
0952         return ret;
0953     deb_info("set pid ok\n");
0954     return 0;
0955 }
0956 
0957 static int af9005_identify_state(struct usb_device *udev,
0958                  const struct dvb_usb_device_properties *props,
0959                  const struct dvb_usb_device_description **desc,
0960                  int *cold)
0961 {
0962     int ret;
0963     u8 reply, *buf;
0964 
0965     buf = kmalloc(FW_BULKOUT_SIZE + 2, GFP_KERNEL);
0966     if (!buf)
0967         return -ENOMEM;
0968 
0969     ret = af9005_boot_packet(udev, FW_CONFIG, &reply,
0970                  buf, FW_BULKOUT_SIZE + 2);
0971     if (ret)
0972         goto err;
0973     deb_info("result of FW_CONFIG in identify state %d\n", reply);
0974     if (reply == 0x01)
0975         *cold = 1;
0976     else if (reply == 0x02)
0977         *cold = 0;
0978     else
0979         ret = -EIO;
0980     if (!ret)
0981         deb_info("Identify state cold = %d\n", *cold);
0982 
0983 err:
0984     kfree(buf);
0985     return ret;
0986 }
0987 
0988 static struct dvb_usb_device_properties af9005_properties;
0989 
0990 static int af9005_usb_probe(struct usb_interface *intf,
0991                 const struct usb_device_id *id)
0992 {
0993     return dvb_usb_device_init(intf, &af9005_properties,
0994                   THIS_MODULE, NULL, adapter_nr);
0995 }
0996 
0997 enum {
0998     AFATECH_AF9005,
0999     TERRATEC_CINERGY_T_USB_XE,
1000     ANSONIC_DVBT_USB,
1001 };
1002 
1003 static struct usb_device_id af9005_usb_table[] = {
1004     DVB_USB_DEV(AFATECH, AFATECH_AF9005),
1005     DVB_USB_DEV(TERRATEC, TERRATEC_CINERGY_T_USB_XE),
1006     DVB_USB_DEV(ANSONIC, ANSONIC_DVBT_USB),
1007     { }
1008 };
1009 
1010 MODULE_DEVICE_TABLE(usb, af9005_usb_table);
1011 
1012 static struct dvb_usb_device_properties af9005_properties = {
1013     .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1014 
1015     .usb_ctrl = DEVICE_SPECIFIC,
1016     .firmware = "af9005.fw",
1017     .download_firmware = af9005_download_firmware,
1018     .no_reconnect = 1,
1019 
1020     .size_of_priv = sizeof(struct af9005_device_state),
1021 
1022     .num_adapters = 1,
1023     .adapter = {
1024             {
1025             .num_frontends = 1,
1026             .fe = {{
1027              .caps =
1028              DVB_USB_ADAP_HAS_PID_FILTER |
1029              DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1030              .pid_filter_count = 32,
1031              .pid_filter = af9005_pid_filter,
1032              /* .pid_filter_ctrl = af9005_pid_filter_control, */
1033              .frontend_attach = af9005_frontend_attach,
1034              /* .tuner_attach     = af9005_tuner_attach, */
1035              /* parameter for the MPEG2-data transfer */
1036              .stream = {
1037                 .type = USB_BULK,
1038                 .count = 10,
1039                 .endpoint = 0x04,
1040                 .u = {
1041                       .bulk = {
1042                            .buffersize = 4096,  /* actual size seen is 3948 */
1043                            }
1044                       }
1045                 },
1046              }},
1047              }
1048             },
1049     .power_ctrl = af9005_power_ctrl,
1050     .identify_state = af9005_identify_state,
1051 
1052     .i2c_algo = &af9005_i2c_algo,
1053 
1054     .rc.legacy = {
1055         .rc_interval = 200,
1056         .rc_map_table = NULL,
1057         .rc_map_size = 0,
1058         .rc_query = af9005_rc_query,
1059     },
1060 
1061     .generic_bulk_ctrl_endpoint          = 2,
1062     .generic_bulk_ctrl_endpoint_response = 1,
1063 
1064     .num_device_descs = 3,
1065     .devices = {
1066             {.name = "Afatech DVB-T USB1.1 stick",
1067              .cold_ids = {&af9005_usb_table[AFATECH_AF9005], NULL},
1068              .warm_ids = {NULL},
1069              },
1070             {.name = "TerraTec Cinergy T USB XE",
1071              .cold_ids = {&af9005_usb_table[TERRATEC_CINERGY_T_USB_XE], NULL},
1072              .warm_ids = {NULL},
1073              },
1074             {.name = "Ansonic DVB-T USB1.1 stick",
1075              .cold_ids = {&af9005_usb_table[ANSONIC_DVBT_USB], NULL},
1076              .warm_ids = {NULL},
1077              },
1078             {NULL},
1079             }
1080 };
1081 
1082 /* usb specific object needed to register this driver with the usb subsystem */
1083 static struct usb_driver af9005_usb_driver = {
1084     .name = "dvb_usb_af9005",
1085     .probe = af9005_usb_probe,
1086     .disconnect = dvb_usb_device_exit,
1087     .id_table = af9005_usb_table,
1088 };
1089 
1090 /* module stuff */
1091 static int __init af9005_usb_module_init(void)
1092 {
1093     int result;
1094     if ((result = usb_register(&af9005_usb_driver))) {
1095         err("usb_register failed. (%d)", result);
1096         return result;
1097     }
1098 #if IS_MODULE(CONFIG_DVB_USB_AF9005) || defined(CONFIG_DVB_USB_AF9005_REMOTE)
1099     /* FIXME: convert to todays kernel IR infrastructure */
1100     rc_decode = symbol_request(af9005_rc_decode);
1101     rc_keys = symbol_request(rc_map_af9005_table);
1102     rc_keys_size = symbol_request(rc_map_af9005_table_size);
1103 #endif
1104     if (rc_decode == NULL || rc_keys == NULL || rc_keys_size == NULL) {
1105         err("af9005_rc_decode function not found, disabling remote");
1106         af9005_properties.rc.legacy.rc_query = NULL;
1107     } else {
1108         af9005_properties.rc.legacy.rc_map_table = rc_keys;
1109         af9005_properties.rc.legacy.rc_map_size = *rc_keys_size;
1110     }
1111 
1112     return 0;
1113 }
1114 
1115 static void __exit af9005_usb_module_exit(void)
1116 {
1117     /* release rc decode symbols */
1118     if (rc_decode != NULL)
1119         symbol_put(af9005_rc_decode);
1120     if (rc_keys != NULL)
1121         symbol_put(rc_map_af9005_table);
1122     if (rc_keys_size != NULL)
1123         symbol_put(rc_map_af9005_table_size);
1124     /* deregister this driver from the USB subsystem */
1125     usb_deregister(&af9005_usb_driver);
1126 }
1127 
1128 module_init(af9005_usb_module_init);
1129 module_exit(af9005_usb_module_exit);
1130 
1131 MODULE_AUTHOR("Luca Olivetti <luca@ventoso.org>");
1132 MODULE_DESCRIPTION("Driver for Afatech 9005 DVB-T USB1.1 stick");
1133 MODULE_VERSION("1.0");
1134 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!