• Home
  • History
  • Annotate
  • Line#
  • Navigate
  • Raw
  • Download
  • only in /asuswrt-rt-n18u-9.0.0.4.380.2695/release/src-rt-6.x.4708/linux/linux-2.6/drivers/media/video/tlg2300/
1#include "pd-common.h"
2#include <linux/kernel.h>
3#include <linux/usb.h>
4#include <linux/dvb/dmx.h>
5#include <linux/delay.h>
6#include <linux/gfp.h>
7
8#include "vendorcmds.h"
9#include <linux/sched.h>
10#include <asm/atomic.h>
11
12static void dvb_urb_cleanup(struct pd_dvb_adapter *pd_dvb);
13
14static int dvb_bandwidth[][2] = {
15	{ TLG_BW_8, BANDWIDTH_8_MHZ },
16	{ TLG_BW_7, BANDWIDTH_7_MHZ },
17	{ TLG_BW_6, BANDWIDTH_6_MHZ }
18};
19static int dvb_bandwidth_length = ARRAY_SIZE(dvb_bandwidth);
20
21static s32 dvb_start_streaming(struct pd_dvb_adapter *pd_dvb);
22static int poseidon_check_mode_dvbt(struct poseidon *pd)
23{
24	s32 ret = 0, cmd_status = 0;
25
26	set_current_state(TASK_INTERRUPTIBLE);
27	schedule_timeout(HZ/4);
28
29	ret = usb_set_interface(pd->udev, 0, BULK_ALTERNATE_IFACE);
30	if (ret != 0)
31		return ret;
32
33	ret = set_tuner_mode(pd, TLG_MODE_CAPS_DVB_T);
34	if (ret)
35		return ret;
36
37	/* signal source */
38	ret = send_set_req(pd, SGNL_SRC_SEL, TLG_SIG_SRC_ANTENNA, &cmd_status);
39	if (ret|cmd_status)
40		return ret;
41
42	return 0;
43}
44
45/* acquire :
46 * 	1 == open
47 * 	0 == release
48 */
49static int poseidon_ts_bus_ctrl(struct dvb_frontend *fe, int acquire)
50{
51	struct poseidon *pd = fe->demodulator_priv;
52	struct pd_dvb_adapter *pd_dvb;
53	int ret = 0;
54
55	if (!pd)
56		return -ENODEV;
57
58	pd_dvb = container_of(fe, struct pd_dvb_adapter, dvb_fe);
59	if (acquire) {
60		mutex_lock(&pd->lock);
61		if (pd->state & POSEIDON_STATE_DISCONNECT) {
62			ret = -ENODEV;
63			goto open_out;
64		}
65
66		if (pd->state && !(pd->state & POSEIDON_STATE_DVBT)) {
67			ret = -EBUSY;
68			goto open_out;
69		}
70
71		usb_autopm_get_interface(pd->interface);
72		if (0 == pd->state) {
73			ret = poseidon_check_mode_dvbt(pd);
74			if (ret < 0) {
75				usb_autopm_put_interface(pd->interface);
76				goto open_out;
77			}
78			pd->state |= POSEIDON_STATE_DVBT;
79			pd_dvb->bandwidth = 0;
80			pd_dvb->prev_freq = 0;
81		}
82		atomic_inc(&pd_dvb->users);
83		kref_get(&pd->kref);
84open_out:
85		mutex_unlock(&pd->lock);
86	} else {
87		dvb_stop_streaming(pd_dvb);
88
89		if (atomic_dec_and_test(&pd_dvb->users)) {
90			mutex_lock(&pd->lock);
91			pd->state &= ~POSEIDON_STATE_DVBT;
92			mutex_unlock(&pd->lock);
93		}
94		kref_put(&pd->kref, poseidon_delete);
95		usb_autopm_put_interface(pd->interface);
96	}
97	return ret;
98}
99
100#ifdef CONFIG_PM
101static void poseidon_fe_release(struct dvb_frontend *fe)
102{
103	struct poseidon *pd = fe->demodulator_priv;
104
105	pd->pm_suspend = NULL;
106	pd->pm_resume  = NULL;
107}
108#else
109#define poseidon_fe_release NULL
110#endif
111
112static s32 poseidon_fe_sleep(struct dvb_frontend *fe)
113{
114	return 0;
115}
116
117/*
118 * return true if we can satisfy the conditions, else return false.
119 */
120static bool check_scan_ok(__u32 freq, int bandwidth,
121			struct pd_dvb_adapter *adapter)
122{
123	if (bandwidth < 0)
124		return false;
125
126	if (adapter->prev_freq == freq
127		&& adapter->bandwidth == bandwidth) {
128		long nl = jiffies - adapter->last_jiffies;
129		unsigned int msec ;
130
131		msec = jiffies_to_msecs(abs(nl));
132		return msec > 15000 ? true : false;
133	}
134	return true;
135}
136
137/*
138 * Check if the firmware delays too long for an invalid frequency.
139 */
140static int fw_delay_overflow(struct pd_dvb_adapter *adapter)
141{
142	long nl = jiffies - adapter->last_jiffies;
143	unsigned int msec ;
144
145	msec = jiffies_to_msecs(abs(nl));
146	return msec > 800 ? true : false;
147}
148
149static int poseidon_set_fe(struct dvb_frontend *fe,
150			struct dvb_frontend_parameters *fep)
151{
152	s32 ret = 0, cmd_status = 0;
153	s32 i, bandwidth = -1;
154	struct poseidon *pd = fe->demodulator_priv;
155	struct pd_dvb_adapter *pd_dvb = &pd->dvb_data;
156
157	if (in_hibernation(pd))
158		return -EBUSY;
159
160	mutex_lock(&pd->lock);
161	for (i = 0; i < dvb_bandwidth_length; i++)
162		if (fep->u.ofdm.bandwidth == dvb_bandwidth[i][1])
163			bandwidth = dvb_bandwidth[i][0];
164
165	if (check_scan_ok(fep->frequency, bandwidth, pd_dvb)) {
166		ret = send_set_req(pd, TUNE_FREQ_SELECT,
167					fep->frequency / 1000, &cmd_status);
168		if (ret | cmd_status) {
169			log("error line");
170			goto front_out;
171		}
172
173		ret = send_set_req(pd, DVBT_BANDW_SEL,
174						bandwidth, &cmd_status);
175		if (ret | cmd_status) {
176			log("error line");
177			goto front_out;
178		}
179
180		ret = send_set_req(pd, TAKE_REQUEST, 0, &cmd_status);
181		if (ret | cmd_status) {
182			log("error line");
183			goto front_out;
184		}
185
186		/* save the context for future */
187		memcpy(&pd_dvb->fe_param, fep, sizeof(*fep));
188		pd_dvb->bandwidth = bandwidth;
189		pd_dvb->prev_freq = fep->frequency;
190		pd_dvb->last_jiffies = jiffies;
191	}
192front_out:
193	mutex_unlock(&pd->lock);
194	return ret;
195}
196
197#ifdef CONFIG_PM
198static int pm_dvb_suspend(struct poseidon *pd)
199{
200	struct pd_dvb_adapter *pd_dvb = &pd->dvb_data;
201	dvb_stop_streaming(pd_dvb);
202	dvb_urb_cleanup(pd_dvb);
203	msleep(500);
204	return 0;
205}
206
207static int pm_dvb_resume(struct poseidon *pd)
208{
209	struct pd_dvb_adapter *pd_dvb = &pd->dvb_data;
210
211	poseidon_check_mode_dvbt(pd);
212	msleep(300);
213	poseidon_set_fe(&pd_dvb->dvb_fe, &pd_dvb->fe_param);
214
215	dvb_start_streaming(pd_dvb);
216	return 0;
217}
218#endif
219
220static s32 poseidon_fe_init(struct dvb_frontend *fe)
221{
222	struct poseidon *pd = fe->demodulator_priv;
223	struct pd_dvb_adapter *pd_dvb = &pd->dvb_data;
224
225#ifdef CONFIG_PM
226	pd->pm_suspend = pm_dvb_suspend;
227	pd->pm_resume  = pm_dvb_resume;
228#endif
229	memset(&pd_dvb->fe_param, 0,
230			sizeof(struct dvb_frontend_parameters));
231	return 0;
232}
233
234static int poseidon_get_fe(struct dvb_frontend *fe,
235			struct dvb_frontend_parameters *fep)
236{
237	struct poseidon *pd = fe->demodulator_priv;
238	struct pd_dvb_adapter *pd_dvb = &pd->dvb_data;
239
240	memcpy(fep, &pd_dvb->fe_param, sizeof(*fep));
241	return 0;
242}
243
244static int poseidon_fe_get_tune_settings(struct dvb_frontend *fe,
245				struct dvb_frontend_tune_settings *tune)
246{
247	tune->min_delay_ms = 1000;
248	return 0;
249}
250
251static int poseidon_read_status(struct dvb_frontend *fe, fe_status_t *stat)
252{
253	struct poseidon *pd = fe->demodulator_priv;
254	s32 ret = -1, cmd_status;
255	struct tuner_dtv_sig_stat_s status = {};
256
257	if (in_hibernation(pd))
258		return -EBUSY;
259	mutex_lock(&pd->lock);
260
261	ret = send_get_req(pd, TUNER_STATUS, TLG_MODE_DVB_T,
262				&status, &cmd_status, sizeof(status));
263	if (ret | cmd_status) {
264		log("get tuner status error");
265		goto out;
266	}
267
268	if (debug_mode)
269		log("P : %d, L %d, LB :%d", status.sig_present,
270			status.sig_locked, status.sig_lock_busy);
271
272	if (status.sig_lock_busy) {
273		goto out;
274	} else if (status.sig_present || status.sig_locked) {
275		*stat |= FE_HAS_LOCK | FE_HAS_SIGNAL | FE_HAS_CARRIER
276				| FE_HAS_SYNC | FE_HAS_VITERBI;
277	} else {
278		if (fw_delay_overflow(&pd->dvb_data))
279			*stat |= FE_TIMEDOUT;
280	}
281out:
282	mutex_unlock(&pd->lock);
283	return ret;
284}
285
286static int poseidon_read_ber(struct dvb_frontend *fe, u32 *ber)
287{
288	struct poseidon *pd = fe->demodulator_priv;
289	struct tuner_ber_rate_s tlg_ber = {};
290	s32 ret = -1, cmd_status;
291
292	mutex_lock(&pd->lock);
293	ret = send_get_req(pd, TUNER_BER_RATE, 0,
294				&tlg_ber, &cmd_status, sizeof(tlg_ber));
295	if (ret | cmd_status)
296		goto out;
297	*ber = tlg_ber.ber_rate;
298out:
299	mutex_unlock(&pd->lock);
300	return ret;
301}
302
303static s32 poseidon_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
304{
305	struct poseidon *pd = fe->demodulator_priv;
306	struct tuner_dtv_sig_stat_s status = {};
307	s32 ret = 0, cmd_status;
308
309	mutex_lock(&pd->lock);
310	ret = send_get_req(pd, TUNER_STATUS, TLG_MODE_DVB_T,
311				&status, &cmd_status, sizeof(status));
312	if (ret | cmd_status)
313		goto out;
314	if ((status.sig_present || status.sig_locked) && !status.sig_strength)
315		*strength = 0xFFFF;
316	else
317		*strength = status.sig_strength;
318out:
319	mutex_unlock(&pd->lock);
320	return ret;
321}
322
323static int poseidon_read_snr(struct dvb_frontend *fe, u16 *snr)
324{
325	return 0;
326}
327
328static int poseidon_read_unc_blocks(struct dvb_frontend *fe, u32 *unc)
329{
330	*unc = 0;
331	return 0;
332}
333
334static struct dvb_frontend_ops poseidon_frontend_ops = {
335	.info = {
336		.name		= "Poseidon DVB-T",
337		.type		= FE_OFDM,
338		.frequency_min	= 174000000,
339		.frequency_max  = 862000000,
340		.frequency_stepsize	  = 62500,
341		.caps = FE_CAN_INVERSION_AUTO |
342			FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
343			FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
344			FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 |
345			FE_CAN_QAM_AUTO | FE_CAN_TRANSMISSION_MODE_AUTO |
346			FE_CAN_GUARD_INTERVAL_AUTO |
347			FE_CAN_RECOVER |
348			FE_CAN_HIERARCHY_AUTO,
349	},
350
351	.release = poseidon_fe_release,
352
353	.init = poseidon_fe_init,
354	.sleep = poseidon_fe_sleep,
355
356	.set_frontend = poseidon_set_fe,
357	.get_frontend = poseidon_get_fe,
358	.get_tune_settings = poseidon_fe_get_tune_settings,
359
360	.read_status	= poseidon_read_status,
361	.read_ber	= poseidon_read_ber,
362	.read_signal_strength = poseidon_read_signal_strength,
363	.read_snr	= poseidon_read_snr,
364	.read_ucblocks	= poseidon_read_unc_blocks,
365
366	.ts_bus_ctrl = poseidon_ts_bus_ctrl,
367};
368
369static void dvb_urb_irq(struct urb *urb)
370{
371	struct pd_dvb_adapter *pd_dvb = urb->context;
372	int len = urb->transfer_buffer_length;
373	struct dvb_demux *demux = &pd_dvb->demux;
374	s32 ret;
375
376	if (!pd_dvb->is_streaming || urb->status) {
377		if (urb->status == -EPROTO)
378			goto resend;
379		return;
380	}
381
382	if (urb->actual_length == len)
383		dvb_dmx_swfilter(demux, urb->transfer_buffer, len);
384	else if (urb->actual_length == len - 4) {
385		int offset;
386		u8 *buf = urb->transfer_buffer;
387
388		/*
389		 * The packet size is 512,
390		 * last packet contains 456 bytes tsp data
391		 */
392		for (offset = 456; offset < len; offset += 512) {
393			if (!strncmp(buf + offset, "DVHS", 4)) {
394				dvb_dmx_swfilter(demux, buf, offset);
395				if (len > offset + 52 + 4) {
396					/*16 bytes trailer + 36 bytes padding */
397					buf += offset + 52;
398					len -= offset + 52 + 4;
399					dvb_dmx_swfilter(demux, buf, len);
400				}
401				break;
402			}
403		}
404	}
405
406resend:
407	ret = usb_submit_urb(urb, GFP_ATOMIC);
408	if (ret)
409		log(" usb_submit_urb failed: error %d", ret);
410}
411
412static int dvb_urb_init(struct pd_dvb_adapter *pd_dvb)
413{
414	if (pd_dvb->urb_array[0])
415		return 0;
416
417	alloc_bulk_urbs_generic(pd_dvb->urb_array, DVB_SBUF_NUM,
418			pd_dvb->pd_device->udev, pd_dvb->ep_addr,
419			DVB_URB_BUF_SIZE, GFP_KERNEL,
420			dvb_urb_irq, pd_dvb);
421	return 0;
422}
423
424static void dvb_urb_cleanup(struct pd_dvb_adapter *pd_dvb)
425{
426	free_all_urb_generic(pd_dvb->urb_array, DVB_SBUF_NUM);
427}
428
429static s32 dvb_start_streaming(struct pd_dvb_adapter *pd_dvb)
430{
431	struct poseidon *pd = pd_dvb->pd_device;
432	int ret = 0;
433
434	if (pd->state & POSEIDON_STATE_DISCONNECT)
435		return -ENODEV;
436
437	mutex_lock(&pd->lock);
438	if (!pd_dvb->is_streaming) {
439		s32 i, cmd_status = 0;
440		/*
441		 * Once upon a time, there was a difficult bug lying here.
442		 * ret = send_set_req(pd, TAKE_REQUEST, 0, &cmd_status);
443		 */
444
445		ret = send_set_req(pd, PLAY_SERVICE, 1, &cmd_status);
446		if (ret | cmd_status)
447			goto out;
448
449		ret = dvb_urb_init(pd_dvb);
450		if (ret < 0)
451			goto out;
452
453		pd_dvb->is_streaming = 1;
454		for (i = 0; i < DVB_SBUF_NUM; i++) {
455			ret = usb_submit_urb(pd_dvb->urb_array[i],
456						       GFP_KERNEL);
457			if (ret) {
458				log(" submit urb error %d", ret);
459				goto out;
460			}
461		}
462	}
463out:
464	mutex_unlock(&pd->lock);
465	return ret;
466}
467
468void dvb_stop_streaming(struct pd_dvb_adapter *pd_dvb)
469{
470	struct poseidon *pd = pd_dvb->pd_device;
471
472	mutex_lock(&pd->lock);
473	if (pd_dvb->is_streaming) {
474		s32 i, ret, cmd_status = 0;
475
476		pd_dvb->is_streaming = 0;
477
478		for (i = 0; i < DVB_SBUF_NUM; i++)
479			if (pd_dvb->urb_array[i])
480				usb_kill_urb(pd_dvb->urb_array[i]);
481
482		ret = send_set_req(pd, PLAY_SERVICE, TLG_TUNE_PLAY_SVC_STOP,
483					&cmd_status);
484		if (ret | cmd_status)
485			log("error");
486	}
487	mutex_unlock(&pd->lock);
488}
489
490static int pd_start_feed(struct dvb_demux_feed *feed)
491{
492	struct pd_dvb_adapter *pd_dvb = feed->demux->priv;
493	int ret = 0;
494
495	if (!pd_dvb)
496		return -1;
497	if (atomic_inc_return(&pd_dvb->active_feed) == 1)
498		ret = dvb_start_streaming(pd_dvb);
499	return ret;
500}
501
502static int pd_stop_feed(struct dvb_demux_feed *feed)
503{
504	struct pd_dvb_adapter *pd_dvb = feed->demux->priv;
505
506	if (!pd_dvb)
507		return -1;
508	if (atomic_dec_and_test(&pd_dvb->active_feed))
509		dvb_stop_streaming(pd_dvb);
510	return 0;
511}
512
513DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
514int pd_dvb_usb_device_init(struct poseidon *pd)
515{
516	struct pd_dvb_adapter *pd_dvb = &pd->dvb_data;
517	struct dvb_demux *dvbdemux;
518	int ret = 0;
519
520	pd_dvb->ep_addr = 0x82;
521	atomic_set(&pd_dvb->users, 0);
522	atomic_set(&pd_dvb->active_feed, 0);
523	pd_dvb->pd_device = pd;
524
525	ret = dvb_register_adapter(&pd_dvb->dvb_adap,
526				"Poseidon dvbt adapter",
527				THIS_MODULE,
528				NULL /* for hibernation correctly*/,
529				adapter_nr);
530	if (ret < 0)
531		goto error1;
532
533	/* register frontend */
534	pd_dvb->dvb_fe.demodulator_priv = pd;
535	memcpy(&pd_dvb->dvb_fe.ops, &poseidon_frontend_ops,
536			sizeof(struct dvb_frontend_ops));
537	ret = dvb_register_frontend(&pd_dvb->dvb_adap, &pd_dvb->dvb_fe);
538	if (ret < 0)
539		goto error2;
540
541	/* register demux device */
542	dvbdemux = &pd_dvb->demux;
543	dvbdemux->dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING;
544	dvbdemux->priv = pd_dvb;
545	dvbdemux->feednum = dvbdemux->filternum = 64;
546	dvbdemux->start_feed = pd_start_feed;
547	dvbdemux->stop_feed = pd_stop_feed;
548	dvbdemux->write_to_decoder = NULL;
549
550	ret = dvb_dmx_init(dvbdemux);
551	if (ret < 0)
552		goto error3;
553
554	pd_dvb->dmxdev.filternum = pd_dvb->demux.filternum;
555	pd_dvb->dmxdev.demux = &pd_dvb->demux.dmx;
556	pd_dvb->dmxdev.capabilities = 0;
557
558	ret = dvb_dmxdev_init(&pd_dvb->dmxdev, &pd_dvb->dvb_adap);
559	if (ret < 0)
560		goto error3;
561	return 0;
562
563error3:
564	dvb_unregister_frontend(&pd_dvb->dvb_fe);
565error2:
566	dvb_unregister_adapter(&pd_dvb->dvb_adap);
567error1:
568	return ret;
569}
570
571void pd_dvb_usb_device_exit(struct poseidon *pd)
572{
573	struct pd_dvb_adapter *pd_dvb = &pd->dvb_data;
574
575	while (atomic_read(&pd_dvb->users) != 0
576		|| atomic_read(&pd_dvb->active_feed) != 0) {
577		set_current_state(TASK_INTERRUPTIBLE);
578		schedule_timeout(HZ);
579	}
580	dvb_dmxdev_release(&pd_dvb->dmxdev);
581	dvb_unregister_frontend(&pd_dvb->dvb_fe);
582	dvb_unregister_adapter(&pd_dvb->dvb_adap);
583	pd_dvb_usb_device_cleanup(pd);
584}
585
586void pd_dvb_usb_device_cleanup(struct poseidon *pd)
587{
588	struct pd_dvb_adapter *pd_dvb = &pd->dvb_data;
589
590	dvb_urb_cleanup(pd_dvb);
591}
592
593int pd_dvb_get_adapter_num(struct pd_dvb_adapter *pd_dvb)
594{
595	return pd_dvb->dvb_adap.num;
596}
597