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/slab.h>
  24 #include <linux/usb.h>
  25
  26 #include "em28xx.h"
  27 #include <media/v4l2-common.h>
  28 #include <media/videobuf-vmalloc.h>
  29 #include <media/tuner.h>
  30 #include "tuner-simple.h"
  31
  32 #include "lgdt330x.h"
  33 #include "lgdt3305.h"
  34 #include "zl10353.h"
  35 #include "s5h1409.h"
  36 #include "mt352.h"
  37 #include "mt352_priv.h" /* FIXME */
  38 #include "tda1002x.h"
  39 #include "tda18271.h"
  40 #include "s921.h"
  41
  42 MODULE_DESCRIPTION("driver for em28xx based DVB cards");
  43 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>");
  44 MODULE_LICENSE("GPL");
  45
  46 static unsigned int debug;
  47 module_param(debug, int, 0644);
  48 MODULE_PARM_DESC(debug, "enable debug messages [dvb]");
  49
  50 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  51
  52 #define dprintk(level, fmt, arg...) do {                        \
  53 if (debug >= level)                                             \
  54         printk(KERN_DEBUG "%s/2-dvb: " fmt, dev->name, ## arg); \
  55 } while (0)
  56
  57 #define EM28XX_DVB_NUM_BUFS 5
  58 #define EM28XX_DVB_MAX_PACKETS 64
  59
  60 struct em28xx_dvb {
  61         struct dvb_frontend        *frontend;
  62
  63         /* feed count management */
  64         struct mutex               lock;
  65         int                        nfeeds;
  66
  67         /* general boilerplate stuff */
  68         struct dvb_adapter         adapter;
  69         struct dvb_demux           demux;
  70         struct dmxdev              dmxdev;
  71         struct dmx_frontend        fe_hw;
  72         struct dmx_frontend        fe_mem;
  73         struct dvb_net             net;
  74 };
  75
  76
  77 static inline void print_err_status(struct em28xx *dev,
  78                                      int packet, int status)
  79 {
  80         char *errmsg = "Unknown";
  81
  82         switch (status) {
  83         case -ENOENT:
  84                 errmsg = "unlinked synchronuously";
  85                 break;
  86         case -ECONNRESET:
  87                 errmsg = "unlinked asynchronuously";
  88                 break;
  89         case -ENOSR:
  90                 errmsg = "Buffer error (overrun)";
  91                 break;
  92         case -EPIPE:
  93                 errmsg = "Stalled (device not responding)";
  94                 break;
  95         case -EOVERFLOW:
  96                 errmsg = "Babble (bad cable?)";
  97                 break;
  98         case -EPROTO:
  99                 errmsg = "Bit-stuff error (bad cable?)";
 100                 break;
 101         case -EILSEQ:
 102                 errmsg = "CRC/Timeout (could be anything)";
 103                 break;
 104         case -ETIME:
 105                 errmsg = "Device does not respond";
 106                 break;
 107         }
 108         if (packet < 0) {
 109                 dprintk(1, "URB status %d [%s].\n", status, errmsg);
 110         } else {
 111                 dprintk(1, "URB packet %d, status %d [%s].\n",
 112                         packet, status, errmsg);
 113         }
 114 }
 115
 116 static inline int dvb_isoc_copy(struct em28xx *dev, struct urb *urb)
 117 {
 118         int i;
 119
 120         if (!dev)
 121                 return 0;
 122
 123         if ((dev->state & DEV_DISCONNECTED) || (dev->state & DEV_MISCONFIGURED))
 124                 return 0;
 125
 126         if (urb->status < 0) {
 127                 print_err_status(dev, -1, urb->status);
 128                 if (urb->status == -ENOENT)
 129                         return 0;
 130         }
 131
 132         for (i = 0; i < urb->number_of_packets; i++) {
 133                 int status = urb->iso_frame_desc[i].status;
 134
 135                 if (status < 0) {
 136                         print_err_status(dev, i, status);
 137                         if (urb->iso_frame_desc[i].status != -EPROTO)
 138                                 continue;
 139                 }
 140
 141                 dvb_dmx_swfilter(&dev->dvb->demux, urb->transfer_buffer +
 142                                  urb->iso_frame_desc[i].offset,
 143                                  urb->iso_frame_desc[i].actual_length);
 144         }
 145
 146         return 0;
 147 }
 148
 149 static int start_streaming(struct em28xx_dvb *dvb)
 150 {
 151         int rc;
 152         struct em28xx *dev = dvb->adapter.priv;
 153         int max_dvb_packet_size;
 154
 155         usb_set_interface(dev->udev, 0, 1);
 156         rc = em28xx_set_mode(dev, EM28XX_DIGITAL_MODE);
 157         if (rc < 0)
 158                 return rc;
 159
 160         max_dvb_packet_size = em28xx_isoc_dvb_max_packetsize(dev);
 161
 162         return em28xx_init_isoc(dev, EM28XX_DVB_MAX_PACKETS,
 163                                 EM28XX_DVB_NUM_BUFS, max_dvb_packet_size,
 164                                 dvb_isoc_copy);
 165 }
 166
 167 static int stop_streaming(struct em28xx_dvb *dvb)
 168 {
 169         struct em28xx *dev = dvb->adapter.priv;
 170
 171         em28xx_uninit_isoc(dev);
 172
 173         em28xx_set_mode(dev, EM28XX_SUSPEND);
 174
 175         return 0;
 176 }
 177
 178 static int start_feed(struct dvb_demux_feed *feed)
 179 {
 180         struct dvb_demux *demux  = feed->demux;
 181         struct em28xx_dvb *dvb = demux->priv;
 182         int rc, ret;
 183
 184         if (!demux->dmx.frontend)
 185                 return -EINVAL;
 186
 187         mutex_lock(&dvb->lock);
 188         dvb->nfeeds++;
 189         rc = dvb->nfeeds;
 190
 191         if (dvb->nfeeds == 1) {
 192                 ret = start_streaming(dvb);
 193                 if (ret < 0)
 194                         rc = ret;
 195         }
 196
 197         mutex_unlock(&dvb->lock);
 198         return rc;
 199 }
 200
 201 static int stop_feed(struct dvb_demux_feed *feed)
 202 {
 203         struct dvb_demux *demux  = feed->demux;
 204         struct em28xx_dvb *dvb = demux->priv;
 205         int err = 0;
 206
 207         mutex_lock(&dvb->lock);
 208         dvb->nfeeds--;
 209
 210         if (0 == dvb->nfeeds)
 211                 err = stop_streaming(dvb);
 212
 213         mutex_unlock(&dvb->lock);
 214         return err;
 215 }
 216
 217
 218
 219 /* ------------------------------------------------------------------ */
 220 static int em28xx_dvb_bus_ctrl(struct dvb_frontend *fe, int acquire)
 221 {
 222         struct em28xx *dev = fe->dvb->priv;
 223
 224         if (acquire)
 225                 return em28xx_set_mode(dev, EM28XX_DIGITAL_MODE);
 226         else
 227                 return em28xx_set_mode(dev, EM28XX_SUSPEND);
 228 }
 229
 230 /* ------------------------------------------------------------------ */
 231
 232 static struct lgdt330x_config em2880_lgdt3303_dev = {
 233         .demod_address = 0x0e,
 234         .demod_chip = LGDT3303,
 235 };
 236
 237 static struct lgdt3305_config em2870_lgdt3304_dev = {
 238         .i2c_addr           = 0x0e,
 239         .demod_chip         = LGDT3304,
 240         .spectral_inversion = 1,
 241         .deny_i2c_rptr      = 1,
 242         .mpeg_mode          = LGDT3305_MPEG_PARALLEL,
 243         .tpclk_edge         = LGDT3305_TPCLK_FALLING_EDGE,
 244         .tpvalid_polarity   = LGDT3305_TP_VALID_HIGH,
 245         .vsb_if_khz         = 3250,
 246         .qam_if_khz         = 4000,
 247 };
 248
 249 static struct s921_config sharp_isdbt = {
 250         .demod_address = 0x30 >> 1
 251 };
 252
 253 static struct zl10353_config em28xx_zl10353_with_xc3028 = {
 254         .demod_address = (0x1e >> 1),
 255         .no_tuner = 1,
 256         .parallel_ts = 1,
 257         .if2 = 45600,
 258 };
 259
 260 static struct s5h1409_config em28xx_s5h1409_with_xc3028 = {
 261         .demod_address = 0x32 >> 1,
 262         .output_mode   = S5H1409_PARALLEL_OUTPUT,
 263         .gpio          = S5H1409_GPIO_OFF,
 264         .inversion     = S5H1409_INVERSION_OFF,
 265         .status_mode   = S5H1409_DEMODLOCKING,
 266         .mpeg_timing   = S5H1409_MPEGTIMING_CONTINOUS_NONINVERTING_CLOCK
 267 };
 268
 269 static struct tda18271_std_map kworld_a340_std_map = {
 270         .atsc_6   = { .if_freq = 3250, .agc_mode = 3, .std = 0,
 271                       .if_lvl = 1, .rfagc_top = 0x37, },
 272         .qam_6    = { .if_freq = 4000, .agc_mode = 3, .std = 1,
 273                       .if_lvl = 1, .rfagc_top = 0x37, },
 274 };
 275
 276 static struct tda18271_config kworld_a340_config = {
 277         .std_map           = &kworld_a340_std_map,
 278 };
 279
 280 static struct zl10353_config em28xx_zl10353_xc3028_no_i2c_gate = {
 281         .demod_address = (0x1e >> 1),
 282         .no_tuner = 1,
 283         .disable_i2c_gate_ctrl = 1,
 284         .parallel_ts = 1,
 285         .if2 = 45600,
 286 };
 287
 288 #ifdef EM28XX_DRX397XD_SUPPORT
 289 /* [TODO] djh - not sure yet what the device config needs to contain */
 290 static struct drx397xD_config em28xx_drx397xD_with_xc3028 = {
 291         .demod_address = (0xe0 >> 1),
 292 };
 293 #endif
 294
 295 static int mt352_terratec_xs_init(struct dvb_frontend *fe)
 296 {
 297         /* Values extracted from a USB trace of the Terratec Windows driver */
 298         static u8 clock_config[]   = { CLOCK_CTL,  0x38, 0x2c };
 299         static u8 reset[]          = { RESET,      0x80 };
 300         static u8 adc_ctl_1_cfg[]  = { ADC_CTL_1,  0x40 };
 301         static u8 agc_cfg[]        = { AGC_TARGET, 0x28, 0xa0 };
 302         static u8 input_freq_cfg[] = { INPUT_FREQ_1, 0x31, 0xb8 };
 303         static u8 rs_err_cfg[]     = { RS_ERR_PER_1, 0x00, 0x4d };
 304         static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
 305         static u8 trl_nom_cfg[]    = { TRL_NOMINAL_RATE_1, 0x64, 0x00 };
 306         static u8 tps_given_cfg[]  = { TPS_GIVEN_1, 0x40, 0x80, 0x50 };
 307         static u8 tuner_go[]       = { TUNER_GO, 0x01};
 308
 309         mt352_write(fe, clock_config,   sizeof(clock_config));
 310         udelay(200);
 311         mt352_write(fe, reset,          sizeof(reset));
 312         mt352_write(fe, adc_ctl_1_cfg,  sizeof(adc_ctl_1_cfg));
 313         mt352_write(fe, agc_cfg,        sizeof(agc_cfg));
 314         mt352_write(fe, input_freq_cfg, sizeof(input_freq_cfg));
 315         mt352_write(fe, rs_err_cfg,     sizeof(rs_err_cfg));
 316         mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
 317         mt352_write(fe, trl_nom_cfg,    sizeof(trl_nom_cfg));
 318         mt352_write(fe, tps_given_cfg,  sizeof(tps_given_cfg));
 319         mt352_write(fe, tuner_go,       sizeof(tuner_go));
 320         return 0;
 321 }
 322
 323 static struct mt352_config terratec_xs_mt352_cfg = {
 324         .demod_address = (0x1e >> 1),
 325         .no_tuner = 1,
 326         .if2 = 45600,
 327         .demod_init = mt352_terratec_xs_init,
 328 };
 329
 330 static struct tda10023_config em28xx_tda10023_config = {
 331         .demod_address = 0x0c,
 332         .invert = 1,
 333 };
 334
 335 /* ------------------------------------------------------------------ */
 336
 337 static int attach_xc3028(u8 addr, struct em28xx *dev)
 338 {
 339         struct dvb_frontend *fe;
 340         struct xc2028_config cfg;
 341
 342         memset(&cfg, 0, sizeof(cfg));
 343         cfg.i2c_adap  = &dev->i2c_adap;
 344         cfg.i2c_addr  = addr;
 345
 346         if (!dev->dvb->frontend) {
 347                 em28xx_errdev("/2: dvb frontend not attached. "
 348                                 "Can't attach xc3028\n");
 349                 return -EINVAL;
 350         }
 351
 352         fe = dvb_attach(xc2028_attach, dev->dvb->frontend, &cfg);
 353         if (!fe) {
 354                 em28xx_errdev("/2: xc3028 attach failed\n");
 355                 dvb_frontend_detach(dev->dvb->frontend);
 356                 dev->dvb->frontend = NULL;
 357                 return -EINVAL;
 358         }
 359
 360         em28xx_info("%s/2: xc3028 attached\n", dev->name);
 361
 362         return 0;
 363 }
 364
 365 /* ------------------------------------------------------------------ */
 366
 367 static int register_dvb(struct em28xx_dvb *dvb,
 368                  struct module *module,
 369                  struct em28xx *dev,
 370                  struct device *device)
 371 {
 372         int result;
 373
 374         mutex_init(&dvb->lock);
 375
 376         /* register adapter */
 377         result = dvb_register_adapter(&dvb->adapter, dev->name, module, device,
 378                                       adapter_nr);
 379         if (result < 0) {
 380                 printk(KERN_WARNING "%s: dvb_register_adapter failed (errno = %d)\n",
 381                        dev->name, result);
 382                 goto fail_adapter;
 383         }
 384
 385         /* Ensure all frontends negotiate bus access */
 386         dvb->frontend->ops.ts_bus_ctrl = em28xx_dvb_bus_ctrl;
 387
 388         dvb->adapter.priv = dev;
 389
 390         /* register frontend */
 391         result = dvb_register_frontend(&dvb->adapter, dvb->frontend);
 392         if (result < 0) {
 393                 printk(KERN_WARNING "%s: dvb_register_frontend failed (errno = %d)\n",
 394                        dev->name, result);
 395                 goto fail_frontend;
 396         }
 397
 398         /* register demux stuff */
 399         dvb->demux.dmx.capabilities =
 400                 DMX_TS_FILTERING | DMX_SECTION_FILTERING |
 401                 DMX_MEMORY_BASED_FILTERING;
 402         dvb->demux.priv       = dvb;
 403         dvb->demux.filternum  = 256;
 404         dvb->demux.feednum    = 256;
 405         dvb->demux.start_feed = start_feed;
 406         dvb->demux.stop_feed  = stop_feed;
 407
 408         result = dvb_dmx_init(&dvb->demux);
 409         if (result < 0) {
 410                 printk(KERN_WARNING "%s: dvb_dmx_init failed (errno = %d)\n",
 411                        dev->name, result);
 412                 goto fail_dmx;
 413         }
 414
 415         dvb->dmxdev.filternum    = 256;
 416         dvb->dmxdev.demux        = &dvb->demux.dmx;
 417         dvb->dmxdev.capabilities = 0;
 418         result = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter);
 419         if (result < 0) {
 420                 printk(KERN_WARNING "%s: dvb_dmxdev_init failed (errno = %d)\n",
 421                        dev->name, result);
 422                 goto fail_dmxdev;
 423         }
 424
 425         dvb->fe_hw.source = DMX_FRONTEND_0;
 426         result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 427         if (result < 0) {
 428                 printk(KERN_WARNING "%s: add_frontend failed (DMX_FRONTEND_0, errno = %d)\n",
 429                        dev->name, result);
 430                 goto fail_fe_hw;
 431         }
 432
 433         dvb->fe_mem.source = DMX_MEMORY_FE;
 434         result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_mem);
 435         if (result < 0) {
 436                 printk(KERN_WARNING "%s: add_frontend failed (DMX_MEMORY_FE, errno = %d)\n",
 437                        dev->name, result);
 438                 goto fail_fe_mem;
 439         }
 440
 441         result = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 442         if (result < 0) {
 443                 printk(KERN_WARNING "%s: connect_frontend failed (errno = %d)\n",
 444                        dev->name, result);
 445                 goto fail_fe_conn;
 446         }
 447
 448         /* register network adapter */
 449         dvb_net_init(&dvb->adapter, &dvb->net, &dvb->demux.dmx);
 450         return 0;
 451
 452 fail_fe_conn:
 453         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
 454 fail_fe_mem:
 455         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 456 fail_fe_hw:
 457         dvb_dmxdev_release(&dvb->dmxdev);
 458 fail_dmxdev:
 459         dvb_dmx_release(&dvb->demux);
 460 fail_dmx:
 461         dvb_unregister_frontend(dvb->frontend);
 462 fail_frontend:
 463         dvb_frontend_detach(dvb->frontend);
 464         dvb_unregister_adapter(&dvb->adapter);
 465 fail_adapter:
 466         return result;
 467 }
 468
 469 static void unregister_dvb(struct em28xx_dvb *dvb)
 470 {
 471         dvb_net_release(&dvb->net);
 472         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
 473         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 474         dvb_dmxdev_release(&dvb->dmxdev);
 475         dvb_dmx_release(&dvb->demux);
 476         dvb_unregister_frontend(dvb->frontend);
 477         dvb_frontend_detach(dvb->frontend);
 478         dvb_unregister_adapter(&dvb->adapter);
 479 }
 480
 481
 482 static int dvb_init(struct em28xx *dev)
 483 {
 484         int result = 0;
 485         struct em28xx_dvb *dvb;
 486
 487         if (!dev->board.has_dvb) {
 488                 /* This device does not support the extension */
 489                 printk(KERN_INFO "em28xx_dvb: This device does not support the extension\n");
 490                 return 0;
 491         }
 492
 493         dvb = kzalloc(sizeof(struct em28xx_dvb), GFP_KERNEL);
 494
 495         if (dvb == NULL) {
 496                 em28xx_info("em28xx_dvb: memory allocation failed\n");
 497                 return -ENOMEM;
 498         }
 499         dev->dvb = dvb;
 500
 501         mutex_lock(&dev->lock);
 502         em28xx_set_mode(dev, EM28XX_DIGITAL_MODE);
 503         /* init frontend */
 504         switch (dev->model) {
 505         case EM2874_LEADERSHIP_ISDBT:
 506                 dvb->frontend = dvb_attach(s921_attach,
 507                                 &sharp_isdbt, &dev->i2c_adap);
 508
 509                 if (!dvb->frontend) {
 510                         result = -EINVAL;
 511                         goto out_free;
 512                 }
 513
 514                 break;
 515         case EM2883_BOARD_HAUPPAUGE_WINTV_HVR_850:
 516         case EM2883_BOARD_HAUPPAUGE_WINTV_HVR_950:
 517         case EM2880_BOARD_PINNACLE_PCTV_HD_PRO:
 518         case EM2880_BOARD_AMD_ATI_TV_WONDER_HD_600:
 519                 dvb->frontend = dvb_attach(lgdt330x_attach,
 520                                            &em2880_lgdt3303_dev,
 521                                            &dev->i2c_adap);
 522                 if (attach_xc3028(0x61, dev) < 0) {
 523                         result = -EINVAL;
 524                         goto out_free;
 525                 }
 526                 break;
 527         case EM2880_BOARD_KWORLD_DVB_310U:
 528                 dvb->frontend = dvb_attach(zl10353_attach,
 529                                            &em28xx_zl10353_with_xc3028,
 530                                            &dev->i2c_adap);
 531                 if (attach_xc3028(0x61, dev) < 0) {
 532                         result = -EINVAL;
 533                         goto out_free;
 534                 }
 535                 break;
 536         case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900:
 537         case EM2882_BOARD_TERRATEC_HYBRID_XS:
 538         case EM2880_BOARD_EMPIRE_DUAL_TV:
 539                 dvb->frontend = dvb_attach(zl10353_attach,
 540                                            &em28xx_zl10353_xc3028_no_i2c_gate,
 541                                            &dev->i2c_adap);
 542                 if (attach_xc3028(0x61, dev) < 0) {
 543                         result = -EINVAL;
 544                         goto out_free;
 545                 }
 546                 break;
 547         case EM2880_BOARD_TERRATEC_HYBRID_XS:
 548         case EM2880_BOARD_TERRATEC_HYBRID_XS_FR:
 549         case EM2881_BOARD_PINNACLE_HYBRID_PRO:
 550         case EM2882_BOARD_DIKOM_DK300:
 551         case EM2882_BOARD_KWORLD_VS_DVBT:
 552                 dvb->frontend = dvb_attach(zl10353_attach,
 553                                            &em28xx_zl10353_xc3028_no_i2c_gate,
 554                                            &dev->i2c_adap);
 555                 if (dvb->frontend == NULL) {
 556                         /* This board could have either a zl10353 or a mt352.
 557                            If the chip id isn't for zl10353, try mt352 */
 558                         dvb->frontend = dvb_attach(mt352_attach,
 559                                                    &terratec_xs_mt352_cfg,
 560                                                    &dev->i2c_adap);
 561                 }
 562
 563                 if (attach_xc3028(0x61, dev) < 0) {
 564                         result = -EINVAL;
 565                         goto out_free;
 566                 }
 567                 break;
 568         case EM2883_BOARD_KWORLD_HYBRID_330U:
 569         case EM2882_BOARD_EVGA_INDTUBE:
 570                 dvb->frontend = dvb_attach(s5h1409_attach,
 571                                            &em28xx_s5h1409_with_xc3028,
 572                                            &dev->i2c_adap);
 573                 if (attach_xc3028(0x61, dev) < 0) {
 574                         result = -EINVAL;
 575                         goto out_free;
 576                 }
 577                 break;
 578         case EM2882_BOARD_KWORLD_ATSC_315U:
 579                 dvb->frontend = dvb_attach(lgdt330x_attach,
 580                                            &em2880_lgdt3303_dev,
 581                                            &dev->i2c_adap);
 582                 if (dvb->frontend != NULL) {
 583                         if (!dvb_attach(simple_tuner_attach, dvb->frontend,
 584                                 &dev->i2c_adap, 0x61, TUNER_THOMSON_DTT761X)) {
 585                                 result = -EINVAL;
 586                                 goto out_free;
 587                         }
 588                 }
 589                 break;
 590         case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900_R2:
 591 #ifdef EM28XX_DRX397XD_SUPPORT
 592                 /* We don't have the config structure properly populated, so
 593                    this is commented out for now */
 594                 dvb->frontend = dvb_attach(drx397xD_attach,
 595                                            &em28xx_drx397xD_with_xc3028,
 596                                            &dev->i2c_adap);
 597                 if (attach_xc3028(0x61, dev) < 0) {
 598                         result = -EINVAL;
 599                         goto out_free;
 600                 }
 601                 break;
 602 #endif
 603         case EM2870_BOARD_REDDO_DVB_C_USB_BOX:
 604                 /* Philips CU1216L NIM (Philips TDA10023 + Infineon TUA6034) */
 605                 dvb->frontend = dvb_attach(tda10023_attach,
 606                         &em28xx_tda10023_config,
 607                         &dev->i2c_adap, 0x48);
 608                 if (dvb->frontend) {
 609                         if (!dvb_attach(simple_tuner_attach, dvb->frontend,
 610                                 &dev->i2c_adap, 0x60, TUNER_PHILIPS_CU1216L)) {
 611                                 result = -EINVAL;
 612                                 goto out_free;
 613                         }
 614                 }
 615                 break;
 616         case EM2870_BOARD_KWORLD_A340:
 617                 dvb->frontend = dvb_attach(lgdt3305_attach,
 618                                            &em2870_lgdt3304_dev,
 619                                            &dev->i2c_adap);
 620                 if (dvb->frontend != NULL)
 621                         dvb_attach(tda18271_attach, dvb->frontend, 0x60,
 622                                    &dev->i2c_adap, &kworld_a340_config);
 623                 break;
 624         default:
 625                 em28xx_errdev("/2: The frontend of your DVB/ATSC card"
 626                                 " isn't supported yet\n");
 627                 break;
 628         }
 629         if (NULL == dvb->frontend) {
 630                 em28xx_errdev("/2: frontend initialization failed\n");
 631                 result = -EINVAL;
 632                 goto out_free;
 633         }
 634         /* define general-purpose callback pointer */
 635         dvb->frontend->callback = em28xx_tuner_callback;
 636
 637         /* register everything */
 638         result = register_dvb(dvb, THIS_MODULE, dev, &dev->udev->dev);
 639
 640         if (result < 0)
 641                 goto out_free;
 642
 643         em28xx_info("Successfully loaded em28xx-dvb\n");
 644 ret:
 645         em28xx_set_mode(dev, EM28XX_SUSPEND);
 646         mutex_unlock(&dev->lock);
 647         return result;
 648
 649 out_free:
 650         kfree(dvb);
 651         dev->dvb = NULL;
 652         goto ret;
 653 }
 654
 655 static int dvb_fini(struct em28xx *dev)
 656 {
 657         if (!dev->board.has_dvb) {
 658                 /* This device does not support the extension */
 659                 return 0;
 660         }
 661
 662         if (dev->dvb) {
 663                 unregister_dvb(dev->dvb);
 664                 kfree(dev->dvb);
 665                 dev->dvb = NULL;
 666         }
 667
 668         return 0;
 669 }
 670
 671 static struct em28xx_ops dvb_ops = {
 672         .id   = EM28XX_DVB,
 673         .name = "Em28xx dvb Extension",
 674         .init = dvb_init,
 675         .fini = dvb_fini,
 676 };
 677
 678 static int __init em28xx_dvb_register(void)
 679 {
 680         return em28xx_register_extension(&dvb_ops);
 681 }
 682
 683 static void __exit em28xx_dvb_unregister(void)
 684 {
 685         em28xx_unregister_extension(&dvb_ops);
 686 }
 687
 688 module_init(em28xx_dvb_register);
 689 module_exit(em28xx_dvb_unregister);