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

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