drivers/media/dvb/dvb-usb/vp702x.c

   1 /* DVB USB compliant Linux driver for the TwinhanDTV StarBox USB2.0 DVB-S
   2  * receiver.
   3  *
   4  * Copyright (C) 2005 Ralph Metzler <rjkm@metzlerbros.de>
   5  *                    Metzler Brothers Systementwicklung GbR
   6  *
   7  * Copyright (C) 2005 Patrick Boettcher <patrick.boettcher@desy.de>
   8  *
   9  * Thanks to Twinhan who kindly provided hardware and information.
  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 Free
  13  *      Software Foundation, version 2.
  14  *
  15  * see Documentation/dvb/README.dvb-usb for more information
  16  */
  17 #include "vp702x.h"
  18 #include <linux/mutex.h>
  19
  20 /* debug */
  21 int dvb_usb_vp702x_debug;
  22 module_param_named(debug,dvb_usb_vp702x_debug, int, 0644);
  23 MODULE_PARM_DESC(debug, "set debugging level (1=info,xfer=2,rc=4 (or-able))." DVB_USB_DEBUG_STATUS);
  24
  25 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  26
  27 struct vp702x_adapter_state {
  28         int pid_filter_count;
  29         int pid_filter_can_bypass;
  30         u8  pid_filter_state;
  31 };
  32
  33 /* check for mutex FIXME */
  34 int vp702x_usb_in_op(struct dvb_usb_device *d, u8 req, u16 value, u16 index, u8 *b, int blen)
  35 {
  36         int ret;
  37
  38         ret = usb_control_msg(d->udev,
  39                 usb_rcvctrlpipe(d->udev, 0),
  40                 req,
  41                 USB_TYPE_VENDOR | USB_DIR_IN,
  42                 value, index, b, blen,
  43                 2000);
  44
  45         if (ret < 0) {
  46                 warn("usb in operation failed. (%d)", ret);
  47                 ret = -EIO;
  48         } else
  49                 ret = 0;
  50
  51
  52         deb_xfer("in: req. %02x, val: %04x, ind: %04x, buffer: ",req,value,index);
  53         debug_dump(b,blen,deb_xfer);
  54
  55         return ret;
  56 }
  57
  58 static int vp702x_usb_out_op(struct dvb_usb_device *d, u8 req, u16 value,
  59                              u16 index, u8 *b, int blen)
  60 {
  61         int ret;
  62         deb_xfer("out: req. %02x, val: %04x, ind: %04x, buffer: ",req,value,index);
  63         debug_dump(b,blen,deb_xfer);
  64
  65         if ((ret = usb_control_msg(d->udev,
  66                         usb_sndctrlpipe(d->udev,0),
  67                         req,
  68                         USB_TYPE_VENDOR | USB_DIR_OUT,
  69                         value,index,b,blen,
  70                         2000)) != blen) {
  71                 warn("usb out operation failed. (%d)",ret);
  72                 return -EIO;
  73         } else
  74                 return 0;
  75 }
  76
  77 int vp702x_usb_inout_op(struct dvb_usb_device *d, u8 *o, int olen, u8 *i, int ilen, int msec)
  78 {
  79         int ret;
  80
  81         if ((ret = mutex_lock_interruptible(&d->usb_mutex)))
  82                 return ret;
  83
  84         ret = vp702x_usb_out_op(d,REQUEST_OUT,0,0,o,olen);
  85         msleep(msec);
  86         ret = vp702x_usb_in_op(d,REQUEST_IN,0,0,i,ilen);
  87
  88         mutex_unlock(&d->usb_mutex);
  89
  90         return ret;
  91 }
  92
  93 static int vp702x_usb_inout_cmd(struct dvb_usb_device *d, u8 cmd, u8 *o,
  94                                 int olen, u8 *i, int ilen, int msec)
  95 {
  96         int ret = 0;
  97         u8 *buf;
  98         int buflen = max(olen + 2, ilen + 1);
  99
 100         buf = kmalloc(buflen, GFP_KERNEL);
 101         if (!buf)
 102                 return -ENOMEM;
 103
 104         buf[0] = 0x00;
 105         buf[1] = cmd;
 106         memcpy(&buf[2], o, olen);
 107
 108         ret = vp702x_usb_inout_op(d, buf, olen+2, buf, ilen+1, msec);
 109
 110         if (ret == 0)
 111                 memcpy(i, &buf[1], ilen);
 112
 113         kfree(buf);
 114         return ret;
 115 }
 116
 117 static int vp702x_set_pld_mode(struct dvb_usb_adapter *adap, u8 bypass)
 118 {
 119         int ret;
 120         u8 *buf = kzalloc(16, GFP_KERNEL);
 121         if (!buf)
 122                 return -ENOMEM;
 123
 124         ret = vp702x_usb_in_op(adap->dev, 0xe0, (bypass << 8) | 0x0e,
 125                         0, buf, 16);
 126         kfree(buf);
 127         return ret;
 128 }
 129
 130 static int vp702x_set_pld_state(struct dvb_usb_adapter *adap, u8 state)
 131 {
 132         int ret;
 133         u8 *buf = kzalloc(16, GFP_KERNEL);
 134         if (!buf)
 135                 return -ENOMEM;
 136
 137         ret = vp702x_usb_in_op(adap->dev, 0xe0, (state << 8) | 0x0f,
 138                         0, buf, 16);
 139         kfree(buf);
 140         return ret;
 141 }
 142
 143 static int vp702x_set_pid(struct dvb_usb_adapter *adap, u16 pid, u8 id, int onoff)
 144 {
 145         struct vp702x_adapter_state *st = adap->priv;
 146         u8 *buf;
 147
 148         buf = kzalloc(16, GFP_KERNEL);
 149         if (!buf)
 150                 return -ENOMEM;
 151
 152         if (onoff)
 153                 st->pid_filter_state |=  (1 << id);
 154         else {
 155                 st->pid_filter_state &= ~(1 << id);
 156                 pid = 0xffff;
 157         }
 158
 159         id = 0x10 + id*2;
 160
 161         vp702x_set_pld_state(adap, st->pid_filter_state);
 162         vp702x_usb_in_op(adap->dev, 0xe0, (((pid >> 8) & 0xff) << 8) | (id), 0, buf, 16);
 163         vp702x_usb_in_op(adap->dev, 0xe0, (((pid     ) & 0xff) << 8) | (id+1), 0, buf, 16);
 164
 165         kfree(buf);
 166         return 0;
 167 }
 168
 169
 170 static int vp702x_init_pid_filter(struct dvb_usb_adapter *adap)
 171 {
 172         struct vp702x_adapter_state *st = adap->priv;
 173         int i;
 174         u8 *b;
 175
 176         b = kzalloc(10, GFP_KERNEL);
 177         if (!b)
 178                 return -ENOMEM;
 179
 180         st->pid_filter_count = 8;
 181         st->pid_filter_can_bypass = 1;
 182         st->pid_filter_state = 0x00;
 183
 184         vp702x_set_pld_mode(adap, 1); /* bypass */
 185
 186         for (i = 0; i < st->pid_filter_count; i++)
 187                 vp702x_set_pid(adap, 0xffff, i, 1);
 188
 189         vp702x_usb_in_op(adap->dev, 0xb5, 3, 0, b, 10);
 190         vp702x_usb_in_op(adap->dev, 0xb5, 0, 0, b, 10);
 191         vp702x_usb_in_op(adap->dev, 0xb5, 1, 0, b, 10);
 192
 193         //vp702x_set_pld_mode(d, 0); // filter
 194         kfree(b);
 195         return 0;
 196 }
 197
 198 static int vp702x_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
 199 {
 200         return 0;
 201 }
 202
 203 /* keys for the enclosed remote control */
 204 static struct rc_map_table rc_map_vp702x_table[] = {
 205         { 0x0001, KEY_1 },
 206         { 0x0002, KEY_2 },
 207 };
 208
 209 /* remote control stuff (does not work with my box) */
 210 static int vp702x_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
 211 {
 212         u8 *key;
 213         int i;
 214
 215 /* remove the following return to enabled remote querying */
 216         return 0;
 217
 218         key = kmalloc(10, GFP_KERNEL);
 219         if (!key)
 220                 return -ENOMEM;
 221
 222         vp702x_usb_in_op(d,READ_REMOTE_REQ,0,0,key,10);
 223
 224         deb_rc("remote query key: %x %d\n",key[1],key[1]);
 225
 226         if (key[1] == 0x44) {
 227                 *state = REMOTE_NO_KEY_PRESSED;
 228                 kfree(key);
 229                 return 0;
 230         }
 231
 232         for (i = 0; i < ARRAY_SIZE(rc_map_vp702x_table); i++)
 233                 if (rc5_custom(&rc_map_vp702x_table[i]) == key[1]) {
 234                         *state = REMOTE_KEY_PRESSED;
 235                         *event = rc_map_vp702x_table[i].keycode;
 236                         break;
 237                 }
 238         kfree(key);
 239         return 0;
 240 }
 241
 242
 243 static int vp702x_read_mac_addr(struct dvb_usb_device *d,u8 mac[6])
 244 {
 245         u8 i, *buf;
 246
 247         buf = kmalloc(6, GFP_KERNEL);
 248         if (!buf)
 249                 return -ENOMEM;
 250
 251         for (i = 6; i < 12; i++)
 252                 vp702x_usb_in_op(d, READ_EEPROM_REQ, i, 1, &buf[i - 6], 1);
 253
 254         memcpy(mac, buf, 6);
 255         kfree(buf);
 256         return 0;
 257 }
 258
 259 static int vp702x_frontend_attach(struct dvb_usb_adapter *adap)
 260 {
 261         u8 buf[10] = { 0 };
 262
 263         vp702x_usb_out_op(adap->dev, SET_TUNER_POWER_REQ, 0, 7, NULL, 0);
 264
 265         if (vp702x_usb_inout_cmd(adap->dev, GET_SYSTEM_STRING, NULL, 0,
 266                                    buf, 10, 10))
 267                 return -EIO;
 268
 269         buf[9] = '\0';
 270         info("system string: %s",&buf[1]);
 271
 272         vp702x_init_pid_filter(adap);
 273
 274         adap->fe = vp702x_fe_attach(adap->dev);
 275         vp702x_usb_out_op(adap->dev, SET_TUNER_POWER_REQ, 1, 7, NULL, 0);
 276
 277         return 0;
 278 }
 279
 280 static struct dvb_usb_device_properties vp702x_properties;
 281
 282 static int vp702x_usb_probe(struct usb_interface *intf,
 283                 const struct usb_device_id *id)
 284 {
 285         struct dvb_usb_device *d;
 286         struct vp702x_device_state *st;
 287         int ret;
 288
 289         ret = dvb_usb_device_init(intf, &vp702x_properties,
 290                                    THIS_MODULE, &d, adapter_nr);
 291         if (ret)
 292                 goto out;
 293
 294         st = d->priv;
 295         st->buf_len = 16;
 296         st->buf = kmalloc(st->buf_len, GFP_KERNEL);
 297         if (!st->buf) {
 298                 ret = -ENOMEM;
 299                 dvb_usb_device_exit(intf);
 300                 goto out;
 301         }
 302         mutex_init(&st->buf_mutex);
 303
 304 out:
 305         return ret;
 306
 307 }
 308
 309 static void vp702x_usb_disconnect(struct usb_interface *intf)
 310 {
 311         struct dvb_usb_device *d = usb_get_intfdata(intf);
 312         struct vp702x_device_state *st = d->priv;
 313         mutex_lock(&st->buf_mutex);
 314         kfree(st->buf);
 315         mutex_unlock(&st->buf_mutex);
 316         dvb_usb_device_exit(intf);
 317 }
 318
 319 static struct usb_device_id vp702x_usb_table [] = {
 320             { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TWINHAN_VP7021_COLD) },
 321 //          { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TWINHAN_VP7020_COLD) },
 322 //          { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TWINHAN_VP7020_WARM) },
 323             { 0 },
 324 };
 325 MODULE_DEVICE_TABLE(usb, vp702x_usb_table);
 326
 327 static struct dvb_usb_device_properties vp702x_properties = {
 328         .usb_ctrl = CYPRESS_FX2,
 329         .firmware            = "dvb-usb-vp702x-02.fw",
 330         .no_reconnect        = 1,
 331
 332         .size_of_priv     = sizeof(struct vp702x_device_state),
 333
 334         .num_adapters = 1,
 335         .adapter = {
 336                 {
 337                         .caps             = DVB_USB_ADAP_RECEIVES_204_BYTE_TS,
 338
 339                         .streaming_ctrl   = vp702x_streaming_ctrl,
 340                         .frontend_attach  = vp702x_frontend_attach,
 341
 342                         /* parameter for the MPEG2-data transfer */
 343                         .stream = {
 344                                 .type = USB_BULK,
 345                                 .count = 10,
 346                                 .endpoint = 0x02,
 347                                 .u = {
 348                                         .bulk = {
 349                                                 .buffersize = 4096,
 350                                         }
 351                                 }
 352                         },
 353                         .size_of_priv     = sizeof(struct vp702x_adapter_state),
 354                 }
 355         },
 356         .read_mac_address = vp702x_read_mac_addr,
 357
 358         .rc.legacy = {
 359                 .rc_map_table       = rc_map_vp702x_table,
 360                 .rc_map_size  = ARRAY_SIZE(rc_map_vp702x_table),
 361                 .rc_interval      = 400,
 362                 .rc_query         = vp702x_rc_query,
 363         },
 364
 365         .num_device_descs = 1,
 366         .devices = {
 367                 { .name = "TwinhanDTV StarBox DVB-S USB2.0 (VP7021)",
 368                   .cold_ids = { &vp702x_usb_table[0], NULL },
 369                   .warm_ids = { NULL },
 370                 },
 371 /*              { .name = "TwinhanDTV StarBox DVB-S USB2.0 (VP7020)",
 372                   .cold_ids = { &vp702x_usb_table[2], NULL },
 373                   .warm_ids = { &vp702x_usb_table[3], NULL },
 374                 },
 375 */              { NULL },
 376         }
 377 };
 378
 379 /* usb specific object needed to register this driver with the usb subsystem */
 380 static struct usb_driver vp702x_usb_driver = {
 381         .name           = "dvb_usb_vp702x",
 382         .probe          = vp702x_usb_probe,
 383         .disconnect     = vp702x_usb_disconnect,
 384         .id_table       = vp702x_usb_table,
 385 };
 386
 387 /* module stuff */
 388 static int __init vp702x_usb_module_init(void)
 389 {
 390         int result;
 391         if ((result = usb_register(&vp702x_usb_driver))) {
 392                 err("usb_register failed. (%d)",result);
 393                 return result;
 394         }
 395
 396         return 0;
 397 }
 398
 399 static void __exit vp702x_usb_module_exit(void)
 400 {
 401         /* deregister this driver from the USB subsystem */
 402         usb_deregister(&vp702x_usb_driver);
 403 }
 404
 405 module_init(vp702x_usb_module_init);
 406 module_exit(vp702x_usb_module_exit);
 407
 408 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>");
 409 MODULE_DESCRIPTION("Driver for Twinhan StarBox DVB-S USB2.0 and clones");
 410 MODULE_VERSION("1.0");
 411 MODULE_LICENSE("GPL");