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