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

   1 /*
   2  DVB device driver for cx231xx
   3
   4  Copyright (C) 2008 <srinivasa.deevi at conexant dot com>
   5                 Based on em28xx driver
   6
   7  This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #include "cx231xx.h"
  23 #include <linux/kernel.h>
  24 #include <linux/slab.h>
  25
  26 #include <media/v4l2-common.h>
  27 #include <media/videobuf-vmalloc.h>
  28 #include <media/tuner.h>
  29
  30 #include "xc5000.h"
  31 #include "s5h1432.h"
  32 #include "tda18271.h"
  33 #include "s5h1411.h"
  34 #include "lgdt3305.h"
  35 #include "si2165.h"
  36 #include "si2168.h"
  37 #include "mb86a20s.h"
  38 #include "si2157.h"
  39 #include "lgdt3306a.h"
  40 #include "r820t.h"
  41 #include "mn88473.h"
  42
  43 MODULE_DESCRIPTION("driver for cx231xx based DVB cards");
  44 MODULE_AUTHOR("Srinivasa Deevi <srinivasa.deevi@conexant.com>");
  45 MODULE_LICENSE("GPL");
  46
  47 static unsigned int debug;
  48 module_param(debug, int, 0644);
  49 MODULE_PARM_DESC(debug, "enable debug messages [dvb]");
  50
  51 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  52
  53 #define CX231XX_DVB_NUM_BUFS 5
  54 #define CX231XX_DVB_MAX_PACKETSIZE 564
  55 #define CX231XX_DVB_MAX_PACKETS 64
  56 #define CX231XX_DVB_MAX_FRONTENDS 2
  57
  58 struct cx231xx_dvb {
  59         struct dvb_frontend *frontend[CX231XX_DVB_MAX_FRONTENDS];
  60
  61         /* feed count management */
  62         struct mutex lock;
  63         int nfeeds;
  64
  65         /* general boilerplate stuff */
  66         struct dvb_adapter adapter;
  67         struct dvb_demux demux;
  68         struct dmxdev dmxdev;
  69         struct dmx_frontend fe_hw;
  70         struct dmx_frontend fe_mem;
  71         struct dvb_net net;
  72         struct i2c_client *i2c_client_demod[2];
  73         struct i2c_client *i2c_client_tuner;
  74 };
  75
  76 static struct s5h1432_config dvico_s5h1432_config = {
  77         .output_mode   = S5H1432_SERIAL_OUTPUT,
  78         .gpio          = S5H1432_GPIO_ON,
  79         .qam_if        = S5H1432_IF_4000,
  80         .vsb_if        = S5H1432_IF_4000,
  81         .inversion     = S5H1432_INVERSION_OFF,
  82         .status_mode   = S5H1432_DEMODLOCKING,
  83         .mpeg_timing   = S5H1432_MPEGTIMING_CONTINUOUS_NONINVERTING_CLOCK,
  84 };
  85
  86 static struct tda18271_std_map cnxt_rde253s_tda18271_std_map = {
  87         .dvbt_6   = { .if_freq = 4000, .agc_mode = 3, .std = 4,
  88                       .if_lvl = 1, .rfagc_top = 0x37, },
  89         .dvbt_7   = { .if_freq = 4000, .agc_mode = 3, .std = 5,
  90                       .if_lvl = 1, .rfagc_top = 0x37, },
  91         .dvbt_8   = { .if_freq = 4000, .agc_mode = 3, .std = 6,
  92                       .if_lvl = 1, .rfagc_top = 0x37, },
  93 };
  94
  95 static struct tda18271_std_map mb86a20s_tda18271_config = {
  96         .dvbt_6   = { .if_freq = 4000, .agc_mode = 3, .std = 4,
  97                       .if_lvl = 0, .rfagc_top = 0x37, },
  98 };
  99
 100 static struct tda18271_config cnxt_rde253s_tunerconfig = {
 101         .std_map = &cnxt_rde253s_tda18271_std_map,
 102         .gate    = TDA18271_GATE_ANALOG,
 103 };
 104
 105 static struct s5h1411_config tda18271_s5h1411_config = {
 106         .output_mode   = S5H1411_SERIAL_OUTPUT,
 107         .gpio          = S5H1411_GPIO_OFF,
 108         .vsb_if        = S5H1411_IF_3250,
 109         .qam_if        = S5H1411_IF_4000,
 110         .inversion     = S5H1411_INVERSION_ON,
 111         .status_mode   = S5H1411_DEMODLOCKING,
 112         .mpeg_timing   = S5H1411_MPEGTIMING_CONTINUOUS_NONINVERTING_CLOCK,
 113 };
 114 static struct s5h1411_config xc5000_s5h1411_config = {
 115         .output_mode   = S5H1411_SERIAL_OUTPUT,
 116         .gpio          = S5H1411_GPIO_OFF,
 117         .vsb_if        = S5H1411_IF_3250,
 118         .qam_if        = S5H1411_IF_3250,
 119         .inversion     = S5H1411_INVERSION_OFF,
 120         .status_mode   = S5H1411_DEMODLOCKING,
 121         .mpeg_timing   = S5H1411_MPEGTIMING_CONTINUOUS_NONINVERTING_CLOCK,
 122 };
 123
 124 static struct lgdt3305_config hcw_lgdt3305_config = {
 125         .i2c_addr           = 0x0e,
 126         .mpeg_mode          = LGDT3305_MPEG_SERIAL,
 127         .tpclk_edge         = LGDT3305_TPCLK_FALLING_EDGE,
 128         .tpvalid_polarity   = LGDT3305_TP_VALID_HIGH,
 129         .deny_i2c_rptr      = 1,
 130         .spectral_inversion = 1,
 131         .qam_if_khz         = 4000,
 132         .vsb_if_khz         = 3250,
 133 };
 134
 135 static struct tda18271_std_map hauppauge_tda18271_std_map = {
 136         .atsc_6   = { .if_freq = 3250, .agc_mode = 3, .std = 4,
 137                       .if_lvl = 1, .rfagc_top = 0x58, },
 138         .qam_6    = { .if_freq = 4000, .agc_mode = 3, .std = 5,
 139                       .if_lvl = 1, .rfagc_top = 0x58, },
 140 };
 141
 142 static struct tda18271_config hcw_tda18271_config = {
 143         .std_map = &hauppauge_tda18271_std_map,
 144         .gate    = TDA18271_GATE_DIGITAL,
 145 };
 146
 147 static const struct mb86a20s_config pv_mb86a20s_config = {
 148         .demod_address = 0x10,
 149         .is_serial = true,
 150 };
 151
 152 static struct tda18271_config pv_tda18271_config = {
 153         .std_map = &mb86a20s_tda18271_config,
 154         .gate    = TDA18271_GATE_DIGITAL,
 155         .small_i2c = TDA18271_03_BYTE_CHUNK_INIT,
 156 };
 157
 158 static struct lgdt3306a_config hauppauge_955q_lgdt3306a_config = {
 159         .i2c_addr           = 0x59,
 160         .qam_if_khz         = 4000,
 161         .vsb_if_khz         = 3250,
 162         .deny_i2c_rptr      = 1,
 163         .spectral_inversion = 1,
 164         .mpeg_mode          = LGDT3306A_MPEG_SERIAL,
 165         .tpclk_edge         = LGDT3306A_TPCLK_RISING_EDGE,
 166         .tpvalid_polarity   = LGDT3306A_TP_VALID_HIGH,
 167         .xtalMHz            = 25,
 168 };
 169
 170 static struct r820t_config astrometa_t2hybrid_r820t_config = {
 171         .i2c_addr               = 0x3a, /* 0x74 >> 1 */
 172         .xtal                   = 16000000,
 173         .rafael_chip            = CHIP_R828D,
 174         .max_i2c_msg_len        = 2,
 175 };
 176
 177 static inline void print_err_status(struct cx231xx *dev, int packet, int status)
 178 {
 179         char *errmsg = "Unknown";
 180
 181         switch (status) {
 182         case -ENOENT:
 183                 errmsg = "unlinked synchronously";
 184                 break;
 185         case -ECONNRESET:
 186                 errmsg = "unlinked asynchronously";
 187                 break;
 188         case -ENOSR:
 189                 errmsg = "Buffer error (overrun)";
 190                 break;
 191         case -EPIPE:
 192                 errmsg = "Stalled (device not responding)";
 193                 break;
 194         case -EOVERFLOW:
 195                 errmsg = "Babble (bad cable?)";
 196                 break;
 197         case -EPROTO:
 198                 errmsg = "Bit-stuff error (bad cable?)";
 199                 break;
 200         case -EILSEQ:
 201                 errmsg = "CRC/Timeout (could be anything)";
 202                 break;
 203         case -ETIME:
 204                 errmsg = "Device does not respond";
 205                 break;
 206         }
 207         if (packet < 0) {
 208                 dev_dbg(dev->dev,
 209                         "URB status %d [%s].\n", status, errmsg);
 210         } else {
 211                 dev_dbg(dev->dev,
 212                         "URB packet %d, status %d [%s].\n",
 213                         packet, status, errmsg);
 214         }
 215 }
 216
 217 static inline int dvb_isoc_copy(struct cx231xx *dev, struct urb *urb)
 218 {
 219         int i;
 220
 221         if (!dev)
 222                 return 0;
 223
 224         if (dev->state & DEV_DISCONNECTED)
 225                 return 0;
 226
 227         if (urb->status < 0) {
 228                 print_err_status(dev, -1, urb->status);
 229                 if (urb->status == -ENOENT)
 230                         return 0;
 231         }
 232
 233         for (i = 0; i < urb->number_of_packets; i++) {
 234                 int status = urb->iso_frame_desc[i].status;
 235
 236                 if (status < 0) {
 237                         print_err_status(dev, i, status);
 238                         if (urb->iso_frame_desc[i].status != -EPROTO)
 239                                 continue;
 240                 }
 241
 242                 dvb_dmx_swfilter(&dev->dvb->demux,
 243                                  urb->transfer_buffer +
 244                                 urb->iso_frame_desc[i].offset,
 245                                 urb->iso_frame_desc[i].actual_length);
 246         }
 247
 248         return 0;
 249 }
 250
 251 static inline int dvb_bulk_copy(struct cx231xx *dev, struct urb *urb)
 252 {
 253         if (!dev)
 254                 return 0;
 255
 256         if (dev->state & DEV_DISCONNECTED)
 257                 return 0;
 258
 259         if (urb->status < 0) {
 260                 print_err_status(dev, -1, urb->status);
 261                 if (urb->status == -ENOENT)
 262                         return 0;
 263         }
 264
 265         /* Feed the transport payload into the kernel demux */
 266         dvb_dmx_swfilter(&dev->dvb->demux,
 267                 urb->transfer_buffer, urb->actual_length);
 268
 269         return 0;
 270 }
 271
 272 static int start_streaming(struct cx231xx_dvb *dvb)
 273 {
 274         int rc;
 275         struct cx231xx *dev = dvb->adapter.priv;
 276
 277         if (dev->USE_ISO) {
 278                 dev_dbg(dev->dev, "DVB transfer mode is ISO.\n");
 279                 cx231xx_set_alt_setting(dev, INDEX_TS1, 5);
 280                 rc = cx231xx_set_mode(dev, CX231XX_DIGITAL_MODE);
 281                 if (rc < 0)
 282                         return rc;
 283                 dev->mode_tv = 1;
 284                 return cx231xx_init_isoc(dev, CX231XX_DVB_MAX_PACKETS,
 285                                         CX231XX_DVB_NUM_BUFS,
 286                                         dev->ts1_mode.max_pkt_size,
 287                                         dvb_isoc_copy);
 288         } else {
 289                 dev_dbg(dev->dev, "DVB transfer mode is BULK.\n");
 290                 cx231xx_set_alt_setting(dev, INDEX_TS1, 0);
 291                 rc = cx231xx_set_mode(dev, CX231XX_DIGITAL_MODE);
 292                 if (rc < 0)
 293                         return rc;
 294                 dev->mode_tv = 1;
 295                 return cx231xx_init_bulk(dev, CX231XX_DVB_MAX_PACKETS,
 296                                         CX231XX_DVB_NUM_BUFS,
 297                                         dev->ts1_mode.max_pkt_size,
 298                                         dvb_bulk_copy);
 299         }
 300
 301 }
 302
 303 static int stop_streaming(struct cx231xx_dvb *dvb)
 304 {
 305         struct cx231xx *dev = dvb->adapter.priv;
 306
 307         if (dev->USE_ISO)
 308                 cx231xx_uninit_isoc(dev);
 309         else
 310                 cx231xx_uninit_bulk(dev);
 311
 312         cx231xx_set_mode(dev, CX231XX_SUSPEND);
 313
 314         return 0;
 315 }
 316
 317 static int start_feed(struct dvb_demux_feed *feed)
 318 {
 319         struct dvb_demux *demux = feed->demux;
 320         struct cx231xx_dvb *dvb = demux->priv;
 321         int rc, ret;
 322
 323         if (!demux->dmx.frontend)
 324                 return -EINVAL;
 325
 326         mutex_lock(&dvb->lock);
 327         dvb->nfeeds++;
 328         rc = dvb->nfeeds;
 329
 330         if (dvb->nfeeds == 1) {
 331                 ret = start_streaming(dvb);
 332                 if (ret < 0)
 333                         rc = ret;
 334         }
 335
 336         mutex_unlock(&dvb->lock);
 337         return rc;
 338 }
 339
 340 static int stop_feed(struct dvb_demux_feed *feed)
 341 {
 342         struct dvb_demux *demux = feed->demux;
 343         struct cx231xx_dvb *dvb = demux->priv;
 344         int err = 0;
 345
 346         mutex_lock(&dvb->lock);
 347         dvb->nfeeds--;
 348
 349         if (0 == dvb->nfeeds)
 350                 err = stop_streaming(dvb);
 351
 352         mutex_unlock(&dvb->lock);
 353         return err;
 354 }
 355
 356 /* ------------------------------------------------------------------ */
 357 static int cx231xx_dvb_bus_ctrl(struct dvb_frontend *fe, int acquire)
 358 {
 359         struct cx231xx *dev = fe->dvb->priv;
 360
 361         if (acquire)
 362                 return cx231xx_set_mode(dev, CX231XX_DIGITAL_MODE);
 363         else
 364                 return cx231xx_set_mode(dev, CX231XX_SUSPEND);
 365 }
 366
 367 /* ------------------------------------------------------------------ */
 368
 369 static struct xc5000_config cnxt_rde250_tunerconfig = {
 370         .i2c_address = 0x61,
 371         .if_khz = 4000,
 372 };
 373 static struct xc5000_config cnxt_rdu250_tunerconfig = {
 374         .i2c_address = 0x61,
 375         .if_khz = 3250,
 376 };
 377
 378 /* ------------------------------------------------------------------ */
 379 #if 0
 380 static int attach_xc5000(u8 addr, struct cx231xx *dev)
 381 {
 382
 383         struct dvb_frontend *fe;
 384         struct xc5000_config cfg;
 385
 386         memset(&cfg, 0, sizeof(cfg));
 387         cfg.i2c_adap = cx231xx_get_i2c_adap(dev, dev->board.tuner_i2c_master);
 388         cfg.i2c_addr = addr;
 389
 390         if (!dev->dvb->frontend[0]) {
 391                 dev_err(dev->dev, "%s/2: dvb frontend not attached. Can't attach xc5000\n",
 392                         dev->name);
 393                 return -EINVAL;
 394         }
 395
 396         fe = dvb_attach(xc5000_attach, dev->dvb->frontend[0], &cfg);
 397         if (!fe) {
 398                 dev_err(dev->dev, "%s/2: xc5000 attach failed\n", dev->name);
 399                 dvb_frontend_detach(dev->dvb->frontend[0]);
 400                 dev->dvb->frontend[0] = NULL;
 401                 return -EINVAL;
 402         }
 403
 404         dev_info(dev->dev, "%s/2: xc5000 attached\n", dev->name);
 405
 406         return 0;
 407 }
 408 #endif
 409
 410 int cx231xx_set_analog_freq(struct cx231xx *dev, u32 freq)
 411 {
 412         if (dev->dvb && dev->dvb->frontend[0]) {
 413
 414                 struct dvb_tuner_ops *dops = &dev->dvb->frontend[0]->ops.tuner_ops;
 415
 416                 if (dops->set_analog_params != NULL) {
 417                         struct analog_parameters params;
 418
 419                         params.frequency = freq;
 420                         params.std = dev->norm;
 421                         params.mode = 0;        /* 0- Air; 1 - cable */
 422                         /*params.audmode = ;       */
 423
 424                         /* Set the analog parameters to set the frequency */
 425                         dops->set_analog_params(dev->dvb->frontend[0], &params);
 426                 }
 427
 428         }
 429
 430         return 0;
 431 }
 432
 433 int cx231xx_reset_analog_tuner(struct cx231xx *dev)
 434 {
 435         int status = 0;
 436
 437         if (dev->dvb && dev->dvb->frontend[0]) {
 438
 439                 struct dvb_tuner_ops *dops = &dev->dvb->frontend[0]->ops.tuner_ops;
 440
 441                 if (dops->init != NULL && !dev->xc_fw_load_done) {
 442
 443                         dev_dbg(dev->dev,
 444                                 "Reloading firmware for XC5000\n");
 445                         status = dops->init(dev->dvb->frontend[0]);
 446                         if (status == 0) {
 447                                 dev->xc_fw_load_done = 1;
 448                                 dev_dbg(dev->dev,
 449                                         "XC5000 firmware download completed\n");
 450                         } else {
 451                                 dev->xc_fw_load_done = 0;
 452                                 dev_dbg(dev->dev,
 453                                         "XC5000 firmware download failed !!!\n");
 454                         }
 455                 }
 456
 457         }
 458
 459         return status;
 460 }
 461
 462 /* ------------------------------------------------------------------ */
 463
 464 static int register_dvb(struct cx231xx_dvb *dvb,
 465                         struct module *module,
 466                         struct cx231xx *dev, struct device *device)
 467 {
 468         int result;
 469
 470         mutex_init(&dvb->lock);
 471
 472
 473         /* register adapter */
 474         result = dvb_register_adapter(&dvb->adapter, dev->name, module, device,
 475                                       adapter_nr);
 476         if (result < 0) {
 477                 dev_warn(dev->dev,
 478                        "%s: dvb_register_adapter failed (errno = %d)\n",
 479                        dev->name, result);
 480                 goto fail_adapter;
 481         }
 482         dvb_register_media_controller(&dvb->adapter, dev->media_dev);
 483
 484         /* Ensure all frontends negotiate bus access */
 485         dvb->frontend[0]->ops.ts_bus_ctrl = cx231xx_dvb_bus_ctrl;
 486         if (dvb->frontend[1])
 487                 dvb->frontend[1]->ops.ts_bus_ctrl = cx231xx_dvb_bus_ctrl;
 488
 489         dvb->adapter.priv = dev;
 490
 491         /* register frontend */
 492         result = dvb_register_frontend(&dvb->adapter, dvb->frontend[0]);
 493         if (result < 0) {
 494                 dev_warn(dev->dev,
 495                        "%s: dvb_register_frontend failed (errno = %d)\n",
 496                        dev->name, result);
 497                 goto fail_frontend0;
 498         }
 499
 500         if (dvb->frontend[1]) {
 501                 result = dvb_register_frontend(&dvb->adapter, dvb->frontend[1]);
 502                 if (result < 0) {
 503                         dev_warn(dev->dev,
 504                                  "%s: 2nd dvb_register_frontend failed (errno = %d)\n",
 505                                 dev->name, result);
 506                         goto fail_frontend1;
 507                 }
 508
 509                 /* MFE lock */
 510                 dvb->adapter.mfe_shared = 1;
 511         }
 512
 513         /* register demux stuff */
 514         dvb->demux.dmx.capabilities =
 515             DMX_TS_FILTERING | DMX_SECTION_FILTERING |
 516             DMX_MEMORY_BASED_FILTERING;
 517         dvb->demux.priv = dvb;
 518         dvb->demux.filternum = 256;
 519         dvb->demux.feednum = 256;
 520         dvb->demux.start_feed = start_feed;
 521         dvb->demux.stop_feed = stop_feed;
 522
 523         result = dvb_dmx_init(&dvb->demux);
 524         if (result < 0) {
 525                 dev_warn(dev->dev,
 526                          "%s: dvb_dmx_init failed (errno = %d)\n",
 527                        dev->name, result);
 528                 goto fail_dmx;
 529         }
 530
 531         dvb->dmxdev.filternum = 256;
 532         dvb->dmxdev.demux = &dvb->demux.dmx;
 533         dvb->dmxdev.capabilities = 0;
 534         result = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter);
 535         if (result < 0) {
 536                 dev_warn(dev->dev,
 537                          "%s: dvb_dmxdev_init failed (errno = %d)\n",
 538                          dev->name, result);
 539                 goto fail_dmxdev;
 540         }
 541
 542         dvb->fe_hw.source = DMX_FRONTEND_0;
 543         result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 544         if (result < 0) {
 545                 dev_warn(dev->dev,
 546                        "%s: add_frontend failed (DMX_FRONTEND_0, errno = %d)\n",
 547                        dev->name, result);
 548                 goto fail_fe_hw;
 549         }
 550
 551         dvb->fe_mem.source = DMX_MEMORY_FE;
 552         result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_mem);
 553         if (result < 0) {
 554                 dev_warn(dev->dev,
 555                          "%s: add_frontend failed (DMX_MEMORY_FE, errno = %d)\n",
 556                          dev->name, result);
 557                 goto fail_fe_mem;
 558         }
 559
 560         result = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 561         if (result < 0) {
 562                 dev_warn(dev->dev,
 563                          "%s: connect_frontend failed (errno = %d)\n",
 564                          dev->name, result);
 565                 goto fail_fe_conn;
 566         }
 567
 568         /* register network adapter */
 569         dvb_net_init(&dvb->adapter, &dvb->net, &dvb->demux.dmx);
 570         result = dvb_create_media_graph(&dvb->adapter,
 571                                         dev->tuner_type == TUNER_ABSENT);
 572         if (result < 0)
 573                 goto fail_create_graph;
 574
 575         return 0;
 576
 577 fail_create_graph:
 578         dvb_net_release(&dvb->net);
 579 fail_fe_conn:
 580         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
 581 fail_fe_mem:
 582         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 583 fail_fe_hw:
 584         dvb_dmxdev_release(&dvb->dmxdev);
 585 fail_dmxdev:
 586         dvb_dmx_release(&dvb->demux);
 587 fail_dmx:
 588         if (dvb->frontend[1])
 589                 dvb_unregister_frontend(dvb->frontend[1]);
 590         dvb_unregister_frontend(dvb->frontend[0]);
 591 fail_frontend1:
 592         if (dvb->frontend[1])
 593                 dvb_frontend_detach(dvb->frontend[1]);
 594 fail_frontend0:
 595         dvb_frontend_detach(dvb->frontend[0]);
 596         dvb_unregister_adapter(&dvb->adapter);
 597 fail_adapter:
 598         return result;
 599 }
 600
 601 static void unregister_dvb(struct cx231xx_dvb *dvb)
 602 {
 603         struct i2c_client *client;
 604         dvb_net_release(&dvb->net);
 605         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
 606         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 607         dvb_dmxdev_release(&dvb->dmxdev);
 608         dvb_dmx_release(&dvb->demux);
 609         if (dvb->frontend[1])
 610                 dvb_unregister_frontend(dvb->frontend[1]);
 611         dvb_unregister_frontend(dvb->frontend[0]);
 612         if (dvb->frontend[1])
 613                 dvb_frontend_detach(dvb->frontend[1]);
 614         dvb_frontend_detach(dvb->frontend[0]);
 615         dvb_unregister_adapter(&dvb->adapter);
 616         /* remove I2C tuner */
 617         client = dvb->i2c_client_tuner;
 618         if (client) {
 619                 module_put(client->dev.driver->owner);
 620                 i2c_unregister_device(client);
 621         }
 622         /* remove I2C demod */
 623         client = dvb->i2c_client_demod[1];
 624         if (client) {
 625                 module_put(client->dev.driver->owner);
 626                 i2c_unregister_device(client);
 627         }
 628         client = dvb->i2c_client_demod[0];
 629         if (client) {
 630                 module_put(client->dev.driver->owner);
 631                 i2c_unregister_device(client);
 632         }
 633 }
 634
 635 static int dvb_init(struct cx231xx *dev)
 636 {
 637         int result;
 638         struct cx231xx_dvb *dvb;
 639         struct i2c_adapter *tuner_i2c;
 640         struct i2c_adapter *demod_i2c;
 641
 642         if (!dev->board.has_dvb) {
 643                 /* This device does not support the extension */
 644                 return 0;
 645         }
 646
 647         dvb = kzalloc(sizeof(struct cx231xx_dvb), GFP_KERNEL);
 648
 649         if (dvb == NULL) {
 650                 dev_info(dev->dev,
 651                          "cx231xx_dvb: memory allocation failed\n");
 652                 return -ENOMEM;
 653         }
 654         dev->dvb = dvb;
 655         dev->cx231xx_set_analog_freq = cx231xx_set_analog_freq;
 656         dev->cx231xx_reset_analog_tuner = cx231xx_reset_analog_tuner;
 657
 658         tuner_i2c = cx231xx_get_i2c_adap(dev, dev->board.tuner_i2c_master);
 659         demod_i2c = cx231xx_get_i2c_adap(dev, dev->board.demod_i2c_master);
 660         mutex_lock(&dev->lock);
 661         cx231xx_set_mode(dev, CX231XX_DIGITAL_MODE);
 662         cx231xx_demod_reset(dev);
 663         /* init frontend */
 664         switch (dev->model) {
 665         case CX231XX_BOARD_CNXT_CARRAERA:
 666         case CX231XX_BOARD_CNXT_RDE_250:
 667
 668                 dev->dvb->frontend[0] = dvb_attach(s5h1432_attach,
 669                                         &dvico_s5h1432_config,
 670                                         demod_i2c);
 671
 672                 if (!dev->dvb->frontend[0]) {
 673                         dev_err(dev->dev,
 674                                 "Failed to attach s5h1432 front end\n");
 675                         result = -EINVAL;
 676                         goto out_free;
 677                 }
 678
 679                 /* define general-purpose callback pointer */
 680                 dvb->frontend[0]->callback = cx231xx_tuner_callback;
 681
 682                 if (!dvb_attach(xc5000_attach, dev->dvb->frontend[0],
 683                                tuner_i2c,
 684                                &cnxt_rde250_tunerconfig)) {
 685                         result = -EINVAL;
 686                         goto out_free;
 687                 }
 688
 689                 break;
 690         case CX231XX_BOARD_CNXT_SHELBY:
 691         case CX231XX_BOARD_CNXT_RDU_250:
 692
 693                 dev->dvb->frontend[0] = dvb_attach(s5h1411_attach,
 694                                                &xc5000_s5h1411_config,
 695                                                demod_i2c);
 696
 697                 if (!dev->dvb->frontend[0]) {
 698                         dev_err(dev->dev,
 699                                 "Failed to attach s5h1411 front end\n");
 700                         result = -EINVAL;
 701                         goto out_free;
 702                 }
 703
 704                 /* define general-purpose callback pointer */
 705                 dvb->frontend[0]->callback = cx231xx_tuner_callback;
 706
 707                 if (!dvb_attach(xc5000_attach, dev->dvb->frontend[0],
 708                                tuner_i2c,
 709                                &cnxt_rdu250_tunerconfig)) {
 710                         result = -EINVAL;
 711                         goto out_free;
 712                 }
 713                 break;
 714         case CX231XX_BOARD_CNXT_RDE_253S:
 715
 716                 dev->dvb->frontend[0] = dvb_attach(s5h1432_attach,
 717                                         &dvico_s5h1432_config,
 718                                         demod_i2c);
 719
 720                 if (!dev->dvb->frontend[0]) {
 721                         dev_err(dev->dev,
 722                                 "Failed to attach s5h1432 front end\n");
 723                         result = -EINVAL;
 724                         goto out_free;
 725                 }
 726
 727                 /* define general-purpose callback pointer */
 728                 dvb->frontend[0]->callback = cx231xx_tuner_callback;
 729
 730                 if (!dvb_attach(tda18271_attach, dev->dvb->frontend[0],
 731                                0x60, tuner_i2c,
 732                                &cnxt_rde253s_tunerconfig)) {
 733                         result = -EINVAL;
 734                         goto out_free;
 735                 }
 736                 break;
 737         case CX231XX_BOARD_CNXT_RDU_253S:
 738         case CX231XX_BOARD_KWORLD_UB445_USB_HYBRID:
 739
 740                 dev->dvb->frontend[0] = dvb_attach(s5h1411_attach,
 741                                                &tda18271_s5h1411_config,
 742                                                demod_i2c);
 743
 744                 if (!dev->dvb->frontend[0]) {
 745                         dev_err(dev->dev,
 746                                 "Failed to attach s5h1411 front end\n");
 747                         result = -EINVAL;
 748                         goto out_free;
 749                 }
 750
 751                 /* define general-purpose callback pointer */
 752                 dvb->frontend[0]->callback = cx231xx_tuner_callback;
 753
 754                 if (!dvb_attach(tda18271_attach, dev->dvb->frontend[0],
 755                                0x60, tuner_i2c,
 756                                &cnxt_rde253s_tunerconfig)) {
 757                         result = -EINVAL;
 758                         goto out_free;
 759                 }
 760                 break;
 761         case CX231XX_BOARD_HAUPPAUGE_EXETER:
 762
 763                 dev_info(dev->dev,
 764                          "%s: looking for tuner / demod on i2c bus: %d\n",
 765                        __func__, i2c_adapter_id(tuner_i2c));
 766
 767                 dev->dvb->frontend[0] = dvb_attach(lgdt3305_attach,
 768                                                 &hcw_lgdt3305_config,
 769                                                 demod_i2c);
 770
 771                 if (!dev->dvb->frontend[0]) {
 772                         dev_err(dev->dev,
 773                                 "Failed to attach LG3305 front end\n");
 774                         result = -EINVAL;
 775                         goto out_free;
 776                 }
 777
 778                 /* define general-purpose callback pointer */
 779                 dvb->frontend[0]->callback = cx231xx_tuner_callback;
 780
 781                 dvb_attach(tda18271_attach, dev->dvb->frontend[0],
 782                            0x60, tuner_i2c,
 783                            &hcw_tda18271_config);
 784                 break;
 785
 786         case CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx:
 787         {
 788                 struct i2c_client *client;
 789                 struct i2c_board_info info;
 790                 struct si2165_platform_data si2165_pdata;
 791
 792                 /* attach demod */
 793                 memset(&si2165_pdata, 0, sizeof(si2165_pdata));
 794                 si2165_pdata.fe = &dev->dvb->frontend[0];
 795                 si2165_pdata.chip_mode = SI2165_MODE_PLL_XTAL;
 796                 si2165_pdata.ref_freq_hz = 16000000;
 797
 798                 memset(&info, 0, sizeof(struct i2c_board_info));
 799                 strlcpy(info.type, "si2165", I2C_NAME_SIZE);
 800                 info.addr = 0x64;
 801                 info.platform_data = &si2165_pdata;
 802                 request_module(info.type);
 803                 client = i2c_new_device(demod_i2c, &info);
 804                 if (!client || !client->dev.driver || !dev->dvb->frontend[0]) {
 805                         dev_err(dev->dev,
 806                                 "Failed to attach SI2165 front end\n");
 807                         result = -EINVAL;
 808                         goto out_free;
 809                 }
 810
 811                 if (!try_module_get(client->dev.driver->owner)) {
 812                         i2c_unregister_device(client);
 813                         result = -ENODEV;
 814                         goto out_free;
 815                 }
 816
 817                 dvb->i2c_client_demod[0] = client;
 818
 819                 dev->dvb->frontend[0]->ops.i2c_gate_ctrl = NULL;
 820
 821                 /* define general-purpose callback pointer */
 822                 dvb->frontend[0]->callback = cx231xx_tuner_callback;
 823
 824                 dvb_attach(tda18271_attach, dev->dvb->frontend[0],
 825                         0x60,
 826                         tuner_i2c,
 827                         &hcw_tda18271_config);
 828
 829                 dev->cx231xx_reset_analog_tuner = NULL;
 830                 break;
 831         }
 832         case CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx:
 833         {
 834                 struct i2c_client *client;
 835                 struct i2c_board_info info;
 836                 struct si2165_platform_data si2165_pdata;
 837                 struct si2157_config si2157_config;
 838
 839                 /* attach demod */
 840                 memset(&si2165_pdata, 0, sizeof(si2165_pdata));
 841                 si2165_pdata.fe = &dev->dvb->frontend[0];
 842                 si2165_pdata.chip_mode = SI2165_MODE_PLL_EXT;
 843                 si2165_pdata.ref_freq_hz = 24000000;
 844
 845                 memset(&info, 0, sizeof(struct i2c_board_info));
 846                 strlcpy(info.type, "si2165", I2C_NAME_SIZE);
 847                 info.addr = 0x64;
 848                 info.platform_data = &si2165_pdata;
 849                 request_module(info.type);
 850                 client = i2c_new_device(demod_i2c, &info);
 851                 if (!client || !client->dev.driver || !dev->dvb->frontend[0]) {
 852                         dev_err(dev->dev,
 853                                 "Failed to attach SI2165 front end\n");
 854                         result = -EINVAL;
 855                         goto out_free;
 856                 }
 857
 858                 if (!try_module_get(client->dev.driver->owner)) {
 859                         i2c_unregister_device(client);
 860                         result = -ENODEV;
 861                         goto out_free;
 862                 }
 863
 864                 dvb->i2c_client_demod[0] = client;
 865
 866                 memset(&info, 0, sizeof(struct i2c_board_info));
 867
 868                 dev->dvb->frontend[0]->ops.i2c_gate_ctrl = NULL;
 869
 870                 /* define general-purpose callback pointer */
 871                 dvb->frontend[0]->callback = cx231xx_tuner_callback;
 872
 873                 /* attach tuner */
 874                 memset(&si2157_config, 0, sizeof(si2157_config));
 875                 si2157_config.fe = dev->dvb->frontend[0];
 876 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
 877                 si2157_config.mdev = dev->media_dev;
 878 #endif
 879                 si2157_config.if_port = 1;
 880                 si2157_config.inversion = true;
 881                 strlcpy(info.type, "si2157", I2C_NAME_SIZE);
 882                 info.addr = 0x60;
 883                 info.platform_data = &si2157_config;
 884                 request_module("si2157");
 885
 886                 client = i2c_new_device(
 887                         tuner_i2c,
 888                         &info);
 889                 if (client == NULL || client->dev.driver == NULL) {
 890                         dvb_frontend_detach(dev->dvb->frontend[0]);
 891                         result = -ENODEV;
 892                         goto out_free;
 893                 }
 894
 895                 if (!try_module_get(client->dev.driver->owner)) {
 896                         i2c_unregister_device(client);
 897                         dvb_frontend_detach(dev->dvb->frontend[0]);
 898                         result = -ENODEV;
 899                         goto out_free;
 900                 }
 901
 902                 dev->cx231xx_reset_analog_tuner = NULL;
 903
 904                 dev->dvb->i2c_client_tuner = client;
 905                 break;
 906         }
 907         case CX231XX_BOARD_HAUPPAUGE_955Q:
 908         {
 909                 struct i2c_client *client;
 910                 struct i2c_board_info info;
 911                 struct si2157_config si2157_config;
 912
 913                 memset(&info, 0, sizeof(struct i2c_board_info));
 914
 915                 dev->dvb->frontend[0] = dvb_attach(lgdt3306a_attach,
 916                         &hauppauge_955q_lgdt3306a_config,
 917                         demod_i2c
 918                         );
 919
 920                 if (!dev->dvb->frontend[0]) {
 921                         dev_err(dev->dev,
 922                                 "Failed to attach LGDT3306A frontend.\n");
 923                         result = -EINVAL;
 924                         goto out_free;
 925                 }
 926
 927                 dev->dvb->frontend[0]->ops.i2c_gate_ctrl = NULL;
 928
 929                 /* define general-purpose callback pointer */
 930                 dvb->frontend[0]->callback = cx231xx_tuner_callback;
 931
 932                 /* attach tuner */
 933                 memset(&si2157_config, 0, sizeof(si2157_config));
 934                 si2157_config.fe = dev->dvb->frontend[0];
 935 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
 936                 si2157_config.mdev = dev->media_dev;
 937 #endif
 938                 si2157_config.if_port = 1;
 939                 si2157_config.inversion = true;
 940                 strlcpy(info.type, "si2157", I2C_NAME_SIZE);
 941                 info.addr = 0x60;
 942                 info.platform_data = &si2157_config;
 943                 request_module("si2157");
 944
 945                 client = i2c_new_device(
 946                         tuner_i2c,
 947                         &info);
 948                 if (client == NULL || client->dev.driver == NULL) {
 949                         dvb_frontend_detach(dev->dvb->frontend[0]);
 950                         result = -ENODEV;
 951                         goto out_free;
 952                 }
 953
 954                 if (!try_module_get(client->dev.driver->owner)) {
 955                         i2c_unregister_device(client);
 956                         dvb_frontend_detach(dev->dvb->frontend[0]);
 957                         result = -ENODEV;
 958                         goto out_free;
 959                 }
 960
 961                 dev->cx231xx_reset_analog_tuner = NULL;
 962
 963                 dev->dvb->i2c_client_tuner = client;
 964                 break;
 965         }
 966         case CX231XX_BOARD_PV_PLAYTV_USB_HYBRID:
 967         case CX231XX_BOARD_KWORLD_UB430_USB_HYBRID:
 968
 969                 dev_info(dev->dev,
 970                          "%s: looking for demod on i2c bus: %d\n",
 971                          __func__, i2c_adapter_id(tuner_i2c));
 972
 973                 dev->dvb->frontend[0] = dvb_attach(mb86a20s_attach,
 974                                                 &pv_mb86a20s_config,
 975                                                 demod_i2c);
 976
 977                 if (!dev->dvb->frontend[0]) {
 978                         dev_err(dev->dev,
 979                                 "Failed to attach mb86a20s demod\n");
 980                         result = -EINVAL;
 981                         goto out_free;
 982                 }
 983
 984                 /* define general-purpose callback pointer */
 985                 dvb->frontend[0]->callback = cx231xx_tuner_callback;
 986
 987                 dvb_attach(tda18271_attach, dev->dvb->frontend[0],
 988                            0x60, tuner_i2c,
 989                            &pv_tda18271_config);
 990                 break;
 991
 992         case CX231XX_BOARD_EVROMEDIA_FULL_HYBRID_FULLHD:
 993         {
 994                 struct si2157_config si2157_config = {};
 995                 struct si2168_config si2168_config = {};
 996                 struct i2c_board_info info = {};
 997                 struct i2c_client *client;
 998                 struct i2c_adapter *adapter;
 999
1000                 /* attach demodulator chip */
1001                 si2168_config.ts_mode = SI2168_TS_SERIAL; /* from *.inf file */
1002                 si2168_config.fe = &dev->dvb->frontend[0];
1003                 si2168_config.i2c_adapter = &adapter;
1004                 si2168_config.ts_clock_inv = true;
1005
1006                 strlcpy(info.type, "si2168", sizeof(info.type));
1007                 info.addr = dev->board.demod_addr;
1008                 info.platform_data = &si2168_config;
1009
1010                 request_module(info.type);
1011                 client = i2c_new_device(demod_i2c, &info);
1012
1013                 if (client == NULL || client->dev.driver == NULL) {
1014                         result = -ENODEV;
1015                         goto out_free;
1016                 }
1017
1018                 if (!try_module_get(client->dev.driver->owner)) {
1019                         i2c_unregister_device(client);
1020                         result = -ENODEV;
1021                         goto out_free;
1022                 }
1023
1024                 dvb->i2c_client_demod[0] = client;
1025
1026                 /* attach tuner chip */
1027                 si2157_config.fe = dev->dvb->frontend[0];
1028 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
1029                 si2157_config.mdev = dev->media_dev;
1030 #endif
1031                 si2157_config.if_port = 1;
1032                 si2157_config.inversion = false;
1033
1034                 memset(&info, 0, sizeof(info));
1035                 strlcpy(info.type, "si2157", sizeof(info.type));
1036                 info.addr = dev->board.tuner_addr;
1037                 info.platform_data = &si2157_config;
1038
1039                 request_module(info.type);
1040                 client = i2c_new_device(tuner_i2c, &info);
1041
1042                 if (client == NULL || client->dev.driver == NULL) {
1043                         module_put(dvb->i2c_client_demod[0]->dev.driver->owner);
1044                         i2c_unregister_device(dvb->i2c_client_demod[0]);
1045                         result = -ENODEV;
1046                         goto out_free;
1047                 }
1048
1049                 if (!try_module_get(client->dev.driver->owner)) {
1050                         i2c_unregister_device(client);
1051                         module_put(dvb->i2c_client_demod[0]->dev.driver->owner);
1052                         i2c_unregister_device(dvb->i2c_client_demod[0]);
1053                         result = -ENODEV;
1054                         goto out_free;
1055                 }
1056
1057                 dev->cx231xx_reset_analog_tuner = NULL;
1058                 dev->dvb->i2c_client_tuner = client;
1059                 break;
1060         }
1061         case CX231XX_BOARD_ASTROMETA_T2HYBRID:
1062         {
1063                 struct i2c_client *client;
1064                 struct i2c_board_info info = {};
1065                 struct mn88473_config mn88473_config = {};
1066
1067                 /* attach demodulator chip */
1068                 mn88473_config.i2c_wr_max = 16;
1069                 mn88473_config.xtal = 25000000;
1070                 mn88473_config.fe = &dev->dvb->frontend[0];
1071
1072                 strlcpy(info.type, "mn88473", sizeof(info.type));
1073                 info.addr = dev->board.demod_addr;
1074                 info.platform_data = &mn88473_config;
1075
1076                 request_module(info.type);
1077                 client = i2c_new_device(demod_i2c, &info);
1078
1079                 if (client == NULL || client->dev.driver == NULL) {
1080                         result = -ENODEV;
1081                         goto out_free;
1082                 }
1083
1084                 if (!try_module_get(client->dev.driver->owner)) {
1085                         i2c_unregister_device(client);
1086                         result = -ENODEV;
1087                         goto out_free;
1088                 }
1089
1090                 dvb->i2c_client_demod[0] = client;
1091
1092                 /* define general-purpose callback pointer */
1093                 dvb->frontend[0]->callback = cx231xx_tuner_callback;
1094
1095                 /* attach tuner chip */
1096                 dvb_attach(r820t_attach, dev->dvb->frontend[0],
1097                            tuner_i2c,
1098                            &astrometa_t2hybrid_r820t_config);
1099                 break;
1100         }
1101         case CX231XX_BOARD_HAUPPAUGE_935C:
1102         {
1103                 struct i2c_client *client;
1104                 struct i2c_adapter *adapter;
1105                 struct i2c_board_info info = {};
1106                 struct si2157_config si2157_config = {};
1107                 struct si2168_config si2168_config = {};
1108
1109                 /* attach demodulator chip */
1110                 si2168_config.ts_mode = SI2168_TS_SERIAL;
1111                 si2168_config.fe = &dev->dvb->frontend[0];
1112                 si2168_config.i2c_adapter = &adapter;
1113                 si2168_config.ts_clock_inv = true;
1114
1115                 strlcpy(info.type, "si2168", sizeof(info.type));
1116                 info.addr = dev->board.demod_addr;
1117                 info.platform_data = &si2168_config;
1118
1119                 request_module(info.type);
1120                 client = i2c_new_device(demod_i2c, &info);
1121                 if (client == NULL || client->dev.driver == NULL) {
1122                         result = -ENODEV;
1123                         goto out_free;
1124                 }
1125
1126                 if (!try_module_get(client->dev.driver->owner)) {
1127                         dev_err(dev->dev,
1128                                 "Failed to attach %s frontend.\n", info.type);
1129                         i2c_unregister_device(client);
1130                         result = -ENODEV;
1131                         goto out_free;
1132                 }
1133
1134                 dvb->i2c_client_demod[0] = client;
1135                 dev->dvb->frontend[0]->ops.i2c_gate_ctrl = NULL;
1136
1137                 /* define general-purpose callback pointer */
1138                 dvb->frontend[0]->callback = cx231xx_tuner_callback;
1139
1140                 /* attach tuner */
1141                 si2157_config.fe = dev->dvb->frontend[0];
1142 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
1143                 si2157_config.mdev = dev->media_dev;
1144 #endif
1145                 si2157_config.if_port = 1;
1146                 si2157_config.inversion = true;
1147
1148                 memset(&info, 0, sizeof(struct i2c_board_info));
1149                 strlcpy(info.type, "si2157", I2C_NAME_SIZE);
1150                 info.addr = dev->board.tuner_addr;
1151                 info.platform_data = &si2157_config;
1152                 request_module("si2157");
1153
1154                 client = i2c_new_device(adapter, &info);
1155                 if (client == NULL || client->dev.driver == NULL) {
1156                         module_put(dvb->i2c_client_demod[0]->dev.driver->owner);
1157                         i2c_unregister_device(dvb->i2c_client_demod[0]);
1158                         result = -ENODEV;
1159                         goto out_free;
1160                 }
1161
1162                 if (!try_module_get(client->dev.driver->owner)) {
1163                         dev_err(dev->dev,
1164                                 "Failed to obtain %s tuner.\n", info.type);
1165                         i2c_unregister_device(client);
1166                         module_put(dvb->i2c_client_demod[0]->dev.driver->owner);
1167                         i2c_unregister_device(dvb->i2c_client_demod[0]);
1168                         result = -ENODEV;
1169                         goto out_free;
1170                 }
1171
1172                 dev->cx231xx_reset_analog_tuner = NULL;
1173                 dev->dvb->i2c_client_tuner = client;
1174                 break;
1175         }
1176         case CX231XX_BOARD_HAUPPAUGE_975:
1177         {
1178                 struct i2c_client *client;
1179                 struct i2c_adapter *adapter;
1180                 struct i2c_adapter *adapter2;
1181                 struct i2c_board_info info = {};
1182                 struct si2157_config si2157_config = {};
1183                 struct lgdt3306a_config lgdt3306a_config = {};
1184                 struct si2168_config si2168_config = {};
1185
1186                 /* attach first demodulator chip */
1187                 lgdt3306a_config = hauppauge_955q_lgdt3306a_config;
1188                 lgdt3306a_config.fe = &dev->dvb->frontend[0];
1189                 lgdt3306a_config.i2c_adapter = &adapter;
1190                 lgdt3306a_config.deny_i2c_rptr = 0;
1191
1192                 strlcpy(info.type, "lgdt3306a", sizeof(info.type));
1193                 info.addr = dev->board.demod_addr;
1194                 info.platform_data = &lgdt3306a_config;
1195
1196                 request_module(info.type);
1197                 client = i2c_new_device(demod_i2c, &info);
1198                 if (client == NULL || client->dev.driver == NULL) {
1199                         result = -ENODEV;
1200                         goto out_free;
1201                 }
1202
1203                 if (!try_module_get(client->dev.driver->owner)) {
1204                         dev_err(dev->dev,
1205                                 "Failed to attach %s frontend.\n", info.type);
1206                         i2c_unregister_device(client);
1207                         result = -ENODEV;
1208                         goto out_free;
1209                 }
1210
1211                 dvb->i2c_client_demod[0] = client;
1212
1213                 /* attach second demodulator chip */
1214                 si2168_config.ts_mode = SI2168_TS_SERIAL;
1215                 si2168_config.fe = &dev->dvb->frontend[1];
1216                 si2168_config.i2c_adapter = &adapter2;
1217                 si2168_config.ts_clock_inv = true;
1218
1219                 memset(&info, 0, sizeof(struct i2c_board_info));
1220                 strlcpy(info.type, "si2168", sizeof(info.type));
1221                 info.addr = dev->board.demod_addr2;
1222                 info.platform_data = &si2168_config;
1223
1224                 request_module(info.type);
1225                 client = i2c_new_device(adapter, &info);
1226                 if (client == NULL || client->dev.driver == NULL) {
1227                         dev_err(dev->dev,
1228                                 "Failed to attach %s frontend.\n", info.type);
1229                         module_put(dvb->i2c_client_demod[0]->dev.driver->owner);
1230                         i2c_unregister_device(dvb->i2c_client_demod[0]);
1231                         result = -ENODEV;
1232                         goto out_free;
1233                 }
1234
1235                 if (!try_module_get(client->dev.driver->owner)) {
1236                         i2c_unregister_device(client);
1237                         module_put(dvb->i2c_client_demod[0]->dev.driver->owner);
1238                         i2c_unregister_device(dvb->i2c_client_demod[0]);
1239                         result = -ENODEV;
1240                         goto out_free;
1241                 }
1242
1243                 dvb->i2c_client_demod[1] = client;
1244                 dvb->frontend[1]->id = 1;
1245
1246                 /* define general-purpose callback pointer */
1247                 dvb->frontend[0]->callback = cx231xx_tuner_callback;
1248                 dvb->frontend[1]->callback = cx231xx_tuner_callback;
1249
1250                 /* attach tuner */
1251                 si2157_config.fe = dev->dvb->frontend[0];
1252 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
1253                 si2157_config.mdev = dev->media_dev;
1254 #endif
1255                 si2157_config.if_port = 1;
1256                 si2157_config.inversion = true;
1257
1258                 memset(&info, 0, sizeof(struct i2c_board_info));
1259                 strlcpy(info.type, "si2157", I2C_NAME_SIZE);
1260                 info.addr = dev->board.tuner_addr;
1261                 info.platform_data = &si2157_config;
1262                 request_module("si2157");
1263
1264                 client = i2c_new_device(adapter, &info);
1265                 if (client == NULL || client->dev.driver == NULL) {
1266                         module_put(dvb->i2c_client_demod[1]->dev.driver->owner);
1267                         i2c_unregister_device(dvb->i2c_client_demod[1]);
1268                         module_put(dvb->i2c_client_demod[0]->dev.driver->owner);
1269                         i2c_unregister_device(dvb->i2c_client_demod[0]);
1270                         result = -ENODEV;
1271                         goto out_free;
1272                 }
1273
1274                 if (!try_module_get(client->dev.driver->owner)) {
1275                         dev_err(dev->dev,
1276                                 "Failed to obtain %s tuner.\n", info.type);
1277                         i2c_unregister_device(client);
1278                         module_put(dvb->i2c_client_demod[1]->dev.driver->owner);
1279                         i2c_unregister_device(dvb->i2c_client_demod[1]);
1280                         module_put(dvb->i2c_client_demod[0]->dev.driver->owner);
1281                         i2c_unregister_device(dvb->i2c_client_demod[0]);
1282                         result = -ENODEV;
1283                         goto out_free;
1284                 }
1285
1286                 dev->cx231xx_reset_analog_tuner = NULL;
1287                 dvb->i2c_client_tuner = client;
1288
1289                 dvb->frontend[1]->tuner_priv = dvb->frontend[0]->tuner_priv;
1290
1291                 memcpy(&dvb->frontend[1]->ops.tuner_ops,
1292                         &dvb->frontend[0]->ops.tuner_ops,
1293                         sizeof(struct dvb_tuner_ops));
1294                 break;
1295         }
1296         default:
1297                 dev_err(dev->dev,
1298                         "%s/2: The frontend of your DVB/ATSC card isn't supported yet\n",
1299                         dev->name);
1300                 break;
1301         }
1302         if (!dvb->frontend[0]) {
1303                 dev_err(dev->dev,
1304                        "%s/2: frontend initialization failed\n", dev->name);
1305                 result = -EINVAL;
1306                 goto out_free;
1307         }
1308
1309         /* register everything */
1310         result = register_dvb(dvb, THIS_MODULE, dev, dev->dev);
1311
1312         if (result < 0)
1313                 goto out_free;
1314
1315
1316         dev_info(dev->dev, "Successfully loaded cx231xx-dvb\n");
1317
1318 ret:
1319         cx231xx_set_mode(dev, CX231XX_SUSPEND);
1320         mutex_unlock(&dev->lock);
1321         return result;
1322
1323 out_free:
1324         kfree(dvb);
1325         dev->dvb = NULL;
1326         goto ret;
1327 }
1328
1329 static int dvb_fini(struct cx231xx *dev)
1330 {
1331         if (!dev->board.has_dvb) {
1332                 /* This device does not support the extension */
1333                 return 0;
1334         }
1335
1336         if (dev->dvb) {
1337                 unregister_dvb(dev->dvb);
1338                 dev->dvb = NULL;
1339         }
1340
1341         return 0;
1342 }
1343
1344 static struct cx231xx_ops dvb_ops = {
1345         .id = CX231XX_DVB,
1346         .name = "Cx231xx dvb Extension",
1347         .init = dvb_init,
1348         .fini = dvb_fini,
1349 };
1350
1351 static int __init cx231xx_dvb_register(void)
1352 {
1353         return cx231xx_register_extension(&dvb_ops);
1354 }
1355
1356 static void __exit cx231xx_dvb_unregister(void)
1357 {
1358         cx231xx_unregister_extension(&dvb_ops);
1359 }
1360
1361 module_init(cx231xx_dvb_register);
1362 module_exit(cx231xx_dvb_unregister);