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

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