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 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); 84 out: 85 kfree(buf); 86 return ret; 87 } 88 89 /* I2C */ 90 91 static 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 134 static 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 mesage %d %d", tmp, msg[i].len); 155 } 156 mutex_unlock(&d->i2c_mutex); 157 return num; 158 } 159 160 static u32 opera1_i2c_func(struct i2c_adapter *adapter) 161 { 162 return I2C_FUNC_I2C; 163 } 164 165 static struct i2c_algorithm opera1_i2c_algo = { 166 .master_xfer = opera1_i2c_xfer, 167 .functionality = opera1_i2c_func, 168 }; 169 170 static int opera1_set_voltage(struct dvb_frontend *fe, fe_sec_voltage_t voltage) 171 { 172 static u8 command_13v[1]={0x00}; 173 static u8 command_18v[1]={0x01}; 174 struct i2c_msg msg[] = { 175 {.addr = ADDR_B600_VOLTAGE_13V,.flags = 0,.buf = command_13v,.len = 1}, 176 }; 177 struct dvb_usb_adapter *udev_adap = 178 (struct dvb_usb_adapter *)(fe->dvb->priv); 179 if (voltage == SEC_VOLTAGE_18) { 180 msg[0].addr = ADDR_B601_VOLTAGE_18V; 181 msg[0].buf = command_18v; 182 } 183 i2c_transfer(&udev_adap->dev->i2c_adap, msg, 1); 184 return 0; 185 } 186 187 static int opera1_stv0299_set_symbol_rate(struct dvb_frontend *fe, u32 srate, 188 u32 ratio) 189 { 190 stv0299_writereg(fe, 0x13, 0x98); 191 stv0299_writereg(fe, 0x14, 0x95); 192 stv0299_writereg(fe, REG_1F_SYMBOLRATE_BYTE0, (ratio >> 16) & 0xff); 193 stv0299_writereg(fe, REG_20_SYMBOLRATE_BYTE1, (ratio >> 8) & 0xff); 194 stv0299_writereg(fe, REG_21_SYMBOLRATE_BYTE2, (ratio) & 0xf0); 195 return 0; 196 197 } 198 static u8 opera1_inittab[] = { 199 0x00, 0xa1, 200 0x01, 0x15, 201 0x02, 0x30, 202 0x03, 0x00, 203 0x04, 0x7d, 204 0x05, 0x05, 205 0x06, 0x02, 206 0x07, 0x00, 207 0x0b, 0x00, 208 0x0c, 0x01, 209 0x0d, 0x81, 210 0x0e, 0x44, 211 0x0f, 0x19, 212 0x10, 0x3f, 213 0x11, 0x84, 214 0x12, 0xda, 215 0x13, 0x98, 216 0x14, 0x95, 217 0x15, 0xc9, 218 0x16, 0xeb, 219 0x17, 0x00, 220 0x18, 0x19, 221 0x19, 0x8b, 222 0x1a, 0x00, 223 0x1b, 0x82, 224 0x1c, 0x7f, 225 0x1d, 0x00, 226 0x1e, 0x00, 227 REG_1F_SYMBOLRATE_BYTE0, 0x06, 228 REG_20_SYMBOLRATE_BYTE1, 0x50, 229 REG_21_SYMBOLRATE_BYTE2, 0x10, 230 0x22, 0x00, 231 0x23, 0x00, 232 0x24, 0x37, 233 0x25, 0xbc, 234 0x26, 0x00, 235 0x27, 0x00, 236 0x28, 0x00, 237 0x29, 0x1e, 238 0x2a, 0x14, 239 0x2b, 0x1f, 240 0x2c, 0x09, 241 0x2d, 0x0a, 242 0x2e, 0x00, 243 0x2f, 0x00, 244 0x30, 0x00, 245 0x31, 0x1f, 246 0x32, 0x19, 247 0x33, 0xfc, 248 0x34, 0x13, 249 0xff, 0xff, 250 }; 251 252 static struct stv0299_config opera1_stv0299_config = { 253 .demod_address = 0xd0>>1, 254 .min_delay_ms = 100, 255 .mclk = 88000000UL, 256 .invert = 1, 257 .skip_reinit = 0, 258 .lock_output = STV0299_LOCKOUTPUT_0, 259 .volt13_op0_op1 = STV0299_VOLT13_OP0, 260 .inittab = opera1_inittab, 261 .set_symbol_rate = opera1_stv0299_set_symbol_rate, 262 }; 263 264 static int opera1_frontend_attach(struct dvb_usb_adapter *d) 265 { 266 d->fe_adap[0].fe = dvb_attach(stv0299_attach, &opera1_stv0299_config, 267 &d->dev->i2c_adap); 268 if ((d->fe_adap[0].fe) != NULL) { 269 d->fe_adap[0].fe->ops.set_voltage = opera1_set_voltage; 270 return 0; 271 } 272 info("not attached stv0299"); 273 return -EIO; 274 } 275 276 static int opera1_tuner_attach(struct dvb_usb_adapter *adap) 277 { 278 dvb_attach( 279 dvb_pll_attach, adap->fe_adap[0].fe, 0xc0>>1, 280 &adap->dev->i2c_adap, DVB_PLL_OPERA1 281 ); 282 return 0; 283 } 284 285 static int opera1_power_ctrl(struct dvb_usb_device *d, int onoff) 286 { 287 u8 val = onoff ? 0x01 : 0x00; 288 289 if (dvb_usb_opera1_debug) 290 info("power %s", onoff ? "on" : "off"); 291 return opera1_xilinx_rw(d->udev, 0xb7, val, 292 &val, 1, OPERA_WRITE_MSG); 293 } 294 295 static int opera1_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff) 296 { 297 static u8 buf_start[2] = { 0xff, 0x03 }; 298 static u8 buf_stop[2] = { 0xff, 0x00 }; 299 struct i2c_msg start_tuner[] = { 300 {.addr = ADDR_B1A6_STREAM_CTRL,.buf = onoff ? buf_start : buf_stop,.len = 2}, 301 }; 302 if (dvb_usb_opera1_debug) 303 info("streaming %s", onoff ? "on" : "off"); 304 i2c_transfer(&adap->dev->i2c_adap, start_tuner, 1); 305 return 0; 306 } 307 308 static int opera1_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid, 309 int onoff) 310 { 311 u8 b_pid[3]; 312 struct i2c_msg msg[] = { 313 {.addr = ADDR_B1A6_STREAM_CTRL,.buf = b_pid,.len = 3}, 314 }; 315 if (dvb_usb_opera1_debug) 316 info("pidfilter index: %d pid: %d %s", index, pid, 317 onoff ? "on" : "off"); 318 b_pid[0] = (2 * index) + 4; 319 b_pid[1] = onoff ? (pid & 0xff) : (0x00); 320 b_pid[2] = onoff ? ((pid >> 8) & 0xff) : (0x00); 321 i2c_transfer(&adap->dev->i2c_adap, msg, 1); 322 return 0; 323 } 324 325 static int opera1_pid_filter_control(struct dvb_usb_adapter *adap, int onoff) 326 { 327 int u = 0x04; 328 u8 b_pid[3]; 329 struct i2c_msg msg[] = { 330 {.addr = ADDR_B1A6_STREAM_CTRL,.buf = b_pid,.len = 3}, 331 }; 332 if (dvb_usb_opera1_debug) 333 info("%s hw-pidfilter", onoff ? "enable" : "disable"); 334 for (; u < 0x7e; u += 2) { 335 b_pid[0] = u; 336 b_pid[1] = 0; 337 b_pid[2] = 0x80; 338 i2c_transfer(&adap->dev->i2c_adap, msg, 1); 339 } 340 return 0; 341 } 342 343 static struct rc_map_table rc_map_opera1_table[] = { 344 {0x5fa0, KEY_1}, 345 {0x51af, KEY_2}, 346 {0x5da2, KEY_3}, 347 {0x41be, KEY_4}, 348 {0x0bf5, KEY_5}, 349 {0x43bd, KEY_6}, 350 {0x47b8, KEY_7}, 351 {0x49b6, KEY_8}, 352 {0x05fa, KEY_9}, 353 {0x45ba, KEY_0}, 354 {0x09f6, KEY_CHANNELUP}, /*chanup */ 355 {0x1be5, KEY_CHANNELDOWN}, /*chandown */ 356 {0x5da3, KEY_VOLUMEDOWN}, /*voldown */ 357 {0x5fa1, KEY_VOLUMEUP}, /*volup */ 358 {0x07f8, KEY_SPACE}, /*tab */ 359 {0x1fe1, KEY_OK}, /*play ok */ 360 {0x1be4, KEY_ZOOM}, /*zoom */ 361 {0x59a6, KEY_MUTE}, /*mute */ 362 {0x5ba5, KEY_RADIO}, /*tv/f */ 363 {0x19e7, KEY_RECORD}, /*rec */ 364 {0x01fe, KEY_STOP}, /*Stop */ 365 {0x03fd, KEY_PAUSE}, /*pause */ 366 {0x03fc, KEY_SCREEN}, /*<- -> */ 367 {0x07f9, KEY_CAMERA}, /*capture */ 368 {0x47b9, KEY_ESC}, /*exit */ 369 {0x43bc, KEY_POWER2}, /*power */ 370 }; 371 372 static int opera1_rc_query(struct dvb_usb_device *dev, u32 * event, int *state) 373 { 374 struct opera1_state *opst = dev->priv; 375 u8 rcbuffer[32]; 376 const u16 startmarker1 = 0x10ed; 377 const u16 startmarker2 = 0x11ec; 378 struct i2c_msg read_remote[] = { 379 {.addr = ADDR_B880_READ_REMOTE,.buf = rcbuffer,.flags = I2C_M_RD,.len = 32}, 380 }; 381 int i = 0; 382 u32 send_key = 0; 383 384 if (i2c_transfer(&dev->i2c_adap, read_remote, 1) == 1) { 385 for (i = 0; i < 32; i++) { 386 if (rcbuffer[i]) 387 send_key |= 1; 388 if (i < 31) 389 send_key = send_key << 1; 390 } 391 if (send_key & 0x8000) 392 send_key = (send_key << 1) | (send_key >> 15 & 0x01); 393 394 if (send_key == 0xffff && opst->last_key_pressed != 0) { 395 *state = REMOTE_KEY_REPEAT; 396 *event = opst->last_key_pressed; 397 return 0; 398 } 399 for (; send_key != 0;) { 400 if (send_key >> 16 == startmarker2) { 401 break; 402 } else if (send_key >> 16 == startmarker1) { 403 send_key = 404 (send_key & 0xfffeffff) | (startmarker1 << 16); 405 break; 406 } else 407 send_key >>= 1; 408 } 409 410 if (send_key == 0) 411 return 0; 412 413 send_key = (send_key & 0xffff) | 0x0100; 414 415 for (i = 0; i < ARRAY_SIZE(rc_map_opera1_table); i++) { 416 if (rc5_scan(&rc_map_opera1_table[i]) == (send_key & 0xffff)) { 417 *state = REMOTE_KEY_PRESSED; 418 *event = rc_map_opera1_table[i].keycode; 419 opst->last_key_pressed = 420 rc_map_opera1_table[i].keycode; 421 break; 422 } 423 opst->last_key_pressed = 0; 424 } 425 } else 426 *state = REMOTE_NO_KEY_PRESSED; 427 return 0; 428 } 429 430 static struct usb_device_id opera1_table[] = { 431 {USB_DEVICE(USB_VID_CYPRESS, USB_PID_OPERA1_COLD)}, 432 {USB_DEVICE(USB_VID_OPERA1, USB_PID_OPERA1_WARM)}, 433 {} 434 }; 435 436 MODULE_DEVICE_TABLE(usb, opera1_table); 437 438 static int opera1_read_mac_address(struct dvb_usb_device *d, u8 mac[6]) 439 { 440 u8 command[] = { READ_MAC_ADDR }; 441 opera1_xilinx_rw(d->udev, 0xb1, 0xa0, command, 1, OPERA_WRITE_MSG); 442 opera1_xilinx_rw(d->udev, 0xb1, 0xa1, mac, 6, OPERA_READ_MSG); 443 return 0; 444 } 445 static int opera1_xilinx_load_firmware(struct usb_device *dev, 446 const char *filename) 447 { 448 const struct firmware *fw = NULL; 449 u8 *b, *p; 450 int ret = 0, i,fpgasize=40; 451 u8 testval; 452 info("start downloading fpga firmware %s",filename); 453 454 if ((ret = request_firmware(&fw, filename, &dev->dev)) != 0) { 455 err("did not find the firmware file. (%s) " 456 "Please see linux/Documentation/dvb/ for more details on firmware-problems.", 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 498 static 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 552 static 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 (udev->descriptor.idProduct == USB_PID_OPERA1_WARM && 558 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 570 static 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 577 module_usb_driver(opera1_driver); 578 579 MODULE_AUTHOR("Mario Hlawitschka (c) dh1pa@amsat.org"); 580 MODULE_AUTHOR("Marco Gittler (c) g.marco@freenet.de"); 581 MODULE_DESCRIPTION("Driver for Opera1 DVB-S device"); 582 MODULE_VERSION("0.1"); 583 MODULE_LICENSE("GPL"); 584