Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /* Linux driver for devices based on the DiBcom DiB0700 USB bridge
0003  *
0004  *  Copyright (C) 2005-6 DiBcom, SA
0005  */
0006 #include "dib0700.h"
0007 
0008 /* debug */
0009 int dvb_usb_dib0700_debug;
0010 module_param_named(debug,dvb_usb_dib0700_debug, int, 0644);
0011 MODULE_PARM_DESC(debug, "set debugging level (1=info,2=fw,4=fwdata,8=data (or-able))." DVB_USB_DEBUG_STATUS);
0012 
0013 static int nb_packet_buffer_size = 21;
0014 module_param(nb_packet_buffer_size, int, 0644);
0015 MODULE_PARM_DESC(nb_packet_buffer_size,
0016     "Set the dib0700 driver data buffer size. This parameter corresponds to the number of TS packets. The actual size of the data buffer corresponds to this parameter multiplied by 188 (default: 21)");
0017 
0018 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
0019 
0020 
0021 int dib0700_get_version(struct dvb_usb_device *d, u32 *hwversion,
0022             u32 *romversion, u32 *ramversion, u32 *fwtype)
0023 {
0024     struct dib0700_state *st = d->priv;
0025     int ret;
0026 
0027     if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
0028         err("could not acquire lock");
0029         return -EINTR;
0030     }
0031 
0032     ret = usb_control_msg(d->udev, usb_rcvctrlpipe(d->udev, 0),
0033                   REQUEST_GET_VERSION,
0034                   USB_TYPE_VENDOR | USB_DIR_IN, 0, 0,
0035                   st->buf, 16, USB_CTRL_GET_TIMEOUT);
0036     if (hwversion != NULL)
0037         *hwversion  = (st->buf[0] << 24)  | (st->buf[1] << 16)  |
0038             (st->buf[2] << 8)  | st->buf[3];
0039     if (romversion != NULL)
0040         *romversion = (st->buf[4] << 24)  | (st->buf[5] << 16)  |
0041             (st->buf[6] << 8)  | st->buf[7];
0042     if (ramversion != NULL)
0043         *ramversion = (st->buf[8] << 24)  | (st->buf[9] << 16)  |
0044             (st->buf[10] << 8) | st->buf[11];
0045     if (fwtype != NULL)
0046         *fwtype     = (st->buf[12] << 24) | (st->buf[13] << 16) |
0047             (st->buf[14] << 8) | st->buf[15];
0048     mutex_unlock(&d->usb_mutex);
0049     return ret;
0050 }
0051 
0052 /* expecting rx buffer: request data[0] data[1] ... data[2] */
0053 static int dib0700_ctrl_wr(struct dvb_usb_device *d, u8 *tx, u8 txlen)
0054 {
0055     int status;
0056 
0057     deb_data(">>> ");
0058     debug_dump(tx, txlen, deb_data);
0059 
0060     status = usb_control_msg(d->udev, usb_sndctrlpipe(d->udev,0),
0061         tx[0], USB_TYPE_VENDOR | USB_DIR_OUT, 0, 0, tx, txlen,
0062         USB_CTRL_GET_TIMEOUT);
0063 
0064     if (status != txlen)
0065         deb_data("ep 0 write error (status = %d, len: %d)\n",status,txlen);
0066 
0067     return status < 0 ? status : 0;
0068 }
0069 
0070 /* expecting tx buffer: request data[0] ... data[n] (n <= 4) */
0071 int dib0700_ctrl_rd(struct dvb_usb_device *d, u8 *tx, u8 txlen, u8 *rx, u8 rxlen)
0072 {
0073     u16 index, value;
0074     int status;
0075 
0076     if (txlen < 2) {
0077         err("tx buffer length is smaller than 2. Makes no sense.");
0078         return -EINVAL;
0079     }
0080     if (txlen > 4) {
0081         err("tx buffer length is larger than 4. Not supported.");
0082         return -EINVAL;
0083     }
0084 
0085     deb_data(">>> ");
0086     debug_dump(tx,txlen,deb_data);
0087 
0088     value = ((txlen - 2) << 8) | tx[1];
0089     index = 0;
0090     if (txlen > 2)
0091         index |= (tx[2] << 8);
0092     if (txlen > 3)
0093         index |= tx[3];
0094 
0095     status = usb_control_msg(d->udev, usb_rcvctrlpipe(d->udev,0), tx[0],
0096             USB_TYPE_VENDOR | USB_DIR_IN, value, index, rx, rxlen,
0097             USB_CTRL_GET_TIMEOUT);
0098 
0099     if (status < 0)
0100         deb_info("ep 0 read error (status = %d)\n",status);
0101 
0102     deb_data("<<< ");
0103     debug_dump(rx, rxlen, deb_data);
0104 
0105     return status; /* length in case of success */
0106 }
0107 
0108 int dib0700_set_gpio(struct dvb_usb_device *d, enum dib07x0_gpios gpio, u8 gpio_dir, u8 gpio_val)
0109 {
0110     struct dib0700_state *st = d->priv;
0111     int ret;
0112 
0113     if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
0114         err("could not acquire lock");
0115         return -EINTR;
0116     }
0117 
0118     st->buf[0] = REQUEST_SET_GPIO;
0119     st->buf[1] = gpio;
0120     st->buf[2] = ((gpio_dir & 0x01) << 7) | ((gpio_val & 0x01) << 6);
0121 
0122     ret = dib0700_ctrl_wr(d, st->buf, 3);
0123 
0124     mutex_unlock(&d->usb_mutex);
0125     return ret;
0126 }
0127 
0128 static int dib0700_set_usb_xfer_len(struct dvb_usb_device *d, u16 nb_ts_packets)
0129 {
0130     struct dib0700_state *st = d->priv;
0131     int ret;
0132 
0133     if (st->fw_version >= 0x10201) {
0134         if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
0135             err("could not acquire lock");
0136             return -EINTR;
0137         }
0138 
0139         st->buf[0] = REQUEST_SET_USB_XFER_LEN;
0140         st->buf[1] = (nb_ts_packets >> 8) & 0xff;
0141         st->buf[2] = nb_ts_packets & 0xff;
0142 
0143         deb_info("set the USB xfer len to %i Ts packet\n", nb_ts_packets);
0144 
0145         ret = dib0700_ctrl_wr(d, st->buf, 3);
0146         mutex_unlock(&d->usb_mutex);
0147     } else {
0148         deb_info("this firmware does not allow to change the USB xfer len\n");
0149         ret = -EIO;
0150     }
0151 
0152     return ret;
0153 }
0154 
0155 /*
0156  * I2C master xfer function (supported in 1.20 firmware)
0157  */
0158 static int dib0700_i2c_xfer_new(struct i2c_adapter *adap, struct i2c_msg *msg,
0159                 int num)
0160 {
0161     /* The new i2c firmware messages are more reliable and in particular
0162        properly support i2c read calls not preceded by a write */
0163 
0164     struct dvb_usb_device *d = i2c_get_adapdata(adap);
0165     struct dib0700_state *st = d->priv;
0166     uint8_t bus_mode = 1;  /* 0=eeprom bus, 1=frontend bus */
0167     uint8_t gen_mode = 0; /* 0=master i2c, 1=gpio i2c */
0168     uint8_t en_start = 0;
0169     uint8_t en_stop = 0;
0170     int result, i;
0171 
0172     /* Ensure nobody else hits the i2c bus while we're sending our
0173        sequence of messages, (such as the remote control thread) */
0174     if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
0175         return -EINTR;
0176 
0177     for (i = 0; i < num; i++) {
0178         if (i == 0) {
0179             /* First message in the transaction */
0180             en_start = 1;
0181         } else if (!(msg[i].flags & I2C_M_NOSTART)) {
0182             /* Device supports repeated-start */
0183             en_start = 1;
0184         } else {
0185             /* Not the first packet and device doesn't support
0186                repeated start */
0187             en_start = 0;
0188         }
0189         if (i == (num - 1)) {
0190             /* Last message in the transaction */
0191             en_stop = 1;
0192         }
0193 
0194         if (msg[i].flags & I2C_M_RD) {
0195             /* Read request */
0196             u16 index, value;
0197             uint8_t i2c_dest;
0198 
0199             i2c_dest = (msg[i].addr << 1);
0200             value = ((en_start << 7) | (en_stop << 6) |
0201                  (msg[i].len & 0x3F)) << 8 | i2c_dest;
0202             /* I2C ctrl + FE bus; */
0203             index = ((gen_mode << 6) & 0xC0) |
0204                 ((bus_mode << 4) & 0x30);
0205 
0206             result = usb_control_msg(d->udev,
0207                          usb_rcvctrlpipe(d->udev, 0),
0208                          REQUEST_NEW_I2C_READ,
0209                          USB_TYPE_VENDOR | USB_DIR_IN,
0210                          value, index, st->buf,
0211                          msg[i].len,
0212                          USB_CTRL_GET_TIMEOUT);
0213             if (result < 0) {
0214                 deb_info("i2c read error (status = %d)\n", result);
0215                 goto unlock;
0216             }
0217 
0218             if (msg[i].len > sizeof(st->buf)) {
0219                 deb_info("buffer too small to fit %d bytes\n",
0220                      msg[i].len);
0221                 result = -EIO;
0222                 goto unlock;
0223             }
0224 
0225             memcpy(msg[i].buf, st->buf, msg[i].len);
0226 
0227             deb_data("<<< ");
0228             debug_dump(msg[i].buf, msg[i].len, deb_data);
0229 
0230         } else {
0231             /* Write request */
0232             if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
0233                 err("could not acquire lock");
0234                 result = -EINTR;
0235                 goto unlock;
0236             }
0237             st->buf[0] = REQUEST_NEW_I2C_WRITE;
0238             st->buf[1] = msg[i].addr << 1;
0239             st->buf[2] = (en_start << 7) | (en_stop << 6) |
0240                 (msg[i].len & 0x3F);
0241             /* I2C ctrl + FE bus; */
0242             st->buf[3] = ((gen_mode << 6) & 0xC0) |
0243                  ((bus_mode << 4) & 0x30);
0244 
0245             if (msg[i].len > sizeof(st->buf) - 4) {
0246                 deb_info("i2c message to big: %d\n",
0247                      msg[i].len);
0248                 mutex_unlock(&d->usb_mutex);
0249                 result = -EIO;
0250                 goto unlock;
0251             }
0252 
0253             /* The Actual i2c payload */
0254             memcpy(&st->buf[4], msg[i].buf, msg[i].len);
0255 
0256             deb_data(">>> ");
0257             debug_dump(st->buf, msg[i].len + 4, deb_data);
0258 
0259             result = usb_control_msg(d->udev,
0260                          usb_sndctrlpipe(d->udev, 0),
0261                          REQUEST_NEW_I2C_WRITE,
0262                          USB_TYPE_VENDOR | USB_DIR_OUT,
0263                          0, 0, st->buf, msg[i].len + 4,
0264                          USB_CTRL_GET_TIMEOUT);
0265             mutex_unlock(&d->usb_mutex);
0266             if (result < 0) {
0267                 deb_info("i2c write error (status = %d)\n", result);
0268                 break;
0269             }
0270         }
0271     }
0272     result = i;
0273 
0274 unlock:
0275     mutex_unlock(&d->i2c_mutex);
0276     return result;
0277 }
0278 
0279 /*
0280  * I2C master xfer function (pre-1.20 firmware)
0281  */
0282 static int dib0700_i2c_xfer_legacy(struct i2c_adapter *adap,
0283                    struct i2c_msg *msg, int num)
0284 {
0285     struct dvb_usb_device *d = i2c_get_adapdata(adap);
0286     struct dib0700_state *st = d->priv;
0287     int i, len, result;
0288 
0289     if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
0290         return -EINTR;
0291     if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
0292         err("could not acquire lock");
0293         mutex_unlock(&d->i2c_mutex);
0294         return -EINTR;
0295     }
0296 
0297     for (i = 0; i < num; i++) {
0298         /* fill in the address */
0299         st->buf[1] = msg[i].addr << 1;
0300         /* fill the buffer */
0301         if (msg[i].len > sizeof(st->buf) - 2) {
0302             deb_info("i2c xfer to big: %d\n",
0303                 msg[i].len);
0304             result = -EIO;
0305             goto unlock;
0306         }
0307         memcpy(&st->buf[2], msg[i].buf, msg[i].len);
0308 
0309         /* write/read request */
0310         if (i+1 < num && (msg[i+1].flags & I2C_M_RD)) {
0311             st->buf[0] = REQUEST_I2C_READ;
0312             st->buf[1] |= 1;
0313 
0314             /* special thing in the current firmware: when length is zero the read-failed */
0315             len = dib0700_ctrl_rd(d, st->buf, msg[i].len + 2,
0316                           st->buf, msg[i + 1].len);
0317             if (len <= 0) {
0318                 deb_info("I2C read failed on address 0x%02x\n",
0319                         msg[i].addr);
0320                 result = -EIO;
0321                 goto unlock;
0322             }
0323 
0324             if (msg[i + 1].len > sizeof(st->buf)) {
0325                 deb_info("i2c xfer buffer to small for %d\n",
0326                     msg[i].len);
0327                 result = -EIO;
0328                 goto unlock;
0329             }
0330             memcpy(msg[i + 1].buf, st->buf, msg[i + 1].len);
0331 
0332             msg[i+1].len = len;
0333 
0334             i++;
0335         } else {
0336             st->buf[0] = REQUEST_I2C_WRITE;
0337             result = dib0700_ctrl_wr(d, st->buf, msg[i].len + 2);
0338             if (result < 0)
0339                 goto unlock;
0340         }
0341     }
0342     result = i;
0343 unlock:
0344     mutex_unlock(&d->usb_mutex);
0345     mutex_unlock(&d->i2c_mutex);
0346 
0347     return result;
0348 }
0349 
0350 static int dib0700_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg *msg,
0351                 int num)
0352 {
0353     struct dvb_usb_device *d = i2c_get_adapdata(adap);
0354     struct dib0700_state *st = d->priv;
0355 
0356     if (st->fw_use_new_i2c_api == 1) {
0357         /* User running at least fw 1.20 */
0358         return dib0700_i2c_xfer_new(adap, msg, num);
0359     } else {
0360         /* Use legacy calls */
0361         return dib0700_i2c_xfer_legacy(adap, msg, num);
0362     }
0363 }
0364 
0365 static u32 dib0700_i2c_func(struct i2c_adapter *adapter)
0366 {
0367     return I2C_FUNC_I2C;
0368 }
0369 
0370 struct i2c_algorithm dib0700_i2c_algo = {
0371     .master_xfer   = dib0700_i2c_xfer,
0372     .functionality = dib0700_i2c_func,
0373 };
0374 
0375 int dib0700_identify_state(struct usb_device *udev,
0376                const struct dvb_usb_device_properties *props,
0377                const struct dvb_usb_device_description **desc,
0378                int *cold)
0379 {
0380     s16 ret;
0381     u8 *b;
0382 
0383     b = kmalloc(16, GFP_KERNEL);
0384     if (!b)
0385         return  -ENOMEM;
0386 
0387 
0388     ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
0389         REQUEST_GET_VERSION, USB_TYPE_VENDOR | USB_DIR_IN, 0, 0, b, 16, USB_CTRL_GET_TIMEOUT);
0390 
0391     deb_info("FW GET_VERSION length: %d\n",ret);
0392 
0393     *cold = ret <= 0;
0394     deb_info("cold: %d\n", *cold);
0395 
0396     kfree(b);
0397     return 0;
0398 }
0399 
0400 static int dib0700_set_clock(struct dvb_usb_device *d, u8 en_pll,
0401     u8 pll_src, u8 pll_range, u8 clock_gpio3, u16 pll_prediv,
0402     u16 pll_loopdiv, u16 free_div, u16 dsuScaler)
0403 {
0404     struct dib0700_state *st = d->priv;
0405     int ret;
0406 
0407     if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
0408         err("could not acquire lock");
0409         return -EINTR;
0410     }
0411 
0412     st->buf[0] = REQUEST_SET_CLOCK;
0413     st->buf[1] = (en_pll << 7) | (pll_src << 6) |
0414         (pll_range << 5) | (clock_gpio3 << 4);
0415     st->buf[2] = (pll_prediv >> 8)  & 0xff; /* MSB */
0416     st->buf[3] =  pll_prediv        & 0xff; /* LSB */
0417     st->buf[4] = (pll_loopdiv >> 8) & 0xff; /* MSB */
0418     st->buf[5] =  pll_loopdiv       & 0xff; /* LSB */
0419     st->buf[6] = (free_div >> 8)    & 0xff; /* MSB */
0420     st->buf[7] =  free_div          & 0xff; /* LSB */
0421     st->buf[8] = (dsuScaler >> 8)   & 0xff; /* MSB */
0422     st->buf[9] =  dsuScaler         & 0xff; /* LSB */
0423 
0424     ret = dib0700_ctrl_wr(d, st->buf, 10);
0425     mutex_unlock(&d->usb_mutex);
0426 
0427     return ret;
0428 }
0429 
0430 int dib0700_set_i2c_speed(struct dvb_usb_device *d, u16 scl_kHz)
0431 {
0432     struct dib0700_state *st = d->priv;
0433     u16 divider;
0434     int ret;
0435 
0436     if (scl_kHz == 0)
0437         return -EINVAL;
0438 
0439     if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
0440         err("could not acquire lock");
0441         return -EINTR;
0442     }
0443 
0444     st->buf[0] = REQUEST_SET_I2C_PARAM;
0445     divider = (u16) (30000 / scl_kHz);
0446     st->buf[1] = 0;
0447     st->buf[2] = (u8) (divider >> 8);
0448     st->buf[3] = (u8) (divider & 0xff);
0449     divider = (u16) (72000 / scl_kHz);
0450     st->buf[4] = (u8) (divider >> 8);
0451     st->buf[5] = (u8) (divider & 0xff);
0452     divider = (u16) (72000 / scl_kHz); /* clock: 72MHz */
0453     st->buf[6] = (u8) (divider >> 8);
0454     st->buf[7] = (u8) (divider & 0xff);
0455 
0456     deb_info("setting I2C speed: %04x %04x %04x (%d kHz).",
0457         (st->buf[2] << 8) | (st->buf[3]), (st->buf[4] << 8) |
0458         st->buf[5], (st->buf[6] << 8) | st->buf[7], scl_kHz);
0459 
0460     ret = dib0700_ctrl_wr(d, st->buf, 8);
0461     mutex_unlock(&d->usb_mutex);
0462 
0463     return ret;
0464 }
0465 
0466 
0467 int dib0700_ctrl_clock(struct dvb_usb_device *d, u32 clk_MHz, u8 clock_out_gp3)
0468 {
0469     switch (clk_MHz) {
0470         case 72: dib0700_set_clock(d, 1, 0, 1, clock_out_gp3, 2, 24, 0, 0x4c); break;
0471         default: return -EINVAL;
0472     }
0473     return 0;
0474 }
0475 
0476 static int dib0700_jumpram(struct usb_device *udev, u32 address)
0477 {
0478     int ret = 0, actlen;
0479     u8 *buf;
0480 
0481     buf = kmalloc(8, GFP_KERNEL);
0482     if (!buf)
0483         return -ENOMEM;
0484     buf[0] = REQUEST_JUMPRAM;
0485     buf[1] = 0;
0486     buf[2] = 0;
0487     buf[3] = 0;
0488     buf[4] = (address >> 24) & 0xff;
0489     buf[5] = (address >> 16) & 0xff;
0490     buf[6] = (address >> 8)  & 0xff;
0491     buf[7] =  address        & 0xff;
0492 
0493     if ((ret = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 0x01),buf,8,&actlen,1000)) < 0) {
0494         deb_fw("jumpram to 0x%x failed\n",address);
0495         goto out;
0496     }
0497     if (actlen != 8) {
0498         deb_fw("jumpram to 0x%x failed\n",address);
0499         ret = -EIO;
0500         goto out;
0501     }
0502 out:
0503     kfree(buf);
0504     return ret;
0505 }
0506 
0507 int dib0700_download_firmware(struct usb_device *udev, const struct firmware *fw)
0508 {
0509     struct hexline hx;
0510     int pos = 0, ret, act_len, i, adap_num;
0511     u8 *buf;
0512     u32 fw_version;
0513 
0514     buf = kmalloc(260, GFP_KERNEL);
0515     if (!buf)
0516         return -ENOMEM;
0517 
0518     while ((ret = dvb_usb_get_hexline(fw, &hx, &pos)) > 0) {
0519         deb_fwdata("writing to address 0x%08x (buffer: 0x%02x %02x)\n",
0520                 hx.addr, hx.len, hx.chk);
0521 
0522         buf[0] = hx.len;
0523         buf[1] = (hx.addr >> 8) & 0xff;
0524         buf[2] =  hx.addr       & 0xff;
0525         buf[3] = hx.type;
0526         memcpy(&buf[4],hx.data,hx.len);
0527         buf[4+hx.len] = hx.chk;
0528 
0529         ret = usb_bulk_msg(udev,
0530             usb_sndbulkpipe(udev, 0x01),
0531             buf,
0532             hx.len + 5,
0533             &act_len,
0534             1000);
0535 
0536         if (ret < 0) {
0537             err("firmware download failed at %d with %d",pos,ret);
0538             goto out;
0539         }
0540     }
0541 
0542     if (ret == 0) {
0543         /* start the firmware */
0544         if ((ret = dib0700_jumpram(udev, 0x70000000)) == 0) {
0545             info("firmware started successfully.");
0546             msleep(500);
0547         }
0548     } else
0549         ret = -EIO;
0550 
0551     /* the number of ts packet has to be at least 1 */
0552     if (nb_packet_buffer_size < 1)
0553         nb_packet_buffer_size = 1;
0554 
0555     /* get the firmware version */
0556     usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
0557                   REQUEST_GET_VERSION,
0558                   USB_TYPE_VENDOR | USB_DIR_IN, 0, 0,
0559                   buf, 16, USB_CTRL_GET_TIMEOUT);
0560     fw_version = (buf[8] << 24) | (buf[9] << 16) | (buf[10] << 8) | buf[11];
0561 
0562     /* set the buffer size - DVB-USB is allocating URB buffers
0563      * only after the firwmare download was successful */
0564     for (i = 0; i < dib0700_device_count; i++) {
0565         for (adap_num = 0; adap_num < dib0700_devices[i].num_adapters;
0566                 adap_num++) {
0567             if (fw_version >= 0x10201) {
0568                 dib0700_devices[i].adapter[adap_num].fe[0].stream.u.bulk.buffersize = 188*nb_packet_buffer_size;
0569             } else {
0570                 /* for fw version older than 1.20.1,
0571                  * the buffersize has to be n times 512 */
0572                 dib0700_devices[i].adapter[adap_num].fe[0].stream.u.bulk.buffersize = ((188*nb_packet_buffer_size+188/2)/512)*512;
0573                 if (dib0700_devices[i].adapter[adap_num].fe[0].stream.u.bulk.buffersize < 512)
0574                     dib0700_devices[i].adapter[adap_num].fe[0].stream.u.bulk.buffersize = 512;
0575             }
0576         }
0577     }
0578 out:
0579     kfree(buf);
0580     return ret;
0581 }
0582 
0583 int dib0700_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
0584 {
0585     struct dib0700_state *st = adap->dev->priv;
0586     int ret, adapt_nr;
0587 
0588     if ((onoff != 0) && (st->fw_version >= 0x10201)) {
0589         /* for firmware later than 1.20.1,
0590          * the USB xfer length can be set  */
0591         ret = dib0700_set_usb_xfer_len(adap->dev,
0592             st->nb_packet_buffer_size);
0593         if (ret < 0) {
0594             deb_info("can not set the USB xfer len\n");
0595             return ret;
0596         }
0597     }
0598 
0599     mutex_lock(&adap->dev->usb_mutex);
0600 
0601     st->buf[0] = REQUEST_ENABLE_VIDEO;
0602     /* this bit gives a kind of command,
0603      * rather than enabling something or not */
0604     st->buf[1] = (onoff << 4) | 0x00;
0605 
0606     if (st->disable_streaming_master_mode == 1)
0607         st->buf[2] = 0x00;
0608     else
0609         st->buf[2] = 0x01 << 4; /* Master mode */
0610 
0611     st->buf[3] = 0x00;
0612 
0613     if ((adap->fe_adap[0].stream.props.endpoint != 2)
0614         && (adap->fe_adap[0].stream.props.endpoint != 3)) {
0615         deb_info("the endpoint number (%i) is not correct, use the adapter id instead\n",
0616              adap->fe_adap[0].stream.props.endpoint);
0617         adapt_nr = adap->id;
0618     } else {
0619         adapt_nr = adap->fe_adap[0].stream.props.endpoint - 2;
0620     }
0621 
0622     if (onoff)
0623         st->channel_state |= 1 << adapt_nr;
0624     else
0625         st->channel_state &= ~(1 << adapt_nr);
0626 
0627     st->buf[2] |= st->channel_state;
0628 
0629     deb_info("adapter %d, streaming %s: %*ph\n",
0630         adapt_nr, onoff ? "ON" : "OFF", 3, st->buf);
0631 
0632     ret = dib0700_ctrl_wr(adap->dev, st->buf, 4);
0633     mutex_unlock(&adap->dev->usb_mutex);
0634 
0635     return ret;
0636 }
0637 
0638 int dib0700_change_protocol(struct rc_dev *rc, u64 *rc_proto)
0639 {
0640     struct dvb_usb_device *d = rc->priv;
0641     struct dib0700_state *st = d->priv;
0642     int new_proto, ret;
0643 
0644     if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
0645         err("could not acquire lock");
0646         return -EINTR;
0647     }
0648 
0649     st->buf[0] = REQUEST_SET_RC;
0650     st->buf[1] = 0;
0651     st->buf[2] = 0;
0652 
0653     /* Set the IR mode */
0654     if (*rc_proto & RC_PROTO_BIT_RC5) {
0655         new_proto = 1;
0656         *rc_proto = RC_PROTO_BIT_RC5;
0657     } else if (*rc_proto & RC_PROTO_BIT_NEC) {
0658         new_proto = 0;
0659         *rc_proto = RC_PROTO_BIT_NEC;
0660     } else if (*rc_proto & RC_PROTO_BIT_RC6_MCE) {
0661         if (st->fw_version < 0x10200) {
0662             ret = -EINVAL;
0663             goto out;
0664         }
0665         new_proto = 2;
0666         *rc_proto = RC_PROTO_BIT_RC6_MCE;
0667     } else {
0668         ret = -EINVAL;
0669         goto out;
0670     }
0671 
0672     st->buf[1] = new_proto;
0673 
0674     ret = dib0700_ctrl_wr(d, st->buf, 3);
0675     if (ret < 0) {
0676         err("ir protocol setup failed");
0677         goto out;
0678     }
0679 
0680     d->props.rc.core.protocol = *rc_proto;
0681 
0682 out:
0683     mutex_unlock(&d->usb_mutex);
0684     return ret;
0685 }
0686 
0687 /* This is the structure of the RC response packet starting in firmware 1.20 */
0688 struct dib0700_rc_response {
0689     u8 report_id;
0690     u8 data_state;
0691     union {
0692         struct {
0693             u8 system;
0694             u8 not_system;
0695             u8 data;
0696             u8 not_data;
0697         } nec;
0698         struct {
0699             u8 not_used;
0700             u8 system;
0701             u8 data;
0702             u8 not_data;
0703         } rc5;
0704     };
0705 };
0706 #define RC_MSG_SIZE_V1_20 6
0707 
0708 static void dib0700_rc_urb_completion(struct urb *purb)
0709 {
0710     struct dvb_usb_device *d = purb->context;
0711     struct dib0700_rc_response *poll_reply;
0712     enum rc_proto protocol;
0713     u32 keycode;
0714     u8 toggle;
0715 
0716     deb_info("%s()\n", __func__);
0717     if (d->rc_dev == NULL) {
0718         /* This will occur if disable_rc_polling=1 */
0719         kfree(purb->transfer_buffer);
0720         usb_free_urb(purb);
0721         return;
0722     }
0723 
0724     poll_reply = purb->transfer_buffer;
0725 
0726     if (purb->status < 0) {
0727         deb_info("discontinuing polling\n");
0728         kfree(purb->transfer_buffer);
0729         usb_free_urb(purb);
0730         return;
0731     }
0732 
0733     if (purb->actual_length != RC_MSG_SIZE_V1_20) {
0734         deb_info("malformed rc msg size=%d\n", purb->actual_length);
0735         goto resubmit;
0736     }
0737 
0738     deb_data("IR ID = %02X state = %02X System = %02X %02X Cmd = %02X %02X (len %d)\n",
0739          poll_reply->report_id, poll_reply->data_state,
0740          poll_reply->nec.system, poll_reply->nec.not_system,
0741          poll_reply->nec.data, poll_reply->nec.not_data,
0742          purb->actual_length);
0743 
0744     switch (d->props.rc.core.protocol) {
0745     case RC_PROTO_BIT_NEC:
0746         toggle = 0;
0747 
0748         /* NEC protocol sends repeat code as 0 0 0 FF */
0749         if (poll_reply->nec.system     == 0x00 &&
0750             poll_reply->nec.not_system == 0x00 &&
0751             poll_reply->nec.data       == 0x00 &&
0752             poll_reply->nec.not_data   == 0xff) {
0753             poll_reply->data_state = 2;
0754             rc_repeat(d->rc_dev);
0755             goto resubmit;
0756         }
0757 
0758         if ((poll_reply->nec.data ^ poll_reply->nec.not_data) != 0xff) {
0759             deb_data("NEC32 protocol\n");
0760             keycode = RC_SCANCODE_NEC32(poll_reply->nec.system     << 24 |
0761                              poll_reply->nec.not_system << 16 |
0762                              poll_reply->nec.data       << 8  |
0763                              poll_reply->nec.not_data);
0764             protocol = RC_PROTO_NEC32;
0765         } else if ((poll_reply->nec.system ^ poll_reply->nec.not_system) != 0xff) {
0766             deb_data("NEC extended protocol\n");
0767             keycode = RC_SCANCODE_NECX(poll_reply->nec.system << 8 |
0768                             poll_reply->nec.not_system,
0769                             poll_reply->nec.data);
0770 
0771             protocol = RC_PROTO_NECX;
0772         } else {
0773             deb_data("NEC normal protocol\n");
0774             keycode = RC_SCANCODE_NEC(poll_reply->nec.system,
0775                            poll_reply->nec.data);
0776             protocol = RC_PROTO_NEC;
0777         }
0778 
0779         break;
0780     default:
0781         deb_data("RC5 protocol\n");
0782         protocol = RC_PROTO_RC5;
0783         toggle = poll_reply->report_id;
0784         keycode = RC_SCANCODE_RC5(poll_reply->rc5.system, poll_reply->rc5.data);
0785 
0786         if ((poll_reply->rc5.data ^ poll_reply->rc5.not_data) != 0xff) {
0787             /* Key failed integrity check */
0788             err("key failed integrity check: %02x %02x %02x %02x",
0789                 poll_reply->rc5.not_used, poll_reply->rc5.system,
0790                 poll_reply->rc5.data, poll_reply->rc5.not_data);
0791             goto resubmit;
0792         }
0793 
0794         break;
0795     }
0796 
0797     rc_keydown(d->rc_dev, protocol, keycode, toggle);
0798 
0799 resubmit:
0800     /* Clean the buffer before we requeue */
0801     memset(purb->transfer_buffer, 0, RC_MSG_SIZE_V1_20);
0802 
0803     /* Requeue URB */
0804     usb_submit_urb(purb, GFP_ATOMIC);
0805 }
0806 
0807 int dib0700_rc_setup(struct dvb_usb_device *d, struct usb_interface *intf)
0808 {
0809     struct dib0700_state *st = d->priv;
0810     struct urb *purb;
0811     const struct usb_endpoint_descriptor *e;
0812     int ret, rc_ep = 1;
0813     unsigned int pipe = 0;
0814 
0815     /* Poll-based. Don't initialize bulk mode */
0816     if (st->fw_version < 0x10200 || !intf)
0817         return 0;
0818 
0819     /* Starting in firmware 1.20, the RC info is provided on a bulk pipe */
0820 
0821     if (intf->cur_altsetting->desc.bNumEndpoints < rc_ep + 1)
0822         return -ENODEV;
0823 
0824     purb = usb_alloc_urb(0, GFP_KERNEL);
0825     if (purb == NULL)
0826         return -ENOMEM;
0827 
0828     purb->transfer_buffer = kzalloc(RC_MSG_SIZE_V1_20, GFP_KERNEL);
0829     if (purb->transfer_buffer == NULL) {
0830         err("rc kzalloc failed");
0831         usb_free_urb(purb);
0832         return -ENOMEM;
0833     }
0834 
0835     purb->status = -EINPROGRESS;
0836 
0837     /*
0838      * Some devices like the Hauppauge NovaTD model 52009 use an interrupt
0839      * endpoint, while others use a bulk one.
0840      */
0841     e = &intf->cur_altsetting->endpoint[rc_ep].desc;
0842     if (usb_endpoint_dir_in(e)) {
0843         if (usb_endpoint_xfer_bulk(e)) {
0844             pipe = usb_rcvbulkpipe(d->udev, rc_ep);
0845             usb_fill_bulk_urb(purb, d->udev, pipe,
0846                       purb->transfer_buffer,
0847                       RC_MSG_SIZE_V1_20,
0848                       dib0700_rc_urb_completion, d);
0849 
0850         } else if (usb_endpoint_xfer_int(e)) {
0851             pipe = usb_rcvintpipe(d->udev, rc_ep);
0852             usb_fill_int_urb(purb, d->udev, pipe,
0853                       purb->transfer_buffer,
0854                       RC_MSG_SIZE_V1_20,
0855                       dib0700_rc_urb_completion, d, 1);
0856         }
0857     }
0858 
0859     if (!pipe) {
0860         err("There's no endpoint for remote controller");
0861         kfree(purb->transfer_buffer);
0862         usb_free_urb(purb);
0863         return 0;
0864     }
0865 
0866     ret = usb_submit_urb(purb, GFP_ATOMIC);
0867     if (ret) {
0868         err("rc submit urb failed");
0869         kfree(purb->transfer_buffer);
0870         usb_free_urb(purb);
0871     }
0872 
0873     return ret;
0874 }
0875 
0876 static int dib0700_probe(struct usb_interface *intf,
0877         const struct usb_device_id *id)
0878 {
0879     int i;
0880     struct dvb_usb_device *dev;
0881 
0882     for (i = 0; i < dib0700_device_count; i++)
0883         if (dvb_usb_device_init(intf, &dib0700_devices[i], THIS_MODULE,
0884             &dev, adapter_nr) == 0) {
0885             struct dib0700_state *st = dev->priv;
0886             u32 hwversion, romversion, fw_version, fwtype;
0887 
0888             dib0700_get_version(dev, &hwversion, &romversion,
0889                 &fw_version, &fwtype);
0890 
0891             deb_info("Firmware version: %x, %d, 0x%x, %d\n",
0892                 hwversion, romversion, fw_version, fwtype);
0893 
0894             st->fw_version = fw_version;
0895             st->nb_packet_buffer_size = (u32)nb_packet_buffer_size;
0896 
0897             /* Disable polling mode on newer firmwares */
0898             if (st->fw_version >= 0x10200)
0899                 dev->props.rc.core.bulk_mode = true;
0900             else
0901                 dev->props.rc.core.bulk_mode = false;
0902 
0903             dib0700_rc_setup(dev, intf);
0904 
0905             return 0;
0906         }
0907 
0908     return -ENODEV;
0909 }
0910 
0911 static void dib0700_disconnect(struct usb_interface *intf)
0912 {
0913     struct dvb_usb_device *d = usb_get_intfdata(intf);
0914     struct dib0700_state *st = d->priv;
0915     struct i2c_client *client;
0916 
0917     /* remove I2C client for tuner */
0918     client = st->i2c_client_tuner;
0919     if (client) {
0920         module_put(client->dev.driver->owner);
0921         i2c_unregister_device(client);
0922     }
0923 
0924     /* remove I2C client for demodulator */
0925     client = st->i2c_client_demod;
0926     if (client) {
0927         module_put(client->dev.driver->owner);
0928         i2c_unregister_device(client);
0929     }
0930 
0931     dvb_usb_device_exit(intf);
0932 }
0933 
0934 
0935 static struct usb_driver dib0700_driver = {
0936     .name       = "dvb_usb_dib0700",
0937     .probe      = dib0700_probe,
0938     .disconnect = dib0700_disconnect,
0939     .id_table   = dib0700_usb_id_table,
0940 };
0941 
0942 module_usb_driver(dib0700_driver);
0943 
0944 MODULE_FIRMWARE("dvb-usb-dib0700-1.20.fw");
0945 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>");
0946 MODULE_DESCRIPTION("Driver for devices based on DiBcom DiB0700 - USB bridge");
0947 MODULE_VERSION("1.0");
0948 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!