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