1/*
2 * TTUSB DEC Driver
3 *
4 * Copyright (C) 2003-2004 Alex Woods <linux-dvb@giblets.org>
5 * IR support by Peter Beutner <p.beutner@gmx.net>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 *
21 */
22
23#include <linux/list.h>
24#include <linux/module.h>
25#include <linux/pci.h>
26#include <linux/slab.h>
27#include <linux/spinlock.h>
28#include <linux/usb.h>
29#include <linux/interrupt.h>
30#include <linux/firmware.h>
31#include <linux/crc32.h>
32#include <linux/init.h>
33#include <linux/input.h>
34
35#include <linux/mutex.h>
36
37#include "dmxdev.h"
38#include "dvb_demux.h"
39#include "dvb_filter.h"
40#include "dvb_frontend.h"
41#include "dvb_net.h"
42#include "ttusbdecfe.h"
43
44static int debug;
45static int output_pva;
46static int enable_rc;
47
48module_param(debug, int, 0644);
49MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
50module_param(output_pva, int, 0444);
51MODULE_PARM_DESC(output_pva, "Output PVA from dvr device (default:off)");
52module_param(enable_rc, int, 0644);
53MODULE_PARM_DESC(enable_rc, "Turn on/off IR remote control(default: off)");
54
55DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
56
57#define dprintk	if (debug) printk
58
59#define DRIVER_NAME		"TechnoTrend/Hauppauge DEC USB"
60
61#define COMMAND_PIPE		0x03
62#define RESULT_PIPE		0x04
63#define IN_PIPE			0x08
64#define OUT_PIPE		0x07
65#define IRQ_PIPE		0x0A
66
67#define COMMAND_PACKET_SIZE	0x3c
68#define ARM_PACKET_SIZE		0x1000
69#define IRQ_PACKET_SIZE		0x8
70
71#define ISO_BUF_COUNT		0x04
72#define FRAMES_PER_ISO_BUF	0x04
73#define ISO_FRAME_SIZE		0x0380
74
75#define	MAX_PVA_LENGTH		6144
76
77enum ttusb_dec_model {
78	TTUSB_DEC2000T,
79	TTUSB_DEC2540T,
80	TTUSB_DEC3000S
81};
82
83enum ttusb_dec_packet_type {
84	TTUSB_DEC_PACKET_PVA,
85	TTUSB_DEC_PACKET_SECTION,
86	TTUSB_DEC_PACKET_EMPTY
87};
88
89enum ttusb_dec_interface {
90	TTUSB_DEC_INTERFACE_INITIAL,
91	TTUSB_DEC_INTERFACE_IN,
92	TTUSB_DEC_INTERFACE_OUT
93};
94
95struct ttusb_dec {
96	enum ttusb_dec_model		model;
97	char				*model_name;
98	char				*firmware_name;
99	int				can_playback;
100
101	/* DVB bits */
102	struct dvb_adapter		adapter;
103	struct dmxdev			dmxdev;
104	struct dvb_demux		demux;
105	struct dmx_frontend		frontend;
106	struct dvb_net			dvb_net;
107	struct dvb_frontend*		fe;
108
109	u16			pid[DMX_PES_OTHER];
110
111	/* USB bits */
112	struct usb_device		*udev;
113	u8				trans_count;
114	unsigned int			command_pipe;
115	unsigned int			result_pipe;
116	unsigned int			in_pipe;
117	unsigned int			out_pipe;
118	unsigned int			irq_pipe;
119	enum ttusb_dec_interface	interface;
120	struct mutex			usb_mutex;
121
122	void			*irq_buffer;
123	struct urb		*irq_urb;
124	dma_addr_t		irq_dma_handle;
125	void			*iso_buffer;
126	dma_addr_t		iso_dma_handle;
127	struct urb		*iso_urb[ISO_BUF_COUNT];
128	int			iso_stream_count;
129	struct mutex		iso_mutex;
130
131	u8				packet[MAX_PVA_LENGTH + 4];
132	enum ttusb_dec_packet_type	packet_type;
133	int				packet_state;
134	int				packet_length;
135	int				packet_payload_length;
136	u16				next_packet_id;
137
138	int				pva_stream_count;
139	int				filter_stream_count;
140
141	struct dvb_filter_pes2ts	a_pes2ts;
142	struct dvb_filter_pes2ts	v_pes2ts;
143
144	u8			v_pes[16 + MAX_PVA_LENGTH];
145	int			v_pes_length;
146	int			v_pes_postbytes;
147
148	struct list_head	urb_frame_list;
149	struct tasklet_struct	urb_tasklet;
150	spinlock_t		urb_frame_list_lock;
151
152	struct dvb_demux_filter	*audio_filter;
153	struct dvb_demux_filter	*video_filter;
154	struct list_head	filter_info_list;
155	spinlock_t		filter_info_list_lock;
156
157	struct input_dev	*rc_input_dev;
158	char			rc_phys[64];
159
160	int			active; /* Loaded successfully */
161};
162
163struct urb_frame {
164	u8			data[ISO_FRAME_SIZE];
165	int			length;
166	struct list_head	urb_frame_list;
167};
168
169struct filter_info {
170	u8			stream_id;
171	struct dvb_demux_filter	*filter;
172	struct list_head	filter_info_list;
173};
174
175static u16 rc_keys[] = {
176	KEY_POWER,
177	KEY_MUTE,
178	KEY_1,
179	KEY_2,
180	KEY_3,
181	KEY_4,
182	KEY_5,
183	KEY_6,
184	KEY_7,
185	KEY_8,
186	KEY_9,
187	KEY_0,
188	KEY_CHANNELUP,
189	KEY_VOLUMEDOWN,
190	KEY_OK,
191	KEY_VOLUMEUP,
192	KEY_CHANNELDOWN,
193	KEY_PREVIOUS,
194	KEY_ESC,
195	KEY_RED,
196	KEY_GREEN,
197	KEY_YELLOW,
198	KEY_BLUE,
199	KEY_OPTION,
200	KEY_M,
201	KEY_RADIO
202};
203
204static void ttusb_dec_set_model(struct ttusb_dec *dec,
205				enum ttusb_dec_model model);
206
207static void ttusb_dec_handle_irq( struct urb *urb)
208{
209	struct ttusb_dec * dec = urb->context;
210	char *buffer = dec->irq_buffer;
211	int retval;
212
213	switch(urb->status) {
214		case 0: /*success*/
215			break;
216		case -ECONNRESET:
217		case -ENOENT:
218		case -ESHUTDOWN:
219		case -ETIME:
220			/* this urb is dead, cleanup */
221			dprintk("%s:urb shutting down with status: %d\n",
222					__func__, urb->status);
223			return;
224		default:
225			dprintk("%s:nonzero status received: %d\n",
226					__func__,urb->status);
227			goto exit;
228	}
229
230	if( (buffer[0] == 0x1) && (buffer[2] == 0x15) )  {
231		/* IR - Event */
232		/* this is an fact a bit too simple implementation;
233		 * the box also reports a keyrepeat signal
234		 * (with buffer[3] == 0x40) in an intervall of ~100ms.
235		 * But to handle this correctly we had to imlemenent some
236		 * kind of timer which signals a 'key up' event if no
237		 * keyrepeat signal is received for lets say 200ms.
238		 * this should/could be added later ...
239		 * for now lets report each signal as a key down and up*/
240		dprintk("%s:rc signal:%d\n", __func__, buffer[4]);
241		input_report_key(dec->rc_input_dev, rc_keys[buffer[4] - 1], 1);
242		input_sync(dec->rc_input_dev);
243		input_report_key(dec->rc_input_dev, rc_keys[buffer[4] - 1], 0);
244		input_sync(dec->rc_input_dev);
245	}
246
247exit:	retval = usb_submit_urb(urb, GFP_ATOMIC);
248	if(retval)
249		printk("%s - usb_commit_urb failed with result: %d\n",
250			__func__, retval);
251}
252
253static u16 crc16(u16 crc, const u8 *buf, size_t len)
254{
255	u16 tmp;
256
257	while (len--) {
258		crc ^= *buf++;
259		crc ^= (u8)crc >> 4;
260		tmp = (u8)crc;
261		crc ^= (tmp ^ (tmp << 1)) << 4;
262	}
263	return crc;
264}
265
266static int ttusb_dec_send_command(struct ttusb_dec *dec, const u8 command,
267				  int param_length, const u8 params[],
268				  int *result_length, u8 cmd_result[])
269{
270	int result, actual_len, i;
271	u8 *b;
272
273	dprintk("%s\n", __func__);
274
275	b = kmalloc(COMMAND_PACKET_SIZE + 4, GFP_KERNEL);
276	if (!b)
277		return -ENOMEM;
278
279	if ((result = mutex_lock_interruptible(&dec->usb_mutex))) {
280		kfree(b);
281		printk("%s: Failed to lock usb mutex.\n", __func__);
282		return result;
283	}
284
285	b[0] = 0xaa;
286	b[1] = ++dec->trans_count;
287	b[2] = command;
288	b[3] = param_length;
289
290	if (params)
291		memcpy(&b[4], params, param_length);
292
293	if (debug) {
294		printk("%s: command: ", __func__);
295		for (i = 0; i < param_length + 4; i++)
296			printk("0x%02X ", b[i]);
297		printk("\n");
298	}
299
300	result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
301			      COMMAND_PACKET_SIZE + 4, &actual_len, 1000);
302
303	if (result) {
304		printk("%s: command bulk message failed: error %d\n",
305		       __func__, result);
306		mutex_unlock(&dec->usb_mutex);
307		kfree(b);
308		return result;
309	}
310
311	result = usb_bulk_msg(dec->udev, dec->result_pipe, b,
312			      COMMAND_PACKET_SIZE + 4, &actual_len, 1000);
313
314	if (result) {
315		printk("%s: result bulk message failed: error %d\n",
316		       __func__, result);
317		mutex_unlock(&dec->usb_mutex);
318		kfree(b);
319		return result;
320	} else {
321		if (debug) {
322			printk("%s: result: ", __func__);
323			for (i = 0; i < actual_len; i++)
324				printk("0x%02X ", b[i]);
325			printk("\n");
326		}
327
328		if (result_length)
329			*result_length = b[3];
330		if (cmd_result && b[3] > 0)
331			memcpy(cmd_result, &b[4], b[3]);
332
333		mutex_unlock(&dec->usb_mutex);
334
335		kfree(b);
336		return 0;
337	}
338}
339
340static int ttusb_dec_get_stb_state (struct ttusb_dec *dec, unsigned int *mode,
341				    unsigned int *model, unsigned int *version)
342{
343	u8 c[COMMAND_PACKET_SIZE];
344	int c_length;
345	int result;
346	__be32 tmp;
347
348	dprintk("%s\n", __func__);
349
350	result = ttusb_dec_send_command(dec, 0x08, 0, NULL, &c_length, c);
351	if (result)
352		return result;
353
354	if (c_length >= 0x0c) {
355		if (mode != NULL) {
356			memcpy(&tmp, c, 4);
357			*mode = ntohl(tmp);
358		}
359		if (model != NULL) {
360			memcpy(&tmp, &c[4], 4);
361			*model = ntohl(tmp);
362		}
363		if (version != NULL) {
364			memcpy(&tmp, &c[8], 4);
365			*version = ntohl(tmp);
366		}
367		return 0;
368	} else {
369		return -ENOENT;
370	}
371}
372
373static int ttusb_dec_audio_pes2ts_cb(void *priv, unsigned char *data)
374{
375	struct ttusb_dec *dec = priv;
376
377	dec->audio_filter->feed->cb.ts(data, 188, NULL, 0,
378				       &dec->audio_filter->feed->feed.ts,
379				       DMX_OK);
380
381	return 0;
382}
383
384static int ttusb_dec_video_pes2ts_cb(void *priv, unsigned char *data)
385{
386	struct ttusb_dec *dec = priv;
387
388	dec->video_filter->feed->cb.ts(data, 188, NULL, 0,
389				       &dec->video_filter->feed->feed.ts,
390				       DMX_OK);
391
392	return 0;
393}
394
395static void ttusb_dec_set_pids(struct ttusb_dec *dec)
396{
397	u8 b[] = { 0x00, 0x00, 0x00, 0x00,
398		   0x00, 0x00, 0xff, 0xff,
399		   0xff, 0xff, 0xff, 0xff };
400
401	__be16 pcr = htons(dec->pid[DMX_PES_PCR]);
402	__be16 audio = htons(dec->pid[DMX_PES_AUDIO]);
403	__be16 video = htons(dec->pid[DMX_PES_VIDEO]);
404
405	dprintk("%s\n", __func__);
406
407	memcpy(&b[0], &pcr, 2);
408	memcpy(&b[2], &audio, 2);
409	memcpy(&b[4], &video, 2);
410
411	ttusb_dec_send_command(dec, 0x50, sizeof(b), b, NULL, NULL);
412
413	dvb_filter_pes2ts_init(&dec->a_pes2ts, dec->pid[DMX_PES_AUDIO],
414			       ttusb_dec_audio_pes2ts_cb, dec);
415	dvb_filter_pes2ts_init(&dec->v_pes2ts, dec->pid[DMX_PES_VIDEO],
416			       ttusb_dec_video_pes2ts_cb, dec);
417	dec->v_pes_length = 0;
418	dec->v_pes_postbytes = 0;
419}
420
421static void ttusb_dec_process_pva(struct ttusb_dec *dec, u8 *pva, int length)
422{
423	if (length < 8) {
424		printk("%s: packet too short - discarding\n", __func__);
425		return;
426	}
427
428	if (length > 8 + MAX_PVA_LENGTH) {
429		printk("%s: packet too long - discarding\n", __func__);
430		return;
431	}
432
433	switch (pva[2]) {
434
435	case 0x01: {		/* VideoStream */
436		int prebytes = pva[5] & 0x03;
437		int postbytes = (pva[5] & 0x0c) >> 2;
438		__be16 v_pes_payload_length;
439
440		if (output_pva) {
441			dec->video_filter->feed->cb.ts(pva, length, NULL, 0,
442				&dec->video_filter->feed->feed.ts, DMX_OK);
443			return;
444		}
445
446		if (dec->v_pes_postbytes > 0 &&
447		    dec->v_pes_postbytes == prebytes) {
448			memcpy(&dec->v_pes[dec->v_pes_length],
449			       &pva[12], prebytes);
450
451			dvb_filter_pes2ts(&dec->v_pes2ts, dec->v_pes,
452					  dec->v_pes_length + prebytes, 1);
453		}
454
455		if (pva[5] & 0x10) {
456			dec->v_pes[7] = 0x80;
457			dec->v_pes[8] = 0x05;
458
459			dec->v_pes[9] = 0x21 | ((pva[8] & 0xc0) >> 5);
460			dec->v_pes[10] = ((pva[8] & 0x3f) << 2) |
461					 ((pva[9] & 0xc0) >> 6);
462			dec->v_pes[11] = 0x01 |
463					 ((pva[9] & 0x3f) << 2) |
464					 ((pva[10] & 0x80) >> 6);
465			dec->v_pes[12] = ((pva[10] & 0x7f) << 1) |
466					 ((pva[11] & 0xc0) >> 7);
467			dec->v_pes[13] = 0x01 | ((pva[11] & 0x7f) << 1);
468
469			memcpy(&dec->v_pes[14], &pva[12 + prebytes],
470			       length - 12 - prebytes);
471			dec->v_pes_length = 14 + length - 12 - prebytes;
472		} else {
473			dec->v_pes[7] = 0x00;
474			dec->v_pes[8] = 0x00;
475
476			memcpy(&dec->v_pes[9], &pva[8], length - 8);
477			dec->v_pes_length = 9 + length - 8;
478		}
479
480		dec->v_pes_postbytes = postbytes;
481
482		if (dec->v_pes[9 + dec->v_pes[8]] == 0x00 &&
483		    dec->v_pes[10 + dec->v_pes[8]] == 0x00 &&
484		    dec->v_pes[11 + dec->v_pes[8]] == 0x01)
485			dec->v_pes[6] = 0x84;
486		else
487			dec->v_pes[6] = 0x80;
488
489		v_pes_payload_length = htons(dec->v_pes_length - 6 +
490					     postbytes);
491		memcpy(&dec->v_pes[4], &v_pes_payload_length, 2);
492
493		if (postbytes == 0)
494			dvb_filter_pes2ts(&dec->v_pes2ts, dec->v_pes,
495					  dec->v_pes_length, 1);
496
497		break;
498	}
499
500	case 0x02:		/* MainAudioStream */
501		if (output_pva) {
502			dec->audio_filter->feed->cb.ts(pva, length, NULL, 0,
503				&dec->audio_filter->feed->feed.ts, DMX_OK);
504			return;
505		}
506
507		dvb_filter_pes2ts(&dec->a_pes2ts, &pva[8], length - 8,
508				  pva[5] & 0x10);
509		break;
510
511	default:
512		printk("%s: unknown PVA type: %02x.\n", __func__,
513		       pva[2]);
514		break;
515	}
516}
517
518static void ttusb_dec_process_filter(struct ttusb_dec *dec, u8 *packet,
519				     int length)
520{
521	struct list_head *item;
522	struct filter_info *finfo;
523	struct dvb_demux_filter *filter = NULL;
524	unsigned long flags;
525	u8 sid;
526
527	sid = packet[1];
528	spin_lock_irqsave(&dec->filter_info_list_lock, flags);
529	for (item = dec->filter_info_list.next; item != &dec->filter_info_list;
530	     item = item->next) {
531		finfo = list_entry(item, struct filter_info, filter_info_list);
532		if (finfo->stream_id == sid) {
533			filter = finfo->filter;
534			break;
535		}
536	}
537	spin_unlock_irqrestore(&dec->filter_info_list_lock, flags);
538
539	if (filter)
540		filter->feed->cb.sec(&packet[2], length - 2, NULL, 0,
541				     &filter->filter, DMX_OK);
542}
543
544static void ttusb_dec_process_packet(struct ttusb_dec *dec)
545{
546	int i;
547	u16 csum = 0;
548	u16 packet_id;
549
550	if (dec->packet_length % 2) {
551		printk("%s: odd sized packet - discarding\n", __func__);
552		return;
553	}
554
555	for (i = 0; i < dec->packet_length; i += 2)
556		csum ^= ((dec->packet[i] << 8) + dec->packet[i + 1]);
557
558	if (csum) {
559		printk("%s: checksum failed - discarding\n", __func__);
560		return;
561	}
562
563	packet_id = dec->packet[dec->packet_length - 4] << 8;
564	packet_id += dec->packet[dec->packet_length - 3];
565
566	if ((packet_id != dec->next_packet_id) && dec->next_packet_id) {
567		printk("%s: warning: lost packets between %u and %u\n",
568		       __func__, dec->next_packet_id - 1, packet_id);
569	}
570
571	if (packet_id == 0xffff)
572		dec->next_packet_id = 0x8000;
573	else
574		dec->next_packet_id = packet_id + 1;
575
576	switch (dec->packet_type) {
577	case TTUSB_DEC_PACKET_PVA:
578		if (dec->pva_stream_count)
579			ttusb_dec_process_pva(dec, dec->packet,
580					      dec->packet_payload_length);
581		break;
582
583	case TTUSB_DEC_PACKET_SECTION:
584		if (dec->filter_stream_count)
585			ttusb_dec_process_filter(dec, dec->packet,
586						 dec->packet_payload_length);
587		break;
588
589	case TTUSB_DEC_PACKET_EMPTY:
590		break;
591	}
592}
593
594static void swap_bytes(u8 *b, int length)
595{
596	u8 c;
597
598	length -= length % 2;
599	for (; length; b += 2, length -= 2) {
600		c = *b;
601		*b = *(b + 1);
602		*(b + 1) = c;
603	}
604}
605
606static void ttusb_dec_process_urb_frame(struct ttusb_dec *dec, u8 *b,
607					int length)
608{
609	swap_bytes(b, length);
610
611	while (length) {
612		switch (dec->packet_state) {
613
614		case 0:
615		case 1:
616		case 2:
617			if (*b++ == 0xaa)
618				dec->packet_state++;
619			else
620				dec->packet_state = 0;
621
622			length--;
623			break;
624
625		case 3:
626			if (*b == 0x00) {
627				dec->packet_state++;
628				dec->packet_length = 0;
629			} else if (*b != 0xaa) {
630				dec->packet_state = 0;
631			}
632
633			b++;
634			length--;
635			break;
636
637		case 4:
638			dec->packet[dec->packet_length++] = *b++;
639
640			if (dec->packet_length == 2) {
641				if (dec->packet[0] == 'A' &&
642				    dec->packet[1] == 'V') {
643					dec->packet_type =
644						TTUSB_DEC_PACKET_PVA;
645					dec->packet_state++;
646				} else if (dec->packet[0] == 'S') {
647					dec->packet_type =
648						TTUSB_DEC_PACKET_SECTION;
649					dec->packet_state++;
650				} else if (dec->packet[0] == 0x00) {
651					dec->packet_type =
652						TTUSB_DEC_PACKET_EMPTY;
653					dec->packet_payload_length = 2;
654					dec->packet_state = 7;
655				} else {
656					printk("%s: unknown packet type: "
657					       "%02x%02x\n", __func__,
658					       dec->packet[0], dec->packet[1]);
659					dec->packet_state = 0;
660				}
661			}
662
663			length--;
664			break;
665
666		case 5:
667			dec->packet[dec->packet_length++] = *b++;
668
669			if (dec->packet_type == TTUSB_DEC_PACKET_PVA &&
670			    dec->packet_length == 8) {
671				dec->packet_state++;
672				dec->packet_payload_length = 8 +
673					(dec->packet[6] << 8) +
674					dec->packet[7];
675			} else if (dec->packet_type ==
676					TTUSB_DEC_PACKET_SECTION &&
677				   dec->packet_length == 5) {
678				dec->packet_state++;
679				dec->packet_payload_length = 5 +
680					((dec->packet[3] & 0x0f) << 8) +
681					dec->packet[4];
682			}
683
684			length--;
685			break;
686
687		case 6: {
688			int remainder = dec->packet_payload_length -
689					dec->packet_length;
690
691			if (length >= remainder) {
692				memcpy(dec->packet + dec->packet_length,
693				       b, remainder);
694				dec->packet_length += remainder;
695				b += remainder;
696				length -= remainder;
697				dec->packet_state++;
698			} else {
699				memcpy(&dec->packet[dec->packet_length],
700				       b, length);
701				dec->packet_length += length;
702				length = 0;
703			}
704
705			break;
706		}
707
708		case 7: {
709			int tail = 4;
710
711			dec->packet[dec->packet_length++] = *b++;
712
713			if (dec->packet_type == TTUSB_DEC_PACKET_SECTION &&
714			    dec->packet_payload_length % 2)
715				tail++;
716
717			if (dec->packet_length ==
718			    dec->packet_payload_length + tail) {
719				ttusb_dec_process_packet(dec);
720				dec->packet_state = 0;
721			}
722
723			length--;
724			break;
725		}
726
727		default:
728			printk("%s: illegal packet state encountered.\n",
729			       __func__);
730			dec->packet_state = 0;
731		}
732	}
733}
734
735static void ttusb_dec_process_urb_frame_list(unsigned long data)
736{
737	struct ttusb_dec *dec = (struct ttusb_dec *)data;
738	struct list_head *item;
739	struct urb_frame *frame;
740	unsigned long flags;
741
742	while (1) {
743		spin_lock_irqsave(&dec->urb_frame_list_lock, flags);
744		if ((item = dec->urb_frame_list.next) != &dec->urb_frame_list) {
745			frame = list_entry(item, struct urb_frame,
746					   urb_frame_list);
747			list_del(&frame->urb_frame_list);
748		} else {
749			spin_unlock_irqrestore(&dec->urb_frame_list_lock,
750					       flags);
751			return;
752		}
753		spin_unlock_irqrestore(&dec->urb_frame_list_lock, flags);
754
755		ttusb_dec_process_urb_frame(dec, frame->data, frame->length);
756		kfree(frame);
757	}
758}
759
760static void ttusb_dec_process_urb(struct urb *urb)
761{
762	struct ttusb_dec *dec = urb->context;
763
764	if (!urb->status) {
765		int i;
766
767		for (i = 0; i < FRAMES_PER_ISO_BUF; i++) {
768			struct usb_iso_packet_descriptor *d;
769			u8 *b;
770			int length;
771			struct urb_frame *frame;
772
773			d = &urb->iso_frame_desc[i];
774			b = urb->transfer_buffer + d->offset;
775			length = d->actual_length;
776
777			if ((frame = kmalloc(sizeof(struct urb_frame),
778					     GFP_ATOMIC))) {
779				unsigned long flags;
780
781				memcpy(frame->data, b, length);
782				frame->length = length;
783
784				spin_lock_irqsave(&dec->urb_frame_list_lock,
785						     flags);
786				list_add_tail(&frame->urb_frame_list,
787					      &dec->urb_frame_list);
788				spin_unlock_irqrestore(&dec->urb_frame_list_lock,
789						       flags);
790
791				tasklet_schedule(&dec->urb_tasklet);
792			}
793		}
794	} else {
795		 /* -ENOENT is expected when unlinking urbs */
796		if (urb->status != -ENOENT)
797			dprintk("%s: urb error: %d\n", __func__,
798				urb->status);
799	}
800
801	if (dec->iso_stream_count)
802		usb_submit_urb(urb, GFP_ATOMIC);
803}
804
805static void ttusb_dec_setup_urbs(struct ttusb_dec *dec)
806{
807	int i, j, buffer_offset = 0;
808
809	dprintk("%s\n", __func__);
810
811	for (i = 0; i < ISO_BUF_COUNT; i++) {
812		int frame_offset = 0;
813		struct urb *urb = dec->iso_urb[i];
814
815		urb->dev = dec->udev;
816		urb->context = dec;
817		urb->complete = ttusb_dec_process_urb;
818		urb->pipe = dec->in_pipe;
819		urb->transfer_flags = URB_ISO_ASAP;
820		urb->interval = 1;
821		urb->number_of_packets = FRAMES_PER_ISO_BUF;
822		urb->transfer_buffer_length = ISO_FRAME_SIZE *
823					      FRAMES_PER_ISO_BUF;
824		urb->transfer_buffer = dec->iso_buffer + buffer_offset;
825		buffer_offset += ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF;
826
827		for (j = 0; j < FRAMES_PER_ISO_BUF; j++) {
828			urb->iso_frame_desc[j].offset = frame_offset;
829			urb->iso_frame_desc[j].length = ISO_FRAME_SIZE;
830			frame_offset += ISO_FRAME_SIZE;
831		}
832	}
833}
834
835static void ttusb_dec_stop_iso_xfer(struct ttusb_dec *dec)
836{
837	int i;
838
839	dprintk("%s\n", __func__);
840
841	if (mutex_lock_interruptible(&dec->iso_mutex))
842		return;
843
844	dec->iso_stream_count--;
845
846	if (!dec->iso_stream_count) {
847		for (i = 0; i < ISO_BUF_COUNT; i++)
848			usb_kill_urb(dec->iso_urb[i]);
849	}
850
851	mutex_unlock(&dec->iso_mutex);
852}
853
854/* Setting the interface of the DEC tends to take down the USB communications
855 * for a short period, so it's important not to call this function just before
856 * trying to talk to it.
857 */
858static int ttusb_dec_set_interface(struct ttusb_dec *dec,
859				   enum ttusb_dec_interface interface)
860{
861	int result = 0;
862	u8 b[] = { 0x05 };
863
864	if (interface != dec->interface) {
865		switch (interface) {
866		case TTUSB_DEC_INTERFACE_INITIAL:
867			result = usb_set_interface(dec->udev, 0, 0);
868			break;
869		case TTUSB_DEC_INTERFACE_IN:
870			result = ttusb_dec_send_command(dec, 0x80, sizeof(b),
871							b, NULL, NULL);
872			if (result)
873				return result;
874			result = usb_set_interface(dec->udev, 0, 8);
875			break;
876		case TTUSB_DEC_INTERFACE_OUT:
877			result = usb_set_interface(dec->udev, 0, 1);
878			break;
879		}
880
881		if (result)
882			return result;
883
884		dec->interface = interface;
885	}
886
887	return 0;
888}
889
890static int ttusb_dec_start_iso_xfer(struct ttusb_dec *dec)
891{
892	int i, result;
893
894	dprintk("%s\n", __func__);
895
896	if (mutex_lock_interruptible(&dec->iso_mutex))
897		return -EAGAIN;
898
899	if (!dec->iso_stream_count) {
900		ttusb_dec_setup_urbs(dec);
901
902		dec->packet_state = 0;
903		dec->v_pes_postbytes = 0;
904		dec->next_packet_id = 0;
905
906		for (i = 0; i < ISO_BUF_COUNT; i++) {
907			if ((result = usb_submit_urb(dec->iso_urb[i],
908						     GFP_ATOMIC))) {
909				printk("%s: failed urb submission %d: "
910				       "error %d\n", __func__, i, result);
911
912				while (i) {
913					usb_kill_urb(dec->iso_urb[i - 1]);
914					i--;
915				}
916
917				mutex_unlock(&dec->iso_mutex);
918				return result;
919			}
920		}
921	}
922
923	dec->iso_stream_count++;
924
925	mutex_unlock(&dec->iso_mutex);
926
927	return 0;
928}
929
930static int ttusb_dec_start_ts_feed(struct dvb_demux_feed *dvbdmxfeed)
931{
932	struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
933	struct ttusb_dec *dec = dvbdmx->priv;
934	u8 b0[] = { 0x05 };
935	int result = 0;
936
937	dprintk("%s\n", __func__);
938
939	dprintk("  ts_type:");
940
941	if (dvbdmxfeed->ts_type & TS_DECODER)
942		dprintk(" TS_DECODER");
943
944	if (dvbdmxfeed->ts_type & TS_PACKET)
945		dprintk(" TS_PACKET");
946
947	if (dvbdmxfeed->ts_type & TS_PAYLOAD_ONLY)
948		dprintk(" TS_PAYLOAD_ONLY");
949
950	dprintk("\n");
951
952	switch (dvbdmxfeed->pes_type) {
953
954	case DMX_PES_VIDEO:
955		dprintk("  pes_type: DMX_PES_VIDEO\n");
956		dec->pid[DMX_PES_PCR] = dvbdmxfeed->pid;
957		dec->pid[DMX_PES_VIDEO] = dvbdmxfeed->pid;
958		dec->video_filter = dvbdmxfeed->filter;
959		ttusb_dec_set_pids(dec);
960		break;
961
962	case DMX_PES_AUDIO:
963		dprintk("  pes_type: DMX_PES_AUDIO\n");
964		dec->pid[DMX_PES_AUDIO] = dvbdmxfeed->pid;
965		dec->audio_filter = dvbdmxfeed->filter;
966		ttusb_dec_set_pids(dec);
967		break;
968
969	case DMX_PES_TELETEXT:
970		dec->pid[DMX_PES_TELETEXT] = dvbdmxfeed->pid;
971		dprintk("  pes_type: DMX_PES_TELETEXT(not supported)\n");
972		return -ENOSYS;
973
974	case DMX_PES_PCR:
975		dprintk("  pes_type: DMX_PES_PCR\n");
976		dec->pid[DMX_PES_PCR] = dvbdmxfeed->pid;
977		ttusb_dec_set_pids(dec);
978		break;
979
980	case DMX_PES_OTHER:
981		dprintk("  pes_type: DMX_PES_OTHER(not supported)\n");
982		return -ENOSYS;
983
984	default:
985		dprintk("  pes_type: unknown (%d)\n", dvbdmxfeed->pes_type);
986		return -EINVAL;
987
988	}
989
990	result = ttusb_dec_send_command(dec, 0x80, sizeof(b0), b0, NULL, NULL);
991	if (result)
992		return result;
993
994	dec->pva_stream_count++;
995	return ttusb_dec_start_iso_xfer(dec);
996}
997
998static int ttusb_dec_start_sec_feed(struct dvb_demux_feed *dvbdmxfeed)
999{
1000	struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
1001	u8 b0[] = { 0x00, 0x00, 0x00, 0x01,
1002		    0x00, 0x00, 0x00, 0x00,
1003		    0x00, 0x00, 0x00, 0x00,
1004		    0x00, 0x00, 0x00, 0x00,
1005		    0x00, 0xff, 0x00, 0x00,
1006		    0x00, 0x00, 0x00, 0x00,
1007		    0x00, 0x00, 0x00, 0x00,
1008		    0x00 };
1009	__be16 pid;
1010	u8 c[COMMAND_PACKET_SIZE];
1011	int c_length;
1012	int result;
1013	struct filter_info *finfo;
1014	unsigned long flags;
1015	u8 x = 1;
1016
1017	dprintk("%s\n", __func__);
1018
1019	pid = htons(dvbdmxfeed->pid);
1020	memcpy(&b0[0], &pid, 2);
1021	memcpy(&b0[4], &x, 1);
1022	memcpy(&b0[5], &dvbdmxfeed->filter->filter.filter_value[0], 1);
1023
1024	result = ttusb_dec_send_command(dec, 0x60, sizeof(b0), b0,
1025					&c_length, c);
1026
1027	if (!result) {
1028		if (c_length == 2) {
1029			if (!(finfo = kmalloc(sizeof(struct filter_info),
1030					      GFP_ATOMIC)))
1031				return -ENOMEM;
1032
1033			finfo->stream_id = c[1];
1034			finfo->filter = dvbdmxfeed->filter;
1035
1036			spin_lock_irqsave(&dec->filter_info_list_lock, flags);
1037			list_add_tail(&finfo->filter_info_list,
1038				      &dec->filter_info_list);
1039			spin_unlock_irqrestore(&dec->filter_info_list_lock,
1040					       flags);
1041
1042			dvbdmxfeed->priv = finfo;
1043
1044			dec->filter_stream_count++;
1045			return ttusb_dec_start_iso_xfer(dec);
1046		}
1047
1048		return -EAGAIN;
1049	} else
1050		return result;
1051}
1052
1053static int ttusb_dec_start_feed(struct dvb_demux_feed *dvbdmxfeed)
1054{
1055	struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
1056
1057	dprintk("%s\n", __func__);
1058
1059	if (!dvbdmx->dmx.frontend)
1060		return -EINVAL;
1061
1062	dprintk("  pid: 0x%04X\n", dvbdmxfeed->pid);
1063
1064	switch (dvbdmxfeed->type) {
1065
1066	case DMX_TYPE_TS:
1067		return ttusb_dec_start_ts_feed(dvbdmxfeed);
1068		break;
1069
1070	case DMX_TYPE_SEC:
1071		return ttusb_dec_start_sec_feed(dvbdmxfeed);
1072		break;
1073
1074	default:
1075		dprintk("  type: unknown (%d)\n", dvbdmxfeed->type);
1076		return -EINVAL;
1077
1078	}
1079}
1080
1081static int ttusb_dec_stop_ts_feed(struct dvb_demux_feed *dvbdmxfeed)
1082{
1083	struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
1084	u8 b0[] = { 0x00 };
1085
1086	ttusb_dec_send_command(dec, 0x81, sizeof(b0), b0, NULL, NULL);
1087
1088	dec->pva_stream_count--;
1089
1090	ttusb_dec_stop_iso_xfer(dec);
1091
1092	return 0;
1093}
1094
1095static int ttusb_dec_stop_sec_feed(struct dvb_demux_feed *dvbdmxfeed)
1096{
1097	struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
1098	u8 b0[] = { 0x00, 0x00 };
1099	struct filter_info *finfo = (struct filter_info *)dvbdmxfeed->priv;
1100	unsigned long flags;
1101
1102	b0[1] = finfo->stream_id;
1103	spin_lock_irqsave(&dec->filter_info_list_lock, flags);
1104	list_del(&finfo->filter_info_list);
1105	spin_unlock_irqrestore(&dec->filter_info_list_lock, flags);
1106	kfree(finfo);
1107	ttusb_dec_send_command(dec, 0x62, sizeof(b0), b0, NULL, NULL);
1108
1109	dec->filter_stream_count--;
1110
1111	ttusb_dec_stop_iso_xfer(dec);
1112
1113	return 0;
1114}
1115
1116static int ttusb_dec_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
1117{
1118	dprintk("%s\n", __func__);
1119
1120	switch (dvbdmxfeed->type) {
1121	case DMX_TYPE_TS:
1122		return ttusb_dec_stop_ts_feed(dvbdmxfeed);
1123		break;
1124
1125	case DMX_TYPE_SEC:
1126		return ttusb_dec_stop_sec_feed(dvbdmxfeed);
1127		break;
1128	}
1129
1130	return 0;
1131}
1132
1133static void ttusb_dec_free_iso_urbs(struct ttusb_dec *dec)
1134{
1135	int i;
1136
1137	dprintk("%s\n", __func__);
1138
1139	for (i = 0; i < ISO_BUF_COUNT; i++)
1140		usb_free_urb(dec->iso_urb[i]);
1141
1142	pci_free_consistent(NULL,
1143			    ISO_FRAME_SIZE * (FRAMES_PER_ISO_BUF *
1144					      ISO_BUF_COUNT),
1145			    dec->iso_buffer, dec->iso_dma_handle);
1146}
1147
1148static int ttusb_dec_alloc_iso_urbs(struct ttusb_dec *dec)
1149{
1150	int i;
1151
1152	dprintk("%s\n", __func__);
1153
1154	dec->iso_buffer = pci_zalloc_consistent(NULL,
1155						ISO_FRAME_SIZE * (FRAMES_PER_ISO_BUF * ISO_BUF_COUNT),
1156						&dec->iso_dma_handle);
1157
1158	if (!dec->iso_buffer) {
1159		dprintk("%s: pci_alloc_consistent - not enough memory\n",
1160			__func__);
1161		return -ENOMEM;
1162	}
1163
1164	for (i = 0; i < ISO_BUF_COUNT; i++) {
1165		struct urb *urb;
1166
1167		if (!(urb = usb_alloc_urb(FRAMES_PER_ISO_BUF, GFP_ATOMIC))) {
1168			ttusb_dec_free_iso_urbs(dec);
1169			return -ENOMEM;
1170		}
1171
1172		dec->iso_urb[i] = urb;
1173	}
1174
1175	ttusb_dec_setup_urbs(dec);
1176
1177	return 0;
1178}
1179
1180static void ttusb_dec_init_tasklet(struct ttusb_dec *dec)
1181{
1182	spin_lock_init(&dec->urb_frame_list_lock);
1183	INIT_LIST_HEAD(&dec->urb_frame_list);
1184	tasklet_init(&dec->urb_tasklet, ttusb_dec_process_urb_frame_list,
1185		     (unsigned long)dec);
1186}
1187
1188static int ttusb_init_rc( struct ttusb_dec *dec)
1189{
1190	struct input_dev *input_dev;
1191	u8 b[] = { 0x00, 0x01 };
1192	int i;
1193	int err;
1194
1195	usb_make_path(dec->udev, dec->rc_phys, sizeof(dec->rc_phys));
1196	strlcat(dec->rc_phys, "/input0", sizeof(dec->rc_phys));
1197
1198	input_dev = input_allocate_device();
1199	if (!input_dev)
1200		return -ENOMEM;
1201
1202	input_dev->name = "ttusb_dec remote control";
1203	input_dev->phys = dec->rc_phys;
1204	input_dev->evbit[0] = BIT_MASK(EV_KEY);
1205	input_dev->keycodesize = sizeof(u16);
1206	input_dev->keycodemax = 0x1a;
1207	input_dev->keycode = rc_keys;
1208
1209	for (i = 0; i < ARRAY_SIZE(rc_keys); i++)
1210		  set_bit(rc_keys[i], input_dev->keybit);
1211
1212	err = input_register_device(input_dev);
1213	if (err) {
1214		input_free_device(input_dev);
1215		return err;
1216	}
1217
1218	dec->rc_input_dev = input_dev;
1219	if (usb_submit_urb(dec->irq_urb, GFP_KERNEL))
1220		printk("%s: usb_submit_urb failed\n",__func__);
1221	/* enable irq pipe */
1222	ttusb_dec_send_command(dec,0xb0,sizeof(b),b,NULL,NULL);
1223
1224	return 0;
1225}
1226
1227static void ttusb_dec_init_v_pes(struct ttusb_dec *dec)
1228{
1229	dprintk("%s\n", __func__);
1230
1231	dec->v_pes[0] = 0x00;
1232	dec->v_pes[1] = 0x00;
1233	dec->v_pes[2] = 0x01;
1234	dec->v_pes[3] = 0xe0;
1235}
1236
1237static int ttusb_dec_init_usb(struct ttusb_dec *dec)
1238{
1239	int result;
1240
1241	dprintk("%s\n", __func__);
1242
1243	mutex_init(&dec->usb_mutex);
1244	mutex_init(&dec->iso_mutex);
1245
1246	dec->command_pipe = usb_sndbulkpipe(dec->udev, COMMAND_PIPE);
1247	dec->result_pipe = usb_rcvbulkpipe(dec->udev, RESULT_PIPE);
1248	dec->in_pipe = usb_rcvisocpipe(dec->udev, IN_PIPE);
1249	dec->out_pipe = usb_sndisocpipe(dec->udev, OUT_PIPE);
1250	dec->irq_pipe = usb_rcvintpipe(dec->udev, IRQ_PIPE);
1251
1252	if(enable_rc) {
1253		dec->irq_urb = usb_alloc_urb(0, GFP_KERNEL);
1254		if(!dec->irq_urb) {
1255			return -ENOMEM;
1256		}
1257		dec->irq_buffer = usb_alloc_coherent(dec->udev,IRQ_PACKET_SIZE,
1258					GFP_KERNEL, &dec->irq_dma_handle);
1259		if(!dec->irq_buffer) {
1260			usb_free_urb(dec->irq_urb);
1261			return -ENOMEM;
1262		}
1263		usb_fill_int_urb(dec->irq_urb, dec->udev,dec->irq_pipe,
1264				 dec->irq_buffer, IRQ_PACKET_SIZE,
1265				 ttusb_dec_handle_irq, dec, 1);
1266		dec->irq_urb->transfer_dma = dec->irq_dma_handle;
1267		dec->irq_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1268	}
1269
1270	result = ttusb_dec_alloc_iso_urbs(dec);
1271	if (result) {
1272		usb_free_urb(dec->irq_urb);
1273		usb_free_coherent(dec->udev, IRQ_PACKET_SIZE,
1274				  dec->irq_buffer, dec->irq_dma_handle);
1275	}
1276	return result;
1277}
1278
1279static int ttusb_dec_boot_dsp(struct ttusb_dec *dec)
1280{
1281	int i, j, actual_len, result, size, trans_count;
1282	u8 b0[] = { 0x00, 0x00, 0x00, 0x00,
1283		    0x00, 0x00, 0x00, 0x00,
1284		    0x61, 0x00 };
1285	u8 b1[] = { 0x61 };
1286	u8 *b;
1287	char idstring[21];
1288	const u8 *firmware = NULL;
1289	size_t firmware_size = 0;
1290	u16 firmware_csum = 0;
1291	__be16 firmware_csum_ns;
1292	__be32 firmware_size_nl;
1293	u32 crc32_csum, crc32_check;
1294	__be32 tmp;
1295	const struct firmware *fw_entry = NULL;
1296
1297	dprintk("%s\n", __func__);
1298
1299	result = request_firmware(&fw_entry, dec->firmware_name, &dec->udev->dev);
1300	if (result) {
1301		printk(KERN_ERR "%s: Firmware (%s) unavailable.\n",
1302		       __func__, dec->firmware_name);
1303		return result;
1304	}
1305
1306	firmware = fw_entry->data;
1307	firmware_size = fw_entry->size;
1308
1309	if (firmware_size < 60) {
1310		printk("%s: firmware size too small for DSP code (%zu < 60).\n",
1311			__func__, firmware_size);
1312		release_firmware(fw_entry);
1313		return -ENOENT;
1314	}
1315
1316	/* a 32 bit checksum over the first 56 bytes of the DSP Code is stored
1317	   at offset 56 of file, so use it to check if the firmware file is
1318	   valid. */
1319	crc32_csum = crc32(~0L, firmware, 56) ^ ~0L;
1320	memcpy(&tmp, &firmware[56], 4);
1321	crc32_check = ntohl(tmp);
1322	if (crc32_csum != crc32_check) {
1323		printk("%s: crc32 check of DSP code failed (calculated "
1324		       "0x%08x != 0x%08x in file), file invalid.\n",
1325			__func__, crc32_csum, crc32_check);
1326		release_firmware(fw_entry);
1327		return -ENOENT;
1328	}
1329	memcpy(idstring, &firmware[36], 20);
1330	idstring[20] = '\0';
1331	printk(KERN_INFO "ttusb_dec: found DSP code \"%s\".\n", idstring);
1332
1333	firmware_size_nl = htonl(firmware_size);
1334	memcpy(b0, &firmware_size_nl, 4);
1335	firmware_csum = crc16(~0, firmware, firmware_size) ^ ~0;
1336	firmware_csum_ns = htons(firmware_csum);
1337	memcpy(&b0[6], &firmware_csum_ns, 2);
1338
1339	result = ttusb_dec_send_command(dec, 0x41, sizeof(b0), b0, NULL, NULL);
1340
1341	if (result) {
1342		release_firmware(fw_entry);
1343		return result;
1344	}
1345
1346	trans_count = 0;
1347	j = 0;
1348
1349	b = kmalloc(ARM_PACKET_SIZE, GFP_KERNEL);
1350	if (b == NULL) {
1351		release_firmware(fw_entry);
1352		return -ENOMEM;
1353	}
1354
1355	for (i = 0; i < firmware_size; i += COMMAND_PACKET_SIZE) {
1356		size = firmware_size - i;
1357		if (size > COMMAND_PACKET_SIZE)
1358			size = COMMAND_PACKET_SIZE;
1359
1360		b[j + 0] = 0xaa;
1361		b[j + 1] = trans_count++;
1362		b[j + 2] = 0xf0;
1363		b[j + 3] = size;
1364		memcpy(&b[j + 4], &firmware[i], size);
1365
1366		j += COMMAND_PACKET_SIZE + 4;
1367
1368		if (j >= ARM_PACKET_SIZE) {
1369			result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
1370					      ARM_PACKET_SIZE, &actual_len,
1371					      100);
1372			j = 0;
1373		} else if (size < COMMAND_PACKET_SIZE) {
1374			result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
1375					      j - COMMAND_PACKET_SIZE + size,
1376					      &actual_len, 100);
1377		}
1378	}
1379
1380	result = ttusb_dec_send_command(dec, 0x43, sizeof(b1), b1, NULL, NULL);
1381
1382	release_firmware(fw_entry);
1383	kfree(b);
1384
1385	return result;
1386}
1387
1388static int ttusb_dec_init_stb(struct ttusb_dec *dec)
1389{
1390	int result;
1391	unsigned int mode = 0, model = 0, version = 0;
1392
1393	dprintk("%s\n", __func__);
1394
1395	result = ttusb_dec_get_stb_state(dec, &mode, &model, &version);
1396	if (result)
1397		return result;
1398
1399	if (!mode) {
1400		if (version == 0xABCDEFAB)
1401			printk(KERN_INFO "ttusb_dec: no version "
1402			       "info in Firmware\n");
1403		else
1404			printk(KERN_INFO "ttusb_dec: Firmware "
1405			       "%x.%02x%c%c\n",
1406			       version >> 24, (version >> 16) & 0xff,
1407			       (version >> 8) & 0xff, version & 0xff);
1408
1409		result = ttusb_dec_boot_dsp(dec);
1410		if (result)
1411			return result;
1412	} else {
1413		/* We can't trust the USB IDs that some firmwares
1414		   give the box */
1415		switch (model) {
1416		case 0x00070001:
1417		case 0x00070008:
1418		case 0x0007000c:
1419			ttusb_dec_set_model(dec, TTUSB_DEC3000S);
1420			break;
1421		case 0x00070009:
1422		case 0x00070013:
1423			ttusb_dec_set_model(dec, TTUSB_DEC2000T);
1424			break;
1425		case 0x00070011:
1426			ttusb_dec_set_model(dec, TTUSB_DEC2540T);
1427			break;
1428		default:
1429			printk(KERN_ERR "%s: unknown model returned "
1430			       "by firmware (%08x) - please report\n",
1431			       __func__, model);
1432			return -ENOENT;
1433		}
1434			if (version >= 0x01770000)
1435				dec->can_playback = 1;
1436	}
1437	return 0;
1438}
1439
1440static int ttusb_dec_init_dvb(struct ttusb_dec *dec)
1441{
1442	int result;
1443
1444	dprintk("%s\n", __func__);
1445
1446	if ((result = dvb_register_adapter(&dec->adapter,
1447					   dec->model_name, THIS_MODULE,
1448					   &dec->udev->dev,
1449					   adapter_nr)) < 0) {
1450		printk("%s: dvb_register_adapter failed: error %d\n",
1451		       __func__, result);
1452
1453		return result;
1454	}
1455
1456	dec->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING;
1457
1458	dec->demux.priv = (void *)dec;
1459	dec->demux.filternum = 31;
1460	dec->demux.feednum = 31;
1461	dec->demux.start_feed = ttusb_dec_start_feed;
1462	dec->demux.stop_feed = ttusb_dec_stop_feed;
1463	dec->demux.write_to_decoder = NULL;
1464
1465	if ((result = dvb_dmx_init(&dec->demux)) < 0) {
1466		printk("%s: dvb_dmx_init failed: error %d\n", __func__,
1467		       result);
1468
1469		dvb_unregister_adapter(&dec->adapter);
1470
1471		return result;
1472	}
1473
1474	dec->dmxdev.filternum = 32;
1475	dec->dmxdev.demux = &dec->demux.dmx;
1476	dec->dmxdev.capabilities = 0;
1477
1478	if ((result = dvb_dmxdev_init(&dec->dmxdev, &dec->adapter)) < 0) {
1479		printk("%s: dvb_dmxdev_init failed: error %d\n",
1480		       __func__, result);
1481
1482		dvb_dmx_release(&dec->demux);
1483		dvb_unregister_adapter(&dec->adapter);
1484
1485		return result;
1486	}
1487
1488	dec->frontend.source = DMX_FRONTEND_0;
1489
1490	if ((result = dec->demux.dmx.add_frontend(&dec->demux.dmx,
1491						  &dec->frontend)) < 0) {
1492		printk("%s: dvb_dmx_init failed: error %d\n", __func__,
1493		       result);
1494
1495		dvb_dmxdev_release(&dec->dmxdev);
1496		dvb_dmx_release(&dec->demux);
1497		dvb_unregister_adapter(&dec->adapter);
1498
1499		return result;
1500	}
1501
1502	if ((result = dec->demux.dmx.connect_frontend(&dec->demux.dmx,
1503						      &dec->frontend)) < 0) {
1504		printk("%s: dvb_dmx_init failed: error %d\n", __func__,
1505		       result);
1506
1507		dec->demux.dmx.remove_frontend(&dec->demux.dmx, &dec->frontend);
1508		dvb_dmxdev_release(&dec->dmxdev);
1509		dvb_dmx_release(&dec->demux);
1510		dvb_unregister_adapter(&dec->adapter);
1511
1512		return result;
1513	}
1514
1515	dvb_net_init(&dec->adapter, &dec->dvb_net, &dec->demux.dmx);
1516
1517	return 0;
1518}
1519
1520static void ttusb_dec_exit_dvb(struct ttusb_dec *dec)
1521{
1522	dprintk("%s\n", __func__);
1523
1524	dvb_net_release(&dec->dvb_net);
1525	dec->demux.dmx.close(&dec->demux.dmx);
1526	dec->demux.dmx.remove_frontend(&dec->demux.dmx, &dec->frontend);
1527	dvb_dmxdev_release(&dec->dmxdev);
1528	dvb_dmx_release(&dec->demux);
1529	if (dec->fe) {
1530		dvb_unregister_frontend(dec->fe);
1531		if (dec->fe->ops.release)
1532			dec->fe->ops.release(dec->fe);
1533	}
1534	dvb_unregister_adapter(&dec->adapter);
1535}
1536
1537static void ttusb_dec_exit_rc(struct ttusb_dec *dec)
1538{
1539	dprintk("%s\n", __func__);
1540
1541	if (dec->rc_input_dev) {
1542		input_unregister_device(dec->rc_input_dev);
1543		dec->rc_input_dev = NULL;
1544	}
1545}
1546
1547
1548static void ttusb_dec_exit_usb(struct ttusb_dec *dec)
1549{
1550	int i;
1551
1552	dprintk("%s\n", __func__);
1553
1554	if (enable_rc) {
1555		/* we have to check whether the irq URB is already submitted.
1556		 * As the irq is submitted after the interface is changed,
1557		 * this is the best method i figured out.
1558		 * Any others?*/
1559		if (dec->interface == TTUSB_DEC_INTERFACE_IN)
1560			usb_kill_urb(dec->irq_urb);
1561
1562		usb_free_urb(dec->irq_urb);
1563
1564		usb_free_coherent(dec->udev, IRQ_PACKET_SIZE,
1565				  dec->irq_buffer, dec->irq_dma_handle);
1566	}
1567
1568	dec->iso_stream_count = 0;
1569
1570	for (i = 0; i < ISO_BUF_COUNT; i++)
1571		usb_kill_urb(dec->iso_urb[i]);
1572
1573	ttusb_dec_free_iso_urbs(dec);
1574}
1575
1576static void ttusb_dec_exit_tasklet(struct ttusb_dec *dec)
1577{
1578	struct list_head *item;
1579	struct urb_frame *frame;
1580
1581	tasklet_kill(&dec->urb_tasklet);
1582
1583	while ((item = dec->urb_frame_list.next) != &dec->urb_frame_list) {
1584		frame = list_entry(item, struct urb_frame, urb_frame_list);
1585		list_del(&frame->urb_frame_list);
1586		kfree(frame);
1587	}
1588}
1589
1590static void ttusb_dec_init_filters(struct ttusb_dec *dec)
1591{
1592	INIT_LIST_HEAD(&dec->filter_info_list);
1593	spin_lock_init(&dec->filter_info_list_lock);
1594}
1595
1596static void ttusb_dec_exit_filters(struct ttusb_dec *dec)
1597{
1598	struct list_head *item;
1599	struct filter_info *finfo;
1600
1601	while ((item = dec->filter_info_list.next) != &dec->filter_info_list) {
1602		finfo = list_entry(item, struct filter_info, filter_info_list);
1603		list_del(&finfo->filter_info_list);
1604		kfree(finfo);
1605	}
1606}
1607
1608static int fe_send_command(struct dvb_frontend* fe, const u8 command,
1609			   int param_length, const u8 params[],
1610			   int *result_length, u8 cmd_result[])
1611{
1612	struct ttusb_dec* dec = fe->dvb->priv;
1613	return ttusb_dec_send_command(dec, command, param_length, params, result_length, cmd_result);
1614}
1615
1616static struct ttusbdecfe_config fe_config = {
1617	.send_command = fe_send_command
1618};
1619
1620static int ttusb_dec_probe(struct usb_interface *intf,
1621			   const struct usb_device_id *id)
1622{
1623	struct usb_device *udev;
1624	struct ttusb_dec *dec;
1625	int result;
1626
1627	dprintk("%s\n", __func__);
1628
1629	udev = interface_to_usbdev(intf);
1630
1631	if (!(dec = kzalloc(sizeof(struct ttusb_dec), GFP_KERNEL))) {
1632		printk("%s: couldn't allocate memory.\n", __func__);
1633		return -ENOMEM;
1634	}
1635
1636	usb_set_intfdata(intf, (void *)dec);
1637
1638	switch (id->idProduct) {
1639	case 0x1006:
1640		ttusb_dec_set_model(dec, TTUSB_DEC3000S);
1641		break;
1642
1643	case 0x1008:
1644		ttusb_dec_set_model(dec, TTUSB_DEC2000T);
1645		break;
1646
1647	case 0x1009:
1648		ttusb_dec_set_model(dec, TTUSB_DEC2540T);
1649		break;
1650	}
1651
1652	dec->udev = udev;
1653
1654	result = ttusb_dec_init_usb(dec);
1655	if (result)
1656		goto err_usb;
1657	result = ttusb_dec_init_stb(dec);
1658	if (result)
1659		goto err_stb;
1660	result = ttusb_dec_init_dvb(dec);
1661	if (result)
1662		goto err_stb;
1663
1664	dec->adapter.priv = dec;
1665	switch (id->idProduct) {
1666	case 0x1006:
1667		dec->fe = ttusbdecfe_dvbs_attach(&fe_config);
1668		break;
1669
1670	case 0x1008:
1671	case 0x1009:
1672		dec->fe = ttusbdecfe_dvbt_attach(&fe_config);
1673		break;
1674	}
1675
1676	if (dec->fe == NULL) {
1677		printk("dvb-ttusb-dec: A frontend driver was not found for device [%04x:%04x]\n",
1678		       le16_to_cpu(dec->udev->descriptor.idVendor),
1679		       le16_to_cpu(dec->udev->descriptor.idProduct));
1680	} else {
1681		if (dvb_register_frontend(&dec->adapter, dec->fe)) {
1682			printk("budget-ci: Frontend registration failed!\n");
1683			if (dec->fe->ops.release)
1684				dec->fe->ops.release(dec->fe);
1685			dec->fe = NULL;
1686		}
1687	}
1688
1689	ttusb_dec_init_v_pes(dec);
1690	ttusb_dec_init_filters(dec);
1691	ttusb_dec_init_tasklet(dec);
1692
1693	dec->active = 1;
1694
1695	ttusb_dec_set_interface(dec, TTUSB_DEC_INTERFACE_IN);
1696
1697	if (enable_rc)
1698		ttusb_init_rc(dec);
1699
1700	return 0;
1701err_stb:
1702	ttusb_dec_exit_usb(dec);
1703err_usb:
1704	kfree(dec);
1705	return result;
1706}
1707
1708static void ttusb_dec_disconnect(struct usb_interface *intf)
1709{
1710	struct ttusb_dec *dec = usb_get_intfdata(intf);
1711
1712	usb_set_intfdata(intf, NULL);
1713
1714	dprintk("%s\n", __func__);
1715
1716	if (dec->active) {
1717		ttusb_dec_exit_tasklet(dec);
1718		ttusb_dec_exit_filters(dec);
1719		if(enable_rc)
1720			ttusb_dec_exit_rc(dec);
1721		ttusb_dec_exit_usb(dec);
1722		ttusb_dec_exit_dvb(dec);
1723	}
1724
1725	kfree(dec);
1726}
1727
1728static void ttusb_dec_set_model(struct ttusb_dec *dec,
1729				enum ttusb_dec_model model)
1730{
1731	dec->model = model;
1732
1733	switch (model) {
1734	case TTUSB_DEC2000T:
1735		dec->model_name = "DEC2000-t";
1736		dec->firmware_name = "dvb-ttusb-dec-2000t.fw";
1737		break;
1738
1739	case TTUSB_DEC2540T:
1740		dec->model_name = "DEC2540-t";
1741		dec->firmware_name = "dvb-ttusb-dec-2540t.fw";
1742		break;
1743
1744	case TTUSB_DEC3000S:
1745		dec->model_name = "DEC3000-s";
1746		dec->firmware_name = "dvb-ttusb-dec-3000s.fw";
1747		break;
1748	}
1749}
1750
1751static struct usb_device_id ttusb_dec_table[] = {
1752	{USB_DEVICE(0x0b48, 0x1006)},	/* DEC3000-s */
1753	/*{USB_DEVICE(0x0b48, 0x1007)},	   Unconfirmed */
1754	{USB_DEVICE(0x0b48, 0x1008)},	/* DEC2000-t */
1755	{USB_DEVICE(0x0b48, 0x1009)},	/* DEC2540-t */
1756	{}
1757};
1758
1759static struct usb_driver ttusb_dec_driver = {
1760	.name		= "ttusb-dec",
1761	.probe		= ttusb_dec_probe,
1762	.disconnect	= ttusb_dec_disconnect,
1763	.id_table	= ttusb_dec_table,
1764};
1765
1766module_usb_driver(ttusb_dec_driver);
1767
1768MODULE_AUTHOR("Alex Woods <linux-dvb@giblets.org>");
1769MODULE_DESCRIPTION(DRIVER_NAME);
1770MODULE_LICENSE("GPL");
1771MODULE_DEVICE_TABLE(usb, ttusb_dec_table);
1772