drivers/media/video/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 <linux/kernel.h>
  23 #include <linux/slab.h>
  24 #include <linux/usb.h>
  25
  26 #include "cx231xx.h"
  27 #include <media/v4l2-common.h>
  28 #include <media/videobuf-vmalloc.h>
  29
  30 #include "xc5000.h"
  31 #include "dvb_dummy_fe.h"
  32 #include "s5h1432.h"
  33 #include "tda18271.h"
  34 #include "s5h1411.h"
  35 #include "lgdt3305.h"
  36
  37 MODULE_DESCRIPTION("driver for cx231xx based DVB cards");
  38 MODULE_AUTHOR("Srinivasa Deevi <srinivasa.deevi@conexant.com>");
  39 MODULE_LICENSE("GPL");
  40
  41 static unsigned int debug;
  42 module_param(debug, int, 0644);
  43 MODULE_PARM_DESC(debug, "enable debug messages [dvb]");
  44
  45 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  46
  47 #define dprintk(level, fmt, arg...) do {                        \
  48 if (debug >= level)                                             \
  49         printk(KERN_DEBUG "%s/2-dvb: " fmt, dev->name, ## arg); \
  50 } while (0)
  51
  52 #define CX231XX_DVB_NUM_BUFS 5
  53 #define CX231XX_DVB_MAX_PACKETSIZE 564
  54 #define CX231XX_DVB_MAX_PACKETS 64
  55
  56 struct cx231xx_dvb {
  57         struct dvb_frontend *frontend;
  58
  59         /* feed count management */
  60         struct mutex lock;
  61         int nfeeds;
  62
  63         /* general boilerplate stuff */
  64         struct dvb_adapter adapter;
  65         struct dvb_demux demux;
  66         struct dmxdev dmxdev;
  67         struct dmx_frontend fe_hw;
  68         struct dmx_frontend fe_mem;
  69         struct dvb_net net;
  70 };
  71
  72 static struct s5h1432_config dvico_s5h1432_config = {
  73         .output_mode   = S5H1432_SERIAL_OUTPUT,
  74         .gpio          = S5H1432_GPIO_ON,
  75         .qam_if        = S5H1432_IF_4000,
  76         .vsb_if        = S5H1432_IF_4000,
  77         .inversion     = S5H1432_INVERSION_OFF,
  78         .status_mode   = S5H1432_DEMODLOCKING,
  79         .mpeg_timing   = S5H1432_MPEGTIMING_CONTINOUS_NONINVERTING_CLOCK,
  80 };
  81
  82 static struct tda18271_std_map cnxt_rde253s_tda18271_std_map = {
  83         .dvbt_6   = { .if_freq = 4000, .agc_mode = 3, .std = 4,
  84                       .if_lvl = 1, .rfagc_top = 0x37, },
  85         .dvbt_7   = { .if_freq = 4000, .agc_mode = 3, .std = 5,
  86                       .if_lvl = 1, .rfagc_top = 0x37, },
  87         .dvbt_8   = { .if_freq = 4000, .agc_mode = 3, .std = 6,
  88                       .if_lvl = 1, .rfagc_top = 0x37, },
  89 };
  90
  91 static struct tda18271_config cnxt_rde253s_tunerconfig = {
  92         .std_map = &cnxt_rde253s_tda18271_std_map,
  93         .gate    = TDA18271_GATE_ANALOG,
  94 };
  95
  96 static struct s5h1411_config tda18271_s5h1411_config = {
  97         .output_mode   = S5H1411_SERIAL_OUTPUT,
  98         .gpio          = S5H1411_GPIO_OFF,
  99         .vsb_if        = S5H1411_IF_3250,
 100         .qam_if        = S5H1411_IF_4000,
 101         .inversion     = S5H1411_INVERSION_ON,
 102         .status_mode   = S5H1411_DEMODLOCKING,
 103         .mpeg_timing   = S5H1411_MPEGTIMING_CONTINOUS_NONINVERTING_CLOCK,
 104 };
 105 static struct s5h1411_config xc5000_s5h1411_config = {
 106         .output_mode   = S5H1411_SERIAL_OUTPUT,
 107         .gpio          = S5H1411_GPIO_OFF,
 108         .vsb_if        = S5H1411_IF_3250,
 109         .qam_if        = S5H1411_IF_3250,
 110         .inversion     = S5H1411_INVERSION_OFF,
 111         .status_mode   = S5H1411_DEMODLOCKING,
 112         .mpeg_timing   = S5H1411_MPEGTIMING_CONTINOUS_NONINVERTING_CLOCK,
 113 };
 114
 115 static struct lgdt3305_config hcw_lgdt3305_config = {
 116         .i2c_addr           = 0x0e,
 117         .mpeg_mode          = LGDT3305_MPEG_SERIAL,
 118         .tpclk_edge         = LGDT3305_TPCLK_FALLING_EDGE,
 119         .tpvalid_polarity   = LGDT3305_TP_VALID_HIGH,
 120         .deny_i2c_rptr      = 1,
 121         .spectral_inversion = 1,
 122         .qam_if_khz         = 4000,
 123         .vsb_if_khz         = 3250,
 124 };
 125
 126 static struct tda18271_std_map hauppauge_tda18271_std_map = {
 127         .atsc_6   = { .if_freq = 3250, .agc_mode = 3, .std = 4,
 128                       .if_lvl = 1, .rfagc_top = 0x58, },
 129         .qam_6    = { .if_freq = 4000, .agc_mode = 3, .std = 5,
 130                       .if_lvl = 1, .rfagc_top = 0x58, },
 131 };
 132
 133 static struct tda18271_config hcw_tda18271_config = {
 134         .std_map = &hauppauge_tda18271_std_map,
 135         .gate    = TDA18271_GATE_DIGITAL,
 136 };
 137
 138 static inline void print_err_status(struct cx231xx *dev, int packet, int status)
 139 {
 140         char *errmsg = "Unknown";
 141
 142         switch (status) {
 143         case -ENOENT:
 144                 errmsg = "unlinked synchronuously";
 145                 break;
 146         case -ECONNRESET:
 147                 errmsg = "unlinked asynchronuously";
 148                 break;
 149         case -ENOSR:
 150                 errmsg = "Buffer error (overrun)";
 151                 break;
 152         case -EPIPE:
 153                 errmsg = "Stalled (device not responding)";
 154                 break;
 155         case -EOVERFLOW:
 156                 errmsg = "Babble (bad cable?)";
 157                 break;
 158         case -EPROTO:
 159                 errmsg = "Bit-stuff error (bad cable?)";
 160                 break;
 161         case -EILSEQ:
 162                 errmsg = "CRC/Timeout (could be anything)";
 163                 break;
 164         case -ETIME:
 165                 errmsg = "Device does not respond";
 166                 break;
 167         }
 168         if (packet < 0) {
 169                 dprintk(1, "URB status %d [%s].\n", status, errmsg);
 170         } else {
 171                 dprintk(1, "URB packet %d, status %d [%s].\n",
 172                         packet, status, errmsg);
 173         }
 174 }
 175
 176 static inline int dvb_isoc_copy(struct cx231xx *dev, struct urb *urb)
 177 {
 178         int i;
 179
 180         if (!dev)
 181                 return 0;
 182
 183         if ((dev->state & DEV_DISCONNECTED) || (dev->state & DEV_MISCONFIGURED))
 184                 return 0;
 185
 186         if (urb->status < 0) {
 187                 print_err_status(dev, -1, urb->status);
 188                 if (urb->status == -ENOENT)
 189                         return 0;
 190         }
 191
 192         for (i = 0; i < urb->number_of_packets; i++) {
 193                 int status = urb->iso_frame_desc[i].status;
 194
 195                 if (status < 0) {
 196                         print_err_status(dev, i, status);
 197                         if (urb->iso_frame_desc[i].status != -EPROTO)
 198                                 continue;
 199                 }
 200
 201                 dvb_dmx_swfilter(&dev->dvb->demux,
 202                                  urb->transfer_buffer +
 203                                 urb->iso_frame_desc[i].offset,
 204                                 urb->iso_frame_desc[i].actual_length);
 205         }
 206
 207         return 0;
 208 }
 209
 210 static inline int dvb_bulk_copy(struct cx231xx *dev, struct urb *urb)
 211 {
 212         int i;
 213
 214         if (!dev)
 215                 return 0;
 216
 217         if ((dev->state & DEV_DISCONNECTED) || (dev->state & DEV_MISCONFIGURED))
 218                 return 0;
 219
 220         if (urb->status < 0) {
 221                 print_err_status(dev, -1, urb->status);
 222                 if (urb->status == -ENOENT)
 223                         return 0;
 224         }
 225
 226         /* Feed the transport payload into the kernel demux */
 227         dvb_dmx_swfilter(&dev->dvb->demux,
 228                 urb->transfer_buffer, urb->actual_length);
 229
 230         return 0;
 231 }
 232
 233 static int start_streaming(struct cx231xx_dvb *dvb)
 234 {
 235         int rc;
 236         struct cx231xx *dev = dvb->adapter.priv;
 237
 238         if (dev->USE_ISO) {
 239                 cx231xx_info("DVB transfer mode is ISO.\n");
 240 mutex_lock(&dev->i2c_lock);
 241                 cx231xx_enable_i2c_for_tuner(dev, I2C_1);
 242                 cx231xx_set_alt_setting(dev, INDEX_TS1, 4);
 243                 cx231xx_enable_i2c_for_tuner(dev, I2C_3);
 244 mutex_unlock(&dev->i2c_lock);
 245                 rc = cx231xx_set_mode(dev, CX231XX_DIGITAL_MODE);
 246                 if (rc < 0)
 247                         return rc;
 248                 dev->mode_tv = 1;
 249                 return cx231xx_init_isoc(dev, CX231XX_DVB_MAX_PACKETS,
 250                                         CX231XX_DVB_NUM_BUFS,
 251                                         dev->ts1_mode.max_pkt_size,
 252                                         dvb_isoc_copy);
 253         } else {
 254                 cx231xx_info("DVB transfer mode is BULK.\n");
 255                 cx231xx_set_alt_setting(dev, INDEX_TS1, 0);
 256                 rc = cx231xx_set_mode(dev, CX231XX_DIGITAL_MODE);
 257                 if (rc < 0)
 258                         return rc;
 259                 dev->mode_tv = 1;
 260                 return cx231xx_init_bulk(dev, CX231XX_DVB_MAX_PACKETS,
 261                                         CX231XX_DVB_NUM_BUFS,
 262                                         dev->ts1_mode.max_pkt_size,
 263                                         dvb_bulk_copy);
 264         }
 265
 266 }
 267
 268 static int stop_streaming(struct cx231xx_dvb *dvb)
 269 {
 270         struct cx231xx *dev = dvb->adapter.priv;
 271
 272         if (dev->USE_ISO)
 273                 cx231xx_uninit_isoc(dev);
 274         else
 275                 cx231xx_uninit_bulk(dev);
 276
 277         cx231xx_set_mode(dev, CX231XX_SUSPEND);
 278
 279         return 0;
 280 }
 281
 282 static int start_feed(struct dvb_demux_feed *feed)
 283 {
 284         struct dvb_demux *demux = feed->demux;
 285         struct cx231xx_dvb *dvb = demux->priv;
 286         int rc, ret;
 287
 288         if (!demux->dmx.frontend)
 289                 return -EINVAL;
 290
 291         mutex_lock(&dvb->lock);
 292         dvb->nfeeds++;
 293         rc = dvb->nfeeds;
 294
 295         if (dvb->nfeeds == 1) {
 296                 ret = start_streaming(dvb);
 297                 if (ret < 0)
 298                         rc = ret;
 299         }
 300
 301         mutex_unlock(&dvb->lock);
 302         return rc;
 303 }
 304
 305 static int stop_feed(struct dvb_demux_feed *feed)
 306 {
 307         struct dvb_demux *demux = feed->demux;
 308         struct cx231xx_dvb *dvb = demux->priv;
 309         int err = 0;
 310
 311         mutex_lock(&dvb->lock);
 312         dvb->nfeeds--;
 313
 314         if (0 == dvb->nfeeds)
 315                 err = stop_streaming(dvb);
 316
 317         mutex_unlock(&dvb->lock);
 318         return err;
 319 }
 320
 321 /* ------------------------------------------------------------------ */
 322 static int cx231xx_dvb_bus_ctrl(struct dvb_frontend *fe, int acquire)
 323 {
 324         struct cx231xx *dev = fe->dvb->priv;
 325
 326         if (acquire)
 327                 return cx231xx_set_mode(dev, CX231XX_DIGITAL_MODE);
 328         else
 329                 return cx231xx_set_mode(dev, CX231XX_SUSPEND);
 330 }
 331
 332 /* ------------------------------------------------------------------ */
 333
 334 static struct xc5000_config cnxt_rde250_tunerconfig = {
 335         .i2c_address = 0x61,
 336         .if_khz = 4000,
 337 };
 338 static struct xc5000_config cnxt_rdu250_tunerconfig = {
 339         .i2c_address = 0x61,
 340         .if_khz = 3250,
 341 };
 342
 343 /* ------------------------------------------------------------------ */
 344 #if 0
 345 static int attach_xc5000(u8 addr, struct cx231xx *dev)
 346 {
 347
 348         struct dvb_frontend *fe;
 349         struct xc5000_config cfg;
 350
 351         memset(&cfg, 0, sizeof(cfg));
 352         cfg.i2c_adap = &dev->i2c_bus[1].i2c_adap;
 353         cfg.i2c_addr = addr;
 354
 355         if (!dev->dvb->frontend) {
 356                 printk(KERN_ERR "%s/2: dvb frontend not attached. "
 357                        "Can't attach xc5000\n", dev->name);
 358                 return -EINVAL;
 359         }
 360
 361         fe = dvb_attach(xc5000_attach, dev->dvb->frontend, &cfg);
 362         if (!fe) {
 363                 printk(KERN_ERR "%s/2: xc5000 attach failed\n", dev->name);
 364                 dvb_frontend_detach(dev->dvb->frontend);
 365                 dev->dvb->frontend = NULL;
 366                 return -EINVAL;
 367         }
 368
 369         printk(KERN_INFO "%s/2: xc5000 attached\n", dev->name);
 370
 371         return 0;
 372 }
 373 #endif
 374
 375 int cx231xx_set_analog_freq(struct cx231xx *dev, u32 freq)
 376 {
 377         int status = 0;
 378
 379         if ((dev->dvb != NULL) && (dev->dvb->frontend != NULL)) {
 380
 381                 struct dvb_tuner_ops *dops = &dev->dvb->frontend->ops.tuner_ops;
 382
 383                 if (dops->set_analog_params != NULL) {
 384                         struct analog_parameters params;
 385
 386                         params.frequency = freq;
 387                         params.std = dev->norm;
 388                         params.mode = 0;        /* 0- Air; 1 - cable */
 389                         /*params.audmode = ;       */
 390
 391                         /* Set the analog parameters to set the frequency */
 392                         dops->set_analog_params(dev->dvb->frontend, &params);
 393                 }
 394
 395         }
 396
 397         return status;
 398 }
 399
 400 int cx231xx_reset_analog_tuner(struct cx231xx *dev)
 401 {
 402         int status = 0;
 403
 404         if ((dev->dvb != NULL) && (dev->dvb->frontend != NULL)) {
 405
 406                 struct dvb_tuner_ops *dops = &dev->dvb->frontend->ops.tuner_ops;
 407
 408                 if (dops->init != NULL && !dev->xc_fw_load_done) {
 409
 410                         cx231xx_info("Reloading firmware for XC5000\n");
 411                         status = dops->init(dev->dvb->frontend);
 412                         if (status == 0) {
 413                                 dev->xc_fw_load_done = 1;
 414                                 cx231xx_info
 415                                     ("XC5000 firmware download completed\n");
 416                         } else {
 417                                 dev->xc_fw_load_done = 0;
 418                                 cx231xx_info
 419                                     ("XC5000 firmware download failed !!!\n");
 420                         }
 421                 }
 422
 423         }
 424
 425         return status;
 426 }
 427
 428 /* ------------------------------------------------------------------ */
 429
 430 static int register_dvb(struct cx231xx_dvb *dvb,
 431                         struct module *module,
 432                         struct cx231xx *dev, struct device *device)
 433 {
 434         int result;
 435
 436         mutex_init(&dvb->lock);
 437
 438         /* register adapter */
 439         result = dvb_register_adapter(&dvb->adapter, dev->name, module, device,
 440                                       adapter_nr);
 441         if (result < 0) {
 442                 printk(KERN_WARNING
 443                        "%s: dvb_register_adapter failed (errno = %d)\n",
 444                        dev->name, result);
 445                 goto fail_adapter;
 446         }
 447
 448         /* Ensure all frontends negotiate bus access */
 449         dvb->frontend->ops.ts_bus_ctrl = cx231xx_dvb_bus_ctrl;
 450
 451         dvb->adapter.priv = dev;
 452
 453         /* register frontend */
 454         result = dvb_register_frontend(&dvb->adapter, dvb->frontend);
 455         if (result < 0) {
 456                 printk(KERN_WARNING
 457                        "%s: dvb_register_frontend failed (errno = %d)\n",
 458                        dev->name, result);
 459                 goto fail_frontend;
 460         }
 461
 462         /* register demux stuff */
 463         dvb->demux.dmx.capabilities =
 464             DMX_TS_FILTERING | DMX_SECTION_FILTERING |
 465             DMX_MEMORY_BASED_FILTERING;
 466         dvb->demux.priv = dvb;
 467         dvb->demux.filternum = 256;
 468         dvb->demux.feednum = 256;
 469         dvb->demux.start_feed = start_feed;
 470         dvb->demux.stop_feed = stop_feed;
 471
 472         result = dvb_dmx_init(&dvb->demux);
 473         if (result < 0) {
 474                 printk(KERN_WARNING "%s: dvb_dmx_init failed (errno = %d)\n",
 475                        dev->name, result);
 476                 goto fail_dmx;
 477         }
 478
 479         dvb->dmxdev.filternum = 256;
 480         dvb->dmxdev.demux = &dvb->demux.dmx;
 481         dvb->dmxdev.capabilities = 0;
 482         result = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter);
 483         if (result < 0) {
 484                 printk(KERN_WARNING "%s: dvb_dmxdev_init failed (errno = %d)\n",
 485                        dev->name, result);
 486                 goto fail_dmxdev;
 487         }
 488
 489         dvb->fe_hw.source = DMX_FRONTEND_0;
 490         result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 491         if (result < 0) {
 492                 printk(KERN_WARNING
 493                        "%s: add_frontend failed (DMX_FRONTEND_0, errno = %d)\n",
 494                        dev->name, result);
 495                 goto fail_fe_hw;
 496         }
 497
 498         dvb->fe_mem.source = DMX_MEMORY_FE;
 499         result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_mem);
 500         if (result < 0) {
 501                 printk(KERN_WARNING
 502                        "%s: add_frontend failed (DMX_MEMORY_FE, errno = %d)\n",
 503                        dev->name, result);
 504                 goto fail_fe_mem;
 505         }
 506
 507         result = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 508         if (result < 0) {
 509                 printk(KERN_WARNING
 510                        "%s: connect_frontend failed (errno = %d)\n", dev->name,
 511                        result);
 512                 goto fail_fe_conn;
 513         }
 514
 515         /* register network adapter */
 516         dvb_net_init(&dvb->adapter, &dvb->net, &dvb->demux.dmx);
 517         return 0;
 518
 519 fail_fe_conn:
 520         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
 521 fail_fe_mem:
 522         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 523 fail_fe_hw:
 524         dvb_dmxdev_release(&dvb->dmxdev);
 525 fail_dmxdev:
 526         dvb_dmx_release(&dvb->demux);
 527 fail_dmx:
 528         dvb_unregister_frontend(dvb->frontend);
 529 fail_frontend:
 530         dvb_frontend_detach(dvb->frontend);
 531         dvb_unregister_adapter(&dvb->adapter);
 532 fail_adapter:
 533         return result;
 534 }
 535
 536 static void unregister_dvb(struct cx231xx_dvb *dvb)
 537 {
 538         dvb_net_release(&dvb->net);
 539         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
 540         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 541         dvb_dmxdev_release(&dvb->dmxdev);
 542         dvb_dmx_release(&dvb->demux);
 543         dvb_unregister_frontend(dvb->frontend);
 544         dvb_frontend_detach(dvb->frontend);
 545         dvb_unregister_adapter(&dvb->adapter);
 546 }
 547
 548 static int dvb_init(struct cx231xx *dev)
 549 {
 550         int result = 0;
 551         struct cx231xx_dvb *dvb;
 552
 553         if (!dev->board.has_dvb) {
 554                 /* This device does not support the extension */
 555                 return 0;
 556         }
 557
 558         dvb = kzalloc(sizeof(struct cx231xx_dvb), GFP_KERNEL);
 559
 560         if (dvb == NULL) {
 561                 printk(KERN_INFO "cx231xx_dvb: memory allocation failed\n");
 562                 return -ENOMEM;
 563         }
 564         dev->dvb = dvb;
 565         dev->cx231xx_set_analog_freq = cx231xx_set_analog_freq;
 566         dev->cx231xx_reset_analog_tuner = cx231xx_reset_analog_tuner;
 567
 568         cx231xx_set_mode(dev, CX231XX_DIGITAL_MODE);
 569         cx231xx_demod_reset(dev);
 570         /* init frontend */
 571         switch (dev->model) {
 572         case CX231XX_BOARD_CNXT_CARRAERA:
 573         case CX231XX_BOARD_CNXT_RDE_250:
 574
 575                 dev->dvb->frontend = dvb_attach(s5h1432_attach,
 576                                         &dvico_s5h1432_config,
 577                                         &dev->i2c_bus[2].i2c_adap);
 578
 579                 if (dev->dvb->frontend == NULL) {
 580                         printk(DRIVER_NAME
 581                                ": Failed to attach s5h1432 front end\n");
 582                         result = -EINVAL;
 583                         goto out_free;
 584                 }
 585
 586                 /* define general-purpose callback pointer */
 587                 dvb->frontend->callback = cx231xx_tuner_callback;
 588
 589                 if (!dvb_attach(xc5000_attach, dev->dvb->frontend,
 590                                &dev->i2c_bus[1].i2c_adap,
 591                                &cnxt_rde250_tunerconfig)) {
 592                         result = -EINVAL;
 593                         goto out_free;
 594                 }
 595
 596                 break;
 597         case CX231XX_BOARD_CNXT_SHELBY:
 598         case CX231XX_BOARD_CNXT_RDU_250:
 599
 600                 dev->dvb->frontend = dvb_attach(s5h1411_attach,
 601                                                &xc5000_s5h1411_config,
 602                                                &dev->i2c_bus[2].i2c_adap);
 603
 604                 if (dev->dvb->frontend == NULL) {
 605                         printk(DRIVER_NAME
 606                                ": Failed to attach dummy front end\n");
 607                         result = -EINVAL;
 608                         goto out_free;
 609                 }
 610
 611                 /* define general-purpose callback pointer */
 612                 dvb->frontend->callback = cx231xx_tuner_callback;
 613
 614                 if (!dvb_attach(xc5000_attach, dev->dvb->frontend,
 615                                &dev->i2c_bus[1].i2c_adap,
 616                                &cnxt_rdu250_tunerconfig)) {
 617                         result = -EINVAL;
 618                         goto out_free;
 619                 }
 620                 break;
 621         case CX231XX_BOARD_CNXT_RDE_253S:
 622
 623                 dev->dvb->frontend = dvb_attach(s5h1432_attach,
 624                                         &dvico_s5h1432_config,
 625                                         &dev->i2c_bus[2].i2c_adap);
 626
 627                 if (dev->dvb->frontend == NULL) {
 628                         printk(DRIVER_NAME
 629                                ": Failed to attach s5h1432 front end\n");
 630                         result = -EINVAL;
 631                         goto out_free;
 632                 }
 633
 634                 /* define general-purpose callback pointer */
 635                 dvb->frontend->callback = cx231xx_tuner_callback;
 636
 637                 if (!dvb_attach(tda18271_attach, dev->dvb->frontend,
 638                                0x60, &dev->i2c_bus[1].i2c_adap,
 639                                &cnxt_rde253s_tunerconfig)) {
 640                         result = -EINVAL;
 641                         goto out_free;
 642                 }
 643                 break;
 644         case CX231XX_BOARD_CNXT_RDU_253S:
 645
 646                 dev->dvb->frontend = dvb_attach(s5h1411_attach,
 647                                                &tda18271_s5h1411_config,
 648                                                &dev->i2c_bus[2].i2c_adap);
 649
 650                 if (dev->dvb->frontend == NULL) {
 651                         printk(DRIVER_NAME
 652                                ": Failed to attach dummy front end\n");
 653                         result = -EINVAL;
 654                         goto out_free;
 655                 }
 656
 657                 /* define general-purpose callback pointer */
 658                 dvb->frontend->callback = cx231xx_tuner_callback;
 659
 660                 if (!dvb_attach(tda18271_attach, dev->dvb->frontend,
 661                                0x60, &dev->i2c_bus[1].i2c_adap,
 662                                &cnxt_rde253s_tunerconfig)) {
 663                         result = -EINVAL;
 664                         goto out_free;
 665                 }
 666                 break;
 667         case CX231XX_BOARD_HAUPPAUGE_EXETER:
 668
 669                 printk(KERN_INFO "%s: looking for tuner / demod on i2c bus: %d\n",
 670                        __func__, i2c_adapter_id(&dev->i2c_bus[1].i2c_adap));
 671
 672                 dev->dvb->frontend = dvb_attach(lgdt3305_attach,
 673                                                 &hcw_lgdt3305_config,
 674                                                 &dev->i2c_bus[1].i2c_adap);
 675
 676                 if (dev->dvb->frontend == NULL) {
 677                         printk(DRIVER_NAME
 678                                ": Failed to attach LG3305 front end\n");
 679                         result = -EINVAL;
 680                         goto out_free;
 681                 }
 682
 683                 /* define general-purpose callback pointer */
 684                 dvb->frontend->callback = cx231xx_tuner_callback;
 685
 686                 dvb_attach(tda18271_attach, dev->dvb->frontend,
 687                            0x60, &dev->i2c_bus[1].i2c_adap,
 688                            &hcw_tda18271_config);
 689                 break;
 690
 691
 692         default:
 693                 printk(KERN_ERR "%s/2: The frontend of your DVB/ATSC card"
 694                        " isn't supported yet\n", dev->name);
 695                 break;
 696         }
 697         if (NULL == dvb->frontend) {
 698                 printk(KERN_ERR
 699                        "%s/2: frontend initialization failed\n", dev->name);
 700                 result = -EINVAL;
 701                 goto out_free;
 702         }
 703
 704         /* register everything */
 705         result = register_dvb(dvb, THIS_MODULE, dev, &dev->udev->dev);
 706
 707         if (result < 0)
 708                 goto out_free;
 709
 710         cx231xx_set_mode(dev, CX231XX_SUSPEND);
 711         printk(KERN_INFO "Successfully loaded cx231xx-dvb\n");
 712         return 0;
 713
 714 out_free:
 715         cx231xx_set_mode(dev, CX231XX_SUSPEND);
 716         kfree(dvb);
 717         dev->dvb = NULL;
 718         return result;
 719 }
 720
 721 static int dvb_fini(struct cx231xx *dev)
 722 {
 723         if (!dev->board.has_dvb) {
 724                 /* This device does not support the extension */
 725                 return 0;
 726         }
 727
 728         if (dev->dvb) {
 729                 unregister_dvb(dev->dvb);
 730                 dev->dvb = NULL;
 731         }
 732
 733         return 0;
 734 }
 735
 736 static struct cx231xx_ops dvb_ops = {
 737         .id = CX231XX_DVB,
 738         .name = "Cx231xx dvb Extension",
 739         .init = dvb_init,
 740         .fini = dvb_fini,
 741 };
 742
 743 static int __init cx231xx_dvb_register(void)
 744 {
 745         return cx231xx_register_extension(&dvb_ops);
 746 }
 747
 748 static void __exit cx231xx_dvb_unregister(void)
 749 {
 750         cx231xx_unregister_extension(&dvb_ops);
 751 }
 752
 753 module_init(cx231xx_dvb_register);
 754 module_exit(cx231xx_dvb_unregister);