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 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");