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