drivers/media/pci/pt3/pt3.c

   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");