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 opera_rc_keys {
  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 dvb_usb_rc_key opera1_rc_keys[] = {
 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_UP},       /*chanup */
 346         {0x1be5, KEY_DOWN},     /*chandown */
 347         {0x5da3, KEY_LEFT},     /*voldown */
 348         {0x5fa1, KEY_RIGHT},    /*volup */
 349         {0x07f8, KEY_SPACE},    /*tab */
 350         {0x1fe1, KEY_ENTER},    /*play ok */
 351         {0x1be4, KEY_Z},        /*zoom */
 352         {0x59a6, KEY_M},        /*mute */
 353         {0x5ba5, KEY_F},        /*tv/f */
 354         {0x19e7, KEY_R},        /*rec */
 355         {0x01fe, KEY_S},        /*Stop */
 356         {0x03fd, KEY_P},        /*pause */
 357         {0x03fc, KEY_W},        /*<- -> */
 358         {0x07f9, KEY_C},        /*capture */
 359         {0x47b9, KEY_Q},        /*exit */
 360         {0x43bc, KEY_O},        /*power */
 361
 362 };
 363
 364 static int opera1_rc_query(struct dvb_usb_device *dev, u32 * event, int *state)
 365 {
 366         struct opera1_state *opst = dev->priv;
 367         u8 rcbuffer[32];
 368         const u16 startmarker1 = 0x10ed;
 369         const u16 startmarker2 = 0x11ec;
 370         struct i2c_msg read_remote[] = {
 371                 {.addr = ADDR_B880_READ_REMOTE,.buf = rcbuffer,.flags = I2C_M_RD,.len = 32},
 372         };
 373         int i = 0;
 374         u32 send_key = 0;
 375
 376         if (i2c_transfer(&dev->i2c_adap, read_remote, 1) == 1) {
 377                 for (i = 0; i < 32; i++) {
 378                         if (rcbuffer[i])
 379                                 send_key |= 1;
 380                         if (i < 31)
 381                                 send_key = send_key << 1;
 382                 }
 383                 if (send_key & 0x8000)
 384                         send_key = (send_key << 1) | (send_key >> 15 & 0x01);
 385
 386                 if (send_key == 0xffff && opst->last_key_pressed != 0) {
 387                         *state = REMOTE_KEY_REPEAT;
 388                         *event = opst->last_key_pressed;
 389                         return 0;
 390                 }
 391                 for (; send_key != 0;) {
 392                         if (send_key >> 16 == startmarker2) {
 393                                 break;
 394                         } else if (send_key >> 16 == startmarker1) {
 395                                 send_key =
 396                                         (send_key & 0xfffeffff) | (startmarker1 << 16);
 397                                 break;
 398                         } else
 399                                 send_key >>= 1;
 400                 }
 401
 402                 if (send_key == 0)
 403                         return 0;
 404
 405                 send_key = (send_key & 0xffff) | 0x0100;
 406
 407                 for (i = 0; i < ARRAY_SIZE(opera1_rc_keys); i++) {
 408                         if (rc5_scan(&opera1_rc_keys[i]) == (send_key & 0xffff)) {
 409                                 *state = REMOTE_KEY_PRESSED;
 410                                 *event = opera1_rc_keys[i].event;
 411                                 opst->last_key_pressed =
 412                                         opera1_rc_keys[i].event;
 413                                 break;
 414                         }
 415                         opst->last_key_pressed = 0;
 416                 }
 417         } else
 418                 *state = REMOTE_NO_KEY_PRESSED;
 419         return 0;
 420 }
 421
 422 static struct usb_device_id opera1_table[] = {
 423         {USB_DEVICE(USB_VID_CYPRESS, USB_PID_OPERA1_COLD)},
 424         {USB_DEVICE(USB_VID_OPERA1, USB_PID_OPERA1_WARM)},
 425         {}
 426 };
 427
 428 MODULE_DEVICE_TABLE(usb, opera1_table);
 429
 430 static int opera1_read_mac_address(struct dvb_usb_device *d, u8 mac[6])
 431 {
 432         u8 command[] = { READ_MAC_ADDR };
 433         opera1_xilinx_rw(d->udev, 0xb1, 0xa0, command, 1, OPERA_WRITE_MSG);
 434         opera1_xilinx_rw(d->udev, 0xb1, 0xa1, mac, 6, OPERA_READ_MSG);
 435         return 0;
 436 }
 437 static int opera1_xilinx_load_firmware(struct usb_device *dev,
 438                                        const char *filename)
 439 {
 440         const struct firmware *fw = NULL;
 441         u8 *b, *p;
 442         int ret = 0, i,fpgasize=40;
 443         u8 testval;
 444         info("start downloading fpga firmware %s",filename);
 445
 446         if ((ret = request_firmware(&fw, filename, &dev->dev)) != 0) {
 447                 err("did not find the firmware file. (%s) "
 448                         "Please see linux/Documentation/dvb/ for more details on firmware-problems.",
 449                         filename);
 450                 return ret;
 451         } else {
 452                 p = kmalloc(fw->size, GFP_KERNEL);
 453                 opera1_xilinx_rw(dev, 0xbc, 0x00, &testval, 1, OPERA_READ_MSG);
 454                 if (p != NULL && testval != 0x67) {
 455
 456                         u8 reset = 0, fpga_command = 0;
 457                         memcpy(p, fw->data, fw->size);
 458                         /* clear fpga ? */
 459                         opera1_xilinx_rw(dev, 0xbc, 0xaa, &fpga_command, 1,
 460                                          OPERA_WRITE_MSG);
 461                         for (i = 0; i < fw->size;) {
 462                                 if ( (fw->size - i) <fpgasize){
 463                                     fpgasize=fw->size-i;
 464                                 }
 465                                 b = (u8 *) p + i;
 466                                 if (opera1_xilinx_rw
 467                                         (dev, OPERA_WRITE_FX2, 0x0, b , fpgasize,
 468                                                 OPERA_WRITE_MSG) != fpgasize
 469                                         ) {
 470                                         err("error while transferring firmware");
 471                                         ret = -EINVAL;
 472                                         break;
 473                                 }
 474                                 i = i + fpgasize;
 475                         }
 476                         /* restart the CPU */
 477                         if (ret || opera1_xilinx_rw
 478                                         (dev, 0xa0, 0xe600, &reset, 1,
 479                                         OPERA_WRITE_MSG) != 1) {
 480                                 err("could not restart the USB controller CPU.");
 481                                 ret = -EINVAL;
 482                         }
 483                 }
 484         }
 485         kfree(p);
 486         if (fw) {
 487                 release_firmware(fw);
 488         }
 489         return ret;
 490 }
 491
 492 static struct dvb_usb_device_properties opera1_properties = {
 493         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
 494         .usb_ctrl = CYPRESS_FX2,
 495         .firmware = "dvb-usb-opera-01.fw",
 496         .size_of_priv = sizeof(struct opera1_state),
 497
 498         .power_ctrl = opera1_power_ctrl,
 499         .i2c_algo = &opera1_i2c_algo,
 500
 501         .rc_key_map = opera1_rc_keys,
 502         .rc_key_map_size = ARRAY_SIZE(opera1_rc_keys),
 503         .rc_interval = 200,
 504         .rc_query = opera1_rc_query,
 505         .read_mac_address = opera1_read_mac_address,
 506         .generic_bulk_ctrl_endpoint = 0x00,
 507         /* parameter for the MPEG2-data transfer */
 508         .num_adapters = 1,
 509         .adapter = {
 510                 {
 511                         .frontend_attach = opera1_frontend_attach,
 512                         .streaming_ctrl = opera1_streaming_ctrl,
 513                         .tuner_attach = opera1_tuner_attach,
 514                         .caps =
 515                                 DVB_USB_ADAP_HAS_PID_FILTER |
 516                                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
 517                         .pid_filter = opera1_pid_filter,
 518                         .pid_filter_ctrl = opera1_pid_filter_control,
 519                         .pid_filter_count = 252,
 520                         .stream = {
 521                                 .type = USB_BULK,
 522                                 .count = 10,
 523                                 .endpoint = 0x82,
 524                                 .u = {
 525                                         .bulk = {
 526                                                 .buffersize = 4096,
 527                                         }
 528                                 }
 529                         },
 530                 }
 531         },
 532         .num_device_descs = 1,
 533         .devices = {
 534                 {"Opera1 DVB-S USB2.0",
 535                         {&opera1_table[0], NULL},
 536                         {&opera1_table[1], NULL},
 537                 },
 538         }
 539 };
 540
 541 static int opera1_probe(struct usb_interface *intf,
 542                         const struct usb_device_id *id)
 543 {
 544         struct usb_device *udev = interface_to_usbdev(intf);
 545
 546         if (udev->descriptor.idProduct == USB_PID_OPERA1_WARM &&
 547                 udev->descriptor.idVendor == USB_VID_OPERA1 &&
 548                 opera1_xilinx_load_firmware(udev, "dvb-usb-opera1-fpga-01.fw") != 0
 549             ) {
 550                 return -EINVAL;
 551         }
 552
 553         if (0 != dvb_usb_device_init(intf, &opera1_properties,
 554                                      THIS_MODULE, NULL, adapter_nr))
 555                 return -EINVAL;
 556         return 0;
 557 }
 558
 559 static struct usb_driver opera1_driver = {
 560         .name = "opera1",
 561         .probe = opera1_probe,
 562         .disconnect = dvb_usb_device_exit,
 563         .id_table = opera1_table,
 564 };
 565
 566 static int __init opera1_module_init(void)
 567 {
 568         int result = 0;
 569         if ((result = usb_register(&opera1_driver))) {
 570                 err("usb_register failed. Error number %d", result);
 571         }
 572         return result;
 573 }
 574
 575 static void __exit opera1_module_exit(void)
 576 {
 577         usb_deregister(&opera1_driver);
 578 }
 579
 580 module_init(opera1_module_init);
 581 module_exit(opera1_module_exit);
 582
 583 MODULE_AUTHOR("Mario Hlawitschka (c) dh1pa@amsat.org");
 584 MODULE_AUTHOR("Marco Gittler (c) g.marco@freenet.de");
 585 MODULE_DESCRIPTION("Driver for Opera1 DVB-S device");
 586 MODULE_VERSION("0.1");
 587 MODULE_LICENSE("GPL");