drivers/media/video/em28xx/em28xx-dvb.c

   1 /*
   2  DVB device driver for em28xx
   3
   4  (c) 2008 Mauro Carvalho Chehab <mchehab@infradead.org>
   5
   6  (c) 2008 Devin Heitmueller <devin.heitmueller@gmail.com>
   7         - Fixes for the driver to properly work with HVR-950
   8         - Fixes for the driver to properly work with Pinnacle PCTV HD Pro Stick
   9         - Fixes for the driver to properly work with AMD ATI TV Wonder HD 600
  10
  11  (c) 2008 Aidan Thornton <makosoft@googlemail.com>
  12
  13  Based on cx88-dvb, saa7134-dvb and videobuf-dvb originally written by:
  14         (c) 2004, 2005 Chris Pascoe <c.pascoe@itee.uq.edu.au>
  15         (c) 2004 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
  16
  17  This program is free software; you can redistribute it and/or modify
  18  it under the terms of the GNU General Public License as published by
  19  the Free Software Foundation; either version 2 of the License.
  20  */
  21
  22 #include <linux/kernel.h>
  23 #include <linux/usb.h>
  24
  25 #include "em28xx.h"
  26 #include <media/v4l2-common.h>
  27 #include <media/videobuf-vmalloc.h>
  28
  29 #include "lgdt330x.h"
  30 #include "zl10353.h"
  31 #include "s5h1409.h"
  32
  33 MODULE_DESCRIPTION("driver for em28xx based DVB cards");
  34 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>");
  35 MODULE_LICENSE("GPL");
  36
  37 static unsigned int debug;
  38 module_param(debug, int, 0644);
  39 MODULE_PARM_DESC(debug, "enable debug messages [dvb]");
  40
  41 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  42
  43 #define dprintk(level, fmt, arg...) do {                        \
  44 if (debug >= level)                                             \
  45         printk(KERN_DEBUG "%s/2-dvb: " fmt, dev->name, ## arg); \
  46 } while (0)
  47
  48 #define EM28XX_DVB_NUM_BUFS 5
  49 #define EM28XX_DVB_MAX_PACKETS 64
  50
  51 struct em28xx_dvb {
  52         struct dvb_frontend        *frontend;
  53
  54         /* feed count management */
  55         struct mutex               lock;
  56         int                        nfeeds;
  57
  58         /* general boilerplate stuff */
  59         struct dvb_adapter         adapter;
  60         struct dvb_demux           demux;
  61         struct dmxdev              dmxdev;
  62         struct dmx_frontend        fe_hw;
  63         struct dmx_frontend        fe_mem;
  64         struct dvb_net             net;
  65 };
  66
  67
  68 static inline void print_err_status(struct em28xx *dev,
  69                                      int packet, int status)
  70 {
  71         char *errmsg = "Unknown";
  72
  73         switch (status) {
  74         case -ENOENT:
  75                 errmsg = "unlinked synchronuously";
  76                 break;
  77         case -ECONNRESET:
  78                 errmsg = "unlinked asynchronuously";
  79                 break;
  80         case -ENOSR:
  81                 errmsg = "Buffer error (overrun)";
  82                 break;
  83         case -EPIPE:
  84                 errmsg = "Stalled (device not responding)";
  85                 break;
  86         case -EOVERFLOW:
  87                 errmsg = "Babble (bad cable?)";
  88                 break;
  89         case -EPROTO:
  90                 errmsg = "Bit-stuff error (bad cable?)";
  91                 break;
  92         case -EILSEQ:
  93                 errmsg = "CRC/Timeout (could be anything)";
  94                 break;
  95         case -ETIME:
  96                 errmsg = "Device does not respond";
  97                 break;
  98         }
  99         if (packet < 0) {
 100                 dprintk(1, "URB status %d [%s].\n", status, errmsg);
 101         } else {
 102                 dprintk(1, "URB packet %d, status %d [%s].\n",
 103                         packet, status, errmsg);
 104         }
 105 }
 106
 107 static inline int dvb_isoc_copy(struct em28xx *dev, struct urb *urb)
 108 {
 109         int i;
 110
 111         if (!dev)
 112                 return 0;
 113
 114         if ((dev->state & DEV_DISCONNECTED) || (dev->state & DEV_MISCONFIGURED))
 115                 return 0;
 116
 117         if (urb->status < 0) {
 118                 print_err_status(dev, -1, urb->status);
 119                 if (urb->status == -ENOENT)
 120                         return 0;
 121         }
 122
 123         for (i = 0; i < urb->number_of_packets; i++) {
 124                 int status = urb->iso_frame_desc[i].status;
 125
 126                 if (status < 0) {
 127                         print_err_status(dev, i, status);
 128                         if (urb->iso_frame_desc[i].status != -EPROTO)
 129                                 continue;
 130                 }
 131
 132                 dvb_dmx_swfilter(&dev->dvb->demux, urb->transfer_buffer +
 133                                  urb->iso_frame_desc[i].offset,
 134                                  urb->iso_frame_desc[i].actual_length);
 135         }
 136
 137         return 0;
 138 }
 139
 140 static int start_streaming(struct em28xx_dvb *dvb)
 141 {
 142         int rc;
 143         struct em28xx *dev = dvb->adapter.priv;
 144         int max_dvb_packet_size;
 145
 146         usb_set_interface(dev->udev, 0, 1);
 147         rc = em28xx_set_mode(dev, EM28XX_DIGITAL_MODE);
 148         if (rc < 0)
 149                 return rc;
 150
 151         max_dvb_packet_size = em28xx_isoc_dvb_max_packetsize(dev);
 152
 153         return em28xx_init_isoc(dev, EM28XX_DVB_MAX_PACKETS,
 154                                 EM28XX_DVB_NUM_BUFS, max_dvb_packet_size,
 155                                 dvb_isoc_copy);
 156 }
 157
 158 static int stop_streaming(struct em28xx_dvb *dvb)
 159 {
 160         struct em28xx *dev = dvb->adapter.priv;
 161
 162         em28xx_uninit_isoc(dev);
 163
 164         em28xx_set_mode(dev, EM28XX_SUSPEND);
 165
 166         return 0;
 167 }
 168
 169 static int start_feed(struct dvb_demux_feed *feed)
 170 {
 171         struct dvb_demux *demux  = feed->demux;
 172         struct em28xx_dvb *dvb = demux->priv;
 173         int rc, ret;
 174
 175         if (!demux->dmx.frontend)
 176                 return -EINVAL;
 177
 178         mutex_lock(&dvb->lock);
 179         dvb->nfeeds++;
 180         rc = dvb->nfeeds;
 181
 182         if (dvb->nfeeds == 1) {
 183                 ret = start_streaming(dvb);
 184                 if (ret < 0)
 185                         rc = ret;
 186         }
 187
 188         mutex_unlock(&dvb->lock);
 189         return rc;
 190 }
 191
 192 static int stop_feed(struct dvb_demux_feed *feed)
 193 {
 194         struct dvb_demux *demux  = feed->demux;
 195         struct em28xx_dvb *dvb = demux->priv;
 196         int err = 0;
 197
 198         mutex_lock(&dvb->lock);
 199         dvb->nfeeds--;
 200
 201         if (0 == dvb->nfeeds)
 202                 err = stop_streaming(dvb);
 203
 204         mutex_unlock(&dvb->lock);
 205         return err;
 206 }
 207
 208
 209
 210 /* ------------------------------------------------------------------ */
 211 static int em28xx_dvb_bus_ctrl(struct dvb_frontend *fe, int acquire)
 212 {
 213         struct em28xx *dev = fe->dvb->priv;
 214
 215         if (acquire)
 216                 return em28xx_set_mode(dev, EM28XX_DIGITAL_MODE);
 217         else
 218                 return em28xx_set_mode(dev, EM28XX_SUSPEND);
 219 }
 220
 221 /* ------------------------------------------------------------------ */
 222
 223 static struct lgdt330x_config em2880_lgdt3303_dev = {
 224         .demod_address = 0x0e,
 225         .demod_chip = LGDT3303,
 226 };
 227
 228 static struct zl10353_config em28xx_zl10353_with_xc3028 = {
 229         .demod_address = (0x1e >> 1),
 230         .no_tuner = 1,
 231         .parallel_ts = 1,
 232         .if2 = 45600,
 233 };
 234
 235 static struct s5h1409_config em28xx_s5h1409_with_xc3028 = {
 236         .demod_address = 0x32 >> 1,
 237         .output_mode   = S5H1409_PARALLEL_OUTPUT,
 238         .gpio          = S5H1409_GPIO_OFF,
 239         .inversion     = S5H1409_INVERSION_OFF,
 240         .status_mode   = S5H1409_DEMODLOCKING,
 241         .mpeg_timing   = S5H1409_MPEGTIMING_CONTINOUS_NONINVERTING_CLOCK
 242 };
 243
 244 #ifdef EM28XX_DRX397XD_SUPPORT
 245 /* [TODO] djh - not sure yet what the device config needs to contain */
 246 static struct drx397xD_config em28xx_drx397xD_with_xc3028 = {
 247         .demod_address = (0xe0 >> 1),
 248 };
 249 #endif
 250
 251 /* ------------------------------------------------------------------ */
 252
 253 static int attach_xc3028(u8 addr, struct em28xx *dev)
 254 {
 255         struct dvb_frontend *fe;
 256         struct xc2028_config cfg;
 257
 258         memset(&cfg, 0, sizeof(cfg));
 259         cfg.i2c_adap  = &dev->i2c_adap;
 260         cfg.i2c_addr  = addr;
 261
 262         if (!dev->dvb->frontend) {
 263                 printk(KERN_ERR "%s/2: dvb frontend not attached. "
 264                                 "Can't attach xc3028\n",
 265                        dev->name);
 266                 return -EINVAL;
 267         }
 268
 269         fe = dvb_attach(xc2028_attach, dev->dvb->frontend, &cfg);
 270         if (!fe) {
 271                 printk(KERN_ERR "%s/2: xc3028 attach failed\n",
 272                        dev->name);
 273                 dvb_frontend_detach(dev->dvb->frontend);
 274                 dev->dvb->frontend = NULL;
 275                 return -EINVAL;
 276         }
 277
 278         printk(KERN_INFO "%s/2: xc3028 attached\n", dev->name);
 279
 280         return 0;
 281 }
 282
 283 /* ------------------------------------------------------------------ */
 284
 285 static int register_dvb(struct em28xx_dvb *dvb,
 286                  struct module *module,
 287                  struct em28xx *dev,
 288                  struct device *device)
 289 {
 290         int result;
 291
 292         mutex_init(&dvb->lock);
 293
 294         /* register adapter */
 295         result = dvb_register_adapter(&dvb->adapter, dev->name, module, device,
 296                                       adapter_nr);
 297         if (result < 0) {
 298                 printk(KERN_WARNING "%s: dvb_register_adapter failed (errno = %d)\n",
 299                        dev->name, result);
 300                 goto fail_adapter;
 301         }
 302
 303         /* Ensure all frontends negotiate bus access */
 304         dvb->frontend->ops.ts_bus_ctrl = em28xx_dvb_bus_ctrl;
 305
 306         dvb->adapter.priv = dev;
 307
 308         /* register frontend */
 309         result = dvb_register_frontend(&dvb->adapter, dvb->frontend);
 310         if (result < 0) {
 311                 printk(KERN_WARNING "%s: dvb_register_frontend failed (errno = %d)\n",
 312                        dev->name, result);
 313                 goto fail_frontend;
 314         }
 315
 316         /* register demux stuff */
 317         dvb->demux.dmx.capabilities =
 318                 DMX_TS_FILTERING | DMX_SECTION_FILTERING |
 319                 DMX_MEMORY_BASED_FILTERING;
 320         dvb->demux.priv       = dvb;
 321         dvb->demux.filternum  = 256;
 322         dvb->demux.feednum    = 256;
 323         dvb->demux.start_feed = start_feed;
 324         dvb->demux.stop_feed  = stop_feed;
 325
 326         result = dvb_dmx_init(&dvb->demux);
 327         if (result < 0) {
 328                 printk(KERN_WARNING "%s: dvb_dmx_init failed (errno = %d)\n",
 329                        dev->name, result);
 330                 goto fail_dmx;
 331         }
 332
 333         dvb->dmxdev.filternum    = 256;
 334         dvb->dmxdev.demux        = &dvb->demux.dmx;
 335         dvb->dmxdev.capabilities = 0;
 336         result = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter);
 337         if (result < 0) {
 338                 printk(KERN_WARNING "%s: dvb_dmxdev_init failed (errno = %d)\n",
 339                        dev->name, result);
 340                 goto fail_dmxdev;
 341         }
 342
 343         dvb->fe_hw.source = DMX_FRONTEND_0;
 344         result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 345         if (result < 0) {
 346                 printk(KERN_WARNING "%s: add_frontend failed (DMX_FRONTEND_0, errno = %d)\n",
 347                        dev->name, result);
 348                 goto fail_fe_hw;
 349         }
 350
 351         dvb->fe_mem.source = DMX_MEMORY_FE;
 352         result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_mem);
 353         if (result < 0) {
 354                 printk(KERN_WARNING "%s: add_frontend failed (DMX_MEMORY_FE, errno = %d)\n",
 355                        dev->name, result);
 356                 goto fail_fe_mem;
 357         }
 358
 359         result = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 360         if (result < 0) {
 361                 printk(KERN_WARNING "%s: connect_frontend failed (errno = %d)\n",
 362                        dev->name, result);
 363                 goto fail_fe_conn;
 364         }
 365
 366         /* register network adapter */
 367         dvb_net_init(&dvb->adapter, &dvb->net, &dvb->demux.dmx);
 368         return 0;
 369
 370 fail_fe_conn:
 371         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
 372 fail_fe_mem:
 373         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 374 fail_fe_hw:
 375         dvb_dmxdev_release(&dvb->dmxdev);
 376 fail_dmxdev:
 377         dvb_dmx_release(&dvb->demux);
 378 fail_dmx:
 379         dvb_unregister_frontend(dvb->frontend);
 380 fail_frontend:
 381         dvb_frontend_detach(dvb->frontend);
 382         dvb_unregister_adapter(&dvb->adapter);
 383 fail_adapter:
 384         return result;
 385 }
 386
 387 static void unregister_dvb(struct em28xx_dvb *dvb)
 388 {
 389         dvb_net_release(&dvb->net);
 390         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
 391         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 392         dvb_dmxdev_release(&dvb->dmxdev);
 393         dvb_dmx_release(&dvb->demux);
 394         dvb_unregister_frontend(dvb->frontend);
 395         dvb_frontend_detach(dvb->frontend);
 396         dvb_unregister_adapter(&dvb->adapter);
 397 }
 398
 399
 400 static int dvb_init(struct em28xx *dev)
 401 {
 402         int result = 0;
 403         struct em28xx_dvb *dvb;
 404
 405         if (!dev->board.has_dvb) {
 406                 /* This device does not support the extension */
 407                 return 0;
 408         }
 409
 410         dvb = kzalloc(sizeof(struct em28xx_dvb), GFP_KERNEL);
 411
 412         if (dvb == NULL) {
 413                 printk(KERN_INFO "em28xx_dvb: memory allocation failed\n");
 414                 return -ENOMEM;
 415         }
 416         dev->dvb = dvb;
 417
 418         em28xx_set_mode(dev, EM28XX_DIGITAL_MODE);
 419         /* init frontend */
 420         switch (dev->model) {
 421         case EM2883_BOARD_HAUPPAUGE_WINTV_HVR_850:
 422         case EM2883_BOARD_HAUPPAUGE_WINTV_HVR_950:
 423         case EM2880_BOARD_PINNACLE_PCTV_HD_PRO:
 424         case EM2880_BOARD_AMD_ATI_TV_WONDER_HD_600:
 425                 dvb->frontend = dvb_attach(lgdt330x_attach,
 426                                            &em2880_lgdt3303_dev,
 427                                            &dev->i2c_adap);
 428                 if (attach_xc3028(0x61, dev) < 0) {
 429                         result = -EINVAL;
 430                         goto out_free;
 431                 }
 432                 break;
 433         case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900:
 434         case EM2880_BOARD_TERRATEC_HYBRID_XS:
 435         case EM2880_BOARD_KWORLD_DVB_310U:
 436         case EM2880_BOARD_EMPIRE_DUAL_TV:
 437                 dvb->frontend = dvb_attach(zl10353_attach,
 438                                            &em28xx_zl10353_with_xc3028,
 439                                            &dev->i2c_adap);
 440                 if (attach_xc3028(0x61, dev) < 0) {
 441                         result = -EINVAL;
 442                         goto out_free;
 443                 }
 444                 break;
 445         case EM2883_BOARD_KWORLD_HYBRID_330U:
 446                 dvb->frontend = dvb_attach(s5h1409_attach,
 447                                            &em28xx_s5h1409_with_xc3028,
 448                                            &dev->i2c_adap);
 449                 if (attach_xc3028(0x61, dev) < 0) {
 450                         result = -EINVAL;
 451                         goto out_free;
 452                 }
 453                 break;
 454         case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900_R2:
 455 #ifdef EM28XX_DRX397XD_SUPPORT
 456                 /* We don't have the config structure properly populated, so
 457                    this is commented out for now */
 458                 dvb->frontend = dvb_attach(drx397xD_attach,
 459                                            &em28xx_drx397xD_with_xc3028,
 460                                            &dev->i2c_adap);
 461                 if (attach_xc3028(0x61, dev) < 0) {
 462                         result = -EINVAL;
 463                         goto out_free;
 464                 }
 465                 break;
 466 #endif
 467         default:
 468                 printk(KERN_ERR "%s/2: The frontend of your DVB/ATSC card"
 469                                 " isn't supported yet\n",
 470                        dev->name);
 471                 break;
 472         }
 473         if (NULL == dvb->frontend) {
 474                 printk(KERN_ERR
 475                        "%s/2: frontend initialization failed\n",
 476                        dev->name);
 477                 result = -EINVAL;
 478                 goto out_free;
 479         }
 480         /* define general-purpose callback pointer */
 481         dvb->frontend->callback = em28xx_tuner_callback;
 482
 483         /* register everything */
 484         result = register_dvb(dvb, THIS_MODULE, dev, &dev->udev->dev);
 485
 486         if (result < 0)
 487                 goto out_free;
 488
 489         em28xx_set_mode(dev, EM28XX_SUSPEND);
 490         printk(KERN_INFO "Successfully loaded em28xx-dvb\n");
 491         return 0;
 492
 493 out_free:
 494         em28xx_set_mode(dev, EM28XX_SUSPEND);
 495         kfree(dvb);
 496         dev->dvb = NULL;
 497         return result;
 498 }
 499
 500 static int dvb_fini(struct em28xx *dev)
 501 {
 502         if (!dev->board.has_dvb) {
 503                 /* This device does not support the extension */
 504                 return 0;
 505         }
 506
 507         if (dev->dvb) {
 508                 unregister_dvb(dev->dvb);
 509                 dev->dvb = NULL;
 510         }
 511
 512         return 0;
 513 }
 514
 515 static struct em28xx_ops dvb_ops = {
 516         .id   = EM28XX_DVB,
 517         .name = "Em28xx dvb Extension",
 518         .init = dvb_init,
 519         .fini = dvb_fini,
 520 };
 521
 522 static int __init em28xx_dvb_register(void)
 523 {
 524         return em28xx_register_extension(&dvb_ops);
 525 }
 526
 527 static void __exit em28xx_dvb_unregister(void)
 528 {
 529         em28xx_unregister_extension(&dvb_ops);
 530 }
 531
 532 module_init(em28xx_dvb_register);
 533 module_exit(em28xx_dvb_unregister);