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 "dmxdev.h"
27 #include "dvbdev.h"
28 #include "dvb_demux.h"
29 #include "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
pt3_demod_write(struct pt3_adapter * adap,const struct reg_val * data,int num)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
pt3_lnb_ctrl(struct pt3_board * pt3,bool on)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
pt3_find_adapter(struct dvb_frontend * fe)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
pt3_set_tuner_power(struct pt3_board * pt3,bool tuner_on,bool amp_on)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
pt3_set_lna(struct dvb_frontend * fe)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
pt3_set_voltage(struct dvb_frontend * fe,enum fe_sec_voltage volt)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 */
pt3_fe_init(struct pt3_board * pt3)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
pt3_attach_fe(struct pt3_board * pt3,int i)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
pt3_fetch_thread(void * data)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
pt3_start_streaming(struct pt3_adapter * adap)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
pt3_stop_streaming(struct pt3_adapter * adap)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
pt3_start_feed(struct dvb_demux_feed * feed)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
pt3_stop_feed(struct dvb_demux_feed * feed)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
pt3_alloc_adapter(struct pt3_board * pt3,int index)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
pt3_cleanup_adapter(struct pt3_board * pt3,int index)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
pt3_suspend(struct device * dev)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
pt3_resume(struct device * dev)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
pt3_remove(struct pci_dev * pdev)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
pt3_probe(struct pci_dev * pdev,const struct pci_device_id * ent)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