linux/drivers/media/usb/dvb-usb/opera1.c
<<
>>
Prefs
   1/* DVB USB framework compliant Linux driver for the Opera1 DVB-S Card
   2*
   3* Copyright (C) 2006 Mario Hlawitschka (dh1pa@amsat.org)
   4* Copyright (C) 2006 Marco Gittler (g.marco@freenet.de)
   5*
   6*       This program is free software; you can redistribute it and/or modify it
   7*       under the terms of the GNU General Public License as published by the Free
   8*       Software Foundation, version 2.
   9*
  10* see Documentation/media/dvb-drivers/dvb-usb.rst for more information
  11*/
  12
  13#define DVB_USB_LOG_PREFIX "opera"
  14
  15#include "dvb-usb.h"
  16#include "stv0299.h"
  17
  18#define OPERA_READ_MSG 0
  19#define OPERA_WRITE_MSG 1
  20#define OPERA_I2C_TUNER 0xd1
  21
  22#define READ_FX2_REG_REQ  0xba
  23#define READ_MAC_ADDR 0x08
  24#define OPERA_WRITE_FX2 0xbb
  25#define OPERA_TUNER_REQ 0xb1
  26#define REG_1F_SYMBOLRATE_BYTE0 0x1f
  27#define REG_20_SYMBOLRATE_BYTE1 0x20
  28#define REG_21_SYMBOLRATE_BYTE2 0x21
  29
  30#define ADDR_B600_VOLTAGE_13V (0x02)
  31#define ADDR_B601_VOLTAGE_18V (0x03)
  32#define ADDR_B1A6_STREAM_CTRL (0x04)
  33#define ADDR_B880_READ_REMOTE (0x05)
  34
  35struct opera1_state {
  36        u32 last_key_pressed;
  37};
  38struct rc_map_opera_table {
  39        u32 keycode;
  40        u32 event;
  41};
  42
  43static int dvb_usb_opera1_debug;
  44module_param_named(debug, dvb_usb_opera1_debug, int, 0644);
  45MODULE_PARM_DESC(debug,
  46                 "set debugging level (1=info,xfer=2,pll=4,ts=8,err=16,rc=32,fw=64 (or-able))."
  47                 DVB_USB_DEBUG_STATUS);
  48
  49DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  50
  51
  52static int opera1_xilinx_rw(struct usb_device *dev, u8 request, u16 value,
  53                            u8 * data, u16 len, int flags)
  54{
  55        int ret;
  56        u8 tmp;
  57        u8 *buf;
  58        unsigned int pipe = (flags == OPERA_READ_MSG) ?
  59                usb_rcvctrlpipe(dev,0) : usb_sndctrlpipe(dev, 0);
  60        u8 request_type = (flags == OPERA_READ_MSG) ? USB_DIR_IN : USB_DIR_OUT;
  61
  62        buf = kmalloc(len, GFP_KERNEL);
  63        if (!buf)
  64                return -ENOMEM;
  65
  66        if (flags == OPERA_WRITE_MSG)
  67                memcpy(buf, data, len);
  68        ret = usb_control_msg(dev, pipe, request,
  69                        request_type | USB_TYPE_VENDOR, value, 0x0,
  70                        buf, len, 2000);
  71
  72        if (request == OPERA_TUNER_REQ) {
  73                tmp = buf[0];
  74                if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
  75                            OPERA_TUNER_REQ, USB_DIR_IN | USB_TYPE_VENDOR,
  76                            0x01, 0x0, buf, 1, 2000) < 1 || buf[0] != 0x08) {
  77                        ret = 0;
  78                        goto out;
  79                }
  80                buf[0] = tmp;
  81        }
  82        if (flags == OPERA_READ_MSG)
  83                memcpy(data, buf, len);
  84out:
  85        kfree(buf);
  86        return ret;
  87}
  88
  89/* I2C */
  90
  91static int opera1_usb_i2c_msgxfer(struct dvb_usb_device *dev, u16 addr,
  92                                  u8 * buf, u16 len)
  93{
  94        int ret = 0;
  95        u8 request;
  96        u16 value;
  97
  98        if (!dev) {
  99                info("no usb_device");
 100                return -EINVAL;
 101        }
 102        if (mutex_lock_interruptible(&dev->usb_mutex) < 0)
 103                return -EAGAIN;
 104
 105        switch (addr>>1){
 106                case ADDR_B600_VOLTAGE_13V:
 107                        request=0xb6;
 108                        value=0x00;
 109                        break;
 110                case ADDR_B601_VOLTAGE_18V:
 111                        request=0xb6;
 112                        value=0x01;
 113                        break;
 114                case ADDR_B1A6_STREAM_CTRL:
 115                        request=0xb1;
 116                        value=0xa6;
 117                        break;
 118                case ADDR_B880_READ_REMOTE:
 119                        request=0xb8;
 120                        value=0x80;
 121                        break;
 122                default:
 123                        request=0xb1;
 124                        value=addr;
 125        }
 126        ret = opera1_xilinx_rw(dev->udev, request,
 127                value, buf, len,
 128                addr&0x01?OPERA_READ_MSG:OPERA_WRITE_MSG);
 129
 130        mutex_unlock(&dev->usb_mutex);
 131        return ret;
 132}
 133
 134static int opera1_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
 135                           int num)
 136{
 137        struct dvb_usb_device *d = i2c_get_adapdata(adap);
 138        int i = 0, tmp = 0;
 139
 140        if (!d)
 141                return -ENODEV;
 142        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
 143                return -EAGAIN;
 144
 145        for (i = 0; i < num; i++) {
 146                if ((tmp = opera1_usb_i2c_msgxfer(d,
 147                                        (msg[i].addr<<1)|(msg[i].flags&I2C_M_RD?0x01:0),
 148                                        msg[i].buf,
 149                                        msg[i].len
 150                                        )) != msg[i].len) {
 151                        break;
 152                }
 153                if (dvb_usb_opera1_debug & 0x10)
 154                        info("sending i2c message %d %d", tmp, msg[i].len);
 155        }
 156        mutex_unlock(&d->i2c_mutex);
 157        return num;
 158}
 159
 160static u32 opera1_i2c_func(struct i2c_adapter *adapter)
 161{
 162        return I2C_FUNC_I2C;
 163}
 164
 165static struct i2c_algorithm opera1_i2c_algo = {
 166        .master_xfer = opera1_i2c_xfer,
 167        .functionality = opera1_i2c_func,
 168};
 169
 170static int opera1_set_voltage(struct dvb_frontend *fe,
 171                              enum fe_sec_voltage voltage)
 172{
 173        static u8 command_13v[1]={0x00};
 174        static u8 command_18v[1]={0x01};
 175        struct i2c_msg msg[] = {
 176                {.addr = ADDR_B600_VOLTAGE_13V,.flags = 0,.buf = command_13v,.len = 1},
 177        };
 178        struct dvb_usb_adapter *udev_adap =
 179            (struct dvb_usb_adapter *)(fe->dvb->priv);
 180        if (voltage == SEC_VOLTAGE_18) {
 181                msg[0].addr = ADDR_B601_VOLTAGE_18V;
 182                msg[0].buf = command_18v;
 183        }
 184        i2c_transfer(&udev_adap->dev->i2c_adap, msg, 1);
 185        return 0;
 186}
 187
 188static int opera1_stv0299_set_symbol_rate(struct dvb_frontend *fe, u32 srate,
 189                                          u32 ratio)
 190{
 191        stv0299_writereg(fe, 0x13, 0x98);
 192        stv0299_writereg(fe, 0x14, 0x95);
 193        stv0299_writereg(fe, REG_1F_SYMBOLRATE_BYTE0, (ratio >> 16) & 0xff);
 194        stv0299_writereg(fe, REG_20_SYMBOLRATE_BYTE1, (ratio >> 8) & 0xff);
 195        stv0299_writereg(fe, REG_21_SYMBOLRATE_BYTE2, (ratio) & 0xf0);
 196        return 0;
 197
 198}
 199static u8 opera1_inittab[] = {
 200        0x00, 0xa1,
 201        0x01, 0x15,
 202        0x02, 0x30,
 203        0x03, 0x00,
 204        0x04, 0x7d,
 205        0x05, 0x05,
 206        0x06, 0x02,
 207        0x07, 0x00,
 208        0x0b, 0x00,
 209        0x0c, 0x01,
 210        0x0d, 0x81,
 211        0x0e, 0x44,
 212        0x0f, 0x19,
 213        0x10, 0x3f,
 214        0x11, 0x84,
 215        0x12, 0xda,
 216        0x13, 0x98,
 217        0x14, 0x95,
 218        0x15, 0xc9,
 219        0x16, 0xeb,
 220        0x17, 0x00,
 221        0x18, 0x19,
 222        0x19, 0x8b,
 223        0x1a, 0x00,
 224        0x1b, 0x82,
 225        0x1c, 0x7f,
 226        0x1d, 0x00,
 227        0x1e, 0x00,
 228        REG_1F_SYMBOLRATE_BYTE0, 0x06,
 229        REG_20_SYMBOLRATE_BYTE1, 0x50,
 230        REG_21_SYMBOLRATE_BYTE2, 0x10,
 231        0x22, 0x00,
 232        0x23, 0x00,
 233        0x24, 0x37,
 234        0x25, 0xbc,
 235        0x26, 0x00,
 236        0x27, 0x00,
 237        0x28, 0x00,
 238        0x29, 0x1e,
 239        0x2a, 0x14,
 240        0x2b, 0x1f,
 241        0x2c, 0x09,
 242        0x2d, 0x0a,
 243        0x2e, 0x00,
 244        0x2f, 0x00,
 245        0x30, 0x00,
 246        0x31, 0x1f,
 247        0x32, 0x19,
 248        0x33, 0xfc,
 249        0x34, 0x13,
 250        0xff, 0xff,
 251};
 252
 253static struct stv0299_config opera1_stv0299_config = {
 254        .demod_address = 0xd0>>1,
 255        .min_delay_ms = 100,
 256        .mclk = 88000000UL,
 257        .invert = 1,
 258        .skip_reinit = 0,
 259        .lock_output = STV0299_LOCKOUTPUT_0,
 260        .volt13_op0_op1 = STV0299_VOLT13_OP0,
 261        .inittab = opera1_inittab,
 262        .set_symbol_rate = opera1_stv0299_set_symbol_rate,
 263};
 264
 265static int opera1_frontend_attach(struct dvb_usb_adapter *d)
 266{
 267        d->fe_adap[0].fe = dvb_attach(stv0299_attach, &opera1_stv0299_config,
 268                                      &d->dev->i2c_adap);
 269        if ((d->fe_adap[0].fe) != NULL) {
 270                d->fe_adap[0].fe->ops.set_voltage = opera1_set_voltage;
 271                return 0;
 272        }
 273        info("not attached stv0299");
 274        return -EIO;
 275}
 276
 277static int opera1_tuner_attach(struct dvb_usb_adapter *adap)
 278{
 279        dvb_attach(
 280                dvb_pll_attach, adap->fe_adap[0].fe, 0xc0>>1,
 281                &adap->dev->i2c_adap, DVB_PLL_OPERA1
 282        );
 283        return 0;
 284}
 285
 286static int opera1_power_ctrl(struct dvb_usb_device *d, int onoff)
 287{
 288        u8 val = onoff ? 0x01 : 0x00;
 289
 290        if (dvb_usb_opera1_debug)
 291                info("power %s", onoff ? "on" : "off");
 292        return opera1_xilinx_rw(d->udev, 0xb7, val,
 293                                &val, 1, OPERA_WRITE_MSG);
 294}
 295
 296static int opera1_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
 297{
 298        static u8 buf_start[2] = { 0xff, 0x03 };
 299        static u8 buf_stop[2] = { 0xff, 0x00 };
 300        struct i2c_msg start_tuner[] = {
 301                {.addr = ADDR_B1A6_STREAM_CTRL,.buf = onoff ? buf_start : buf_stop,.len = 2},
 302        };
 303        if (dvb_usb_opera1_debug)
 304                info("streaming %s", onoff ? "on" : "off");
 305        i2c_transfer(&adap->dev->i2c_adap, start_tuner, 1);
 306        return 0;
 307}
 308
 309static int opera1_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid,
 310                             int onoff)
 311{
 312        u8 b_pid[3];
 313        struct i2c_msg msg[] = {
 314                {.addr = ADDR_B1A6_STREAM_CTRL,.buf = b_pid,.len = 3},
 315        };
 316        if (dvb_usb_opera1_debug)
 317                info("pidfilter index: %d pid: %d %s", index, pid,
 318                        onoff ? "on" : "off");
 319        b_pid[0] = (2 * index) + 4;
 320        b_pid[1] = onoff ? (pid & 0xff) : (0x00);
 321        b_pid[2] = onoff ? ((pid >> 8) & 0xff) : (0x00);
 322        i2c_transfer(&adap->dev->i2c_adap, msg, 1);
 323        return 0;
 324}
 325
 326static int opera1_pid_filter_control(struct dvb_usb_adapter *adap, int onoff)
 327{
 328        int u = 0x04;
 329        u8 b_pid[3];
 330        struct i2c_msg msg[] = {
 331                {.addr = ADDR_B1A6_STREAM_CTRL,.buf = b_pid,.len = 3},
 332        };
 333        if (dvb_usb_opera1_debug)
 334                info("%s hw-pidfilter", onoff ? "enable" : "disable");
 335        for (; u < 0x7e; u += 2) {
 336                b_pid[0] = u;
 337                b_pid[1] = 0;
 338                b_pid[2] = 0x80;
 339                i2c_transfer(&adap->dev->i2c_adap, msg, 1);
 340        }
 341        return 0;
 342}
 343
 344static struct rc_map_table rc_map_opera1_table[] = {
 345        {0x5fa0, KEY_1},
 346        {0x51af, KEY_2},
 347        {0x5da2, KEY_3},
 348        {0x41be, KEY_4},
 349        {0x0bf5, KEY_5},
 350        {0x43bd, KEY_6},
 351        {0x47b8, KEY_7},
 352        {0x49b6, KEY_8},
 353        {0x05fa, KEY_9},
 354        {0x45ba, KEY_0},
 355        {0x09f6, KEY_CHANNELUP},        /*chanup */
 356        {0x1be5, KEY_CHANNELDOWN},      /*chandown */
 357        {0x5da3, KEY_VOLUMEDOWN},       /*voldown */
 358        {0x5fa1, KEY_VOLUMEUP},         /*volup */
 359        {0x07f8, KEY_SPACE},            /*tab */
 360        {0x1fe1, KEY_OK},               /*play ok */
 361        {0x1be4, KEY_ZOOM},             /*zoom */
 362        {0x59a6, KEY_MUTE},             /*mute */
 363        {0x5ba5, KEY_RADIO},            /*tv/f */
 364        {0x19e7, KEY_RECORD},           /*rec */
 365        {0x01fe, KEY_STOP},             /*Stop */
 366        {0x03fd, KEY_PAUSE},            /*pause */
 367        {0x03fc, KEY_SCREEN},           /*<- -> */
 368        {0x07f9, KEY_CAMERA},           /*capture */
 369        {0x47b9, KEY_ESC},              /*exit */
 370        {0x43bc, KEY_POWER2},           /*power */
 371};
 372
 373static int opera1_rc_query(struct dvb_usb_device *dev, u32 * event, int *state)
 374{
 375        struct opera1_state *opst = dev->priv;
 376        u8 rcbuffer[32];
 377        const u16 startmarker1 = 0x10ed;
 378        const u16 startmarker2 = 0x11ec;
 379        struct i2c_msg read_remote[] = {
 380                {.addr = ADDR_B880_READ_REMOTE,.buf = rcbuffer,.flags = I2C_M_RD,.len = 32},
 381        };
 382        int i = 0;
 383        u32 send_key = 0;
 384
 385        if (i2c_transfer(&dev->i2c_adap, read_remote, 1) == 1) {
 386                for (i = 0; i < 32; i++) {
 387                        if (rcbuffer[i])
 388                                send_key |= 1;
 389                        if (i < 31)
 390                                send_key = send_key << 1;
 391                }
 392                if (send_key & 0x8000)
 393                        send_key = (send_key << 1) | (send_key >> 15 & 0x01);
 394
 395                if (send_key == 0xffff && opst->last_key_pressed != 0) {
 396                        *state = REMOTE_KEY_REPEAT;
 397                        *event = opst->last_key_pressed;
 398                        return 0;
 399                }
 400                for (; send_key != 0;) {
 401                        if (send_key >> 16 == startmarker2) {
 402                                break;
 403                        } else if (send_key >> 16 == startmarker1) {
 404                                send_key =
 405                                        (send_key & 0xfffeffff) | (startmarker1 << 16);
 406                                break;
 407                        } else
 408                                send_key >>= 1;
 409                }
 410
 411                if (send_key == 0)
 412                        return 0;
 413
 414                send_key = (send_key & 0xffff) | 0x0100;
 415
 416                for (i = 0; i < ARRAY_SIZE(rc_map_opera1_table); i++) {
 417                        if (rc5_scan(&rc_map_opera1_table[i]) == (send_key & 0xffff)) {
 418                                *state = REMOTE_KEY_PRESSED;
 419                                *event = rc_map_opera1_table[i].keycode;
 420                                opst->last_key_pressed =
 421                                        rc_map_opera1_table[i].keycode;
 422                                break;
 423                        }
 424                        opst->last_key_pressed = 0;
 425                }
 426        } else
 427                *state = REMOTE_NO_KEY_PRESSED;
 428        return 0;
 429}
 430
 431static struct usb_device_id opera1_table[] = {
 432        {USB_DEVICE(USB_VID_CYPRESS, USB_PID_OPERA1_COLD)},
 433        {USB_DEVICE(USB_VID_OPERA1, USB_PID_OPERA1_WARM)},
 434        {}
 435};
 436
 437MODULE_DEVICE_TABLE(usb, opera1_table);
 438
 439static int opera1_read_mac_address(struct dvb_usb_device *d, u8 mac[6])
 440{
 441        u8 command[] = { READ_MAC_ADDR };
 442        opera1_xilinx_rw(d->udev, 0xb1, 0xa0, command, 1, OPERA_WRITE_MSG);
 443        opera1_xilinx_rw(d->udev, 0xb1, 0xa1, mac, 6, OPERA_READ_MSG);
 444        return 0;
 445}
 446static int opera1_xilinx_load_firmware(struct usb_device *dev,
 447                                       const char *filename)
 448{
 449        const struct firmware *fw = NULL;
 450        u8 *b, *p;
 451        int ret = 0, i,fpgasize=40;
 452        u8 testval;
 453        info("start downloading fpga firmware %s",filename);
 454
 455        if ((ret = request_firmware(&fw, filename, &dev->dev)) != 0) {
 456                err("did not find the firmware file '%s'. You can use <kernel_dir>/scripts/get_dvb_firmware to get the firmware",
 457                        filename);
 458                return ret;
 459        } else {
 460                p = kmalloc(fw->size, GFP_KERNEL);
 461                opera1_xilinx_rw(dev, 0xbc, 0x00, &testval, 1, OPERA_READ_MSG);
 462                if (p != NULL && testval != 0x67) {
 463
 464                        u8 reset = 0, fpga_command = 0;
 465                        memcpy(p, fw->data, fw->size);
 466                        /* clear fpga ? */
 467                        opera1_xilinx_rw(dev, 0xbc, 0xaa, &fpga_command, 1,
 468                                         OPERA_WRITE_MSG);
 469                        for (i = 0; i < fw->size;) {
 470                                if ( (fw->size - i) <fpgasize){
 471                                    fpgasize=fw->size-i;
 472                                }
 473                                b = (u8 *) p + i;
 474                                if (opera1_xilinx_rw
 475                                        (dev, OPERA_WRITE_FX2, 0x0, b , fpgasize,
 476                                                OPERA_WRITE_MSG) != fpgasize
 477                                        ) {
 478                                        err("error while transferring firmware");
 479                                        ret = -EINVAL;
 480                                        break;
 481                                }
 482                                i = i + fpgasize;
 483                        }
 484                        /* restart the CPU */
 485                        if (ret || opera1_xilinx_rw
 486                                        (dev, 0xa0, 0xe600, &reset, 1,
 487                                        OPERA_WRITE_MSG) != 1) {
 488                                err("could not restart the USB controller CPU.");
 489                                ret = -EINVAL;
 490                        }
 491                }
 492        }
 493        kfree(p);
 494        release_firmware(fw);
 495        return ret;
 496}
 497
 498static struct dvb_usb_device_properties opera1_properties = {
 499        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
 500        .usb_ctrl = CYPRESS_FX2,
 501        .firmware = "dvb-usb-opera-01.fw",
 502        .size_of_priv = sizeof(struct opera1_state),
 503
 504        .power_ctrl = opera1_power_ctrl,
 505        .i2c_algo = &opera1_i2c_algo,
 506
 507        .rc.legacy = {
 508                .rc_map_table = rc_map_opera1_table,
 509                .rc_map_size = ARRAY_SIZE(rc_map_opera1_table),
 510                .rc_interval = 200,
 511                .rc_query = opera1_rc_query,
 512        },
 513        .read_mac_address = opera1_read_mac_address,
 514        .generic_bulk_ctrl_endpoint = 0x00,
 515        /* parameter for the MPEG2-data transfer */
 516        .num_adapters = 1,
 517        .adapter = {
 518                {
 519                .num_frontends = 1,
 520                .fe = {{
 521                        .frontend_attach = opera1_frontend_attach,
 522                        .streaming_ctrl = opera1_streaming_ctrl,
 523                        .tuner_attach = opera1_tuner_attach,
 524                        .caps =
 525                                DVB_USB_ADAP_HAS_PID_FILTER |
 526                                DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
 527                        .pid_filter = opera1_pid_filter,
 528                        .pid_filter_ctrl = opera1_pid_filter_control,
 529                        .pid_filter_count = 252,
 530                        .stream = {
 531                                .type = USB_BULK,
 532                                .count = 10,
 533                                .endpoint = 0x82,
 534                                .u = {
 535                                        .bulk = {
 536                                                .buffersize = 4096,
 537                                        }
 538                                }
 539                        },
 540                }},
 541                }
 542        },
 543        .num_device_descs = 1,
 544        .devices = {
 545                {"Opera1 DVB-S USB2.0",
 546                        {&opera1_table[0], NULL},
 547                        {&opera1_table[1], NULL},
 548                },
 549        }
 550};
 551
 552static int opera1_probe(struct usb_interface *intf,
 553                        const struct usb_device_id *id)
 554{
 555        struct usb_device *udev = interface_to_usbdev(intf);
 556
 557        if (le16_to_cpu(udev->descriptor.idProduct) == USB_PID_OPERA1_WARM &&
 558            le16_to_cpu(udev->descriptor.idVendor) == USB_VID_OPERA1 &&
 559                opera1_xilinx_load_firmware(udev, "dvb-usb-opera1-fpga-01.fw") != 0
 560            ) {
 561                return -EINVAL;
 562        }
 563
 564        if (0 != dvb_usb_device_init(intf, &opera1_properties,
 565                                     THIS_MODULE, NULL, adapter_nr))
 566                return -EINVAL;
 567        return 0;
 568}
 569
 570static struct usb_driver opera1_driver = {
 571        .name = "opera1",
 572        .probe = opera1_probe,
 573        .disconnect = dvb_usb_device_exit,
 574        .id_table = opera1_table,
 575};
 576
 577module_usb_driver(opera1_driver);
 578
 579MODULE_AUTHOR("Mario Hlawitschka (c) dh1pa@amsat.org");
 580MODULE_AUTHOR("Marco Gittler (c) g.marco@freenet.de");
 581MODULE_DESCRIPTION("Driver for Opera1 DVB-S device");
 582MODULE_VERSION("0.1");
 583MODULE_LICENSE("GPL");
 584