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
opera1_xilinx_rw(struct usb_device * dev,u8 request,u16 value,u8 * data,u16 len,int flags)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
opera1_usb_i2c_msgxfer(struct dvb_usb_device * dev,u16 addr,u8 * buf,u16 len)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
opera1_i2c_xfer(struct i2c_adapter * adap,struct i2c_msg msg[],int num)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
opera1_i2c_func(struct i2c_adapter * adapter)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
opera1_set_voltage(struct dvb_frontend * fe,enum fe_sec_voltage voltage)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
opera1_stv0299_set_symbol_rate(struct dvb_frontend * fe,u32 srate,u32 ratio)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
opera1_frontend_attach(struct dvb_usb_adapter * d)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
opera1_tuner_attach(struct dvb_usb_adapter * adap)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
opera1_power_ctrl(struct dvb_usb_device * d,int onoff)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
opera1_streaming_ctrl(struct dvb_usb_adapter * adap,int onoff)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
opera1_pid_filter(struct dvb_usb_adapter * adap,int index,u16 pid,int onoff)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
opera1_pid_filter_control(struct dvb_usb_adapter * adap,int onoff)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
opera1_rc_query(struct dvb_usb_device * dev,u32 * event,int * state)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
opera1_read_mac_address(struct dvb_usb_device * d,u8 mac[6])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 }
opera1_xilinx_load_firmware(struct usb_device * dev,const char * filename)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
opera1_probe(struct usb_interface * intf,const struct usb_device_id * id)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