1 /* 2 * Earthsoft PT3 driver 3 * 4 * Copyright (C) 2014 Akihiro Tsukada <tskd08@gmail.com> 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License as 8 * published by the Free Software Foundation version 2. 9 * 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 * GNU General Public License for more details. 15 */ 16 17 #include <linux/freezer.h> 18 #include <linux/kernel.h> 19 #include <linux/kthread.h> 20 #include <linux/mutex.h> 21 #include <linux/module.h> 22 #include <linux/pci.h> 23 #include <linux/string.h> 24 #include <linux/sched/signal.h> 25 26 #include <media/dmxdev.h> 27 #include <media/dvbdev.h> 28 #include <media/dvb_demux.h> 29 #include <media/dvb_frontend.h> 30 31 #include "pt3.h" 32 33 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); 34 35 static bool one_adapter; 36 module_param(one_adapter, bool, 0444); 37 MODULE_PARM_DESC(one_adapter, "Place FE's together under one adapter."); 38 39 static int num_bufs = 4; 40 module_param(num_bufs, int, 0444); 41 MODULE_PARM_DESC(num_bufs, "Number of DMA buffer (188KiB) per FE."); 42 43 44 static const struct i2c_algorithm pt3_i2c_algo = { 45 .master_xfer = &pt3_i2c_master_xfer, 46 .functionality = &pt3_i2c_functionality, 47 }; 48 49 static const struct pt3_adap_config adap_conf[PT3_NUM_FE] = { 50 { 51 .demod_info = { 52 I2C_BOARD_INFO(TC90522_I2C_DEV_SAT, 0x11), 53 }, 54 .tuner_info = { 55 I2C_BOARD_INFO("qm1d1c0042", 0x63), 56 }, 57 .tuner_cfg.qm1d1c0042 = { 58 .lpf = 1, 59 }, 60 .init_freq = 1049480 - 300, 61 }, 62 { 63 .demod_info = { 64 I2C_BOARD_INFO(TC90522_I2C_DEV_TER, 0x10), 65 }, 66 .tuner_info = { 67 I2C_BOARD_INFO("mxl301rf", 0x62), 68 }, 69 .init_freq = 515142857, 70 }, 71 { 72 .demod_info = { 73 I2C_BOARD_INFO(TC90522_I2C_DEV_SAT, 0x13), 74 }, 75 .tuner_info = { 76 I2C_BOARD_INFO("qm1d1c0042", 0x60), 77 }, 78 .tuner_cfg.qm1d1c0042 = { 79 .lpf = 1, 80 }, 81 .init_freq = 1049480 + 300, 82 }, 83 { 84 .demod_info = { 85 I2C_BOARD_INFO(TC90522_I2C_DEV_TER, 0x12), 86 }, 87 .tuner_info = { 88 I2C_BOARD_INFO("mxl301rf", 0x61), 89 }, 90 .init_freq = 521142857, 91 }, 92 }; 93 94 95 struct reg_val { 96 u8 reg; 97 u8 val; 98 }; 99 100 static int 101 pt3_demod_write(struct pt3_adapter *adap, const struct reg_val *data, int num) 102 { 103 struct i2c_msg msg; 104 int i, ret; 105 106 ret = 0; 107 msg.addr = adap->i2c_demod->addr; 108 msg.flags = 0; 109 msg.len = 2; 110 for (i = 0; i < num; i++) { 111 msg.buf = (u8 *)&data[i]; 112 ret = i2c_transfer(adap->i2c_demod->adapter, &msg, 1); 113 if (ret == 0) 114 ret = -EREMOTE; 115 if (ret < 0) 116 return ret; 117 } 118 return 0; 119 } 120 121 static inline void pt3_lnb_ctrl(struct pt3_board *pt3, bool on) 122 { 123 iowrite32((on ? 0x0f : 0x0c), pt3->regs[0] + REG_SYSTEM_W); 124 } 125 126 static inline struct pt3_adapter *pt3_find_adapter(struct dvb_frontend *fe) 127 { 128 struct pt3_board *pt3; 129 int i; 130 131 if (one_adapter) { 132 pt3 = fe->dvb->priv; 133 for (i = 0; i < PT3_NUM_FE; i++) 134 if (pt3->adaps[i]->fe == fe) 135 return pt3->adaps[i]; 136 } 137 return container_of(fe->dvb, struct pt3_adapter, dvb_adap); 138 } 139 140 /* 141 * all 4 tuners in PT3 are packaged in a can module (Sharp VA4M6JC2103). 142 * it seems that they share the power lines and Amp power line and 143 * adaps[3] controls those powers. 144 */ 145 static int 146 pt3_set_tuner_power(struct pt3_board *pt3, bool tuner_on, bool amp_on) 147 { 148 struct reg_val rv = { 0x1e, 0x99 }; 149 150 if (tuner_on) 151 rv.val |= 0x40; 152 if (amp_on) 153 rv.val |= 0x04; 154 return pt3_demod_write(pt3->adaps[PT3_NUM_FE - 1], &rv, 1); 155 } 156 157 static int pt3_set_lna(struct dvb_frontend *fe) 158 { 159 struct pt3_adapter *adap; 160 struct pt3_board *pt3; 161 u32 val; 162 int ret; 163 164 /* LNA is shared btw. 2 TERR-tuners */ 165 166 adap = pt3_find_adapter(fe); 167 val = fe->dtv_property_cache.lna; 168 if (val == LNA_AUTO || val == adap->cur_lna) 169 return 0; 170 171 pt3 = adap->dvb_adap.priv; 172 if (mutex_lock_interruptible(&pt3->lock)) 173 return -ERESTARTSYS; 174 if (val) 175 pt3->lna_on_cnt++; 176 else 177 pt3->lna_on_cnt--; 178 179 if (val && pt3->lna_on_cnt <= 1) { 180 pt3->lna_on_cnt = 1; 181 ret = pt3_set_tuner_power(pt3, true, true); 182 } else if (!val && pt3->lna_on_cnt <= 0) { 183 pt3->lna_on_cnt = 0; 184 ret = pt3_set_tuner_power(pt3, true, false); 185 } else 186 ret = 0; 187 mutex_unlock(&pt3->lock); 188 adap->cur_lna = (val != 0); 189 return ret; 190 } 191 192 static int pt3_set_voltage(struct dvb_frontend *fe, enum fe_sec_voltage volt) 193 { 194 struct pt3_adapter *adap; 195 struct pt3_board *pt3; 196 bool on; 197 198 /* LNB power is shared btw. 2 SAT-tuners */ 199 200 adap = pt3_find_adapter(fe); 201 on = (volt != SEC_VOLTAGE_OFF); 202 if (on == adap->cur_lnb) 203 return 0; 204 adap->cur_lnb = on; 205 pt3 = adap->dvb_adap.priv; 206 if (mutex_lock_interruptible(&pt3->lock)) 207 return -ERESTARTSYS; 208 if (on) 209 pt3->lnb_on_cnt++; 210 else 211 pt3->lnb_on_cnt--; 212 213 if (on && pt3->lnb_on_cnt <= 1) { 214 pt3->lnb_on_cnt = 1; 215 pt3_lnb_ctrl(pt3, true); 216 } else if (!on && pt3->lnb_on_cnt <= 0) { 217 pt3->lnb_on_cnt = 0; 218 pt3_lnb_ctrl(pt3, false); 219 } 220 mutex_unlock(&pt3->lock); 221 return 0; 222 } 223 224 /* register values used in pt3_fe_init() */ 225 226 static const struct reg_val init0_sat[] = { 227 { 0x03, 0x01 }, 228 { 0x1e, 0x10 }, 229 }; 230 static const struct reg_val init0_ter[] = { 231 { 0x01, 0x40 }, 232 { 0x1c, 0x10 }, 233 }; 234 static const struct reg_val cfg_sat[] = { 235 { 0x1c, 0x15 }, 236 { 0x1f, 0x04 }, 237 }; 238 static const struct reg_val cfg_ter[] = { 239 { 0x1d, 0x01 }, 240 }; 241 242 /* 243 * pt3_fe_init: initialize demod sub modules and ISDB-T tuners all at once. 244 * 245 * As for demod IC (TC90522) and ISDB-T tuners (MxL301RF), 246 * the i2c sequences for init'ing them are not public and hidden in a ROM, 247 * and include the board specific configurations as well. 248 * They are stored in a lump and cannot be taken out / accessed separately, 249 * thus cannot be moved to the FE/tuner driver. 250 */ 251 static int pt3_fe_init(struct pt3_board *pt3) 252 { 253 int i, ret; 254 struct dvb_frontend *fe; 255 256 pt3_i2c_reset(pt3); 257 ret = pt3_init_all_demods(pt3); 258 if (ret < 0) { 259 dev_warn(&pt3->pdev->dev, "Failed to init demod chips\n"); 260 return ret; 261 } 262 263 /* additional config? */ 264 for (i = 0; i < PT3_NUM_FE; i++) { 265 fe = pt3->adaps[i]->fe; 266 267 if (fe->ops.delsys[0] == SYS_ISDBS) 268 ret = pt3_demod_write(pt3->adaps[i], 269 init0_sat, ARRAY_SIZE(init0_sat)); 270 else 271 ret = pt3_demod_write(pt3->adaps[i], 272 init0_ter, ARRAY_SIZE(init0_ter)); 273 if (ret < 0) { 274 dev_warn(&pt3->pdev->dev, 275 "demod[%d] failed in init sequence0\n", i); 276 return ret; 277 } 278 ret = fe->ops.init(fe); 279 if (ret < 0) 280 return ret; 281 } 282 283 usleep_range(2000, 4000); 284 ret = pt3_set_tuner_power(pt3, true, false); 285 if (ret < 0) { 286 dev_warn(&pt3->pdev->dev, "Failed to control tuner module\n"); 287 return ret; 288 } 289 290 /* output pin configuration */ 291 for (i = 0; i < PT3_NUM_FE; i++) { 292 fe = pt3->adaps[i]->fe; 293 if (fe->ops.delsys[0] == SYS_ISDBS) 294 ret = pt3_demod_write(pt3->adaps[i], 295 cfg_sat, ARRAY_SIZE(cfg_sat)); 296 else 297 ret = pt3_demod_write(pt3->adaps[i], 298 cfg_ter, ARRAY_SIZE(cfg_ter)); 299 if (ret < 0) { 300 dev_warn(&pt3->pdev->dev, 301 "demod[%d] failed in init sequence1\n", i); 302 return ret; 303 } 304 } 305 usleep_range(4000, 6000); 306 307 for (i = 0; i < PT3_NUM_FE; i++) { 308 fe = pt3->adaps[i]->fe; 309 if (fe->ops.delsys[0] != SYS_ISDBS) 310 continue; 311 /* init and wake-up ISDB-S tuners */ 312 ret = fe->ops.tuner_ops.init(fe); 313 if (ret < 0) { 314 dev_warn(&pt3->pdev->dev, 315 "Failed to init SAT-tuner[%d]\n", i); 316 return ret; 317 } 318 } 319 ret = pt3_init_all_mxl301rf(pt3); 320 if (ret < 0) { 321 dev_warn(&pt3->pdev->dev, "Failed to init TERR-tuners\n"); 322 return ret; 323 } 324 325 ret = pt3_set_tuner_power(pt3, true, true); 326 if (ret < 0) { 327 dev_warn(&pt3->pdev->dev, "Failed to control tuner module\n"); 328 return ret; 329 } 330 331 /* Wake up all tuners and make an initial tuning, 332 * in order to avoid interference among the tuners in the module, 333 * according to the doc from the manufacturer. 334 */ 335 for (i = 0; i < PT3_NUM_FE; i++) { 336 fe = pt3->adaps[i]->fe; 337 ret = 0; 338 if (fe->ops.delsys[0] == SYS_ISDBT) 339 ret = fe->ops.tuner_ops.init(fe); 340 /* set only when called from pt3_probe(), not resume() */ 341 if (ret == 0 && fe->dtv_property_cache.frequency == 0) { 342 fe->dtv_property_cache.frequency = 343 adap_conf[i].init_freq; 344 ret = fe->ops.tuner_ops.set_params(fe); 345 } 346 if (ret < 0) { 347 dev_warn(&pt3->pdev->dev, 348 "Failed in initial tuning of tuner[%d]\n", i); 349 return ret; 350 } 351 } 352 353 /* and sleep again, waiting to be opened by users. */ 354 for (i = 0; i < PT3_NUM_FE; i++) { 355 fe = pt3->adaps[i]->fe; 356 if (fe->ops.tuner_ops.sleep) 357 ret = fe->ops.tuner_ops.sleep(fe); 358 if (ret < 0) 359 break; 360 if (fe->ops.sleep) 361 ret = fe->ops.sleep(fe); 362 if (ret < 0) 363 break; 364 if (fe->ops.delsys[0] == SYS_ISDBS) 365 fe->ops.set_voltage = &pt3_set_voltage; 366 else 367 fe->ops.set_lna = &pt3_set_lna; 368 } 369 if (i < PT3_NUM_FE) { 370 dev_warn(&pt3->pdev->dev, "FE[%d] failed to standby\n", i); 371 return ret; 372 } 373 return 0; 374 } 375 376 377 static int pt3_attach_fe(struct pt3_board *pt3, int i) 378 { 379 struct i2c_board_info info; 380 struct tc90522_config cfg; 381 struct i2c_client *cl; 382 struct dvb_adapter *dvb_adap; 383 int ret; 384 385 info = adap_conf[i].demod_info; 386 cfg = adap_conf[i].demod_cfg; 387 cfg.tuner_i2c = NULL; 388 info.platform_data = &cfg; 389 390 ret = -ENODEV; 391 request_module("tc90522"); 392 cl = i2c_new_device(&pt3->i2c_adap, &info); 393 if (!cl || !cl->dev.driver) 394 return -ENODEV; 395 pt3->adaps[i]->i2c_demod = cl; 396 if (!try_module_get(cl->dev.driver->owner)) 397 goto err_demod_i2c_unregister_device; 398 399 if (!strncmp(cl->name, TC90522_I2C_DEV_SAT, 400 strlen(TC90522_I2C_DEV_SAT))) { 401 struct qm1d1c0042_config tcfg; 402 403 tcfg = adap_conf[i].tuner_cfg.qm1d1c0042; 404 tcfg.fe = cfg.fe; 405 info = adap_conf[i].tuner_info; 406 info.platform_data = &tcfg; 407 request_module("qm1d1c0042"); 408 cl = i2c_new_device(cfg.tuner_i2c, &info); 409 } else { 410 struct mxl301rf_config tcfg; 411 412 tcfg = adap_conf[i].tuner_cfg.mxl301rf; 413 tcfg.fe = cfg.fe; 414 info = adap_conf[i].tuner_info; 415 info.platform_data = &tcfg; 416 request_module("mxl301rf"); 417 cl = i2c_new_device(cfg.tuner_i2c, &info); 418 } 419 if (!cl || !cl->dev.driver) 420 goto err_demod_module_put; 421 pt3->adaps[i]->i2c_tuner = cl; 422 if (!try_module_get(cl->dev.driver->owner)) 423 goto err_tuner_i2c_unregister_device; 424 425 dvb_adap = &pt3->adaps[one_adapter ? 0 : i]->dvb_adap; 426 ret = dvb_register_frontend(dvb_adap, cfg.fe); 427 if (ret < 0) 428 goto err_tuner_module_put; 429 pt3->adaps[i]->fe = cfg.fe; 430 return 0; 431 432 err_tuner_module_put: 433 module_put(pt3->adaps[i]->i2c_tuner->dev.driver->owner); 434 err_tuner_i2c_unregister_device: 435 i2c_unregister_device(pt3->adaps[i]->i2c_tuner); 436 err_demod_module_put: 437 module_put(pt3->adaps[i]->i2c_demod->dev.driver->owner); 438 err_demod_i2c_unregister_device: 439 i2c_unregister_device(pt3->adaps[i]->i2c_demod); 440 441 return ret; 442 } 443 444 445 static int pt3_fetch_thread(void *data) 446 { 447 struct pt3_adapter *adap = data; 448 ktime_t delay; 449 bool was_frozen; 450 451 #define PT3_INITIAL_BUF_DROPS 4 452 #define PT3_FETCH_DELAY 10 453 #define PT3_FETCH_DELAY_DELTA 2 454 455 pt3_init_dmabuf(adap); 456 adap->num_discard = PT3_INITIAL_BUF_DROPS; 457 458 dev_dbg(adap->dvb_adap.device, "PT3: [%s] started\n", 459 adap->thread->comm); 460 set_freezable(); 461 while (!kthread_freezable_should_stop(&was_frozen)) { 462 if (was_frozen) 463 adap->num_discard = PT3_INITIAL_BUF_DROPS; 464 465 pt3_proc_dma(adap); 466 467 delay = PT3_FETCH_DELAY * NSEC_PER_MSEC; 468 set_current_state(TASK_UNINTERRUPTIBLE); 469 freezable_schedule_hrtimeout_range(&delay, 470 PT3_FETCH_DELAY_DELTA * NSEC_PER_MSEC, 471 HRTIMER_MODE_REL); 472 } 473 dev_dbg(adap->dvb_adap.device, "PT3: [%s] exited\n", 474 adap->thread->comm); 475 return 0; 476 } 477 478 static int pt3_start_streaming(struct pt3_adapter *adap) 479 { 480 struct task_struct *thread; 481 482 /* start fetching thread */ 483 thread = kthread_run(pt3_fetch_thread, adap, "pt3-ad%i-dmx%i", 484 adap->dvb_adap.num, adap->dmxdev.dvbdev->id); 485 if (IS_ERR(thread)) { 486 int ret = PTR_ERR(thread); 487 488 adap->thread = NULL; 489 dev_warn(adap->dvb_adap.device, 490 "PT3 (adap:%d, dmx:%d): failed to start kthread\n", 491 adap->dvb_adap.num, adap->dmxdev.dvbdev->id); 492 return ret; 493 } 494 adap->thread = thread; 495 496 return pt3_start_dma(adap); 497 } 498 499 static int pt3_stop_streaming(struct pt3_adapter *adap) 500 { 501 int ret; 502 503 ret = pt3_stop_dma(adap); 504 if (ret) 505 dev_warn(adap->dvb_adap.device, 506 "PT3: failed to stop streaming of adap:%d/FE:%d\n", 507 adap->dvb_adap.num, adap->fe->id); 508 509 /* kill the fetching thread */ 510 ret = kthread_stop(adap->thread); 511 adap->thread = NULL; 512 return ret; 513 } 514 515 static int pt3_start_feed(struct dvb_demux_feed *feed) 516 { 517 struct pt3_adapter *adap; 518 519 if (signal_pending(current)) 520 return -EINTR; 521 522 adap = container_of(feed->demux, struct pt3_adapter, demux); 523 adap->num_feeds++; 524 if (adap->num_feeds > 1) 525 return 0; 526 527 return pt3_start_streaming(adap); 528 529 } 530 531 static int pt3_stop_feed(struct dvb_demux_feed *feed) 532 { 533 struct pt3_adapter *adap; 534 535 adap = container_of(feed->demux, struct pt3_adapter, demux); 536 537 adap->num_feeds--; 538 if (adap->num_feeds > 0 || !adap->thread) 539 return 0; 540 adap->num_feeds = 0; 541 542 return pt3_stop_streaming(adap); 543 } 544 545 546 static int pt3_alloc_adapter(struct pt3_board *pt3, int index) 547 { 548 int ret; 549 struct pt3_adapter *adap; 550 struct dvb_adapter *da; 551 552 adap = kzalloc(sizeof(*adap), GFP_KERNEL); 553 if (!adap) 554 return -ENOMEM; 555 556 pt3->adaps[index] = adap; 557 adap->adap_idx = index; 558 559 if (index == 0 || !one_adapter) { 560 ret = dvb_register_adapter(&adap->dvb_adap, "PT3 DVB", 561 THIS_MODULE, &pt3->pdev->dev, adapter_nr); 562 if (ret < 0) { 563 dev_err(&pt3->pdev->dev, 564 "failed to register adapter dev\n"); 565 goto err_mem; 566 } 567 da = &adap->dvb_adap; 568 } else 569 da = &pt3->adaps[0]->dvb_adap; 570 571 adap->dvb_adap.priv = pt3; 572 adap->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING; 573 adap->demux.priv = adap; 574 adap->demux.feednum = 256; 575 adap->demux.filternum = 256; 576 adap->demux.start_feed = pt3_start_feed; 577 adap->demux.stop_feed = pt3_stop_feed; 578 ret = dvb_dmx_init(&adap->demux); 579 if (ret < 0) { 580 dev_err(&pt3->pdev->dev, "failed to init dmx dev\n"); 581 goto err_adap; 582 } 583 584 adap->dmxdev.filternum = 256; 585 adap->dmxdev.demux = &adap->demux.dmx; 586 ret = dvb_dmxdev_init(&adap->dmxdev, da); 587 if (ret < 0) { 588 dev_err(&pt3->pdev->dev, "failed to init dmxdev\n"); 589 goto err_demux; 590 } 591 592 ret = pt3_alloc_dmabuf(adap); 593 if (ret) { 594 dev_err(&pt3->pdev->dev, "failed to alloc DMA buffers\n"); 595 goto err_dmabuf; 596 } 597 598 return 0; 599 600 err_dmabuf: 601 pt3_free_dmabuf(adap); 602 dvb_dmxdev_release(&adap->dmxdev); 603 err_demux: 604 dvb_dmx_release(&adap->demux); 605 err_adap: 606 if (index == 0 || !one_adapter) 607 dvb_unregister_adapter(da); 608 err_mem: 609 kfree(adap); 610 pt3->adaps[index] = NULL; 611 return ret; 612 } 613 614 static void pt3_cleanup_adapter(struct pt3_board *pt3, int index) 615 { 616 struct pt3_adapter *adap; 617 struct dmx_demux *dmx; 618 619 adap = pt3->adaps[index]; 620 if (adap == NULL) 621 return; 622 623 /* stop demux kthread */ 624 if (adap->thread) 625 pt3_stop_streaming(adap); 626 627 dmx = &adap->demux.dmx; 628 dmx->close(dmx); 629 if (adap->fe) { 630 adap->fe->callback = NULL; 631 if (adap->fe->frontend_priv) 632 dvb_unregister_frontend(adap->fe); 633 if (adap->i2c_tuner) { 634 module_put(adap->i2c_tuner->dev.driver->owner); 635 i2c_unregister_device(adap->i2c_tuner); 636 } 637 if (adap->i2c_demod) { 638 module_put(adap->i2c_demod->dev.driver->owner); 639 i2c_unregister_device(adap->i2c_demod); 640 } 641 } 642 pt3_free_dmabuf(adap); 643 dvb_dmxdev_release(&adap->dmxdev); 644 dvb_dmx_release(&adap->demux); 645 if (index == 0 || !one_adapter) 646 dvb_unregister_adapter(&adap->dvb_adap); 647 kfree(adap); 648 pt3->adaps[index] = NULL; 649 } 650 651 #ifdef CONFIG_PM_SLEEP 652 653 static int pt3_suspend(struct device *dev) 654 { 655 struct pci_dev *pdev = to_pci_dev(dev); 656 struct pt3_board *pt3 = pci_get_drvdata(pdev); 657 int i; 658 struct pt3_adapter *adap; 659 660 for (i = 0; i < PT3_NUM_FE; i++) { 661 adap = pt3->adaps[i]; 662 if (adap->num_feeds > 0) 663 pt3_stop_dma(adap); 664 dvb_frontend_suspend(adap->fe); 665 pt3_free_dmabuf(adap); 666 } 667 668 pt3_lnb_ctrl(pt3, false); 669 pt3_set_tuner_power(pt3, false, false); 670 return 0; 671 } 672 673 static int pt3_resume(struct device *dev) 674 { 675 struct pci_dev *pdev = to_pci_dev(dev); 676 struct pt3_board *pt3 = pci_get_drvdata(pdev); 677 int i, ret; 678 struct pt3_adapter *adap; 679 680 ret = pt3_fe_init(pt3); 681 if (ret) 682 return ret; 683 684 if (pt3->lna_on_cnt > 0) 685 pt3_set_tuner_power(pt3, true, true); 686 if (pt3->lnb_on_cnt > 0) 687 pt3_lnb_ctrl(pt3, true); 688 689 for (i = 0; i < PT3_NUM_FE; i++) { 690 adap = pt3->adaps[i]; 691 dvb_frontend_resume(adap->fe); 692 ret = pt3_alloc_dmabuf(adap); 693 if (ret) { 694 dev_err(&pt3->pdev->dev, "failed to alloc DMA bufs\n"); 695 continue; 696 } 697 if (adap->num_feeds > 0) 698 pt3_start_dma(adap); 699 } 700 701 return 0; 702 } 703 704 #endif /* CONFIG_PM_SLEEP */ 705 706 707 static void pt3_remove(struct pci_dev *pdev) 708 { 709 struct pt3_board *pt3; 710 int i; 711 712 pt3 = pci_get_drvdata(pdev); 713 for (i = PT3_NUM_FE - 1; i >= 0; i--) 714 pt3_cleanup_adapter(pt3, i); 715 i2c_del_adapter(&pt3->i2c_adap); 716 kfree(pt3->i2c_buf); 717 pci_iounmap(pt3->pdev, pt3->regs[0]); 718 pci_iounmap(pt3->pdev, pt3->regs[1]); 719 pci_release_regions(pdev); 720 pci_disable_device(pdev); 721 kfree(pt3); 722 } 723 724 static int pt3_probe(struct pci_dev *pdev, const struct pci_device_id *ent) 725 { 726 u8 rev; 727 u32 ver; 728 int i, ret; 729 struct pt3_board *pt3; 730 struct i2c_adapter *i2c; 731 732 if (pci_read_config_byte(pdev, PCI_REVISION_ID, &rev) || rev != 1) 733 return -ENODEV; 734 735 ret = pci_enable_device(pdev); 736 if (ret < 0) 737 return -ENODEV; 738 pci_set_master(pdev); 739 740 ret = pci_request_regions(pdev, DRV_NAME); 741 if (ret < 0) 742 goto err_disable_device; 743 744 ret = dma_set_mask(&pdev->dev, DMA_BIT_MASK(64)); 745 if (ret == 0) 746 dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64)); 747 else { 748 ret = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32)); 749 if (ret == 0) 750 dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32)); 751 else { 752 dev_err(&pdev->dev, "Failed to set DMA mask\n"); 753 goto err_release_regions; 754 } 755 dev_info(&pdev->dev, "Use 32bit DMA\n"); 756 } 757 758 pt3 = kzalloc(sizeof(*pt3), GFP_KERNEL); 759 if (!pt3) { 760 ret = -ENOMEM; 761 goto err_release_regions; 762 } 763 pci_set_drvdata(pdev, pt3); 764 pt3->pdev = pdev; 765 mutex_init(&pt3->lock); 766 pt3->regs[0] = pci_ioremap_bar(pdev, 0); 767 pt3->regs[1] = pci_ioremap_bar(pdev, 2); 768 if (pt3->regs[0] == NULL || pt3->regs[1] == NULL) { 769 dev_err(&pdev->dev, "Failed to ioremap\n"); 770 ret = -ENOMEM; 771 goto err_kfree; 772 } 773 774 ver = ioread32(pt3->regs[0] + REG_VERSION); 775 if ((ver >> 16) != 0x0301) { 776 dev_warn(&pdev->dev, "PT%d, I/F-ver.:%d not supported\n", 777 ver >> 24, (ver & 0x00ff0000) >> 16); 778 ret = -ENODEV; 779 goto err_iounmap; 780 } 781 782 pt3->num_bufs = clamp_val(num_bufs, MIN_DATA_BUFS, MAX_DATA_BUFS); 783 784 pt3->i2c_buf = kmalloc(sizeof(*pt3->i2c_buf), GFP_KERNEL); 785 if (pt3->i2c_buf == NULL) { 786 ret = -ENOMEM; 787 goto err_iounmap; 788 } 789 i2c = &pt3->i2c_adap; 790 i2c->owner = THIS_MODULE; 791 i2c->algo = &pt3_i2c_algo; 792 i2c->algo_data = NULL; 793 i2c->dev.parent = &pdev->dev; 794 strlcpy(i2c->name, DRV_NAME, sizeof(i2c->name)); 795 i2c_set_adapdata(i2c, pt3); 796 ret = i2c_add_adapter(i2c); 797 if (ret < 0) 798 goto err_i2cbuf; 799 800 for (i = 0; i < PT3_NUM_FE; i++) { 801 ret = pt3_alloc_adapter(pt3, i); 802 if (ret < 0) 803 break; 804 805 ret = pt3_attach_fe(pt3, i); 806 if (ret < 0) 807 break; 808 } 809 if (i < PT3_NUM_FE) { 810 dev_err(&pdev->dev, "Failed to create FE%d\n", i); 811 goto err_cleanup_adapters; 812 } 813 814 ret = pt3_fe_init(pt3); 815 if (ret < 0) { 816 dev_err(&pdev->dev, "Failed to init frontends\n"); 817 i = PT3_NUM_FE - 1; 818 goto err_cleanup_adapters; 819 } 820 821 dev_info(&pdev->dev, 822 "successfully init'ed PT%d (fw:0x%02x, I/F:0x%02x)\n", 823 ver >> 24, (ver >> 8) & 0xff, (ver >> 16) & 0xff); 824 return 0; 825 826 err_cleanup_adapters: 827 while (i >= 0) 828 pt3_cleanup_adapter(pt3, i--); 829 i2c_del_adapter(i2c); 830 err_i2cbuf: 831 kfree(pt3->i2c_buf); 832 err_iounmap: 833 if (pt3->regs[0]) 834 pci_iounmap(pdev, pt3->regs[0]); 835 if (pt3->regs[1]) 836 pci_iounmap(pdev, pt3->regs[1]); 837 err_kfree: 838 kfree(pt3); 839 err_release_regions: 840 pci_release_regions(pdev); 841 err_disable_device: 842 pci_disable_device(pdev); 843 return ret; 844 845 } 846 847 static const struct pci_device_id pt3_id_table[] = { 848 { PCI_DEVICE_SUB(0x1172, 0x4c15, 0xee8d, 0x0368) }, 849 { }, 850 }; 851 MODULE_DEVICE_TABLE(pci, pt3_id_table); 852 853 static SIMPLE_DEV_PM_OPS(pt3_pm_ops, pt3_suspend, pt3_resume); 854 855 static struct pci_driver pt3_driver = { 856 .name = DRV_NAME, 857 .probe = pt3_probe, 858 .remove = pt3_remove, 859 .id_table = pt3_id_table, 860 861 .driver.pm = &pt3_pm_ops, 862 }; 863 864 module_pci_driver(pt3_driver); 865 866 MODULE_DESCRIPTION("Earthsoft PT3 Driver"); 867 MODULE_AUTHOR("Akihiro TSUKADA"); 868 MODULE_LICENSE("GPL"); 869