text: /*
   * TTUSB DEC Driver
   *
   * Copyright (C) 2003-2004 Alex Woods <linux-dvb@giblets.org>
   * IR support by Peter Beutner <p.beutner@gmx.net>
   *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU General Public License as published by
   * the Free Software Foundation; either version 2 of the License, or
   * (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   */
  
  #include <linux/list.h>
  #include <linux/module.h>
  #include <linux/pci.h>
  #include <linux/slab.h>
  #include <linux/spinlock.h>
  #include <linux/usb.h>
  #include <linux/interrupt.h>
  #include <linux/firmware.h>
  #include <linux/crc32.h>
  #include <linux/init.h>
  #include <linux/input.h>
  
  #include <linux/mutex.h>
  
  #include "dmxdev.h"
  #include "dvb_demux.h"
  #include "dvb_frontend.h"
  #include "dvb_net.h"
  #include "ttusbdecfe.h"
  
  static int debug;
  static int output_pva;
  static int enable_rc;
  
  module_param(debug, int, 0644);
  MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
  module_param(output_pva, int, 0444);
  MODULE_PARM_DESC(output_pva, "Output PVA from dvr device (default:off)");
  module_param(enable_rc, int, 0644);
  MODULE_PARM_DESC(enable_rc, "Turn on/off IR remote control(default: off)");
  
  DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  
  #define dprintk	if (debug) printk
  
  #define DRIVER_NAME		"TechnoTrend/Hauppauge DEC USB"
  
  #define COMMAND_PIPE		0x03
  #define RESULT_PIPE		0x04
  #define IN_PIPE			0x08
  #define OUT_PIPE		0x07
  #define IRQ_PIPE		0x0A
  
  #define COMMAND_PACKET_SIZE	0x3c
  #define ARM_PACKET_SIZE		0x1000
  #define IRQ_PACKET_SIZE		0x8
  
  #define ISO_BUF_COUNT		0x04
  #define FRAMES_PER_ISO_BUF	0x04
  #define ISO_FRAME_SIZE		0x0380
  
  #define	MAX_PVA_LENGTH		6144
  
  enum ttusb_dec_model {
  	TTUSB_DEC2000T,
  	TTUSB_DEC2540T,
  	TTUSB_DEC3000S
  };
  
  enum ttusb_dec_packet_type {
  	TTUSB_DEC_PACKET_PVA,
  	TTUSB_DEC_PACKET_SECTION,
  	TTUSB_DEC_PACKET_EMPTY
  };
  
  enum ttusb_dec_interface {
  	TTUSB_DEC_INTERFACE_INITIAL,
  	TTUSB_DEC_INTERFACE_IN,
  	TTUSB_DEC_INTERFACE_OUT
  };
  
  typedef int (dvb_filter_pes2ts_cb_t) (void *, unsigned char *);
  
  struct dvb_filter_pes2ts {
  	unsigned char buf[188];
  	unsigned char cc;
  	dvb_filter_pes2ts_cb_t *cb;
  	void *priv;
  };
  
  struct ttusb_dec {
  	enum ttusb_dec_model		model;
  	char				*model_name;
  	char				*firmware_name;
  	int				can_playback;
  
  	/* DVB bits */
  	struct dvb_adapter		adapter;
  	struct dmxdev			dmxdev;
  	struct dvb_demux		demux;
  	struct dmx_frontend		frontend;
  	struct dvb_net			dvb_net;
  	struct dvb_frontend*		fe;
  
  	u16			pid[DMX_PES_OTHER];
  
  	/* USB bits */
  	struct usb_device		*udev;
  	u8				trans_count;
  	unsigned int			command_pipe;
  	unsigned int			result_pipe;
  	unsigned int			in_pipe;
  	unsigned int			out_pipe;
  	unsigned int			irq_pipe;
  	enum ttusb_dec_interface	interface;
  	struct mutex			usb_mutex;
  
  	void			*irq_buffer;
  	struct urb		*irq_urb;
  	dma_addr_t		irq_dma_handle;
  	void			*iso_buffer;
  	dma_addr_t		iso_dma_handle;
  	struct urb		*iso_urb[ISO_BUF_COUNT];
  	int			iso_stream_count;
  	struct mutex		iso_mutex;
  
  	u8				packet[MAX_PVA_LENGTH + 4];
  	enum ttusb_dec_packet_type	packet_type;
  	int				packet_state;
  	int				packet_length;
  	int				packet_payload_length;
  	u16				next_packet_id;
  
  	int				pva_stream_count;
  	int				filter_stream_count;
  
  	struct dvb_filter_pes2ts	a_pes2ts;
  	struct dvb_filter_pes2ts	v_pes2ts;
  
  	u8			v_pes[16 + MAX_PVA_LENGTH];
  	int			v_pes_length;
  	int			v_pes_postbytes;
  
  	struct list_head	urb_frame_list;
  	struct tasklet_struct	urb_tasklet;
  	spinlock_t		urb_frame_list_lock;
  
  	struct dvb_demux_filter	*audio_filter;
  	struct dvb_demux_filter	*video_filter;
  	struct list_head	filter_info_list;
  	spinlock_t		filter_info_list_lock;
  
  	struct input_dev	*rc_input_dev;
  	char			rc_phys[64];
  
  	int			active; /* Loaded successfully */
  };
  
  struct urb_frame {
  	u8			data[ISO_FRAME_SIZE];
  	int			length;
  	struct list_head	urb_frame_list;
  };
  
  struct filter_info {
  	u8			stream_id;
  	struct dvb_demux_filter	*filter;
  	struct list_head	filter_info_list;
  };
  
  static u16 rc_keys[] = {
  	KEY_POWER,
  	KEY_MUTE,
  	KEY_1,
  	KEY_2,
  	KEY_3,
  	KEY_4,
  	KEY_5,
  	KEY_6,
  	KEY_7,
  	KEY_8,
  	KEY_9,
  	KEY_0,
  	KEY_CHANNELUP,
  	KEY_VOLUMEDOWN,
  	KEY_OK,
  	KEY_VOLUMEUP,
  	KEY_CHANNELDOWN,
  	KEY_PREVIOUS,
  	KEY_ESC,
  	KEY_RED,
  	KEY_GREEN,
  	KEY_YELLOW,
  	KEY_BLUE,
  	KEY_OPTION,
  	KEY_M,
  	KEY_RADIO
  };
  
  static void dvb_filter_pes2ts_init(struct dvb_filter_pes2ts *p2ts,
  				   unsigned short pid,
  				   dvb_filter_pes2ts_cb_t *cb, void *priv)
  {
  	unsigned char *buf=p2ts->buf;
  
  	buf[0]=0x47;
  	buf[1]=(pid>>8);
  	buf[2]=pid&0xff;
  	p2ts->cc=0;
  	p2ts->cb=cb;
  	p2ts->priv=priv;
  }
  
  static int dvb_filter_pes2ts(struct dvb_filter_pes2ts *p2ts,
  			     unsigned char *pes, int len, int payload_start)
  {
  	unsigned char *buf=p2ts->buf;
  	int ret=0, rest;
  
  	//len=6+((pes[4]<<8)|pes[5]);
  
  	if (payload_start)
  		buf[1]|=0x40;
  	else
  		buf[1]&=~0x40;
  	while (len>=184) {
  		buf[3]=0x10|((p2ts->cc++)&0x0f);
  		memcpy(buf+4, pes, 184);
  		if ((ret=p2ts->cb(p2ts->priv, buf)))
  			return ret;
  		len-=184; pes+=184;
  		buf[1]&=~0x40;
  	}
  	if (!len)
  		return 0;
  	buf[3]=0x30|((p2ts->cc++)&0x0f);
  	rest=183-len;
  	if (rest) {
  		buf[5]=0x00;
  		if (rest-1)
  			memset(buf+6, 0xff, rest-1);
  	}
  	buf[4]=rest;
  	memcpy(buf+5+rest, pes, len);
  	return p2ts->cb(p2ts->priv, buf);
  }
  
  static void ttusb_dec_set_model(struct ttusb_dec *dec,
  				enum ttusb_dec_model model);
  
  static void ttusb_dec_handle_irq( struct urb *urb)
  {
  	struct ttusb_dec *dec = urb->context;
  	char *buffer = dec->irq_buffer;
  	int retval;
  
  	switch(urb->status) {
  		case 0: /*success*/
  			break;
  		case -ECONNRESET:
  		case -ENOENT:
  		case -ESHUTDOWN:
  		case -ETIME:
  			/* this urb is dead, cleanup */
  			dprintk("%s:urb shutting down with status: %d\n",
  					__func__, urb->status);
  			return;
  		default:
  			dprintk("%s:nonzero status received: %d\n",
  					__func__,urb->status);
  			goto exit;
  	}
  
  	if ((buffer[0] == 0x1) && (buffer[2] == 0x15))  {
  		/*
  		 * IR - Event
  		 *
  		 * this is an fact a bit too simple implementation;
  		 * the box also reports a keyrepeat signal
  		 * (with buffer[3] == 0x40) in an intervall of ~100ms.
  		 * But to handle this correctly we had to imlemenent some
  		 * kind of timer which signals a 'key up' event if no
  		 * keyrepeat signal is received for lets say 200ms.
  		 * this should/could be added later ...
  		 * for now lets report each signal as a key down and up
  		 */
  		if (buffer[4] - 1 < ARRAY_SIZE(rc_keys)) {
  			dprintk("%s:rc signal:%d\n", __func__, buffer[4]);
  			input_report_key(dec->rc_input_dev, rc_keys[buffer[4] - 1], 1);
  			input_sync(dec->rc_input_dev);
  			input_report_key(dec->rc_input_dev, rc_keys[buffer[4] - 1], 0);
  			input_sync(dec->rc_input_dev);
  		}
  	}
  
  exit:
  	retval = usb_submit_urb(urb, GFP_ATOMIC);
  	if (retval)
  		printk("%s - usb_commit_urb failed with result: %d\n",
  			__func__, retval);
  }
  
  static u16 crc16(u16 crc, const u8 *buf, size_t len)
  {
  	u16 tmp;
  
  	while (len--) {
  		crc ^= *buf++;
  		crc ^= (u8)crc >> 4;
  		tmp = (u8)crc;
  		crc ^= (tmp ^ (tmp << 1)) << 4;
  	}
  	return crc;
  }
  
  static int ttusb_dec_send_command(struct ttusb_dec *dec, const u8 command,
  				  int param_length, const u8 params[],
  				  int *result_length, u8 cmd_result[])
  {
  	int result, actual_len;
  	u8 *b;
  
  	dprintk("%s\n", __func__);
  
  	b = kmalloc(COMMAND_PACKET_SIZE + 4, GFP_KERNEL);
  	if (!b)
  		return -ENOMEM;
  
  	if ((result = mutex_lock_interruptible(&dec->usb_mutex))) {
  		kfree(b);
  		printk("%s: Failed to lock usb mutex.\n", __func__);
  		return result;
  	}
  
  	b[0] = 0xaa;
  	b[1] = ++dec->trans_count;
  	b[2] = command;
  	b[3] = param_length;
  
  	if (params)
  		memcpy(&b[4], params, param_length);
  
  	if (debug) {
  		printk(KERN_DEBUG "%s: command: %*ph\n",
  		       __func__, param_length, b);
  	}
  
  	result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
  			      COMMAND_PACKET_SIZE + 4, &actual_len, 1000);
  
  	if (result) {
  		printk("%s: command bulk message failed: error %d\n",
  		       __func__, result);
  		mutex_unlock(&dec->usb_mutex);
  		kfree(b);
  		return result;
  	}
  
  	result = usb_bulk_msg(dec->udev, dec->result_pipe, b,
  			      COMMAND_PACKET_SIZE + 4, &actual_len, 1000);
  
  	if (result) {
  		printk("%s: result bulk message failed: error %d\n",
  		       __func__, result);
  		mutex_unlock(&dec->usb_mutex);
  		kfree(b);
  		return result;
  	} else {
  		if (debug) {
  			printk(KERN_DEBUG "%s: result: %*ph\n",
  			       __func__, actual_len, b);
  		}
  
  		if (result_length)
  			*result_length = b[3];
  		if (cmd_result && b[3] > 0)
  			memcpy(cmd_result, &b[4], b[3]);
  
  		mutex_unlock(&dec->usb_mutex);
  
  		kfree(b);
  		return 0;
  	}
  }
  
  static int ttusb_dec_get_stb_state (struct ttusb_dec *dec, unsigned int *mode,
  				    unsigned int *model, unsigned int *version)
  {
  	u8 c[COMMAND_PACKET_SIZE];
  	int c_length;
  	int result;
  	__be32 tmp;
  
  	dprintk("%s\n", __func__);
  
  	result = ttusb_dec_send_command(dec, 0x08, 0, NULL, &c_length, c);
  	if (result)
  		return result;
  
  	if (c_length >= 0x0c) {
  		if (mode != NULL) {
  			memcpy(&tmp, c, 4);
  			*mode = ntohl(tmp);
  		}
  		if (model != NULL) {
  			memcpy(&tmp, &c[4], 4);
  			*model = ntohl(tmp);
  		}
  		if (version != NULL) {
  			memcpy(&tmp, &c[8], 4);
  			*version = ntohl(tmp);
  		}
  		return 0;
  	} else {
  		return -ENOENT;
  	}
  }
  
  static int ttusb_dec_audio_pes2ts_cb(void *priv, unsigned char *data)
  {
  	struct ttusb_dec *dec = priv;
  
  	dec->audio_filter->feed->cb.ts(data, 188, NULL, 0,
  				       &dec->audio_filter->feed->feed.ts);
  
  	return 0;
  }
  
  static int ttusb_dec_video_pes2ts_cb(void *priv, unsigned char *data)
  {
  	struct ttusb_dec *dec = priv;
  
  	dec->video_filter->feed->cb.ts(data, 188, NULL, 0,
  				       &dec->video_filter->feed->feed.ts);
  
  	return 0;
  }
  
  static void ttusb_dec_set_pids(struct ttusb_dec *dec)
  {
  	u8 b[] = { 0x00, 0x00, 0x00, 0x00,
  		   0x00, 0x00, 0xff, 0xff,
  		   0xff, 0xff, 0xff, 0xff };
  
  	__be16 pcr = htons(dec->pid[DMX_PES_PCR]);
  	__be16 audio = htons(dec->pid[DMX_PES_AUDIO]);
  	__be16 video = htons(dec->pid[DMX_PES_VIDEO]);
  
  	dprintk("%s\n", __func__);
  
  	memcpy(&b[0], &pcr, 2);
  	memcpy(&b[2], &audio, 2);
  	memcpy(&b[4], &video, 2);
  
  	ttusb_dec_send_command(dec, 0x50, sizeof(b), b, NULL, NULL);
  
  	dvb_filter_pes2ts_init(&dec->a_pes2ts, dec->pid[DMX_PES_AUDIO],
  			       ttusb_dec_audio_pes2ts_cb, dec);
  	dvb_filter_pes2ts_init(&dec->v_pes2ts, dec->pid[DMX_PES_VIDEO],
  			       ttusb_dec_video_pes2ts_cb, dec);
  	dec->v_pes_length = 0;
  	dec->v_pes_postbytes = 0;
  }
  
  static void ttusb_dec_process_pva(struct ttusb_dec *dec, u8 *pva, int length)
  {
  	if (length < 8) {
  		printk("%s: packet too short - discarding\n", __func__);
  		return;
  	}
  
  	if (length > 8 + MAX_PVA_LENGTH) {
  		printk("%s: packet too long - discarding\n", __func__);
  		return;
  	}
  
  	switch (pva[2]) {
  
  	case 0x01: {		/* VideoStream */
  		int prebytes = pva[5] & 0x03;
  		int postbytes = (pva[5] & 0x0c) >> 2;
  		__be16 v_pes_payload_length;
  
  		if (output_pva) {
  			dec->video_filter->feed->cb.ts(pva, length, NULL, 0,
  				&dec->video_filter->feed->feed.ts);
  			return;
  		}
  
  		if (dec->v_pes_postbytes > 0 &&
  		    dec->v_pes_postbytes == prebytes) {
  			memcpy(&dec->v_pes[dec->v_pes_length],
  			       &pva[12], prebytes);
  
  			dvb_filter_pes2ts(&dec->v_pes2ts, dec->v_pes,
  					  dec->v_pes_length + prebytes, 1);
  		}
  
  		if (pva[5] & 0x10) {
  			dec->v_pes[7] = 0x80;
  			dec->v_pes[8] = 0x05;
  
  			dec->v_pes[9] = 0x21 | ((pva[8] & 0xc0) >> 5);
  			dec->v_pes[10] = ((pva[8] & 0x3f) << 2) |
  					 ((pva[9] & 0xc0) >> 6);
  			dec->v_pes[11] = 0x01 |
  					 ((pva[9] & 0x3f) << 2) |
  					 ((pva[10] & 0x80) >> 6);
  			dec->v_pes[12] = ((pva[10] & 0x7f) << 1) |
  					 ((pva[11] & 0xc0) >> 7);
  			dec->v_pes[13] = 0x01 | ((pva[11] & 0x7f) << 1);
  
  			memcpy(&dec->v_pes[14], &pva[12 + prebytes],
  			       length - 12 - prebytes);
  			dec->v_pes_length = 14 + length - 12 - prebytes;
  		} else {
  			dec->v_pes[7] = 0x00;
  			dec->v_pes[8] = 0x00;
  
  			memcpy(&dec->v_pes[9], &pva[8], length - 8);
  			dec->v_pes_length = 9 + length - 8;
  		}
  
  		dec->v_pes_postbytes = postbytes;
  
  		if (dec->v_pes[9 + dec->v_pes[8]] == 0x00 &&
  		    dec->v_pes[10 + dec->v_pes[8]] == 0x00 &&
  		    dec->v_pes[11 + dec->v_pes[8]] == 0x01)
  			dec->v_pes[6] = 0x84;
  		else
  			dec->v_pes[6] = 0x80;
  
  		v_pes_payload_length = htons(dec->v_pes_length - 6 +
  					     postbytes);
  		memcpy(&dec->v_pes[4], &v_pes_payload_length, 2);
  
  		if (postbytes == 0)
  			dvb_filter_pes2ts(&dec->v_pes2ts, dec->v_pes,
  					  dec->v_pes_length, 1);
  
  		break;
  	}
  
  	case 0x02:		/* MainAudioStream */
  		if (output_pva) {
  			dec->audio_filter->feed->cb.ts(pva, length, NULL, 0,
  				&dec->audio_filter->feed->feed.ts);
  			return;
  		}
  
  		dvb_filter_pes2ts(&dec->a_pes2ts, &pva[8], length - 8,
  				  pva[5] & 0x10);
  		break;
  
  	default:
  		printk("%s: unknown PVA type: %02x.\n", __func__,
  		       pva[2]);
  		break;
  	}
  }
  
  static void ttusb_dec_process_filter(struct ttusb_dec *dec, u8 *packet,
  				     int length)
  {
  	struct list_head *item;
  	struct filter_info *finfo;
  	struct dvb_demux_filter *filter = NULL;
  	unsigned long flags;
  	u8 sid;
  
  	sid = packet[1];
  	spin_lock_irqsave(&dec->filter_info_list_lock, flags);
  	for (item = dec->filter_info_list.next; item != &dec->filter_info_list;
  	     item = item->next) {
  		finfo = list_entry(item, struct filter_info, filter_info_list);
  		if (finfo->stream_id == sid) {
  			filter = finfo->filter;
  			break;
  		}
  	}
  	spin_unlock_irqrestore(&dec->filter_info_list_lock, flags);
  
  	if (filter)
  		filter->feed->cb.sec(&packet[2], length - 2, NULL, 0,
  				     &filter->filter);
  }
  
  static void ttusb_dec_process_packet(struct ttusb_dec *dec)
  {
  	int i;
  	u16 csum = 0;
  	u16 packet_id;
  
  	if (dec->packet_length % 2) {
  		printk("%s: odd sized packet - discarding\n", __func__);
  		return;
  	}
  
  	for (i = 0; i < dec->packet_length; i += 2)
  		csum ^= ((dec->packet[i] << 8) + dec->packet[i + 1]);
  
  	if (csum) {
  		printk("%s: checksum failed - discarding\n", __func__);
  		return;
  	}
  
  	packet_id = dec->packet[dec->packet_length - 4] << 8;
  	packet_id += dec->packet[dec->packet_length - 3];
  
  	if ((packet_id != dec->next_packet_id) && dec->next_packet_id) {
  		printk("%s: warning: lost packets between %u and %u\n",
  		       __func__, dec->next_packet_id - 1, packet_id);
  	}
  
  	if (packet_id == 0xffff)
  		dec->next_packet_id = 0x8000;
  	else
  		dec->next_packet_id = packet_id + 1;
  
  	switch (dec->packet_type) {
  	case TTUSB_DEC_PACKET_PVA:
  		if (dec->pva_stream_count)
  			ttusb_dec_process_pva(dec, dec->packet,
  					      dec->packet_payload_length);
  		break;
  
  	case TTUSB_DEC_PACKET_SECTION:
  		if (dec->filter_stream_count)
  			ttusb_dec_process_filter(dec, dec->packet,
  						 dec->packet_payload_length);
  		break;
  
  	case TTUSB_DEC_PACKET_EMPTY:
  		break;
  	}
  }
  
  static void swap_bytes(u8 *b, int length)
  {
  	length -= length % 2;
  	for (; length; b += 2, length -= 2)
  		swap(*b, *(b + 1));
  }
  
  static void ttusb_dec_process_urb_frame(struct ttusb_dec *dec, u8 *b,
  					int length)
  {
  	swap_bytes(b, length);
  
  	while (length) {
  		switch (dec->packet_state) {
  
  		case 0:
  		case 1:
  		case 2:
  			if (*b++ == 0xaa)
  				dec->packet_state++;
  			else
  				dec->packet_state = 0;
  
  			length--;
  			break;
  
  		case 3:
  			if (*b == 0x00) {
  				dec->packet_state++;
  				dec->packet_length = 0;
  			} else if (*b != 0xaa) {
  				dec->packet_state = 0;
  			}
  
  			b++;
  			length--;
  			break;
  
  		case 4:
  			dec->packet[dec->packet_length++] = *b++;
  
  			if (dec->packet_length == 2) {
  				if (dec->packet[0] == 'A' &&
  				    dec->packet[1] == 'V') {
  					dec->packet_type =
  						TTUSB_DEC_PACKET_PVA;
  					dec->packet_state++;
  				} else if (dec->packet[0] == 'S') {
  					dec->packet_type =
  						TTUSB_DEC_PACKET_SECTION;
  					dec->packet_state++;
  				} else if (dec->packet[0] == 0x00) {
  					dec->packet_type =
  						TTUSB_DEC_PACKET_EMPTY;
  					dec->packet_payload_length = 2;
  					dec->packet_state = 7;
  				} else {
  					printk("%s: unknown packet type: %02x%02x\n",
  					       __func__,
  					       dec->packet[0], dec->packet[1]);
  					dec->packet_state = 0;
  				}
  			}
  
  			length--;
  			break;
  
  		case 5:
  			dec->packet[dec->packet_length++] = *b++;
  
  			if (dec->packet_type == TTUSB_DEC_PACKET_PVA &&
  			    dec->packet_length == 8) {
  				dec->packet_state++;
  				dec->packet_payload_length = 8 +
  					(dec->packet[6] << 8) +
  					dec->packet[7];
  			} else if (dec->packet_type ==
  					TTUSB_DEC_PACKET_SECTION &&
  				   dec->packet_length == 5) {
  				dec->packet_state++;
  				dec->packet_payload_length = 5 +
  					((dec->packet[3] & 0x0f) << 8) +
  					dec->packet[4];
  			}
  
  			length--;
  			break;
  
  		case 6: {
  			int remainder = dec->packet_payload_length -
  					dec->packet_length;
  
  			if (length >= remainder) {
  				memcpy(dec->packet + dec->packet_length,
  				       b, remainder);
  				dec->packet_length += remainder;
  				b += remainder;
  				length -= remainder;
  				dec->packet_state++;
  			} else {
  				memcpy(&dec->packet[dec->packet_length],
  				       b, length);
  				dec->packet_length += length;
  				length = 0;
  			}
  
  			break;
  		}
  
  		case 7: {
  			int tail = 4;
  
  			dec->packet[dec->packet_length++] = *b++;
  
  			if (dec->packet_type == TTUSB_DEC_PACKET_SECTION &&
  			    dec->packet_payload_length % 2)
  				tail++;
  
  			if (dec->packet_length ==
  			    dec->packet_payload_length + tail) {
  				ttusb_dec_process_packet(dec);
  				dec->packet_state = 0;
  			}
  
  			length--;
  			break;
  		}
  
  		default:
  			printk("%s: illegal packet state encountered.\n",
  			       __func__);
  			dec->packet_state = 0;
  		}
  	}
  }
  
  static void ttusb_dec_process_urb_frame_list(unsigned long data)
  {
  	struct ttusb_dec *dec = (struct ttusb_dec *)data;
  	struct list_head *item;
  	struct urb_frame *frame;
  	unsigned long flags;
  
  	while (1) {
  		spin_lock_irqsave(&dec->urb_frame_list_lock, flags);
  		if ((item = dec->urb_frame_list.next) != &dec->urb_frame_list) {
  			frame = list_entry(item, struct urb_frame,
  					   urb_frame_list);
  			list_del(&frame->urb_frame_list);
  		} else {
  			spin_unlock_irqrestore(&dec->urb_frame_list_lock,
  					       flags);
  			return;
  		}
  		spin_unlock_irqrestore(&dec->urb_frame_list_lock, flags);
  
  		ttusb_dec_process_urb_frame(dec, frame->data, frame->length);
  		kfree(frame);
  	}
  }
  
  static void ttusb_dec_process_urb(struct urb *urb)
  {
  	struct ttusb_dec *dec = urb->context;
  
  	if (!urb->status) {
  		int i;
  
  		for (i = 0; i < FRAMES_PER_ISO_BUF; i++) {
  			struct usb_iso_packet_descriptor *d;
  			u8 *b;
  			int length;
  			struct urb_frame *frame;
  
  			d = &urb->iso_frame_desc[i];
  			b = urb->transfer_buffer + d->offset;
  			length = d->actual_length;
  
  			if ((frame = kmalloc(sizeof(struct urb_frame),
  					     GFP_ATOMIC))) {
  				unsigned long flags;
  
  				memcpy(frame->data, b, length);
  				frame->length = length;
  
  				spin_lock_irqsave(&dec->urb_frame_list_lock,
  						     flags);
  				list_add_tail(&frame->urb_frame_list,
  					      &dec->urb_frame_list);
  				spin_unlock_irqrestore(&dec->urb_frame_list_lock,
  						       flags);
  
  				tasklet_schedule(&dec->urb_tasklet);
  			}
  		}
  	} else {
  		 /* -ENOENT is expected when unlinking urbs */
  		if (urb->status != -ENOENT)
  			dprintk("%s: urb error: %d\n", __func__,
  				urb->status);
  	}
  
  	if (dec->iso_stream_count)
  		usb_submit_urb(urb, GFP_ATOMIC);
  }
  
  static void ttusb_dec_setup_urbs(struct ttusb_dec *dec)
  {
  	int i, j, buffer_offset = 0;
  
  	dprintk("%s\n", __func__);
  
  	for (i = 0; i < ISO_BUF_COUNT; i++) {
  		int frame_offset = 0;
  		struct urb *urb = dec->iso_urb[i];
  
  		urb->dev = dec->udev;
  		urb->context = dec;
  		urb->complete = ttusb_dec_process_urb;
  		urb->pipe = dec->in_pipe;
  		urb->transfer_flags = URB_ISO_ASAP;
  		urb->interval = 1;
  		urb->number_of_packets = FRAMES_PER_ISO_BUF;
  		urb->transfer_buffer_length = ISO_FRAME_SIZE *
  					      FRAMES_PER_ISO_BUF;
  		urb->transfer_buffer = dec->iso_buffer + buffer_offset;
  		buffer_offset += ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF;
  
  		for (j = 0; j < FRAMES_PER_ISO_BUF; j++) {
  			urb->iso_frame_desc[j].offset = frame_offset;
  			urb->iso_frame_desc[j].length = ISO_FRAME_SIZE;
  			frame_offset += ISO_FRAME_SIZE;
  		}
  	}
  }
  
  static void ttusb_dec_stop_iso_xfer(struct ttusb_dec *dec)
  {
  	int i;
  
  	dprintk("%s\n", __func__);
  
  	if (mutex_lock_interruptible(&dec->iso_mutex))
  		return;
  
  	dec->iso_stream_count--;
  
  	if (!dec->iso_stream_count) {
  		for (i = 0; i < ISO_BUF_COUNT; i++)
  			usb_kill_urb(dec->iso_urb[i]);
  	}
  
  	mutex_unlock(&dec->iso_mutex);
  }
  
  /* Setting the interface of the DEC tends to take down the USB communications
   * for a short period, so it's important not to call this function just before
   * trying to talk to it.
   */
  static int ttusb_dec_set_interface(struct ttusb_dec *dec,
  				   enum ttusb_dec_interface interface)
  {
  	int result = 0;
  	u8 b[] = { 0x05 };
  
  	if (interface != dec->interface) {
  		switch (interface) {
  		case TTUSB_DEC_INTERFACE_INITIAL:
  			result = usb_set_interface(dec->udev, 0, 0);
  			break;
  		case TTUSB_DEC_INTERFACE_IN:
  			result = ttusb_dec_send_command(dec, 0x80, sizeof(b),
  							b, NULL, NULL);
  			if (result)
  				return result;
  			result = usb_set_interface(dec->udev, 0, 8);
  			break;
  		case TTUSB_DEC_INTERFACE_OUT:
  			result = usb_set_interface(dec->udev, 0, 1);
  			break;
  		}
  
  		if (result)
  			return result;
  
  		dec->interface = interface;
  	}
  
  	return 0;
  }
  
  static int ttusb_dec_start_iso_xfer(struct ttusb_dec *dec)
  {
  	int i, result;
  
  	dprintk("%s\n", __func__);
  
  	if (mutex_lock_interruptible(&dec->iso_mutex))
  		return -EAGAIN;
  
  	if (!dec->iso_stream_count) {
  		ttusb_dec_setup_urbs(dec);
  
  		dec->packet_state = 0;
  		dec->v_pes_postbytes = 0;
  		dec->next_packet_id = 0;
  
  		for (i = 0; i < ISO_BUF_COUNT; i++) {
  			if ((result = usb_submit_urb(dec->iso_urb[i],
  						     GFP_ATOMIC))) {
  				printk("%s: failed urb submission %d: error %d\n",
  				       __func__, i, result);
  
  				while (i) {
  					usb_kill_urb(dec->iso_urb[i - 1]);
  					i--;
  				}
  
  				mutex_unlock(&dec->iso_mutex);
  				return result;
  			}
  		}
  	}
  
  	dec->iso_stream_count++;
  
  	mutex_unlock(&dec->iso_mutex);
  
  	return 0;
  }
  
  static int ttusb_dec_start_ts_feed(struct dvb_demux_feed *dvbdmxfeed)
  {
  	struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
  	struct ttusb_dec *dec = dvbdmx->priv;
  	u8 b0[] = { 0x05 };
  	int result = 0;
  
  	dprintk("%s\n", __func__);
  
  	dprintk("  ts_type:");
  
  	if (dvbdmxfeed->ts_type & TS_DECODER)
  		dprintk(" TS_DECODER");
  
  	if (dvbdmxfeed->ts_type & TS_PACKET)
  		dprintk(" TS_PACKET");
  
  	if (dvbdmxfeed->ts_type & TS_PAYLOAD_ONLY)
  		dprintk(" TS_PAYLOAD_ONLY");
  
  	dprintk("\n");
  
  	switch (dvbdmxfeed->pes_type) {
  
  	case DMX_PES_VIDEO:
  		dprintk("  pes_type: DMX_PES_VIDEO\n");
  		dec->pid[DMX_PES_PCR] = dvbdmxfeed->pid;
  		dec->pid[DMX_PES_VIDEO] = dvbdmxfeed->pid;
  		dec->video_filter = dvbdmxfeed->filter;
  		ttusb_dec_set_pids(dec);
  		break;
  
  	case DMX_PES_AUDIO:
  		dprintk("  pes_type: DMX_PES_AUDIO\n");
  		dec->pid[DMX_PES_AUDIO] = dvbdmxfeed->pid;
  		dec->audio_filter = dvbdmxfeed->filter;
  		ttusb_dec_set_pids(dec);
  		break;
  
  	case DMX_PES_TELETEXT:
  		dec->pid[DMX_PES_TELETEXT] = dvbdmxfeed->pid;
  		dprintk("  pes_type: DMX_PES_TELETEXT(not supported)\n");
  		return -ENOSYS;
  
  	case DMX_PES_PCR:
  		dprintk("  pes_type: DMX_PES_PCR\n");
  		dec->pid[DMX_PES_PCR] = dvbdmxfeed->pid;
  		ttusb_dec_set_pids(dec);
  		break;
  
  	case DMX_PES_OTHER:
  		dprintk("  pes_type: DMX_PES_OTHER(not supported)\n");
  		return -ENOSYS;
  
  	default:
  		dprintk("  pes_type: unknown (%d)\n", dvbdmxfeed->pes_type);
  		return -EINVAL;
  
  	}
  
  	result = ttusb_dec_send_command(dec, 0x80, sizeof(b0), b0, NULL, NULL);
  	if (result)
  		return result;
  
  	dec->pva_stream_count++;
  	return ttusb_dec_start_iso_xfer(dec);
  }
  
  static int ttusb_dec_start_sec_feed(struct dvb_demux_feed *dvbdmxfeed)
  {
  	struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
  	u8 b0[] = { 0x00, 0x00, 0x00, 0x01,
  		    0x00, 0x00, 0x00, 0x00,
  		    0x00, 0x00, 0x00, 0x00,
  		    0x00, 0x00, 0x00, 0x00,
  		    0x00, 0xff, 0x00, 0x00,
  		    0x00, 0x00, 0x00, 0x00,
  		    0x00, 0x00, 0x00, 0x00,
  		    0x00 };
  	__be16 pid;
  	u8 c[COMMAND_PACKET_SIZE];
  	int c_length;
  	int result;
  	struct filter_info *finfo;
  	unsigned long flags;
  	u8 x = 1;
  
  	dprintk("%s\n", __func__);
  
  	pid = htons(dvbdmxfeed->pid);
  	memcpy(&b0[0], &pid, 2);
  	memcpy(&b0[4], &x, 1);
  	memcpy(&b0[5], &dvbdmxfeed->filter->filter.filter_value[0], 1);
  
  	result = ttusb_dec_send_command(dec, 0x60, sizeof(b0), b0,
  					&c_length, c);
  
  	if (!result) {
  		if (c_length == 2) {
  			if (!(finfo = kmalloc(sizeof(struct filter_info),
  					      GFP_ATOMIC)))
  				return -ENOMEM;
  
  			finfo->stream_id = c[1];
  			finfo->filter = dvbdmxfeed->filter;
  
  			spin_lock_irqsave(&dec->filter_info_list_lock, flags);
  			list_add_tail(&finfo->filter_info_list,
  				      &dec->filter_info_list);
  			spin_unlock_irqrestore(&dec->filter_info_list_lock,
  					       flags);
  
  			dvbdmxfeed->priv = finfo;
  
  			dec->filter_stream_count++;
  			return ttusb_dec_start_iso_xfer(dec);
  		}
  
  		return -EAGAIN;
  	} else
  		return result;
  }
  
  static int ttusb_dec_start_feed(struct dvb_demux_feed *dvbdmxfeed)
  {
  	struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
  
  	dprintk("%s\n", __func__);
  
  	if (!dvbdmx->dmx.frontend)
  		return -EINVAL;
  
  	dprintk("  pid: 0x%04X\n", dvbdmxfeed->pid);
  
  	switch (dvbdmxfeed->type) {
  
  	case DMX_TYPE_TS:
  		return ttusb_dec_start_ts_feed(dvbdmxfeed);
  		break;
  
  	case DMX_TYPE_SEC:
  		return ttusb_dec_start_sec_feed(dvbdmxfeed);
  		break;
  
  	default:
  		dprintk("  type: unknown (%d)\n", dvbdmxfeed->type);
  		return -EINVAL;
  
  	}
  }
  
  static int ttusb_dec_stop_ts_feed(struct dvb_demux_feed *dvbdmxfeed)
  {
  	struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
  	u8 b0[] = { 0x00 };
  
  	ttusb_dec_send_command(dec, 0x81, sizeof(b0), b0, NULL, NULL);
  
  	dec->pva_stream_count--;
  
  	ttusb_dec_stop_iso_xfer(dec);
  
  	return 0;
  }
  
  static int ttusb_dec_stop_sec_feed(struct dvb_demux_feed *dvbdmxfeed)
  {
  	struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
  	u8 b0[] = { 0x00, 0x00 };
  	struct filter_info *finfo = (struct filter_info *)dvbdmxfeed->priv;
  	unsigned long flags;
  
  	b0[1] = finfo->stream_id;
  	spin_lock_irqsave(&dec->filter_info_list_lock, flags);
  	list_del(&finfo->filter_info_list);
  	spin_unlock_irqrestore(&dec->filter_info_list_lock, flags);
  	kfree(finfo);
  	ttusb_dec_send_command(dec, 0x62, sizeof(b0), b0, NULL, NULL);
  
  	dec->filter_stream_count--;
  
  	ttusb_dec_stop_iso_xfer(dec);
  
  	return 0;
  }
  
  static int ttusb_dec_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
  {
  	dprintk("%s\n", __func__);
  
  	switch (dvbdmxfeed->type) {
  	case DMX_TYPE_TS:
  		return ttusb_dec_stop_ts_feed(dvbdmxfeed);
  		break;
  
  	case DMX_TYPE_SEC:
  		return ttusb_dec_stop_sec_feed(dvbdmxfeed);
  		break;
  	}
  
  	return 0;
  }
  
  static void ttusb_dec_free_iso_urbs(struct ttusb_dec *dec)
  {
  	int i;
  
  	dprintk("%s\n", __func__);
  
  	for (i = 0; i < ISO_BUF_COUNT; i++)
  		usb_free_urb(dec->iso_urb[i]);
  
  	pci_free_consistent(NULL,
  			    ISO_FRAME_SIZE * (FRAMES_PER_ISO_BUF *
  					      ISO_BUF_COUNT),
  			    dec->iso_buffer, dec->iso_dma_handle);
  }
  
  static int ttusb_dec_alloc_iso_urbs(struct ttusb_dec *dec)
  {
  	int i;
  
  	dprintk("%s\n", __func__);
  
  	dec->iso_buffer = pci_zalloc_consistent(NULL,
  						ISO_FRAME_SIZE * (FRAMES_PER_ISO_BUF * ISO_BUF_COUNT),
  						&dec->iso_dma_handle);
  
  	if (!dec->iso_buffer) {
  		dprintk("%s: pci_alloc_consistent - not enough memory\n",
  			__func__);
  		return -ENOMEM;
  	}
  
  	for (i = 0; i < ISO_BUF_COUNT; i++) {
  		struct urb *urb;
  
  		if (!(urb = usb_alloc_urb(FRAMES_PER_ISO_BUF, GFP_ATOMIC))) {
  			ttusb_dec_free_iso_urbs(dec);
  			return -ENOMEM;
  		}
  
  		dec->iso_urb[i] = urb;
  	}
  
  	ttusb_dec_setup_urbs(dec);
  
  	return 0;
  }
  
  static void ttusb_dec_init_tasklet(struct ttusb_dec *dec)
  {
  	spin_lock_init(&dec->urb_frame_list_lock);
  	INIT_LIST_HEAD(&dec->urb_frame_list);
  	tasklet_init(&dec->urb_tasklet, ttusb_dec_process_urb_frame_list,
  		     (unsigned long)dec);
  }
  
  static int ttusb_init_rc( struct ttusb_dec *dec)
  {
  	struct input_dev *input_dev;
  	u8 b[] = { 0x00, 0x01 };
  	int i;
  	int err;
  
  	usb_make_path(dec->udev, dec->rc_phys, sizeof(dec->rc_phys));
  	strlcat(dec->rc_phys, "/input0", sizeof(dec->rc_phys));
  
  	input_dev = input_allocate_device();
  	if (!input_dev)
  		return -ENOMEM;
  
  	input_dev->name = "ttusb_dec remote control";
  	input_dev->phys = dec->rc_phys;
  	input_dev->evbit[0] = BIT_MASK(EV_KEY);
  	input_dev->keycodesize = sizeof(u16);
  	input_dev->keycodemax = 0x1a;
  	input_dev->keycode = rc_keys;
  
  	for (i = 0; i < ARRAY_SIZE(rc_keys); i++)
  		  set_bit(rc_keys[i], input_dev->keybit);
  
  	err = input_register_device(input_dev);
  	if (err) {
  		input_free_device(input_dev);
  		return err;
  	}
  
  	dec->rc_input_dev = input_dev;
  	if (usb_submit_urb(dec->irq_urb, GFP_KERNEL))
  		printk("%s: usb_submit_urb failed\n",__func__);
  	/* enable irq pipe */
  	ttusb_dec_send_command(dec,0xb0,sizeof(b),b,NULL,NULL);
  
  	return 0;
  }
  
  static void ttusb_dec_init_v_pes(struct ttusb_dec *dec)
  {
  	dprintk("%s\n", __func__);
  
  	dec->v_pes[0] = 0x00;
  	dec->v_pes[1] = 0x00;
  	dec->v_pes[2] = 0x01;
  	dec->v_pes[3] = 0xe0;
  }
  
  static int ttusb_dec_init_usb(struct ttusb_dec *dec)
  {
  	int result;
  
  	dprintk("%s\n", __func__);
  
  	mutex_init(&dec->usb_mutex);
  	mutex_init(&dec->iso_mutex);
  
  	dec->command_pipe = usb_sndbulkpipe(dec->udev, COMMAND_PIPE);
  	dec->result_pipe = usb_rcvbulkpipe(dec->udev, RESULT_PIPE);
  	dec->in_pipe = usb_rcvisocpipe(dec->udev, IN_PIPE);
  	dec->out_pipe = usb_sndisocpipe(dec->udev, OUT_PIPE);
  	dec->irq_pipe = usb_rcvintpipe(dec->udev, IRQ_PIPE);
  
  	if(enable_rc) {
  		dec->irq_urb = usb_alloc_urb(0, GFP_KERNEL);
  		if(!dec->irq_urb) {
  			return -ENOMEM;
  		}
  		dec->irq_buffer = usb_alloc_coherent(dec->udev,IRQ_PACKET_SIZE,
  					GFP_KERNEL, &dec->irq_dma_handle);
  		if(!dec->irq_buffer) {
  			usb_free_urb(dec->irq_urb);
  			return -ENOMEM;
  		}
  		usb_fill_int_urb(dec->irq_urb, dec->udev,dec->irq_pipe,
  				 dec->irq_buffer, IRQ_PACKET_SIZE,
  				 ttusb_dec_handle_irq, dec, 1);
  		dec->irq_urb->transfer_dma = dec->irq_dma_handle;
  		dec->irq_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
  	}
  
  	result = ttusb_dec_alloc_iso_urbs(dec);
  	if (result) {
  		usb_free_urb(dec->irq_urb);
  		usb_free_coherent(dec->udev, IRQ_PACKET_SIZE,
  				  dec->irq_buffer, dec->irq_dma_handle);
  	}
  	return result;
  }
  
  static int ttusb_dec_boot_dsp(struct ttusb_dec *dec)
  {
  	int i, j, actual_len, result, size, trans_count;
  	u8 b0[] = { 0x00, 0x00, 0x00, 0x00,
  		    0x00, 0x00, 0x00, 0x00,
  		    0x61, 0x00 };
  	u8 b1[] = { 0x61 };
  	u8 *b;
  	char idstring[21];
  	const u8 *firmware = NULL;
  	size_t firmware_size = 0;
  	u16 firmware_csum = 0;
  	__be16 firmware_csum_ns;
  	__be32 firmware_size_nl;
  	u32 crc32_csum, crc32_check;
  	__be32 tmp;
  	const struct firmware *fw_entry = NULL;
  
  	dprintk("%s\n", __func__);
  
  	result = request_firmware(&fw_entry, dec->firmware_name, &dec->udev->dev);
  	if (result) {
  		printk(KERN_ERR "%s: Firmware (%s) unavailable.\n",
  		       __func__, dec->firmware_name);
  		return result;
  	}
  
  	firmware = fw_entry->data;
  	firmware_size = fw_entry->size;
  
  	if (firmware_size < 60) {
  		printk("%s: firmware size too small for DSP code (%zu < 60).\n",
  			__func__, firmware_size);
  		release_firmware(fw_entry);
  		return -ENOENT;
  	}
  
  	/* a 32 bit checksum over the first 56 bytes of the DSP Code is stored
  	   at offset 56 of file, so use it to check if the firmware file is
  	   valid. */
  	crc32_csum = crc32(~0L, firmware, 56) ^ ~0L;
  	memcpy(&tmp, &firmware[56], 4);
  	crc32_check = ntohl(tmp);
  	if (crc32_csum != crc32_check) {
  		printk("%s: crc32 check of DSP code failed (calculated 0x%08x != 0x%08x in file), file invalid.\n",
  			__func__, crc32_csum, crc32_check);
  		release_firmware(fw_entry);
  		return -ENOENT;
  	}
  	memcpy(idstring, &firmware[36], 20);
  	idstring[20] = '\0';
  	printk(KERN_INFO "ttusb_dec: found DSP code \"%s\".\n", idstring);
  
  	firmware_size_nl = htonl(firmware_size);
  	memcpy(b0, &firmware_size_nl, 4);
  	firmware_csum = crc16(~0, firmware, firmware_size) ^ ~0;
  	firmware_csum_ns = htons(firmware_csum);
  	memcpy(&b0[6], &firmware_csum_ns, 2);
  
  	result = ttusb_dec_send_command(dec, 0x41, sizeof(b0), b0, NULL, NULL);
  
  	if (result) {
  		release_firmware(fw_entry);
  		return result;
  	}
  
  	trans_count = 0;
  	j = 0;
  
  	b = kmalloc(ARM_PACKET_SIZE, GFP_KERNEL);
  	if (b == NULL) {
  		release_firmware(fw_entry);
  		return -ENOMEM;
  	}
  
  	for (i = 0; i < firmware_size; i += COMMAND_PACKET_SIZE) {
  		size = firmware_size - i;
  		if (size > COMMAND_PACKET_SIZE)
  			size = COMMAND_PACKET_SIZE;
  
  		b[j + 0] = 0xaa;
  		b[j + 1] = trans_count++;
  		b[j + 2] = 0xf0;
  		b[j + 3] = size;
  		memcpy(&b[j + 4], &firmware[i], size);
  
  		j += COMMAND_PACKET_SIZE + 4;
  
  		if (j >= ARM_PACKET_SIZE) {
  			result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
  					      ARM_PACKET_SIZE, &actual_len,
  					      100);
  			j = 0;
  		} else if (size < COMMAND_PACKET_SIZE) {
  			result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
  					      j - COMMAND_PACKET_SIZE + size,
  					      &actual_len, 100);
  		}
  	}
  
  	result = ttusb_dec_send_command(dec, 0x43, sizeof(b1), b1, NULL, NULL);
  
  	release_firmware(fw_entry);
  	kfree(b);
  
  	return result;
  }
  
  static int ttusb_dec_init_stb(struct ttusb_dec *dec)
  {
  	int result;
  	unsigned int mode = 0, model = 0, version = 0;
  
  	dprintk("%s\n", __func__);
  
  	result = ttusb_dec_get_stb_state(dec, &mode, &model, &version);
  	if (result)
  		return result;
  
  	if (!mode) {
  		if (version == 0xABCDEFAB)
  			printk(KERN_INFO "ttusb_dec: no version info in Firmware\n");
  		else
  			printk(KERN_INFO "ttusb_dec: Firmware %x.%02x%c%c\n",
  			       version >> 24, (version >> 16) & 0xff,
  			       (version >> 8) & 0xff, version & 0xff);
  
  		result = ttusb_dec_boot_dsp(dec);
  		if (result)
  			return result;
  	} else {
  		/* We can't trust the USB IDs that some firmwares
  		   give the box */
  		switch (model) {
  		case 0x00070001:
  		case 0x00070008:
  		case 0x0007000c:
  			ttusb_dec_set_model(dec, TTUSB_DEC3000S);
  			break;
  		case 0x00070009:
  		case 0x00070013:
  			ttusb_dec_set_model(dec, TTUSB_DEC2000T);
  			break;
  		case 0x00070011:
  			ttusb_dec_set_model(dec, TTUSB_DEC2540T);
  			break;
  		default:
  			printk(KERN_ERR "%s: unknown model returned by firmware (%08x) - please report\n",
  			       __func__, model);
  			return -ENOENT;
  		}
  		if (version >= 0x01770000)
  			dec->can_playback = 1;
  	}
  	return 0;
  }
  
  static int ttusb_dec_init_dvb(struct ttusb_dec *dec)
  {
  	int result;
  
  	dprintk("%s\n", __func__);
  
  	if ((result = dvb_register_adapter(&dec->adapter,
  					   dec->model_name, THIS_MODULE,
  					   &dec->udev->dev,
  					   adapter_nr)) < 0) {
  		printk("%s: dvb_register_adapter failed: error %d\n",
  		       __func__, result);
  
  		return result;
  	}
  
  	dec->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING;
  
  	dec->demux.priv = (void *)dec;
  	dec->demux.filternum = 31;
  	dec->demux.feednum = 31;
  	dec->demux.start_feed = ttusb_dec_start_feed;
  	dec->demux.stop_feed = ttusb_dec_stop_feed;
  	dec->demux.write_to_decoder = NULL;
  
  	if ((result = dvb_dmx_init(&dec->demux)) < 0) {
  		printk("%s: dvb_dmx_init failed: error %d\n", __func__,
  		       result);
  
  		dvb_unregister_adapter(&dec->adapter);
  
  		return result;
  	}
  
  	dec->dmxdev.filternum = 32;
  	dec->dmxdev.demux = &dec->demux.dmx;
  	dec->dmxdev.capabilities = 0;
  
  	if ((result = dvb_dmxdev_init(&dec->dmxdev, &dec->adapter)) < 0) {
  		printk("%s: dvb_dmxdev_init failed: error %d\n",
  		       __func__, result);
  
  		dvb_dmx_release(&dec->demux);
  		dvb_unregister_adapter(&dec->adapter);
  
  		return result;
  	}
  
  	dec->frontend.source = DMX_FRONTEND_0;
  
  	if ((result = dec->demux.dmx.add_frontend(&dec->demux.dmx,
  						  &dec->frontend)) < 0) {
  		printk("%s: dvb_dmx_init failed: error %d\n", __func__,
  		       result);
  
  		dvb_dmxdev_release(&dec->dmxdev);
  		dvb_dmx_release(&dec->demux);
  		dvb_unregister_adapter(&dec->adapter);
  
  		return result;
  	}
  
  	if ((result = dec->demux.dmx.connect_frontend(&dec->demux.dmx,
  						      &dec->frontend)) < 0) {
  		printk("%s: dvb_dmx_init failed: error %d\n", __func__,
  		       result);
  
  		dec->demux.dmx.remove_frontend(&dec->demux.dmx, &dec->frontend);
  		dvb_dmxdev_release(&dec->dmxdev);
  		dvb_dmx_release(&dec->demux);
  		dvb_unregister_adapter(&dec->adapter);
  
  		return result;
  	}
  
  	dvb_net_init(&dec->adapter, &dec->dvb_net, &dec->demux.dmx);
  
  	return 0;
  }
  
  static void ttusb_dec_exit_dvb(struct ttusb_dec *dec)
  {
  	dprintk("%s\n", __func__);
  
  	dvb_net_release(&dec->dvb_net);
  	dec->demux.dmx.close(&dec->demux.dmx);
  	dec->demux.dmx.remove_frontend(&dec->demux.dmx, &dec->frontend);
  	dvb_dmxdev_release(&dec->dmxdev);
  	dvb_dmx_release(&dec->demux);
  	if (dec->fe) {
  		dvb_unregister_frontend(dec->fe);
  		if (dec->fe->ops.release)
  			dec->fe->ops.release(dec->fe);
  	}
  	dvb_unregister_adapter(&dec->adapter);
  }
  
  static void ttusb_dec_exit_rc(struct ttusb_dec *dec)
  {
  	dprintk("%s\n", __func__);
  
  	if (dec->rc_input_dev) {
  		input_unregister_device(dec->rc_input_dev);
  		dec->rc_input_dev = NULL;
  	}
  }
  
  
  static void ttusb_dec_exit_usb(struct ttusb_dec *dec)
  {
  	int i;
  
  	dprintk("%s\n", __func__);
  
  	if (enable_rc) {
  		/* we have to check whether the irq URB is already submitted.
  		 * As the irq is submitted after the interface is changed,
  		 * this is the best method i figured out.
  		 * Any others?*/
  		if (dec->interface == TTUSB_DEC_INTERFACE_IN)
  			usb_kill_urb(dec->irq_urb);
  
  		usb_free_urb(dec->irq_urb);
  
  		usb_free_coherent(dec->udev, IRQ_PACKET_SIZE,
  				  dec->irq_buffer, dec->irq_dma_handle);
  	}
  
  	dec->iso_stream_count = 0;
  
  	for (i = 0; i < ISO_BUF_COUNT; i++)
  		usb_kill_urb(dec->iso_urb[i]);
  
  	ttusb_dec_free_iso_urbs(dec);
  }
  
  static void ttusb_dec_exit_tasklet(struct ttusb_dec *dec)
  {
  	struct list_head *item;
  	struct urb_frame *frame;
  
  	tasklet_kill(&dec->urb_tasklet);
  
  	while ((item = dec->urb_frame_list.next) != &dec->urb_frame_list) {
  		frame = list_entry(item, struct urb_frame, urb_frame_list);
  		list_del(&frame->urb_frame_list);
  		kfree(frame);
  	}
  }
  
  static void ttusb_dec_init_filters(struct ttusb_dec *dec)
  {
  	INIT_LIST_HEAD(&dec->filter_info_list);
  	spin_lock_init(&dec->filter_info_list_lock);
  }
  
  static void ttusb_dec_exit_filters(struct ttusb_dec *dec)
  {
  	struct list_head *item;
  	struct filter_info *finfo;
  
  	while ((item = dec->filter_info_list.next) != &dec->filter_info_list) {
  		finfo = list_entry(item, struct filter_info, filter_info_list);
  		list_del(&finfo->filter_info_list);
  		kfree(finfo);
  	}
  }
  
  static int fe_send_command(struct dvb_frontend* fe, const u8 command,
  			   int param_length, const u8 params[],
  			   int *result_length, u8 cmd_result[])
  {
  	struct ttusb_dec* dec = fe->dvb->priv;
  	return ttusb_dec_send_command(dec, command, param_length, params, result_length, cmd_result);
  }
  
  static const struct ttusbdecfe_config fe_config = {
  	.send_command = fe_send_command
  };
  
  static int ttusb_dec_probe(struct usb_interface *intf,
  			   const struct usb_device_id *id)
  {
  	struct usb_device *udev;
  	struct ttusb_dec *dec;
  	int result;
  
  	dprintk("%s\n", __func__);
  
  	udev = interface_to_usbdev(intf);
  
  	if (!(dec = kzalloc(sizeof(struct ttusb_dec), GFP_KERNEL))) {
  		printk("%s: couldn't allocate memory.\n", __func__);
  		return -ENOMEM;
  	}
  
  	usb_set_intfdata(intf, (void *)dec);
  
  	switch (id->idProduct) {
  	case 0x1006:
  		ttusb_dec_set_model(dec, TTUSB_DEC3000S);
  		break;
  
  	case 0x1008:
  		ttusb_dec_set_model(dec, TTUSB_DEC2000T);
  		break;
  
  	case 0x1009:
  		ttusb_dec_set_model(dec, TTUSB_DEC2540T);
  		break;
  	}
  
  	dec->udev = udev;
  
  	result = ttusb_dec_init_usb(dec);
  	if (result)
  		goto err_usb;
  	result = ttusb_dec_init_stb(dec);
  	if (result)
  		goto err_stb;
  	result = ttusb_dec_init_dvb(dec);
  	if (result)
  		goto err_stb;
  
  	dec->adapter.priv = dec;
  	switch (id->idProduct) {
  	case 0x1006:
  		dec->fe = ttusbdecfe_dvbs_attach(&fe_config);
  		break;
  
  	case 0x1008:
  	case 0x1009:
  		dec->fe = ttusbdecfe_dvbt_attach(&fe_config);
  		break;
  	}
  
  	if (dec->fe == NULL) {
  		printk("dvb-ttusb-dec: A frontend driver was not found for device [%04x:%04x]\n",
  		       le16_to_cpu(dec->udev->descriptor.idVendor),
  		       le16_to_cpu(dec->udev->descriptor.idProduct));
  	} else {
  		if (dvb_register_frontend(&dec->adapter, dec->fe)) {
  			printk("budget-ci: Frontend registration failed!\n");
  			if (dec->fe->ops.release)
  				dec->fe->ops.release(dec->fe);
  			dec->fe = NULL;
  		}
  	}
  
  	ttusb_dec_init_v_pes(dec);
  	ttusb_dec_init_filters(dec);
  	ttusb_dec_init_tasklet(dec);
  
  	dec->active = 1;
  
  	ttusb_dec_set_interface(dec, TTUSB_DEC_INTERFACE_IN);
  
  	if (enable_rc)
  		ttusb_init_rc(dec);
  
  	return 0;
  err_stb:
  	ttusb_dec_exit_usb(dec);
  err_usb:
  	kfree(dec);
  	return result;
  }
  
  static void ttusb_dec_disconnect(struct usb_interface *intf)
  {
  	struct ttusb_dec *dec = usb_get_intfdata(intf);
  
  	usb_set_intfdata(intf, NULL);
  
  	dprintk("%s\n", __func__);
  
  	if (dec->active) {
  		ttusb_dec_exit_tasklet(dec);
  		ttusb_dec_exit_filters(dec);
  		if(enable_rc)
  			ttusb_dec_exit_rc(dec);
  		ttusb_dec_exit_usb(dec);
  		ttusb_dec_exit_dvb(dec);
  	}
  
  	kfree(dec);
  }
  
  static void ttusb_dec_set_model(struct ttusb_dec *dec,
  				enum ttusb_dec_model model)
  {
  	dec->model = model;
  
  	switch (model) {
  	case TTUSB_DEC2000T:
  		dec->model_name = "DEC2000-t";
  		dec->firmware_name = "dvb-ttusb-dec-2000t.fw";
  		break;
  
  	case TTUSB_DEC2540T:
  		dec->model_name = "DEC2540-t";
  		dec->firmware_name = "dvb-ttusb-dec-2540t.fw";
  		break;
  
  	case TTUSB_DEC3000S:
  		dec->model_name = "DEC3000-s";
  		dec->firmware_name = "dvb-ttusb-dec-3000s.fw";
  		break;
  	}
  }
  
  static const struct usb_device_id ttusb_dec_table[] = {
  	{USB_DEVICE(0x0b48, 0x1006)},	/* DEC3000-s */
  	/*{USB_DEVICE(0x0b48, 0x1007)},	   Unconfirmed */
  	{USB_DEVICE(0x0b48, 0x1008)},	/* DEC2000-t */
  	{USB_DEVICE(0x0b48, 0x1009)},	/* DEC2540-t */
  	{}
  };
  
  static struct usb_driver ttusb_dec_driver = {
  	.name		= "ttusb-dec",
  	.probe		= ttusb_dec_probe,
  	.disconnect	= ttusb_dec_disconnect,
  	.id_table	= ttusb_dec_table,
  };
  
  module_usb_driver(ttusb_dec_driver);
  
  MODULE_AUTHOR("Alex Woods <linux-dvb@giblets.org>");
  MODULE_DESCRIPTION(DRIVER_NAME);
  MODULE_LICENSE("GPL");
  MODULE_DEVICE_TABLE(usb, ttusb_dec_table);
  