1 /* 2 DVB device driver for cx231xx 3 4 Copyright (C) 2008 <srinivasa.deevi at conexant dot com> 5 Based on em28xx driver 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 */ 21 22 #include "cx231xx.h" 23 #include <linux/kernel.h> 24 #include <linux/slab.h> 25 26 #include <media/v4l2-common.h> 27 #include <media/videobuf-vmalloc.h> 28 #include <media/tuner.h> 29 30 #include "xc5000.h" 31 #include "s5h1432.h" 32 #include "tda18271.h" 33 #include "s5h1411.h" 34 #include "lgdt3305.h" 35 #include "si2165.h" 36 #include "si2168.h" 37 #include "mb86a20s.h" 38 #include "si2157.h" 39 #include "lgdt3306a.h" 40 #include "r820t.h" 41 #include "mn88473.h" 42 43 MODULE_DESCRIPTION("driver for cx231xx based DVB cards"); 44 MODULE_AUTHOR("Srinivasa Deevi <srinivasa.deevi@conexant.com>"); 45 MODULE_LICENSE("GPL"); 46 47 static unsigned int debug; 48 module_param(debug, int, 0644); 49 MODULE_PARM_DESC(debug, "enable debug messages [dvb]"); 50 51 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); 52 53 #define CX231XX_DVB_NUM_BUFS 5 54 #define CX231XX_DVB_MAX_PACKETSIZE 564 55 #define CX231XX_DVB_MAX_PACKETS 64 56 #define CX231XX_DVB_MAX_FRONTENDS 2 57 58 struct cx231xx_dvb { 59 struct dvb_frontend *frontend[CX231XX_DVB_MAX_FRONTENDS]; 60 61 /* feed count management */ 62 struct mutex lock; 63 int nfeeds; 64 65 /* general boilerplate stuff */ 66 struct dvb_adapter adapter; 67 struct dvb_demux demux; 68 struct dmxdev dmxdev; 69 struct dmx_frontend fe_hw; 70 struct dmx_frontend fe_mem; 71 struct dvb_net net; 72 struct i2c_client *i2c_client_demod[2]; 73 struct i2c_client *i2c_client_tuner; 74 }; 75 76 static struct s5h1432_config dvico_s5h1432_config = { 77 .output_mode = S5H1432_SERIAL_OUTPUT, 78 .gpio = S5H1432_GPIO_ON, 79 .qam_if = S5H1432_IF_4000, 80 .vsb_if = S5H1432_IF_4000, 81 .inversion = S5H1432_INVERSION_OFF, 82 .status_mode = S5H1432_DEMODLOCKING, 83 .mpeg_timing = S5H1432_MPEGTIMING_CONTINUOUS_NONINVERTING_CLOCK, 84 }; 85 86 static struct tda18271_std_map cnxt_rde253s_tda18271_std_map = { 87 .dvbt_6 = { .if_freq = 4000, .agc_mode = 3, .std = 4, 88 .if_lvl = 1, .rfagc_top = 0x37, }, 89 .dvbt_7 = { .if_freq = 4000, .agc_mode = 3, .std = 5, 90 .if_lvl = 1, .rfagc_top = 0x37, }, 91 .dvbt_8 = { .if_freq = 4000, .agc_mode = 3, .std = 6, 92 .if_lvl = 1, .rfagc_top = 0x37, }, 93 }; 94 95 static struct tda18271_std_map mb86a20s_tda18271_config = { 96 .dvbt_6 = { .if_freq = 4000, .agc_mode = 3, .std = 4, 97 .if_lvl = 0, .rfagc_top = 0x37, }, 98 }; 99 100 static struct tda18271_config cnxt_rde253s_tunerconfig = { 101 .std_map = &cnxt_rde253s_tda18271_std_map, 102 .gate = TDA18271_GATE_ANALOG, 103 }; 104 105 static struct s5h1411_config tda18271_s5h1411_config = { 106 .output_mode = S5H1411_SERIAL_OUTPUT, 107 .gpio = S5H1411_GPIO_OFF, 108 .vsb_if = S5H1411_IF_3250, 109 .qam_if = S5H1411_IF_4000, 110 .inversion = S5H1411_INVERSION_ON, 111 .status_mode = S5H1411_DEMODLOCKING, 112 .mpeg_timing = S5H1411_MPEGTIMING_CONTINUOUS_NONINVERTING_CLOCK, 113 }; 114 static struct s5h1411_config xc5000_s5h1411_config = { 115 .output_mode = S5H1411_SERIAL_OUTPUT, 116 .gpio = S5H1411_GPIO_OFF, 117 .vsb_if = S5H1411_IF_3250, 118 .qam_if = S5H1411_IF_3250, 119 .inversion = S5H1411_INVERSION_OFF, 120 .status_mode = S5H1411_DEMODLOCKING, 121 .mpeg_timing = S5H1411_MPEGTIMING_CONTINUOUS_NONINVERTING_CLOCK, 122 }; 123 124 static struct lgdt3305_config hcw_lgdt3305_config = { 125 .i2c_addr = 0x0e, 126 .mpeg_mode = LGDT3305_MPEG_SERIAL, 127 .tpclk_edge = LGDT3305_TPCLK_FALLING_EDGE, 128 .tpvalid_polarity = LGDT3305_TP_VALID_HIGH, 129 .deny_i2c_rptr = 1, 130 .spectral_inversion = 1, 131 .qam_if_khz = 4000, 132 .vsb_if_khz = 3250, 133 }; 134 135 static struct tda18271_std_map hauppauge_tda18271_std_map = { 136 .atsc_6 = { .if_freq = 3250, .agc_mode = 3, .std = 4, 137 .if_lvl = 1, .rfagc_top = 0x58, }, 138 .qam_6 = { .if_freq = 4000, .agc_mode = 3, .std = 5, 139 .if_lvl = 1, .rfagc_top = 0x58, }, 140 }; 141 142 static struct tda18271_config hcw_tda18271_config = { 143 .std_map = &hauppauge_tda18271_std_map, 144 .gate = TDA18271_GATE_DIGITAL, 145 }; 146 147 static const struct mb86a20s_config pv_mb86a20s_config = { 148 .demod_address = 0x10, 149 .is_serial = true, 150 }; 151 152 static struct tda18271_config pv_tda18271_config = { 153 .std_map = &mb86a20s_tda18271_config, 154 .gate = TDA18271_GATE_DIGITAL, 155 .small_i2c = TDA18271_03_BYTE_CHUNK_INIT, 156 }; 157 158 static struct lgdt3306a_config hauppauge_955q_lgdt3306a_config = { 159 .i2c_addr = 0x59, 160 .qam_if_khz = 4000, 161 .vsb_if_khz = 3250, 162 .deny_i2c_rptr = 1, 163 .spectral_inversion = 1, 164 .mpeg_mode = LGDT3306A_MPEG_SERIAL, 165 .tpclk_edge = LGDT3306A_TPCLK_RISING_EDGE, 166 .tpvalid_polarity = LGDT3306A_TP_VALID_HIGH, 167 .xtalMHz = 25, 168 }; 169 170 static struct r820t_config astrometa_t2hybrid_r820t_config = { 171 .i2c_addr = 0x3a, /* 0x74 >> 1 */ 172 .xtal = 16000000, 173 .rafael_chip = CHIP_R828D, 174 .max_i2c_msg_len = 2, 175 }; 176 177 static inline void print_err_status(struct cx231xx *dev, int packet, int status) 178 { 179 char *errmsg = "Unknown"; 180 181 switch (status) { 182 case -ENOENT: 183 errmsg = "unlinked synchronously"; 184 break; 185 case -ECONNRESET: 186 errmsg = "unlinked asynchronously"; 187 break; 188 case -ENOSR: 189 errmsg = "Buffer error (overrun)"; 190 break; 191 case -EPIPE: 192 errmsg = "Stalled (device not responding)"; 193 break; 194 case -EOVERFLOW: 195 errmsg = "Babble (bad cable?)"; 196 break; 197 case -EPROTO: 198 errmsg = "Bit-stuff error (bad cable?)"; 199 break; 200 case -EILSEQ: 201 errmsg = "CRC/Timeout (could be anything)"; 202 break; 203 case -ETIME: 204 errmsg = "Device does not respond"; 205 break; 206 } 207 if (packet < 0) { 208 dev_dbg(dev->dev, 209 "URB status %d [%s].\n", status, errmsg); 210 } else { 211 dev_dbg(dev->dev, 212 "URB packet %d, status %d [%s].\n", 213 packet, status, errmsg); 214 } 215 } 216 217 static inline int dvb_isoc_copy(struct cx231xx *dev, struct urb *urb) 218 { 219 int i; 220 221 if (!dev) 222 return 0; 223 224 if (dev->state & DEV_DISCONNECTED) 225 return 0; 226 227 if (urb->status < 0) { 228 print_err_status(dev, -1, urb->status); 229 if (urb->status == -ENOENT) 230 return 0; 231 } 232 233 for (i = 0; i < urb->number_of_packets; i++) { 234 int status = urb->iso_frame_desc[i].status; 235 236 if (status < 0) { 237 print_err_status(dev, i, status); 238 if (urb->iso_frame_desc[i].status != -EPROTO) 239 continue; 240 } 241 242 dvb_dmx_swfilter(&dev->dvb->demux, 243 urb->transfer_buffer + 244 urb->iso_frame_desc[i].offset, 245 urb->iso_frame_desc[i].actual_length); 246 } 247 248 return 0; 249 } 250 251 static inline int dvb_bulk_copy(struct cx231xx *dev, struct urb *urb) 252 { 253 if (!dev) 254 return 0; 255 256 if (dev->state & DEV_DISCONNECTED) 257 return 0; 258 259 if (urb->status < 0) { 260 print_err_status(dev, -1, urb->status); 261 if (urb->status == -ENOENT) 262 return 0; 263 } 264 265 /* Feed the transport payload into the kernel demux */ 266 dvb_dmx_swfilter(&dev->dvb->demux, 267 urb->transfer_buffer, urb->actual_length); 268 269 return 0; 270 } 271 272 static int start_streaming(struct cx231xx_dvb *dvb) 273 { 274 int rc; 275 struct cx231xx *dev = dvb->adapter.priv; 276 277 if (dev->USE_ISO) { 278 dev_dbg(dev->dev, "DVB transfer mode is ISO.\n"); 279 cx231xx_set_alt_setting(dev, INDEX_TS1, 5); 280 rc = cx231xx_set_mode(dev, CX231XX_DIGITAL_MODE); 281 if (rc < 0) 282 return rc; 283 dev->mode_tv = 1; 284 return cx231xx_init_isoc(dev, CX231XX_DVB_MAX_PACKETS, 285 CX231XX_DVB_NUM_BUFS, 286 dev->ts1_mode.max_pkt_size, 287 dvb_isoc_copy); 288 } else { 289 dev_dbg(dev->dev, "DVB transfer mode is BULK.\n"); 290 cx231xx_set_alt_setting(dev, INDEX_TS1, 0); 291 rc = cx231xx_set_mode(dev, CX231XX_DIGITAL_MODE); 292 if (rc < 0) 293 return rc; 294 dev->mode_tv = 1; 295 return cx231xx_init_bulk(dev, CX231XX_DVB_MAX_PACKETS, 296 CX231XX_DVB_NUM_BUFS, 297 dev->ts1_mode.max_pkt_size, 298 dvb_bulk_copy); 299 } 300 301 } 302 303 static int stop_streaming(struct cx231xx_dvb *dvb) 304 { 305 struct cx231xx *dev = dvb->adapter.priv; 306 307 if (dev->USE_ISO) 308 cx231xx_uninit_isoc(dev); 309 else 310 cx231xx_uninit_bulk(dev); 311 312 cx231xx_set_mode(dev, CX231XX_SUSPEND); 313 314 return 0; 315 } 316 317 static int start_feed(struct dvb_demux_feed *feed) 318 { 319 struct dvb_demux *demux = feed->demux; 320 struct cx231xx_dvb *dvb = demux->priv; 321 int rc, ret; 322 323 if (!demux->dmx.frontend) 324 return -EINVAL; 325 326 mutex_lock(&dvb->lock); 327 dvb->nfeeds++; 328 rc = dvb->nfeeds; 329 330 if (dvb->nfeeds == 1) { 331 ret = start_streaming(dvb); 332 if (ret < 0) 333 rc = ret; 334 } 335 336 mutex_unlock(&dvb->lock); 337 return rc; 338 } 339 340 static int stop_feed(struct dvb_demux_feed *feed) 341 { 342 struct dvb_demux *demux = feed->demux; 343 struct cx231xx_dvb *dvb = demux->priv; 344 int err = 0; 345 346 mutex_lock(&dvb->lock); 347 dvb->nfeeds--; 348 349 if (0 == dvb->nfeeds) 350 err = stop_streaming(dvb); 351 352 mutex_unlock(&dvb->lock); 353 return err; 354 } 355 356 /* ------------------------------------------------------------------ */ 357 static int cx231xx_dvb_bus_ctrl(struct dvb_frontend *fe, int acquire) 358 { 359 struct cx231xx *dev = fe->dvb->priv; 360 361 if (acquire) 362 return cx231xx_set_mode(dev, CX231XX_DIGITAL_MODE); 363 else 364 return cx231xx_set_mode(dev, CX231XX_SUSPEND); 365 } 366 367 /* ------------------------------------------------------------------ */ 368 369 static struct xc5000_config cnxt_rde250_tunerconfig = { 370 .i2c_address = 0x61, 371 .if_khz = 4000, 372 }; 373 static struct xc5000_config cnxt_rdu250_tunerconfig = { 374 .i2c_address = 0x61, 375 .if_khz = 3250, 376 }; 377 378 /* ------------------------------------------------------------------ */ 379 #if 0 380 static int attach_xc5000(u8 addr, struct cx231xx *dev) 381 { 382 383 struct dvb_frontend *fe; 384 struct xc5000_config cfg; 385 386 memset(&cfg, 0, sizeof(cfg)); 387 cfg.i2c_adap = cx231xx_get_i2c_adap(dev, dev->board.tuner_i2c_master); 388 cfg.i2c_addr = addr; 389 390 if (!dev->dvb->frontend[0]) { 391 dev_err(dev->dev, "%s/2: dvb frontend not attached. Can't attach xc5000\n", 392 dev->name); 393 return -EINVAL; 394 } 395 396 fe = dvb_attach(xc5000_attach, dev->dvb->frontend[0], &cfg); 397 if (!fe) { 398 dev_err(dev->dev, "%s/2: xc5000 attach failed\n", dev->name); 399 dvb_frontend_detach(dev->dvb->frontend[0]); 400 dev->dvb->frontend[0] = NULL; 401 return -EINVAL; 402 } 403 404 dev_info(dev->dev, "%s/2: xc5000 attached\n", dev->name); 405 406 return 0; 407 } 408 #endif 409 410 int cx231xx_set_analog_freq(struct cx231xx *dev, u32 freq) 411 { 412 if (dev->dvb && dev->dvb->frontend[0]) { 413 414 struct dvb_tuner_ops *dops = &dev->dvb->frontend[0]->ops.tuner_ops; 415 416 if (dops->set_analog_params != NULL) { 417 struct analog_parameters params; 418 419 params.frequency = freq; 420 params.std = dev->norm; 421 params.mode = 0; /* 0- Air; 1 - cable */ 422 /*params.audmode = ; */ 423 424 /* Set the analog parameters to set the frequency */ 425 dops->set_analog_params(dev->dvb->frontend[0], ¶ms); 426 } 427 428 } 429 430 return 0; 431 } 432 433 int cx231xx_reset_analog_tuner(struct cx231xx *dev) 434 { 435 int status = 0; 436 437 if (dev->dvb && dev->dvb->frontend[0]) { 438 439 struct dvb_tuner_ops *dops = &dev->dvb->frontend[0]->ops.tuner_ops; 440 441 if (dops->init != NULL && !dev->xc_fw_load_done) { 442 443 dev_dbg(dev->dev, 444 "Reloading firmware for XC5000\n"); 445 status = dops->init(dev->dvb->frontend[0]); 446 if (status == 0) { 447 dev->xc_fw_load_done = 1; 448 dev_dbg(dev->dev, 449 "XC5000 firmware download completed\n"); 450 } else { 451 dev->xc_fw_load_done = 0; 452 dev_dbg(dev->dev, 453 "XC5000 firmware download failed !!!\n"); 454 } 455 } 456 457 } 458 459 return status; 460 } 461 462 /* ------------------------------------------------------------------ */ 463 464 static int register_dvb(struct cx231xx_dvb *dvb, 465 struct module *module, 466 struct cx231xx *dev, struct device *device) 467 { 468 int result; 469 470 mutex_init(&dvb->lock); 471 472 473 /* register adapter */ 474 result = dvb_register_adapter(&dvb->adapter, dev->name, module, device, 475 adapter_nr); 476 if (result < 0) { 477 dev_warn(dev->dev, 478 "%s: dvb_register_adapter failed (errno = %d)\n", 479 dev->name, result); 480 goto fail_adapter; 481 } 482 dvb_register_media_controller(&dvb->adapter, dev->media_dev); 483 484 /* Ensure all frontends negotiate bus access */ 485 dvb->frontend[0]->ops.ts_bus_ctrl = cx231xx_dvb_bus_ctrl; 486 if (dvb->frontend[1]) 487 dvb->frontend[1]->ops.ts_bus_ctrl = cx231xx_dvb_bus_ctrl; 488 489 dvb->adapter.priv = dev; 490 491 /* register frontend */ 492 result = dvb_register_frontend(&dvb->adapter, dvb->frontend[0]); 493 if (result < 0) { 494 dev_warn(dev->dev, 495 "%s: dvb_register_frontend failed (errno = %d)\n", 496 dev->name, result); 497 goto fail_frontend0; 498 } 499 500 if (dvb->frontend[1]) { 501 result = dvb_register_frontend(&dvb->adapter, dvb->frontend[1]); 502 if (result < 0) { 503 dev_warn(dev->dev, 504 "%s: 2nd dvb_register_frontend failed (errno = %d)\n", 505 dev->name, result); 506 goto fail_frontend1; 507 } 508 509 /* MFE lock */ 510 dvb->adapter.mfe_shared = 1; 511 } 512 513 /* register demux stuff */ 514 dvb->demux.dmx.capabilities = 515 DMX_TS_FILTERING | DMX_SECTION_FILTERING | 516 DMX_MEMORY_BASED_FILTERING; 517 dvb->demux.priv = dvb; 518 dvb->demux.filternum = 256; 519 dvb->demux.feednum = 256; 520 dvb->demux.start_feed = start_feed; 521 dvb->demux.stop_feed = stop_feed; 522 523 result = dvb_dmx_init(&dvb->demux); 524 if (result < 0) { 525 dev_warn(dev->dev, 526 "%s: dvb_dmx_init failed (errno = %d)\n", 527 dev->name, result); 528 goto fail_dmx; 529 } 530 531 dvb->dmxdev.filternum = 256; 532 dvb->dmxdev.demux = &dvb->demux.dmx; 533 dvb->dmxdev.capabilities = 0; 534 result = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter); 535 if (result < 0) { 536 dev_warn(dev->dev, 537 "%s: dvb_dmxdev_init failed (errno = %d)\n", 538 dev->name, result); 539 goto fail_dmxdev; 540 } 541 542 dvb->fe_hw.source = DMX_FRONTEND_0; 543 result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_hw); 544 if (result < 0) { 545 dev_warn(dev->dev, 546 "%s: add_frontend failed (DMX_FRONTEND_0, errno = %d)\n", 547 dev->name, result); 548 goto fail_fe_hw; 549 } 550 551 dvb->fe_mem.source = DMX_MEMORY_FE; 552 result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_mem); 553 if (result < 0) { 554 dev_warn(dev->dev, 555 "%s: add_frontend failed (DMX_MEMORY_FE, errno = %d)\n", 556 dev->name, result); 557 goto fail_fe_mem; 558 } 559 560 result = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx, &dvb->fe_hw); 561 if (result < 0) { 562 dev_warn(dev->dev, 563 "%s: connect_frontend failed (errno = %d)\n", 564 dev->name, result); 565 goto fail_fe_conn; 566 } 567 568 /* register network adapter */ 569 dvb_net_init(&dvb->adapter, &dvb->net, &dvb->demux.dmx); 570 result = dvb_create_media_graph(&dvb->adapter, 571 dev->tuner_type == TUNER_ABSENT); 572 if (result < 0) 573 goto fail_create_graph; 574 575 return 0; 576 577 fail_create_graph: 578 dvb_net_release(&dvb->net); 579 fail_fe_conn: 580 dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem); 581 fail_fe_mem: 582 dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw); 583 fail_fe_hw: 584 dvb_dmxdev_release(&dvb->dmxdev); 585 fail_dmxdev: 586 dvb_dmx_release(&dvb->demux); 587 fail_dmx: 588 if (dvb->frontend[1]) 589 dvb_unregister_frontend(dvb->frontend[1]); 590 dvb_unregister_frontend(dvb->frontend[0]); 591 fail_frontend1: 592 if (dvb->frontend[1]) 593 dvb_frontend_detach(dvb->frontend[1]); 594 fail_frontend0: 595 dvb_frontend_detach(dvb->frontend[0]); 596 dvb_unregister_adapter(&dvb->adapter); 597 fail_adapter: 598 return result; 599 } 600 601 static void unregister_dvb(struct cx231xx_dvb *dvb) 602 { 603 struct i2c_client *client; 604 dvb_net_release(&dvb->net); 605 dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem); 606 dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw); 607 dvb_dmxdev_release(&dvb->dmxdev); 608 dvb_dmx_release(&dvb->demux); 609 if (dvb->frontend[1]) 610 dvb_unregister_frontend(dvb->frontend[1]); 611 dvb_unregister_frontend(dvb->frontend[0]); 612 if (dvb->frontend[1]) 613 dvb_frontend_detach(dvb->frontend[1]); 614 dvb_frontend_detach(dvb->frontend[0]); 615 dvb_unregister_adapter(&dvb->adapter); 616 /* remove I2C tuner */ 617 client = dvb->i2c_client_tuner; 618 if (client) { 619 module_put(client->dev.driver->owner); 620 i2c_unregister_device(client); 621 } 622 /* remove I2C demod */ 623 client = dvb->i2c_client_demod[1]; 624 if (client) { 625 module_put(client->dev.driver->owner); 626 i2c_unregister_device(client); 627 } 628 client = dvb->i2c_client_demod[0]; 629 if (client) { 630 module_put(client->dev.driver->owner); 631 i2c_unregister_device(client); 632 } 633 } 634 635 static int dvb_init(struct cx231xx *dev) 636 { 637 int result; 638 struct cx231xx_dvb *dvb; 639 struct i2c_adapter *tuner_i2c; 640 struct i2c_adapter *demod_i2c; 641 642 if (!dev->board.has_dvb) { 643 /* This device does not support the extension */ 644 return 0; 645 } 646 647 dvb = kzalloc(sizeof(struct cx231xx_dvb), GFP_KERNEL); 648 649 if (dvb == NULL) { 650 dev_info(dev->dev, 651 "cx231xx_dvb: memory allocation failed\n"); 652 return -ENOMEM; 653 } 654 dev->dvb = dvb; 655 dev->cx231xx_set_analog_freq = cx231xx_set_analog_freq; 656 dev->cx231xx_reset_analog_tuner = cx231xx_reset_analog_tuner; 657 658 tuner_i2c = cx231xx_get_i2c_adap(dev, dev->board.tuner_i2c_master); 659 demod_i2c = cx231xx_get_i2c_adap(dev, dev->board.demod_i2c_master); 660 mutex_lock(&dev->lock); 661 cx231xx_set_mode(dev, CX231XX_DIGITAL_MODE); 662 cx231xx_demod_reset(dev); 663 /* init frontend */ 664 switch (dev->model) { 665 case CX231XX_BOARD_CNXT_CARRAERA: 666 case CX231XX_BOARD_CNXT_RDE_250: 667 668 dev->dvb->frontend[0] = dvb_attach(s5h1432_attach, 669 &dvico_s5h1432_config, 670 demod_i2c); 671 672 if (!dev->dvb->frontend[0]) { 673 dev_err(dev->dev, 674 "Failed to attach s5h1432 front end\n"); 675 result = -EINVAL; 676 goto out_free; 677 } 678 679 /* define general-purpose callback pointer */ 680 dvb->frontend[0]->callback = cx231xx_tuner_callback; 681 682 if (!dvb_attach(xc5000_attach, dev->dvb->frontend[0], 683 tuner_i2c, 684 &cnxt_rde250_tunerconfig)) { 685 result = -EINVAL; 686 goto out_free; 687 } 688 689 break; 690 case CX231XX_BOARD_CNXT_SHELBY: 691 case CX231XX_BOARD_CNXT_RDU_250: 692 693 dev->dvb->frontend[0] = dvb_attach(s5h1411_attach, 694 &xc5000_s5h1411_config, 695 demod_i2c); 696 697 if (!dev->dvb->frontend[0]) { 698 dev_err(dev->dev, 699 "Failed to attach s5h1411 front end\n"); 700 result = -EINVAL; 701 goto out_free; 702 } 703 704 /* define general-purpose callback pointer */ 705 dvb->frontend[0]->callback = cx231xx_tuner_callback; 706 707 if (!dvb_attach(xc5000_attach, dev->dvb->frontend[0], 708 tuner_i2c, 709 &cnxt_rdu250_tunerconfig)) { 710 result = -EINVAL; 711 goto out_free; 712 } 713 break; 714 case CX231XX_BOARD_CNXT_RDE_253S: 715 716 dev->dvb->frontend[0] = dvb_attach(s5h1432_attach, 717 &dvico_s5h1432_config, 718 demod_i2c); 719 720 if (!dev->dvb->frontend[0]) { 721 dev_err(dev->dev, 722 "Failed to attach s5h1432 front end\n"); 723 result = -EINVAL; 724 goto out_free; 725 } 726 727 /* define general-purpose callback pointer */ 728 dvb->frontend[0]->callback = cx231xx_tuner_callback; 729 730 if (!dvb_attach(tda18271_attach, dev->dvb->frontend[0], 731 0x60, tuner_i2c, 732 &cnxt_rde253s_tunerconfig)) { 733 result = -EINVAL; 734 goto out_free; 735 } 736 break; 737 case CX231XX_BOARD_CNXT_RDU_253S: 738 case CX231XX_BOARD_KWORLD_UB445_USB_HYBRID: 739 740 dev->dvb->frontend[0] = dvb_attach(s5h1411_attach, 741 &tda18271_s5h1411_config, 742 demod_i2c); 743 744 if (!dev->dvb->frontend[0]) { 745 dev_err(dev->dev, 746 "Failed to attach s5h1411 front end\n"); 747 result = -EINVAL; 748 goto out_free; 749 } 750 751 /* define general-purpose callback pointer */ 752 dvb->frontend[0]->callback = cx231xx_tuner_callback; 753 754 if (!dvb_attach(tda18271_attach, dev->dvb->frontend[0], 755 0x60, tuner_i2c, 756 &cnxt_rde253s_tunerconfig)) { 757 result = -EINVAL; 758 goto out_free; 759 } 760 break; 761 case CX231XX_BOARD_HAUPPAUGE_EXETER: 762 763 dev_info(dev->dev, 764 "%s: looking for tuner / demod on i2c bus: %d\n", 765 __func__, i2c_adapter_id(tuner_i2c)); 766 767 dev->dvb->frontend[0] = dvb_attach(lgdt3305_attach, 768 &hcw_lgdt3305_config, 769 demod_i2c); 770 771 if (!dev->dvb->frontend[0]) { 772 dev_err(dev->dev, 773 "Failed to attach LG3305 front end\n"); 774 result = -EINVAL; 775 goto out_free; 776 } 777 778 /* define general-purpose callback pointer */ 779 dvb->frontend[0]->callback = cx231xx_tuner_callback; 780 781 dvb_attach(tda18271_attach, dev->dvb->frontend[0], 782 0x60, tuner_i2c, 783 &hcw_tda18271_config); 784 break; 785 786 case CX231XX_BOARD_HAUPPAUGE_930C_HD_1113xx: 787 { 788 struct i2c_client *client; 789 struct i2c_board_info info; 790 struct si2165_platform_data si2165_pdata; 791 792 /* attach demod */ 793 memset(&si2165_pdata, 0, sizeof(si2165_pdata)); 794 si2165_pdata.fe = &dev->dvb->frontend[0]; 795 si2165_pdata.chip_mode = SI2165_MODE_PLL_XTAL; 796 si2165_pdata.ref_freq_hz = 16000000; 797 798 memset(&info, 0, sizeof(struct i2c_board_info)); 799 strlcpy(info.type, "si2165", I2C_NAME_SIZE); 800 info.addr = 0x64; 801 info.platform_data = &si2165_pdata; 802 request_module(info.type); 803 client = i2c_new_device(demod_i2c, &info); 804 if (!client || !client->dev.driver || !dev->dvb->frontend[0]) { 805 dev_err(dev->dev, 806 "Failed to attach SI2165 front end\n"); 807 result = -EINVAL; 808 goto out_free; 809 } 810 811 if (!try_module_get(client->dev.driver->owner)) { 812 i2c_unregister_device(client); 813 result = -ENODEV; 814 goto out_free; 815 } 816 817 dvb->i2c_client_demod[0] = client; 818 819 dev->dvb->frontend[0]->ops.i2c_gate_ctrl = NULL; 820 821 /* define general-purpose callback pointer */ 822 dvb->frontend[0]->callback = cx231xx_tuner_callback; 823 824 dvb_attach(tda18271_attach, dev->dvb->frontend[0], 825 0x60, 826 tuner_i2c, 827 &hcw_tda18271_config); 828 829 dev->cx231xx_reset_analog_tuner = NULL; 830 break; 831 } 832 case CX231XX_BOARD_HAUPPAUGE_930C_HD_1114xx: 833 { 834 struct i2c_client *client; 835 struct i2c_board_info info; 836 struct si2165_platform_data si2165_pdata; 837 struct si2157_config si2157_config; 838 839 /* attach demod */ 840 memset(&si2165_pdata, 0, sizeof(si2165_pdata)); 841 si2165_pdata.fe = &dev->dvb->frontend[0]; 842 si2165_pdata.chip_mode = SI2165_MODE_PLL_EXT; 843 si2165_pdata.ref_freq_hz = 24000000; 844 845 memset(&info, 0, sizeof(struct i2c_board_info)); 846 strlcpy(info.type, "si2165", I2C_NAME_SIZE); 847 info.addr = 0x64; 848 info.platform_data = &si2165_pdata; 849 request_module(info.type); 850 client = i2c_new_device(demod_i2c, &info); 851 if (!client || !client->dev.driver || !dev->dvb->frontend[0]) { 852 dev_err(dev->dev, 853 "Failed to attach SI2165 front end\n"); 854 result = -EINVAL; 855 goto out_free; 856 } 857 858 if (!try_module_get(client->dev.driver->owner)) { 859 i2c_unregister_device(client); 860 result = -ENODEV; 861 goto out_free; 862 } 863 864 dvb->i2c_client_demod[0] = client; 865 866 memset(&info, 0, sizeof(struct i2c_board_info)); 867 868 dev->dvb->frontend[0]->ops.i2c_gate_ctrl = NULL; 869 870 /* define general-purpose callback pointer */ 871 dvb->frontend[0]->callback = cx231xx_tuner_callback; 872 873 /* attach tuner */ 874 memset(&si2157_config, 0, sizeof(si2157_config)); 875 si2157_config.fe = dev->dvb->frontend[0]; 876 #ifdef CONFIG_MEDIA_CONTROLLER_DVB 877 si2157_config.mdev = dev->media_dev; 878 #endif 879 si2157_config.if_port = 1; 880 si2157_config.inversion = true; 881 strlcpy(info.type, "si2157", I2C_NAME_SIZE); 882 info.addr = 0x60; 883 info.platform_data = &si2157_config; 884 request_module("si2157"); 885 886 client = i2c_new_device( 887 tuner_i2c, 888 &info); 889 if (client == NULL || client->dev.driver == NULL) { 890 dvb_frontend_detach(dev->dvb->frontend[0]); 891 result = -ENODEV; 892 goto out_free; 893 } 894 895 if (!try_module_get(client->dev.driver->owner)) { 896 i2c_unregister_device(client); 897 dvb_frontend_detach(dev->dvb->frontend[0]); 898 result = -ENODEV; 899 goto out_free; 900 } 901 902 dev->cx231xx_reset_analog_tuner = NULL; 903 904 dev->dvb->i2c_client_tuner = client; 905 break; 906 } 907 case CX231XX_BOARD_HAUPPAUGE_955Q: 908 { 909 struct i2c_client *client; 910 struct i2c_board_info info; 911 struct si2157_config si2157_config; 912 913 memset(&info, 0, sizeof(struct i2c_board_info)); 914 915 dev->dvb->frontend[0] = dvb_attach(lgdt3306a_attach, 916 &hauppauge_955q_lgdt3306a_config, 917 demod_i2c 918 ); 919 920 if (!dev->dvb->frontend[0]) { 921 dev_err(dev->dev, 922 "Failed to attach LGDT3306A frontend.\n"); 923 result = -EINVAL; 924 goto out_free; 925 } 926 927 dev->dvb->frontend[0]->ops.i2c_gate_ctrl = NULL; 928 929 /* define general-purpose callback pointer */ 930 dvb->frontend[0]->callback = cx231xx_tuner_callback; 931 932 /* attach tuner */ 933 memset(&si2157_config, 0, sizeof(si2157_config)); 934 si2157_config.fe = dev->dvb->frontend[0]; 935 #ifdef CONFIG_MEDIA_CONTROLLER_DVB 936 si2157_config.mdev = dev->media_dev; 937 #endif 938 si2157_config.if_port = 1; 939 si2157_config.inversion = true; 940 strlcpy(info.type, "si2157", I2C_NAME_SIZE); 941 info.addr = 0x60; 942 info.platform_data = &si2157_config; 943 request_module("si2157"); 944 945 client = i2c_new_device( 946 tuner_i2c, 947 &info); 948 if (client == NULL || client->dev.driver == NULL) { 949 dvb_frontend_detach(dev->dvb->frontend[0]); 950 result = -ENODEV; 951 goto out_free; 952 } 953 954 if (!try_module_get(client->dev.driver->owner)) { 955 i2c_unregister_device(client); 956 dvb_frontend_detach(dev->dvb->frontend[0]); 957 result = -ENODEV; 958 goto out_free; 959 } 960 961 dev->cx231xx_reset_analog_tuner = NULL; 962 963 dev->dvb->i2c_client_tuner = client; 964 break; 965 } 966 case CX231XX_BOARD_PV_PLAYTV_USB_HYBRID: 967 case CX231XX_BOARD_KWORLD_UB430_USB_HYBRID: 968 969 dev_info(dev->dev, 970 "%s: looking for demod on i2c bus: %d\n", 971 __func__, i2c_adapter_id(tuner_i2c)); 972 973 dev->dvb->frontend[0] = dvb_attach(mb86a20s_attach, 974 &pv_mb86a20s_config, 975 demod_i2c); 976 977 if (!dev->dvb->frontend[0]) { 978 dev_err(dev->dev, 979 "Failed to attach mb86a20s demod\n"); 980 result = -EINVAL; 981 goto out_free; 982 } 983 984 /* define general-purpose callback pointer */ 985 dvb->frontend[0]->callback = cx231xx_tuner_callback; 986 987 dvb_attach(tda18271_attach, dev->dvb->frontend[0], 988 0x60, tuner_i2c, 989 &pv_tda18271_config); 990 break; 991 992 case CX231XX_BOARD_EVROMEDIA_FULL_HYBRID_FULLHD: 993 { 994 struct si2157_config si2157_config = {}; 995 struct si2168_config si2168_config = {}; 996 struct i2c_board_info info = {}; 997 struct i2c_client *client; 998 struct i2c_adapter *adapter; 999 1000 /* attach demodulator chip */ 1001 si2168_config.ts_mode = SI2168_TS_SERIAL; /* from *.inf file */ 1002 si2168_config.fe = &dev->dvb->frontend[0]; 1003 si2168_config.i2c_adapter = &adapter; 1004 si2168_config.ts_clock_inv = true; 1005 1006 strlcpy(info.type, "si2168", sizeof(info.type)); 1007 info.addr = dev->board.demod_addr; 1008 info.platform_data = &si2168_config; 1009 1010 request_module(info.type); 1011 client = i2c_new_device(demod_i2c, &info); 1012 1013 if (client == NULL || client->dev.driver == NULL) { 1014 result = -ENODEV; 1015 goto out_free; 1016 } 1017 1018 if (!try_module_get(client->dev.driver->owner)) { 1019 i2c_unregister_device(client); 1020 result = -ENODEV; 1021 goto out_free; 1022 } 1023 1024 dvb->i2c_client_demod[0] = client; 1025 1026 /* attach tuner chip */ 1027 si2157_config.fe = dev->dvb->frontend[0]; 1028 #ifdef CONFIG_MEDIA_CONTROLLER_DVB 1029 si2157_config.mdev = dev->media_dev; 1030 #endif 1031 si2157_config.if_port = 1; 1032 si2157_config.inversion = false; 1033 1034 memset(&info, 0, sizeof(info)); 1035 strlcpy(info.type, "si2157", sizeof(info.type)); 1036 info.addr = dev->board.tuner_addr; 1037 info.platform_data = &si2157_config; 1038 1039 request_module(info.type); 1040 client = i2c_new_device(tuner_i2c, &info); 1041 1042 if (client == NULL || client->dev.driver == NULL) { 1043 module_put(dvb->i2c_client_demod[0]->dev.driver->owner); 1044 i2c_unregister_device(dvb->i2c_client_demod[0]); 1045 result = -ENODEV; 1046 goto out_free; 1047 } 1048 1049 if (!try_module_get(client->dev.driver->owner)) { 1050 i2c_unregister_device(client); 1051 module_put(dvb->i2c_client_demod[0]->dev.driver->owner); 1052 i2c_unregister_device(dvb->i2c_client_demod[0]); 1053 result = -ENODEV; 1054 goto out_free; 1055 } 1056 1057 dev->cx231xx_reset_analog_tuner = NULL; 1058 dev->dvb->i2c_client_tuner = client; 1059 break; 1060 } 1061 case CX231XX_BOARD_ASTROMETA_T2HYBRID: 1062 { 1063 struct i2c_client *client; 1064 struct i2c_board_info info = {}; 1065 struct mn88473_config mn88473_config = {}; 1066 1067 /* attach demodulator chip */ 1068 mn88473_config.i2c_wr_max = 16; 1069 mn88473_config.xtal = 25000000; 1070 mn88473_config.fe = &dev->dvb->frontend[0]; 1071 1072 strlcpy(info.type, "mn88473", sizeof(info.type)); 1073 info.addr = dev->board.demod_addr; 1074 info.platform_data = &mn88473_config; 1075 1076 request_module(info.type); 1077 client = i2c_new_device(demod_i2c, &info); 1078 1079 if (client == NULL || client->dev.driver == NULL) { 1080 result = -ENODEV; 1081 goto out_free; 1082 } 1083 1084 if (!try_module_get(client->dev.driver->owner)) { 1085 i2c_unregister_device(client); 1086 result = -ENODEV; 1087 goto out_free; 1088 } 1089 1090 dvb->i2c_client_demod[0] = client; 1091 1092 /* define general-purpose callback pointer */ 1093 dvb->frontend[0]->callback = cx231xx_tuner_callback; 1094 1095 /* attach tuner chip */ 1096 dvb_attach(r820t_attach, dev->dvb->frontend[0], 1097 tuner_i2c, 1098 &astrometa_t2hybrid_r820t_config); 1099 break; 1100 } 1101 case CX231XX_BOARD_HAUPPAUGE_935C: 1102 { 1103 struct i2c_client *client; 1104 struct i2c_adapter *adapter; 1105 struct i2c_board_info info = {}; 1106 struct si2157_config si2157_config = {}; 1107 struct si2168_config si2168_config = {}; 1108 1109 /* attach demodulator chip */ 1110 si2168_config.ts_mode = SI2168_TS_SERIAL; 1111 si2168_config.fe = &dev->dvb->frontend[0]; 1112 si2168_config.i2c_adapter = &adapter; 1113 si2168_config.ts_clock_inv = true; 1114 1115 strlcpy(info.type, "si2168", sizeof(info.type)); 1116 info.addr = dev->board.demod_addr; 1117 info.platform_data = &si2168_config; 1118 1119 request_module(info.type); 1120 client = i2c_new_device(demod_i2c, &info); 1121 if (client == NULL || client->dev.driver == NULL) { 1122 result = -ENODEV; 1123 goto out_free; 1124 } 1125 1126 if (!try_module_get(client->dev.driver->owner)) { 1127 dev_err(dev->dev, 1128 "Failed to attach %s frontend.\n", info.type); 1129 i2c_unregister_device(client); 1130 result = -ENODEV; 1131 goto out_free; 1132 } 1133 1134 dvb->i2c_client_demod[0] = client; 1135 dev->dvb->frontend[0]->ops.i2c_gate_ctrl = NULL; 1136 1137 /* define general-purpose callback pointer */ 1138 dvb->frontend[0]->callback = cx231xx_tuner_callback; 1139 1140 /* attach tuner */ 1141 si2157_config.fe = dev->dvb->frontend[0]; 1142 #ifdef CONFIG_MEDIA_CONTROLLER_DVB 1143 si2157_config.mdev = dev->media_dev; 1144 #endif 1145 si2157_config.if_port = 1; 1146 si2157_config.inversion = true; 1147 1148 memset(&info, 0, sizeof(struct i2c_board_info)); 1149 strlcpy(info.type, "si2157", I2C_NAME_SIZE); 1150 info.addr = dev->board.tuner_addr; 1151 info.platform_data = &si2157_config; 1152 request_module("si2157"); 1153 1154 client = i2c_new_device(adapter, &info); 1155 if (client == NULL || client->dev.driver == NULL) { 1156 module_put(dvb->i2c_client_demod[0]->dev.driver->owner); 1157 i2c_unregister_device(dvb->i2c_client_demod[0]); 1158 result = -ENODEV; 1159 goto out_free; 1160 } 1161 1162 if (!try_module_get(client->dev.driver->owner)) { 1163 dev_err(dev->dev, 1164 "Failed to obtain %s tuner.\n", info.type); 1165 i2c_unregister_device(client); 1166 module_put(dvb->i2c_client_demod[0]->dev.driver->owner); 1167 i2c_unregister_device(dvb->i2c_client_demod[0]); 1168 result = -ENODEV; 1169 goto out_free; 1170 } 1171 1172 dev->cx231xx_reset_analog_tuner = NULL; 1173 dev->dvb->i2c_client_tuner = client; 1174 break; 1175 } 1176 case CX231XX_BOARD_HAUPPAUGE_975: 1177 { 1178 struct i2c_client *client; 1179 struct i2c_adapter *adapter; 1180 struct i2c_adapter *adapter2; 1181 struct i2c_board_info info = {}; 1182 struct si2157_config si2157_config = {}; 1183 struct lgdt3306a_config lgdt3306a_config = {}; 1184 struct si2168_config si2168_config = {}; 1185 1186 /* attach first demodulator chip */ 1187 lgdt3306a_config = hauppauge_955q_lgdt3306a_config; 1188 lgdt3306a_config.fe = &dev->dvb->frontend[0]; 1189 lgdt3306a_config.i2c_adapter = &adapter; 1190 lgdt3306a_config.deny_i2c_rptr = 0; 1191 1192 strlcpy(info.type, "lgdt3306a", sizeof(info.type)); 1193 info.addr = dev->board.demod_addr; 1194 info.platform_data = &lgdt3306a_config; 1195 1196 request_module(info.type); 1197 client = i2c_new_device(demod_i2c, &info); 1198 if (client == NULL || client->dev.driver == NULL) { 1199 result = -ENODEV; 1200 goto out_free; 1201 } 1202 1203 if (!try_module_get(client->dev.driver->owner)) { 1204 dev_err(dev->dev, 1205 "Failed to attach %s frontend.\n", info.type); 1206 i2c_unregister_device(client); 1207 result = -ENODEV; 1208 goto out_free; 1209 } 1210 1211 dvb->i2c_client_demod[0] = client; 1212 1213 /* attach second demodulator chip */ 1214 si2168_config.ts_mode = SI2168_TS_SERIAL; 1215 si2168_config.fe = &dev->dvb->frontend[1]; 1216 si2168_config.i2c_adapter = &adapter2; 1217 si2168_config.ts_clock_inv = true; 1218 1219 memset(&info, 0, sizeof(struct i2c_board_info)); 1220 strlcpy(info.type, "si2168", sizeof(info.type)); 1221 info.addr = dev->board.demod_addr2; 1222 info.platform_data = &si2168_config; 1223 1224 request_module(info.type); 1225 client = i2c_new_device(adapter, &info); 1226 if (client == NULL || client->dev.driver == NULL) { 1227 dev_err(dev->dev, 1228 "Failed to attach %s frontend.\n", info.type); 1229 module_put(dvb->i2c_client_demod[0]->dev.driver->owner); 1230 i2c_unregister_device(dvb->i2c_client_demod[0]); 1231 result = -ENODEV; 1232 goto out_free; 1233 } 1234 1235 if (!try_module_get(client->dev.driver->owner)) { 1236 i2c_unregister_device(client); 1237 module_put(dvb->i2c_client_demod[0]->dev.driver->owner); 1238 i2c_unregister_device(dvb->i2c_client_demod[0]); 1239 result = -ENODEV; 1240 goto out_free; 1241 } 1242 1243 dvb->i2c_client_demod[1] = client; 1244 dvb->frontend[1]->id = 1; 1245 1246 /* define general-purpose callback pointer */ 1247 dvb->frontend[0]->callback = cx231xx_tuner_callback; 1248 dvb->frontend[1]->callback = cx231xx_tuner_callback; 1249 1250 /* attach tuner */ 1251 si2157_config.fe = dev->dvb->frontend[0]; 1252 #ifdef CONFIG_MEDIA_CONTROLLER_DVB 1253 si2157_config.mdev = dev->media_dev; 1254 #endif 1255 si2157_config.if_port = 1; 1256 si2157_config.inversion = true; 1257 1258 memset(&info, 0, sizeof(struct i2c_board_info)); 1259 strlcpy(info.type, "si2157", I2C_NAME_SIZE); 1260 info.addr = dev->board.tuner_addr; 1261 info.platform_data = &si2157_config; 1262 request_module("si2157"); 1263 1264 client = i2c_new_device(adapter, &info); 1265 if (client == NULL || client->dev.driver == NULL) { 1266 module_put(dvb->i2c_client_demod[1]->dev.driver->owner); 1267 i2c_unregister_device(dvb->i2c_client_demod[1]); 1268 module_put(dvb->i2c_client_demod[0]->dev.driver->owner); 1269 i2c_unregister_device(dvb->i2c_client_demod[0]); 1270 result = -ENODEV; 1271 goto out_free; 1272 } 1273 1274 if (!try_module_get(client->dev.driver->owner)) { 1275 dev_err(dev->dev, 1276 "Failed to obtain %s tuner.\n", info.type); 1277 i2c_unregister_device(client); 1278 module_put(dvb->i2c_client_demod[1]->dev.driver->owner); 1279 i2c_unregister_device(dvb->i2c_client_demod[1]); 1280 module_put(dvb->i2c_client_demod[0]->dev.driver->owner); 1281 i2c_unregister_device(dvb->i2c_client_demod[0]); 1282 result = -ENODEV; 1283 goto out_free; 1284 } 1285 1286 dev->cx231xx_reset_analog_tuner = NULL; 1287 dvb->i2c_client_tuner = client; 1288 1289 dvb->frontend[1]->tuner_priv = dvb->frontend[0]->tuner_priv; 1290 1291 memcpy(&dvb->frontend[1]->ops.tuner_ops, 1292 &dvb->frontend[0]->ops.tuner_ops, 1293 sizeof(struct dvb_tuner_ops)); 1294 break; 1295 } 1296 default: 1297 dev_err(dev->dev, 1298 "%s/2: The frontend of your DVB/ATSC card isn't supported yet\n", 1299 dev->name); 1300 break; 1301 } 1302 if (!dvb->frontend[0]) { 1303 dev_err(dev->dev, 1304 "%s/2: frontend initialization failed\n", dev->name); 1305 result = -EINVAL; 1306 goto out_free; 1307 } 1308 1309 /* register everything */ 1310 result = register_dvb(dvb, THIS_MODULE, dev, dev->dev); 1311 1312 if (result < 0) 1313 goto out_free; 1314 1315 1316 dev_info(dev->dev, "Successfully loaded cx231xx-dvb\n"); 1317 1318 ret: 1319 cx231xx_set_mode(dev, CX231XX_SUSPEND); 1320 mutex_unlock(&dev->lock); 1321 return result; 1322 1323 out_free: 1324 kfree(dvb); 1325 dev->dvb = NULL; 1326 goto ret; 1327 } 1328 1329 static int dvb_fini(struct cx231xx *dev) 1330 { 1331 if (!dev->board.has_dvb) { 1332 /* This device does not support the extension */ 1333 return 0; 1334 } 1335 1336 if (dev->dvb) { 1337 unregister_dvb(dev->dvb); 1338 dev->dvb = NULL; 1339 } 1340 1341 return 0; 1342 } 1343 1344 static struct cx231xx_ops dvb_ops = { 1345 .id = CX231XX_DVB, 1346 .name = "Cx231xx dvb Extension", 1347 .init = dvb_init, 1348 .fini = dvb_fini, 1349 }; 1350 1351 static int __init cx231xx_dvb_register(void) 1352 { 1353 return cx231xx_register_extension(&dvb_ops); 1354 } 1355 1356 static void __exit cx231xx_dvb_unregister(void) 1357 { 1358 cx231xx_unregister_extension(&dvb_ops); 1359 } 1360 1361 module_init(cx231xx_dvb_register); 1362 module_exit(cx231xx_dvb_unregister); 1363