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 35struct opera1_state { 36 u32 last_key_pressed; 37}; 38struct ir_codes_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 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 82static 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 125static 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 151static u32 opera1_i2c_func(struct i2c_adapter *adapter) 152{ 153 return I2C_FUNC_I2C; 154} 155 156static struct i2c_algorithm opera1_i2c_algo = { 157 .master_xfer = opera1_i2c_xfer, 158 .functionality = opera1_i2c_func, 159}; 160 161static 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 178static 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} 189static 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 243static 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 255static 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 267static 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 276static 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 286static 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 299static 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 316static 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 334static struct ir_scancode ir_codes_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_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 364static 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(ir_codes_opera1_table); i++) { 408 if (rc5_scan(&ir_codes_opera1_table[i]) == (send_key & 0xffff)) { 409 *state = REMOTE_KEY_PRESSED; 410 *event = ir_codes_opera1_table[i].keycode; 411 opst->last_key_pressed = 412 ir_codes_opera1_table[i].keycode; 413 break; 414 } 415 opst->last_key_pressed = 0; 416 } 417 } else 418 *state = REMOTE_NO_KEY_PRESSED; 419 return 0; 420} 421 422static 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 428MODULE_DEVICE_TABLE(usb, opera1_table); 429 430static 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} 437static 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 release_firmware(fw); 487 return ret; 488} 489 490static struct dvb_usb_device_properties opera1_properties = { 491 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 492 .usb_ctrl = CYPRESS_FX2, 493 .firmware = "dvb-usb-opera-01.fw", 494 .size_of_priv = sizeof(struct opera1_state), 495 496 .power_ctrl = opera1_power_ctrl, 497 .i2c_algo = &opera1_i2c_algo, 498 499 .rc.legacy = { 500 .rc_key_map = ir_codes_opera1_table, 501 .rc_key_map_size = ARRAY_SIZE(ir_codes_opera1_table), 502 .rc_interval = 200, 503 .rc_query = opera1_rc_query, 504 }, 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 541static 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 559static 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 566static 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 575static void __exit opera1_module_exit(void) 576{ 577 usb_deregister(&opera1_driver); 578} 579 580module_init(opera1_module_init); 581module_exit(opera1_module_exit); 582 583MODULE_AUTHOR("Mario Hlawitschka (c) dh1pa@amsat.org"); 584MODULE_AUTHOR("Marco Gittler (c) g.marco@freenet.de"); 585MODULE_DESCRIPTION("Driver for Opera1 DVB-S device"); 586MODULE_VERSION("0.1"); 587MODULE_LICENSE("GPL"); 588