ttusb_dec.c

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