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

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