API tools faq
paste
Advertisement
Guest User

tbs-qbox.c

a guest
Jul 3rd, 2012
200
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 11.83 KB | None | 0 0
raw download clone embed print report
  1. /* DVB USB framework compliant Linux driver for the
  2. *   TBS QBOX
  3. *
  4. * Copyright (C) 2008 Bob Liu (Bob@Turbosight.com)
  5. * Igor M. Liplianin (liplianin@me.by)
  6. *
  7. * Konstantin Dimitrov <kosio.dimitrov@gmail.com>
  8. *   June 2009
  9. *   Some fixes and improvements.
  10. *
  11. *   This program is free software; you can redistribute it and/or modify it
  12. *   under the terms of the GNU General Public License as published by the
  13. *   Free Software Foundation, version 2.
  14. *
  15. * see Documentation/dvb/README.dvb-usb for more information
  16. */
  17. #include <linux/version.h>
  18. #include "tbs-qbox.h"
  19. #include "stv0299.h"
  20. #include "stv0288.h"
  21. #include "stb6000.h"
  22.  
  23.  
  24. #ifndef USB_PID_TBSQBOX
  25. #define USB_PID_TBSQBOX 0x2601
  26. #endif
  27.  
  28. #ifndef USB_PID_TBSQBOX_1
  29. #define USB_PID_TBSQBOX_1 0x2601
  30. #endif
  31.  
  32. #define TBSQBOX_READ_MSG 0
  33. #define TBSQBOX_WRITE_MSG 1
  34.  
  35. /* on my own*/
  36. #define TBSQBOX_VOLTAGE_CTRL (0x1800)
  37. #define TBSQBOX_RC_QUERY (0x1a00)
  38.  
  39. struct tbsqboxs1_state {
  40.     u32 last_key_pressed;
  41. };
  42. struct tbsqboxs1_rc_keys {
  43.     u32 keycode;
  44.     u32 event;
  45. };
  46.  
  47. /* debug */
  48. static int dvb_usb_tbsqboxs1_debug;
  49. module_param_named(debug, dvb_usb_tbsqboxs1_debug, int, 0644);
  50. MODULE_PARM_DESC(debug, "set debugging level (1=info 2=xfer (or-able))." DVB_USB_DEBUG_STATUS);
  51.  
  52. DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  53.  
  54. static int tbsqboxs1_op_rw(struct usb_device *dev, u8 request, u16 value,
  55.             u16 index, u8 * data, u16 len, int flags)
  56. {
  57.     int ret;
  58.     u8 u8buf[len];
  59.  
  60.     unsigned int pipe = (flags == TBSQBOX_READ_MSG) ?
  61.                 usb_rcvctrlpipe(dev, 0) : usb_sndctrlpipe(dev, 0);
  62.     u8 request_type = (flags == TBSQBOX_READ_MSG) ? USB_DIR_IN : USB_DIR_OUT;
  63.  
  64.     if (flags == TBSQBOX_WRITE_MSG)
  65.         memcpy(u8buf, data, len);
  66.     ret = usb_control_msg(dev, pipe, request, request_type | USB_TYPE_VENDOR,
  67.                 value, index , u8buf, len, 2000);
  68.  
  69.     if (flags == TBSQBOX_READ_MSG)
  70.         memcpy(data, u8buf, len);
  71.     return ret;
  72. }
  73.  
  74. /* I2C */
  75. static int tbsqboxs1_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[],
  76.         int num)
  77. {
  78. struct dvb_usb_device *d = i2c_get_adapdata(adap);
  79.     int i = 0;
  80.     u8 buf6[20];
  81.     u8 inbuf[20];
  82.  
  83.     if (!d)
  84.         return -ENODEV;
  85.     if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
  86.         return -EAGAIN;
  87.  
  88.     switch (num) {
  89.     case 2:
  90.        
  91.         buf6[0]=msg[1].len;//lenth
  92.         buf6[1]=msg[0].addr<<1;//demod addr
  93.         buf6[2]=msg[0].buf[0];//register
  94.        
  95.         tbsqboxs1_op_rw(d->udev, 0x90, 0, 0,
  96.                     buf6, 3, TBSQBOX_WRITE_MSG);
  97.         msleep(5);
  98.         tbsqboxs1_op_rw(d->udev, 0x91, 0, 0,
  99.                     inbuf, 1, TBSQBOX_READ_MSG);
  100.         memcpy(msg[1].buf, inbuf, msg[1].len);
  101.         break;
  102.     case 1:
  103.         switch (msg[0].addr) {
  104.         case 0x68:
  105.             /* write to stv0299 register */
  106.             buf6[0] = msg[0].len+1;//lenth
  107.             buf6[1] = msg[0].addr<<1;//demod addr
  108.             for(i=0;i<msg[0].len;i++)
  109.                 {
  110.                 buf6[2+i] = msg[0].buf[i];//register
  111.                 }
  112.             tbsqboxs1_op_rw(d->udev, 0x80, 0, 0,
  113.                     buf6, msg[0].len+2, TBSQBOX_WRITE_MSG);
  114.             msleep(3);
  115.             break;
  116.         case 0x61:
  117.         case 0x60:
  118.             if (msg[0].flags == 0) {
  119.             /* write to tuner pll */
  120.                 buf6[0] = msg[0].len+1;//lenth
  121.                 buf6[1] = msg[0].addr<<1;//tuner addr
  122.                 for(i=0;i<msg[0].len;i++)
  123.                 {
  124.                 buf6[2+i] = msg[0].buf[i];//register
  125.                 }
  126.                 tbsqboxs1_op_rw(d->udev, 0x80, 0, 0,
  127.                         buf6, msg[0].len+2, TBSQBOX_WRITE_MSG);
  128.             }
  129.             msleep(3);
  130.             break;
  131.         case (TBSQBOX_RC_QUERY):
  132.             tbsqboxs1_op_rw(d->udev, 0xb8, 0, 0,
  133.                     buf6, 4, TBSQBOX_READ_MSG);
  134.             msg[0].buf[0] = buf6[2];
  135.             msg[0].buf[1] = buf6[3];
  136.             msleep(3);
  137.             //info("TBSQBOX_RC_QUERY %x %x %x %x\n",buf6[0],buf6[1],buf6[2],buf6[3]);
  138.             break;
  139.         case (TBSQBOX_VOLTAGE_CTRL):
  140.             buf6[0] = 3;
  141.             buf6[1] = msg[0].buf[0];
  142.             tbsqboxs1_op_rw(d->udev, 0x8a, 0, 0,
  143.                     buf6, 2, TBSQBOX_WRITE_MSG);
  144.            
  145.             break;
  146.         }
  147.  
  148.         break;
  149.     }
  150.  
  151.     mutex_unlock(&d->i2c_mutex);
  152.     return num;
  153. }
  154.  
  155. static u32 tbsqboxs1_i2c_func(struct i2c_adapter *adapter)
  156. {
  157.     return I2C_FUNC_I2C;
  158. }
  159.  
  160. static struct stv0288_config earda_config = {
  161.     .demod_address = 0x68,
  162. };
  163.  
  164. static struct i2c_algorithm tbsqboxs1_i2c_algo = {
  165.     .master_xfer = tbsqboxs1_i2c_transfer,
  166.     .functionality = tbsqboxs1_i2c_func,
  167. };
  168.  
  169. static int tbsqboxs1_earda_tuner_attach(struct dvb_usb_adapter *adap)
  170. {
  171.     dvb_attach(stb6000_attach, adap->fe[0], 0x61,
  172.         &adap->dev->i2c_adap);
  173.  
  174.     return 0;
  175. }
  176. static int tbsqboxs1_read_mac_address(struct dvb_usb_device *d, u8 mac[6])
  177. {
  178.     int i,ret;
  179.     u8 ibuf[3] = {0, 0,0};
  180.     u8 eeprom[256], eepromline[16];
  181.  
  182.     for (i = 0; i < 256; i++) {
  183.         ibuf[0]=1;//lenth
  184.         ibuf[1]=0xa0;//eeprom addr
  185.         ibuf[2]=i;//register
  186.         ret = tbsqboxs1_op_rw(d->udev, 0x90, 0, 0,
  187.                     ibuf, 3, TBSQBOX_WRITE_MSG);
  188.         ret = tbsqboxs1_op_rw(d->udev, 0x91, 0, 0,
  189.                     ibuf, 1, TBSQBOX_READ_MSG);
  190.             if (ret < 0) {
  191.                 err("read eeprom failed.");
  192.                 return -1;
  193.             } else {
  194.                 eepromline[i%16] = ibuf[0];
  195.                 eeprom[i] = ibuf[0];
  196.             }
  197.            
  198.             if ((i % 16) == 15) {
  199.                 deb_xfer("%02x: ", i - 15);
  200.                 debug_dump(eepromline, 16, deb_xfer);
  201.             }
  202.     }
  203.     memcpy(mac, eeprom + 16, 6);
  204.     return 0;
  205. };
  206.  
  207. static int tbsqboxs1_set_voltage(struct dvb_frontend *fe, fe_sec_voltage_t voltage)
  208. {
  209.     static u8 command_13v[1] = {0x00};
  210.     static u8 command_18v[1] = {0x01};
  211.     struct i2c_msg msg[] = {
  212.         {.addr = TBSQBOX_VOLTAGE_CTRL, .flags = 0,
  213.             .buf = command_13v, .len = 1},
  214.     };
  215.    
  216.     struct dvb_usb_adapter *udev_adap =
  217.         (struct dvb_usb_adapter *)(fe->dvb->priv);
  218.     if (voltage == SEC_VOLTAGE_18)
  219.         msg[0].buf = command_18v;
  220.     //info("tbsqboxs1_set_voltage %d",voltage);
  221.     i2c_transfer(&udev_adap->dev->i2c_adap, msg, 1);
  222.     return 0;
  223. }
  224.  
  225. static struct dvb_usb_device_properties tbsqboxs1_properties;
  226.  
  227. static int tbsqboxs1_frontend_attach(struct dvb_usb_adapter *d)
  228. {
  229.     u8 buf[20];
  230.  
  231.     if (tbsqboxs1_properties.adapter->tuner_attach == &tbsqboxs1_earda_tuner_attach) {
  232.         d->fe[0] = dvb_attach(stv0288_attach, &earda_config,
  233.                     &d->dev->i2c_adap);
  234.         if (d->fe[0] != NULL) {
  235.             d->fe[0]->ops.set_voltage = tbsqboxs1_set_voltage;
  236.             info("Attached stv0288!\n");
  237.  
  238.             buf[0] = 7;
  239.             buf[1] = 1;
  240.             tbsqboxs1_op_rw(d->dev->udev, 0x8a, 0, 0,
  241.                      buf, 2, TBSQBOX_WRITE_MSG);
  242.  
  243.             return 0;
  244.         }
  245.     }
  246.  
  247.     return -EIO;
  248. }
  249.  
  250.  
  251.  
  252. static struct rc_map_table tbsqboxs1_rc_keys[] = {
  253.     { 0xff84, KEY_POWER2},      /* power */
  254.     { 0xff94, KEY_MUTE},        /* mute */
  255.     { 0xff87, KEY_1},
  256.     { 0xff86, KEY_2},
  257.     { 0xff85, KEY_3},
  258.     { 0xff8b, KEY_4},
  259.     { 0xff8a, KEY_5},
  260.     { 0xff89, KEY_6},
  261.     { 0xff8f, KEY_7},
  262.     { 0xff8e, KEY_8},
  263.     { 0xff8d, KEY_9},
  264.     { 0xff92, KEY_0},
  265.     { 0xff96, KEY_CHANNELUP},   /* ch+ */
  266.     { 0xff91, KEY_CHANNELDOWN}, /* ch- */
  267.     { 0xff93, KEY_VOLUMEUP},    /* vol+ */
  268.     { 0xff8c, KEY_VOLUMEDOWN},  /* vol- */
  269.     { 0xff83, KEY_RECORD},      /* rec */
  270.     { 0xff98, KEY_PAUSE},       /* pause, yellow */
  271.     { 0xff99, KEY_OK},      /* ok */
  272.     { 0xff9a, KEY_CAMERA},      /* snapshot */
  273.     { 0xff81, KEY_UP},
  274.     { 0xff90, KEY_LEFT},
  275.     { 0xff82, KEY_RIGHT},
  276.     { 0xff88, KEY_DOWN},
  277.     { 0xff95, KEY_FAVORITES},   /* blue */
  278.     { 0xff97, KEY_SUBTITLE},    /* green */
  279.     { 0xff9d, KEY_ZOOM},
  280.     { 0xff9f, KEY_EXIT},
  281.     { 0xff9e, KEY_MENU},
  282.     { 0xff9c, KEY_EPG},
  283.     { 0xff80, KEY_PREVIOUS},    /* red */
  284.     { 0xff9b, KEY_MODE},
  285.     { 0xffdd, KEY_TV },
  286.     { 0xffde, KEY_PLAY },
  287.     { 0xffdc, KEY_STOP },
  288.     { 0xffdb, KEY_REWIND },
  289.     { 0xffda, KEY_FASTFORWARD },
  290.     { 0xffd9, KEY_PREVIOUS },   /* replay */
  291.     { 0xffd8, KEY_NEXT },       /* skip */
  292.     { 0xffd1, KEY_NUMERIC_STAR },
  293.     { 0xffd2, KEY_NUMERIC_POUND },
  294.     { 0xffd4, KEY_DELETE },     /* clear */
  295. };
  296.  
  297.  
  298.  
  299. static int tbsqboxs1_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
  300. {
  301.     struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
  302.     int keymap_size = d->props.rc.legacy.rc_map_size;
  303.    
  304.     struct tbsqboxs1_state *st = d->priv;
  305.     u8 key[2];
  306.     struct i2c_msg msg[] = {
  307.         {.addr = TBSQBOX_RC_QUERY, .flags = I2C_M_RD, .buf = key,
  308.         .len = 2},
  309.     };
  310.     int i;
  311.  
  312.     *state = REMOTE_NO_KEY_PRESSED;
  313.     if (tbsqboxs1_i2c_transfer(&d->i2c_adap, msg, 1) == 1) {
  314.         //info("key: %x %x\n",msg[0].buf[0],msg[0].buf[1]);
  315.         for (i = 0; i < keymap_size; i++) {
  316.             if (rc5_data(&keymap[i]) == msg[0].buf[1]) {
  317.                 *state = REMOTE_KEY_PRESSED;
  318.                 *event = keymap[i].keycode;
  319.                 st->last_key_pressed =
  320.                     keymap[i].keycode;
  321.                 break;
  322.             }
  323.         st->last_key_pressed = 0;
  324.         }
  325.     }
  326.      
  327.     return 0;
  328. }
  329.  
  330. static struct usb_device_id tbsqboxs1_table[] = {
  331.     {USB_DEVICE(0x734c, 0x2601)},
  332.     {USB_DEVICE(0x734c, 0x2601)},
  333.     {USB_DEVICE(USB_VID_CYPRESS, USB_PID_TBSQBOX)},
  334.     {USB_DEVICE(USB_VID_CYPRESS, USB_PID_TBSQBOX_1)},
  335.     { }
  336. };
  337.  
  338. MODULE_DEVICE_TABLE(usb, tbsqboxs1_table);
  339.  
  340. static int tbsqboxs1_load_firmware(struct usb_device *dev,
  341.             const struct firmware *frmwr)
  342. {
  343.     u8 *b, *p;
  344.     int ret = 0, i;
  345.     u8 reset;
  346.     const struct firmware *fw;
  347.     const char *filename = "dvb-usb-tbsqbox-id2601.fw";
  348.     const char *filename1 = "dvb-usb-tbsqbox-id2601.fw";
  349.     switch (dev->descriptor.idProduct) {
  350.     case 0x2601:
  351.         ret = request_firmware(&fw, filename, &dev->dev);
  352.         if (ret != 0) {
  353.             err("did not find the firmware file. (%s) "
  354.             "Please see linux/Documentation/dvb/ for more details "
  355.             "on firmware-problems.", filename);
  356.             return ret;
  357.         }
  358.         break;
  359.     default:
  360.         fw = frmwr;
  361.         break;
  362.     }
  363.     info("start downloading TBSQBOX firmware");
  364.     p = kmalloc(fw->size, GFP_KERNEL);
  365.     reset = 1;
  366.     /*stop the CPU*/
  367.     tbsqboxs1_op_rw(dev, 0xa0, 0x7f92, 0, &reset, 1, TBSQBOX_WRITE_MSG);
  368.     tbsqboxs1_op_rw(dev, 0xa0, 0xe600, 0, &reset, 1, TBSQBOX_WRITE_MSG);
  369.  
  370.     if (p != NULL) {
  371.         memcpy(p, fw->data, fw->size);
  372.         for (i = 0; i < fw->size; i += 0x40) {
  373.             b = (u8 *) p + i;
  374.             if (tbsqboxs1_op_rw(dev, 0xa0, i, 0, b , 0x40,
  375.                     TBSQBOX_WRITE_MSG) != 0x40) {
  376.                 err("error while transferring firmware");
  377.                 ret = -EINVAL;
  378.                 break;
  379.             }
  380.         }
  381.         /* restart the CPU */
  382.         reset = 0;
  383.         if (ret || tbsqboxs1_op_rw(dev, 0xa0, 0x7f92, 0, &reset, 1,
  384.                     TBSQBOX_WRITE_MSG) != 1) {
  385.             err("could not restart the USB controller CPU.");
  386.             ret = -EINVAL;
  387.         }
  388.         if (ret || tbsqboxs1_op_rw(dev, 0xa0, 0xe600, 0, &reset, 1,
  389.                     TBSQBOX_WRITE_MSG) != 1) {
  390.             err("could not restart the USB controller CPU.");
  391.             ret = -EINVAL;
  392.         }
  393.  
  394.         msleep(100);
  395.         kfree(p);
  396.     }
  397.     return ret;
  398. }
  399.  
  400. static struct dvb_usb_device_properties tbsqboxs1_properties = {
  401.     .caps = DVB_USB_IS_AN_I2C_ADAPTER,
  402.     .usb_ctrl = DEVICE_SPECIFIC,
  403.     .firmware = "dvb-usb-tbsqbox-id2601.fw",
  404.     .size_of_priv = sizeof(struct tbsqboxs1_state),
  405.     .no_reconnect = 1,
  406.  
  407.     .i2c_algo = &tbsqboxs1_i2c_algo,
  408.     .rc.legacy = {
  409.         .rc_map_table = tbsqboxs1_rc_keys,
  410.         .rc_map_size = ARRAY_SIZE(tbsqboxs1_rc_keys),
  411.         .rc_interval = 150,
  412.         .rc_query = tbsqboxs1_rc_query,
  413.     },
  414.  
  415.     .generic_bulk_ctrl_endpoint = 0x81,
  416.     /* parameter for the MPEG2-data transfer */
  417.     .num_adapters = 1,
  418.     .download_firmware = tbsqboxs1_load_firmware,
  419.     .read_mac_address = tbsqboxs1_read_mac_address,
  420.         .adapter = {
  421.         {
  422.             .frontend_attach = tbsqboxs1_frontend_attach,
  423.             .streaming_ctrl = NULL,
  424.             .tuner_attach = tbsqboxs1_earda_tuner_attach,
  425.             .stream = {
  426.                 .type = USB_BULK,
  427.                 .count = 8,
  428.                 .endpoint = 0x82,
  429.                 .u = {
  430.                     .bulk = {
  431.                         .buffersize = 4096,
  432.                     }
  433.                 }
  434.             },
  435.         }
  436.     },
  437.     .num_device_descs = 1,
  438.     .devices = {
  439.         {"TBS QBOX DVBS USB2.0",
  440.             {&tbsqboxs1_table[1], NULL},
  441.             {NULL},
  442.         }
  443.     }
  444. };
  445.  
  446. static int tbsqboxs1_probe(struct usb_interface *intf,
  447.         const struct usb_device_id *id)
  448. {
  449.     if (0 == dvb_usb_device_init(intf, &tbsqboxs1_properties,
  450.             THIS_MODULE, NULL, adapter_nr)) {
  451.         return 0;
  452.     }
  453.     return -ENODEV;
  454. }
  455.  
  456. static struct usb_driver tbsqboxs1_driver = {
  457.     .name = "tbsqboxs1",
  458.     .probe = tbsqboxs1_probe,
  459.     .disconnect = dvb_usb_device_exit,
  460.     .id_table = tbsqboxs1_table,
  461. };
  462.  
  463. static int __init tbsqboxs1_module_init(void)
  464. {
  465.     int ret =  usb_register(&tbsqboxs1_driver);
  466.     if (ret)
  467.         err("usb_register failed. Error number %d", ret);
  468.  
  469.     return ret;
  470. }
  471.  
  472. static void __exit tbsqboxs1_module_exit(void)
  473. {
  474.     usb_deregister(&tbsqboxs1_driver);
  475. }
  476.  
  477. module_init(tbsqboxs1_module_init);
  478. module_exit(tbsqboxs1_module_exit);
  479.  
  480. MODULE_AUTHOR("Bob Liu <Bob@turbosight.com>");
  481. MODULE_DESCRIPTION("Driver for TBS QBOX");
  482. MODULE_VERSION("0.1");
  483. MODULE_LICENSE("GPL");
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!