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

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * PCTV 452e DVB driver
   4  *
   5  * Copyright (c) 2006-2008 Dominik Kuhlen <dkuhlen@gmx.net>
   6  *
   7  * TT connect S2-3650-CI Common Interface support, MAC readout
   8  * Copyright (C) 2008 Michael H. Schimek <mschimek@gmx.at>
   9  */
  10
  11 /* dvb usb framework */
  12 #define DVB_USB_LOG_PREFIX "pctv452e"
  13 #include "dvb-usb.h"
  14
  15 /* Demodulator */
  16 #include "stb0899_drv.h"
  17 #include "stb0899_reg.h"
  18 #include "stb0899_cfg.h"
  19 /* Tuner */
  20 #include "stb6100.h"
  21 #include "stb6100_cfg.h"
  22 /* FE Power */
  23 #include "isl6423.h"
  24 #include "lnbp22.h"
  25
  26 #include <media/dvb_ca_en50221.h>
  27 #include "ttpci-eeprom.h"
  28
  29 #include <linux/etherdevice.h>
  30
  31 static int debug;
  32 module_param(debug, int, 0644);
  33 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
  34
  35 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  36
  37 #define ISOC_INTERFACE_ALTERNATIVE 3
  38
  39 #define SYNC_BYTE_OUT 0xaa
  40 #define SYNC_BYTE_IN  0x55
  41
  42 /* guessed: (copied from ttusb-budget) */
  43 #define PCTV_CMD_RESET 0x15
  44 /* command to poll IR receiver */
  45 #define PCTV_CMD_IR    0x1b
  46 /* command to send I2C  */
  47 #define PCTV_CMD_I2C   0x31
  48
  49 #define I2C_ADDR_STB0899 (0xd0 >> 1)
  50 #define I2C_ADDR_STB6100 (0xc0 >> 1)
  51 #define I2C_ADDR_LNBP22  (0x10 >> 1)
  52 #define I2C_ADDR_24C16   (0xa0 >> 1)
  53 #define I2C_ADDR_24C64   (0xa2 >> 1)
  54
  55
  56 /* pctv452e sends us this amount of data for each issued usb-command */
  57 #define PCTV_ANSWER_LEN 64
  58 /* Wait up to 1000ms for device  */
  59 #define PCTV_TIMEOUT 1000
  60
  61
  62 #define PCTV_LED_GPIO   STB0899_GPIO01
  63 #define PCTV_LED_GREEN  0x82
  64 #define PCTV_LED_ORANGE 0x02
  65
  66 #define ci_dbg(format, arg...)                          \
  67 do {                                                    \
  68         if (0)                                          \
  69                 printk(KERN_DEBUG DVB_USB_LOG_PREFIX    \
  70                         ": " format "\n" , ## arg);     \
  71 } while (0)
  72
  73 enum {
  74         TT3650_CMD_CI_TEST = 0x40,
  75         TT3650_CMD_CI_RD_CTRL,
  76         TT3650_CMD_CI_WR_CTRL,
  77         TT3650_CMD_CI_RD_ATTR,
  78         TT3650_CMD_CI_WR_ATTR,
  79         TT3650_CMD_CI_RESET,
  80         TT3650_CMD_CI_SET_VIDEO_PORT
  81 };
  82
  83
  84 static struct stb0899_postproc pctv45e_postproc[] = {
  85         { PCTV_LED_GPIO, STB0899_GPIOPULLUP },
  86         { 0, 0 }
  87 };
  88
  89 static struct isl6423_config pctv452e_isl6423_config = {
  90         .current_max            = SEC_CURRENT_515m,
  91         .curlim                 = SEC_CURRENT_LIM_ON,
  92         .mod_extern             = 1,
  93         .addr                   = 0x08,
  94 };
  95
  96 /*
  97  * stores all private variables for communication with the PCTV452e DVB-S2
  98  */
  99 struct pctv452e_state {
 100         struct dvb_ca_en50221 ca;
 101         struct mutex ca_mutex;
 102
 103         u8 c;      /* transaction counter, wraps around...  */
 104         u8 initialized; /* set to 1 if 0x15 has been sent */
 105         u16 last_rc_key;
 106 };
 107
 108 static int tt3650_ci_msg(struct dvb_usb_device *d, u8 cmd, u8 *data,
 109                          unsigned int write_len, unsigned int read_len)
 110 {
 111         struct pctv452e_state *state = d->priv;
 112         u8 *buf;
 113         u8 id;
 114         unsigned int rlen;
 115         int ret;
 116
 117         if (!data || (write_len > 64 - 4) || (read_len > 64 - 4)) {
 118                 err("%s: transfer data invalid", __func__);
 119                 return -EIO;
 120         }
 121
 122         buf = kmalloc(64, GFP_KERNEL);
 123         if (!buf)
 124                 return -ENOMEM;
 125
 126         id = state->c++;
 127
 128         buf[0] = SYNC_BYTE_OUT;
 129         buf[1] = id;
 130         buf[2] = cmd;
 131         buf[3] = write_len;
 132
 133         memcpy(buf + 4, data, write_len);
 134
 135         rlen = (read_len > 0) ? 64 : 0;
 136         ret = dvb_usb_generic_rw(d, buf, 4 + write_len,
 137                                   buf, rlen, /* delay_ms */ 0);
 138         if (0 != ret)
 139                 goto failed;
 140
 141         ret = -EIO;
 142         if (SYNC_BYTE_IN != buf[0] || id != buf[1])
 143                 goto failed;
 144
 145         memcpy(data, buf + 4, read_len);
 146
 147         kfree(buf);
 148         return 0;
 149
 150 failed:
 151         err("CI error %d; %02X %02X %02X -> %*ph.",
 152              ret, SYNC_BYTE_OUT, id, cmd, 3, buf);
 153
 154         kfree(buf);
 155         return ret;
 156 }
 157
 158 static int tt3650_ci_msg_locked(struct dvb_ca_en50221 *ca,
 159                                 u8 cmd, u8 *data, unsigned int write_len,
 160                                 unsigned int read_len)
 161 {
 162         struct dvb_usb_device *d = ca->data;
 163         struct pctv452e_state *state = d->priv;
 164         int ret;
 165
 166         mutex_lock(&state->ca_mutex);
 167         ret = tt3650_ci_msg(d, cmd, data, write_len, read_len);
 168         mutex_unlock(&state->ca_mutex);
 169
 170         return ret;
 171 }
 172
 173 static int tt3650_ci_read_attribute_mem(struct dvb_ca_en50221 *ca,
 174                                  int slot, int address)
 175 {
 176         u8 buf[3];
 177         int ret;
 178
 179         if (0 != slot)
 180                 return -EINVAL;
 181
 182         buf[0] = (address >> 8) & 0x0F;
 183         buf[1] = address;
 184
 185         ret = tt3650_ci_msg_locked(ca, TT3650_CMD_CI_RD_ATTR, buf, 2, 3);
 186
 187         ci_dbg("%s %04x -> %d 0x%02x",
 188                 __func__, address, ret, buf[2]);
 189
 190         if (ret < 0)
 191                 return ret;
 192
 193         return buf[2];
 194 }
 195
 196 static int tt3650_ci_write_attribute_mem(struct dvb_ca_en50221 *ca,
 197                                  int slot, int address, u8 value)
 198 {
 199         u8 buf[3];
 200
 201         ci_dbg("%s %d 0x%04x 0x%02x",
 202                 __func__, slot, address, value);
 203
 204         if (0 != slot)
 205                 return -EINVAL;
 206
 207         buf[0] = (address >> 8) & 0x0F;
 208         buf[1] = address;
 209         buf[2] = value;
 210
 211         return tt3650_ci_msg_locked(ca, TT3650_CMD_CI_WR_ATTR, buf, 3, 3);
 212 }
 213
 214 static int tt3650_ci_read_cam_control(struct dvb_ca_en50221 *ca,
 215                                  int                    slot,
 216                                  u8                     address)
 217 {
 218         u8 buf[2];
 219         int ret;
 220
 221         if (0 != slot)
 222                 return -EINVAL;
 223
 224         buf[0] = address & 3;
 225
 226         ret = tt3650_ci_msg_locked(ca, TT3650_CMD_CI_RD_CTRL, buf, 1, 2);
 227
 228         ci_dbg("%s 0x%02x -> %d 0x%02x",
 229                 __func__, address, ret, buf[1]);
 230
 231         if (ret < 0)
 232                 return ret;
 233
 234         return buf[1];
 235 }
 236
 237 static int tt3650_ci_write_cam_control(struct dvb_ca_en50221 *ca,
 238                                  int                    slot,
 239                                  u8                     address,
 240                                  u8                     value)
 241 {
 242         u8 buf[2];
 243
 244         ci_dbg("%s %d 0x%02x 0x%02x",
 245                 __func__, slot, address, value);
 246
 247         if (0 != slot)
 248                 return -EINVAL;
 249
 250         buf[0] = address;
 251         buf[1] = value;
 252
 253         return tt3650_ci_msg_locked(ca, TT3650_CMD_CI_WR_CTRL, buf, 2, 2);
 254 }
 255
 256 static int tt3650_ci_set_video_port(struct dvb_ca_en50221 *ca,
 257                                  int                    slot,
 258                                  int                    enable)
 259 {
 260         u8 buf[1];
 261         int ret;
 262
 263         ci_dbg("%s %d %d", __func__, slot, enable);
 264
 265         if (0 != slot)
 266                 return -EINVAL;
 267
 268         enable = !!enable;
 269         buf[0] = enable;
 270
 271         ret = tt3650_ci_msg_locked(ca, TT3650_CMD_CI_SET_VIDEO_PORT, buf, 1, 1);
 272         if (ret < 0)
 273                 return ret;
 274
 275         if (enable != buf[0]) {
 276                 err("CI not %sabled.", enable ? "en" : "dis");
 277                 return -EIO;
 278         }
 279
 280         return 0;
 281 }
 282
 283 static int tt3650_ci_slot_shutdown(struct dvb_ca_en50221 *ca, int slot)
 284 {
 285         return tt3650_ci_set_video_port(ca, slot, /* enable */ 0);
 286 }
 287
 288 static int tt3650_ci_slot_ts_enable(struct dvb_ca_en50221 *ca, int slot)
 289 {
 290         return tt3650_ci_set_video_port(ca, slot, /* enable */ 1);
 291 }
 292
 293 static int tt3650_ci_slot_reset(struct dvb_ca_en50221 *ca, int slot)
 294 {
 295         struct dvb_usb_device *d = ca->data;
 296         struct pctv452e_state *state = d->priv;
 297         u8 buf[1];
 298         int ret;
 299
 300         ci_dbg("%s %d", __func__, slot);
 301
 302         if (0 != slot)
 303                 return -EINVAL;
 304
 305         buf[0] = 0;
 306
 307         mutex_lock(&state->ca_mutex);
 308
 309         ret = tt3650_ci_msg(d, TT3650_CMD_CI_RESET, buf, 1, 1);
 310         if (0 != ret)
 311                 goto failed;
 312
 313         msleep(500);
 314
 315         buf[0] = 1;
 316
 317         ret = tt3650_ci_msg(d, TT3650_CMD_CI_RESET, buf, 1, 1);
 318         if (0 != ret)
 319                 goto failed;
 320
 321         msleep(500);
 322
 323         buf[0] = 0; /* FTA */
 324
 325         ret = tt3650_ci_msg(d, TT3650_CMD_CI_SET_VIDEO_PORT, buf, 1, 1);
 326
 327  failed:
 328         mutex_unlock(&state->ca_mutex);
 329
 330         return ret;
 331 }
 332
 333 static int tt3650_ci_poll_slot_status(struct dvb_ca_en50221 *ca,
 334                                  int                    slot,
 335                                  int                    open)
 336 {
 337         u8 buf[1];
 338         int ret;
 339
 340         if (0 != slot)
 341                 return -EINVAL;
 342
 343         ret = tt3650_ci_msg_locked(ca, TT3650_CMD_CI_TEST, buf, 0, 1);
 344         if (0 != ret)
 345                 return ret;
 346
 347         if (1 == buf[0])
 348                 return DVB_CA_EN50221_POLL_CAM_PRESENT |
 349                         DVB_CA_EN50221_POLL_CAM_READY;
 350
 351         return 0;
 352
 353 }
 354
 355 static void tt3650_ci_uninit(struct dvb_usb_device *d)
 356 {
 357         struct pctv452e_state *state;
 358
 359         ci_dbg("%s", __func__);
 360
 361         if (NULL == d)
 362                 return;
 363
 364         state = d->priv;
 365         if (NULL == state)
 366                 return;
 367
 368         if (NULL == state->ca.data)
 369                 return;
 370
 371         /* Error ignored. */
 372         tt3650_ci_set_video_port(&state->ca, /* slot */ 0, /* enable */ 0);
 373
 374         dvb_ca_en50221_release(&state->ca);
 375
 376         memset(&state->ca, 0, sizeof(state->ca));
 377 }
 378
 379 static int tt3650_ci_init(struct dvb_usb_adapter *a)
 380 {
 381         struct dvb_usb_device *d = a->dev;
 382         struct pctv452e_state *state = d->priv;
 383         int ret;
 384
 385         ci_dbg("%s", __func__);
 386
 387         mutex_init(&state->ca_mutex);
 388
 389         state->ca.owner = THIS_MODULE;
 390         state->ca.read_attribute_mem = tt3650_ci_read_attribute_mem;
 391         state->ca.write_attribute_mem = tt3650_ci_write_attribute_mem;
 392         state->ca.read_cam_control = tt3650_ci_read_cam_control;
 393         state->ca.write_cam_control = tt3650_ci_write_cam_control;
 394         state->ca.slot_reset = tt3650_ci_slot_reset;
 395         state->ca.slot_shutdown = tt3650_ci_slot_shutdown;
 396         state->ca.slot_ts_enable = tt3650_ci_slot_ts_enable;
 397         state->ca.poll_slot_status = tt3650_ci_poll_slot_status;
 398         state->ca.data = d;
 399
 400         ret = dvb_ca_en50221_init(&a->dvb_adap,
 401                                    &state->ca,
 402                                    /* flags */ 0,
 403                                    /* n_slots */ 1);
 404         if (0 != ret) {
 405                 err("Cannot initialize CI: Error %d.", ret);
 406                 memset(&state->ca, 0, sizeof(state->ca));
 407                 return ret;
 408         }
 409
 410         info("CI initialized.");
 411
 412         return 0;
 413 }
 414
 415 #define CMD_BUFFER_SIZE 0x28
 416 static int pctv452e_i2c_msg(struct dvb_usb_device *d, u8 addr,
 417                                 const u8 *snd_buf, u8 snd_len,
 418                                 u8 *rcv_buf, u8 rcv_len)
 419 {
 420         struct pctv452e_state *state = d->priv;
 421         u8 *buf;
 422         u8 id;
 423         int ret;
 424
 425         buf = kmalloc(64, GFP_KERNEL);
 426         if (!buf)
 427                 return -ENOMEM;
 428
 429         id = state->c++;
 430
 431         ret = -EINVAL;
 432         if (snd_len > 64 - 7 || rcv_len > 64 - 7)
 433                 goto failed;
 434
 435         buf[0] = SYNC_BYTE_OUT;
 436         buf[1] = id;
 437         buf[2] = PCTV_CMD_I2C;
 438         buf[3] = snd_len + 3;
 439         buf[4] = addr << 1;
 440         buf[5] = snd_len;
 441         buf[6] = rcv_len;
 442
 443         memcpy(buf + 7, snd_buf, snd_len);
 444
 445         ret = dvb_usb_generic_rw(d, buf, 7 + snd_len,
 446                                   buf, /* rcv_len */ 64,
 447                                   /* delay_ms */ 0);
 448         if (ret < 0)
 449                 goto failed;
 450
 451         /* TT USB protocol error. */
 452         ret = -EIO;
 453         if (SYNC_BYTE_IN != buf[0] || id != buf[1])
 454                 goto failed;
 455
 456         /* I2C device didn't respond as expected. */
 457         ret = -EREMOTEIO;
 458         if (buf[5] < snd_len || buf[6] < rcv_len)
 459                 goto failed;
 460
 461         memcpy(rcv_buf, buf + 7, rcv_len);
 462
 463         kfree(buf);
 464         return rcv_len;
 465
 466 failed:
 467         err("I2C error %d; %02X %02X  %02X %02X %02X -> %*ph",
 468              ret, SYNC_BYTE_OUT, id, addr << 1, snd_len, rcv_len,
 469              7, buf);
 470
 471         kfree(buf);
 472         return ret;
 473 }
 474
 475 static int pctv452e_i2c_xfer(struct i2c_adapter *adapter, struct i2c_msg *msg,
 476                                 int num)
 477 {
 478         struct dvb_usb_device *d = i2c_get_adapdata(adapter);
 479         int i;
 480
 481         if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
 482                 return -EAGAIN;
 483
 484         for (i = 0; i < num; i++) {
 485                 u8 addr, snd_len, rcv_len, *snd_buf, *rcv_buf;
 486                 int ret;
 487
 488                 if (msg[i].flags & I2C_M_RD) {
 489                         addr = msg[i].addr;
 490                         snd_buf = NULL;
 491                         snd_len = 0;
 492                         rcv_buf = msg[i].buf;
 493                         rcv_len = msg[i].len;
 494                 } else {
 495                         addr = msg[i].addr;
 496                         snd_buf = msg[i].buf;
 497                         snd_len = msg[i].len;
 498                         rcv_buf = NULL;
 499                         rcv_len = 0;
 500                 }
 501
 502                 ret = pctv452e_i2c_msg(d, addr, snd_buf, snd_len, rcv_buf,
 503                                         rcv_len);
 504                 if (ret < rcv_len)
 505                         break;
 506         }
 507
 508         mutex_unlock(&d->i2c_mutex);
 509         return i;
 510 }
 511
 512 static u32 pctv452e_i2c_func(struct i2c_adapter *adapter)
 513 {
 514         return I2C_FUNC_I2C;
 515 }
 516
 517 static int pctv452e_power_ctrl(struct dvb_usb_device *d, int i)
 518 {
 519         struct pctv452e_state *state = d->priv;
 520         u8 *b0, *rx;
 521         int ret;
 522
 523         info("%s: %d\n", __func__, i);
 524
 525         if (!i)
 526                 return 0;
 527
 528         if (state->initialized)
 529                 return 0;
 530
 531         b0 = kmalloc(5 + PCTV_ANSWER_LEN, GFP_KERNEL);
 532         if (!b0)
 533                 return -ENOMEM;
 534
 535         rx = b0 + 5;
 536
 537         /* hmm where should this should go? */
 538         ret = usb_set_interface(d->udev, 0, ISOC_INTERFACE_ALTERNATIVE);
 539         if (ret != 0)
 540                 info("%s: Warning set interface returned: %d\n",
 541                         __func__, ret);
 542
 543         /* this is a one-time initialization, don't know where to put */
 544         b0[0] = 0xaa;
 545         b0[1] = state->c++;
 546         b0[2] = PCTV_CMD_RESET;
 547         b0[3] = 1;
 548         b0[4] = 0;
 549         /* reset board */
 550         ret = dvb_usb_generic_rw(d, b0, 5, rx, PCTV_ANSWER_LEN, 0);
 551         if (ret)
 552                 goto ret;
 553
 554         b0[1] = state->c++;
 555         b0[4] = 1;
 556         /* reset board (again?) */
 557         ret = dvb_usb_generic_rw(d, b0, 5, rx, PCTV_ANSWER_LEN, 0);
 558         if (ret)
 559                 goto ret;
 560
 561         state->initialized = 1;
 562
 563 ret:
 564         kfree(b0);
 565         return ret;
 566 }
 567
 568 static int pctv452e_rc_query(struct dvb_usb_device *d)
 569 {
 570         struct pctv452e_state *state = d->priv;
 571         u8 *b, *rx;
 572         int ret, i;
 573         u8 id;
 574
 575         b = kmalloc(CMD_BUFFER_SIZE + PCTV_ANSWER_LEN, GFP_KERNEL);
 576         if (!b)
 577                 return -ENOMEM;
 578
 579         rx = b + CMD_BUFFER_SIZE;
 580
 581         id = state->c++;
 582
 583         /* prepare command header  */
 584         b[0] = SYNC_BYTE_OUT;
 585         b[1] = id;
 586         b[2] = PCTV_CMD_IR;
 587         b[3] = 0;
 588
 589         /* send ir request */
 590         ret = dvb_usb_generic_rw(d, b, 4, rx, PCTV_ANSWER_LEN, 0);
 591         if (ret != 0)
 592                 goto ret;
 593
 594         if (debug > 3) {
 595                 info("%s: read: %2d: %*ph: ", __func__, ret, 3, rx);
 596                 for (i = 0; (i < rx[3]) && ((i+3) < PCTV_ANSWER_LEN); i++)
 597                         info(" %02x", rx[i+3]);
 598
 599                 info("\n");
 600         }
 601
 602         if ((rx[3] == 9) &&  (rx[12] & 0x01)) {
 603                 /* got a "press" event */
 604                 state->last_rc_key = RC_SCANCODE_RC5(rx[7], rx[6]);
 605                 if (debug > 2)
 606                         info("%s: cmd=0x%02x sys=0x%02x\n",
 607                                 __func__, rx[6], rx[7]);
 608
 609                 rc_keydown(d->rc_dev, RC_PROTO_RC5, state->last_rc_key, 0);
 610         } else if (state->last_rc_key) {
 611                 rc_keyup(d->rc_dev);
 612                 state->last_rc_key = 0;
 613         }
 614 ret:
 615         kfree(b);
 616         return ret;
 617 }
 618
 619 static int pctv452e_read_mac_address(struct dvb_usb_device *d, u8 mac[6])
 620 {
 621         const u8 mem_addr[] = { 0x1f, 0xcc };
 622         u8 encoded_mac[20];
 623         int ret;
 624
 625         ret = -EAGAIN;
 626         if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
 627                 goto failed;
 628
 629         ret = pctv452e_i2c_msg(d, I2C_ADDR_24C16,
 630                                 mem_addr + 1, /* snd_len */ 1,
 631                                 encoded_mac, /* rcv_len */ 20);
 632         if (-EREMOTEIO == ret)
 633                 /* Caution! A 24C16 interprets 0xA2 0x1F 0xCC as a
 634                    byte write if /WC is low. */
 635                 ret = pctv452e_i2c_msg(d, I2C_ADDR_24C64,
 636                                         mem_addr, 2,
 637                                         encoded_mac, 20);
 638
 639         mutex_unlock(&d->i2c_mutex);
 640
 641         if (20 != ret)
 642                 goto failed;
 643
 644         ret = ttpci_eeprom_decode_mac(mac, encoded_mac);
 645         if (0 != ret)
 646                 goto failed;
 647
 648         return 0;
 649
 650 failed:
 651         eth_zero_addr(mac);
 652
 653         return ret;
 654 }
 655
 656 static const struct stb0899_s1_reg pctv452e_init_dev[] = {
 657         { STB0899_DISCNTRL1,    0x26 },
 658         { STB0899_DISCNTRL2,    0x80 },
 659         { STB0899_DISRX_ST0,    0x04 },
 660         { STB0899_DISRX_ST1,    0x20 },
 661         { STB0899_DISPARITY,    0x00 },
 662         { STB0899_DISFIFO,      0x00 },
 663         { STB0899_DISF22,       0x99 },
 664         { STB0899_DISF22RX,     0x85 }, /* 0xa8 */
 665         { STB0899_ACRPRESC,     0x11 },
 666         { STB0899_ACRDIV1,      0x0a },
 667         { STB0899_ACRDIV2,      0x05 },
 668         { STB0899_DACR1 ,       0x00 },
 669         { STB0899_DACR2 ,       0x00 },
 670         { STB0899_OUTCFG,       0x00 },
 671         { STB0899_MODECFG,      0x00 }, /* Inversion */
 672         { STB0899_IRQMSK_3,     0xf3 },
 673         { STB0899_IRQMSK_2,     0xfc },
 674         { STB0899_IRQMSK_1,     0xff },
 675         { STB0899_IRQMSK_0,     0xff },
 676         { STB0899_I2CCFG,       0x88 },
 677         { STB0899_I2CRPT,       0x58 },
 678         { STB0899_GPIO00CFG,    0x82 },
 679         { STB0899_GPIO01CFG,    0x82 }, /* LED: 0x02 green, 0x82 orange */
 680         { STB0899_GPIO02CFG,    0x82 },
 681         { STB0899_GPIO03CFG,    0x82 },
 682         { STB0899_GPIO04CFG,    0x82 },
 683         { STB0899_GPIO05CFG,    0x82 },
 684         { STB0899_GPIO06CFG,    0x82 },
 685         { STB0899_GPIO07CFG,    0x82 },
 686         { STB0899_GPIO08CFG,    0x82 },
 687         { STB0899_GPIO09CFG,    0x82 },
 688         { STB0899_GPIO10CFG,    0x82 },
 689         { STB0899_GPIO11CFG,    0x82 },
 690         { STB0899_GPIO12CFG,    0x82 },
 691         { STB0899_GPIO13CFG,    0x82 },
 692         { STB0899_GPIO14CFG,    0x82 },
 693         { STB0899_GPIO15CFG,    0x82 },
 694         { STB0899_GPIO16CFG,    0x82 },
 695         { STB0899_GPIO17CFG,    0x82 },
 696         { STB0899_GPIO18CFG,    0x82 },
 697         { STB0899_GPIO19CFG,    0x82 },
 698         { STB0899_GPIO20CFG,    0x82 },
 699         { STB0899_SDATCFG,      0xb8 },
 700         { STB0899_SCLTCFG,      0xba },
 701         { STB0899_AGCRFCFG,     0x1c }, /* 0x11 DVB-S; 0x1c DVB-S2 (1c, rjkm) */
 702         { STB0899_GPIO22,       0x82 },
 703         { STB0899_GPIO21,       0x91 },
 704         { STB0899_DIRCLKCFG,    0x82 },
 705         { STB0899_CLKOUT27CFG,  0x7e },
 706         { STB0899_STDBYCFG,     0x82 },
 707         { STB0899_CS0CFG,       0x82 },
 708         { STB0899_CS1CFG,       0x82 },
 709         { STB0899_DISEQCOCFG,   0x20 },
 710         { STB0899_NCOARSE,      0x15 }, /* 0x15 27Mhz, F/3 198MHz, F/6 108MHz */
 711         { STB0899_SYNTCTRL,     0x00 }, /* 0x00 CLKI, 0x02 XTALI */
 712         { STB0899_FILTCTRL,     0x00 },
 713         { STB0899_SYSCTRL,      0x00 },
 714         { STB0899_STOPCLK1,     0x20 }, /* orig: 0x00 budget-ci: 0x20 */
 715         { STB0899_STOPCLK2,     0x00 },
 716         { STB0899_INTBUFCTRL,   0x0a },
 717         { STB0899_AGC2I1,       0x00 },
 718         { STB0899_AGC2I2,       0x00 },
 719         { STB0899_AGCIQIN,      0x00 },
 720         { STB0899_TSTRES,       0x40 }, /* rjkm */
 721         { 0xffff,               0xff },
 722 };
 723
 724 static const struct stb0899_s1_reg pctv452e_init_s1_demod[] = {
 725         { STB0899_DEMOD,        0x00 },
 726         { STB0899_RCOMPC,       0xc9 },
 727         { STB0899_AGC1CN,       0x01 },
 728         { STB0899_AGC1REF,      0x10 },
 729         { STB0899_RTC,          0x23 },
 730         { STB0899_TMGCFG,       0x4e },
 731         { STB0899_AGC2REF,      0x34 },
 732         { STB0899_TLSR,         0x84 },
 733         { STB0899_CFD,          0xf7 },
 734         { STB0899_ACLC,         0x87 },
 735         { STB0899_BCLC,         0x94 },
 736         { STB0899_EQON,         0x41 },
 737         { STB0899_LDT,          0xf1 },
 738         { STB0899_LDT2,         0xe3 },
 739         { STB0899_EQUALREF,     0xb4 },
 740         { STB0899_TMGRAMP,      0x10 },
 741         { STB0899_TMGTHD,       0x30 },
 742         { STB0899_IDCCOMP,      0xfd },
 743         { STB0899_QDCCOMP,      0xff },
 744         { STB0899_POWERI,       0x0c },
 745         { STB0899_POWERQ,       0x0f },
 746         { STB0899_RCOMP,        0x6c },
 747         { STB0899_AGCIQIN,      0x80 },
 748         { STB0899_AGC2I1,       0x06 },
 749         { STB0899_AGC2I2,       0x00 },
 750         { STB0899_TLIR,         0x30 },
 751         { STB0899_RTF,          0x7f },
 752         { STB0899_DSTATUS,      0x00 },
 753         { STB0899_LDI,          0xbc },
 754         { STB0899_CFRM,         0xea },
 755         { STB0899_CFRL,         0x31 },
 756         { STB0899_NIRM,         0x2b },
 757         { STB0899_NIRL,         0x80 },
 758         { STB0899_ISYMB,        0x1d },
 759         { STB0899_QSYMB,        0xa6 },
 760         { STB0899_SFRH,         0x2f },
 761         { STB0899_SFRM,         0x68 },
 762         { STB0899_SFRL,         0x40 },
 763         { STB0899_SFRUPH,       0x2f },
 764         { STB0899_SFRUPM,       0x68 },
 765         { STB0899_SFRUPL,       0x40 },
 766         { STB0899_EQUAI1,       0x02 },
 767         { STB0899_EQUAQ1,       0xff },
 768         { STB0899_EQUAI2,       0x04 },
 769         { STB0899_EQUAQ2,       0x05 },
 770         { STB0899_EQUAI3,       0x02 },
 771         { STB0899_EQUAQ3,       0xfd },
 772         { STB0899_EQUAI4,       0x03 },
 773         { STB0899_EQUAQ4,       0x07 },
 774         { STB0899_EQUAI5,       0x08 },
 775         { STB0899_EQUAQ5,       0xf5 },
 776         { STB0899_DSTATUS2,     0x00 },
 777         { STB0899_VSTATUS,      0x00 },
 778         { STB0899_VERROR,       0x86 },
 779         { STB0899_IQSWAP,       0x2a },
 780         { STB0899_ECNT1M,       0x00 },
 781         { STB0899_ECNT1L,       0x00 },
 782         { STB0899_ECNT2M,       0x00 },
 783         { STB0899_ECNT2L,       0x00 },
 784         { STB0899_ECNT3M,       0x0a },
 785         { STB0899_ECNT3L,       0xad },
 786         { STB0899_FECAUTO1,     0x06 },
 787         { STB0899_FECM,         0x01 },
 788         { STB0899_VTH12,        0xb0 },
 789         { STB0899_VTH23,        0x7a },
 790         { STB0899_VTH34,        0x58 },
 791         { STB0899_VTH56,        0x38 },
 792         { STB0899_VTH67,        0x34 },
 793         { STB0899_VTH78,        0x24 },
 794         { STB0899_PRVIT,        0xff },
 795         { STB0899_VITSYNC,      0x19 },
 796         { STB0899_RSULC,        0xb1 }, /* DVB = 0xb1, DSS = 0xa1 */
 797         { STB0899_TSULC,        0x42 },
 798         { STB0899_RSLLC,        0x41 },
 799         { STB0899_TSLPL,        0x12 },
 800         { STB0899_TSCFGH,       0x0c },
 801         { STB0899_TSCFGM,       0x00 },
 802         { STB0899_TSCFGL,       0x00 },
 803         { STB0899_TSOUT,        0x69 }, /* 0x0d for CAM */
 804         { STB0899_RSSYNCDEL,    0x00 },
 805         { STB0899_TSINHDELH,    0x02 },
 806         { STB0899_TSINHDELM,    0x00 },
 807         { STB0899_TSINHDELL,    0x00 },
 808         { STB0899_TSLLSTKM,     0x1b },
 809         { STB0899_TSLLSTKL,     0xb3 },
 810         { STB0899_TSULSTKM,     0x00 },
 811         { STB0899_TSULSTKL,     0x00 },
 812         { STB0899_PCKLENUL,     0xbc },
 813         { STB0899_PCKLENLL,     0xcc },
 814         { STB0899_RSPCKLEN,     0xbd },
 815         { STB0899_TSSTATUS,     0x90 },
 816         { STB0899_ERRCTRL1,     0xb6 },
 817         { STB0899_ERRCTRL2,     0x95 },
 818         { STB0899_ERRCTRL3,     0x8d },
 819         { STB0899_DMONMSK1,     0x27 },
 820         { STB0899_DMONMSK0,     0x03 },
 821         { STB0899_DEMAPVIT,     0x5c },
 822         { STB0899_PLPARM,       0x19 },
 823         { STB0899_PDELCTRL,     0x48 },
 824         { STB0899_PDELCTRL2,    0x00 },
 825         { STB0899_BBHCTRL1,     0x00 },
 826         { STB0899_BBHCTRL2,     0x00 },
 827         { STB0899_HYSTTHRESH,   0x77 },
 828         { STB0899_MATCSTM,      0x00 },
 829         { STB0899_MATCSTL,      0x00 },
 830         { STB0899_UPLCSTM,      0x00 },
 831         { STB0899_UPLCSTL,      0x00 },
 832         { STB0899_DFLCSTM,      0x00 },
 833         { STB0899_DFLCSTL,      0x00 },
 834         { STB0899_SYNCCST,      0x00 },
 835         { STB0899_SYNCDCSTM,    0x00 },
 836         { STB0899_SYNCDCSTL,    0x00 },
 837         { STB0899_ISI_ENTRY,    0x00 },
 838         { STB0899_ISI_BIT_EN,   0x00 },
 839         { STB0899_MATSTRM,      0xf0 },
 840         { STB0899_MATSTRL,      0x02 },
 841         { STB0899_UPLSTRM,      0x45 },
 842         { STB0899_UPLSTRL,      0x60 },
 843         { STB0899_DFLSTRM,      0xe3 },
 844         { STB0899_DFLSTRL,      0x00 },
 845         { STB0899_SYNCSTR,      0x47 },
 846         { STB0899_SYNCDSTRM,    0x05 },
 847         { STB0899_SYNCDSTRL,    0x18 },
 848         { STB0899_CFGPDELSTATUS1, 0x19 },
 849         { STB0899_CFGPDELSTATUS2, 0x2b },
 850         { STB0899_BBFERRORM,    0x00 },
 851         { STB0899_BBFERRORL,    0x01 },
 852         { STB0899_UPKTERRORM,   0x00 },
 853         { STB0899_UPKTERRORL,   0x00 },
 854         { 0xffff,               0xff },
 855 };
 856
 857 static struct stb0899_config stb0899_config = {
 858         .init_dev       = pctv452e_init_dev,
 859         .init_s2_demod  = stb0899_s2_init_2,
 860         .init_s1_demod  = pctv452e_init_s1_demod,
 861         .init_s2_fec    = stb0899_s2_init_4,
 862         .init_tst       = stb0899_s1_init_5,
 863
 864         .demod_address   = I2C_ADDR_STB0899, /* I2C Address */
 865         .block_sync_mode = STB0899_SYNC_FORCED, /* ? */
 866
 867         .xtal_freq       = 27000000,     /* Assume Hz ? */
 868         .inversion       = IQ_SWAP_ON,
 869
 870         .lo_clk   = 76500000,
 871         .hi_clk   = 99000000,
 872
 873         .ts_output_mode  = 0,   /* Use parallel mode */
 874         .clock_polarity  = 0,
 875         .data_clk_parity = 0,
 876         .fec_mode       = 0,
 877
 878         .esno_ave           = STB0899_DVBS2_ESNO_AVE,
 879         .esno_quant       = STB0899_DVBS2_ESNO_QUANT,
 880         .avframes_coarse     = STB0899_DVBS2_AVFRAMES_COARSE,
 881         .avframes_fine       = STB0899_DVBS2_AVFRAMES_FINE,
 882         .miss_threshold      = STB0899_DVBS2_MISS_THRESHOLD,
 883         .uwp_threshold_acq   = STB0899_DVBS2_UWP_THRESHOLD_ACQ,
 884         .uwp_threshold_track = STB0899_DVBS2_UWP_THRESHOLD_TRACK,
 885         .uwp_threshold_sof   = STB0899_DVBS2_UWP_THRESHOLD_SOF,
 886         .sof_search_timeout  = STB0899_DVBS2_SOF_SEARCH_TIMEOUT,
 887
 888         .btr_nco_bits     = STB0899_DVBS2_BTR_NCO_BITS,
 889         .btr_gain_shift_offset = STB0899_DVBS2_BTR_GAIN_SHIFT_OFFSET,
 890         .crl_nco_bits     = STB0899_DVBS2_CRL_NCO_BITS,
 891         .ldpc_max_iter   = STB0899_DVBS2_LDPC_MAX_ITER,
 892
 893         .tuner_get_frequency    = stb6100_get_frequency,
 894         .tuner_set_frequency    = stb6100_set_frequency,
 895         .tuner_set_bandwidth    = stb6100_set_bandwidth,
 896         .tuner_get_bandwidth    = stb6100_get_bandwidth,
 897         .tuner_set_rfsiggain    = NULL,
 898
 899         /* helper for switching LED green/orange */
 900         .postproc = pctv45e_postproc
 901 };
 902
 903 static struct stb6100_config stb6100_config = {
 904         .tuner_address = I2C_ADDR_STB6100,
 905         .refclock      = 27000000
 906 };
 907
 908
 909 static struct i2c_algorithm pctv452e_i2c_algo = {
 910         .master_xfer   = pctv452e_i2c_xfer,
 911         .functionality = pctv452e_i2c_func
 912 };
 913
 914 static int pctv452e_frontend_attach(struct dvb_usb_adapter *a)
 915 {
 916         struct usb_device_id *id;
 917
 918         a->fe_adap[0].fe = dvb_attach(stb0899_attach, &stb0899_config,
 919                                                 &a->dev->i2c_adap);
 920         if (!a->fe_adap[0].fe)
 921                 return -ENODEV;
 922
 923         id = a->dev->desc->warm_ids[0];
 924         if (id->idVendor == USB_VID_TECHNOTREND &&
 925             id->idProduct == USB_PID_TECHNOTREND_CONNECT_S2_3650_CI) {
 926                 if (dvb_attach(lnbp22_attach,
 927                                a->fe_adap[0].fe,
 928                                &a->dev->i2c_adap) == NULL) {
 929                         err("Cannot attach lnbp22\n");
 930                 }
 931                 /* Error ignored. */
 932                 tt3650_ci_init(a);
 933         } else if (dvb_attach(isl6423_attach,
 934                               a->fe_adap[0].fe,
 935                               &a->dev->i2c_adap,
 936                               &pctv452e_isl6423_config) == NULL) {
 937                 err("Cannot attach isl6423\n");
 938         }
 939
 940         return 0;
 941 }
 942
 943 static int pctv452e_tuner_attach(struct dvb_usb_adapter *a)
 944 {
 945         if (!a->fe_adap[0].fe)
 946                 return -ENODEV;
 947         if (dvb_attach(stb6100_attach, a->fe_adap[0].fe, &stb6100_config,
 948                                         &a->dev->i2c_adap) == NULL) {
 949                 err("%s failed\n", __func__);
 950                 return -ENODEV;
 951         }
 952
 953         return 0;
 954 }
 955
 956 enum {
 957         PINNACLE_PCTV_452E,
 958         TECHNOTREND_CONNECT_S2_3600,
 959         TECHNOTREND_CONNECT_S2_3650_CI,
 960 };
 961
 962 static struct usb_device_id pctv452e_usb_table[] = {
 963         DVB_USB_DEV(PINNACLE, PINNACLE_PCTV_452E),
 964         DVB_USB_DEV(TECHNOTREND, TECHNOTREND_CONNECT_S2_3600),
 965         DVB_USB_DEV(TECHNOTREND, TECHNOTREND_CONNECT_S2_3650_CI),
 966         { }
 967 };
 968
 969 MODULE_DEVICE_TABLE(usb, pctv452e_usb_table);
 970
 971 static struct dvb_usb_device_properties pctv452e_properties = {
 972         .caps = DVB_USB_IS_AN_I2C_ADAPTER, /* more ? */
 973         .usb_ctrl = DEVICE_SPECIFIC,
 974
 975         .size_of_priv     = sizeof(struct pctv452e_state),
 976
 977         .power_ctrl       = pctv452e_power_ctrl,
 978
 979         .rc.core = {
 980                 .rc_codes       = RC_MAP_DIB0700_RC5_TABLE,
 981                 .allowed_protos = RC_PROTO_BIT_RC5,
 982                 .rc_query       = pctv452e_rc_query,
 983                 .rc_interval    = 100,
 984         },
 985
 986         .num_adapters     = 1,
 987         .adapter = {{
 988                 .num_frontends = 1,
 989                 .fe = {{
 990                         .frontend_attach  = pctv452e_frontend_attach,
 991                         .tuner_attach     = pctv452e_tuner_attach,
 992
 993                         /* parameter for the MPEG2-data transfer */
 994                         .stream = {
 995                                 .type     = USB_ISOC,
 996                                 .count    = 4,
 997                                 .endpoint = 0x02,
 998                                 .u = {
 999                                         .isoc = {
1000                                                 .framesperurb = 4,
1001                                                 .framesize    = 940,
1002                                                 .interval     = 1
1003                                         }
1004                                 }
1005                         },
1006                 } },
1007         } },
1008
1009         .i2c_algo = &pctv452e_i2c_algo,
1010
1011         .generic_bulk_ctrl_endpoint = 1, /* allow generice rw function */
1012
1013         .num_device_descs = 1,
1014         .devices = {
1015                 { .name = "PCTV HDTV USB",
1016                   .cold_ids = { NULL, NULL }, /* this is a warm only device */
1017                   .warm_ids = { &pctv452e_usb_table[PINNACLE_PCTV_452E], NULL }
1018                 },
1019                 { NULL },
1020         }
1021 };
1022
1023 static struct dvb_usb_device_properties tt_connect_s2_3600_properties = {
1024         .caps = DVB_USB_IS_AN_I2C_ADAPTER, /* more ? */
1025         .usb_ctrl = DEVICE_SPECIFIC,
1026
1027         .size_of_priv           = sizeof(struct pctv452e_state),
1028
1029         .power_ctrl             = pctv452e_power_ctrl,
1030         .read_mac_address       = pctv452e_read_mac_address,
1031
1032         .rc.core = {
1033                 .rc_codes       = RC_MAP_TT_1500,
1034                 .allowed_protos = RC_PROTO_BIT_RC5,
1035                 .rc_query       = pctv452e_rc_query,
1036                 .rc_interval    = 100,
1037         },
1038
1039         .num_adapters           = 1,
1040         .adapter = {{
1041                 .num_frontends = 1,
1042                 .fe = {{
1043                         .frontend_attach = pctv452e_frontend_attach,
1044                         .tuner_attach = pctv452e_tuner_attach,
1045
1046                         /* parameter for the MPEG2-data transfer */
1047                         .stream = {
1048                                 .type = USB_ISOC,
1049                                 .count = 4,
1050                                 .endpoint = 0x02,
1051                                 .u = {
1052                                         .isoc = {
1053                                                 .framesperurb = 64,
1054                                                 .framesize = 940,
1055                                                 .interval = 1
1056                                         }
1057                                 }
1058                         },
1059
1060                 } },
1061         } },
1062
1063         .i2c_algo = &pctv452e_i2c_algo,
1064
1065         .generic_bulk_ctrl_endpoint = 1, /* allow generic rw function*/
1066
1067         .num_device_descs = 2,
1068         .devices = {
1069                 { .name = "Technotrend TT Connect S2-3600",
1070                   .cold_ids = { NULL, NULL }, /* this is a warm only device */
1071                   .warm_ids = { &pctv452e_usb_table[TECHNOTREND_CONNECT_S2_3600], NULL }
1072                 },
1073                 { .name = "Technotrend TT Connect S2-3650-CI",
1074                   .cold_ids = { NULL, NULL },
1075                   .warm_ids = { &pctv452e_usb_table[TECHNOTREND_CONNECT_S2_3650_CI], NULL }
1076                 },
1077                 { NULL },
1078         }
1079 };
1080
1081 static void pctv452e_usb_disconnect(struct usb_interface *intf)
1082 {
1083         struct dvb_usb_device *d = usb_get_intfdata(intf);
1084
1085         tt3650_ci_uninit(d);
1086         dvb_usb_device_exit(intf);
1087 }
1088
1089 static int pctv452e_usb_probe(struct usb_interface *intf,
1090                                 const struct usb_device_id *id)
1091 {
1092         if (0 == dvb_usb_device_init(intf, &pctv452e_properties,
1093                                         THIS_MODULE, NULL, adapter_nr) ||
1094             0 == dvb_usb_device_init(intf, &tt_connect_s2_3600_properties,
1095                                         THIS_MODULE, NULL, adapter_nr))
1096                 return 0;
1097
1098         return -ENODEV;
1099 }
1100
1101 static struct usb_driver pctv452e_usb_driver = {
1102         .name       = "pctv452e",
1103         .probe      = pctv452e_usb_probe,
1104         .disconnect = pctv452e_usb_disconnect,
1105         .id_table   = pctv452e_usb_table,
1106 };
1107
1108 module_usb_driver(pctv452e_usb_driver);
1109
1110 MODULE_AUTHOR("Dominik Kuhlen <dkuhlen@gmx.net>");
1111 MODULE_AUTHOR("Andre Weidemann <Andre.Weidemann@web.de>");
1112 MODULE_AUTHOR("Michael H. Schimek <mschimek@gmx.at>");
1113 MODULE_DESCRIPTION("Pinnacle PCTV HDTV USB DVB / TT connect S2-3600 Driver");
1114 MODULE_LICENSE("GPL");