SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/video/saa7164/saa7164-dvb.c

   1 /*
   2  *  Driver for the NXP SAA7164 PCIe bridge
   3  *
   4  *  Copyright (c) 2009 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
  28 #define DRIVER_NAME "saa7164"
  29
  30 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  31
  32 /* addr is in the card struct, get it from there */
  33 static struct tda10048_config hauppauge_hvr2200_1_config = {
  34         .demod_address    = 0x10 >> 1,
  35         .output_mode      = TDA10048_SERIAL_OUTPUT,
  36         .fwbulkwritelen   = TDA10048_BULKWRITE_200,
  37         .inversion        = TDA10048_INVERSION_ON,
  38         .dtv6_if_freq_khz = TDA10048_IF_3300,
  39         .dtv7_if_freq_khz = TDA10048_IF_3500,
  40         .dtv8_if_freq_khz = TDA10048_IF_4000,
  41         .clk_freq_khz     = TDA10048_CLK_16000,
  42 };
  43 static struct tda10048_config hauppauge_hvr2200_2_config = {
  44         .demod_address    = 0x12 >> 1,
  45         .output_mode      = TDA10048_SERIAL_OUTPUT,
  46         .fwbulkwritelen   = TDA10048_BULKWRITE_200,
  47         .inversion        = TDA10048_INVERSION_ON,
  48         .dtv6_if_freq_khz = TDA10048_IF_3300,
  49         .dtv7_if_freq_khz = TDA10048_IF_3500,
  50         .dtv8_if_freq_khz = TDA10048_IF_4000,
  51         .clk_freq_khz     = TDA10048_CLK_16000,
  52 };
  53
  54 static struct tda18271_std_map hauppauge_tda18271_std_map = {
  55         .atsc_6   = { .if_freq = 3250, .agc_mode = 3, .std = 3,
  56                       .if_lvl = 6, .rfagc_top = 0x37 },
  57         .qam_6    = { .if_freq = 4000, .agc_mode = 3, .std = 0,
  58                       .if_lvl = 6, .rfagc_top = 0x37 },
  59 };
  60
  61 static struct tda18271_config hauppauge_hvr22x0_tuner_config = {
  62         .std_map        = &hauppauge_tda18271_std_map,
  63         .gate           = TDA18271_GATE_ANALOG,
  64 };
  65
  66 static struct s5h1411_config hauppauge_s5h1411_config = {
  67         .output_mode   = S5H1411_SERIAL_OUTPUT,
  68         .gpio          = S5H1411_GPIO_ON,
  69         .qam_if        = S5H1411_IF_4000,
  70         .vsb_if        = S5H1411_IF_3250,
  71         .inversion     = S5H1411_INVERSION_ON,
  72         .status_mode   = S5H1411_DEMODLOCKING,
  73         .mpeg_timing   = S5H1411_MPEGTIMING_CONTINOUS_NONINVERTING_CLOCK,
  74 };
  75
  76 static int saa7164_dvb_stop_tsport(struct saa7164_tsport *port)
  77 {
  78         struct saa7164_dev *dev = port->dev;
  79         int ret;
  80
  81         ret = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
  82         if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
  83                 printk(KERN_ERR "%s() stop transition failed, ret = 0x%x\n",
  84                         __func__, ret);
  85                 ret = -EIO;
  86         } else {
  87                 dprintk(DBGLVL_DVB, "%s()    Stopped\n", __func__);
  88                 ret = 0;
  89         }
  90
  91         return ret;
  92 }
  93
  94 static int saa7164_dvb_acquire_tsport(struct saa7164_tsport *port)
  95 {
  96         struct saa7164_dev *dev = port->dev;
  97         int ret;
  98
  99         ret = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE);
 100         if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
 101                 printk(KERN_ERR "%s() acquire transition failed, ret = 0x%x\n",
 102                         __func__, ret);
 103                 ret = -EIO;
 104         } else {
 105                 dprintk(DBGLVL_DVB, "%s() Acquired\n", __func__);
 106                 ret = 0;
 107         }
 108
 109         return ret;
 110 }
 111
 112 static int saa7164_dvb_pause_tsport(struct saa7164_tsport *port)
 113 {
 114         struct saa7164_dev *dev = port->dev;
 115         int ret;
 116
 117         ret = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE);
 118         if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
 119                 printk(KERN_ERR "%s() pause transition failed, ret = 0x%x\n",
 120                         __func__, ret);
 121                 ret = -EIO;
 122         } else {
 123                 dprintk(DBGLVL_DVB, "%s()   Paused\n", __func__);
 124                 ret = 0;
 125         }
 126
 127         return ret;
 128 }
 129
 130 /* Firmware is very windows centric, meaning you have to transition
 131  * the part through AVStream / KS Windows stages, forwards or backwards.
 132  * States are: stopped, acquired (h/w), paused, started.
 133  */
 134 static int saa7164_dvb_stop_streaming(struct saa7164_tsport *port)
 135 {
 136         struct saa7164_dev *dev = port->dev;
 137         int ret;
 138
 139         dprintk(DBGLVL_DVB, "%s(port=%d)\n", __func__, port->nr);
 140
 141         ret = saa7164_dvb_pause_tsport(port);
 142         ret = saa7164_dvb_acquire_tsport(port);
 143         ret = saa7164_dvb_stop_tsport(port);
 144
 145         return ret;
 146 }
 147
 148 static int saa7164_dvb_cfg_tsport(struct saa7164_tsport *port)
 149 {
 150         tmHWStreamParameters_t *params = &port->hw_streamingparams;
 151         struct saa7164_dev *dev = port->dev;
 152         struct saa7164_buffer *buf;
 153         struct list_head *c, *n;
 154         int i = 0;
 155
 156         dprintk(DBGLVL_DVB, "%s(port=%d)\n", __func__, port->nr);
 157
 158         saa7164_writel(port->pitch, params->pitch);
 159         saa7164_writel(port->bufsize, params->pitch * params->numberoflines);
 160
 161         dprintk(DBGLVL_DVB, " configured:\n");
 162         dprintk(DBGLVL_DVB, "   lmmio       0x%p\n", dev->lmmio);
 163         dprintk(DBGLVL_DVB, "   bufcounter  0x%x = 0x%x\n", port->bufcounter,
 164                 saa7164_readl(port->bufcounter));
 165
 166         dprintk(DBGLVL_DVB, "   pitch       0x%x = %d\n", port->pitch,
 167                 saa7164_readl(port->pitch));
 168
 169         dprintk(DBGLVL_DVB, "   bufsize     0x%x = %d\n", port->bufsize,
 170                 saa7164_readl(port->bufsize));
 171
 172         dprintk(DBGLVL_DVB, "   buffercount = %d\n", port->hwcfg.buffercount);
 173         dprintk(DBGLVL_DVB, "   bufoffset = 0x%x\n", port->bufoffset);
 174         dprintk(DBGLVL_DVB, "   bufptr32h = 0x%x\n", port->bufptr32h);
 175         dprintk(DBGLVL_DVB, "   bufptr32l = 0x%x\n", port->bufptr32l);
 176
 177         /* Poke the buffers and offsets into PCI space */
 178         mutex_lock(&port->dmaqueue_lock);
 179         list_for_each_safe(c, n, &port->dmaqueue.list) {
 180                 buf = list_entry(c, struct saa7164_buffer, list);
 181
 182                 /* TODO: Review this in light of 32v64 assignments */
 183                 saa7164_writel(port->bufoffset + (sizeof(u32) * i), 0);
 184                 saa7164_writel(port->bufptr32h + ((sizeof(u32) * 2) * i),
 185                         buf->pt_dma);
 186                 saa7164_writel(port->bufptr32l + ((sizeof(u32) * 2) * i), 0);
 187
 188                 dprintk(DBGLVL_DVB,
 189                         "   buf[%d] offset 0x%llx (0x%x) "
 190                         "buf 0x%llx/%llx (0x%x/%x)\n",
 191                         i,
 192                         (u64)port->bufoffset + (i * sizeof(u32)),
 193                         saa7164_readl(port->bufoffset + (sizeof(u32) * i)),
 194                         (u64)port->bufptr32h + ((sizeof(u32) * 2) * i),
 195                         (u64)port->bufptr32l + ((sizeof(u32) * 2) * i),
 196                         saa7164_readl(port->bufptr32h + ((sizeof(u32) * i)
 197                                 * 2)),
 198                         saa7164_readl(port->bufptr32l + ((sizeof(u32) * i)
 199                                 * 2)));
 200
 201                 if (i++ > port->hwcfg.buffercount)
 202                         BUG();
 203
 204         }
 205         mutex_unlock(&port->dmaqueue_lock);
 206
 207         return 0;
 208 }
 209
 210 static int saa7164_dvb_start_tsport(struct saa7164_tsport *port)
 211 {
 212         struct saa7164_dev *dev = port->dev;
 213         int ret = 0, result;
 214
 215         dprintk(DBGLVL_DVB, "%s(port=%d)\n", __func__, port->nr);
 216
 217         saa7164_dvb_cfg_tsport(port);
 218
 219         /* Acquire the hardware */
 220         result = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE);
 221         if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
 222                 printk(KERN_ERR "%s() acquire transition failed, res = 0x%x\n",
 223                         __func__, result);
 224
 225                 /* Stop the hardware, regardless */
 226                 result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
 227                 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
 228                         printk(KERN_ERR "%s() acquire/forced stop transition "
 229                                 "failed, res = 0x%x\n", __func__, result);
 230                 }
 231                 ret = -EIO;
 232                 goto out;
 233         } else
 234                 dprintk(DBGLVL_DVB, "%s()   Acquired\n", __func__);
 235
 236         /* Pause the hardware */
 237         result = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE);
 238         if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
 239                 printk(KERN_ERR "%s() pause transition failed, res = 0x%x\n",
 240                                 __func__, result);
 241
 242                 /* Stop the hardware, regardless */
 243                 result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
 244                 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
 245                         printk(KERN_ERR "%s() pause/forced stop transition "
 246                                 "failed, res = 0x%x\n", __func__, result);
 247                 }
 248
 249                 ret = -EIO;
 250                 goto out;
 251         } else
 252                 dprintk(DBGLVL_DVB, "%s()   Paused\n", __func__);
 253
 254         /* Start the hardware */
 255         result = saa7164_api_transition_port(port, SAA_DMASTATE_RUN);
 256         if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
 257                 printk(KERN_ERR "%s() run transition failed, result = 0x%x\n",
 258                                 __func__, result);
 259
 260                 /* Stop the hardware, regardless */
 261                 result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
 262                 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
 263                         printk(KERN_ERR "%s() run/forced stop transition "
 264                                 "failed, res = 0x%x\n", __func__, result);
 265                 }
 266
 267                 ret = -EIO;
 268         } else
 269                 dprintk(DBGLVL_DVB, "%s()   Running\n", __func__);
 270
 271 out:
 272         return ret;
 273 }
 274
 275 static int saa7164_dvb_start_feed(struct dvb_demux_feed *feed)
 276 {
 277         struct dvb_demux *demux = feed->demux;
 278         struct saa7164_tsport *port = (struct saa7164_tsport *) demux->priv;
 279         struct saa7164_dvb *dvb = &port->dvb;
 280         struct saa7164_dev *dev = port->dev;
 281         int ret = 0;
 282
 283         dprintk(DBGLVL_DVB, "%s(port=%d)\n", __func__, port->nr);
 284
 285         if (!demux->dmx.frontend)
 286                 return -EINVAL;
 287
 288         if (dvb) {
 289                 mutex_lock(&dvb->lock);
 290                 if (dvb->feeding++ == 0) {
 291                         /* Start transport */
 292                         ret = saa7164_dvb_start_tsport(port);
 293                 }
 294                 mutex_unlock(&dvb->lock);
 295                 dprintk(DBGLVL_DVB, "%s(port=%d) now feeding = %d\n",
 296                         __func__, port->nr, dvb->feeding);
 297         }
 298
 299         return ret;
 300 }
 301
 302 static int saa7164_dvb_stop_feed(struct dvb_demux_feed *feed)
 303 {
 304         struct dvb_demux *demux = feed->demux;
 305         struct saa7164_tsport *port = (struct saa7164_tsport *) demux->priv;
 306         struct saa7164_dvb *dvb = &port->dvb;
 307         struct saa7164_dev *dev = port->dev;
 308         int ret = 0;
 309
 310         dprintk(DBGLVL_DVB, "%s(port=%d)\n", __func__, port->nr);
 311
 312         if (dvb) {
 313                 mutex_lock(&dvb->lock);
 314                 if (--dvb->feeding == 0) {
 315                         /* Stop transport */
 316                         ret = saa7164_dvb_stop_streaming(port);
 317                 }
 318                 mutex_unlock(&dvb->lock);
 319                 dprintk(DBGLVL_DVB, "%s(port=%d) now feeding = %d\n",
 320                         __func__, port->nr, dvb->feeding);
 321         }
 322
 323         return ret;
 324 }
 325
 326 static int dvb_register(struct saa7164_tsport *port)
 327 {
 328         struct saa7164_dvb *dvb = &port->dvb;
 329         struct saa7164_dev *dev = port->dev;
 330         struct saa7164_buffer *buf;
 331         int result, i;
 332
 333         dprintk(DBGLVL_DVB, "%s(port=%d)\n", __func__, port->nr);
 334
 335         /* Sanity check that the PCI configuration space is active */
 336         if (port->hwcfg.BARLocation == 0) {
 337                 result = -ENOMEM;
 338                 printk(KERN_ERR "%s: dvb_register_adapter failed "
 339                        "(errno = %d), NO PCI configuration\n",
 340                         DRIVER_NAME, result);
 341                 goto fail_adapter;
 342         }
 343
 344         /* Init and establish defaults */
 345         port->hw_streamingparams.bitspersample = 8;
 346         port->hw_streamingparams.samplesperline = 188;
 347         port->hw_streamingparams.numberoflines =
 348                 (SAA7164_TS_NUMBER_OF_LINES * 188) / 188;
 349
 350         port->hw_streamingparams.pitch = 188;
 351         port->hw_streamingparams.linethreshold = 0;
 352         port->hw_streamingparams.pagetablelistvirt = 0;
 353         port->hw_streamingparams.pagetablelistphys = 0;
 354         port->hw_streamingparams.numpagetables = 2 +
 355                 ((SAA7164_TS_NUMBER_OF_LINES * 188) / PAGE_SIZE);
 356
 357         port->hw_streamingparams.numpagetableentries = port->hwcfg.buffercount;
 358
 359         /* Allocate the PCI resources */
 360         for (i = 0; i < port->hwcfg.buffercount; i++) {
 361                 buf = saa7164_buffer_alloc(port,
 362                         port->hw_streamingparams.numberoflines *
 363                         port->hw_streamingparams.pitch);
 364
 365                 if (!buf) {
 366                         result = -ENOMEM;
 367                         printk(KERN_ERR "%s: dvb_register_adapter failed "
 368                                "(errno = %d), unable to allocate buffers\n",
 369                                 DRIVER_NAME, result);
 370                         goto fail_adapter;
 371                 }
 372                 buf->nr = i;
 373
 374                 mutex_lock(&port->dmaqueue_lock);
 375                 list_add_tail(&buf->list, &port->dmaqueue.list);
 376                 mutex_unlock(&port->dmaqueue_lock);
 377         }
 378
 379         /* register adapter */
 380         result = dvb_register_adapter(&dvb->adapter, DRIVER_NAME, THIS_MODULE,
 381                         &dev->pci->dev, adapter_nr);
 382         if (result < 0) {
 383                 printk(KERN_ERR "%s: dvb_register_adapter failed "
 384                        "(errno = %d)\n", DRIVER_NAME, result);
 385                 goto fail_adapter;
 386         }
 387         dvb->adapter.priv = port;
 388
 389         /* register frontend */
 390         result = dvb_register_frontend(&dvb->adapter, dvb->frontend);
 391         if (result < 0) {
 392                 printk(KERN_ERR "%s: dvb_register_frontend failed "
 393                        "(errno = %d)\n", DRIVER_NAME, result);
 394                 goto fail_frontend;
 395         }
 396
 397         /* register demux stuff */
 398         dvb->demux.dmx.capabilities =
 399                 DMX_TS_FILTERING | DMX_SECTION_FILTERING |
 400                 DMX_MEMORY_BASED_FILTERING;
 401         dvb->demux.priv       = port;
 402         dvb->demux.filternum  = 256;
 403         dvb->demux.feednum    = 256;
 404         dvb->demux.start_feed = saa7164_dvb_start_feed;
 405         dvb->demux.stop_feed  = saa7164_dvb_stop_feed;
 406         result = dvb_dmx_init(&dvb->demux);
 407         if (result < 0) {
 408                 printk(KERN_ERR "%s: dvb_dmx_init failed (errno = %d)\n",
 409                        DRIVER_NAME, result);
 410                 goto fail_dmx;
 411         }
 412
 413         dvb->dmxdev.filternum    = 256;
 414         dvb->dmxdev.demux        = &dvb->demux.dmx;
 415         dvb->dmxdev.capabilities = 0;
 416         result = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter);
 417         if (result < 0) {
 418                 printk(KERN_ERR "%s: dvb_dmxdev_init failed (errno = %d)\n",
 419                        DRIVER_NAME, result);
 420                 goto fail_dmxdev;
 421         }
 422
 423         dvb->fe_hw.source = DMX_FRONTEND_0;
 424         result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 425         if (result < 0) {
 426                 printk(KERN_ERR "%s: add_frontend failed "
 427                        "(DMX_FRONTEND_0, errno = %d)\n", DRIVER_NAME, result);
 428                 goto fail_fe_hw;
 429         }
 430
 431         dvb->fe_mem.source = DMX_MEMORY_FE;
 432         result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_mem);
 433         if (result < 0) {
 434                 printk(KERN_ERR "%s: add_frontend failed "
 435                        "(DMX_MEMORY_FE, errno = %d)\n", DRIVER_NAME, result);
 436                 goto fail_fe_mem;
 437         }
 438
 439         result = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 440         if (result < 0) {
 441                 printk(KERN_ERR "%s: connect_frontend failed (errno = %d)\n",
 442                        DRIVER_NAME, result);
 443                 goto fail_fe_conn;
 444         }
 445
 446         /* register network adapter */
 447         dvb_net_init(&dvb->adapter, &dvb->net, &dvb->demux.dmx);
 448         return 0;
 449
 450 fail_fe_conn:
 451         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
 452 fail_fe_mem:
 453         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 454 fail_fe_hw:
 455         dvb_dmxdev_release(&dvb->dmxdev);
 456 fail_dmxdev:
 457         dvb_dmx_release(&dvb->demux);
 458 fail_dmx:
 459         dvb_unregister_frontend(dvb->frontend);
 460 fail_frontend:
 461         dvb_frontend_detach(dvb->frontend);
 462         dvb_unregister_adapter(&dvb->adapter);
 463 fail_adapter:
 464         return result;
 465 }
 466
 467 int saa7164_dvb_unregister(struct saa7164_tsport *port)
 468 {
 469         struct saa7164_dvb *dvb = &port->dvb;
 470         struct saa7164_dev *dev = port->dev;
 471         struct saa7164_buffer *b;
 472         struct list_head *c, *n;
 473
 474         dprintk(DBGLVL_DVB, "%s()\n", __func__);
 475
 476         /* Remove any allocated buffers */
 477         mutex_lock(&port->dmaqueue_lock);
 478         list_for_each_safe(c, n, &port->dmaqueue.list) {
 479                 b = list_entry(c, struct saa7164_buffer, list);
 480                 list_del(c);
 481                 saa7164_buffer_dealloc(port, b);
 482         }
 483         mutex_unlock(&port->dmaqueue_lock);
 484
 485         if (dvb->frontend == NULL)
 486                 return 0;
 487
 488         dvb_net_release(&dvb->net);
 489         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
 490         dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
 491         dvb_dmxdev_release(&dvb->dmxdev);
 492         dvb_dmx_release(&dvb->demux);
 493         dvb_unregister_frontend(dvb->frontend);
 494         dvb_frontend_detach(dvb->frontend);
 495         dvb_unregister_adapter(&dvb->adapter);
 496         return 0;
 497 }
 498
 499 /* All the DVB attach calls go here, this function get's modified
 500  * for each new card.
 501  */
 502 int saa7164_dvb_register(struct saa7164_tsport *port)
 503 {
 504         struct saa7164_dev *dev = port->dev;
 505         struct saa7164_dvb *dvb = &port->dvb;
 506         struct saa7164_i2c *i2c_bus = NULL;
 507         int ret;
 508
 509         dprintk(DBGLVL_DVB, "%s()\n", __func__);
 510
 511         /* init frontend */
 512         switch (dev->board) {
 513         case SAA7164_BOARD_HAUPPAUGE_HVR2200:
 514         case SAA7164_BOARD_HAUPPAUGE_HVR2200_2:
 515         case SAA7164_BOARD_HAUPPAUGE_HVR2200_3:
 516                 switch (port->nr) {
 517                 case 0:
 518                         i2c_bus = &dev->i2c_bus[1];
 519
 520                         port->dvb.frontend = dvb_attach(tda10048_attach,
 521                                 &hauppauge_hvr2200_1_config,
 522                                 &i2c_bus->i2c_adap);
 523
 524                         if (port->dvb.frontend != NULL) {
 525                                 dvb_attach(tda18271_attach, port->dvb.frontend,
 526                                         0xc0 >> 1, &i2c_bus->i2c_adap,
 527                                         &hauppauge_hvr22x0_tuner_config);
 528                         }
 529
 530                         break;
 531                 case 1:
 532                         i2c_bus = &dev->i2c_bus[2];
 533
 534                         port->dvb.frontend = dvb_attach(tda10048_attach,
 535                                 &hauppauge_hvr2200_2_config,
 536                                 &i2c_bus->i2c_adap);
 537
 538                         if (port->dvb.frontend != NULL) {
 539                                 dvb_attach(tda18271_attach, port->dvb.frontend,
 540                                         0xc0 >> 1, &i2c_bus->i2c_adap,
 541                                         &hauppauge_hvr22x0_tuner_config);
 542                         }
 543
 544                         break;
 545                 }
 546                 break;
 547         case SAA7164_BOARD_HAUPPAUGE_HVR2250:
 548         case SAA7164_BOARD_HAUPPAUGE_HVR2250_2:
 549         case SAA7164_BOARD_HAUPPAUGE_HVR2250_3:
 550                 i2c_bus = &dev->i2c_bus[port->nr + 1];
 551
 552                 port->dvb.frontend = dvb_attach(s5h1411_attach,
 553                         &hauppauge_s5h1411_config,
 554                         &i2c_bus->i2c_adap);
 555
 556                 if (port->dvb.frontend != NULL) {
 557                         /* TODO: addr is in the card struct */
 558                         dvb_attach(tda18271_attach, port->dvb.frontend,
 559                                 0xc0 >> 1, &i2c_bus->i2c_adap,
 560                                 &hauppauge_hvr22x0_tuner_config);
 561                 }
 562
 563                 break;
 564         default:
 565                 printk(KERN_ERR "%s: The frontend isn't supported\n",
 566                        dev->name);
 567                 break;
 568         }
 569         if (NULL == dvb->frontend) {
 570                 printk(KERN_ERR "%s() Frontend initialization failed\n",
 571                        __func__);
 572                 return -1;
 573         }
 574
 575         /* Put the analog decoder in standby to keep it quiet */
 576
 577         /* register everything */
 578         ret = dvb_register(port);
 579         if (ret < 0) {
 580                 if (dvb->frontend->ops.release)
 581                         dvb->frontend->ops.release(dvb->frontend);
 582                 return ret;
 583         }
 584
 585         return 0;
 586 }
 587