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