Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

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

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us