Version:  2.0.40 2.2.26 2.4.37 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7

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

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