1
2
3
4
5
6
7
8
9
10
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
35struct opera1_state {
36 u32 last_key_pressed;
37};
38struct opera_rc_keys {
39 u32 keycode;
40 u32 event;
41};
42
43static int dvb_usb_opera1_debug;
44module_param_named(debug, dvb_usb_opera1_debug, int, 0644);
45MODULE_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
49DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
50
51
52static 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
81
82static 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
125static 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
151static u32 opera1_i2c_func(struct i2c_adapter *adapter)
152{
153 return I2C_FUNC_I2C;
154}
155
156static struct i2c_algorithm opera1_i2c_algo = {
157 .master_xfer = opera1_i2c_xfer,
158 .functionality = opera1_i2c_func,
159};
160
161static 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
178static 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}
189static 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
243static 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
255static 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
267static 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
276static 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
286static 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
299static 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
316static 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
334static struct dvb_usb_rc_key opera1_rc_keys[] = {
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_UP},
346 {0x1be5, KEY_DOWN},
347 {0x5da3, KEY_LEFT},
348 {0x5fa1, KEY_RIGHT},
349 {0x07f8, KEY_SPACE},
350 {0x1fe1, KEY_ENTER},
351 {0x1be4, KEY_Z},
352 {0x59a6, KEY_M},
353 {0x5ba5, KEY_F},
354 {0x19e7, KEY_R},
355 {0x01fe, KEY_S},
356 {0x03fd, KEY_P},
357 {0x03fc, KEY_W},
358 {0x07f9, KEY_C},
359 {0x47b9, KEY_Q},
360 {0x43bc, KEY_O},
361
362};
363
364static int opera1_rc_query(struct dvb_usb_device *dev, u32 * event, int *state)
365{
366 struct opera1_state *opst = dev->priv;
367 u8 rcbuffer[32];
368 const u16 startmarker1 = 0x10ed;
369 const u16 startmarker2 = 0x11ec;
370 struct i2c_msg read_remote[] = {
371 {.addr = ADDR_B880_READ_REMOTE,.buf = rcbuffer,.flags = I2C_M_RD,.len = 32},
372 };
373 int i = 0;
374 u32 send_key = 0;
375
376 if (i2c_transfer(&dev->i2c_adap, read_remote, 1) == 1) {
377 for (i = 0; i < 32; i++) {
378 if (rcbuffer[i])
379 send_key |= 1;
380 if (i < 31)
381 send_key = send_key << 1;
382 }
383 if (send_key & 0x8000)
384 send_key = (send_key << 1) | (send_key >> 15 & 0x01);
385
386 if (send_key == 0xffff && opst->last_key_pressed != 0) {
387 *state = REMOTE_KEY_REPEAT;
388 *event = opst->last_key_pressed;
389 return 0;
390 }
391 for (; send_key != 0;) {
392 if (send_key >> 16 == startmarker2) {
393 break;
394 } else if (send_key >> 16 == startmarker1) {
395 send_key =
396 (send_key & 0xfffeffff) | (startmarker1 << 16);
397 break;
398 } else
399 send_key >>= 1;
400 }
401
402 if (send_key == 0)
403 return 0;
404
405 send_key = (send_key & 0xffff) | 0x0100;
406
407 for (i = 0; i < ARRAY_SIZE(opera1_rc_keys); i++) {
408 if (rc5_scan(&opera1_rc_keys[i]) == (send_key & 0xffff)) {
409 *state = REMOTE_KEY_PRESSED;
410 *event = opera1_rc_keys[i].event;
411 opst->last_key_pressed =
412 opera1_rc_keys[i].event;
413 break;
414 }
415 opst->last_key_pressed = 0;
416 }
417 } else
418 *state = REMOTE_NO_KEY_PRESSED;
419 return 0;
420}
421
422static struct usb_device_id opera1_table[] = {
423 {USB_DEVICE(USB_VID_CYPRESS, USB_PID_OPERA1_COLD)},
424 {USB_DEVICE(USB_VID_OPERA1, USB_PID_OPERA1_WARM)},
425 {}
426};
427
428MODULE_DEVICE_TABLE(usb, opera1_table);
429
430static int opera1_read_mac_address(struct dvb_usb_device *d, u8 mac[6])
431{
432 u8 command[] = { READ_MAC_ADDR };
433 opera1_xilinx_rw(d->udev, 0xb1, 0xa0, command, 1, OPERA_WRITE_MSG);
434 opera1_xilinx_rw(d->udev, 0xb1, 0xa1, mac, 6, OPERA_READ_MSG);
435 return 0;
436}
437static int opera1_xilinx_load_firmware(struct usb_device *dev,
438 const char *filename)
439{
440 const struct firmware *fw = NULL;
441 u8 *b, *p;
442 int ret = 0, i,fpgasize=40;
443 u8 testval;
444 info("start downloading fpga firmware %s",filename);
445
446 if ((ret = request_firmware(&fw, filename, &dev->dev)) != 0) {
447 err("did not find the firmware file. (%s) "
448 "Please see linux/Documentation/dvb/ for more details on firmware-problems.",
449 filename);
450 return ret;
451 } else {
452 p = kmalloc(fw->size, GFP_KERNEL);
453 opera1_xilinx_rw(dev, 0xbc, 0x00, &testval, 1, OPERA_READ_MSG);
454 if (p != NULL && testval != 0x67) {
455
456 u8 reset = 0, fpga_command = 0;
457 memcpy(p, fw->data, fw->size);
458
459 opera1_xilinx_rw(dev, 0xbc, 0xaa, &fpga_command, 1,
460 OPERA_WRITE_MSG);
461 for (i = 0; i < fw->size;) {
462 if ( (fw->size - i) <fpgasize){
463 fpgasize=fw->size-i;
464 }
465 b = (u8 *) p + i;
466 if (opera1_xilinx_rw
467 (dev, OPERA_WRITE_FX2, 0x0, b , fpgasize,
468 OPERA_WRITE_MSG) != fpgasize
469 ) {
470 err("error while transferring firmware");
471 ret = -EINVAL;
472 break;
473 }
474 i = i + fpgasize;
475 }
476
477 if (ret || opera1_xilinx_rw
478 (dev, 0xa0, 0xe600, &reset, 1,
479 OPERA_WRITE_MSG) != 1) {
480 err("could not restart the USB controller CPU.");
481 ret = -EINVAL;
482 }
483 }
484 }
485 kfree(p);
486 if (fw) {
487 release_firmware(fw);
488 }
489 return ret;
490}
491
492static struct dvb_usb_device_properties opera1_properties = {
493 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
494 .usb_ctrl = CYPRESS_FX2,
495 .firmware = "dvb-usb-opera-01.fw",
496 .size_of_priv = sizeof(struct opera1_state),
497
498 .power_ctrl = opera1_power_ctrl,
499 .i2c_algo = &opera1_i2c_algo,
500
501 .rc_key_map = opera1_rc_keys,
502 .rc_key_map_size = ARRAY_SIZE(opera1_rc_keys),
503 .rc_interval = 200,
504 .rc_query = opera1_rc_query,
505 .read_mac_address = opera1_read_mac_address,
506 .generic_bulk_ctrl_endpoint = 0x00,
507
508 .num_adapters = 1,
509 .adapter = {
510 {
511 .frontend_attach = opera1_frontend_attach,
512 .streaming_ctrl = opera1_streaming_ctrl,
513 .tuner_attach = opera1_tuner_attach,
514 .caps =
515 DVB_USB_ADAP_HAS_PID_FILTER |
516 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
517 .pid_filter = opera1_pid_filter,
518 .pid_filter_ctrl = opera1_pid_filter_control,
519 .pid_filter_count = 252,
520 .stream = {
521 .type = USB_BULK,
522 .count = 10,
523 .endpoint = 0x82,
524 .u = {
525 .bulk = {
526 .buffersize = 4096,
527 }
528 }
529 },
530 }
531 },
532 .num_device_descs = 1,
533 .devices = {
534 {"Opera1 DVB-S USB2.0",
535 {&opera1_table[0], NULL},
536 {&opera1_table[1], NULL},
537 },
538 }
539};
540
541static int opera1_probe(struct usb_interface *intf,
542 const struct usb_device_id *id)
543{
544 struct usb_device *udev = interface_to_usbdev(intf);
545
546 if (udev->descriptor.idProduct == USB_PID_OPERA1_WARM &&
547 udev->descriptor.idVendor == USB_VID_OPERA1 &&
548 opera1_xilinx_load_firmware(udev, "dvb-usb-opera1-fpga-01.fw") != 0
549 ) {
550 return -EINVAL;
551 }
552
553 if (0 != dvb_usb_device_init(intf, &opera1_properties,
554 THIS_MODULE, NULL, adapter_nr))
555 return -EINVAL;
556 return 0;
557}
558
559static struct usb_driver opera1_driver = {
560 .name = "opera1",
561 .probe = opera1_probe,
562 .disconnect = dvb_usb_device_exit,
563 .id_table = opera1_table,
564};
565
566static int __init opera1_module_init(void)
567{
568 int result = 0;
569 if ((result = usb_register(&opera1_driver))) {
570 err("usb_register failed. Error number %d", result);
571 }
572 return result;
573}
574
575static void __exit opera1_module_exit(void)
576{
577 usb_deregister(&opera1_driver);
578}
579
580module_init(opera1_module_init);
581module_exit(opera1_module_exit);
582
583MODULE_AUTHOR("Mario Hlawitschka (c) dh1pa@amsat.org");
584MODULE_AUTHOR("Marco Gittler (c) g.marco@freenet.de");
585MODULE_DESCRIPTION("Driver for Opera1 DVB-S device");
586MODULE_VERSION("0.1");
587MODULE_LICENSE("GPL");
588
