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