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

   1 /*
   2  DVB device driver for em28xx
   3
   4  (c) 2008-2011 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  (c) 2012 Frank Schäfer <fschaefer.oss@googlemail.com>
  14
  15  Based on cx88-dvb, saa7134-dvb and videobuf-dvb originally written by:
  16         (c) 2004, 2005 Chris Pascoe <c.pascoe@itee.uq.edu.au>
  17         (c) 2004 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
  18
  19  This program is free software; you can redistribute it and/or modify
  20  it under the terms of the GNU General Public License as published by
  21  the Free Software Foundation; either version 2 of the License.
  22  */
  23
  24 #include "em28xx.h"
  25
  26 #include <linux/kernel.h>
  27 #include <linux/slab.h>
  28 #include <linux/usb.h>
  29
  30 #include <media/v4l2-common.h>
  31 #include <dvb_demux.h>
  32 #include <dvb_net.h>
  33 #include <dmxdev.h>
  34 #include <media/tuner.h>
  35 #include "tuner-simple.h"
  36 #include <linux/gpio.h>
  37
  38 #include "lgdt330x.h"
  39 #include "lgdt3305.h"
  40 #include "lgdt3306a.h"
  41 #include "zl10353.h"
  42 #include "s5h1409.h"
  43 #include "mt2060.h"
  44 #include "mt352.h"
  45 #include "mt352_priv.h" /* FIXME */
  46 #include "tda1002x.h"
  47 #include "drx39xyj/drx39xxj.h"
  48 #include "tda18271.h"
  49 #include "s921.h"
  50 #include "drxd.h"
  51 #include "cxd2820r.h"
  52 #include "tda18271c2dd.h"
  53 #include "drxk.h"
  54 #include "tda10071.h"
  55 #include "tda18212.h"
  56 #include "a8293.h"
  57 #include "qt1010.h"
  58 #include "mb86a20s.h"
  59 #include "m88ds3103.h"
  60 #include "ts2020.h"
  61 #include "si2168.h"
  62 #include "si2157.h"
  63 #include "tc90522.h"
  64 #include "qm1d1c0042.h"
  65
  66 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>");
  67 MODULE_LICENSE("GPL");
  68 MODULE_DESCRIPTION(DRIVER_DESC " - digital TV interface");
  69 MODULE_VERSION(EM28XX_VERSION);
  70
  71 static unsigned int debug;
  72 module_param(debug, int, 0644);
  73 MODULE_PARM_DESC(debug, "enable debug messages [dvb]");
  74
  75 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  76
  77 #define dprintk(level, fmt, arg...) do {                                \
  78         if (debug >= level)                                             \
  79                 dev_printk(KERN_DEBUG, &dev->intf->dev,                 \
  80                            "dvb: " fmt, ## arg);                        \
  81 } while (0)
  82
  83 struct em28xx_dvb {
  84         struct dvb_frontend        *fe[2];
  85
  86         /* feed count management */
  87         struct mutex               lock;
  88         int                        nfeeds;
  89
  90         /* general boilerplate stuff */
  91         struct dvb_adapter         adapter;
  92         struct dvb_demux           demux;
  93         struct dmxdev              dmxdev;
  94         struct dmx_frontend        fe_hw;
  95         struct dmx_frontend        fe_mem;
  96         struct dvb_net             net;
  97
  98         /* Due to DRX-K - probably need changes */
  99         int (*gate_ctrl)(struct dvb_frontend *, int);
 100         struct semaphore      pll_mutex;
 101         bool                    dont_attach_fe1;
 102         int                     lna_gpio;
 103         struct i2c_client       *i2c_client_demod;
 104         struct i2c_client       *i2c_client_tuner;
 105         struct i2c_client       *i2c_client_sec;
 106 };
 107
 108 static inline void print_err_status(struct em28xx *dev,
 109                                     int packet, int status)
 110 {
 111         char *errmsg = "Unknown";
 112
 113         switch (status) {
 114         case -ENOENT:
 115                 errmsg = "unlinked synchronuously";
 116                 break;
 117         case -ECONNRESET:
 118                 errmsg = "unlinked asynchronuously";
 119                 break;
 120         case -ENOSR:
 121                 errmsg = "Buffer error (overrun)";
 122                 break;
 123         case -EPIPE:
 124                 errmsg = "Stalled (device not responding)";
 125                 break;
 126         case -EOVERFLOW:
 127                 errmsg = "Babble (bad cable?)";
 128                 break;
 129         case -EPROTO:
 130                 errmsg = "Bit-stuff error (bad cable?)";
 131                 break;
 132         case -EILSEQ:
 133                 errmsg = "CRC/Timeout (could be anything)";
 134                 break;
 135         case -ETIME:
 136                 errmsg = "Device does not respond";
 137                 break;
 138         }
 139         if (packet < 0) {
 140                 dprintk(1, "URB status %d [%s].\n", status, errmsg);
 141         } else {
 142                 dprintk(1, "URB packet %d, status %d [%s].\n",
 143                         packet, status, errmsg);
 144         }
 145 }
 146
 147 static inline int em28xx_dvb_urb_data_copy(struct em28xx *dev, struct urb *urb)
 148 {
 149         int xfer_bulk, num_packets, i;
 150
 151         if (!dev)
 152                 return 0;
 153
 154         if (dev->disconnected)
 155                 return 0;
 156
 157         if (urb->status < 0)
 158                 print_err_status(dev, -1, urb->status);
 159
 160         xfer_bulk = usb_pipebulk(urb->pipe);
 161
 162         if (xfer_bulk) /* bulk */
 163                 num_packets = 1;
 164         else /* isoc */
 165                 num_packets = urb->number_of_packets;
 166
 167         for (i = 0; i < num_packets; i++) {
 168                 if (xfer_bulk) {
 169                         if (urb->status < 0) {
 170                                 print_err_status(dev, i, urb->status);
 171                                 if (urb->status != -EPROTO)
 172                                         continue;
 173                         }
 174                         if (!urb->actual_length)
 175                                 continue;
 176                         dvb_dmx_swfilter(&dev->dvb->demux, urb->transfer_buffer,
 177                                          urb->actual_length);
 178                 } else {
 179                         if (urb->iso_frame_desc[i].status < 0) {
 180                                 print_err_status(dev, i,
 181                                                  urb->iso_frame_desc[i].status);
 182                                 if (urb->iso_frame_desc[i].status != -EPROTO)
 183                                         continue;
 184                         }
 185                         if (!urb->iso_frame_desc[i].actual_length)
 186                                 continue;
 187                         dvb_dmx_swfilter(&dev->dvb->demux,
 188                                          urb->transfer_buffer +
 189                                          urb->iso_frame_desc[i].offset,
 190                                          urb->iso_frame_desc[i].actual_length);
 191                 }
 192         }
 193
 194         return 0;
 195 }
 196
 197 static int em28xx_start_streaming(struct em28xx_dvb *dvb)
 198 {
 199         int rc;
 200         struct em28xx_i2c_bus *i2c_bus = dvb->adapter.priv;
 201         struct em28xx *dev = i2c_bus->dev;
 202         struct usb_device *udev = interface_to_usbdev(dev->intf);
 203         int dvb_max_packet_size, packet_multiplier, dvb_alt;
 204
 205         if (dev->dvb_xfer_bulk) {
 206                 if (!dev->dvb_ep_bulk)
 207                         return -ENODEV;
 208                 dvb_max_packet_size = 512; /* USB 2.0 spec */
 209                 packet_multiplier = EM28XX_DVB_BULK_PACKET_MULTIPLIER;
 210                 dvb_alt = 0;
 211         } else { /* isoc */
 212                 if (!dev->dvb_ep_isoc)
 213                         return -ENODEV;
 214                 dvb_max_packet_size = dev->dvb_max_pkt_size_isoc;
 215                 if (dvb_max_packet_size < 0)
 216                         return dvb_max_packet_size;
 217                 packet_multiplier = EM28XX_DVB_NUM_ISOC_PACKETS;
 218                 dvb_alt = dev->dvb_alt_isoc;
 219         }
 220
 221         usb_set_interface(udev, dev->ifnum, dvb_alt);
 222         rc = em28xx_set_mode(dev, EM28XX_DIGITAL_MODE);
 223         if (rc < 0)
 224                 return rc;
 225
 226         dprintk(1, "Using %d buffers each with %d x %d bytes, alternate %d\n",
 227                 EM28XX_DVB_NUM_BUFS,
 228                 packet_multiplier,
 229                 dvb_max_packet_size, dvb_alt);
 230
 231         return em28xx_init_usb_xfer(dev, EM28XX_DIGITAL_MODE,
 232                                     dev->dvb_xfer_bulk,
 233                                     EM28XX_DVB_NUM_BUFS,
 234                                     dvb_max_packet_size,
 235                                     packet_multiplier,
 236                                     em28xx_dvb_urb_data_copy);
 237 }
 238
 239 static int em28xx_stop_streaming(struct em28xx_dvb *dvb)
 240 {
 241         struct em28xx_i2c_bus *i2c_bus = dvb->adapter.priv;
 242         struct em28xx *dev = i2c_bus->dev;
 243
 244         em28xx_stop_urbs(dev);
 245
 246         return 0;
 247 }
 248
 249 static int em28xx_start_feed(struct dvb_demux_feed *feed)
 250 {
 251         struct dvb_demux *demux  = feed->demux;
 252         struct em28xx_dvb *dvb = demux->priv;
 253         int rc, ret;
 254
 255         if (!demux->dmx.frontend)
 256                 return -EINVAL;
 257
 258         mutex_lock(&dvb->lock);
 259         dvb->nfeeds++;
 260         rc = dvb->nfeeds;
 261
 262         if (dvb->nfeeds == 1) {
 263                 ret = em28xx_start_streaming(dvb);
 264                 if (ret < 0)
 265                         rc = ret;
 266         }
 267
 268         mutex_unlock(&dvb->lock);
 269         return rc;
 270 }
 271
 272 static int em28xx_stop_feed(struct dvb_demux_feed *feed)
 273 {
 274         struct dvb_demux *demux  = feed->demux;
 275         struct em28xx_dvb *dvb = demux->priv;
 276         int err = 0;
 277
 278         mutex_lock(&dvb->lock);
 279         dvb->nfeeds--;
 280
 281         if (0 == dvb->nfeeds)
 282                 err = em28xx_stop_streaming(dvb);
 283
 284         mutex_unlock(&dvb->lock);
 285         return err;
 286 }
 287
 288
 289 /* ------------------------------------------------------------------ */
 290 static int em28xx_dvb_bus_ctrl(struct dvb_frontend *fe, int acquire)
 291 {
 292         struct em28xx_i2c_bus *i2c_bus = fe->dvb->priv;
 293         struct em28xx *dev = i2c_bus->dev;
 294
 295         if (acquire)
 296                 return em28xx_set_mode(dev, EM28XX_DIGITAL_MODE);
 297         else
 298                 return em28xx_set_mode(dev, EM28XX_SUSPEND);
 299 }
 300
 301 /* ------------------------------------------------------------------ */
 302
 303 static struct lgdt330x_config em2880_lgdt3303_dev = {
 304         .demod_address = 0x0e,
 305         .demod_chip = LGDT3303,
 306 };
 307
 308 static struct lgdt3305_config em2870_lgdt3304_dev = {
 309         .i2c_addr           = 0x0e,
 310         .demod_chip         = LGDT3304,
 311         .spectral_inversion = 1,
 312         .deny_i2c_rptr      = 1,
 313         .mpeg_mode          = LGDT3305_MPEG_PARALLEL,
 314         .tpclk_edge         = LGDT3305_TPCLK_FALLING_EDGE,
 315         .tpvalid_polarity   = LGDT3305_TP_VALID_HIGH,
 316         .vsb_if_khz         = 3250,
 317         .qam_if_khz         = 4000,
 318 };
 319
 320 static struct lgdt3305_config em2874_lgdt3305_dev = {
 321         .i2c_addr           = 0x0e,
 322         .demod_chip         = LGDT3305,
 323         .spectral_inversion = 1,
 324         .deny_i2c_rptr      = 0,
 325         .mpeg_mode          = LGDT3305_MPEG_SERIAL,
 326         .tpclk_edge         = LGDT3305_TPCLK_FALLING_EDGE,
 327         .tpvalid_polarity   = LGDT3305_TP_VALID_HIGH,
 328         .vsb_if_khz         = 3250,
 329         .qam_if_khz         = 4000,
 330 };
 331
 332 static struct lgdt3305_config em2874_lgdt3305_nogate_dev = {
 333         .i2c_addr           = 0x0e,
 334         .demod_chip         = LGDT3305,
 335         .spectral_inversion = 1,
 336         .deny_i2c_rptr      = 1,
 337         .mpeg_mode          = LGDT3305_MPEG_SERIAL,
 338         .tpclk_edge         = LGDT3305_TPCLK_FALLING_EDGE,
 339         .tpvalid_polarity   = LGDT3305_TP_VALID_HIGH,
 340         .vsb_if_khz         = 3600,
 341         .qam_if_khz         = 3600,
 342 };
 343
 344 static struct s921_config sharp_isdbt = {
 345         .demod_address = 0x30 >> 1
 346 };
 347
 348 static struct zl10353_config em28xx_zl10353_with_xc3028 = {
 349         .demod_address = (0x1e >> 1),
 350         .no_tuner = 1,
 351         .parallel_ts = 1,
 352         .if2 = 45600,
 353 };
 354
 355 static struct s5h1409_config em28xx_s5h1409_with_xc3028 = {
 356         .demod_address = 0x32 >> 1,
 357         .output_mode   = S5H1409_PARALLEL_OUTPUT,
 358         .gpio          = S5H1409_GPIO_OFF,
 359         .inversion     = S5H1409_INVERSION_OFF,
 360         .status_mode   = S5H1409_DEMODLOCKING,
 361         .mpeg_timing   = S5H1409_MPEGTIMING_CONTINOUS_NONINVERTING_CLOCK
 362 };
 363
 364 static struct tda18271_std_map kworld_a340_std_map = {
 365         .atsc_6   = { .if_freq = 3250, .agc_mode = 3, .std = 0,
 366                       .if_lvl = 1, .rfagc_top = 0x37, },
 367         .qam_6    = { .if_freq = 4000, .agc_mode = 3, .std = 1,
 368                       .if_lvl = 1, .rfagc_top = 0x37, },
 369 };
 370
 371 static struct tda18271_config kworld_a340_config = {
 372         .std_map           = &kworld_a340_std_map,
 373 };
 374
 375 static struct tda18271_config kworld_ub435q_v2_config = {
 376         .std_map        = &kworld_a340_std_map,
 377         .gate           = TDA18271_GATE_DIGITAL,
 378 };
 379
 380 static struct tda18212_config kworld_ub435q_v3_config = {
 381         .if_atsc_vsb    = 3600,
 382         .if_atsc_qam    = 3600,
 383 };
 384
 385 static struct zl10353_config em28xx_zl10353_xc3028_no_i2c_gate = {
 386         .demod_address = (0x1e >> 1),
 387         .no_tuner = 1,
 388         .disable_i2c_gate_ctrl = 1,
 389         .parallel_ts = 1,
 390         .if2 = 45600,
 391 };
 392
 393 static struct drxd_config em28xx_drxd = {
 394         .demod_address = 0x70,
 395         .demod_revision = 0xa2,
 396         .pll_type = DRXD_PLL_NONE,
 397         .clock = 12000,
 398         .insert_rs_byte = 1,
 399         .IF = 42800000,
 400         .disable_i2c_gate_ctrl = 1,
 401 };
 402
 403 static struct drxk_config terratec_h5_drxk = {
 404         .adr = 0x29,
 405         .single_master = 1,
 406         .no_i2c_bridge = 1,
 407         .microcode_name = "dvb-usb-terratec-h5-drxk.fw",
 408         .qam_demod_parameter_count = 2,
 409 };
 410
 411 static struct drxk_config hauppauge_930c_drxk = {
 412         .adr = 0x29,
 413         .single_master = 1,
 414         .no_i2c_bridge = 1,
 415         .microcode_name = "dvb-usb-hauppauge-hvr930c-drxk.fw",
 416         .chunk_size = 56,
 417         .qam_demod_parameter_count = 2,
 418 };
 419
 420 static struct drxk_config terratec_htc_stick_drxk = {
 421         .adr = 0x29,
 422         .single_master = 1,
 423         .no_i2c_bridge = 1,
 424         .microcode_name = "dvb-usb-terratec-htc-stick-drxk.fw",
 425         .chunk_size = 54,
 426         .qam_demod_parameter_count = 2,
 427         /* Required for the antenna_gpio to disable LNA. */
 428         .antenna_dvbt = true,
 429         /* The windows driver uses the same. This will disable LNA. */
 430         .antenna_gpio = 0x6,
 431 };
 432
 433 static struct drxk_config maxmedia_ub425_tc_drxk = {
 434         .adr = 0x29,
 435         .single_master = 1,
 436         .no_i2c_bridge = 1,
 437         .microcode_name = "dvb-demod-drxk-01.fw",
 438         .chunk_size = 62,
 439         .qam_demod_parameter_count = 2,
 440 };
 441
 442 static struct drxk_config pctv_520e_drxk = {
 443         .adr = 0x29,
 444         .single_master = 1,
 445         .microcode_name = "dvb-demod-drxk-pctv.fw",
 446         .qam_demod_parameter_count = 2,
 447         .chunk_size = 58,
 448         .antenna_dvbt = true, /* disable LNA */
 449         .antenna_gpio = (1 << 2), /* disable LNA */
 450 };
 451
 452 static int drxk_gate_ctrl(struct dvb_frontend *fe, int enable)
 453 {
 454         struct em28xx_dvb *dvb = fe->sec_priv;
 455         int status;
 456
 457         if (!dvb)
 458                 return -EINVAL;
 459
 460         if (enable) {
 461                 down(&dvb->pll_mutex);
 462                 status = dvb->gate_ctrl(fe, 1);
 463         } else {
 464                 status = dvb->gate_ctrl(fe, 0);
 465                 up(&dvb->pll_mutex);
 466         }
 467         return status;
 468 }
 469
 470 static void hauppauge_hvr930c_init(struct em28xx *dev)
 471 {
 472         int i;
 473
 474         struct em28xx_reg_seq hauppauge_hvr930c_init[] = {
 475                 {EM2874_R80_GPIO_P0_CTRL,       0xff,   0xff,   0x65},
 476                 {EM2874_R80_GPIO_P0_CTRL,       0xfb,   0xff,   0x32},
 477                 {EM2874_R80_GPIO_P0_CTRL,       0xff,   0xff,   0xb8},
 478                 {       -1,                     -1,     -1,     -1},
 479         };
 480         struct em28xx_reg_seq hauppauge_hvr930c_end[] = {
 481                 {EM2874_R80_GPIO_P0_CTRL,       0xef,   0xff,   0x01},
 482                 {EM2874_R80_GPIO_P0_CTRL,       0xaf,   0xff,   0x65},
 483                 {EM2874_R80_GPIO_P0_CTRL,       0xef,   0xff,   0x76},
 484                 {EM2874_R80_GPIO_P0_CTRL,       0xef,   0xff,   0x01},
 485                 {EM2874_R80_GPIO_P0_CTRL,       0xcf,   0xff,   0x0b},
 486                 {EM2874_R80_GPIO_P0_CTRL,       0xef,   0xff,   0x40},
 487
 488                 {EM2874_R80_GPIO_P0_CTRL,       0xcf,   0xff,   0x65},
 489                 {EM2874_R80_GPIO_P0_CTRL,       0xef,   0xff,   0x65},
 490                 {EM2874_R80_GPIO_P0_CTRL,       0xcf,   0xff,   0x0b},
 491                 {EM2874_R80_GPIO_P0_CTRL,       0xef,   0xff,   0x65},
 492
 493                 {       -1,                     -1,     -1,     -1},
 494         };
 495
 496         struct {
 497                 unsigned char r[4];
 498                 int len;
 499         } regs[] = {
 500                 {{ 0x06, 0x02, 0x00, 0x31 }, 4},
 501                 {{ 0x01, 0x02 }, 2},
 502                 {{ 0x01, 0x02, 0x00, 0xc6 }, 4},
 503                 {{ 0x01, 0x00 }, 2},
 504                 {{ 0x01, 0x00, 0xff, 0xaf }, 4},
 505                 {{ 0x01, 0x00, 0x03, 0xa0 }, 4},
 506                 {{ 0x01, 0x00 }, 2},
 507                 {{ 0x01, 0x00, 0x73, 0xaf }, 4},
 508                 {{ 0x04, 0x00 }, 2},
 509                 {{ 0x00, 0x04 }, 2},
 510                 {{ 0x00, 0x04, 0x00, 0x0a }, 4},
 511                 {{ 0x04, 0x14 }, 2},
 512                 {{ 0x04, 0x14, 0x00, 0x00 }, 4},
 513         };
 514
 515         em28xx_gpio_set(dev, hauppauge_hvr930c_init);
 516         em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x40);
 517         msleep(10);
 518         em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x44);
 519         msleep(10);
 520
 521         dev->i2c_client[dev->def_i2c_bus].addr = 0x82 >> 1;
 522
 523         for (i = 0; i < ARRAY_SIZE(regs); i++)
 524                 i2c_master_send(&dev->i2c_client[dev->def_i2c_bus], regs[i].r, regs[i].len);
 525         em28xx_gpio_set(dev, hauppauge_hvr930c_end);
 526
 527         msleep(100);
 528
 529         em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x44);
 530         msleep(30);
 531
 532         em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x45);
 533         msleep(10);
 534
 535 }
 536
 537 static void terratec_h5_init(struct em28xx *dev)
 538 {
 539         int i;
 540         struct em28xx_reg_seq terratec_h5_init[] = {
 541                 {EM2820_R08_GPIO_CTRL,          0xff,   0xff,   10},
 542                 {EM2874_R80_GPIO_P0_CTRL,       0xf6,   0xff,   100},
 543                 {EM2874_R80_GPIO_P0_CTRL,       0xf2,   0xff,   50},
 544                 {EM2874_R80_GPIO_P0_CTRL,       0xf6,   0xff,   100},
 545                 {       -1,                     -1,     -1,     -1},
 546         };
 547         struct em28xx_reg_seq terratec_h5_end[] = {
 548                 {EM2874_R80_GPIO_P0_CTRL,       0xe6,   0xff,   100},
 549                 {EM2874_R80_GPIO_P0_CTRL,       0xa6,   0xff,   50},
 550                 {EM2874_R80_GPIO_P0_CTRL,       0xe6,   0xff,   100},
 551                 {       -1,                     -1,     -1,     -1},
 552         };
 553         struct {
 554                 unsigned char r[4];
 555                 int len;
 556         } regs[] = {
 557                 {{ 0x06, 0x02, 0x00, 0x31 }, 4},
 558                 {{ 0x01, 0x02 }, 2},
 559                 {{ 0x01, 0x02, 0x00, 0xc6 }, 4},
 560                 {{ 0x01, 0x00 }, 2},
 561                 {{ 0x01, 0x00, 0xff, 0xaf }, 4},
 562                 {{ 0x01, 0x00, 0x03, 0xa0 }, 4},
 563                 {{ 0x01, 0x00 }, 2},
 564                 {{ 0x01, 0x00, 0x73, 0xaf }, 4},
 565                 {{ 0x04, 0x00 }, 2},
 566                 {{ 0x00, 0x04 }, 2},
 567                 {{ 0x00, 0x04, 0x00, 0x0a }, 4},
 568                 {{ 0x04, 0x14 }, 2},
 569                 {{ 0x04, 0x14, 0x00, 0x00 }, 4},
 570         };
 571
 572         em28xx_gpio_set(dev, terratec_h5_init);
 573         em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x40);
 574         msleep(10);
 575         em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x45);
 576         msleep(10);
 577
 578         dev->i2c_client[dev->def_i2c_bus].addr = 0x82 >> 1;
 579
 580         for (i = 0; i < ARRAY_SIZE(regs); i++)
 581                 i2c_master_send(&dev->i2c_client[dev->def_i2c_bus], regs[i].r, regs[i].len);
 582         em28xx_gpio_set(dev, terratec_h5_end);
 583 };
 584
 585 static void terratec_htc_stick_init(struct em28xx *dev)
 586 {
 587         int i;
 588
 589         /*
 590          * GPIO configuration:
 591          * 0xff: unknown (does not affect DVB-T).
 592          * 0xf6: DRX-K (demodulator).
 593          * 0xe6: unknown (does not affect DVB-T).
 594          * 0xb6: unknown (does not affect DVB-T).
 595          */
 596         struct em28xx_reg_seq terratec_htc_stick_init[] = {
 597                 {EM2820_R08_GPIO_CTRL,          0xff,   0xff,   10},
 598                 {EM2874_R80_GPIO_P0_CTRL,       0xf6,   0xff,   100},
 599                 {EM2874_R80_GPIO_P0_CTRL,       0xe6,   0xff,   50},
 600                 {EM2874_R80_GPIO_P0_CTRL,       0xf6,   0xff,   100},
 601                 {       -1,                     -1,     -1,     -1},
 602         };
 603         struct em28xx_reg_seq terratec_htc_stick_end[] = {
 604                 {EM2874_R80_GPIO_P0_CTRL,       0xb6,   0xff,   100},
 605                 {EM2874_R80_GPIO_P0_CTRL,       0xf6,   0xff,   50},
 606                 {       -1,                     -1,     -1,     -1},
 607         };
 608
 609         /*
 610          * Init the analog decoder (not yet supported), but
 611          * it's probably still a good idea.
 612          */
 613         struct {
 614                 unsigned char r[4];
 615                 int len;
 616         } regs[] = {
 617                 {{ 0x06, 0x02, 0x00, 0x31 }, 4},
 618                 {{ 0x01, 0x02 }, 2},
 619                 {{ 0x01, 0x02, 0x00, 0xc6 }, 4},
 620                 {{ 0x01, 0x00 }, 2},
 621                 {{ 0x01, 0x00, 0xff, 0xaf }, 4},
 622         };
 623
 624         em28xx_gpio_set(dev, terratec_htc_stick_init);
 625
 626         em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x40);
 627         msleep(10);
 628         em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x44);
 629         msleep(10);
 630
 631         dev->i2c_client[dev->def_i2c_bus].addr = 0x82 >> 1;
 632
 633         for (i = 0; i < ARRAY_SIZE(regs); i++)
 634                 i2c_master_send(&dev->i2c_client[dev->def_i2c_bus], regs[i].r, regs[i].len);
 635
 636         em28xx_gpio_set(dev, terratec_htc_stick_end);
 637 };
 638
 639 static void terratec_htc_usb_xs_init(struct em28xx *dev)
 640 {
 641         int i;
 642
 643         struct em28xx_reg_seq terratec_htc_usb_xs_init[] = {
 644                 {EM2820_R08_GPIO_CTRL,          0xff,   0xff,   10},
 645                 {EM2874_R80_GPIO_P0_CTRL,       0xb2,   0xff,   100},
 646                 {EM2874_R80_GPIO_P0_CTRL,       0xb2,   0xff,   50},
 647                 {EM2874_R80_GPIO_P0_CTRL,       0xb6,   0xff,   100},
 648                 {       -1,                     -1,     -1,     -1},
 649         };
 650         struct em28xx_reg_seq terratec_htc_usb_xs_end[] = {
 651                 {EM2874_R80_GPIO_P0_CTRL,       0xa6,   0xff,   100},
 652                 {EM2874_R80_GPIO_P0_CTRL,       0xa6,   0xff,   50},
 653                 {EM2874_R80_GPIO_P0_CTRL,       0xe6,   0xff,   100},
 654                 {       -1,                     -1,     -1,     -1},
 655         };
 656
 657         /*
 658          * Init the analog decoder (not yet supported), but
 659          * it's probably still a good idea.
 660          */
 661         struct {
 662                 unsigned char r[4];
 663                 int len;
 664         } regs[] = {
 665                 {{ 0x06, 0x02, 0x00, 0x31 }, 4},
 666                 {{ 0x01, 0x02 }, 2},
 667                 {{ 0x01, 0x02, 0x00, 0xc6 }, 4},
 668                 {{ 0x01, 0x00 }, 2},
 669                 {{ 0x01, 0x00, 0xff, 0xaf }, 4},
 670                 {{ 0x01, 0x00, 0x03, 0xa0 }, 4},
 671                 {{ 0x01, 0x00 }, 2},
 672                 {{ 0x01, 0x00, 0x73, 0xaf }, 4},
 673                 {{ 0x04, 0x00 }, 2},
 674                 {{ 0x00, 0x04 }, 2},
 675                 {{ 0x00, 0x04, 0x00, 0x0a }, 4},
 676                 {{ 0x04, 0x14 }, 2},
 677                 {{ 0x04, 0x14, 0x00, 0x00 }, 4},
 678         };
 679
 680         em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x40);
 681
 682         em28xx_gpio_set(dev, terratec_htc_usb_xs_init);
 683
 684         em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x40);
 685         msleep(10);
 686         em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x44);
 687         msleep(10);
 688
 689         dev->i2c_client[dev->def_i2c_bus].addr = 0x82 >> 1;
 690
 691         for (i = 0; i < ARRAY_SIZE(regs); i++)
 692                 i2c_master_send(&dev->i2c_client[dev->def_i2c_bus], regs[i].r, regs[i].len);
 693
 694         em28xx_gpio_set(dev, terratec_htc_usb_xs_end);
 695 };
 696
 697 static void pctv_520e_init(struct em28xx *dev)
 698 {
 699         /*
 700          * Init AVF4910B analog decoder. Looks like I2C traffic to
 701          * digital demodulator and tuner are routed via AVF4910B.
 702          */
 703         int i;
 704         struct {
 705                 unsigned char r[4];
 706                 int len;
 707         } regs[] = {
 708                 {{ 0x06, 0x02, 0x00, 0x31 }, 4},
 709                 {{ 0x01, 0x02 }, 2},
 710                 {{ 0x01, 0x02, 0x00, 0xc6 }, 4},
 711                 {{ 0x01, 0x00 }, 2},
 712                 {{ 0x01, 0x00, 0xff, 0xaf }, 4},
 713                 {{ 0x01, 0x00, 0x03, 0xa0 }, 4},
 714                 {{ 0x01, 0x00 }, 2},
 715                 {{ 0x01, 0x00, 0x73, 0xaf }, 4},
 716         };
 717
 718         dev->i2c_client[dev->def_i2c_bus].addr = 0x82 >> 1; /* 0x41 */
 719
 720         for (i = 0; i < ARRAY_SIZE(regs); i++)
 721                 i2c_master_send(&dev->i2c_client[dev->def_i2c_bus], regs[i].r, regs[i].len);
 722 };
 723
 724 static int em28xx_pctv_290e_set_lna(struct dvb_frontend *fe)
 725 {
 726         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 727         struct em28xx_i2c_bus *i2c_bus = fe->dvb->priv;
 728         struct em28xx *dev = i2c_bus->dev;
 729 #ifdef CONFIG_GPIOLIB
 730         struct em28xx_dvb *dvb = dev->dvb;
 731         int ret;
 732         unsigned long flags;
 733
 734         if (c->lna == 1)
 735                 flags = GPIOF_OUT_INIT_HIGH; /* enable LNA */
 736         else
 737                 flags = GPIOF_OUT_INIT_LOW; /* disable LNA */
 738
 739         ret = gpio_request_one(dvb->lna_gpio, flags, NULL);
 740         if (ret)
 741                 dev_err(&dev->intf->dev, "gpio request failed %d\n", ret);
 742         else
 743                 gpio_free(dvb->lna_gpio);
 744
 745         return ret;
 746 #else
 747         dev_warn(&dev->intf->dev, "%s: LNA control is disabled (lna=%u)\n",
 748                  KBUILD_MODNAME, c->lna);
 749         return 0;
 750 #endif
 751 }
 752
 753 static int em28xx_pctv_292e_set_lna(struct dvb_frontend *fe)
 754 {
 755         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 756         struct em28xx_i2c_bus *i2c_bus = fe->dvb->priv;
 757         struct em28xx *dev = i2c_bus->dev;
 758         u8 lna;
 759
 760         if (c->lna == 1)
 761                 lna = 0x01;
 762         else
 763                 lna = 0x00;
 764
 765         return em28xx_write_reg_bits(dev, EM2874_R80_GPIO_P0_CTRL, lna, 0x01);
 766 }
 767
 768 static int em28xx_mt352_terratec_xs_init(struct dvb_frontend *fe)
 769 {
 770         /* Values extracted from a USB trace of the Terratec Windows driver */
 771         static u8 clock_config[]   = { CLOCK_CTL,  0x38, 0x2c };
 772         static u8 reset[]          = { RESET,      0x80 };
 773         static u8 adc_ctl_1_cfg[]  = { ADC_CTL_1,  0x40 };
 774         static u8 agc_cfg[]        = { AGC_TARGET, 0x28, 0xa0 };
 775         static u8 input_freq_cfg[] = { INPUT_FREQ_1, 0x31, 0xb8 };
 776         static u8 rs_err_cfg[]     = { RS_ERR_PER_1, 0x00, 0x4d };
 777         static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
 778         static u8 trl_nom_cfg[]    = { TRL_NOMINAL_RATE_1, 0x64, 0x00 };
 779         static u8 tps_given_cfg[]  = { TPS_GIVEN_1, 0x40, 0x80, 0x50 };
 780         static u8 tuner_go[]       = { TUNER_GO, 0x01};
 781
 782         mt352_write(fe, clock_config,   sizeof(clock_config));
 783         udelay(200);
 784         mt352_write(fe, reset,          sizeof(reset));
 785         mt352_write(fe, adc_ctl_1_cfg,  sizeof(adc_ctl_1_cfg));
 786         mt352_write(fe, agc_cfg,        sizeof(agc_cfg));
 787         mt352_write(fe, input_freq_cfg, sizeof(input_freq_cfg));
 788         mt352_write(fe, rs_err_cfg,     sizeof(rs_err_cfg));
 789         mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
 790         mt352_write(fe, trl_nom_cfg,    sizeof(trl_nom_cfg));
 791         mt352_write(fe, tps_given_cfg,  sizeof(tps_given_cfg));
 792         mt352_write(fe, tuner_go,       sizeof(tuner_go));
 793         return 0;
 794 }
 795
 796 static void px_bcud_init(struct em28xx *dev)
 797 {
 798         int i;
 799         struct {
 800                 unsigned char r[4];
 801                 int len;
 802         } regs1[] = {
 803                 {{ 0x0e, 0x77 }, 2},
 804                 {{ 0x0f, 0x77 }, 2},
 805                 {{ 0x03, 0x90 }, 2},
 806         }, regs2[] = {
 807                 {{ 0x07, 0x01 }, 2},
 808                 {{ 0x08, 0x10 }, 2},
 809                 {{ 0x13, 0x00 }, 2},
 810                 {{ 0x17, 0x00 }, 2},
 811                 {{ 0x03, 0x01 }, 2},
 812                 {{ 0x10, 0xb1 }, 2},
 813                 {{ 0x11, 0x40 }, 2},
 814                 {{ 0x85, 0x7a }, 2},
 815                 {{ 0x87, 0x04 }, 2},
 816         };
 817         static struct em28xx_reg_seq gpio[] = {
 818                 {EM28XX_R06_I2C_CLK,            0x40,   0xff,   300},
 819                 {EM2874_R80_GPIO_P0_CTRL,       0xfd,   0xff,   60},
 820                 {EM28XX_R15_RGAIN,              0x20,   0xff,   0},
 821                 {EM28XX_R16_GGAIN,              0x20,   0xff,   0},
 822                 {EM28XX_R17_BGAIN,              0x20,   0xff,   0},
 823                 {EM28XX_R18_ROFFSET,            0x00,   0xff,   0},
 824                 {EM28XX_R19_GOFFSET,            0x00,   0xff,   0},
 825                 {EM28XX_R1A_BOFFSET,            0x00,   0xff,   0},
 826                 {EM28XX_R23_UOFFSET,            0x00,   0xff,   0},
 827                 {EM28XX_R24_VOFFSET,            0x00,   0xff,   0},
 828                 {EM28XX_R26_COMPR,              0x00,   0xff,   0},
 829                 {0x13,                          0x08,   0xff,   0},
 830                 {EM28XX_R12_VINENABLE,          0x27,   0xff,   0},
 831                 {EM28XX_R0C_USBSUSP,            0x10,   0xff,   0},
 832                 {EM28XX_R27_OUTFMT,             0x00,   0xff,   0},
 833                 {EM28XX_R10_VINMODE,            0x00,   0xff,   0},
 834                 {EM28XX_R11_VINCTRL,            0x11,   0xff,   0},
 835                 {EM2874_R50_IR_CONFIG,          0x01,   0xff,   0},
 836                 {EM2874_R5F_TS_ENABLE,          0x80,   0xff,   0},
 837                 {EM28XX_R06_I2C_CLK,            0x46,   0xff,   0},
 838         };
 839         em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x46);
 840         /* sleeping ISDB-T */
 841         dev->dvb->i2c_client_demod->addr = 0x14;
 842         for (i = 0; i < ARRAY_SIZE(regs1); i++)
 843                 i2c_master_send(dev->dvb->i2c_client_demod, regs1[i].r,
 844                                 regs1[i].len);
 845         /* sleeping ISDB-S */
 846         dev->dvb->i2c_client_demod->addr = 0x15;
 847         for (i = 0; i < ARRAY_SIZE(regs2); i++)
 848                 i2c_master_send(dev->dvb->i2c_client_demod, regs2[i].r,
 849                                 regs2[i].len);
 850         for (i = 0; i < ARRAY_SIZE(gpio); i++) {
 851                 em28xx_write_reg_bits(dev, gpio[i].reg, gpio[i].val,
 852                                       gpio[i].mask);
 853                 if (gpio[i].sleep > 0)
 854                         msleep(gpio[i].sleep);
 855         }
 856 };
 857
 858 static struct mt352_config terratec_xs_mt352_cfg = {
 859         .demod_address = (0x1e >> 1),
 860         .no_tuner = 1,
 861         .if2 = 45600,
 862         .demod_init = em28xx_mt352_terratec_xs_init,
 863 };
 864
 865 static struct tda10023_config em28xx_tda10023_config = {
 866         .demod_address = 0x0c,
 867         .invert = 1,
 868 };
 869
 870 static struct cxd2820r_config em28xx_cxd2820r_config = {
 871         .i2c_address = (0xd8 >> 1),
 872         .ts_mode = CXD2820R_TS_SERIAL,
 873 };
 874
 875 static struct tda18271_config em28xx_cxd2820r_tda18271_config = {
 876         .output_opt = TDA18271_OUTPUT_LT_OFF,
 877         .gate = TDA18271_GATE_DIGITAL,
 878 };
 879
 880 static struct zl10353_config em28xx_zl10353_no_i2c_gate_dev = {
 881         .demod_address = (0x1e >> 1),
 882         .disable_i2c_gate_ctrl = 1,
 883         .no_tuner = 1,
 884         .parallel_ts = 1,
 885 };
 886
 887 static struct mt2060_config em28xx_mt2060_config = {
 888         .i2c_address = 0x60,
 889 };
 890
 891 static struct qt1010_config em28xx_qt1010_config = {
 892         .i2c_address = 0x62
 893 };
 894
 895 static const struct mb86a20s_config c3tech_duo_mb86a20s_config = {
 896         .demod_address = 0x10,
 897         .is_serial = true,
 898 };
 899
 900 static struct tda18271_std_map mb86a20s_tda18271_config = {
 901         .dvbt_6   = { .if_freq = 4000, .agc_mode = 3, .std = 4,
 902                       .if_lvl = 1, .rfagc_top = 0x37, },
 903 };
 904
 905 static struct tda18271_config c3tech_duo_tda18271_config = {
 906         .std_map = &mb86a20s_tda18271_config,
 907         .gate    = TDA18271_GATE_DIGITAL,
 908         .small_i2c = TDA18271_03_BYTE_CHUNK_INIT,
 909 };
 910
 911 static struct tda18271_std_map drx_j_std_map = {
 912         .atsc_6   = { .if_freq = 5000, .agc_mode = 3, .std = 0, .if_lvl = 1,
 913                       .rfagc_top = 0x37, },
 914         .qam_6    = { .if_freq = 5380, .agc_mode = 3, .std = 3, .if_lvl = 1,
 915                       .rfagc_top = 0x37, },
 916 };
 917
 918 static struct tda18271_config pinnacle_80e_dvb_config = {
 919         .std_map = &drx_j_std_map,
 920         .gate    = TDA18271_GATE_DIGITAL,
 921         .role    = TDA18271_MASTER,
 922 };
 923
 924 static struct lgdt3306a_config hauppauge_01595_lgdt3306a_config = {
 925         .qam_if_khz         = 4000,
 926         .vsb_if_khz         = 3250,
 927         .spectral_inversion = 0,
 928         .deny_i2c_rptr      = 0,
 929         .mpeg_mode          = LGDT3306A_MPEG_SERIAL,
 930         .tpclk_edge         = LGDT3306A_TPCLK_RISING_EDGE,
 931         .tpvalid_polarity   = LGDT3306A_TP_VALID_HIGH,
 932         .xtalMHz            = 25,
 933 };
 934
 935 /* ------------------------------------------------------------------ */
 936
 937 static int em28xx_attach_xc3028(u8 addr, struct em28xx *dev)
 938 {
 939         struct dvb_frontend *fe;
 940         struct xc2028_config cfg;
 941         struct xc2028_ctrl ctl;
 942
 943         memset(&cfg, 0, sizeof(cfg));
 944         cfg.i2c_adap  = &dev->i2c_adap[dev->def_i2c_bus];
 945         cfg.i2c_addr  = addr;
 946
 947         memset(&ctl, 0, sizeof(ctl));
 948         em28xx_setup_xc3028(dev, &ctl);
 949         cfg.ctrl  = &ctl;
 950
 951         if (!dev->dvb->fe[0]) {
 952                 dev_err(&dev->intf->dev,
 953                         "dvb frontend not attached. Can't attach xc3028\n");
 954                 return -EINVAL;
 955         }
 956
 957         fe = dvb_attach(xc2028_attach, dev->dvb->fe[0], &cfg);
 958         if (!fe) {
 959                 dev_err(&dev->intf->dev, "xc3028 attach failed\n");
 960                 dvb_frontend_detach(dev->dvb->fe[0]);
 961                 dev->dvb->fe[0] = NULL;
 962                 return -EINVAL;
 963         }
 964
 965         dev_info(&dev->intf->dev, "xc3028 attached\n");
 966
 967         return 0;
 968 }
 969
 970 /* ------------------------------------------------------------------ */
 971
 972 static int em28xx_register_dvb(struct em28xx_dvb *dvb, struct module *module,
 973                                struct em28xx *dev, struct device *device)
 974 {
 975         int result;
 976         bool create_rf_connector = false;
 977
 978         mutex_init(&dvb->lock);
 979
 980         /* register adapter */
 981         result = dvb_register_adapter(&dvb->adapter,
 982                                       dev_name(&dev->intf->dev), module,
 983                                       device, adapter_nr);
 984         if (result < 0) {
 985                 dev_warn(&dev->intf->dev,
 986                          "dvb_register_adapter failed (errno = %d)\n",
 987                          result);
 988                 goto fail_adapter;
 989         }
 990 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
 991         dvb->adapter.mdev = dev->media_dev;
 992 #endif
 993
 994         /* Ensure all frontends negotiate bus access */
 995         dvb->fe[0]->ops.ts_bus_ctrl = em28xx_dvb_bus_ctrl;
 996         if (dvb->fe[1])
 997                 dvb->fe[1]->ops.ts_bus_ctrl = em28xx_dvb_bus_ctrl;
 998
 999         dvb->adapter.priv = &dev->i2c_bus[dev->def_i2c_bus];
1000
1001         /* register frontend */
1002         result = dvb_register_frontend(&dvb->adapter, dvb->fe[0]);
1003         if (result < 0) {
1004                 dev_warn(&dev->intf->dev,
1005                          "dvb_register_frontend failed (errno = %d)\n",
1006                          result);
1007                 goto fail_frontend0;
1008         }
1009
1010         /* register 2nd frontend */
1011         if (dvb->fe[1]) {
1012                 result = dvb_register_frontend(&dvb->adapter, dvb->fe[1]);
1013                 if (result < 0) {
1014                         dev_warn(&dev->intf->dev,
1015                                  "2nd dvb_register_frontend failed (errno = %d)\n",
1016                                  result);
1017                         goto fail_frontend1;
1018                 }
1019         }
1020
1021         /* register demux stuff */
1022         dvb->demux.dmx.capabilities =
1023                 DMX_TS_FILTERING | DMX_SECTION_FILTERING |
1024                 DMX_MEMORY_BASED_FILTERING;
1025         dvb->demux.priv       = dvb;
1026         dvb->demux.filternum  = 256;
1027         dvb->demux.feednum    = 256;
1028         dvb->demux.start_feed = em28xx_start_feed;
1029         dvb->demux.stop_feed  = em28xx_stop_feed;
1030
1031         result = dvb_dmx_init(&dvb->demux);
1032         if (result < 0) {
1033                 dev_warn(&dev->intf->dev,
1034                          "dvb_dmx_init failed (errno = %d)\n",
1035                          result);
1036                 goto fail_dmx;
1037         }
1038
1039         dvb->dmxdev.filternum    = 256;
1040         dvb->dmxdev.demux        = &dvb->demux.dmx;
1041         dvb->dmxdev.capabilities = 0;
1042         result = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter);
1043         if (result < 0) {
1044                 dev_warn(&dev->intf->dev,
1045                          "dvb_dmxdev_init failed (errno = %d)\n",
1046                          result);
1047                 goto fail_dmxdev;
1048         }
1049
1050         dvb->fe_hw.source = DMX_FRONTEND_0;
1051         result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_hw);
1052         if (result < 0) {
1053                 dev_warn(&dev->intf->dev,
1054                          "add_frontend failed (DMX_FRONTEND_0, errno = %d)\n",
1055                          result);
1056                 goto fail_fe_hw;
1057         }
1058
1059         dvb->fe_mem.source = DMX_MEMORY_FE;
1060         result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_mem);
1061         if (result < 0) {
1062                 dev_warn(&dev->intf->dev,
1063                          "add_frontend failed (DMX_MEMORY_FE, errno = %d)\n",
1064                          result);
1065                 goto fail_fe_mem;
1066         }
1067
1068         result = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx, &dvb->fe_hw);
1069         if (result < 0) {
1070                 dev_warn(&dev->intf->dev,
1071                          "connect_frontend failed (errno = %d)\n",
1072                          result);
1073                 goto fail_fe_conn;
1074         }
1075
1076         /* register network adapter */
1077         dvb_net_init(&dvb->adapter, &dvb->net, &dvb->demux.dmx);
1078
1079         /* If the analog part won't create RF connectors, DVB will do it */
1080         if (!dev->has_video || (dev->tuner_type == TUNER_ABSENT))
1081                 create_rf_connector = true;
1082
1083         result = dvb_create_media_graph(&dvb->adapter, create_rf_connector);
1084         if (result < 0)
1085                 goto fail_create_graph;
1086
1087         return 0;
1088
1089 fail_create_graph:
1090         dvb_net_release(&dvb->net);
1091 fail_fe_conn:
1092         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
1093 fail_fe_mem:
1094         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
1095 fail_fe_hw:
1096         dvb_dmxdev_release(&dvb->dmxdev);
1097 fail_dmxdev:
1098         dvb_dmx_release(&dvb->demux);
1099 fail_dmx:
1100         if (dvb->fe[1])
1101                 dvb_unregister_frontend(dvb->fe[1]);
1102         dvb_unregister_frontend(dvb->fe[0]);
1103 fail_frontend1:
1104         if (dvb->fe[1])
1105                 dvb_frontend_detach(dvb->fe[1]);
1106 fail_frontend0:
1107         dvb_frontend_detach(dvb->fe[0]);
1108         dvb_unregister_adapter(&dvb->adapter);
1109 fail_adapter:
1110         return result;
1111 }
1112
1113 static void em28xx_unregister_dvb(struct em28xx_dvb *dvb)
1114 {
1115         dvb_net_release(&dvb->net);
1116         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
1117         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
1118         dvb_dmxdev_release(&dvb->dmxdev);
1119         dvb_dmx_release(&dvb->demux);
1120         if (dvb->fe[1])
1121                 dvb_unregister_frontend(dvb->fe[1]);
1122         dvb_unregister_frontend(dvb->fe[0]);
1123         if (dvb->fe[1] && !dvb->dont_attach_fe1)
1124                 dvb_frontend_detach(dvb->fe[1]);
1125         dvb_frontend_detach(dvb->fe[0]);
1126         dvb_unregister_adapter(&dvb->adapter);
1127 }
1128
1129 static int em28xx_dvb_init(struct em28xx *dev)
1130 {
1131         int result = 0;
1132         struct em28xx_dvb *dvb;
1133
1134         if (dev->is_audio_only) {
1135                 /* Shouldn't initialize IR for this interface */
1136                 return 0;
1137         }
1138
1139         if (!dev->board.has_dvb) {
1140                 /* This device does not support the extension */
1141                 return 0;
1142         }
1143
1144         dev_info(&dev->intf->dev, "Binding DVB extension\n");
1145
1146         dvb = kzalloc(sizeof(struct em28xx_dvb), GFP_KERNEL);
1147         if (!dvb)
1148                 return -ENOMEM;
1149
1150         dev->dvb = dvb;
1151         dvb->fe[0] = dvb->fe[1] = NULL;
1152
1153         /* pre-allocate DVB usb transfer buffers */
1154         if (dev->dvb_xfer_bulk) {
1155                 result = em28xx_alloc_urbs(dev, EM28XX_DIGITAL_MODE,
1156                                            dev->dvb_xfer_bulk,
1157                                            EM28XX_DVB_NUM_BUFS,
1158                                            512,
1159                                            EM28XX_DVB_BULK_PACKET_MULTIPLIER);
1160         } else {
1161                 result = em28xx_alloc_urbs(dev, EM28XX_DIGITAL_MODE,
1162                                            dev->dvb_xfer_bulk,
1163                                            EM28XX_DVB_NUM_BUFS,
1164                                            dev->dvb_max_pkt_size_isoc,
1165                                            EM28XX_DVB_NUM_ISOC_PACKETS);
1166         }
1167         if (result) {
1168                 dev_err(&dev->intf->dev,
1169                         "failed to pre-allocate USB transfer buffers for DVB.\n");
1170                 kfree(dvb);
1171                 dev->dvb = NULL;
1172                 return result;
1173         }
1174
1175         mutex_lock(&dev->lock);
1176         em28xx_set_mode(dev, EM28XX_DIGITAL_MODE);
1177         /* init frontend */
1178         switch (dev->model) {
1179         case EM2874_BOARD_LEADERSHIP_ISDBT:
1180                 dvb->fe[0] = dvb_attach(s921_attach,
1181                                 &sharp_isdbt, &dev->i2c_adap[dev->def_i2c_bus]);
1182
1183                 if (!dvb->fe[0]) {
1184                         result = -EINVAL;
1185                         goto out_free;
1186                 }
1187
1188                 break;
1189         case EM2883_BOARD_HAUPPAUGE_WINTV_HVR_850:
1190         case EM2883_BOARD_HAUPPAUGE_WINTV_HVR_950:
1191         case EM2880_BOARD_PINNACLE_PCTV_HD_PRO:
1192         case EM2880_BOARD_AMD_ATI_TV_WONDER_HD_600:
1193                 dvb->fe[0] = dvb_attach(lgdt330x_attach,
1194                                            &em2880_lgdt3303_dev,
1195                                            &dev->i2c_adap[dev->def_i2c_bus]);
1196                 if (em28xx_attach_xc3028(0x61, dev) < 0) {
1197                         result = -EINVAL;
1198                         goto out_free;
1199                 }
1200                 break;
1201         case EM2880_BOARD_KWORLD_DVB_310U:
1202                 dvb->fe[0] = dvb_attach(zl10353_attach,
1203                                            &em28xx_zl10353_with_xc3028,
1204                                            &dev->i2c_adap[dev->def_i2c_bus]);
1205                 if (em28xx_attach_xc3028(0x61, dev) < 0) {
1206                         result = -EINVAL;
1207                         goto out_free;
1208                 }
1209                 break;
1210         case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900:
1211         case EM2882_BOARD_TERRATEC_HYBRID_XS:
1212         case EM2880_BOARD_EMPIRE_DUAL_TV:
1213                 dvb->fe[0] = dvb_attach(zl10353_attach,
1214                                            &em28xx_zl10353_xc3028_no_i2c_gate,
1215                                            &dev->i2c_adap[dev->def_i2c_bus]);
1216                 if (em28xx_attach_xc3028(0x61, dev) < 0) {
1217                         result = -EINVAL;
1218                         goto out_free;
1219                 }
1220                 break;
1221         case EM2880_BOARD_TERRATEC_HYBRID_XS:
1222         case EM2880_BOARD_TERRATEC_HYBRID_XS_FR:
1223         case EM2881_BOARD_PINNACLE_HYBRID_PRO:
1224         case EM2882_BOARD_DIKOM_DK300:
1225         case EM2882_BOARD_KWORLD_VS_DVBT:
1226                 dvb->fe[0] = dvb_attach(zl10353_attach,
1227                                            &em28xx_zl10353_xc3028_no_i2c_gate,
1228                                            &dev->i2c_adap[dev->def_i2c_bus]);
1229                 if (dvb->fe[0] == NULL) {
1230                         /* This board could have either a zl10353 or a mt352.
1231                            If the chip id isn't for zl10353, try mt352 */
1232                         dvb->fe[0] = dvb_attach(mt352_attach,
1233                                                    &terratec_xs_mt352_cfg,
1234                                                    &dev->i2c_adap[dev->def_i2c_bus]);
1235                 }
1236
1237                 if (em28xx_attach_xc3028(0x61, dev) < 0) {
1238                         result = -EINVAL;
1239                         goto out_free;
1240                 }
1241                 break;
1242         case EM2870_BOARD_TERRATEC_XS_MT2060:
1243                 dvb->fe[0] = dvb_attach(zl10353_attach,
1244                                                 &em28xx_zl10353_no_i2c_gate_dev,
1245                                                 &dev->i2c_adap[dev->def_i2c_bus]);
1246                 if (dvb->fe[0] != NULL) {
1247                         dvb_attach(mt2060_attach, dvb->fe[0],
1248                                         &dev->i2c_adap[dev->def_i2c_bus],
1249                                         &em28xx_mt2060_config, 1220);
1250                 }
1251                 break;
1252         case EM2870_BOARD_KWORLD_355U:
1253                 dvb->fe[0] = dvb_attach(zl10353_attach,
1254                                            &em28xx_zl10353_no_i2c_gate_dev,
1255                                            &dev->i2c_adap[dev->def_i2c_bus]);
1256                 if (dvb->fe[0] != NULL)
1257                         dvb_attach(qt1010_attach, dvb->fe[0],
1258                                    &dev->i2c_adap[dev->def_i2c_bus], &em28xx_qt1010_config);
1259                 break;
1260         case EM2883_BOARD_KWORLD_HYBRID_330U:
1261         case EM2882_BOARD_EVGA_INDTUBE:
1262                 dvb->fe[0] = dvb_attach(s5h1409_attach,
1263                                            &em28xx_s5h1409_with_xc3028,
1264                                            &dev->i2c_adap[dev->def_i2c_bus]);
1265                 if (em28xx_attach_xc3028(0x61, dev) < 0) {
1266                         result = -EINVAL;
1267                         goto out_free;
1268                 }
1269                 break;
1270         case EM2882_BOARD_KWORLD_ATSC_315U:
1271                 dvb->fe[0] = dvb_attach(lgdt330x_attach,
1272                                            &em2880_lgdt3303_dev,
1273                                            &dev->i2c_adap[dev->def_i2c_bus]);
1274                 if (dvb->fe[0] != NULL) {
1275                         if (!dvb_attach(simple_tuner_attach, dvb->fe[0],
1276                                         &dev->i2c_adap[dev->def_i2c_bus],
1277                                         0x61, TUNER_THOMSON_DTT761X)) {
1278                                 result = -EINVAL;
1279                                 goto out_free;
1280                         }
1281                 }
1282                 break;
1283         case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900_R2:
1284         case EM2882_BOARD_PINNACLE_HYBRID_PRO_330E:
1285                 dvb->fe[0] = dvb_attach(drxd_attach, &em28xx_drxd, NULL,
1286                                         &dev->i2c_adap[dev->def_i2c_bus],
1287                                         &dev->intf->dev);
1288                 if (em28xx_attach_xc3028(0x61, dev) < 0) {
1289                         result = -EINVAL;
1290                         goto out_free;
1291                 }
1292                 break;
1293         case EM2870_BOARD_REDDO_DVB_C_USB_BOX:
1294                 /* Philips CU1216L NIM (Philips TDA10023 + Infineon TUA6034) */
1295                 dvb->fe[0] = dvb_attach(tda10023_attach,
1296                         &em28xx_tda10023_config,
1297                         &dev->i2c_adap[dev->def_i2c_bus], 0x48);
1298                 if (dvb->fe[0]) {
1299                         if (!dvb_attach(simple_tuner_attach, dvb->fe[0],
1300                                         &dev->i2c_adap[dev->def_i2c_bus],
1301                                         0x60, TUNER_PHILIPS_CU1216L)) {
1302                                 result = -EINVAL;
1303                                 goto out_free;
1304                         }
1305                 }
1306                 break;
1307         case EM2870_BOARD_KWORLD_A340:
1308                 dvb->fe[0] = dvb_attach(lgdt3305_attach,
1309                                            &em2870_lgdt3304_dev,
1310                                            &dev->i2c_adap[dev->def_i2c_bus]);
1311                 if (!dvb->fe[0]) {
1312                         result = -EINVAL;
1313                         goto out_free;
1314                 }
1315                 if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
1316                                 &dev->i2c_adap[dev->def_i2c_bus],
1317                         &kworld_a340_config)) {
1318                                 dvb_frontend_detach(dvb->fe[0]);
1319                                 result = -EINVAL;
1320                                 goto out_free;
1321                 }
1322                 break;
1323         case EM28174_BOARD_PCTV_290E:
1324                 /* set default GPIO0 for LNA, used if GPIOLIB is undefined */
1325                 dvb->lna_gpio = CXD2820R_GPIO_E | CXD2820R_GPIO_O |
1326                                 CXD2820R_GPIO_L;
1327                 dvb->fe[0] = dvb_attach(cxd2820r_attach,
1328                                         &em28xx_cxd2820r_config,
1329                                         &dev->i2c_adap[dev->def_i2c_bus],
1330                                         &dvb->lna_gpio);
1331                 if (dvb->fe[0]) {
1332                         /* FE 0 attach tuner */
1333                         if (!dvb_attach(tda18271_attach,
1334                                         dvb->fe[0],
1335                                         0x60,
1336                                         &dev->i2c_adap[dev->def_i2c_bus],
1337                                         &em28xx_cxd2820r_tda18271_config)) {
1338
1339                                 dvb_frontend_detach(dvb->fe[0]);
1340                                 result = -EINVAL;
1341                                 goto out_free;
1342                         }
1343
1344 #ifdef CONFIG_GPIOLIB
1345                         /* enable LNA for DVB-T, DVB-T2 and DVB-C */
1346                         result = gpio_request_one(dvb->lna_gpio,
1347                                                   GPIOF_OUT_INIT_LOW, NULL);
1348                         if (result)
1349                                 dev_err(&dev->intf->dev,
1350                                         "gpio request failed %d\n",
1351                                         result);
1352                         else
1353                                 gpio_free(dvb->lna_gpio);
1354
1355                         result = 0; /* continue even set LNA fails */
1356 #endif
1357                         dvb->fe[0]->ops.set_lna = em28xx_pctv_290e_set_lna;
1358                 }
1359
1360                 break;
1361         case EM2884_BOARD_HAUPPAUGE_WINTV_HVR_930C:
1362         {
1363                 struct xc5000_config cfg;
1364
1365                 hauppauge_hvr930c_init(dev);
1366
1367                 dvb->fe[0] = dvb_attach(drxk_attach,
1368                                         &hauppauge_930c_drxk, &dev->i2c_adap[dev->def_i2c_bus]);
1369                 if (!dvb->fe[0]) {
1370                         result = -EINVAL;
1371                         goto out_free;
1372                 }
1373                 /* FIXME: do we need a pll semaphore? */
1374                 dvb->fe[0]->sec_priv = dvb;
1375                 sema_init(&dvb->pll_mutex, 1);
1376                 dvb->gate_ctrl = dvb->fe[0]->ops.i2c_gate_ctrl;
1377                 dvb->fe[0]->ops.i2c_gate_ctrl = drxk_gate_ctrl;
1378
1379                 /* Attach xc5000 */
1380                 memset(&cfg, 0, sizeof(cfg));
1381                 cfg.i2c_address  = 0x61;
1382                 cfg.if_khz = 4000;
1383
1384                 if (dvb->fe[0]->ops.i2c_gate_ctrl)
1385                         dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 1);
1386                 if (!dvb_attach(xc5000_attach, dvb->fe[0], &dev->i2c_adap[dev->def_i2c_bus],
1387                                 &cfg)) {
1388                         result = -EINVAL;
1389                         goto out_free;
1390                 }
1391                 if (dvb->fe[0]->ops.i2c_gate_ctrl)
1392                         dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 0);
1393
1394                 break;
1395         }
1396         case EM2884_BOARD_TERRATEC_H5:
1397                 terratec_h5_init(dev);
1398
1399                 dvb->fe[0] = dvb_attach(drxk_attach, &terratec_h5_drxk, &dev->i2c_adap[dev->def_i2c_bus]);
1400                 if (!dvb->fe[0]) {
1401                         result = -EINVAL;
1402                         goto out_free;
1403                 }
1404                 /* FIXME: do we need a pll semaphore? */
1405                 dvb->fe[0]->sec_priv = dvb;
1406                 sema_init(&dvb->pll_mutex, 1);
1407                 dvb->gate_ctrl = dvb->fe[0]->ops.i2c_gate_ctrl;
1408                 dvb->fe[0]->ops.i2c_gate_ctrl = drxk_gate_ctrl;
1409
1410                 /* Attach tda18271 to DVB-C frontend */
1411                 if (dvb->fe[0]->ops.i2c_gate_ctrl)
1412                         dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 1);
1413                 if (!dvb_attach(tda18271c2dd_attach, dvb->fe[0], &dev->i2c_adap[dev->def_i2c_bus], 0x60)) {
1414                         result = -EINVAL;
1415                         goto out_free;
1416                 }
1417                 if (dvb->fe[0]->ops.i2c_gate_ctrl)
1418                         dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 0);
1419
1420                 break;
1421         case EM2884_BOARD_C3TECH_DIGITAL_DUO:
1422                 dvb->fe[0] = dvb_attach(mb86a20s_attach,
1423                                            &c3tech_duo_mb86a20s_config,
1424                                            &dev->i2c_adap[dev->def_i2c_bus]);
1425                 if (dvb->fe[0] != NULL)
1426                         dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
1427                                    &dev->i2c_adap[dev->def_i2c_bus],
1428                                    &c3tech_duo_tda18271_config);
1429                 break;
1430         case EM28174_BOARD_PCTV_460E: {
1431                 struct i2c_client *client;
1432                 struct i2c_board_info board_info;
1433                 struct tda10071_platform_data tda10071_pdata = {};
1434                 struct a8293_platform_data a8293_pdata = {};
1435
1436                 /* attach demod + tuner combo */
1437                 tda10071_pdata.clk = 40444000, /* 40.444 MHz */
1438                 tda10071_pdata.i2c_wr_max = 64,
1439                 tda10071_pdata.ts_mode = TDA10071_TS_SERIAL,
1440                 tda10071_pdata.pll_multiplier = 20,
1441                 tda10071_pdata.tuner_i2c_addr = 0x14,
1442                 memset(&board_info, 0, sizeof(board_info));
1443                 strlcpy(board_info.type, "tda10071_cx24118", I2C_NAME_SIZE);
1444                 board_info.addr = 0x55;
1445                 board_info.platform_data = &tda10071_pdata;
1446                 request_module("tda10071");
1447                 client = i2c_new_device(&dev->i2c_adap[dev->def_i2c_bus], &board_info);
1448                 if (client == NULL || client->dev.driver == NULL) {
1449                         result = -ENODEV;
1450                         goto out_free;
1451                 }
1452                 if (!try_module_get(client->dev.driver->owner)) {
1453                         i2c_unregister_device(client);
1454                         result = -ENODEV;
1455                         goto out_free;
1456                 }
1457                 dvb->fe[0] = tda10071_pdata.get_dvb_frontend(client);
1458                 dvb->i2c_client_demod = client;
1459
1460                 /* attach SEC */
1461                 a8293_pdata.dvb_frontend = dvb->fe[0];
1462                 memset(&board_info, 0, sizeof(board_info));
1463                 strlcpy(board_info.type, "a8293", I2C_NAME_SIZE);
1464                 board_info.addr = 0x08;
1465                 board_info.platform_data = &a8293_pdata;
1466                 request_module("a8293");
1467                 client = i2c_new_device(&dev->i2c_adap[dev->def_i2c_bus], &board_info);
1468                 if (client == NULL || client->dev.driver == NULL) {
1469                         module_put(dvb->i2c_client_demod->dev.driver->owner);
1470                         i2c_unregister_device(dvb->i2c_client_demod);
1471                         result = -ENODEV;
1472                         goto out_free;
1473                 }
1474                 if (!try_module_get(client->dev.driver->owner)) {
1475                         i2c_unregister_device(client);
1476                         module_put(dvb->i2c_client_demod->dev.driver->owner);
1477                         i2c_unregister_device(dvb->i2c_client_demod);
1478                         result = -ENODEV;
1479                         goto out_free;
1480                 }
1481                 dvb->i2c_client_sec = client;
1482                 break;
1483         }
1484         case EM2874_BOARD_DELOCK_61959:
1485         case EM2874_BOARD_MAXMEDIA_UB425_TC:
1486                 /* attach demodulator */
1487                 dvb->fe[0] = dvb_attach(drxk_attach, &maxmedia_ub425_tc_drxk,
1488                                 &dev->i2c_adap[dev->def_i2c_bus]);
1489
1490                 if (dvb->fe[0]) {
1491                         /* disable I2C-gate */
1492                         dvb->fe[0]->ops.i2c_gate_ctrl = NULL;
1493
1494                         /* attach tuner */
1495                         if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
1496                                         &dev->i2c_adap[dev->def_i2c_bus],
1497                                         &em28xx_cxd2820r_tda18271_config)) {
1498                                 dvb_frontend_detach(dvb->fe[0]);
1499                                 result = -EINVAL;
1500                                 goto out_free;
1501                         }
1502                 }
1503                 break;
1504         case EM2884_BOARD_PCTV_510E:
1505         case EM2884_BOARD_PCTV_520E:
1506                 pctv_520e_init(dev);
1507
1508                 /* attach demodulator */
1509                 dvb->fe[0] = dvb_attach(drxk_attach, &pctv_520e_drxk,
1510                                 &dev->i2c_adap[dev->def_i2c_bus]);
1511
1512                 if (dvb->fe[0]) {
1513                         /* attach tuner */
1514                         if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
1515                                         &dev->i2c_adap[dev->def_i2c_bus],
1516                                         &em28xx_cxd2820r_tda18271_config)) {
1517                                 dvb_frontend_detach(dvb->fe[0]);
1518                                 result = -EINVAL;
1519                                 goto out_free;
1520                         }
1521                 }
1522                 break;
1523         case EM2884_BOARD_ELGATO_EYETV_HYBRID_2008:
1524         case EM2884_BOARD_CINERGY_HTC_STICK:
1525         case EM2884_BOARD_TERRATEC_H6:
1526                 terratec_htc_stick_init(dev);
1527
1528                 /* attach demodulator */
1529                 dvb->fe[0] = dvb_attach(drxk_attach, &terratec_htc_stick_drxk,
1530                                         &dev->i2c_adap[dev->def_i2c_bus]);
1531                 if (!dvb->fe[0]) {
1532                         result = -EINVAL;
1533                         goto out_free;
1534                 }
1535
1536                 /* Attach the demodulator. */
1537                 if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
1538                                 &dev->i2c_adap[dev->def_i2c_bus],
1539                                 &em28xx_cxd2820r_tda18271_config)) {
1540                         result = -EINVAL;
1541                         goto out_free;
1542                 }
1543                 break;
1544         case EM2884_BOARD_TERRATEC_HTC_USB_XS:
1545                 terratec_htc_usb_xs_init(dev);
1546
1547                 /* attach demodulator */
1548                 dvb->fe[0] = dvb_attach(drxk_attach, &terratec_htc_stick_drxk,
1549                                         &dev->i2c_adap[dev->def_i2c_bus]);
1550                 if (!dvb->fe[0]) {
1551                         result = -EINVAL;
1552                         goto out_free;
1553                 }
1554
1555                 /* Attach the demodulator. */
1556                 if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
1557                                 &dev->i2c_adap[dev->def_i2c_bus],
1558                                 &em28xx_cxd2820r_tda18271_config)) {
1559                         result = -EINVAL;
1560                         goto out_free;
1561                 }
1562                 break;
1563         case EM2874_BOARD_KWORLD_UB435Q_V2:
1564                 dvb->fe[0] = dvb_attach(lgdt3305_attach,
1565                                         &em2874_lgdt3305_dev,
1566                                         &dev->i2c_adap[dev->def_i2c_bus]);
1567                 if (!dvb->fe[0]) {
1568                         result = -EINVAL;
1569                         goto out_free;
1570                 }
1571
1572                 /* Attach the demodulator. */
1573                 if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
1574                                 &dev->i2c_adap[dev->def_i2c_bus],
1575                                 &kworld_ub435q_v2_config)) {
1576                         result = -EINVAL;
1577                         goto out_free;
1578                 }
1579                 break;
1580         case EM2874_BOARD_KWORLD_UB435Q_V3:
1581         {
1582                 struct i2c_client *client;
1583                 struct i2c_adapter *adapter = &dev->i2c_adap[dev->def_i2c_bus];
1584                 struct i2c_board_info board_info = {
1585                         .type = "tda18212",
1586                         .addr = 0x60,
1587                         .platform_data = &kworld_ub435q_v3_config,
1588                 };
1589
1590                 dvb->fe[0] = dvb_attach(lgdt3305_attach,
1591                                         &em2874_lgdt3305_nogate_dev,
1592                                         &dev->i2c_adap[dev->def_i2c_bus]);
1593                 if (!dvb->fe[0]) {
1594                         result = -EINVAL;
1595                         goto out_free;
1596                 }
1597
1598                 /* attach tuner */
1599                 kworld_ub435q_v3_config.fe = dvb->fe[0];
1600                 request_module("tda18212");
1601                 client = i2c_new_device(adapter, &board_info);
1602                 if (client == NULL || client->dev.driver == NULL) {
1603                         dvb_frontend_detach(dvb->fe[0]);
1604                         result = -ENODEV;
1605                         goto out_free;
1606                 }
1607
1608                 if (!try_module_get(client->dev.driver->owner)) {
1609                         i2c_unregister_device(client);
1610                         dvb_frontend_detach(dvb->fe[0]);
1611                         result = -ENODEV;
1612                         goto out_free;
1613                 }
1614
1615                 dvb->i2c_client_tuner = client;
1616                 break;
1617         }
1618         case EM2874_BOARD_PCTV_HD_MINI_80E:
1619                 dvb->fe[0] = dvb_attach(drx39xxj_attach, &dev->i2c_adap[dev->def_i2c_bus]);
1620                 if (dvb->fe[0] != NULL) {
1621                         dvb->fe[0] = dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
1622                                                 &dev->i2c_adap[dev->def_i2c_bus],
1623                                                 &pinnacle_80e_dvb_config);
1624                         if (!dvb->fe[0]) {
1625                                 result = -EINVAL;
1626                                 goto out_free;
1627                         }
1628                 }
1629                 break;
1630         case EM28178_BOARD_PCTV_461E: {
1631                 struct i2c_client *client;
1632                 struct i2c_adapter *i2c_adapter;
1633                 struct i2c_board_info board_info;
1634                 struct m88ds3103_platform_data m88ds3103_pdata = {};
1635                 struct ts2020_config ts2020_config = {};
1636                 struct a8293_platform_data a8293_pdata = {};
1637
1638                 /* attach demod */
1639                 m88ds3103_pdata.clk = 27000000;
1640                 m88ds3103_pdata.i2c_wr_max = 33;
1641                 m88ds3103_pdata.ts_mode = M88DS3103_TS_PARALLEL;
1642                 m88ds3103_pdata.ts_clk = 16000;
1643                 m88ds3103_pdata.ts_clk_pol = 1;
1644                 m88ds3103_pdata.agc = 0x99;
1645                 memset(&board_info, 0, sizeof(board_info));
1646                 strlcpy(board_info.type, "m88ds3103", I2C_NAME_SIZE);
1647                 board_info.addr = 0x68;
1648                 board_info.platform_data = &m88ds3103_pdata;
1649                 request_module("m88ds3103");
1650                 client = i2c_new_device(&dev->i2c_adap[dev->def_i2c_bus], &board_info);
1651                 if (client == NULL || client->dev.driver == NULL) {
1652                         result = -ENODEV;
1653                         goto out_free;
1654                 }
1655                 if (!try_module_get(client->dev.driver->owner)) {
1656                         i2c_unregister_device(client);
1657                         result = -ENODEV;
1658                         goto out_free;
1659                 }
1660                 dvb->fe[0] = m88ds3103_pdata.get_dvb_frontend(client);
1661                 i2c_adapter = m88ds3103_pdata.get_i2c_adapter(client);
1662                 dvb->i2c_client_demod = client;
1663
1664                 /* attach tuner */
1665                 ts2020_config.fe = dvb->fe[0];
1666                 memset(&board_info, 0, sizeof(board_info));
1667                 strlcpy(board_info.type, "ts2022", I2C_NAME_SIZE);
1668                 board_info.addr = 0x60;
1669                 board_info.platform_data = &ts2020_config;
1670                 request_module("ts2020");
1671                 client = i2c_new_device(i2c_adapter, &board_info);
1672                 if (client == NULL || client->dev.driver == NULL) {
1673                         module_put(dvb->i2c_client_demod->dev.driver->owner);
1674                         i2c_unregister_device(dvb->i2c_client_demod);
1675                         result = -ENODEV;
1676                         goto out_free;
1677                 }
1678                 if (!try_module_get(client->dev.driver->owner)) {
1679                         i2c_unregister_device(client);
1680                         module_put(dvb->i2c_client_demod->dev.driver->owner);
1681                         i2c_unregister_device(dvb->i2c_client_demod);
1682                         result = -ENODEV;
1683                         goto out_free;
1684                 }
1685                 dvb->i2c_client_tuner = client;
1686                 /* delegate signal strength measurement to tuner */
1687                 dvb->fe[0]->ops.read_signal_strength =
1688                                 dvb->fe[0]->ops.tuner_ops.get_rf_strength;
1689
1690                 /* attach SEC */
1691                 a8293_pdata.dvb_frontend = dvb->fe[0];
1692                 memset(&board_info, 0, sizeof(board_info));
1693                 strlcpy(board_info.type, "a8293", I2C_NAME_SIZE);
1694                 board_info.addr = 0x08;
1695                 board_info.platform_data = &a8293_pdata;
1696                 request_module("a8293");
1697                 client = i2c_new_device(&dev->i2c_adap[dev->def_i2c_bus], &board_info);
1698                 if (client == NULL || client->dev.driver == NULL) {
1699                         module_put(dvb->i2c_client_tuner->dev.driver->owner);
1700                         i2c_unregister_device(dvb->i2c_client_tuner);
1701                         module_put(dvb->i2c_client_demod->dev.driver->owner);
1702                         i2c_unregister_device(dvb->i2c_client_demod);
1703                         result = -ENODEV;
1704                         goto out_free;
1705                 }
1706                 if (!try_module_get(client->dev.driver->owner)) {
1707                         i2c_unregister_device(client);
1708                         module_put(dvb->i2c_client_tuner->dev.driver->owner);
1709                         i2c_unregister_device(dvb->i2c_client_tuner);
1710                         module_put(dvb->i2c_client_demod->dev.driver->owner);
1711                         i2c_unregister_device(dvb->i2c_client_demod);
1712                         result = -ENODEV;
1713                         goto out_free;
1714                 }
1715                 dvb->i2c_client_sec = client;
1716                 break;
1717         }
1718         case EM28178_BOARD_PCTV_292E:
1719                 {
1720                         struct i2c_adapter *adapter;
1721                         struct i2c_client *client;
1722                         struct i2c_board_info info;
1723                         struct si2168_config si2168_config;
1724                         struct si2157_config si2157_config;
1725
1726                         /* attach demod */
1727                         memset(&si2168_config, 0, sizeof(si2168_config));
1728                         si2168_config.i2c_adapter = &adapter;
1729                         si2168_config.fe = &dvb->fe[0];
1730                         si2168_config.ts_mode = SI2168_TS_PARALLEL;
1731                         memset(&info, 0, sizeof(struct i2c_board_info));
1732                         strlcpy(info.type, "si2168", I2C_NAME_SIZE);
1733                         info.addr = 0x64;
1734                         info.platform_data = &si2168_config;
1735                         request_module(info.type);
1736                         client = i2c_new_device(&dev->i2c_adap[dev->def_i2c_bus], &info);
1737                         if (client == NULL || client->dev.driver == NULL) {
1738                                 result = -ENODEV;
1739                                 goto out_free;
1740                         }
1741
1742                         if (!try_module_get(client->dev.driver->owner)) {
1743                                 i2c_unregister_device(client);
1744                                 result = -ENODEV;
1745                                 goto out_free;
1746                         }
1747
1748                         dvb->i2c_client_demod = client;
1749
1750                         /* attach tuner */
1751                         memset(&si2157_config, 0, sizeof(si2157_config));
1752                         si2157_config.fe = dvb->fe[0];
1753                         si2157_config.if_port = 1;
1754 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
1755                         si2157_config.mdev = dev->media_dev;
1756 #endif
1757                         memset(&info, 0, sizeof(struct i2c_board_info));
1758                         strlcpy(info.type, "si2157", I2C_NAME_SIZE);
1759                         info.addr = 0x60;
1760                         info.platform_data = &si2157_config;
1761                         request_module(info.type);
1762                         client = i2c_new_device(adapter, &info);
1763                         if (client == NULL || client->dev.driver == NULL) {
1764                                 module_put(dvb->i2c_client_demod->dev.driver->owner);
1765                                 i2c_unregister_device(dvb->i2c_client_demod);
1766                                 result = -ENODEV;
1767                                 goto out_free;
1768                         }
1769
1770                         if (!try_module_get(client->dev.driver->owner)) {
1771                                 i2c_unregister_device(client);
1772                                 module_put(dvb->i2c_client_demod->dev.driver->owner);
1773                                 i2c_unregister_device(dvb->i2c_client_demod);
1774                                 result = -ENODEV;
1775                                 goto out_free;
1776                         }
1777
1778                         dvb->i2c_client_tuner = client;
1779                         dvb->fe[0]->ops.set_lna = em28xx_pctv_292e_set_lna;
1780                 }
1781                 break;
1782         case EM28178_BOARD_TERRATEC_T2_STICK_HD:
1783                 {
1784                         struct i2c_adapter *adapter;
1785                         struct i2c_client *client;
1786                         struct i2c_board_info info;
1787                         struct si2168_config si2168_config;
1788                         struct si2157_config si2157_config;
1789
1790                         /* attach demod */
1791                         memset(&si2168_config, 0, sizeof(si2168_config));
1792                         si2168_config.i2c_adapter = &adapter;
1793                         si2168_config.fe = &dvb->fe[0];
1794                         si2168_config.ts_mode = SI2168_TS_PARALLEL;
1795                         memset(&info, 0, sizeof(struct i2c_board_info));
1796                         strlcpy(info.type, "si2168", I2C_NAME_SIZE);
1797                         info.addr = 0x64;
1798                         info.platform_data = &si2168_config;
1799                         request_module(info.type);
1800                         client = i2c_new_device(&dev->i2c_adap[dev->def_i2c_bus], &info);
1801                         if (client == NULL || client->dev.driver == NULL) {
1802                                 result = -ENODEV;
1803                                 goto out_free;
1804                         }
1805
1806                         if (!try_module_get(client->dev.driver->owner)) {
1807                                 i2c_unregister_device(client);
1808                                 result = -ENODEV;
1809                                 goto out_free;
1810                         }
1811
1812                         dvb->i2c_client_demod = client;
1813
1814                         /* attach tuner */
1815                         memset(&si2157_config, 0, sizeof(si2157_config));
1816                         si2157_config.fe = dvb->fe[0];
1817                         si2157_config.if_port = 0;
1818 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
1819                         si2157_config.mdev = dev->media_dev;
1820 #endif
1821                         memset(&info, 0, sizeof(struct i2c_board_info));
1822                         strlcpy(info.type, "si2146", I2C_NAME_SIZE);
1823                         info.addr = 0x60;
1824                         info.platform_data = &si2157_config;
1825                         request_module("si2157");
1826                         client = i2c_new_device(adapter, &info);
1827                         if (client == NULL || client->dev.driver == NULL) {
1828                                 module_put(dvb->i2c_client_demod->dev.driver->owner);
1829                                 i2c_unregister_device(dvb->i2c_client_demod);
1830                                 result = -ENODEV;
1831                                 goto out_free;
1832                         }
1833
1834                         if (!try_module_get(client->dev.driver->owner)) {
1835                                 i2c_unregister_device(client);
1836                                 module_put(dvb->i2c_client_demod->dev.driver->owner);
1837                                 i2c_unregister_device(dvb->i2c_client_demod);
1838                                 result = -ENODEV;
1839                                 goto out_free;
1840                         }
1841
1842                         dvb->i2c_client_tuner = client;
1843                 }
1844                 break;
1845
1846         case EM28178_BOARD_PLEX_PX_BCUD:
1847                 {
1848                         struct i2c_client *client;
1849                         struct i2c_board_info info;
1850                         struct tc90522_config tc90522_config;
1851                         struct qm1d1c0042_config qm1d1c0042_config;
1852
1853                         /* attach demod */
1854                         memset(&tc90522_config, 0, sizeof(tc90522_config));
1855                         memset(&info, 0, sizeof(struct i2c_board_info));
1856                         strlcpy(info.type, "tc90522sat", I2C_NAME_SIZE);
1857                         info.addr = 0x15;
1858                         info.platform_data = &tc90522_config;
1859                         request_module("tc90522");
1860                         client = i2c_new_device(&dev->i2c_adap[dev->def_i2c_bus], &info);
1861                         if (client == NULL || client->dev.driver == NULL) {
1862                                 result = -ENODEV;
1863                                 goto out_free;
1864                         }
1865                         dvb->i2c_client_demod = client;
1866                         if (!try_module_get(client->dev.driver->owner)) {
1867                                 i2c_unregister_device(client);
1868                                 result = -ENODEV;
1869                                 goto out_free;
1870                         }
1871
1872                         /* attach tuner */
1873                         memset(&qm1d1c0042_config, 0,
1874                                sizeof(qm1d1c0042_config));
1875                         qm1d1c0042_config.fe = tc90522_config.fe;
1876                         qm1d1c0042_config.lpf = 1;
1877                         memset(&info, 0, sizeof(struct i2c_board_info));
1878                         strlcpy(info.type, "qm1d1c0042", I2C_NAME_SIZE);
1879                         info.addr = 0x61;
1880                         info.platform_data = &qm1d1c0042_config;
1881                         request_module(info.type);
1882                         client = i2c_new_device(tc90522_config.tuner_i2c,
1883                                                 &info);
1884                         if (client == NULL || client->dev.driver == NULL) {
1885                                 module_put(dvb->i2c_client_demod->dev.driver->owner);
1886                                 i2c_unregister_device(dvb->i2c_client_demod);
1887                                 result = -ENODEV;
1888                                 goto out_free;
1889                         }
1890                         dvb->i2c_client_tuner = client;
1891                         if (!try_module_get(client->dev.driver->owner)) {
1892                                 i2c_unregister_device(client);
1893                                 module_put(dvb->i2c_client_demod->dev.driver->owner);
1894                                 i2c_unregister_device(dvb->i2c_client_demod);
1895                                 result = -ENODEV;
1896                                 goto out_free;
1897                         }
1898                         dvb->fe[0] = tc90522_config.fe;
1899                         px_bcud_init(dev);
1900                 }
1901                 break;
1902         case EM28174_BOARD_HAUPPAUGE_WINTV_DUALHD_DVB:
1903                 {
1904                         struct i2c_adapter *adapter;
1905                         struct i2c_client *client;
1906                         struct i2c_board_info info;
1907                         struct si2168_config si2168_config;
1908                         struct si2157_config si2157_config;
1909
1910                         /* attach demod */
1911                         memset(&si2168_config, 0, sizeof(si2168_config));
1912                         si2168_config.i2c_adapter = &adapter;
1913                         si2168_config.fe = &dvb->fe[0];
1914                         si2168_config.ts_mode = SI2168_TS_SERIAL;
1915                         memset(&info, 0, sizeof(struct i2c_board_info));
1916                         strlcpy(info.type, "si2168", I2C_NAME_SIZE);
1917                         info.addr = 0x64;
1918                         info.platform_data = &si2168_config;
1919                         request_module(info.type);
1920                         client = i2c_new_device(&dev->i2c_adap[dev->def_i2c_bus], &info);
1921                         if (client == NULL || client->dev.driver == NULL) {
1922                                 result = -ENODEV;
1923                                 goto out_free;
1924                         }
1925
1926                         if (!try_module_get(client->dev.driver->owner)) {
1927                                 i2c_unregister_device(client);
1928                                 result = -ENODEV;
1929                                 goto out_free;
1930                         }
1931
1932                         dvb->i2c_client_demod = client;
1933
1934                         /* attach tuner */
1935                         memset(&si2157_config, 0, sizeof(si2157_config));
1936                         si2157_config.fe = dvb->fe[0];
1937                         si2157_config.if_port = 1;
1938 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
1939                         si2157_config.mdev = dev->media_dev;
1940 #endif
1941                         memset(&info, 0, sizeof(struct i2c_board_info));
1942                         strlcpy(info.type, "si2157", I2C_NAME_SIZE);
1943                         info.addr = 0x60;
1944                         info.platform_data = &si2157_config;
1945                         request_module(info.type);
1946                         client = i2c_new_device(adapter, &info);
1947                         if (client == NULL || client->dev.driver == NULL) {
1948                                 module_put(dvb->i2c_client_demod->dev.driver->owner);
1949                                 i2c_unregister_device(dvb->i2c_client_demod);
1950                                 result = -ENODEV;
1951                                 goto out_free;
1952                         }
1953
1954                         if (!try_module_get(client->dev.driver->owner)) {
1955                                 i2c_unregister_device(client);
1956                                 module_put(dvb->i2c_client_demod->dev.driver->owner);
1957                                 i2c_unregister_device(dvb->i2c_client_demod);
1958                                 result = -ENODEV;
1959                                 goto out_free;
1960                         }
1961
1962                         dvb->i2c_client_tuner = client;
1963
1964                 }
1965                 break;
1966         case EM28174_BOARD_HAUPPAUGE_WINTV_DUALHD_01595:
1967                 {
1968                         struct i2c_adapter *adapter;
1969                         struct i2c_client *client;
1970                         struct i2c_board_info info = {};
1971                         struct lgdt3306a_config lgdt3306a_config;
1972                         struct si2157_config si2157_config = {};
1973
1974                         /* attach demod */
1975                         lgdt3306a_config = hauppauge_01595_lgdt3306a_config;
1976                         lgdt3306a_config.fe = &dvb->fe[0];
1977                         lgdt3306a_config.i2c_adapter = &adapter;
1978                         strlcpy(info.type, "lgdt3306a", sizeof(info.type));
1979                         info.addr = 0x59;
1980                         info.platform_data = &lgdt3306a_config;
1981                         request_module(info.type);
1982                         client = i2c_new_device(&dev->i2c_adap[dev->def_i2c_bus],
1983                                         &info);
1984                         if (client == NULL || client->dev.driver == NULL) {
1985                                 result = -ENODEV;
1986                                 goto out_free;
1987                         }
1988
1989                         if (!try_module_get(client->dev.driver->owner)) {
1990                                 i2c_unregister_device(client);
1991                                 result = -ENODEV;
1992                                 goto out_free;
1993                         }
1994
1995                         dvb->i2c_client_demod = client;
1996
1997                         /* attach tuner */
1998                         si2157_config.fe = dvb->fe[0];
1999                         si2157_config.if_port = 1;
2000                         si2157_config.inversion = 1;
2001 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
2002                         si2157_config.mdev = dev->media_dev;
2003 #endif
2004                         memset(&info, 0, sizeof(struct i2c_board_info));
2005                         strlcpy(info.type, "si2157", sizeof(info.type));
2006                         info.addr = 0x60;
2007                         info.platform_data = &si2157_config;
2008                         request_module(info.type);
2009
2010                         client = i2c_new_device(adapter, &info);
2011                         if (client == NULL || client->dev.driver == NULL) {
2012                                 module_put(dvb->i2c_client_demod->dev.driver->owner);
2013                                 i2c_unregister_device(dvb->i2c_client_demod);
2014                                 result = -ENODEV;
2015                                 goto out_free;
2016                         }
2017                         if (!try_module_get(client->dev.driver->owner)) {
2018                                 i2c_unregister_device(client);
2019                                 module_put(dvb->i2c_client_demod->dev.driver->owner);
2020                                 i2c_unregister_device(dvb->i2c_client_demod);
2021                                 result = -ENODEV;
2022                                 goto out_free;
2023                         }
2024
2025                         dvb->i2c_client_tuner = client;
2026                 }
2027                 break;
2028         default:
2029                 dev_err(&dev->intf->dev,
2030                         "The frontend of your DVB/ATSC card isn't supported yet\n");
2031                 break;
2032         }
2033         if (NULL == dvb->fe[0]) {
2034                 dev_err(&dev->intf->dev, "frontend initialization failed\n");
2035                 result = -EINVAL;
2036                 goto out_free;
2037         }
2038         /* define general-purpose callback pointer */
2039         dvb->fe[0]->callback = em28xx_tuner_callback;
2040         if (dvb->fe[1])
2041                 dvb->fe[1]->callback = em28xx_tuner_callback;
2042
2043         /* register everything */
2044         result = em28xx_register_dvb(dvb, THIS_MODULE, dev, &dev->intf->dev);
2045
2046         if (result < 0)
2047                 goto out_free;
2048
2049         dev_info(&dev->intf->dev, "DVB extension successfully initialized\n");
2050
2051         kref_get(&dev->ref);
2052
2053 ret:
2054         em28xx_set_mode(dev, EM28XX_SUSPEND);
2055         mutex_unlock(&dev->lock);
2056         return result;
2057
2058 out_free:
2059         kfree(dvb);
2060         dev->dvb = NULL;
2061         goto ret;
2062 }
2063
2064 static inline void prevent_sleep(struct dvb_frontend_ops *ops)
2065 {
2066         ops->set_voltage = NULL;
2067         ops->sleep = NULL;
2068         ops->tuner_ops.sleep = NULL;
2069 }
2070
2071 static int em28xx_dvb_fini(struct em28xx *dev)
2072 {
2073         struct em28xx_dvb *dvb;
2074         struct i2c_client *client;
2075
2076         if (dev->is_audio_only) {
2077                 /* Shouldn't initialize IR for this interface */
2078                 return 0;
2079         }
2080
2081         if (!dev->board.has_dvb) {
2082                 /* This device does not support the extension */
2083                 return 0;
2084         }
2085
2086         if (!dev->dvb)
2087                 return 0;
2088
2089         dev_info(&dev->intf->dev, "Closing DVB extension\n");
2090
2091         dvb = dev->dvb;
2092
2093         em28xx_uninit_usb_xfer(dev, EM28XX_DIGITAL_MODE);
2094
2095         if (dev->disconnected) {
2096                 /* We cannot tell the device to sleep
2097                  * once it has been unplugged. */
2098                 if (dvb->fe[0]) {
2099                         prevent_sleep(&dvb->fe[0]->ops);
2100                         dvb->fe[0]->exit = DVB_FE_DEVICE_REMOVED;
2101                 }
2102                 if (dvb->fe[1]) {
2103                         prevent_sleep(&dvb->fe[1]->ops);
2104                         dvb->fe[1]->exit = DVB_FE_DEVICE_REMOVED;
2105                 }
2106         }
2107
2108         /* remove I2C SEC */
2109         client = dvb->i2c_client_sec;
2110         if (client) {
2111                 module_put(client->dev.driver->owner);
2112                 i2c_unregister_device(client);
2113         }
2114
2115         /* remove I2C tuner */
2116         client = dvb->i2c_client_tuner;
2117         if (client) {
2118                 module_put(client->dev.driver->owner);
2119                 i2c_unregister_device(client);
2120         }
2121
2122         /* remove I2C demod */
2123         client = dvb->i2c_client_demod;
2124         if (client) {
2125                 module_put(client->dev.driver->owner);
2126                 i2c_unregister_device(client);
2127         }
2128
2129         em28xx_unregister_dvb(dvb);
2130         kfree(dvb);
2131         dev->dvb = NULL;
2132         kref_put(&dev->ref, em28xx_free_device);
2133
2134         return 0;
2135 }
2136
2137 static int em28xx_dvb_suspend(struct em28xx *dev)
2138 {
2139         int ret = 0;
2140
2141         if (dev->is_audio_only)
2142                 return 0;
2143
2144         if (!dev->board.has_dvb)
2145                 return 0;
2146
2147         dev_info(&dev->intf->dev, "Suspending DVB extension\n");
2148         if (dev->dvb) {
2149                 struct em28xx_dvb *dvb = dev->dvb;
2150
2151                 if (dvb->fe[0]) {
2152                         ret = dvb_frontend_suspend(dvb->fe[0]);
2153                         dev_info(&dev->intf->dev, "fe0 suspend %d\n", ret);
2154                 }
2155                 if (dvb->fe[1]) {
2156                         dvb_frontend_suspend(dvb->fe[1]);
2157                         dev_info(&dev->intf->dev, "fe1 suspend %d\n", ret);
2158                 }
2159         }
2160
2161         return 0;
2162 }
2163
2164 static int em28xx_dvb_resume(struct em28xx *dev)
2165 {
2166         int ret = 0;
2167
2168         if (dev->is_audio_only)
2169                 return 0;
2170
2171         if (!dev->board.has_dvb)
2172                 return 0;
2173
2174         dev_info(&dev->intf->dev, "Resuming DVB extension\n");
2175         if (dev->dvb) {
2176                 struct em28xx_dvb *dvb = dev->dvb;
2177
2178                 if (dvb->fe[0]) {
2179                         ret = dvb_frontend_resume(dvb->fe[0]);
2180                         dev_info(&dev->intf->dev, "fe0 resume %d\n", ret);
2181                 }
2182
2183                 if (dvb->fe[1]) {
2184                         ret = dvb_frontend_resume(dvb->fe[1]);
2185                         dev_info(&dev->intf->dev, "fe1 resume %d\n", ret);
2186                 }
2187         }
2188
2189         return 0;
2190 }
2191
2192 static struct em28xx_ops dvb_ops = {
2193         .id   = EM28XX_DVB,
2194         .name = "Em28xx dvb Extension",
2195         .init = em28xx_dvb_init,
2196         .fini = em28xx_dvb_fini,
2197         .suspend = em28xx_dvb_suspend,
2198         .resume = em28xx_dvb_resume,
2199 };
2200
2201 static int __init em28xx_dvb_register(void)
2202 {
2203         return em28xx_register_extension(&dvb_ops);
2204 }
2205
2206 static void __exit em28xx_dvb_unregister(void)
2207 {
2208         em28xx_unregister_extension(&dvb_ops);
2209 }
2210
2211 module_init(em28xx_dvb_register);
2212 module_exit(em28xx_dvb_unregister);