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