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