drivers/media/pci/saa7164/saa7164-dvb.c

   1 /*
   2  *  Driver for the NXP SAA7164 PCIe bridge
   3  *
   4  *  Copyright (c) 2010-2015 Steven Toth <stoth@kernellabs.com>
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *
  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 "saa7164.h"
  23
  24 #include "tda10048.h"
  25 #include "tda18271.h"
  26 #include "s5h1411.h"
  27 #include "si2157.h"
  28 #include "si2168.h"
  29 #include "lgdt3306a.h"
  30
  31 #define DRIVER_NAME "saa7164"
  32
  33 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  34
  35 /* addr is in the card struct, get it from there */
  36 static struct tda10048_config hauppauge_hvr2200_1_config = {
  37         .demod_address    = 0x10 >> 1,
  38         .output_mode      = TDA10048_SERIAL_OUTPUT,
  39         .fwbulkwritelen   = TDA10048_BULKWRITE_200,
  40         .inversion        = TDA10048_INVERSION_ON,
  41         .dtv6_if_freq_khz = TDA10048_IF_3300,
  42         .dtv7_if_freq_khz = TDA10048_IF_3500,
  43         .dtv8_if_freq_khz = TDA10048_IF_4000,
  44         .clk_freq_khz     = TDA10048_CLK_16000,
  45 };
  46 static struct tda10048_config hauppauge_hvr2200_2_config = {
  47         .demod_address    = 0x12 >> 1,
  48         .output_mode      = TDA10048_SERIAL_OUTPUT,
  49         .fwbulkwritelen   = TDA10048_BULKWRITE_200,
  50         .inversion        = TDA10048_INVERSION_ON,
  51         .dtv6_if_freq_khz = TDA10048_IF_3300,
  52         .dtv7_if_freq_khz = TDA10048_IF_3500,
  53         .dtv8_if_freq_khz = TDA10048_IF_4000,
  54         .clk_freq_khz     = TDA10048_CLK_16000,
  55 };
  56
  57 static struct tda18271_std_map hauppauge_tda18271_std_map = {
  58         .atsc_6   = { .if_freq = 3250, .agc_mode = 3, .std = 3,
  59                       .if_lvl = 6, .rfagc_top = 0x37 },
  60         .qam_6    = { .if_freq = 4000, .agc_mode = 3, .std = 0,
  61                       .if_lvl = 6, .rfagc_top = 0x37 },
  62 };
  63
  64 static struct tda18271_config hauppauge_hvr22x0_tuner_config = {
  65         .std_map        = &hauppauge_tda18271_std_map,
  66         .gate           = TDA18271_GATE_ANALOG,
  67         .role           = TDA18271_MASTER,
  68 };
  69
  70 static struct tda18271_config hauppauge_hvr22x0s_tuner_config = {
  71         .std_map        = &hauppauge_tda18271_std_map,
  72         .gate           = TDA18271_GATE_ANALOG,
  73         .role           = TDA18271_SLAVE,
  74         .output_opt     = TDA18271_OUTPUT_LT_OFF,
  75         .rf_cal_on_startup = 1
  76 };
  77
  78 static struct s5h1411_config hauppauge_s5h1411_config = {
  79         .output_mode   = S5H1411_SERIAL_OUTPUT,
  80         .gpio          = S5H1411_GPIO_ON,
  81         .qam_if        = S5H1411_IF_4000,
  82         .vsb_if        = S5H1411_IF_3250,
  83         .inversion     = S5H1411_INVERSION_ON,
  84         .status_mode   = S5H1411_DEMODLOCKING,
  85         .mpeg_timing   = S5H1411_MPEGTIMING_CONTINOUS_NONINVERTING_CLOCK,
  86 };
  87
  88 static struct lgdt3306a_config hauppauge_hvr2255a_config = {
  89         .i2c_addr               = 0xb2 >> 1,
  90         .qam_if_khz             = 4000,
  91         .vsb_if_khz             = 3250,
  92         .deny_i2c_rptr          = 1, /* Disabled */
  93         .spectral_inversion     = 0, /* Disabled */
  94         .mpeg_mode              = LGDT3306A_MPEG_SERIAL,
  95         .tpclk_edge             = LGDT3306A_TPCLK_RISING_EDGE,
  96         .tpvalid_polarity       = LGDT3306A_TP_VALID_HIGH,
  97         .xtalMHz                = 25, /* 24 or 25 */
  98 };
  99
 100 static struct lgdt3306a_config hauppauge_hvr2255b_config = {
 101         .i2c_addr               = 0x1c >> 1,
 102         .qam_if_khz             = 4000,
 103         .vsb_if_khz             = 3250,
 104         .deny_i2c_rptr          = 1, /* Disabled */
 105         .spectral_inversion     = 0, /* Disabled */
 106         .mpeg_mode              = LGDT3306A_MPEG_SERIAL,
 107         .tpclk_edge             = LGDT3306A_TPCLK_RISING_EDGE,
 108         .tpvalid_polarity       = LGDT3306A_TP_VALID_HIGH,
 109         .xtalMHz                = 25, /* 24 or 25 */
 110 };
 111
 112 static struct si2157_config hauppauge_hvr2255_tuner_config = {
 113         .inversion = 1,
 114         .if_port = 1,
 115 };
 116
 117 static int si2157_attach(struct saa7164_port *port, struct i2c_adapter *adapter,
 118         struct dvb_frontend *fe, u8 addr8bit, struct si2157_config *cfg)
 119 {
 120         struct i2c_board_info bi;
 121         struct i2c_client *tuner;
 122
 123         cfg->fe = fe;
 124
 125         memset(&bi, 0, sizeof(bi));
 126
 127         strlcpy(bi.type, "si2157", I2C_NAME_SIZE);
 128         bi.platform_data = cfg;
 129         bi.addr = addr8bit >> 1;
 130
 131         request_module(bi.type);
 132
 133         tuner = i2c_new_device(adapter, &bi);
 134         if (tuner == NULL || tuner->dev.driver == NULL)
 135                 return -ENODEV;
 136
 137         if (!try_module_get(tuner->dev.driver->owner)) {
 138                 i2c_unregister_device(tuner);
 139                 return -ENODEV;
 140         }
 141
 142         port->i2c_client_tuner = tuner;
 143
 144         return 0;
 145 }
 146
 147 static int saa7164_dvb_stop_port(struct saa7164_port *port)
 148 {
 149         struct saa7164_dev *dev = port->dev;
 150         int ret;
 151
 152         ret = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
 153         if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
 154                 printk(KERN_ERR "%s() stop transition failed, ret = 0x%x\n",
 155                         __func__, ret);
 156                 ret = -EIO;
 157         } else {
 158                 dprintk(DBGLVL_DVB, "%s()    Stopped\n", __func__);
 159                 ret = 0;
 160         }
 161
 162         return ret;
 163 }
 164
 165 static int saa7164_dvb_acquire_port(struct saa7164_port *port)
 166 {
 167         struct saa7164_dev *dev = port->dev;
 168         int ret;
 169
 170         ret = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE);
 171         if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
 172                 printk(KERN_ERR "%s() acquire transition failed, ret = 0x%x\n",
 173                         __func__, ret);
 174                 ret = -EIO;
 175         } else {
 176                 dprintk(DBGLVL_DVB, "%s() Acquired\n", __func__);
 177                 ret = 0;
 178         }
 179
 180         return ret;
 181 }
 182
 183 static int saa7164_dvb_pause_port(struct saa7164_port *port)
 184 {
 185         struct saa7164_dev *dev = port->dev;
 186         int ret;
 187
 188         ret = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE);
 189         if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
 190                 printk(KERN_ERR "%s() pause transition failed, ret = 0x%x\n",
 191                         __func__, ret);
 192                 ret = -EIO;
 193         } else {
 194                 dprintk(DBGLVL_DVB, "%s()   Paused\n", __func__);
 195                 ret = 0;
 196         }
 197
 198         return ret;
 199 }
 200
 201 /* Firmware is very windows centric, meaning you have to transition
 202  * the part through AVStream / KS Windows stages, forwards or backwards.
 203  * States are: stopped, acquired (h/w), paused, started.
 204  */
 205 static int saa7164_dvb_stop_streaming(struct saa7164_port *port)
 206 {
 207         struct saa7164_dev *dev = port->dev;
 208         struct saa7164_buffer *buf;
 209         struct list_head *p, *q;
 210         int ret;
 211
 212         dprintk(DBGLVL_DVB, "%s(port=%d)\n", __func__, port->nr);
 213
 214         ret = saa7164_dvb_pause_port(port);
 215         ret = saa7164_dvb_acquire_port(port);
 216         ret = saa7164_dvb_stop_port(port);
 217
 218         /* Mark the hardware buffers as free */
 219         mutex_lock(&port->dmaqueue_lock);
 220         list_for_each_safe(p, q, &port->dmaqueue.list) {
 221                 buf = list_entry(p, struct saa7164_buffer, list);
 222                 buf->flags = SAA7164_BUFFER_FREE;
 223         }
 224         mutex_unlock(&port->dmaqueue_lock);
 225
 226         return ret;
 227 }
 228
 229 static int saa7164_dvb_start_port(struct saa7164_port *port)
 230 {
 231         struct saa7164_dev *dev = port->dev;
 232         int ret = 0, result;
 233
 234         dprintk(DBGLVL_DVB, "%s(port=%d)\n", __func__, port->nr);
 235
 236         saa7164_buffer_cfg_port(port);
 237
 238         /* Acquire the hardware */
 239         result = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE);
 240         if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
 241                 printk(KERN_ERR "%s() acquire transition failed, res = 0x%x\n",
 242                         __func__, result);
 243
 244                 /* Stop the hardware, regardless */
 245                 result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
 246                 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
 247                         printk(KERN_ERR "%s() acquire/forced stop transition failed, res = 0x%x\n",
 248                                __func__, result);
 249                 }
 250                 ret = -EIO;
 251                 goto out;
 252         } else
 253                 dprintk(DBGLVL_DVB, "%s()   Acquired\n", __func__);
 254
 255         /* Pause the hardware */
 256         result = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE);
 257         if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
 258                 printk(KERN_ERR "%s() pause transition failed, res = 0x%x\n",
 259                                 __func__, result);
 260
 261                 /* Stop the hardware, regardless */
 262                 result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
 263                 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
 264                         printk(KERN_ERR "%s() pause/forced stop transition failed, res = 0x%x\n",
 265                                __func__, result);
 266                 }
 267
 268                 ret = -EIO;
 269                 goto out;
 270         } else
 271                 dprintk(DBGLVL_DVB, "%s()   Paused\n", __func__);
 272
 273         /* Start the hardware */
 274         result = saa7164_api_transition_port(port, SAA_DMASTATE_RUN);
 275         if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
 276                 printk(KERN_ERR "%s() run transition failed, result = 0x%x\n",
 277                                 __func__, result);
 278
 279                 /* Stop the hardware, regardless */
 280                 result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
 281                 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
 282                         printk(KERN_ERR "%s() run/forced stop transition failed, res = 0x%x\n",
 283                                __func__, result);
 284                 }
 285
 286                 ret = -EIO;
 287         } else
 288                 dprintk(DBGLVL_DVB, "%s()   Running\n", __func__);
 289
 290 out:
 291         return ret;
 292 }
 293
 294 static int saa7164_dvb_start_feed(struct dvb_demux_feed *feed)
 295 {
 296         struct dvb_demux *demux = feed->demux;
 297         struct saa7164_port *port = (struct saa7164_port *) demux->priv;
 298         struct saa7164_dvb *dvb = &port->dvb;
 299         struct saa7164_dev *dev = port->dev;
 300         int ret = 0;
 301
 302         dprintk(DBGLVL_DVB, "%s(port=%d)\n", __func__, port->nr);
 303
 304         if (!demux->dmx.frontend)
 305                 return -EINVAL;
 306
 307         if (dvb) {
 308                 mutex_lock(&dvb->lock);
 309                 if (dvb->feeding++ == 0) {
 310                         /* Start transport */
 311                         ret = saa7164_dvb_start_port(port);
 312                 }
 313                 mutex_unlock(&dvb->lock);
 314                 dprintk(DBGLVL_DVB, "%s(port=%d) now feeding = %d\n",
 315                         __func__, port->nr, dvb->feeding);
 316         }
 317
 318         return ret;
 319 }
 320
 321 static int saa7164_dvb_stop_feed(struct dvb_demux_feed *feed)
 322 {
 323         struct dvb_demux *demux = feed->demux;
 324         struct saa7164_port *port = (struct saa7164_port *) demux->priv;
 325         struct saa7164_dvb *dvb = &port->dvb;
 326         struct saa7164_dev *dev = port->dev;
 327         int ret = 0;
 328
 329         dprintk(DBGLVL_DVB, "%s(port=%d)\n", __func__, port->nr);
 330
 331         if (dvb) {
 332                 mutex_lock(&dvb->lock);
 333                 if (--dvb->feeding == 0) {
 334                         /* Stop transport */
 335                         ret = saa7164_dvb_stop_streaming(port);
 336                 }
 337                 mutex_unlock(&dvb->lock);
 338                 dprintk(DBGLVL_DVB, "%s(port=%d) now feeding = %d\n",
 339                         __func__, port->nr, dvb->feeding);
 340         }
 341
 342         return ret;
 343 }
 344
 345 static int dvb_register(struct saa7164_port *port)
 346 {
 347         struct saa7164_dvb *dvb = &port->dvb;
 348         struct saa7164_dev *dev = port->dev;
 349         struct saa7164_buffer *buf;
 350         int result, i;
 351
 352         dprintk(DBGLVL_DVB, "%s(port=%d)\n", __func__, port->nr);
 353
 354         if (port->type != SAA7164_MPEG_DVB)
 355                 BUG();
 356
 357         /* Sanity check that the PCI configuration space is active */
 358         if (port->hwcfg.BARLocation == 0) {
 359                 result = -ENOMEM;
 360                 printk(KERN_ERR "%s: dvb_register_adapter failed (errno = %d), NO PCI configuration\n",
 361                         DRIVER_NAME, result);
 362                 goto fail_adapter;
 363         }
 364
 365         /* Init and establish defaults */
 366         port->hw_streamingparams.bitspersample = 8;
 367         port->hw_streamingparams.samplesperline = 188;
 368         port->hw_streamingparams.numberoflines =
 369                 (SAA7164_TS_NUMBER_OF_LINES * 188) / 188;
 370
 371         port->hw_streamingparams.pitch = 188;
 372         port->hw_streamingparams.linethreshold = 0;
 373         port->hw_streamingparams.pagetablelistvirt = NULL;
 374         port->hw_streamingparams.pagetablelistphys = NULL;
 375         port->hw_streamingparams.numpagetables = 2 +
 376                 ((SAA7164_TS_NUMBER_OF_LINES * 188) / PAGE_SIZE);
 377
 378         port->hw_streamingparams.numpagetableentries = port->hwcfg.buffercount;
 379
 380         /* Allocate the PCI resources */
 381         for (i = 0; i < port->hwcfg.buffercount; i++) {
 382                 buf = saa7164_buffer_alloc(port,
 383                         port->hw_streamingparams.numberoflines *
 384                         port->hw_streamingparams.pitch);
 385
 386                 if (!buf) {
 387                         result = -ENOMEM;
 388                         printk(KERN_ERR "%s: dvb_register_adapter failed (errno = %d), unable to allocate buffers\n",
 389                                 DRIVER_NAME, result);
 390                         goto fail_adapter;
 391                 }
 392
 393                 mutex_lock(&port->dmaqueue_lock);
 394                 list_add_tail(&buf->list, &port->dmaqueue.list);
 395                 mutex_unlock(&port->dmaqueue_lock);
 396         }
 397
 398         /* register adapter */
 399         result = dvb_register_adapter(&dvb->adapter, DRIVER_NAME, THIS_MODULE,
 400                         &dev->pci->dev, adapter_nr);
 401         if (result < 0) {
 402                 printk(KERN_ERR "%s: dvb_register_adapter failed (errno = %d)\n",
 403                        DRIVER_NAME, result);
 404                 goto fail_adapter;
 405         }
 406         dvb->adapter.priv = port;
 407
 408         /* register frontend */
 409         result = dvb_register_frontend(&dvb->adapter, dvb->frontend);
 410         if (result < 0) {
 411                 printk(KERN_ERR "%s: dvb_register_frontend failed (errno = %d)\n",
 412                        DRIVER_NAME, result);
 413                 goto fail_frontend;
 414         }
 415
 416         /* register demux stuff */
 417         dvb->demux.dmx.capabilities =
 418                 DMX_TS_FILTERING | DMX_SECTION_FILTERING |
 419                 DMX_MEMORY_BASED_FILTERING;
 420         dvb->demux.priv       = port;
 421         dvb->demux.filternum  = 256;
 422         dvb->demux.feednum    = 256;
 423         dvb->demux.start_feed = saa7164_dvb_start_feed;
 424         dvb->demux.stop_feed  = saa7164_dvb_stop_feed;
 425         result = dvb_dmx_init(&dvb->demux);
 426         if (result < 0) {
 427                 printk(KERN_ERR "%s: dvb_dmx_init failed (errno = %d)\n",
 428                        DRIVER_NAME, result);
 429                 goto fail_dmx;
 430         }
 431
 432         dvb->dmxdev.filternum    = 256;
 433         dvb->dmxdev.demux        = &dvb->demux.dmx;
 434         dvb->dmxdev.capabilities = 0;
 435         result = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter);
 436         if (result < 0) {
 437                 printk(KERN_ERR "%s: dvb_dmxdev_init failed (errno = %d)\n",
 438                        DRIVER_NAME, result);
 439                 goto fail_dmxdev;
 440         }
 441
 442         dvb->fe_hw.source = DMX_FRONTEND_0;
 443         result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 444         if (result < 0) {
 445                 printk(KERN_ERR "%s: add_frontend failed (DMX_FRONTEND_0, errno = %d)\n",
 446                        DRIVER_NAME, result);
 447                 goto fail_fe_hw;
 448         }
 449
 450         dvb->fe_mem.source = DMX_MEMORY_FE;
 451         result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_mem);
 452         if (result < 0) {
 453                 printk(KERN_ERR "%s: add_frontend failed (DMX_MEMORY_FE, errno = %d)\n",
 454                        DRIVER_NAME, result);
 455                 goto fail_fe_mem;
 456         }
 457
 458         result = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 459         if (result < 0) {
 460                 printk(KERN_ERR "%s: connect_frontend failed (errno = %d)\n",
 461                        DRIVER_NAME, result);
 462                 goto fail_fe_conn;
 463         }
 464
 465         /* register network adapter */
 466         dvb_net_init(&dvb->adapter, &dvb->net, &dvb->demux.dmx);
 467         return 0;
 468
 469 fail_fe_conn:
 470         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
 471 fail_fe_mem:
 472         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 473 fail_fe_hw:
 474         dvb_dmxdev_release(&dvb->dmxdev);
 475 fail_dmxdev:
 476         dvb_dmx_release(&dvb->demux);
 477 fail_dmx:
 478         dvb_unregister_frontend(dvb->frontend);
 479 fail_frontend:
 480         dvb_frontend_detach(dvb->frontend);
 481         dvb_unregister_adapter(&dvb->adapter);
 482 fail_adapter:
 483         return result;
 484 }
 485
 486 int saa7164_dvb_unregister(struct saa7164_port *port)
 487 {
 488         struct saa7164_dvb *dvb = &port->dvb;
 489         struct saa7164_dev *dev = port->dev;
 490         struct saa7164_buffer *b;
 491         struct list_head *c, *n;
 492         struct i2c_client *client;
 493
 494         dprintk(DBGLVL_DVB, "%s()\n", __func__);
 495
 496         if (port->type != SAA7164_MPEG_DVB)
 497                 BUG();
 498
 499         /* Remove any allocated buffers */
 500         mutex_lock(&port->dmaqueue_lock);
 501         list_for_each_safe(c, n, &port->dmaqueue.list) {
 502                 b = list_entry(c, struct saa7164_buffer, list);
 503                 list_del(c);
 504                 saa7164_buffer_dealloc(b);
 505         }
 506         mutex_unlock(&port->dmaqueue_lock);
 507
 508         if (dvb->frontend == NULL)
 509                 return 0;
 510
 511         /* remove I2C client for tuner */
 512         client = port->i2c_client_tuner;
 513         if (client) {
 514                 module_put(client->dev.driver->owner);
 515                 i2c_unregister_device(client);
 516         }
 517
 518         /* remove I2C client for demodulator */
 519         client = port->i2c_client_demod;
 520         if (client) {
 521                 module_put(client->dev.driver->owner);
 522                 i2c_unregister_device(client);
 523         }
 524
 525         dvb_net_release(&dvb->net);
 526         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
 527         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 528         dvb_dmxdev_release(&dvb->dmxdev);
 529         dvb_dmx_release(&dvb->demux);
 530         dvb_unregister_frontend(dvb->frontend);
 531         dvb_frontend_detach(dvb->frontend);
 532         dvb_unregister_adapter(&dvb->adapter);
 533         return 0;
 534 }
 535
 536 /* All the DVB attach calls go here, this function get's modified
 537  * for each new card.
 538  */
 539 int saa7164_dvb_register(struct saa7164_port *port)
 540 {
 541         struct saa7164_dev *dev = port->dev;
 542         struct saa7164_dvb *dvb = &port->dvb;
 543         struct saa7164_i2c *i2c_bus = NULL;
 544         struct si2168_config si2168_config;
 545         struct si2157_config si2157_config;
 546         struct i2c_adapter *adapter;
 547         struct i2c_board_info info;
 548         struct i2c_client *client_demod;
 549         struct i2c_client *client_tuner;
 550         int ret;
 551
 552         dprintk(DBGLVL_DVB, "%s()\n", __func__);
 553
 554         /* init frontend */
 555         switch (dev->board) {
 556         case SAA7164_BOARD_HAUPPAUGE_HVR2200:
 557         case SAA7164_BOARD_HAUPPAUGE_HVR2200_2:
 558         case SAA7164_BOARD_HAUPPAUGE_HVR2200_3:
 559         case SAA7164_BOARD_HAUPPAUGE_HVR2200_4:
 560         case SAA7164_BOARD_HAUPPAUGE_HVR2200_5:
 561                 i2c_bus = &dev->i2c_bus[port->nr + 1];
 562                 switch (port->nr) {
 563                 case 0:
 564                         port->dvb.frontend = dvb_attach(tda10048_attach,
 565                                 &hauppauge_hvr2200_1_config,
 566                                 &i2c_bus->i2c_adap);
 567
 568                         if (port->dvb.frontend != NULL) {
 569                                 /* TODO: addr is in the card struct */
 570                                 dvb_attach(tda18271_attach, port->dvb.frontend,
 571                                         0xc0 >> 1, &i2c_bus->i2c_adap,
 572                                         &hauppauge_hvr22x0_tuner_config);
 573                         }
 574
 575                         break;
 576                 case 1:
 577                         port->dvb.frontend = dvb_attach(tda10048_attach,
 578                                 &hauppauge_hvr2200_2_config,
 579                                 &i2c_bus->i2c_adap);
 580
 581                         if (port->dvb.frontend != NULL) {
 582                                 /* TODO: addr is in the card struct */
 583                                 dvb_attach(tda18271_attach, port->dvb.frontend,
 584                                         0xc0 >> 1, &i2c_bus->i2c_adap,
 585                                         &hauppauge_hvr22x0s_tuner_config);
 586                         }
 587
 588                         break;
 589                 }
 590                 break;
 591         case SAA7164_BOARD_HAUPPAUGE_HVR2250:
 592         case SAA7164_BOARD_HAUPPAUGE_HVR2250_2:
 593         case SAA7164_BOARD_HAUPPAUGE_HVR2250_3:
 594                 i2c_bus = &dev->i2c_bus[port->nr + 1];
 595
 596                 port->dvb.frontend = dvb_attach(s5h1411_attach,
 597                         &hauppauge_s5h1411_config,
 598                         &i2c_bus->i2c_adap);
 599
 600                 if (port->dvb.frontend != NULL) {
 601                         if (port->nr == 0) {
 602                                 /* Master TDA18271 */
 603                                 /* TODO: addr is in the card struct */
 604                                 dvb_attach(tda18271_attach, port->dvb.frontend,
 605                                         0xc0 >> 1, &i2c_bus->i2c_adap,
 606                                         &hauppauge_hvr22x0_tuner_config);
 607                         } else {
 608                                 /* Slave TDA18271 */
 609                                 dvb_attach(tda18271_attach, port->dvb.frontend,
 610                                         0xc0 >> 1, &i2c_bus->i2c_adap,
 611                                         &hauppauge_hvr22x0s_tuner_config);
 612                         }
 613                 }
 614
 615                 break;
 616         case SAA7164_BOARD_HAUPPAUGE_HVR2255proto:
 617         case SAA7164_BOARD_HAUPPAUGE_HVR2255:
 618                 i2c_bus = &dev->i2c_bus[2];
 619
 620                 if (port->nr == 0) {
 621                         port->dvb.frontend = dvb_attach(lgdt3306a_attach,
 622                                 &hauppauge_hvr2255a_config, &i2c_bus->i2c_adap);
 623                 } else {
 624                         port->dvb.frontend = dvb_attach(lgdt3306a_attach,
 625                                 &hauppauge_hvr2255b_config, &i2c_bus->i2c_adap);
 626                 }
 627
 628                 if (port->dvb.frontend != NULL) {
 629
 630                         if (port->nr == 0) {
 631                                 si2157_attach(port, &dev->i2c_bus[0].i2c_adap,
 632                                               port->dvb.frontend, 0xc0,
 633                                               &hauppauge_hvr2255_tuner_config);
 634                         } else {
 635                                 si2157_attach(port, &dev->i2c_bus[1].i2c_adap,
 636                                               port->dvb.frontend, 0xc0,
 637                                               &hauppauge_hvr2255_tuner_config);
 638                         }
 639                 }
 640                 break;
 641         case SAA7164_BOARD_HAUPPAUGE_HVR2205:
 642
 643                 if (port->nr == 0) {
 644                         /* attach frontend */
 645                         memset(&si2168_config, 0, sizeof(si2168_config));
 646                         si2168_config.i2c_adapter = &adapter;
 647                         si2168_config.fe = &port->dvb.frontend;
 648                         si2168_config.ts_mode = SI2168_TS_SERIAL;
 649                         memset(&info, 0, sizeof(struct i2c_board_info));
 650                         strlcpy(info.type, "si2168", I2C_NAME_SIZE);
 651                         info.addr = 0xc8 >> 1;
 652                         info.platform_data = &si2168_config;
 653                         request_module(info.type);
 654                         client_demod = i2c_new_device(&dev->i2c_bus[2].i2c_adap,
 655                                                       &info);
 656                         if (!client_demod || !client_demod->dev.driver)
 657                                 goto frontend_detach;
 658
 659                         if (!try_module_get(client_demod->dev.driver->owner)) {
 660                                 i2c_unregister_device(client_demod);
 661                                 goto frontend_detach;
 662                         }
 663                         port->i2c_client_demod = client_demod;
 664
 665                         /* attach tuner */
 666                         memset(&si2157_config, 0, sizeof(si2157_config));
 667                         si2157_config.if_port = 1;
 668                         si2157_config.fe = port->dvb.frontend;
 669                         memset(&info, 0, sizeof(struct i2c_board_info));
 670                         strlcpy(info.type, "si2157", I2C_NAME_SIZE);
 671                         info.addr = 0xc0 >> 1;
 672                         info.platform_data = &si2157_config;
 673                         request_module(info.type);
 674                         client_tuner = i2c_new_device(&dev->i2c_bus[0].i2c_adap,
 675                                                       &info);
 676                         if (!client_tuner || !client_tuner->dev.driver) {
 677                                 module_put(client_demod->dev.driver->owner);
 678                                 i2c_unregister_device(client_demod);
 679                                 goto frontend_detach;
 680                         }
 681                         if (!try_module_get(client_tuner->dev.driver->owner)) {
 682                                 i2c_unregister_device(client_tuner);
 683                                 module_put(client_demod->dev.driver->owner);
 684                                 i2c_unregister_device(client_demod);
 685                                 goto frontend_detach;
 686                         }
 687                         port->i2c_client_tuner = client_tuner;
 688                 } else {
 689                         /* attach frontend */
 690                         memset(&si2168_config, 0, sizeof(si2168_config));
 691                         si2168_config.i2c_adapter = &adapter;
 692                         si2168_config.fe = &port->dvb.frontend;
 693                         si2168_config.ts_mode = SI2168_TS_SERIAL;
 694                         memset(&info, 0, sizeof(struct i2c_board_info));
 695                         strlcpy(info.type, "si2168", I2C_NAME_SIZE);
 696                         info.addr = 0xcc >> 1;
 697                         info.platform_data = &si2168_config;
 698                         request_module(info.type);
 699                         client_demod = i2c_new_device(&dev->i2c_bus[2].i2c_adap,
 700                                                       &info);
 701                         if (!client_demod || !client_demod->dev.driver)
 702                                 goto frontend_detach;
 703
 704                         if (!try_module_get(client_demod->dev.driver->owner)) {
 705                                 i2c_unregister_device(client_demod);
 706                                 goto frontend_detach;
 707                         }
 708                         port->i2c_client_demod = client_demod;
 709
 710                         /* attach tuner */
 711                         memset(&si2157_config, 0, sizeof(si2157_config));
 712                         si2157_config.fe = port->dvb.frontend;
 713                         si2157_config.if_port = 1;
 714                         memset(&info, 0, sizeof(struct i2c_board_info));
 715                         strlcpy(info.type, "si2157", I2C_NAME_SIZE);
 716                         info.addr = 0xc0 >> 1;
 717                         info.platform_data = &si2157_config;
 718                         request_module(info.type);
 719                         client_tuner = i2c_new_device(&dev->i2c_bus[1].i2c_adap,
 720                                                       &info);
 721                         if (!client_tuner || !client_tuner->dev.driver) {
 722                                 module_put(client_demod->dev.driver->owner);
 723                                 i2c_unregister_device(client_demod);
 724                                 goto frontend_detach;
 725                         }
 726                         if (!try_module_get(client_tuner->dev.driver->owner)) {
 727                                 i2c_unregister_device(client_tuner);
 728                                 module_put(client_demod->dev.driver->owner);
 729                                 i2c_unregister_device(client_demod);
 730                                 goto frontend_detach;
 731                         }
 732                         port->i2c_client_tuner = client_tuner;
 733                 }
 734
 735                 break;
 736         default:
 737                 printk(KERN_ERR "%s: The frontend isn't supported\n",
 738                        dev->name);
 739                 break;
 740         }
 741         if (NULL == dvb->frontend) {
 742                 printk(KERN_ERR "%s() Frontend initialization failed\n",
 743                        __func__);
 744                 return -1;
 745         }
 746
 747         /* register everything */
 748         ret = dvb_register(port);
 749         if (ret < 0) {
 750                 if (dvb->frontend->ops.release)
 751                         dvb->frontend->ops.release(dvb->frontend);
 752                 return ret;
 753         }
 754
 755         return 0;
 756
 757 frontend_detach:
 758         printk(KERN_ERR "%s() Frontend/I2C initialization failed\n", __func__);
 759         return -1;
 760 }
 761