Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * DVB USB Linux driver for Afatech AF9015 DVB-T USB2.0 receiver
0004  *
0005  * Copyright (C) 2007 Antti Palosaari <crope@iki.fi>
0006  *
0007  * Thanks to Afatech who kindly provided information.
0008  */
0009 
0010 #include "af9015.h"
0011 
0012 static int dvb_usb_af9015_remote;
0013 module_param_named(remote, dvb_usb_af9015_remote, int, 0644);
0014 MODULE_PARM_DESC(remote, "select remote");
0015 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
0016 
0017 static int af9015_ctrl_msg(struct dvb_usb_device *d, struct req_t *req)
0018 {
0019 #define REQ_HDR_LEN 8 /* send header size */
0020 #define ACK_HDR_LEN 2 /* rece header size */
0021     struct af9015_state *state = d_to_priv(d);
0022     struct usb_interface *intf = d->intf;
0023     int ret, wlen, rlen;
0024     u8 write = 1;
0025 
0026     mutex_lock(&d->usb_mutex);
0027 
0028     state->buf[0] = req->cmd;
0029     state->buf[1] = state->seq++;
0030     state->buf[2] = req->i2c_addr << 1;
0031     state->buf[3] = req->addr >> 8;
0032     state->buf[4] = req->addr & 0xff;
0033     state->buf[5] = req->mbox;
0034     state->buf[6] = req->addr_len;
0035     state->buf[7] = req->data_len;
0036 
0037     switch (req->cmd) {
0038     case GET_CONFIG:
0039     case READ_MEMORY:
0040     case RECONNECT_USB:
0041         write = 0;
0042         break;
0043     case READ_I2C:
0044         write = 0;
0045         state->buf[2] |= 0x01; /* set I2C direction */
0046         fallthrough;
0047     case WRITE_I2C:
0048         state->buf[0] = READ_WRITE_I2C;
0049         break;
0050     case WRITE_MEMORY:
0051         if (((req->addr & 0xff00) == 0xff00) ||
0052             ((req->addr & 0xff00) == 0xae00))
0053             state->buf[0] = WRITE_VIRTUAL_MEMORY;
0054         break;
0055     case WRITE_VIRTUAL_MEMORY:
0056     case COPY_FIRMWARE:
0057     case DOWNLOAD_FIRMWARE:
0058     case BOOT:
0059         break;
0060     default:
0061         dev_err(&intf->dev, "unknown cmd %d\n", req->cmd);
0062         ret = -EIO;
0063         goto error;
0064     }
0065 
0066     /* Buffer overflow check */
0067     if ((write && (req->data_len > BUF_LEN - REQ_HDR_LEN)) ||
0068         (!write && (req->data_len > BUF_LEN - ACK_HDR_LEN))) {
0069         dev_err(&intf->dev, "too much data, cmd %u, len %u\n",
0070             req->cmd, req->data_len);
0071         ret = -EINVAL;
0072         goto error;
0073     }
0074 
0075     /*
0076      * Write receives seq + status = 2 bytes
0077      * Read receives seq + status + data = 2 + N bytes
0078      */
0079     wlen = REQ_HDR_LEN;
0080     rlen = ACK_HDR_LEN;
0081     if (write) {
0082         wlen += req->data_len;
0083         memcpy(&state->buf[REQ_HDR_LEN], req->data, req->data_len);
0084     } else {
0085         rlen += req->data_len;
0086     }
0087 
0088     /* no ack for these packets */
0089     if (req->cmd == DOWNLOAD_FIRMWARE || req->cmd == RECONNECT_USB)
0090         rlen = 0;
0091 
0092     ret = dvb_usbv2_generic_rw_locked(d, state->buf, wlen,
0093                       state->buf, rlen);
0094     if (ret)
0095         goto error;
0096 
0097     /* check status */
0098     if (rlen && state->buf[1]) {
0099         dev_err(&intf->dev, "cmd failed %u\n", state->buf[1]);
0100         ret = -EIO;
0101         goto error;
0102     }
0103 
0104     /* read request, copy returned data to return buf */
0105     if (!write)
0106         memcpy(req->data, &state->buf[ACK_HDR_LEN], req->data_len);
0107 error:
0108     mutex_unlock(&d->usb_mutex);
0109 
0110     return ret;
0111 }
0112 
0113 static int af9015_write_reg_i2c(struct dvb_usb_device *d, u8 addr, u16 reg,
0114                 u8 val)
0115 {
0116     struct af9015_state *state = d_to_priv(d);
0117     struct req_t req = {WRITE_I2C, addr, reg, 1, 1, 1, &val};
0118 
0119     if (addr == state->af9013_i2c_addr[0] ||
0120         addr == state->af9013_i2c_addr[1])
0121         req.addr_len = 3;
0122 
0123     return af9015_ctrl_msg(d, &req);
0124 }
0125 
0126 static int af9015_read_reg_i2c(struct dvb_usb_device *d, u8 addr, u16 reg,
0127                    u8 *val)
0128 {
0129     struct af9015_state *state = d_to_priv(d);
0130     struct req_t req = {READ_I2C, addr, reg, 0, 1, 1, val};
0131 
0132     if (addr == state->af9013_i2c_addr[0] ||
0133         addr == state->af9013_i2c_addr[1])
0134         req.addr_len = 3;
0135 
0136     return af9015_ctrl_msg(d, &req);
0137 }
0138 
0139 static int af9015_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
0140                int num)
0141 {
0142     struct dvb_usb_device *d = i2c_get_adapdata(adap);
0143     struct af9015_state *state = d_to_priv(d);
0144     struct usb_interface *intf = d->intf;
0145     int ret;
0146     u16 addr;
0147     u8 mbox, addr_len;
0148     struct req_t req;
0149 
0150     /*
0151      * I2C multiplexing:
0152      * There could be two tuners, both using same I2C address. Demodulator
0153      * I2C-gate is only possibility to select correct tuner.
0154      *
0155      * ...........................................
0156      * . AF9015 integrates AF9013 demodulator    .
0157      * . ____________               ____________ .             ____________
0158      * .|   USB IF   |             |   demod    |.            |   tuner    |
0159      * .|------------|             |------------|.            |------------|
0160      * .|   AF9015   |             |   AF9013   |.            |   MXL5003  |
0161      * .|            |--+--I2C-----|-----/ -----|.----I2C-----|            |
0162      * .|            |  |          | addr 0x1c  |.            |  addr 0x63 |
0163      * .|____________|  |          |____________|.            |____________|
0164      * .................|.........................
0165      *                  |           ____________               ____________
0166      *                  |          |   demod    |             |   tuner    |
0167      *                  |          |------------|             |------------|
0168      *                  |          |   AF9013   |             |   MXL5003  |
0169      *                  +--I2C-----|-----/ -----|-----I2C-----|            |
0170      *                             | addr 0x1d  |             |  addr 0x63 |
0171      *                             |____________|             |____________|
0172      */
0173 
0174     if (msg[0].len == 0 || msg[0].flags & I2C_M_RD) {
0175         addr = 0x0000;
0176         mbox = 0;
0177         addr_len = 0;
0178     } else if (msg[0].len == 1) {
0179         addr = msg[0].buf[0];
0180         mbox = 0;
0181         addr_len = 1;
0182     } else if (msg[0].len == 2) {
0183         addr = msg[0].buf[0] << 8 | msg[0].buf[1] << 0;
0184         mbox = 0;
0185         addr_len = 2;
0186     } else {
0187         addr = msg[0].buf[0] << 8 | msg[0].buf[1] << 0;
0188         mbox = msg[0].buf[2];
0189         addr_len = 3;
0190     }
0191 
0192     if (num == 1 && !(msg[0].flags & I2C_M_RD)) {
0193         /* i2c write */
0194         if (msg[0].len > 21) {
0195             ret = -EOPNOTSUPP;
0196             goto err;
0197         }
0198         if (msg[0].addr == state->af9013_i2c_addr[0])
0199             req.cmd = WRITE_MEMORY;
0200         else
0201             req.cmd = WRITE_I2C;
0202         req.i2c_addr = msg[0].addr;
0203         req.addr = addr;
0204         req.mbox = mbox;
0205         req.addr_len = addr_len;
0206         req.data_len = msg[0].len - addr_len;
0207         req.data = &msg[0].buf[addr_len];
0208         ret = af9015_ctrl_msg(d, &req);
0209     } else if (num == 2 && !(msg[0].flags & I2C_M_RD) &&
0210            (msg[1].flags & I2C_M_RD)) {
0211         /* i2c write + read */
0212         if (msg[0].len > 3 || msg[1].len > 61) {
0213             ret = -EOPNOTSUPP;
0214             goto err;
0215         }
0216         if (msg[0].addr == state->af9013_i2c_addr[0])
0217             req.cmd = READ_MEMORY;
0218         else
0219             req.cmd = READ_I2C;
0220         req.i2c_addr = msg[0].addr;
0221         req.addr = addr;
0222         req.mbox = mbox;
0223         req.addr_len = addr_len;
0224         req.data_len = msg[1].len;
0225         req.data = &msg[1].buf[0];
0226         ret = af9015_ctrl_msg(d, &req);
0227     } else if (num == 1 && (msg[0].flags & I2C_M_RD)) {
0228         /* i2c read */
0229         if (msg[0].len > 61) {
0230             ret = -EOPNOTSUPP;
0231             goto err;
0232         }
0233         if (msg[0].addr == state->af9013_i2c_addr[0]) {
0234             ret = -EINVAL;
0235             goto err;
0236         }
0237         req.cmd = READ_I2C;
0238         req.i2c_addr = msg[0].addr;
0239         req.addr = addr;
0240         req.mbox = mbox;
0241         req.addr_len = addr_len;
0242         req.data_len = msg[0].len;
0243         req.data = &msg[0].buf[0];
0244         ret = af9015_ctrl_msg(d, &req);
0245     } else {
0246         ret = -EOPNOTSUPP;
0247         dev_dbg(&intf->dev, "unknown msg, num %u\n", num);
0248     }
0249     if (ret)
0250         goto err;
0251 
0252     return num;
0253 err:
0254     dev_dbg(&intf->dev, "failed %d\n", ret);
0255     return ret;
0256 }
0257 
0258 static u32 af9015_i2c_func(struct i2c_adapter *adapter)
0259 {
0260     return I2C_FUNC_I2C;
0261 }
0262 
0263 static struct i2c_algorithm af9015_i2c_algo = {
0264     .master_xfer = af9015_i2c_xfer,
0265     .functionality = af9015_i2c_func,
0266 };
0267 
0268 static int af9015_identify_state(struct dvb_usb_device *d, const char **name)
0269 {
0270     struct usb_interface *intf = d->intf;
0271     int ret;
0272     u8 reply;
0273     struct req_t req = {GET_CONFIG, 0, 0, 0, 0, 1, &reply};
0274 
0275     ret = af9015_ctrl_msg(d, &req);
0276     if (ret)
0277         return ret;
0278 
0279     dev_dbg(&intf->dev, "reply %02x\n", reply);
0280 
0281     if (reply == 0x02)
0282         ret = WARM;
0283     else
0284         ret = COLD;
0285 
0286     return ret;
0287 }
0288 
0289 static int af9015_download_firmware(struct dvb_usb_device *d,
0290                     const struct firmware *firmware)
0291 {
0292     struct af9015_state *state = d_to_priv(d);
0293     struct usb_interface *intf = d->intf;
0294     int ret, i, rem;
0295     struct req_t req = {DOWNLOAD_FIRMWARE, 0, 0, 0, 0, 0, NULL};
0296     u16 checksum;
0297 
0298     dev_dbg(&intf->dev, "\n");
0299 
0300     /* Calc checksum, we need it when copy firmware to slave demod */
0301     for (i = 0, checksum = 0; i < firmware->size; i++)
0302         checksum += firmware->data[i];
0303 
0304     state->firmware_size = firmware->size;
0305     state->firmware_checksum = checksum;
0306 
0307     #define LEN_MAX (BUF_LEN - REQ_HDR_LEN) /* Max payload size */
0308     for (rem = firmware->size; rem > 0; rem -= LEN_MAX) {
0309         req.data_len = min(LEN_MAX, rem);
0310         req.data = (u8 *)&firmware->data[firmware->size - rem];
0311         req.addr = 0x5100 + firmware->size - rem;
0312         ret = af9015_ctrl_msg(d, &req);
0313         if (ret) {
0314             dev_err(&intf->dev, "firmware download failed %d\n",
0315                 ret);
0316             goto err;
0317         }
0318     }
0319 
0320     req.cmd = BOOT;
0321     req.data_len = 0;
0322     ret = af9015_ctrl_msg(d, &req);
0323     if (ret) {
0324         dev_err(&intf->dev, "firmware boot failed %d\n", ret);
0325         goto err;
0326     }
0327 
0328     return 0;
0329 err:
0330     dev_dbg(&intf->dev, "failed %d\n", ret);
0331     return ret;
0332 }
0333 
0334 #define AF9015_EEPROM_SIZE 256
0335 /* 2^31 + 2^29 - 2^25 + 2^22 - 2^19 - 2^16 + 1 */
0336 #define GOLDEN_RATIO_PRIME_32 0x9e370001UL
0337 
0338 /* hash (and dump) eeprom */
0339 static int af9015_eeprom_hash(struct dvb_usb_device *d)
0340 {
0341     struct af9015_state *state = d_to_priv(d);
0342     struct usb_interface *intf = d->intf;
0343     int ret, i;
0344     u8 buf[AF9015_EEPROM_SIZE];
0345     struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, NULL};
0346 
0347     /* read eeprom */
0348     for (i = 0; i < AF9015_EEPROM_SIZE; i++) {
0349         req.addr = i;
0350         req.data = &buf[i];
0351         ret = af9015_ctrl_msg(d, &req);
0352         if (ret < 0)
0353             goto err;
0354     }
0355 
0356     /* calculate checksum */
0357     for (i = 0; i < AF9015_EEPROM_SIZE / sizeof(u32); i++) {
0358         state->eeprom_sum *= GOLDEN_RATIO_PRIME_32;
0359         state->eeprom_sum += le32_to_cpu(((__le32 *)buf)[i]);
0360     }
0361 
0362     for (i = 0; i < AF9015_EEPROM_SIZE; i += 16)
0363         dev_dbg(&intf->dev, "%*ph\n", 16, buf + i);
0364 
0365     dev_dbg(&intf->dev, "eeprom sum %.8x\n", state->eeprom_sum);
0366     return 0;
0367 err:
0368     dev_dbg(&intf->dev, "failed %d\n", ret);
0369     return ret;
0370 }
0371 
0372 static int af9015_read_config(struct dvb_usb_device *d)
0373 {
0374     struct af9015_state *state = d_to_priv(d);
0375     struct usb_interface *intf = d->intf;
0376     int ret;
0377     u8 val, i, offset = 0;
0378     struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, &val};
0379 
0380     dev_dbg(&intf->dev, "\n");
0381 
0382     /* IR remote controller */
0383     req.addr = AF9015_EEPROM_IR_MODE;
0384     /* first message will timeout often due to possible hw bug */
0385     for (i = 0; i < 4; i++) {
0386         ret = af9015_ctrl_msg(d, &req);
0387         if (!ret)
0388             break;
0389     }
0390     if (ret)
0391         goto error;
0392 
0393     ret = af9015_eeprom_hash(d);
0394     if (ret)
0395         goto error;
0396 
0397     state->ir_mode = val;
0398     dev_dbg(&intf->dev, "ir mode %02x\n", val);
0399 
0400     /* TS mode - one or two receivers */
0401     req.addr = AF9015_EEPROM_TS_MODE;
0402     ret = af9015_ctrl_msg(d, &req);
0403     if (ret)
0404         goto error;
0405 
0406     state->dual_mode = val;
0407     dev_dbg(&intf->dev, "ts mode %02x\n", state->dual_mode);
0408 
0409     state->af9013_i2c_addr[0] = AF9015_I2C_DEMOD;
0410 
0411     if (state->dual_mode) {
0412         /* read 2nd demodulator I2C address */
0413         req.addr = AF9015_EEPROM_DEMOD2_I2C;
0414         ret = af9015_ctrl_msg(d, &req);
0415         if (ret)
0416             goto error;
0417 
0418         state->af9013_i2c_addr[1] = val >> 1;
0419     }
0420 
0421     for (i = 0; i < state->dual_mode + 1; i++) {
0422         if (i == 1)
0423             offset = AF9015_EEPROM_OFFSET;
0424         /* xtal */
0425         req.addr = AF9015_EEPROM_XTAL_TYPE1 + offset;
0426         ret = af9015_ctrl_msg(d, &req);
0427         if (ret)
0428             goto error;
0429         switch (val) {
0430         case 0:
0431             state->af9013_pdata[i].clk = 28800000;
0432             break;
0433         case 1:
0434             state->af9013_pdata[i].clk = 20480000;
0435             break;
0436         case 2:
0437             state->af9013_pdata[i].clk = 28000000;
0438             break;
0439         case 3:
0440             state->af9013_pdata[i].clk = 25000000;
0441             break;
0442         }
0443         dev_dbg(&intf->dev, "[%d] xtal %02x, clk %u\n",
0444             i, val, state->af9013_pdata[i].clk);
0445 
0446         /* IF frequency */
0447         req.addr = AF9015_EEPROM_IF1H + offset;
0448         ret = af9015_ctrl_msg(d, &req);
0449         if (ret)
0450             goto error;
0451 
0452         state->af9013_pdata[i].if_frequency = val << 8;
0453 
0454         req.addr = AF9015_EEPROM_IF1L + offset;
0455         ret = af9015_ctrl_msg(d, &req);
0456         if (ret)
0457             goto error;
0458 
0459         state->af9013_pdata[i].if_frequency += val;
0460         state->af9013_pdata[i].if_frequency *= 1000;
0461         dev_dbg(&intf->dev, "[%d] if frequency %u\n",
0462             i, state->af9013_pdata[i].if_frequency);
0463 
0464         /* MT2060 IF1 */
0465         req.addr = AF9015_EEPROM_MT2060_IF1H  + offset;
0466         ret = af9015_ctrl_msg(d, &req);
0467         if (ret)
0468             goto error;
0469         state->mt2060_if1[i] = val << 8;
0470         req.addr = AF9015_EEPROM_MT2060_IF1L + offset;
0471         ret = af9015_ctrl_msg(d, &req);
0472         if (ret)
0473             goto error;
0474         state->mt2060_if1[i] += val;
0475         dev_dbg(&intf->dev, "[%d] MT2060 IF1 %u\n",
0476             i, state->mt2060_if1[i]);
0477 
0478         /* tuner */
0479         req.addr =  AF9015_EEPROM_TUNER_ID1 + offset;
0480         ret = af9015_ctrl_msg(d, &req);
0481         if (ret)
0482             goto error;
0483         switch (val) {
0484         case AF9013_TUNER_ENV77H11D5:
0485         case AF9013_TUNER_MT2060:
0486         case AF9013_TUNER_QT1010:
0487         case AF9013_TUNER_UNKNOWN:
0488         case AF9013_TUNER_MT2060_2:
0489         case AF9013_TUNER_TDA18271:
0490         case AF9013_TUNER_QT1010A:
0491         case AF9013_TUNER_TDA18218:
0492             state->af9013_pdata[i].spec_inv = 1;
0493             break;
0494         case AF9013_TUNER_MXL5003D:
0495         case AF9013_TUNER_MXL5005D:
0496         case AF9013_TUNER_MXL5005R:
0497         case AF9013_TUNER_MXL5007T:
0498             state->af9013_pdata[i].spec_inv = 0;
0499             break;
0500         case AF9013_TUNER_MC44S803:
0501             state->af9013_pdata[i].gpio[1] = AF9013_GPIO_LO;
0502             state->af9013_pdata[i].spec_inv = 1;
0503             break;
0504         default:
0505             dev_err(&intf->dev,
0506                 "tuner id %02x not supported, please report!\n",
0507                 val);
0508             return -ENODEV;
0509         }
0510 
0511         state->af9013_pdata[i].tuner = val;
0512         dev_dbg(&intf->dev, "[%d] tuner id %02x\n", i, val);
0513     }
0514 
0515 error:
0516     if (ret)
0517         dev_err(&intf->dev, "eeprom read failed %d\n", ret);
0518 
0519     /*
0520      * AverMedia AVerTV Volar Black HD (A850) device have bad EEPROM
0521      * content :-( Override some wrong values here. Ditto for the
0522      * AVerTV Red HD+ (A850T) device.
0523      */
0524     if (le16_to_cpu(d->udev->descriptor.idVendor) == USB_VID_AVERMEDIA &&
0525         ((le16_to_cpu(d->udev->descriptor.idProduct) == USB_PID_AVERMEDIA_A850) ||
0526         (le16_to_cpu(d->udev->descriptor.idProduct) == USB_PID_AVERMEDIA_A850T))) {
0527         dev_dbg(&intf->dev, "AverMedia A850: overriding config\n");
0528         /* disable dual mode */
0529         state->dual_mode = 0;
0530 
0531         /* set correct IF */
0532         state->af9013_pdata[0].if_frequency = 4570000;
0533     }
0534 
0535     return ret;
0536 }
0537 
0538 static int af9015_get_stream_config(struct dvb_frontend *fe, u8 *ts_type,
0539                     struct usb_data_stream_properties *stream)
0540 {
0541     struct dvb_usb_device *d = fe_to_d(fe);
0542     struct usb_interface *intf = d->intf;
0543 
0544     dev_dbg(&intf->dev, "adap %u\n", fe_to_adap(fe)->id);
0545 
0546     if (d->udev->speed == USB_SPEED_FULL)
0547         stream->u.bulk.buffersize = 5 * 188;
0548 
0549     return 0;
0550 }
0551 
0552 static int af9015_streaming_ctrl(struct dvb_frontend *fe, int onoff)
0553 {
0554     struct dvb_usb_device *d = fe_to_d(fe);
0555     struct af9015_state *state = d_to_priv(d);
0556     struct usb_interface *intf = d->intf;
0557     int ret;
0558     unsigned int utmp1, utmp2, reg1, reg2;
0559     u8 buf[2];
0560     const unsigned int adap_id = fe_to_adap(fe)->id;
0561 
0562     dev_dbg(&intf->dev, "adap id %d, onoff %d\n", adap_id, onoff);
0563 
0564     if (!state->usb_ts_if_configured[adap_id]) {
0565         dev_dbg(&intf->dev, "set usb and ts interface\n");
0566 
0567         /* USB IF stream settings */
0568         utmp1 = (d->udev->speed == USB_SPEED_FULL ? 5 : 87) * 188 / 4;
0569         utmp2 = (d->udev->speed == USB_SPEED_FULL ? 64 : 512) / 4;
0570 
0571         buf[0] = (utmp1 >> 0) & 0xff;
0572         buf[1] = (utmp1 >> 8) & 0xff;
0573         if (adap_id == 0) {
0574             /* 1st USB IF (EP4) stream settings */
0575             reg1 = 0xdd88;
0576             reg2 = 0xdd0c;
0577         } else {
0578             /* 2nd USB IF (EP5) stream settings */
0579             reg1 = 0xdd8a;
0580             reg2 = 0xdd0d;
0581         }
0582         ret = regmap_bulk_write(state->regmap, reg1, buf, 2);
0583         if (ret)
0584             goto err;
0585         ret = regmap_write(state->regmap, reg2, utmp2);
0586         if (ret)
0587             goto err;
0588 
0589         /* TS IF settings */
0590         if (state->dual_mode) {
0591             utmp1 = 0x01;
0592             utmp2 = 0x10;
0593         } else {
0594             utmp1 = 0x00;
0595             utmp2 = 0x00;
0596         }
0597         ret = regmap_update_bits(state->regmap, 0xd50b, 0x01, utmp1);
0598         if (ret)
0599             goto err;
0600         ret = regmap_update_bits(state->regmap, 0xd520, 0x10, utmp2);
0601         if (ret)
0602             goto err;
0603 
0604         state->usb_ts_if_configured[adap_id] = true;
0605     }
0606 
0607     if (adap_id == 0 && onoff) {
0608         /* Adapter 0 stream on. EP4: clear NAK, enable, clear reset */
0609         ret = regmap_update_bits(state->regmap, 0xdd13, 0x20, 0x00);
0610         if (ret)
0611             goto err;
0612         ret = regmap_update_bits(state->regmap, 0xdd11, 0x20, 0x20);
0613         if (ret)
0614             goto err;
0615         ret = regmap_update_bits(state->regmap, 0xd507, 0x04, 0x00);
0616         if (ret)
0617             goto err;
0618     } else if (adap_id == 1 && onoff) {
0619         /* Adapter 1 stream on. EP5: clear NAK, enable, clear reset */
0620         ret = regmap_update_bits(state->regmap, 0xdd13, 0x40, 0x00);
0621         if (ret)
0622             goto err;
0623         ret = regmap_update_bits(state->regmap, 0xdd11, 0x40, 0x40);
0624         if (ret)
0625             goto err;
0626         ret = regmap_update_bits(state->regmap, 0xd50b, 0x02, 0x00);
0627         if (ret)
0628             goto err;
0629     } else if (adap_id == 0 && !onoff) {
0630         /* Adapter 0 stream off. EP4: set reset, disable, set NAK */
0631         ret = regmap_update_bits(state->regmap, 0xd507, 0x04, 0x04);
0632         if (ret)
0633             goto err;
0634         ret = regmap_update_bits(state->regmap, 0xdd11, 0x20, 0x00);
0635         if (ret)
0636             goto err;
0637         ret = regmap_update_bits(state->regmap, 0xdd13, 0x20, 0x20);
0638         if (ret)
0639             goto err;
0640     } else if (adap_id == 1 && !onoff) {
0641         /* Adapter 1 stream off. EP5: set reset, disable, set NAK */
0642         ret = regmap_update_bits(state->regmap, 0xd50b, 0x02, 0x02);
0643         if (ret)
0644             goto err;
0645         ret = regmap_update_bits(state->regmap, 0xdd11, 0x40, 0x00);
0646         if (ret)
0647             goto err;
0648         ret = regmap_update_bits(state->regmap, 0xdd13, 0x40, 0x40);
0649         if (ret)
0650             goto err;
0651     }
0652 
0653     return 0;
0654 err:
0655     dev_dbg(&intf->dev, "failed %d\n", ret);
0656     return ret;
0657 }
0658 
0659 static int af9015_get_adapter_count(struct dvb_usb_device *d)
0660 {
0661     struct af9015_state *state = d_to_priv(d);
0662 
0663     return state->dual_mode + 1;
0664 }
0665 
0666 /* override demod callbacks for resource locking */
0667 static int af9015_af9013_set_frontend(struct dvb_frontend *fe)
0668 {
0669     int ret;
0670     struct af9015_state *state = fe_to_priv(fe);
0671 
0672     if (mutex_lock_interruptible(&state->fe_mutex))
0673         return -EAGAIN;
0674 
0675     ret = state->set_frontend[fe_to_adap(fe)->id](fe);
0676 
0677     mutex_unlock(&state->fe_mutex);
0678 
0679     return ret;
0680 }
0681 
0682 /* override demod callbacks for resource locking */
0683 static int af9015_af9013_read_status(struct dvb_frontend *fe,
0684                      enum fe_status *status)
0685 {
0686     int ret;
0687     struct af9015_state *state = fe_to_priv(fe);
0688 
0689     if (mutex_lock_interruptible(&state->fe_mutex))
0690         return -EAGAIN;
0691 
0692     ret = state->read_status[fe_to_adap(fe)->id](fe, status);
0693 
0694     mutex_unlock(&state->fe_mutex);
0695 
0696     return ret;
0697 }
0698 
0699 /* override demod callbacks for resource locking */
0700 static int af9015_af9013_init(struct dvb_frontend *fe)
0701 {
0702     int ret;
0703     struct af9015_state *state = fe_to_priv(fe);
0704 
0705     if (mutex_lock_interruptible(&state->fe_mutex))
0706         return -EAGAIN;
0707 
0708     ret = state->init[fe_to_adap(fe)->id](fe);
0709 
0710     mutex_unlock(&state->fe_mutex);
0711 
0712     return ret;
0713 }
0714 
0715 /* override demod callbacks for resource locking */
0716 static int af9015_af9013_sleep(struct dvb_frontend *fe)
0717 {
0718     int ret;
0719     struct af9015_state *state = fe_to_priv(fe);
0720 
0721     if (mutex_lock_interruptible(&state->fe_mutex))
0722         return -EAGAIN;
0723 
0724     ret = state->sleep[fe_to_adap(fe)->id](fe);
0725 
0726     mutex_unlock(&state->fe_mutex);
0727 
0728     return ret;
0729 }
0730 
0731 /* override tuner callbacks for resource locking */
0732 static int af9015_tuner_init(struct dvb_frontend *fe)
0733 {
0734     int ret;
0735     struct af9015_state *state = fe_to_priv(fe);
0736 
0737     if (mutex_lock_interruptible(&state->fe_mutex))
0738         return -EAGAIN;
0739 
0740     ret = state->tuner_init[fe_to_adap(fe)->id](fe);
0741 
0742     mutex_unlock(&state->fe_mutex);
0743 
0744     return ret;
0745 }
0746 
0747 /* override tuner callbacks for resource locking */
0748 static int af9015_tuner_sleep(struct dvb_frontend *fe)
0749 {
0750     int ret;
0751     struct af9015_state *state = fe_to_priv(fe);
0752 
0753     if (mutex_lock_interruptible(&state->fe_mutex))
0754         return -EAGAIN;
0755 
0756     ret = state->tuner_sleep[fe_to_adap(fe)->id](fe);
0757 
0758     mutex_unlock(&state->fe_mutex);
0759 
0760     return ret;
0761 }
0762 
0763 static int af9015_copy_firmware(struct dvb_usb_device *d)
0764 {
0765     struct af9015_state *state = d_to_priv(d);
0766     struct usb_interface *intf = d->intf;
0767     int ret;
0768     unsigned long timeout;
0769     u8 val, firmware_info[4];
0770     struct req_t req = {COPY_FIRMWARE, 0, 0x5100, 0, 0, 4, firmware_info};
0771 
0772     dev_dbg(&intf->dev, "\n");
0773 
0774     firmware_info[0] = (state->firmware_size >> 8) & 0xff;
0775     firmware_info[1] = (state->firmware_size >> 0) & 0xff;
0776     firmware_info[2] = (state->firmware_checksum >> 8) & 0xff;
0777     firmware_info[3] = (state->firmware_checksum >> 0) & 0xff;
0778 
0779     /* Check whether firmware is already running */
0780     ret = af9015_read_reg_i2c(d, state->af9013_i2c_addr[1], 0x98be, &val);
0781     if (ret)
0782         goto err;
0783 
0784     dev_dbg(&intf->dev, "firmware status %02x\n", val);
0785 
0786     if (val == 0x0c)
0787         return 0;
0788 
0789     /* Set i2c clock to 625kHz to speed up firmware copy */
0790     ret = regmap_write(state->regmap, 0xd416, 0x04);
0791     if (ret)
0792         goto err;
0793 
0794     /* Copy firmware from master demod to slave demod */
0795     ret = af9015_ctrl_msg(d, &req);
0796     if (ret) {
0797         dev_err(&intf->dev, "firmware copy cmd failed %d\n", ret);
0798         goto err;
0799     }
0800 
0801     /* Set i2c clock to 125kHz */
0802     ret = regmap_write(state->regmap, 0xd416, 0x14);
0803     if (ret)
0804         goto err;
0805 
0806     /* Boot firmware */
0807     ret = af9015_write_reg_i2c(d, state->af9013_i2c_addr[1], 0xe205, 0x01);
0808     if (ret)
0809         goto err;
0810 
0811     /* Poll firmware ready */
0812     for (val = 0x00, timeout = jiffies + msecs_to_jiffies(1000);
0813          !time_after(jiffies, timeout) && val != 0x0c && val != 0x04;) {
0814         msleep(20);
0815 
0816         /* Check firmware status. 0c=OK, 04=fail */
0817         ret = af9015_read_reg_i2c(d, state->af9013_i2c_addr[1],
0818                       0x98be, &val);
0819         if (ret)
0820             goto err;
0821 
0822         dev_dbg(&intf->dev, "firmware status %02x\n", val);
0823     }
0824 
0825     dev_dbg(&intf->dev, "firmware boot took %u ms\n",
0826         jiffies_to_msecs(jiffies) - (jiffies_to_msecs(timeout) - 1000));
0827 
0828     if (val == 0x04) {
0829         ret = -ENODEV;
0830         dev_err(&intf->dev, "firmware did not run\n");
0831         goto err;
0832     } else if (val != 0x0c) {
0833         ret = -ETIMEDOUT;
0834         dev_err(&intf->dev, "firmware boot timeout\n");
0835         goto err;
0836     }
0837 
0838     return 0;
0839 err:
0840     dev_dbg(&intf->dev, "failed %d\n", ret);
0841     return ret;
0842 }
0843 
0844 static int af9015_af9013_frontend_attach(struct dvb_usb_adapter *adap)
0845 {
0846     struct af9015_state *state = adap_to_priv(adap);
0847     struct dvb_usb_device *d = adap_to_d(adap);
0848     struct usb_interface *intf = d->intf;
0849     struct i2c_client *client;
0850     int ret;
0851 
0852     dev_dbg(&intf->dev, "adap id %u\n", adap->id);
0853 
0854     if (adap->id == 0) {
0855         state->af9013_pdata[0].ts_mode = AF9013_TS_MODE_USB;
0856         memcpy(state->af9013_pdata[0].api_version, "\x0\x1\x9\x0", 4);
0857         state->af9013_pdata[0].gpio[0] = AF9013_GPIO_HI;
0858         state->af9013_pdata[0].gpio[3] = AF9013_GPIO_TUNER_ON;
0859     } else if (adap->id == 1) {
0860         state->af9013_pdata[1].ts_mode = AF9013_TS_MODE_SERIAL;
0861         state->af9013_pdata[1].ts_output_pin = 7;
0862         memcpy(state->af9013_pdata[1].api_version, "\x0\x1\x9\x0", 4);
0863         state->af9013_pdata[1].gpio[0] = AF9013_GPIO_TUNER_ON;
0864         state->af9013_pdata[1].gpio[1] = AF9013_GPIO_LO;
0865 
0866         /* copy firmware to 2nd demodulator */
0867         if (state->dual_mode) {
0868             /* Wait 2nd demodulator ready */
0869             msleep(100);
0870 
0871             ret = af9015_copy_firmware(adap_to_d(adap));
0872             if (ret) {
0873                 dev_err(&intf->dev,
0874                     "firmware copy to 2nd frontend failed, will disable it\n");
0875                 state->dual_mode = 0;
0876                 goto err;
0877             }
0878         } else {
0879             ret = -ENODEV;
0880             goto err;
0881         }
0882     }
0883 
0884     /* Add I2C demod */
0885     client = dvb_module_probe("af9013", NULL, &d->i2c_adap,
0886                   state->af9013_i2c_addr[adap->id],
0887                   &state->af9013_pdata[adap->id]);
0888     if (!client) {
0889         ret = -ENODEV;
0890         goto err;
0891     }
0892     adap->fe[0] = state->af9013_pdata[adap->id].get_dvb_frontend(client);
0893     state->demod_i2c_client[adap->id] = client;
0894 
0895     /*
0896      * AF9015 firmware does not like if it gets interrupted by I2C adapter
0897      * request on some critical phases. During normal operation I2C adapter
0898      * is used only 2nd demodulator and tuner on dual tuner devices.
0899      * Override demodulator callbacks and use mutex for limit access to
0900      * those "critical" paths to keep AF9015 happy.
0901      */
0902     if (adap->fe[0]) {
0903         state->set_frontend[adap->id] = adap->fe[0]->ops.set_frontend;
0904         adap->fe[0]->ops.set_frontend = af9015_af9013_set_frontend;
0905         state->read_status[adap->id] = adap->fe[0]->ops.read_status;
0906         adap->fe[0]->ops.read_status = af9015_af9013_read_status;
0907         state->init[adap->id] = adap->fe[0]->ops.init;
0908         adap->fe[0]->ops.init = af9015_af9013_init;
0909         state->sleep[adap->id] = adap->fe[0]->ops.sleep;
0910         adap->fe[0]->ops.sleep = af9015_af9013_sleep;
0911     }
0912 
0913     return 0;
0914 err:
0915     dev_dbg(&intf->dev, "failed %d\n", ret);
0916     return ret;
0917 }
0918 
0919 static int af9015_frontend_detach(struct dvb_usb_adapter *adap)
0920 {
0921     struct af9015_state *state = adap_to_priv(adap);
0922     struct dvb_usb_device *d = adap_to_d(adap);
0923     struct usb_interface *intf = d->intf;
0924     struct i2c_client *client;
0925 
0926     dev_dbg(&intf->dev, "adap id %u\n", adap->id);
0927 
0928     /* Remove I2C demod */
0929     client = state->demod_i2c_client[adap->id];
0930     dvb_module_release(client);
0931 
0932     return 0;
0933 }
0934 
0935 static struct mt2060_config af9015_mt2060_config = {
0936     .i2c_address = 0x60,
0937     .clock_out = 0,
0938 };
0939 
0940 static struct qt1010_config af9015_qt1010_config = {
0941     .i2c_address = 0x62,
0942 };
0943 
0944 static struct tda18271_config af9015_tda18271_config = {
0945     .gate = TDA18271_GATE_DIGITAL,
0946     .small_i2c = TDA18271_16_BYTE_CHUNK_INIT,
0947 };
0948 
0949 static struct mxl5005s_config af9015_mxl5003_config = {
0950     .i2c_address     = 0x63,
0951     .if_freq         = IF_FREQ_4570000HZ,
0952     .xtal_freq       = CRYSTAL_FREQ_16000000HZ,
0953     .agc_mode        = MXL_SINGLE_AGC,
0954     .tracking_filter = MXL_TF_DEFAULT,
0955     .rssi_enable     = MXL_RSSI_ENABLE,
0956     .cap_select      = MXL_CAP_SEL_ENABLE,
0957     .div_out         = MXL_DIV_OUT_4,
0958     .clock_out       = MXL_CLOCK_OUT_DISABLE,
0959     .output_load     = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
0960     .top         = MXL5005S_TOP_25P2,
0961     .mod_mode        = MXL_DIGITAL_MODE,
0962     .if_mode         = MXL_ZERO_IF,
0963     .AgcMasterByte   = 0x00,
0964 };
0965 
0966 static struct mxl5005s_config af9015_mxl5005_config = {
0967     .i2c_address     = 0x63,
0968     .if_freq         = IF_FREQ_4570000HZ,
0969     .xtal_freq       = CRYSTAL_FREQ_16000000HZ,
0970     .agc_mode        = MXL_SINGLE_AGC,
0971     .tracking_filter = MXL_TF_OFF,
0972     .rssi_enable     = MXL_RSSI_ENABLE,
0973     .cap_select      = MXL_CAP_SEL_ENABLE,
0974     .div_out         = MXL_DIV_OUT_4,
0975     .clock_out       = MXL_CLOCK_OUT_DISABLE,
0976     .output_load     = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
0977     .top         = MXL5005S_TOP_25P2,
0978     .mod_mode        = MXL_DIGITAL_MODE,
0979     .if_mode         = MXL_ZERO_IF,
0980     .AgcMasterByte   = 0x00,
0981 };
0982 
0983 static struct mc44s803_config af9015_mc44s803_config = {
0984     .i2c_address = 0x60,
0985     .dig_out = 1,
0986 };
0987 
0988 static struct tda18218_config af9015_tda18218_config = {
0989     .i2c_address = 0x60,
0990     .i2c_wr_max = 21, /* max wr bytes AF9015 I2C adap can handle at once */
0991 };
0992 
0993 static struct mxl5007t_config af9015_mxl5007t_config = {
0994     .xtal_freq_hz = MxL_XTAL_24_MHZ,
0995     .if_freq_hz = MxL_IF_4_57_MHZ,
0996 };
0997 
0998 static int af9015_tuner_attach(struct dvb_usb_adapter *adap)
0999 {
1000     struct dvb_usb_device *d = adap_to_d(adap);
1001     struct af9015_state *state = d_to_priv(d);
1002     struct usb_interface *intf = d->intf;
1003     struct i2c_client *client;
1004     struct i2c_adapter *adapter;
1005     int ret;
1006 
1007     dev_dbg(&intf->dev, "adap id %u\n", adap->id);
1008 
1009     client = state->demod_i2c_client[adap->id];
1010     adapter = state->af9013_pdata[adap->id].get_i2c_adapter(client);
1011 
1012     switch (state->af9013_pdata[adap->id].tuner) {
1013     case AF9013_TUNER_MT2060:
1014     case AF9013_TUNER_MT2060_2:
1015         ret = dvb_attach(mt2060_attach, adap->fe[0], adapter,
1016                  &af9015_mt2060_config,
1017                  state->mt2060_if1[adap->id]) == NULL ? -ENODEV : 0;
1018         break;
1019     case AF9013_TUNER_QT1010:
1020     case AF9013_TUNER_QT1010A:
1021         ret = dvb_attach(qt1010_attach, adap->fe[0], adapter,
1022                  &af9015_qt1010_config) == NULL ? -ENODEV : 0;
1023         break;
1024     case AF9013_TUNER_TDA18271:
1025         ret = dvb_attach(tda18271_attach, adap->fe[0], 0x60, adapter,
1026                  &af9015_tda18271_config) == NULL ? -ENODEV : 0;
1027         break;
1028     case AF9013_TUNER_TDA18218:
1029         ret = dvb_attach(tda18218_attach, adap->fe[0], adapter,
1030                  &af9015_tda18218_config) == NULL ? -ENODEV : 0;
1031         break;
1032     case AF9013_TUNER_MXL5003D:
1033         ret = dvb_attach(mxl5005s_attach, adap->fe[0], adapter,
1034                  &af9015_mxl5003_config) == NULL ? -ENODEV : 0;
1035         break;
1036     case AF9013_TUNER_MXL5005D:
1037     case AF9013_TUNER_MXL5005R:
1038         ret = dvb_attach(mxl5005s_attach, adap->fe[0], adapter,
1039                  &af9015_mxl5005_config) == NULL ? -ENODEV : 0;
1040         break;
1041     case AF9013_TUNER_ENV77H11D5:
1042         ret = dvb_attach(dvb_pll_attach, adap->fe[0], 0x60, adapter,
1043                  DVB_PLL_TDA665X) == NULL ? -ENODEV : 0;
1044         break;
1045     case AF9013_TUNER_MC44S803:
1046         ret = dvb_attach(mc44s803_attach, adap->fe[0], adapter,
1047                  &af9015_mc44s803_config) == NULL ? -ENODEV : 0;
1048         break;
1049     case AF9013_TUNER_MXL5007T:
1050         ret = dvb_attach(mxl5007t_attach, adap->fe[0], adapter,
1051                  0x60, &af9015_mxl5007t_config) == NULL ? -ENODEV : 0;
1052         break;
1053     case AF9013_TUNER_UNKNOWN:
1054     default:
1055         dev_err(&intf->dev, "unknown tuner, tuner id %02x\n",
1056             state->af9013_pdata[adap->id].tuner);
1057         ret = -ENODEV;
1058     }
1059 
1060     if (adap->fe[0]->ops.tuner_ops.init) {
1061         state->tuner_init[adap->id] =
1062             adap->fe[0]->ops.tuner_ops.init;
1063         adap->fe[0]->ops.tuner_ops.init = af9015_tuner_init;
1064     }
1065 
1066     if (adap->fe[0]->ops.tuner_ops.sleep) {
1067         state->tuner_sleep[adap->id] =
1068             adap->fe[0]->ops.tuner_ops.sleep;
1069         adap->fe[0]->ops.tuner_ops.sleep = af9015_tuner_sleep;
1070     }
1071 
1072     return ret;
1073 }
1074 
1075 static int af9015_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff)
1076 {
1077     struct af9015_state *state = adap_to_priv(adap);
1078     struct af9013_platform_data *pdata = &state->af9013_pdata[adap->id];
1079     int ret;
1080 
1081     mutex_lock(&state->fe_mutex);
1082     ret = pdata->pid_filter_ctrl(adap->fe[0], onoff);
1083     mutex_unlock(&state->fe_mutex);
1084 
1085     return ret;
1086 }
1087 
1088 static int af9015_pid_filter(struct dvb_usb_adapter *adap, int index,
1089                  u16 pid, int onoff)
1090 {
1091     struct af9015_state *state = adap_to_priv(adap);
1092     struct af9013_platform_data *pdata = &state->af9013_pdata[adap->id];
1093     int ret;
1094 
1095     mutex_lock(&state->fe_mutex);
1096     ret = pdata->pid_filter(adap->fe[0], index, pid, onoff);
1097     mutex_unlock(&state->fe_mutex);
1098 
1099     return ret;
1100 }
1101 
1102 static int af9015_init(struct dvb_usb_device *d)
1103 {
1104     struct af9015_state *state = d_to_priv(d);
1105     struct usb_interface *intf = d->intf;
1106     int ret;
1107 
1108     dev_dbg(&intf->dev, "\n");
1109 
1110     mutex_init(&state->fe_mutex);
1111 
1112     /* init RC canary */
1113     ret = regmap_write(state->regmap, 0x98e9, 0xff);
1114     if (ret)
1115         goto error;
1116 
1117 error:
1118     return ret;
1119 }
1120 
1121 #if IS_ENABLED(CONFIG_RC_CORE)
1122 struct af9015_rc_setup {
1123     unsigned int id;
1124     char *rc_codes;
1125 };
1126 
1127 static char *af9015_rc_setup_match(unsigned int id,
1128                    const struct af9015_rc_setup *table)
1129 {
1130     for (; table->rc_codes; table++)
1131         if (table->id == id)
1132             return table->rc_codes;
1133     return NULL;
1134 }
1135 
1136 static const struct af9015_rc_setup af9015_rc_setup_modparam[] = {
1137     { AF9015_REMOTE_A_LINK_DTU_M, RC_MAP_ALINK_DTU_M },
1138     { AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3, RC_MAP_MSI_DIGIVOX_II },
1139     { AF9015_REMOTE_MYGICTV_U718, RC_MAP_TOTAL_MEDIA_IN_HAND },
1140     { AF9015_REMOTE_DIGITTRADE_DVB_T, RC_MAP_DIGITTRADE },
1141     { AF9015_REMOTE_AVERMEDIA_KS, RC_MAP_AVERMEDIA_RM_KS },
1142     { }
1143 };
1144 
1145 static const struct af9015_rc_setup af9015_rc_setup_hashes[] = {
1146     { 0xb8feb708, RC_MAP_MSI_DIGIVOX_II },
1147     { 0xa3703d00, RC_MAP_ALINK_DTU_M },
1148     { 0x9b7dc64e, RC_MAP_TOTAL_MEDIA_IN_HAND }, /* MYGICTV U718 */
1149     { 0x5d49e3db, RC_MAP_DIGITTRADE }, /* LC-Power LC-USB-DVBT */
1150     { }
1151 };
1152 
1153 static int af9015_rc_query(struct dvb_usb_device *d)
1154 {
1155     struct af9015_state *state = d_to_priv(d);
1156     struct usb_interface *intf = d->intf;
1157     int ret;
1158     u8 buf[17];
1159 
1160     /* read registers needed to detect remote controller code */
1161     ret = regmap_bulk_read(state->regmap, 0x98d9, buf, sizeof(buf));
1162     if (ret)
1163         goto error;
1164 
1165     /* If any of these are non-zero, assume invalid data */
1166     if (buf[1] || buf[2] || buf[3]) {
1167         dev_dbg(&intf->dev, "invalid data\n");
1168         return ret;
1169     }
1170 
1171     /* Check for repeat of previous code */
1172     if ((state->rc_repeat != buf[6] || buf[0]) &&
1173         !memcmp(&buf[12], state->rc_last, 4)) {
1174         dev_dbg(&intf->dev, "key repeated\n");
1175         rc_repeat(d->rc_dev);
1176         state->rc_repeat = buf[6];
1177         return ret;
1178     }
1179 
1180     /* Only process key if canary killed */
1181     if (buf[16] != 0xff && buf[0] != 0x01) {
1182         enum rc_proto proto;
1183 
1184         dev_dbg(&intf->dev, "key pressed %*ph\n", 4, buf + 12);
1185 
1186         /* Reset the canary */
1187         ret = regmap_write(state->regmap, 0x98e9, 0xff);
1188         if (ret)
1189             goto error;
1190 
1191         /* Remember this key */
1192         memcpy(state->rc_last, &buf[12], 4);
1193         if (buf[14] == (u8)~buf[15]) {
1194             if (buf[12] == (u8)~buf[13]) {
1195                 /* NEC */
1196                 state->rc_keycode = RC_SCANCODE_NEC(buf[12],
1197                                     buf[14]);
1198                 proto = RC_PROTO_NEC;
1199             } else {
1200                 /* NEC extended*/
1201                 state->rc_keycode = RC_SCANCODE_NECX(buf[12] << 8 |
1202                                      buf[13],
1203                                      buf[14]);
1204                 proto = RC_PROTO_NECX;
1205             }
1206         } else {
1207             /* 32 bit NEC */
1208             state->rc_keycode = RC_SCANCODE_NEC32(buf[12] << 24 |
1209                                   buf[13] << 16 |
1210                                   buf[14] << 8  |
1211                                   buf[15]);
1212             proto = RC_PROTO_NEC32;
1213         }
1214         rc_keydown(d->rc_dev, proto, state->rc_keycode, 0);
1215     } else {
1216         dev_dbg(&intf->dev, "no key press\n");
1217         /* Invalidate last keypress */
1218         /* Not really needed, but helps with debug */
1219         state->rc_last[2] = state->rc_last[3];
1220     }
1221 
1222     state->rc_repeat = buf[6];
1223     state->rc_failed = false;
1224 
1225 error:
1226     if (ret) {
1227         dev_warn(&intf->dev, "rc query failed %d\n", ret);
1228 
1229         /* allow random errors as dvb-usb will stop polling on error */
1230         if (!state->rc_failed)
1231             ret = 0;
1232 
1233         state->rc_failed = true;
1234     }
1235 
1236     return ret;
1237 }
1238 
1239 static int af9015_get_rc_config(struct dvb_usb_device *d, struct dvb_usb_rc *rc)
1240 {
1241     struct af9015_state *state = d_to_priv(d);
1242     u16 vid = le16_to_cpu(d->udev->descriptor.idVendor);
1243 
1244     if (state->ir_mode == AF9015_IR_MODE_DISABLED)
1245         return 0;
1246 
1247     /* try to load remote based module param */
1248     if (!rc->map_name)
1249         rc->map_name = af9015_rc_setup_match(dvb_usb_af9015_remote,
1250                              af9015_rc_setup_modparam);
1251 
1252     /* try to load remote based eeprom hash */
1253     if (!rc->map_name)
1254         rc->map_name = af9015_rc_setup_match(state->eeprom_sum,
1255                              af9015_rc_setup_hashes);
1256 
1257     /* try to load remote based USB iManufacturer string */
1258     if (!rc->map_name && vid == USB_VID_AFATECH) {
1259         /*
1260          * Check USB manufacturer and product strings and try
1261          * to determine correct remote in case of chip vendor
1262          * reference IDs are used.
1263          * DO NOT ADD ANYTHING NEW HERE. Use hashes instead.
1264          */
1265         char manufacturer[10];
1266 
1267         memset(manufacturer, 0, sizeof(manufacturer));
1268         usb_string(d->udev, d->udev->descriptor.iManufacturer,
1269                manufacturer, sizeof(manufacturer));
1270         if (!strcmp("MSI", manufacturer)) {
1271             /*
1272              * iManufacturer 1 MSI
1273              * iProduct      2 MSI K-VOX
1274              */
1275             rc->map_name = af9015_rc_setup_match(AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3,
1276                                  af9015_rc_setup_modparam);
1277         }
1278     }
1279 
1280     /* load empty to enable rc */
1281     if (!rc->map_name)
1282         rc->map_name = RC_MAP_EMPTY;
1283 
1284     rc->allowed_protos = RC_PROTO_BIT_NEC | RC_PROTO_BIT_NECX |
1285                         RC_PROTO_BIT_NEC32;
1286     rc->query = af9015_rc_query;
1287     rc->interval = 500;
1288 
1289     return 0;
1290 }
1291 #else
1292     #define af9015_get_rc_config NULL
1293 #endif
1294 
1295 static int af9015_regmap_write(void *context, const void *data, size_t count)
1296 {
1297     struct dvb_usb_device *d = context;
1298     struct usb_interface *intf = d->intf;
1299     int ret;
1300     u16 reg = ((u8 *)data)[0] << 8 | ((u8 *)data)[1] << 0;
1301     u8 *val = &((u8 *)data)[2];
1302     const unsigned int len = count - 2;
1303     struct req_t req = {WRITE_MEMORY, 0, reg, 0, 0, len, val};
1304 
1305     ret = af9015_ctrl_msg(d, &req);
1306     if (ret)
1307         goto err;
1308 
1309     return 0;
1310 err:
1311     dev_dbg(&intf->dev, "failed %d\n", ret);
1312     return ret;
1313 }
1314 
1315 static int af9015_regmap_read(void *context, const void *reg_buf,
1316                   size_t reg_size, void *val_buf, size_t val_size)
1317 {
1318     struct dvb_usb_device *d = context;
1319     struct usb_interface *intf = d->intf;
1320     int ret;
1321     u16 reg = ((u8 *)reg_buf)[0] << 8 | ((u8 *)reg_buf)[1] << 0;
1322     u8 *val = &((u8 *)val_buf)[0];
1323     const unsigned int len = val_size;
1324     struct req_t req = {READ_MEMORY, 0, reg, 0, 0, len, val};
1325 
1326     ret = af9015_ctrl_msg(d, &req);
1327     if (ret)
1328         goto err;
1329 
1330     return 0;
1331 err:
1332     dev_dbg(&intf->dev, "failed %d\n", ret);
1333     return ret;
1334 }
1335 
1336 static int af9015_probe(struct dvb_usb_device *d)
1337 {
1338     struct af9015_state *state = d_to_priv(d);
1339     struct usb_interface *intf = d->intf;
1340     struct usb_device *udev = interface_to_usbdev(intf);
1341     int ret;
1342     char manufacturer[sizeof("ITE Technologies, Inc.")];
1343     static const struct regmap_config regmap_config = {
1344         .reg_bits    =  16,
1345         .val_bits    =  8,
1346     };
1347     static const struct regmap_bus regmap_bus = {
1348         .read = af9015_regmap_read,
1349         .write = af9015_regmap_write,
1350     };
1351 
1352     dev_dbg(&intf->dev, "\n");
1353 
1354     memset(manufacturer, 0, sizeof(manufacturer));
1355     usb_string(udev, udev->descriptor.iManufacturer,
1356            manufacturer, sizeof(manufacturer));
1357     /*
1358      * There is two devices having same ID but different chipset. One uses
1359      * AF9015 and the other IT9135 chipset. Only difference seen on lsusb
1360      * is iManufacturer string.
1361      *
1362      * idVendor           0x0ccd TerraTec Electronic GmbH
1363      * idProduct          0x0099
1364      * bcdDevice            2.00
1365      * iManufacturer           1 Afatech
1366      * iProduct                2 DVB-T 2
1367      *
1368      * idVendor           0x0ccd TerraTec Electronic GmbH
1369      * idProduct          0x0099
1370      * bcdDevice            2.00
1371      * iManufacturer           1 ITE Technologies, Inc.
1372      * iProduct                2 DVB-T TV Stick
1373      */
1374     if ((le16_to_cpu(udev->descriptor.idVendor) == USB_VID_TERRATEC) &&
1375         (le16_to_cpu(udev->descriptor.idProduct) == 0x0099)) {
1376         if (!strcmp("ITE Technologies, Inc.", manufacturer)) {
1377             ret = -ENODEV;
1378             dev_dbg(&intf->dev, "rejecting device\n");
1379             goto err;
1380         }
1381     }
1382 
1383     state->regmap = regmap_init(&intf->dev, &regmap_bus, d, &regmap_config);
1384     if (IS_ERR(state->regmap)) {
1385         ret = PTR_ERR(state->regmap);
1386         goto err;
1387     }
1388 
1389     return 0;
1390 err:
1391     dev_dbg(&intf->dev, "failed %d\n", ret);
1392     return ret;
1393 }
1394 
1395 static void af9015_disconnect(struct dvb_usb_device *d)
1396 {
1397     struct af9015_state *state = d_to_priv(d);
1398     struct usb_interface *intf = d->intf;
1399 
1400     dev_dbg(&intf->dev, "\n");
1401 
1402     regmap_exit(state->regmap);
1403 }
1404 
1405 /*
1406  * Interface 0 is used by DVB-T receiver and
1407  * interface 1 is for remote controller (HID)
1408  */
1409 static const struct dvb_usb_device_properties af9015_props = {
1410     .driver_name = KBUILD_MODNAME,
1411     .owner = THIS_MODULE,
1412     .adapter_nr = adapter_nr,
1413     .size_of_priv = sizeof(struct af9015_state),
1414 
1415     .generic_bulk_ctrl_endpoint = 0x02,
1416     .generic_bulk_ctrl_endpoint_response = 0x81,
1417 
1418     .probe = af9015_probe,
1419     .disconnect = af9015_disconnect,
1420     .identify_state = af9015_identify_state,
1421     .firmware = AF9015_FIRMWARE,
1422     .download_firmware = af9015_download_firmware,
1423 
1424     .i2c_algo = &af9015_i2c_algo,
1425     .read_config = af9015_read_config,
1426     .frontend_attach = af9015_af9013_frontend_attach,
1427     .frontend_detach = af9015_frontend_detach,
1428     .tuner_attach = af9015_tuner_attach,
1429     .init = af9015_init,
1430     .get_rc_config = af9015_get_rc_config,
1431     .get_stream_config = af9015_get_stream_config,
1432     .streaming_ctrl = af9015_streaming_ctrl,
1433 
1434     .get_adapter_count = af9015_get_adapter_count,
1435     .adapter = {
1436         {
1437             .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1438                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1439             .pid_filter_count = 32,
1440             .pid_filter = af9015_pid_filter,
1441             .pid_filter_ctrl = af9015_pid_filter_ctrl,
1442 
1443             .stream = DVB_USB_STREAM_BULK(0x84, 6, 87 * 188),
1444         }, {
1445             .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1446                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1447             .pid_filter_count = 32,
1448             .pid_filter = af9015_pid_filter,
1449             .pid_filter_ctrl = af9015_pid_filter_ctrl,
1450 
1451             .stream = DVB_USB_STREAM_BULK(0x85, 6, 87 * 188),
1452         },
1453     },
1454 };
1455 
1456 static const struct usb_device_id af9015_id_table[] = {
1457     { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9015_9015,
1458         &af9015_props, "Afatech AF9015 reference design", NULL) },
1459     { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9015_9016,
1460         &af9015_props, "Afatech AF9015 reference design", NULL) },
1461     { DVB_USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_GOLD,
1462         &af9015_props, "Leadtek WinFast DTV Dongle Gold", RC_MAP_LEADTEK_Y04G0051) },
1463     { DVB_USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV71E,
1464         &af9015_props, "Pinnacle PCTV 71e", NULL) },
1465     { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_399U,
1466         &af9015_props, "KWorld PlusTV Dual DVB-T Stick (DVB-T 399U)", NULL) },
1467     { DVB_USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TINYTWIN,
1468         &af9015_props, "DigitalNow TinyTwin", RC_MAP_AZUREWAVE_AD_TU700) },
1469     { DVB_USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_AZUREWAVE_AD_TU700,
1470         &af9015_props, "TwinHan AzureWave AD-TU700(704J)", RC_MAP_AZUREWAVE_AD_TU700) },
1471     { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_USB_XE_REV2,
1472         &af9015_props, "TerraTec Cinergy T USB XE", NULL) },
1473     { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_PC160_2T,
1474         &af9015_props, "KWorld PlusTV Dual DVB-T PCI (DVB-T PC160-2T)", NULL) },
1475     { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X,
1476         &af9015_props, "AVerMedia AVerTV DVB-T Volar X", RC_MAP_AVERMEDIA_M135A) },
1477     { DVB_USB_DEVICE(USB_VID_XTENSIONS, USB_PID_XTENSIONS_XD_380,
1478         &af9015_props, "Xtensions XD-380", NULL) },
1479     { DVB_USB_DEVICE(USB_VID_MSI_2, USB_PID_MSI_DIGIVOX_DUO,
1480         &af9015_props, "MSI DIGIVOX Duo", RC_MAP_MSI_DIGIVOX_III) },
1481     { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X_2,
1482         &af9015_props, "Fujitsu-Siemens Slim Mobile USB DVB-T", NULL) },
1483     { DVB_USB_DEVICE(USB_VID_TELESTAR,  USB_PID_TELESTAR_STARSTICK_2,
1484         &af9015_props, "Telestar Starstick 2", NULL) },
1485     { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A309,
1486         &af9015_props, "AVerMedia A309", NULL) },
1487     { DVB_USB_DEVICE(USB_VID_MSI_2, USB_PID_MSI_DIGI_VOX_MINI_III,
1488         &af9015_props, "MSI Digi VOX mini III", RC_MAP_MSI_DIGIVOX_III) },
1489     { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U,
1490         &af9015_props, "KWorld USB DVB-T TV Stick II (VS-DVB-T 395U)", NULL) },
1491     { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_2,
1492         &af9015_props, "KWorld USB DVB-T TV Stick II (VS-DVB-T 395U)", NULL) },
1493     { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_3,
1494         &af9015_props, "KWorld USB DVB-T TV Stick II (VS-DVB-T 395U)", NULL) },
1495     { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_TREKSTOR_DVBT,
1496         &af9015_props, "TrekStor DVB-T USB Stick", RC_MAP_TREKSTOR) },
1497     { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A850,
1498         &af9015_props, "AverMedia AVerTV Volar Black HD (A850)", NULL) },
1499     { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A805,
1500         &af9015_props, "AverMedia AVerTV Volar GPS 805 (A805)", NULL) },
1501     { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_CONCEPTRONIC_CTVDIGRCU,
1502         &af9015_props, "Conceptronic USB2.0 DVB-T CTVDIGRCU V3.0", NULL) },
1503     { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_MC810,
1504         &af9015_props, "KWorld Digital MC-810", NULL) },
1505     { DVB_USB_DEVICE(USB_VID_KYE, USB_PID_GENIUS_TVGO_DVB_T03,
1506         &af9015_props, "Genius TVGo DVB-T03", NULL) },
1507     { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_399U_2,
1508         &af9015_props, "KWorld PlusTV Dual DVB-T Stick (DVB-T 399U)", NULL) },
1509     { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_PC160_T,
1510         &af9015_props, "KWorld PlusTV DVB-T PCI Pro Card (DVB-T PC160-T)", NULL) },
1511     { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV20,
1512         &af9015_props, "Sveon STV20 Tuner USB DVB-T HDTV", NULL) },
1513     { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_TINYTWIN_2,
1514         &af9015_props, "DigitalNow TinyTwin v2", RC_MAP_DIGITALNOW_TINYTWIN) },
1515     { DVB_USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV2000DS,
1516         &af9015_props, "Leadtek WinFast DTV2000DS", RC_MAP_LEADTEK_Y04G0051) },
1517     { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_UB383_T,
1518         &af9015_props, "KWorld USB DVB-T Stick Mobile (UB383-T)", NULL) },
1519     { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_4,
1520         &af9015_props, "KWorld USB DVB-T TV Stick II (VS-DVB-T 395U)", NULL) },
1521     { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A815M,
1522         &af9015_props, "AverMedia AVerTV Volar M (A815Mac)", NULL) },
1523     { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_STICK_RC,
1524         &af9015_props, "TerraTec Cinergy T Stick RC", RC_MAP_TERRATEC_SLIM_2) },
1525     /* XXX: that same ID [0ccd:0099] is used by af9035 driver too */
1526     { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_STICK_DUAL_RC,
1527         &af9015_props, "TerraTec Cinergy T Stick Dual RC", RC_MAP_TERRATEC_SLIM) },
1528     { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A850T,
1529         &af9015_props, "AverMedia AVerTV Red HD+ (A850T)", NULL) },
1530     { DVB_USB_DEVICE(USB_VID_GTEK, USB_PID_TINYTWIN_3,
1531         &af9015_props, "DigitalNow TinyTwin v3", RC_MAP_DIGITALNOW_TINYTWIN) },
1532     { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV22,
1533         &af9015_props, "Sveon STV22 Dual USB DVB-T Tuner HDTV", RC_MAP_MSI_DIGIVOX_III) },
1534     { }
1535 };
1536 MODULE_DEVICE_TABLE(usb, af9015_id_table);
1537 
1538 /* usb specific object needed to register this driver with the usb subsystem */
1539 static struct usb_driver af9015_usb_driver = {
1540     .name = KBUILD_MODNAME,
1541     .id_table = af9015_id_table,
1542     .probe = dvb_usbv2_probe,
1543     .disconnect = dvb_usbv2_disconnect,
1544     .suspend = dvb_usbv2_suspend,
1545     .resume = dvb_usbv2_resume,
1546     .reset_resume = dvb_usbv2_reset_resume,
1547     .no_dynamic_id = 1,
1548     .soft_unbind = 1,
1549 };
1550 
1551 module_usb_driver(af9015_usb_driver);
1552 
1553 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1554 MODULE_DESCRIPTION("Afatech AF9015 driver");
1555 MODULE_LICENSE("GPL");
1556 MODULE_FIRMWARE(AF9015_FIRMWARE);
[ 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!