drivers/media/usb/dvb-usb/dib0700_core.c

   1 /* Linux driver for devices based on the DiBcom DiB0700 USB bridge
   2  *
   3  *      This program is free software; you can redistribute it and/or modify it
   4  *      under the terms of the GNU General Public License as published by the Free
   5  *      Software Foundation, version 2.
   6  *
   7  *  Copyright (C) 2005-6 DiBcom, SA
   8  */
   9 #include "dib0700.h"
  10
  11 /* debug */
  12 int dvb_usb_dib0700_debug;
  13 module_param_named(debug,dvb_usb_dib0700_debug, int, 0644);
  14 MODULE_PARM_DESC(debug, "set debugging level (1=info,2=fw,4=fwdata,8=data (or-able))." DVB_USB_DEBUG_STATUS);
  15
  16 static int nb_packet_buffer_size = 21;
  17 module_param(nb_packet_buffer_size, int, 0644);
  18 MODULE_PARM_DESC(nb_packet_buffer_size,
  19         "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)");
  20
  21 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  22
  23
  24 int dib0700_get_version(struct dvb_usb_device *d, u32 *hwversion,
  25                         u32 *romversion, u32 *ramversion, u32 *fwtype)
  26 {
  27         struct dib0700_state *st = d->priv;
  28         int ret;
  29
  30         if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
  31                 err("could not acquire lock");
  32                 return -EINTR;
  33         }
  34
  35         ret = usb_control_msg(d->udev, usb_rcvctrlpipe(d->udev, 0),
  36                                   REQUEST_GET_VERSION,
  37                                   USB_TYPE_VENDOR | USB_DIR_IN, 0, 0,
  38                                   st->buf, 16, USB_CTRL_GET_TIMEOUT);
  39         if (hwversion != NULL)
  40                 *hwversion  = (st->buf[0] << 24)  | (st->buf[1] << 16)  |
  41                         (st->buf[2] << 8)  | st->buf[3];
  42         if (romversion != NULL)
  43                 *romversion = (st->buf[4] << 24)  | (st->buf[5] << 16)  |
  44                         (st->buf[6] << 8)  | st->buf[7];
  45         if (ramversion != NULL)
  46                 *ramversion = (st->buf[8] << 24)  | (st->buf[9] << 16)  |
  47                         (st->buf[10] << 8) | st->buf[11];
  48         if (fwtype != NULL)
  49                 *fwtype     = (st->buf[12] << 24) | (st->buf[13] << 16) |
  50                         (st->buf[14] << 8) | st->buf[15];
  51         mutex_unlock(&d->usb_mutex);
  52         return ret;
  53 }
  54
  55 /* expecting rx buffer: request data[0] data[1] ... data[2] */
  56 static int dib0700_ctrl_wr(struct dvb_usb_device *d, u8 *tx, u8 txlen)
  57 {
  58         int status;
  59
  60         deb_data(">>> ");
  61         debug_dump(tx, txlen, deb_data);
  62
  63         status = usb_control_msg(d->udev, usb_sndctrlpipe(d->udev,0),
  64                 tx[0], USB_TYPE_VENDOR | USB_DIR_OUT, 0, 0, tx, txlen,
  65                 USB_CTRL_GET_TIMEOUT);
  66
  67         if (status != txlen)
  68                 deb_data("ep 0 write error (status = %d, len: %d)\n",status,txlen);
  69
  70         return status < 0 ? status : 0;
  71 }
  72
  73 /* expecting tx buffer: request data[0] ... data[n] (n <= 4) */
  74 int dib0700_ctrl_rd(struct dvb_usb_device *d, u8 *tx, u8 txlen, u8 *rx, u8 rxlen)
  75 {
  76         u16 index, value;
  77         int status;
  78
  79         if (txlen < 2) {
  80                 err("tx buffer length is smaller than 2. Makes no sense.");
  81                 return -EINVAL;
  82         }
  83         if (txlen > 4) {
  84                 err("tx buffer length is larger than 4. Not supported.");
  85                 return -EINVAL;
  86         }
  87
  88         deb_data(">>> ");
  89         debug_dump(tx,txlen,deb_data);
  90
  91         value = ((txlen - 2) << 8) | tx[1];
  92         index = 0;
  93         if (txlen > 2)
  94                 index |= (tx[2] << 8);
  95         if (txlen > 3)
  96                 index |= tx[3];
  97
  98         status = usb_control_msg(d->udev, usb_rcvctrlpipe(d->udev,0), tx[0],
  99                         USB_TYPE_VENDOR | USB_DIR_IN, value, index, rx, rxlen,
 100                         USB_CTRL_GET_TIMEOUT);
 101
 102         if (status < 0)
 103                 deb_info("ep 0 read error (status = %d)\n",status);
 104
 105         deb_data("<<< ");
 106         debug_dump(rx, rxlen, deb_data);
 107
 108         return status; /* length in case of success */
 109 }
 110
 111 int dib0700_set_gpio(struct dvb_usb_device *d, enum dib07x0_gpios gpio, u8 gpio_dir, u8 gpio_val)
 112 {
 113         struct dib0700_state *st = d->priv;
 114         int ret;
 115
 116         if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
 117                 err("could not acquire lock");
 118                 return -EINTR;
 119         }
 120
 121         st->buf[0] = REQUEST_SET_GPIO;
 122         st->buf[1] = gpio;
 123         st->buf[2] = ((gpio_dir & 0x01) << 7) | ((gpio_val & 0x01) << 6);
 124
 125         ret = dib0700_ctrl_wr(d, st->buf, 3);
 126
 127         mutex_unlock(&d->usb_mutex);
 128         return ret;
 129 }
 130
 131 static int dib0700_set_usb_xfer_len(struct dvb_usb_device *d, u16 nb_ts_packets)
 132 {
 133         struct dib0700_state *st = d->priv;
 134         int ret;
 135
 136         if (st->fw_version >= 0x10201) {
 137                 if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
 138                         err("could not acquire lock");
 139                         return -EINTR;
 140                 }
 141
 142                 st->buf[0] = REQUEST_SET_USB_XFER_LEN;
 143                 st->buf[1] = (nb_ts_packets >> 8) & 0xff;
 144                 st->buf[2] = nb_ts_packets & 0xff;
 145
 146                 deb_info("set the USB xfer len to %i Ts packet\n", nb_ts_packets);
 147
 148                 ret = dib0700_ctrl_wr(d, st->buf, 3);
 149                 mutex_unlock(&d->usb_mutex);
 150         } else {
 151                 deb_info("this firmware does not allow to change the USB xfer len\n");
 152                 ret = -EIO;
 153         }
 154
 155         return ret;
 156 }
 157
 158 /*
 159  * I2C master xfer function (supported in 1.20 firmware)
 160  */
 161 static int dib0700_i2c_xfer_new(struct i2c_adapter *adap, struct i2c_msg *msg,
 162                                 int num)
 163 {
 164         /* The new i2c firmware messages are more reliable and in particular
 165            properly support i2c read calls not preceded by a write */
 166
 167         struct dvb_usb_device *d = i2c_get_adapdata(adap);
 168         struct dib0700_state *st = d->priv;
 169         uint8_t bus_mode = 1;  /* 0=eeprom bus, 1=frontend bus */
 170         uint8_t gen_mode = 0; /* 0=master i2c, 1=gpio i2c */
 171         uint8_t en_start = 0;
 172         uint8_t en_stop = 0;
 173         int result, i;
 174
 175         /* Ensure nobody else hits the i2c bus while we're sending our
 176            sequence of messages, (such as the remote control thread) */
 177         if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
 178                 return -EINTR;
 179
 180         for (i = 0; i < num; i++) {
 181                 if (i == 0) {
 182                         /* First message in the transaction */
 183                         en_start = 1;
 184                 } else if (!(msg[i].flags & I2C_M_NOSTART)) {
 185                         /* Device supports repeated-start */
 186                         en_start = 1;
 187                 } else {
 188                         /* Not the first packet and device doesn't support
 189                            repeated start */
 190                         en_start = 0;
 191                 }
 192                 if (i == (num - 1)) {
 193                         /* Last message in the transaction */
 194                         en_stop = 1;
 195                 }
 196
 197                 if (msg[i].flags & I2C_M_RD) {
 198                         /* Read request */
 199                         u16 index, value;
 200                         uint8_t i2c_dest;
 201
 202                         i2c_dest = (msg[i].addr << 1);
 203                         value = ((en_start << 7) | (en_stop << 6) |
 204                                  (msg[i].len & 0x3F)) << 8 | i2c_dest;
 205                         /* I2C ctrl + FE bus; */
 206                         index = ((gen_mode << 6) & 0xC0) |
 207                                 ((bus_mode << 4) & 0x30);
 208
 209                         result = usb_control_msg(d->udev,
 210                                                  usb_rcvctrlpipe(d->udev, 0),
 211                                                  REQUEST_NEW_I2C_READ,
 212                                                  USB_TYPE_VENDOR | USB_DIR_IN,
 213                                                  value, index, st->buf,
 214                                                  msg[i].len,
 215                                                  USB_CTRL_GET_TIMEOUT);
 216                         if (result < 0) {
 217                                 deb_info("i2c read error (status = %d)\n", result);
 218                                 goto unlock;
 219                         }
 220
 221                         if (msg[i].len > sizeof(st->buf)) {
 222                                 deb_info("buffer too small to fit %d bytes\n",
 223                                          msg[i].len);
 224                                 result = -EIO;
 225                                 goto unlock;
 226                         }
 227
 228                         memcpy(msg[i].buf, st->buf, msg[i].len);
 229
 230                         deb_data("<<< ");
 231                         debug_dump(msg[i].buf, msg[i].len, deb_data);
 232
 233                 } else {
 234                         /* Write request */
 235                         if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
 236                                 err("could not acquire lock");
 237                                 result = -EINTR;
 238                                 goto unlock;
 239                         }
 240                         st->buf[0] = REQUEST_NEW_I2C_WRITE;
 241                         st->buf[1] = msg[i].addr << 1;
 242                         st->buf[2] = (en_start << 7) | (en_stop << 6) |
 243                                 (msg[i].len & 0x3F);
 244                         /* I2C ctrl + FE bus; */
 245                         st->buf[3] = ((gen_mode << 6) & 0xC0) |
 246                                  ((bus_mode << 4) & 0x30);
 247
 248                         if (msg[i].len > sizeof(st->buf) - 4) {
 249                                 deb_info("i2c message to big: %d\n",
 250                                          msg[i].len);
 251                                 mutex_unlock(&d->usb_mutex);
 252                                 result = -EIO;
 253                                 goto unlock;
 254                         }
 255
 256                         /* The Actual i2c payload */
 257                         memcpy(&st->buf[4], msg[i].buf, msg[i].len);
 258
 259                         deb_data(">>> ");
 260                         debug_dump(st->buf, msg[i].len + 4, deb_data);
 261
 262                         result = usb_control_msg(d->udev,
 263                                                  usb_sndctrlpipe(d->udev, 0),
 264                                                  REQUEST_NEW_I2C_WRITE,
 265                                                  USB_TYPE_VENDOR | USB_DIR_OUT,
 266                                                  0, 0, st->buf, msg[i].len + 4,
 267                                                  USB_CTRL_GET_TIMEOUT);
 268                         mutex_unlock(&d->usb_mutex);
 269                         if (result < 0) {
 270                                 deb_info("i2c write error (status = %d)\n", result);
 271                                 break;
 272                         }
 273                 }
 274         }
 275         result = i;
 276
 277 unlock:
 278         mutex_unlock(&d->i2c_mutex);
 279         return result;
 280 }
 281
 282 /*
 283  * I2C master xfer function (pre-1.20 firmware)
 284  */
 285 static int dib0700_i2c_xfer_legacy(struct i2c_adapter *adap,
 286                                    struct i2c_msg *msg, int num)
 287 {
 288         struct dvb_usb_device *d = i2c_get_adapdata(adap);
 289         struct dib0700_state *st = d->priv;
 290         int i, len, result;
 291
 292         if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
 293                 return -EINTR;
 294         if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
 295                 err("could not acquire lock");
 296                 mutex_unlock(&d->i2c_mutex);
 297                 return -EINTR;
 298         }
 299
 300         for (i = 0; i < num; i++) {
 301                 /* fill in the address */
 302                 st->buf[1] = msg[i].addr << 1;
 303                 /* fill the buffer */
 304                 if (msg[i].len > sizeof(st->buf) - 2) {
 305                         deb_info("i2c xfer to big: %d\n",
 306                                 msg[i].len);
 307                         result = -EIO;
 308                         goto unlock;
 309                 }
 310                 memcpy(&st->buf[2], msg[i].buf, msg[i].len);
 311
 312                 /* write/read request */
 313                 if (i+1 < num && (msg[i+1].flags & I2C_M_RD)) {
 314                         st->buf[0] = REQUEST_I2C_READ;
 315                         st->buf[1] |= 1;
 316
 317                         /* special thing in the current firmware: when length is zero the read-failed */
 318                         len = dib0700_ctrl_rd(d, st->buf, msg[i].len + 2,
 319                                               st->buf, msg[i + 1].len);
 320                         if (len <= 0) {
 321                                 deb_info("I2C read failed on address 0x%02x\n",
 322                                                 msg[i].addr);
 323                                 result = -EIO;
 324                                 goto unlock;
 325                         }
 326
 327                         if (msg[i + 1].len > sizeof(st->buf)) {
 328                                 deb_info("i2c xfer buffer to small for %d\n",
 329                                         msg[i].len);
 330                                 result = -EIO;
 331                                 goto unlock;
 332                         }
 333                         memcpy(msg[i + 1].buf, st->buf, msg[i + 1].len);
 334
 335                         msg[i+1].len = len;
 336
 337                         i++;
 338                 } else {
 339                         st->buf[0] = REQUEST_I2C_WRITE;
 340                         result = dib0700_ctrl_wr(d, st->buf, msg[i].len + 2);
 341                         if (result < 0)
 342                                 goto unlock;
 343                 }
 344         }
 345         result = i;
 346 unlock:
 347         mutex_unlock(&d->usb_mutex);
 348         mutex_unlock(&d->i2c_mutex);
 349
 350         return result;
 351 }
 352
 353 static int dib0700_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg *msg,
 354                             int num)
 355 {
 356         struct dvb_usb_device *d = i2c_get_adapdata(adap);
 357         struct dib0700_state *st = d->priv;
 358
 359         if (st->fw_use_new_i2c_api == 1) {
 360                 /* User running at least fw 1.20 */
 361                 return dib0700_i2c_xfer_new(adap, msg, num);
 362         } else {
 363                 /* Use legacy calls */
 364                 return dib0700_i2c_xfer_legacy(adap, msg, num);
 365         }
 366 }
 367
 368 static u32 dib0700_i2c_func(struct i2c_adapter *adapter)
 369 {
 370         return I2C_FUNC_I2C;
 371 }
 372
 373 struct i2c_algorithm dib0700_i2c_algo = {
 374         .master_xfer   = dib0700_i2c_xfer,
 375         .functionality = dib0700_i2c_func,
 376 };
 377
 378 int dib0700_identify_state(struct usb_device *udev, struct dvb_usb_device_properties *props,
 379                         struct dvb_usb_device_description **desc, int *cold)
 380 {
 381         s16 ret;
 382         u8 *b;
 383
 384         b = kmalloc(16, GFP_KERNEL);
 385         if (!b)
 386                 return  -ENOMEM;
 387
 388
 389         ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
 390                 REQUEST_GET_VERSION, USB_TYPE_VENDOR | USB_DIR_IN, 0, 0, b, 16, USB_CTRL_GET_TIMEOUT);
 391
 392         deb_info("FW GET_VERSION length: %d\n",ret);
 393
 394         *cold = ret <= 0;
 395         deb_info("cold: %d\n", *cold);
 396
 397         kfree(b);
 398         return 0;
 399 }
 400
 401 static int dib0700_set_clock(struct dvb_usb_device *d, u8 en_pll,
 402         u8 pll_src, u8 pll_range, u8 clock_gpio3, u16 pll_prediv,
 403         u16 pll_loopdiv, u16 free_div, u16 dsuScaler)
 404 {
 405         struct dib0700_state *st = d->priv;
 406         int ret;
 407
 408         if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
 409                 err("could not acquire lock");
 410                 return -EINTR;
 411         }
 412
 413         st->buf[0] = REQUEST_SET_CLOCK;
 414         st->buf[1] = (en_pll << 7) | (pll_src << 6) |
 415                 (pll_range << 5) | (clock_gpio3 << 4);
 416         st->buf[2] = (pll_prediv >> 8)  & 0xff; /* MSB */
 417         st->buf[3] =  pll_prediv        & 0xff; /* LSB */
 418         st->buf[4] = (pll_loopdiv >> 8) & 0xff; /* MSB */
 419         st->buf[5] =  pll_loopdiv       & 0xff; /* LSB */
 420         st->buf[6] = (free_div >> 8)    & 0xff; /* MSB */
 421         st->buf[7] =  free_div          & 0xff; /* LSB */
 422         st->buf[8] = (dsuScaler >> 8)   & 0xff; /* MSB */
 423         st->buf[9] =  dsuScaler         & 0xff; /* LSB */
 424
 425         ret = dib0700_ctrl_wr(d, st->buf, 10);
 426         mutex_unlock(&d->usb_mutex);
 427
 428         return ret;
 429 }
 430
 431 int dib0700_set_i2c_speed(struct dvb_usb_device *d, u16 scl_kHz)
 432 {
 433         struct dib0700_state *st = d->priv;
 434         u16 divider;
 435         int ret;
 436
 437         if (scl_kHz == 0)
 438                 return -EINVAL;
 439
 440         if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
 441                 err("could not acquire lock");
 442                 return -EINTR;
 443         }
 444
 445         st->buf[0] = REQUEST_SET_I2C_PARAM;
 446         divider = (u16) (30000 / scl_kHz);
 447         st->buf[1] = 0;
 448         st->buf[2] = (u8) (divider >> 8);
 449         st->buf[3] = (u8) (divider & 0xff);
 450         divider = (u16) (72000 / scl_kHz);
 451         st->buf[4] = (u8) (divider >> 8);
 452         st->buf[5] = (u8) (divider & 0xff);
 453         divider = (u16) (72000 / scl_kHz); /* clock: 72MHz */
 454         st->buf[6] = (u8) (divider >> 8);
 455         st->buf[7] = (u8) (divider & 0xff);
 456
 457         deb_info("setting I2C speed: %04x %04x %04x (%d kHz).",
 458                 (st->buf[2] << 8) | (st->buf[3]), (st->buf[4] << 8) |
 459                 st->buf[5], (st->buf[6] << 8) | st->buf[7], scl_kHz);
 460
 461         ret = dib0700_ctrl_wr(d, st->buf, 8);
 462         mutex_unlock(&d->usb_mutex);
 463
 464         return ret;
 465 }
 466
 467
 468 int dib0700_ctrl_clock(struct dvb_usb_device *d, u32 clk_MHz, u8 clock_out_gp3)
 469 {
 470         switch (clk_MHz) {
 471                 case 72: dib0700_set_clock(d, 1, 0, 1, clock_out_gp3, 2, 24, 0, 0x4c); break;
 472                 default: return -EINVAL;
 473         }
 474         return 0;
 475 }
 476
 477 static int dib0700_jumpram(struct usb_device *udev, u32 address)
 478 {
 479         int ret = 0, actlen;
 480         u8 *buf;
 481
 482         buf = kmalloc(8, GFP_KERNEL);
 483         if (!buf)
 484                 return -ENOMEM;
 485         buf[0] = REQUEST_JUMPRAM;
 486         buf[1] = 0;
 487         buf[2] = 0;
 488         buf[3] = 0;
 489         buf[4] = (address >> 24) & 0xff;
 490         buf[5] = (address >> 16) & 0xff;
 491         buf[6] = (address >> 8)  & 0xff;
 492         buf[7] =  address        & 0xff;
 493
 494         if ((ret = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 0x01),buf,8,&actlen,1000)) < 0) {
 495                 deb_fw("jumpram to 0x%x failed\n",address);
 496                 goto out;
 497         }
 498         if (actlen != 8) {
 499                 deb_fw("jumpram to 0x%x failed\n",address);
 500                 ret = -EIO;
 501                 goto out;
 502         }
 503 out:
 504         kfree(buf);
 505         return ret;
 506 }
 507
 508 int dib0700_download_firmware(struct usb_device *udev, const struct firmware *fw)
 509 {
 510         struct hexline hx;
 511         int pos = 0, ret, act_len, i, adap_num;
 512         u8 *buf;
 513         u32 fw_version;
 514
 515         buf = kmalloc(260, GFP_KERNEL);
 516         if (!buf)
 517                 return -ENOMEM;
 518
 519         while ((ret = dvb_usb_get_hexline(fw, &hx, &pos)) > 0) {
 520                 deb_fwdata("writing to address 0x%08x (buffer: 0x%02x %02x)\n",
 521                                 hx.addr, hx.len, hx.chk);
 522
 523                 buf[0] = hx.len;
 524                 buf[1] = (hx.addr >> 8) & 0xff;
 525                 buf[2] =  hx.addr       & 0xff;
 526                 buf[3] = hx.type;
 527                 memcpy(&buf[4],hx.data,hx.len);
 528                 buf[4+hx.len] = hx.chk;
 529
 530                 ret = usb_bulk_msg(udev,
 531                         usb_sndbulkpipe(udev, 0x01),
 532                         buf,
 533                         hx.len + 5,
 534                         &act_len,
 535                         1000);
 536
 537                 if (ret < 0) {
 538                         err("firmware download failed at %d with %d",pos,ret);
 539                         goto out;
 540                 }
 541         }
 542
 543         if (ret == 0) {
 544                 /* start the firmware */
 545                 if ((ret = dib0700_jumpram(udev, 0x70000000)) == 0) {
 546                         info("firmware started successfully.");
 547                         msleep(500);
 548                 }
 549         } else
 550                 ret = -EIO;
 551
 552         /* the number of ts packet has to be at least 1 */
 553         if (nb_packet_buffer_size < 1)
 554                 nb_packet_buffer_size = 1;
 555
 556         /* get the firmware version */
 557         usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
 558                                   REQUEST_GET_VERSION,
 559                                   USB_TYPE_VENDOR | USB_DIR_IN, 0, 0,
 560                                   buf, 16, USB_CTRL_GET_TIMEOUT);
 561         fw_version = (buf[8] << 24) | (buf[9] << 16) | (buf[10] << 8) | buf[11];
 562
 563         /* set the buffer size - DVB-USB is allocating URB buffers
 564          * only after the firwmare download was successful */
 565         for (i = 0; i < dib0700_device_count; i++) {
 566                 for (adap_num = 0; adap_num < dib0700_devices[i].num_adapters;
 567                                 adap_num++) {
 568                         if (fw_version >= 0x10201) {
 569                                 dib0700_devices[i].adapter[adap_num].fe[0].stream.u.bulk.buffersize = 188*nb_packet_buffer_size;
 570                         } else {
 571                                 /* for fw version older than 1.20.1,
 572                                  * the buffersize has to be n times 512 */
 573                                 dib0700_devices[i].adapter[adap_num].fe[0].stream.u.bulk.buffersize = ((188*nb_packet_buffer_size+188/2)/512)*512;
 574                                 if (dib0700_devices[i].adapter[adap_num].fe[0].stream.u.bulk.buffersize < 512)
 575                                         dib0700_devices[i].adapter[adap_num].fe[0].stream.u.bulk.buffersize = 512;
 576                         }
 577                 }
 578         }
 579 out:
 580         kfree(buf);
 581         return ret;
 582 }
 583
 584 int dib0700_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
 585 {
 586         struct dib0700_state *st = adap->dev->priv;
 587         int ret;
 588
 589         if ((onoff != 0) && (st->fw_version >= 0x10201)) {
 590                 /* for firmware later than 1.20.1,
 591                  * the USB xfer length can be set  */
 592                 ret = dib0700_set_usb_xfer_len(adap->dev,
 593                         st->nb_packet_buffer_size);
 594                 if (ret < 0) {
 595                         deb_info("can not set the USB xfer len\n");
 596                         return ret;
 597                 }
 598         }
 599
 600         mutex_lock(&adap->dev->usb_mutex);
 601
 602         st->buf[0] = REQUEST_ENABLE_VIDEO;
 603         /* this bit gives a kind of command,
 604          * rather than enabling something or not */
 605         st->buf[1] = (onoff << 4) | 0x00;
 606
 607         if (st->disable_streaming_master_mode == 1)
 608                 st->buf[2] = 0x00;
 609         else
 610                 st->buf[2] = 0x01 << 4; /* Master mode */
 611
 612         st->buf[3] = 0x00;
 613
 614         deb_info("modifying (%d) streaming state for %d\n", onoff, adap->id);
 615
 616         st->channel_state &= ~0x3;
 617         if ((adap->fe_adap[0].stream.props.endpoint != 2)
 618                         && (adap->fe_adap[0].stream.props.endpoint != 3)) {
 619                 deb_info("the endpoint number (%i) is not correct, use the adapter id instead", adap->fe_adap[0].stream.props.endpoint);
 620                 if (onoff)
 621                         st->channel_state |=    1 << (adap->id);
 622         } else {
 623                 if (onoff)
 624                         st->channel_state |=    1 << (adap->fe_adap[0].stream.props.endpoint-2);
 625                 else
 626                         st->channel_state |=    1 << (3-adap->fe_adap[0].stream.props.endpoint);
 627         }
 628
 629         st->buf[2] |= st->channel_state;
 630
 631         deb_info("data for streaming: %x %x\n", st->buf[1], st->buf[2]);
 632
 633         ret = dib0700_ctrl_wr(adap->dev, st->buf, 4);
 634         mutex_unlock(&adap->dev->usb_mutex);
 635
 636         return ret;
 637 }
 638
 639 int dib0700_change_protocol(struct rc_dev *rc, u64 *rc_proto)
 640 {
 641         struct dvb_usb_device *d = rc->priv;
 642         struct dib0700_state *st = d->priv;
 643         int new_proto, ret;
 644
 645         if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
 646                 err("could not acquire lock");
 647                 return -EINTR;
 648         }
 649
 650         st->buf[0] = REQUEST_SET_RC;
 651         st->buf[1] = 0;
 652         st->buf[2] = 0;
 653
 654         /* Set the IR mode */
 655         if (*rc_proto & RC_PROTO_BIT_RC5) {
 656                 new_proto = 1;
 657                 *rc_proto = RC_PROTO_BIT_RC5;
 658         } else if (*rc_proto & RC_PROTO_BIT_NEC) {
 659                 new_proto = 0;
 660                 *rc_proto = RC_PROTO_BIT_NEC;
 661         } else if (*rc_proto & RC_PROTO_BIT_RC6_MCE) {
 662                 if (st->fw_version < 0x10200) {
 663                         ret = -EINVAL;
 664                         goto out;
 665                 }
 666                 new_proto = 2;
 667                 *rc_proto = RC_PROTO_BIT_RC6_MCE;
 668         } else {
 669                 ret = -EINVAL;
 670                 goto out;
 671         }
 672
 673         st->buf[1] = new_proto;
 674
 675         ret = dib0700_ctrl_wr(d, st->buf, 3);
 676         if (ret < 0) {
 677                 err("ir protocol setup failed");
 678                 goto out;
 679         }
 680
 681         d->props.rc.core.protocol = *rc_proto;
 682
 683 out:
 684         mutex_unlock(&d->usb_mutex);
 685         return ret;
 686 }
 687
 688 /* This is the structure of the RC response packet starting in firmware 1.20 */
 689 struct dib0700_rc_response {
 690         u8 report_id;
 691         u8 data_state;
 692         union {
 693                 struct {
 694                         u8 system;
 695                         u8 not_system;
 696                         u8 data;
 697                         u8 not_data;
 698                 } nec;
 699                 struct {
 700                         u8 not_used;
 701                         u8 system;
 702                         u8 data;
 703                         u8 not_data;
 704                 } rc5;
 705         };
 706 };
 707 #define RC_MSG_SIZE_V1_20 6
 708
 709 static void dib0700_rc_urb_completion(struct urb *purb)
 710 {
 711         struct dvb_usb_device *d = purb->context;
 712         struct dib0700_rc_response *poll_reply;
 713         enum rc_proto protocol;
 714         u32 keycode;
 715         u8 toggle;
 716
 717         deb_info("%s()\n", __func__);
 718         if (d->rc_dev == NULL) {
 719                 /* This will occur if disable_rc_polling=1 */
 720                 kfree(purb->transfer_buffer);
 721                 usb_free_urb(purb);
 722                 return;
 723         }
 724
 725         poll_reply = purb->transfer_buffer;
 726
 727         if (purb->status < 0) {
 728                 deb_info("discontinuing polling\n");
 729                 kfree(purb->transfer_buffer);
 730                 usb_free_urb(purb);
 731                 return;
 732         }
 733
 734         if (purb->actual_length != RC_MSG_SIZE_V1_20) {
 735                 deb_info("malformed rc msg size=%d\n", purb->actual_length);
 736                 goto resubmit;
 737         }
 738
 739         deb_data("IR ID = %02X state = %02X System = %02X %02X Cmd = %02X %02X (len %d)\n",
 740                  poll_reply->report_id, poll_reply->data_state,
 741                  poll_reply->nec.system, poll_reply->nec.not_system,
 742                  poll_reply->nec.data, poll_reply->nec.not_data,
 743                  purb->actual_length);
 744
 745         switch (d->props.rc.core.protocol) {
 746         case RC_PROTO_BIT_NEC:
 747                 toggle = 0;
 748
 749                 /* NEC protocol sends repeat code as 0 0 0 FF */
 750                 if (poll_reply->nec.system     == 0x00 &&
 751                     poll_reply->nec.not_system == 0x00 &&
 752                     poll_reply->nec.data       == 0x00 &&
 753                     poll_reply->nec.not_data   == 0xff) {
 754                         poll_reply->data_state = 2;
 755                         rc_repeat(d->rc_dev);
 756                         goto resubmit;
 757                 }
 758
 759                 if ((poll_reply->nec.data ^ poll_reply->nec.not_data) != 0xff) {
 760                         deb_data("NEC32 protocol\n");
 761                         keycode = RC_SCANCODE_NEC32(poll_reply->nec.system     << 24 |
 762                                                      poll_reply->nec.not_system << 16 |
 763                                                      poll_reply->nec.data       << 8  |
 764                                                      poll_reply->nec.not_data);
 765                         protocol = RC_PROTO_NEC32;
 766                 } else if ((poll_reply->nec.system ^ poll_reply->nec.not_system) != 0xff) {
 767                         deb_data("NEC extended protocol\n");
 768                         keycode = RC_SCANCODE_NECX(poll_reply->nec.system << 8 |
 769                                                     poll_reply->nec.not_system,
 770                                                     poll_reply->nec.data);
 771
 772                         protocol = RC_PROTO_NECX;
 773                 } else {
 774                         deb_data("NEC normal protocol\n");
 775                         keycode = RC_SCANCODE_NEC(poll_reply->nec.system,
 776                                                    poll_reply->nec.data);
 777                         protocol = RC_PROTO_NEC;
 778                 }
 779
 780                 break;
 781         default:
 782                 deb_data("RC5 protocol\n");
 783                 protocol = RC_PROTO_RC5;
 784                 toggle = poll_reply->report_id;
 785                 keycode = RC_SCANCODE_RC5(poll_reply->rc5.system, poll_reply->rc5.data);
 786
 787                 if ((poll_reply->rc5.data ^ poll_reply->rc5.not_data) != 0xff) {
 788                         /* Key failed integrity check */
 789                         err("key failed integrity check: %02x %02x %02x %02x",
 790                             poll_reply->rc5.not_used, poll_reply->rc5.system,
 791                             poll_reply->rc5.data, poll_reply->rc5.not_data);
 792                         goto resubmit;
 793                 }
 794
 795                 break;
 796         }
 797
 798         rc_keydown(d->rc_dev, protocol, keycode, toggle);
 799
 800 resubmit:
 801         /* Clean the buffer before we requeue */
 802         memset(purb->transfer_buffer, 0, RC_MSG_SIZE_V1_20);
 803
 804         /* Requeue URB */
 805         usb_submit_urb(purb, GFP_ATOMIC);
 806 }
 807
 808 int dib0700_rc_setup(struct dvb_usb_device *d, struct usb_interface *intf)
 809 {
 810         struct dib0700_state *st = d->priv;
 811         struct urb *purb;
 812         const struct usb_endpoint_descriptor *e;
 813         int ret, rc_ep = 1;
 814         unsigned int pipe = 0;
 815
 816         /* Poll-based. Don't initialize bulk mode */
 817         if (st->fw_version < 0x10200 || !intf)
 818                 return 0;
 819
 820         /* Starting in firmware 1.20, the RC info is provided on a bulk pipe */
 821
 822         if (intf->cur_altsetting->desc.bNumEndpoints < rc_ep + 1)
 823                 return -ENODEV;
 824
 825         purb = usb_alloc_urb(0, GFP_KERNEL);
 826         if (purb == NULL)
 827                 return -ENOMEM;
 828
 829         purb->transfer_buffer = kzalloc(RC_MSG_SIZE_V1_20, GFP_KERNEL);
 830         if (purb->transfer_buffer == NULL) {
 831                 err("rc kzalloc failed");
 832                 usb_free_urb(purb);
 833                 return -ENOMEM;
 834         }
 835
 836         purb->status = -EINPROGRESS;
 837
 838         /*
 839          * Some devices like the Hauppauge NovaTD model 52009 use an interrupt
 840          * endpoint, while others use a bulk one.
 841          */
 842         e = &intf->cur_altsetting->endpoint[rc_ep].desc;
 843         if (usb_endpoint_dir_in(e)) {
 844                 if (usb_endpoint_xfer_bulk(e)) {
 845                         pipe = usb_rcvbulkpipe(d->udev, rc_ep);
 846                         usb_fill_bulk_urb(purb, d->udev, pipe,
 847                                           purb->transfer_buffer,
 848                                           RC_MSG_SIZE_V1_20,
 849                                           dib0700_rc_urb_completion, d);
 850
 851                 } else if (usb_endpoint_xfer_int(e)) {
 852                         pipe = usb_rcvintpipe(d->udev, rc_ep);
 853                         usb_fill_int_urb(purb, d->udev, pipe,
 854                                           purb->transfer_buffer,
 855                                           RC_MSG_SIZE_V1_20,
 856                                           dib0700_rc_urb_completion, d, 1);
 857                 }
 858         }
 859
 860         if (!pipe) {
 861                 err("There's no endpoint for remote controller");
 862                 kfree(purb->transfer_buffer);
 863                 usb_free_urb(purb);
 864                 return 0;
 865         }
 866
 867         ret = usb_submit_urb(purb, GFP_ATOMIC);
 868         if (ret) {
 869                 err("rc submit urb failed");
 870                 kfree(purb->transfer_buffer);
 871                 usb_free_urb(purb);
 872         }
 873
 874         return ret;
 875 }
 876
 877 static int dib0700_probe(struct usb_interface *intf,
 878                 const struct usb_device_id *id)
 879 {
 880         int i;
 881         struct dvb_usb_device *dev;
 882
 883         for (i = 0; i < dib0700_device_count; i++)
 884                 if (dvb_usb_device_init(intf, &dib0700_devices[i], THIS_MODULE,
 885                     &dev, adapter_nr) == 0) {
 886                         struct dib0700_state *st = dev->priv;
 887                         u32 hwversion, romversion, fw_version, fwtype;
 888
 889                         dib0700_get_version(dev, &hwversion, &romversion,
 890                                 &fw_version, &fwtype);
 891
 892                         deb_info("Firmware version: %x, %d, 0x%x, %d\n",
 893                                 hwversion, romversion, fw_version, fwtype);
 894
 895                         st->fw_version = fw_version;
 896                         st->nb_packet_buffer_size = (u32)nb_packet_buffer_size;
 897
 898                         /* Disable polling mode on newer firmwares */
 899                         if (st->fw_version >= 0x10200)
 900                                 dev->props.rc.core.bulk_mode = true;
 901                         else
 902                                 dev->props.rc.core.bulk_mode = false;
 903
 904                         dib0700_rc_setup(dev, intf);
 905
 906                         return 0;
 907                 }
 908
 909         return -ENODEV;
 910 }
 911
 912 static void dib0700_disconnect(struct usb_interface *intf)
 913 {
 914         struct dvb_usb_device *d = usb_get_intfdata(intf);
 915         struct dib0700_state *st = d->priv;
 916         struct i2c_client *client;
 917
 918         /* remove I2C client for tuner */
 919         client = st->i2c_client_tuner;
 920         if (client) {
 921                 module_put(client->dev.driver->owner);
 922                 i2c_unregister_device(client);
 923         }
 924
 925         /* remove I2C client for demodulator */
 926         client = st->i2c_client_demod;
 927         if (client) {
 928                 module_put(client->dev.driver->owner);
 929                 i2c_unregister_device(client);
 930         }
 931
 932         dvb_usb_device_exit(intf);
 933 }
 934
 935
 936 static struct usb_driver dib0700_driver = {
 937         .name       = "dvb_usb_dib0700",
 938         .probe      = dib0700_probe,
 939         .disconnect = dib0700_disconnect,
 940         .id_table   = dib0700_usb_id_table,
 941 };
 942
 943 module_usb_driver(dib0700_driver);
 944
 945 /*(DEBLOBBED)*/
 946 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>");
 947 MODULE_DESCRIPTION("Driver for devices based on DiBcom DiB0700 - USB bridge");
 948 MODULE_VERSION("1.0");
 949 MODULE_LICENSE("GPL");