4 * Copyright (C) 2003-2004 Alex Woods <linux-dvb@giblets.org>
5 * IR support by Peter Beutner <p.beutner@gmx.net>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 #include <asm/semaphore.h>
24 #include <linux/list.h>
25 #include <linux/module.h>
26 #include <linux/moduleparam.h>
27 #include <linux/pci.h>
28 #include <linux/slab.h>
29 #include <linux/spinlock.h>
30 #include <linux/usb.h>
31 #include <linux/interrupt.h>
32 #include <linux/firmware.h>
33 #include <linux/crc32.h>
34 #include <linux/init.h>
35 #include <linux/input.h>
38 #include "dvb_demux.h"
39 #include "dvb_filter.h"
40 #include "dvb_frontend.h"
42 #include "ttusbdecfe.h"
45 static int output_pva;
48 module_param(debug, int, 0644);
49 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
50 module_param(output_pva, int, 0444);
51 MODULE_PARM_DESC(output_pva, "Output PVA from dvr device (default:off)");
52 module_param(enable_rc, int, 0644);
53 MODULE_PARM_DESC(enable_rc, "Turn on/off IR remote control(default: off)");
55 #define dprintk if (debug) printk
57 #define DRIVER_NAME "TechnoTrend/Hauppauge DEC USB"
59 #define COMMAND_PIPE 0x03
60 #define RESULT_PIPE 0x04
65 #define COMMAND_PACKET_SIZE 0x3c
66 #define ARM_PACKET_SIZE 0x1000
67 #define IRQ_PACKET_SIZE 0x8
69 #define ISO_BUF_COUNT 0x04
70 #define FRAMES_PER_ISO_BUF 0x04
71 #define ISO_FRAME_SIZE 0x0380
73 #define MAX_PVA_LENGTH 6144
75 enum ttusb_dec_model {
81 enum ttusb_dec_packet_type {
83 TTUSB_DEC_PACKET_SECTION,
84 TTUSB_DEC_PACKET_EMPTY
87 enum ttusb_dec_interface {
88 TTUSB_DEC_INTERFACE_INITIAL,
89 TTUSB_DEC_INTERFACE_IN,
90 TTUSB_DEC_INTERFACE_OUT
94 enum ttusb_dec_model model;
100 struct dvb_adapter adapter;
101 struct dmxdev dmxdev;
102 struct dvb_demux demux;
103 struct dmx_frontend frontend;
104 struct dvb_net dvb_net;
105 struct dvb_frontend* fe;
107 u16 pid[DMX_PES_OTHER];
110 struct usb_device *udev;
112 unsigned int command_pipe;
113 unsigned int result_pipe;
114 unsigned int in_pipe;
115 unsigned int out_pipe;
116 unsigned int irq_pipe;
117 enum ttusb_dec_interface interface;
118 struct semaphore usb_sem;
122 dma_addr_t irq_dma_handle;
124 dma_addr_t iso_dma_handle;
125 struct urb *iso_urb[ISO_BUF_COUNT];
126 int iso_stream_count;
127 struct semaphore iso_sem;
129 u8 packet[MAX_PVA_LENGTH + 4];
130 enum ttusb_dec_packet_type packet_type;
133 int packet_payload_length;
136 int pva_stream_count;
137 int filter_stream_count;
139 struct dvb_filter_pes2ts a_pes2ts;
140 struct dvb_filter_pes2ts v_pes2ts;
142 u8 v_pes[16 + MAX_PVA_LENGTH];
146 struct list_head urb_frame_list;
147 struct tasklet_struct urb_tasklet;
148 spinlock_t urb_frame_list_lock;
150 struct dvb_demux_filter *audio_filter;
151 struct dvb_demux_filter *video_filter;
152 struct list_head filter_info_list;
153 spinlock_t filter_info_list_lock;
155 struct input_dev rc_input_dev;
157 int active; /* Loaded successfully */
161 u8 data[ISO_FRAME_SIZE];
163 struct list_head urb_frame_list;
168 struct dvb_demux_filter *filter;
169 struct list_head filter_info_list;
172 static u16 rc_keys[] = {
201 static void ttusb_dec_set_model(struct ttusb_dec *dec,
202 enum ttusb_dec_model model);
204 static void ttusb_dec_handle_irq( struct urb *urb, struct pt_regs *regs)
206 struct ttusb_dec * dec = urb->context;
207 char *buffer = dec->irq_buffer;
210 switch(urb->status) {
217 /* this urb is dead, cleanup */
218 dprintk("%s:urb shutting down with status: %d\n",
219 __FUNCTION__, urb->status);
222 dprintk("%s:nonzero status received: %d\n",
223 __FUNCTION__,urb->status);
227 if( (buffer[0] == 0x1) && (buffer[2] == 0x15) ) {
229 /* this is an fact a bit too simple implementation;
230 * the box also reports a keyrepeat signal
231 * (with buffer[3] == 0x40) in an intervall of ~100ms.
232 * But to handle this correctly we had to imlemenent some
233 * kind of timer which signals a 'key up' event if no
234 * keyrepeat signal is recieved for lets say 200ms.
235 * this should/could be added later ...
236 * for now lets report each signal as a key down and up*/
237 dprintk("%s:rc signal:%d\n", __FUNCTION__, buffer[4]);
238 input_report_key(&dec->rc_input_dev,rc_keys[buffer[4]-1],1);
239 input_report_key(&dec->rc_input_dev,rc_keys[buffer[4]-1],0);
240 input_sync(&dec->rc_input_dev);
243 exit: retval = usb_submit_urb(urb, GFP_ATOMIC);
245 printk("%s - usb_commit_urb failed with result: %d\n",
246 __FUNCTION__, retval);
249 static u16 crc16(u16 crc, const u8 *buf, size_t len)
257 crc ^= (tmp ^ (tmp << 1)) << 4;
262 static int ttusb_dec_send_command(struct ttusb_dec *dec, const u8 command,
263 int param_length, const u8 params[],
264 int *result_length, u8 cmd_result[])
266 int result, actual_len, i;
269 dprintk("%s\n", __FUNCTION__);
271 b = kmalloc(COMMAND_PACKET_SIZE + 4, GFP_KERNEL);
275 if ((result = down_interruptible(&dec->usb_sem))) {
277 printk("%s: Failed to down usb semaphore.\n", __FUNCTION__);
282 b[1] = ++dec->trans_count;
287 memcpy(&b[4], params, param_length);
290 printk("%s: command: ", __FUNCTION__);
291 for (i = 0; i < param_length + 4; i++)
292 printk("0x%02X ", b[i]);
296 result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
297 COMMAND_PACKET_SIZE + 4, &actual_len, 1000);
300 printk("%s: command bulk message failed: error %d\n",
301 __FUNCTION__, result);
307 result = usb_bulk_msg(dec->udev, dec->result_pipe, b,
308 COMMAND_PACKET_SIZE + 4, &actual_len, 1000);
311 printk("%s: result bulk message failed: error %d\n",
312 __FUNCTION__, result);
318 printk("%s: result: ", __FUNCTION__);
319 for (i = 0; i < actual_len; i++)
320 printk("0x%02X ", b[i]);
325 *result_length = b[3];
326 if (cmd_result && b[3] > 0)
327 memcpy(cmd_result, &b[4], b[3]);
336 static int ttusb_dec_get_stb_state (struct ttusb_dec *dec, unsigned int *mode,
337 unsigned int *model, unsigned int *version)
339 u8 c[COMMAND_PACKET_SIZE];
344 dprintk("%s\n", __FUNCTION__);
346 result = ttusb_dec_send_command(dec, 0x08, 0, NULL, &c_length, c);
350 if (c_length >= 0x0c) {
356 memcpy(&tmp, &c[4], 4);
359 if (version != NULL) {
360 memcpy(&tmp, &c[8], 4);
361 *version = ntohl(tmp);
369 static int ttusb_dec_audio_pes2ts_cb(void *priv, unsigned char *data)
371 struct ttusb_dec *dec = (struct ttusb_dec *)priv;
373 dec->audio_filter->feed->cb.ts(data, 188, NULL, 0,
374 &dec->audio_filter->feed->feed.ts,
380 static int ttusb_dec_video_pes2ts_cb(void *priv, unsigned char *data)
382 struct ttusb_dec *dec = (struct ttusb_dec *)priv;
384 dec->video_filter->feed->cb.ts(data, 188, NULL, 0,
385 &dec->video_filter->feed->feed.ts,
391 static void ttusb_dec_set_pids(struct ttusb_dec *dec)
393 u8 b[] = { 0x00, 0x00, 0x00, 0x00,
394 0x00, 0x00, 0xff, 0xff,
395 0xff, 0xff, 0xff, 0xff };
397 u16 pcr = htons(dec->pid[DMX_PES_PCR]);
398 u16 audio = htons(dec->pid[DMX_PES_AUDIO]);
399 u16 video = htons(dec->pid[DMX_PES_VIDEO]);
401 dprintk("%s\n", __FUNCTION__);
403 memcpy(&b[0], &pcr, 2);
404 memcpy(&b[2], &audio, 2);
405 memcpy(&b[4], &video, 2);
407 ttusb_dec_send_command(dec, 0x50, sizeof(b), b, NULL, NULL);
409 dvb_filter_pes2ts_init(&dec->a_pes2ts, dec->pid[DMX_PES_AUDIO],
410 ttusb_dec_audio_pes2ts_cb, dec);
411 dvb_filter_pes2ts_init(&dec->v_pes2ts, dec->pid[DMX_PES_VIDEO],
412 ttusb_dec_video_pes2ts_cb, dec);
413 dec->v_pes_length = 0;
414 dec->v_pes_postbytes = 0;
417 static void ttusb_dec_process_pva(struct ttusb_dec *dec, u8 *pva, int length)
420 printk("%s: packet too short - discarding\n", __FUNCTION__);
424 if (length > 8 + MAX_PVA_LENGTH) {
425 printk("%s: packet too long - discarding\n", __FUNCTION__);
431 case 0x01: { /* VideoStream */
432 int prebytes = pva[5] & 0x03;
433 int postbytes = (pva[5] & 0x0c) >> 2;
434 u16 v_pes_payload_length;
437 dec->video_filter->feed->cb.ts(pva, length, NULL, 0,
438 &dec->video_filter->feed->feed.ts, DMX_OK);
442 if (dec->v_pes_postbytes > 0 &&
443 dec->v_pes_postbytes == prebytes) {
444 memcpy(&dec->v_pes[dec->v_pes_length],
447 dvb_filter_pes2ts(&dec->v_pes2ts, dec->v_pes,
448 dec->v_pes_length + prebytes, 1);
452 dec->v_pes[7] = 0x80;
453 dec->v_pes[8] = 0x05;
455 dec->v_pes[9] = 0x21 | ((pva[8] & 0xc0) >> 5);
456 dec->v_pes[10] = ((pva[8] & 0x3f) << 2) |
457 ((pva[9] & 0xc0) >> 6);
458 dec->v_pes[11] = 0x01 |
459 ((pva[9] & 0x3f) << 2) |
460 ((pva[10] & 0x80) >> 6);
461 dec->v_pes[12] = ((pva[10] & 0x7f) << 1) |
462 ((pva[11] & 0xc0) >> 7);
463 dec->v_pes[13] = 0x01 | ((pva[11] & 0x7f) << 1);
465 memcpy(&dec->v_pes[14], &pva[12 + prebytes],
466 length - 12 - prebytes);
467 dec->v_pes_length = 14 + length - 12 - prebytes;
469 dec->v_pes[7] = 0x00;
470 dec->v_pes[8] = 0x00;
472 memcpy(&dec->v_pes[9], &pva[8], length - 8);
473 dec->v_pes_length = 9 + length - 8;
476 dec->v_pes_postbytes = postbytes;
478 if (dec->v_pes[9 + dec->v_pes[8]] == 0x00 &&
479 dec->v_pes[10 + dec->v_pes[8]] == 0x00 &&
480 dec->v_pes[11 + dec->v_pes[8]] == 0x01)
481 dec->v_pes[6] = 0x84;
483 dec->v_pes[6] = 0x80;
485 v_pes_payload_length = htons(dec->v_pes_length - 6 +
487 memcpy(&dec->v_pes[4], &v_pes_payload_length, 2);
490 dvb_filter_pes2ts(&dec->v_pes2ts, dec->v_pes,
491 dec->v_pes_length, 1);
496 case 0x02: /* MainAudioStream */
498 dec->audio_filter->feed->cb.ts(pva, length, NULL, 0,
499 &dec->audio_filter->feed->feed.ts, DMX_OK);
503 dvb_filter_pes2ts(&dec->a_pes2ts, &pva[8], length - 8,
508 printk("%s: unknown PVA type: %02x.\n", __FUNCTION__,
514 static void ttusb_dec_process_filter(struct ttusb_dec *dec, u8 *packet,
517 struct list_head *item;
518 struct filter_info *finfo;
519 struct dvb_demux_filter *filter = NULL;
524 spin_lock_irqsave(&dec->filter_info_list_lock, flags);
525 for (item = dec->filter_info_list.next; item != &dec->filter_info_list;
527 finfo = list_entry(item, struct filter_info, filter_info_list);
528 if (finfo->stream_id == sid) {
529 filter = finfo->filter;
533 spin_unlock_irqrestore(&dec->filter_info_list_lock, flags);
536 filter->feed->cb.sec(&packet[2], length - 2, NULL, 0,
537 &filter->filter, DMX_OK);
540 static void ttusb_dec_process_packet(struct ttusb_dec *dec)
546 if (dec->packet_length % 2) {
547 printk("%s: odd sized packet - discarding\n", __FUNCTION__);
551 for (i = 0; i < dec->packet_length; i += 2)
552 csum ^= ((dec->packet[i] << 8) + dec->packet[i + 1]);
555 printk("%s: checksum failed - discarding\n", __FUNCTION__);
559 packet_id = dec->packet[dec->packet_length - 4] << 8;
560 packet_id += dec->packet[dec->packet_length - 3];
562 if ((packet_id != dec->next_packet_id) && dec->next_packet_id) {
563 printk("%s: warning: lost packets between %u and %u\n",
564 __FUNCTION__, dec->next_packet_id - 1, packet_id);
567 if (packet_id == 0xffff)
568 dec->next_packet_id = 0x8000;
570 dec->next_packet_id = packet_id + 1;
572 switch (dec->packet_type) {
573 case TTUSB_DEC_PACKET_PVA:
574 if (dec->pva_stream_count)
575 ttusb_dec_process_pva(dec, dec->packet,
576 dec->packet_payload_length);
579 case TTUSB_DEC_PACKET_SECTION:
580 if (dec->filter_stream_count)
581 ttusb_dec_process_filter(dec, dec->packet,
582 dec->packet_payload_length);
585 case TTUSB_DEC_PACKET_EMPTY:
590 static void swap_bytes(u8 *b, int length)
594 length -= length % 2;
595 for (; length; b += 2, length -= 2) {
602 static void ttusb_dec_process_urb_frame(struct ttusb_dec *dec, u8 *b,
605 swap_bytes(b, length);
608 switch (dec->packet_state) {
616 dec->packet_state = 0;
624 dec->packet_length = 0;
625 } else if (*b != 0xaa) {
626 dec->packet_state = 0;
634 dec->packet[dec->packet_length++] = *b++;
636 if (dec->packet_length == 2) {
637 if (dec->packet[0] == 'A' &&
638 dec->packet[1] == 'V') {
640 TTUSB_DEC_PACKET_PVA;
642 } else if (dec->packet[0] == 'S') {
644 TTUSB_DEC_PACKET_SECTION;
646 } else if (dec->packet[0] == 0x00) {
648 TTUSB_DEC_PACKET_EMPTY;
649 dec->packet_payload_length = 2;
650 dec->packet_state = 7;
652 printk("%s: unknown packet type: "
653 "%02x%02x\n", __FUNCTION__,
654 dec->packet[0], dec->packet[1]);
655 dec->packet_state = 0;
663 dec->packet[dec->packet_length++] = *b++;
665 if (dec->packet_type == TTUSB_DEC_PACKET_PVA &&
666 dec->packet_length == 8) {
668 dec->packet_payload_length = 8 +
669 (dec->packet[6] << 8) +
671 } else if (dec->packet_type ==
672 TTUSB_DEC_PACKET_SECTION &&
673 dec->packet_length == 5) {
675 dec->packet_payload_length = 5 +
676 ((dec->packet[3] & 0x0f) << 8) +
684 int remainder = dec->packet_payload_length -
687 if (length >= remainder) {
688 memcpy(dec->packet + dec->packet_length,
690 dec->packet_length += remainder;
695 memcpy(&dec->packet[dec->packet_length],
697 dec->packet_length += length;
707 dec->packet[dec->packet_length++] = *b++;
709 if (dec->packet_type == TTUSB_DEC_PACKET_SECTION &&
710 dec->packet_payload_length % 2)
713 if (dec->packet_length ==
714 dec->packet_payload_length + tail) {
715 ttusb_dec_process_packet(dec);
716 dec->packet_state = 0;
724 printk("%s: illegal packet state encountered.\n",
726 dec->packet_state = 0;
731 static void ttusb_dec_process_urb_frame_list(unsigned long data)
733 struct ttusb_dec *dec = (struct ttusb_dec *)data;
734 struct list_head *item;
735 struct urb_frame *frame;
739 spin_lock_irqsave(&dec->urb_frame_list_lock, flags);
740 if ((item = dec->urb_frame_list.next) != &dec->urb_frame_list) {
741 frame = list_entry(item, struct urb_frame,
743 list_del(&frame->urb_frame_list);
745 spin_unlock_irqrestore(&dec->urb_frame_list_lock,
749 spin_unlock_irqrestore(&dec->urb_frame_list_lock, flags);
751 ttusb_dec_process_urb_frame(dec, frame->data, frame->length);
756 static void ttusb_dec_process_urb(struct urb *urb, struct pt_regs *ptregs)
758 struct ttusb_dec *dec = urb->context;
763 for (i = 0; i < FRAMES_PER_ISO_BUF; i++) {
764 struct usb_iso_packet_descriptor *d;
767 struct urb_frame *frame;
769 d = &urb->iso_frame_desc[i];
770 b = urb->transfer_buffer + d->offset;
771 length = d->actual_length;
773 if ((frame = kmalloc(sizeof(struct urb_frame),
777 memcpy(frame->data, b, length);
778 frame->length = length;
780 spin_lock_irqsave(&dec->urb_frame_list_lock,
782 list_add_tail(&frame->urb_frame_list,
783 &dec->urb_frame_list);
784 spin_unlock_irqrestore(&dec->urb_frame_list_lock,
787 tasklet_schedule(&dec->urb_tasklet);
791 /* -ENOENT is expected when unlinking urbs */
792 if (urb->status != -ENOENT)
793 dprintk("%s: urb error: %d\n", __FUNCTION__,
797 if (dec->iso_stream_count)
798 usb_submit_urb(urb, GFP_ATOMIC);
801 static void ttusb_dec_setup_urbs(struct ttusb_dec *dec)
803 int i, j, buffer_offset = 0;
805 dprintk("%s\n", __FUNCTION__);
807 for (i = 0; i < ISO_BUF_COUNT; i++) {
808 int frame_offset = 0;
809 struct urb *urb = dec->iso_urb[i];
811 urb->dev = dec->udev;
813 urb->complete = ttusb_dec_process_urb;
814 urb->pipe = dec->in_pipe;
815 urb->transfer_flags = URB_ISO_ASAP;
817 urb->number_of_packets = FRAMES_PER_ISO_BUF;
818 urb->transfer_buffer_length = ISO_FRAME_SIZE *
820 urb->transfer_buffer = dec->iso_buffer + buffer_offset;
821 buffer_offset += ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF;
823 for (j = 0; j < FRAMES_PER_ISO_BUF; j++) {
824 urb->iso_frame_desc[j].offset = frame_offset;
825 urb->iso_frame_desc[j].length = ISO_FRAME_SIZE;
826 frame_offset += ISO_FRAME_SIZE;
831 static void ttusb_dec_stop_iso_xfer(struct ttusb_dec *dec)
835 dprintk("%s\n", __FUNCTION__);
837 if (down_interruptible(&dec->iso_sem))
840 dec->iso_stream_count--;
842 if (!dec->iso_stream_count) {
843 for (i = 0; i < ISO_BUF_COUNT; i++)
844 usb_kill_urb(dec->iso_urb[i]);
850 /* Setting the interface of the DEC tends to take down the USB communications
851 * for a short period, so it's important not to call this function just before
852 * trying to talk to it.
854 static int ttusb_dec_set_interface(struct ttusb_dec *dec,
855 enum ttusb_dec_interface interface)
860 if (interface != dec->interface) {
862 case TTUSB_DEC_INTERFACE_INITIAL:
863 result = usb_set_interface(dec->udev, 0, 0);
865 case TTUSB_DEC_INTERFACE_IN:
866 result = ttusb_dec_send_command(dec, 0x80, sizeof(b),
870 result = usb_set_interface(dec->udev, 0, 8);
872 case TTUSB_DEC_INTERFACE_OUT:
873 result = usb_set_interface(dec->udev, 0, 1);
880 dec->interface = interface;
886 static int ttusb_dec_start_iso_xfer(struct ttusb_dec *dec)
890 dprintk("%s\n", __FUNCTION__);
892 if (down_interruptible(&dec->iso_sem))
895 if (!dec->iso_stream_count) {
896 ttusb_dec_setup_urbs(dec);
898 dec->packet_state = 0;
899 dec->v_pes_postbytes = 0;
900 dec->next_packet_id = 0;
902 for (i = 0; i < ISO_BUF_COUNT; i++) {
903 if ((result = usb_submit_urb(dec->iso_urb[i],
905 printk("%s: failed urb submission %d: "
906 "error %d\n", __FUNCTION__, i, result);
909 usb_kill_urb(dec->iso_urb[i - 1]);
919 dec->iso_stream_count++;
926 static int ttusb_dec_start_ts_feed(struct dvb_demux_feed *dvbdmxfeed)
928 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
929 struct ttusb_dec *dec = dvbdmx->priv;
933 dprintk("%s\n", __FUNCTION__);
935 dprintk(" ts_type:");
937 if (dvbdmxfeed->ts_type & TS_DECODER)
938 dprintk(" TS_DECODER");
940 if (dvbdmxfeed->ts_type & TS_PACKET)
941 dprintk(" TS_PACKET");
943 if (dvbdmxfeed->ts_type & TS_PAYLOAD_ONLY)
944 dprintk(" TS_PAYLOAD_ONLY");
948 switch (dvbdmxfeed->pes_type) {
950 case DMX_TS_PES_VIDEO:
951 dprintk(" pes_type: DMX_TS_PES_VIDEO\n");
952 dec->pid[DMX_PES_PCR] = dvbdmxfeed->pid;
953 dec->pid[DMX_PES_VIDEO] = dvbdmxfeed->pid;
954 dec->video_filter = dvbdmxfeed->filter;
955 ttusb_dec_set_pids(dec);
958 case DMX_TS_PES_AUDIO:
959 dprintk(" pes_type: DMX_TS_PES_AUDIO\n");
960 dec->pid[DMX_PES_AUDIO] = dvbdmxfeed->pid;
961 dec->audio_filter = dvbdmxfeed->filter;
962 ttusb_dec_set_pids(dec);
965 case DMX_TS_PES_TELETEXT:
966 dec->pid[DMX_PES_TELETEXT] = dvbdmxfeed->pid;
967 dprintk(" pes_type: DMX_TS_PES_TELETEXT\n");
971 dprintk(" pes_type: DMX_TS_PES_PCR\n");
972 dec->pid[DMX_PES_PCR] = dvbdmxfeed->pid;
973 ttusb_dec_set_pids(dec);
976 case DMX_TS_PES_OTHER:
977 dprintk(" pes_type: DMX_TS_PES_OTHER\n");
981 dprintk(" pes_type: unknown (%d)\n", dvbdmxfeed->pes_type);
986 result = ttusb_dec_send_command(dec, 0x80, sizeof(b0), b0, NULL, NULL);
990 dec->pva_stream_count++;
991 return ttusb_dec_start_iso_xfer(dec);
994 static int ttusb_dec_start_sec_feed(struct dvb_demux_feed *dvbdmxfeed)
996 struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
997 u8 b0[] = { 0x00, 0x00, 0x00, 0x01,
998 0x00, 0x00, 0x00, 0x00,
999 0x00, 0x00, 0x00, 0x00,
1000 0x00, 0x00, 0x00, 0x00,
1001 0x00, 0xff, 0x00, 0x00,
1002 0x00, 0x00, 0x00, 0x00,
1003 0x00, 0x00, 0x00, 0x00,
1006 u8 c[COMMAND_PACKET_SIZE];
1009 struct filter_info *finfo;
1010 unsigned long flags;
1013 dprintk("%s\n", __FUNCTION__);
1015 pid = htons(dvbdmxfeed->pid);
1016 memcpy(&b0[0], &pid, 2);
1017 memcpy(&b0[4], &x, 1);
1018 memcpy(&b0[5], &dvbdmxfeed->filter->filter.filter_value[0], 1);
1020 result = ttusb_dec_send_command(dec, 0x60, sizeof(b0), b0,
1024 if (c_length == 2) {
1025 if (!(finfo = kmalloc(sizeof(struct filter_info),
1029 finfo->stream_id = c[1];
1030 finfo->filter = dvbdmxfeed->filter;
1032 spin_lock_irqsave(&dec->filter_info_list_lock, flags);
1033 list_add_tail(&finfo->filter_info_list,
1034 &dec->filter_info_list);
1035 spin_unlock_irqrestore(&dec->filter_info_list_lock,
1038 dvbdmxfeed->priv = finfo;
1040 dec->filter_stream_count++;
1041 return ttusb_dec_start_iso_xfer(dec);
1049 static int ttusb_dec_start_feed(struct dvb_demux_feed *dvbdmxfeed)
1051 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
1053 dprintk("%s\n", __FUNCTION__);
1055 if (!dvbdmx->dmx.frontend)
1058 dprintk(" pid: 0x%04X\n", dvbdmxfeed->pid);
1060 switch (dvbdmxfeed->type) {
1063 return ttusb_dec_start_ts_feed(dvbdmxfeed);
1067 return ttusb_dec_start_sec_feed(dvbdmxfeed);
1071 dprintk(" type: unknown (%d)\n", dvbdmxfeed->type);
1077 static int ttusb_dec_stop_ts_feed(struct dvb_demux_feed *dvbdmxfeed)
1079 struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
1082 ttusb_dec_send_command(dec, 0x81, sizeof(b0), b0, NULL, NULL);
1084 dec->pva_stream_count--;
1086 ttusb_dec_stop_iso_xfer(dec);
1091 static int ttusb_dec_stop_sec_feed(struct dvb_demux_feed *dvbdmxfeed)
1093 struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
1094 u8 b0[] = { 0x00, 0x00 };
1095 struct filter_info *finfo = (struct filter_info *)dvbdmxfeed->priv;
1096 unsigned long flags;
1098 b0[1] = finfo->stream_id;
1099 spin_lock_irqsave(&dec->filter_info_list_lock, flags);
1100 list_del(&finfo->filter_info_list);
1101 spin_unlock_irqrestore(&dec->filter_info_list_lock, flags);
1103 ttusb_dec_send_command(dec, 0x62, sizeof(b0), b0, NULL, NULL);
1105 dec->filter_stream_count--;
1107 ttusb_dec_stop_iso_xfer(dec);
1112 static int ttusb_dec_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
1114 dprintk("%s\n", __FUNCTION__);
1116 switch (dvbdmxfeed->type) {
1118 return ttusb_dec_stop_ts_feed(dvbdmxfeed);
1122 return ttusb_dec_stop_sec_feed(dvbdmxfeed);
1129 static void ttusb_dec_free_iso_urbs(struct ttusb_dec *dec)
1133 dprintk("%s\n", __FUNCTION__);
1135 for (i = 0; i < ISO_BUF_COUNT; i++)
1136 if (dec->iso_urb[i])
1137 usb_free_urb(dec->iso_urb[i]);
1139 pci_free_consistent(NULL,
1140 ISO_FRAME_SIZE * (FRAMES_PER_ISO_BUF *
1142 dec->iso_buffer, dec->iso_dma_handle);
1145 static int ttusb_dec_alloc_iso_urbs(struct ttusb_dec *dec)
1149 dprintk("%s\n", __FUNCTION__);
1151 dec->iso_buffer = pci_alloc_consistent(NULL,
1153 (FRAMES_PER_ISO_BUF *
1155 &dec->iso_dma_handle);
1157 memset(dec->iso_buffer, 0,
1158 ISO_FRAME_SIZE * (FRAMES_PER_ISO_BUF * ISO_BUF_COUNT));
1160 for (i = 0; i < ISO_BUF_COUNT; i++) {
1163 if (!(urb = usb_alloc_urb(FRAMES_PER_ISO_BUF, GFP_ATOMIC))) {
1164 ttusb_dec_free_iso_urbs(dec);
1168 dec->iso_urb[i] = urb;
1171 ttusb_dec_setup_urbs(dec);
1176 static void ttusb_dec_init_tasklet(struct ttusb_dec *dec)
1178 spin_lock_init(&dec->urb_frame_list_lock);
1179 INIT_LIST_HEAD(&dec->urb_frame_list);
1180 tasklet_init(&dec->urb_tasklet, ttusb_dec_process_urb_frame_list,
1181 (unsigned long)dec);
1184 static void ttusb_init_rc( struct ttusb_dec *dec)
1186 u8 b[] = { 0x00, 0x01 };
1189 init_input_dev(&dec->rc_input_dev);
1191 dec->rc_input_dev.name = "ttusb_dec remote control";
1192 dec->rc_input_dev.evbit[0] = BIT(EV_KEY);
1193 dec->rc_input_dev.keycodesize = sizeof(u16);
1194 dec->rc_input_dev.keycodemax = 0x1a;
1195 dec->rc_input_dev.keycode = rc_keys;
1197 for (i = 0; i < sizeof(rc_keys)/sizeof(rc_keys[0]); i++)
1198 set_bit(rc_keys[i], dec->rc_input_dev.keybit);
1200 input_register_device(&dec->rc_input_dev);
1202 if(usb_submit_urb(dec->irq_urb,GFP_KERNEL)) {
1203 printk("%s: usb_submit_urb failed\n",__FUNCTION__);
1205 /* enable irq pipe */
1206 ttusb_dec_send_command(dec,0xb0,sizeof(b),b,NULL,NULL);
1209 static void ttusb_dec_init_v_pes(struct ttusb_dec *dec)
1211 dprintk("%s\n", __FUNCTION__);
1213 dec->v_pes[0] = 0x00;
1214 dec->v_pes[1] = 0x00;
1215 dec->v_pes[2] = 0x01;
1216 dec->v_pes[3] = 0xe0;
1219 static int ttusb_dec_init_usb(struct ttusb_dec *dec)
1221 dprintk("%s\n", __FUNCTION__);
1223 sema_init(&dec->usb_sem, 1);
1224 sema_init(&dec->iso_sem, 1);
1226 dec->command_pipe = usb_sndbulkpipe(dec->udev, COMMAND_PIPE);
1227 dec->result_pipe = usb_rcvbulkpipe(dec->udev, RESULT_PIPE);
1228 dec->in_pipe = usb_rcvisocpipe(dec->udev, IN_PIPE);
1229 dec->out_pipe = usb_sndisocpipe(dec->udev, OUT_PIPE);
1230 dec->irq_pipe = usb_rcvintpipe(dec->udev, IRQ_PIPE);
1233 dec->irq_urb = usb_alloc_urb(0, GFP_KERNEL);
1237 dec->irq_buffer = usb_buffer_alloc(dec->udev,IRQ_PACKET_SIZE,
1238 SLAB_ATOMIC, &dec->irq_dma_handle);
1239 if(!dec->irq_buffer) {
1242 usb_fill_int_urb(dec->irq_urb, dec->udev,dec->irq_pipe,
1243 dec->irq_buffer, IRQ_PACKET_SIZE,
1244 ttusb_dec_handle_irq, dec, 1);
1245 dec->irq_urb->transfer_dma = dec->irq_dma_handle;
1246 dec->irq_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1249 return ttusb_dec_alloc_iso_urbs(dec);
1252 static int ttusb_dec_boot_dsp(struct ttusb_dec *dec)
1254 int i, j, actual_len, result, size, trans_count;
1255 u8 b0[] = { 0x00, 0x00, 0x00, 0x00,
1256 0x00, 0x00, 0x00, 0x00,
1261 u8 *firmware = NULL;
1262 size_t firmware_size = 0;
1263 u16 firmware_csum = 0;
1264 u16 firmware_csum_ns;
1265 u32 firmware_size_nl;
1266 u32 crc32_csum, crc32_check, tmp;
1267 const struct firmware *fw_entry = NULL;
1269 dprintk("%s\n", __FUNCTION__);
1271 if (request_firmware(&fw_entry, dec->firmware_name, &dec->udev->dev)) {
1272 printk(KERN_ERR "%s: Firmware (%s) unavailable.\n",
1273 __FUNCTION__, dec->firmware_name);
1277 firmware = fw_entry->data;
1278 firmware_size = fw_entry->size;
1280 if (firmware_size < 60) {
1281 printk("%s: firmware size too small for DSP code (%zu < 60).\n",
1282 __FUNCTION__, firmware_size);
1283 release_firmware(fw_entry);
1287 /* a 32 bit checksum over the first 56 bytes of the DSP Code is stored
1288 at offset 56 of file, so use it to check if the firmware file is
1290 crc32_csum = crc32(~0L, firmware, 56) ^ ~0L;
1291 memcpy(&tmp, &firmware[56], 4);
1292 crc32_check = htonl(tmp);
1293 if (crc32_csum != crc32_check) {
1294 printk("%s: crc32 check of DSP code failed (calculated "
1295 "0x%08x != 0x%08x in file), file invalid.\n",
1296 __FUNCTION__, crc32_csum, crc32_check);
1297 release_firmware(fw_entry);
1300 memcpy(idstring, &firmware[36], 20);
1301 idstring[20] = '\0';
1302 printk(KERN_INFO "ttusb_dec: found DSP code \"%s\".\n", idstring);
1304 firmware_size_nl = htonl(firmware_size);
1305 memcpy(b0, &firmware_size_nl, 4);
1306 firmware_csum = crc16(~0, firmware, firmware_size) ^ ~0;
1307 firmware_csum_ns = htons(firmware_csum);
1308 memcpy(&b0[6], &firmware_csum_ns, 2);
1310 result = ttusb_dec_send_command(dec, 0x41, sizeof(b0), b0, NULL, NULL);
1313 release_firmware(fw_entry);
1320 b = kmalloc(ARM_PACKET_SIZE, GFP_KERNEL);
1322 release_firmware(fw_entry);
1326 for (i = 0; i < firmware_size; i += COMMAND_PACKET_SIZE) {
1327 size = firmware_size - i;
1328 if (size > COMMAND_PACKET_SIZE)
1329 size = COMMAND_PACKET_SIZE;
1332 b[j + 1] = trans_count++;
1335 memcpy(&b[j + 4], &firmware[i], size);
1337 j += COMMAND_PACKET_SIZE + 4;
1339 if (j >= ARM_PACKET_SIZE) {
1340 result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
1341 ARM_PACKET_SIZE, &actual_len,
1344 } else if (size < COMMAND_PACKET_SIZE) {
1345 result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
1346 j - COMMAND_PACKET_SIZE + size,
1351 result = ttusb_dec_send_command(dec, 0x43, sizeof(b1), b1, NULL, NULL);
1353 release_firmware(fw_entry);
1359 static int ttusb_dec_init_stb(struct ttusb_dec *dec)
1362 unsigned int mode, model, version;
1364 dprintk("%s\n", __FUNCTION__);
1366 result = ttusb_dec_get_stb_state(dec, &mode, &model, &version);
1370 if (version == 0xABCDEFAB)
1371 printk(KERN_INFO "ttusb_dec: no version "
1372 "info in Firmware\n");
1374 printk(KERN_INFO "ttusb_dec: Firmware "
1376 version >> 24, (version >> 16) & 0xff,
1377 (version >> 8) & 0xff, version & 0xff);
1379 result = ttusb_dec_boot_dsp(dec);
1385 /* We can't trust the USB IDs that some firmwares
1390 ttusb_dec_set_model(dec, TTUSB_DEC3000S);
1394 ttusb_dec_set_model(dec, TTUSB_DEC2000T);
1397 ttusb_dec_set_model(dec, TTUSB_DEC2540T);
1400 printk(KERN_ERR "%s: unknown model returned "
1401 "by firmware (%08x) - please report\n",
1402 __FUNCTION__, model);
1407 if (version >= 0x01770000)
1408 dec->can_playback = 1;
1417 static int ttusb_dec_init_dvb(struct ttusb_dec *dec)
1421 dprintk("%s\n", __FUNCTION__);
1423 if ((result = dvb_register_adapter(&dec->adapter,
1424 dec->model_name, THIS_MODULE)) < 0) {
1425 printk("%s: dvb_register_adapter failed: error %d\n",
1426 __FUNCTION__, result);
1431 dec->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING;
1433 dec->demux.priv = (void *)dec;
1434 dec->demux.filternum = 31;
1435 dec->demux.feednum = 31;
1436 dec->demux.start_feed = ttusb_dec_start_feed;
1437 dec->demux.stop_feed = ttusb_dec_stop_feed;
1438 dec->demux.write_to_decoder = NULL;
1440 if ((result = dvb_dmx_init(&dec->demux)) < 0) {
1441 printk("%s: dvb_dmx_init failed: error %d\n", __FUNCTION__,
1444 dvb_unregister_adapter(&dec->adapter);
1449 dec->dmxdev.filternum = 32;
1450 dec->dmxdev.demux = &dec->demux.dmx;
1451 dec->dmxdev.capabilities = 0;
1453 if ((result = dvb_dmxdev_init(&dec->dmxdev, &dec->adapter)) < 0) {
1454 printk("%s: dvb_dmxdev_init failed: error %d\n",
1455 __FUNCTION__, result);
1457 dvb_dmx_release(&dec->demux);
1458 dvb_unregister_adapter(&dec->adapter);
1463 dec->frontend.source = DMX_FRONTEND_0;
1465 if ((result = dec->demux.dmx.add_frontend(&dec->demux.dmx,
1466 &dec->frontend)) < 0) {
1467 printk("%s: dvb_dmx_init failed: error %d\n", __FUNCTION__,
1470 dvb_dmxdev_release(&dec->dmxdev);
1471 dvb_dmx_release(&dec->demux);
1472 dvb_unregister_adapter(&dec->adapter);
1477 if ((result = dec->demux.dmx.connect_frontend(&dec->demux.dmx,
1478 &dec->frontend)) < 0) {
1479 printk("%s: dvb_dmx_init failed: error %d\n", __FUNCTION__,
1482 dec->demux.dmx.remove_frontend(&dec->demux.dmx, &dec->frontend);
1483 dvb_dmxdev_release(&dec->dmxdev);
1484 dvb_dmx_release(&dec->demux);
1485 dvb_unregister_adapter(&dec->adapter);
1490 dvb_net_init(&dec->adapter, &dec->dvb_net, &dec->demux.dmx);
1495 static void ttusb_dec_exit_dvb(struct ttusb_dec *dec)
1497 dprintk("%s\n", __FUNCTION__);
1499 dvb_net_release(&dec->dvb_net);
1500 dec->demux.dmx.close(&dec->demux.dmx);
1501 dec->demux.dmx.remove_frontend(&dec->demux.dmx, &dec->frontend);
1502 dvb_dmxdev_release(&dec->dmxdev);
1503 dvb_dmx_release(&dec->demux);
1504 if (dec->fe) dvb_unregister_frontend(dec->fe);
1505 dvb_unregister_adapter(&dec->adapter);
1508 static void ttusb_dec_exit_rc(struct ttusb_dec *dec)
1511 dprintk("%s\n", __FUNCTION__);
1512 /* we have to check whether the irq URB is already submitted.
1513 * As the irq is submitted after the interface is changed,
1514 * this is the best method i figured out.
1516 if(dec->interface == TTUSB_DEC_INTERFACE_IN)
1517 usb_kill_urb(dec->irq_urb);
1519 usb_free_urb(dec->irq_urb);
1521 usb_buffer_free(dec->udev,IRQ_PACKET_SIZE,
1522 dec->irq_buffer, dec->irq_dma_handle);
1524 input_unregister_device(&dec->rc_input_dev);
1528 static void ttusb_dec_exit_usb(struct ttusb_dec *dec)
1532 dprintk("%s\n", __FUNCTION__);
1534 dec->iso_stream_count = 0;
1536 for (i = 0; i < ISO_BUF_COUNT; i++)
1537 usb_kill_urb(dec->iso_urb[i]);
1539 ttusb_dec_free_iso_urbs(dec);
1542 static void ttusb_dec_exit_tasklet(struct ttusb_dec *dec)
1544 struct list_head *item;
1545 struct urb_frame *frame;
1547 tasklet_kill(&dec->urb_tasklet);
1549 while ((item = dec->urb_frame_list.next) != &dec->urb_frame_list) {
1550 frame = list_entry(item, struct urb_frame, urb_frame_list);
1551 list_del(&frame->urb_frame_list);
1556 static void ttusb_dec_init_filters(struct ttusb_dec *dec)
1558 INIT_LIST_HEAD(&dec->filter_info_list);
1559 spin_lock_init(&dec->filter_info_list_lock);
1562 static void ttusb_dec_exit_filters(struct ttusb_dec *dec)
1564 struct list_head *item;
1565 struct filter_info *finfo;
1567 while ((item = dec->filter_info_list.next) != &dec->filter_info_list) {
1568 finfo = list_entry(item, struct filter_info, filter_info_list);
1569 list_del(&finfo->filter_info_list);
1574 static int fe_send_command(struct dvb_frontend* fe, const u8 command,
1575 int param_length, const u8 params[],
1576 int *result_length, u8 cmd_result[])
1578 struct ttusb_dec* dec = (struct ttusb_dec*) fe->dvb->priv;
1579 return ttusb_dec_send_command(dec, command, param_length, params, result_length, cmd_result);
1582 static struct ttusbdecfe_config fe_config = {
1583 .send_command = fe_send_command
1586 static int ttusb_dec_probe(struct usb_interface *intf,
1587 const struct usb_device_id *id)
1589 struct usb_device *udev;
1590 struct ttusb_dec *dec;
1592 dprintk("%s\n", __FUNCTION__);
1594 udev = interface_to_usbdev(intf);
1596 if (!(dec = kmalloc(sizeof(struct ttusb_dec), GFP_KERNEL))) {
1597 printk("%s: couldn't allocate memory.\n", __FUNCTION__);
1601 usb_set_intfdata(intf, (void *)dec);
1603 memset(dec, 0, sizeof(struct ttusb_dec));
1605 switch (le16_to_cpu(id->idProduct)) {
1607 ttusb_dec_set_model(dec, TTUSB_DEC3000S);
1611 ttusb_dec_set_model(dec, TTUSB_DEC2000T);
1615 ttusb_dec_set_model(dec, TTUSB_DEC2540T);
1621 if (ttusb_dec_init_usb(dec))
1623 if (ttusb_dec_init_stb(dec)) {
1624 ttusb_dec_exit_usb(dec);
1627 ttusb_dec_init_dvb(dec);
1629 dec->adapter.priv = dec;
1630 switch (le16_to_cpu(id->idProduct)) {
1632 dec->fe = ttusbdecfe_dvbs_attach(&fe_config);
1637 dec->fe = ttusbdecfe_dvbt_attach(&fe_config);
1641 if (dec->fe == NULL) {
1642 printk("dvb-ttusb-dec: A frontend driver was not found for device %04x/%04x\n",
1643 le16_to_cpu(dec->udev->descriptor.idVendor),
1644 le16_to_cpu(dec->udev->descriptor.idProduct));
1646 if (dvb_register_frontend(&dec->adapter, dec->fe)) {
1647 printk("budget-ci: Frontend registration failed!\n");
1648 if (dec->fe->ops->release)
1649 dec->fe->ops->release(dec->fe);
1654 ttusb_dec_init_v_pes(dec);
1655 ttusb_dec_init_filters(dec);
1656 ttusb_dec_init_tasklet(dec);
1660 ttusb_dec_set_interface(dec, TTUSB_DEC_INTERFACE_IN);
1668 static void ttusb_dec_disconnect(struct usb_interface *intf)
1670 struct ttusb_dec *dec = usb_get_intfdata(intf);
1672 usb_set_intfdata(intf, NULL);
1674 dprintk("%s\n", __FUNCTION__);
1677 ttusb_dec_exit_tasklet(dec);
1678 ttusb_dec_exit_filters(dec);
1680 ttusb_dec_exit_rc(dec);
1681 ttusb_dec_exit_usb(dec);
1682 ttusb_dec_exit_dvb(dec);
1688 static void ttusb_dec_set_model(struct ttusb_dec *dec,
1689 enum ttusb_dec_model model)
1694 case TTUSB_DEC2000T:
1695 dec->model_name = "DEC2000-t";
1696 dec->firmware_name = "dvb-ttusb-dec-2000t.fw";
1699 case TTUSB_DEC2540T:
1700 dec->model_name = "DEC2540-t";
1701 dec->firmware_name = "dvb-ttusb-dec-2540t.fw";
1704 case TTUSB_DEC3000S:
1705 dec->model_name = "DEC3000-s";
1706 dec->firmware_name = "dvb-ttusb-dec-3000s.fw";
1711 static struct usb_device_id ttusb_dec_table[] = {
1712 {USB_DEVICE(0x0b48, 0x1006)}, /* DEC3000-s */
1713 /*{USB_DEVICE(0x0b48, 0x1007)}, Unconfirmed */
1714 {USB_DEVICE(0x0b48, 0x1008)}, /* DEC2000-t */
1715 {USB_DEVICE(0x0b48, 0x1009)}, /* DEC2540-t */
1719 static struct usb_driver ttusb_dec_driver = {
1720 .name = "ttusb-dec",
1721 .probe = ttusb_dec_probe,
1722 .disconnect = ttusb_dec_disconnect,
1723 .id_table = ttusb_dec_table,
1726 static int __init ttusb_dec_init(void)
1730 if ((result = usb_register(&ttusb_dec_driver)) < 0) {
1731 printk("%s: initialisation failed: error %d.\n", __FUNCTION__,
1739 static void __exit ttusb_dec_exit(void)
1741 usb_deregister(&ttusb_dec_driver);
1744 module_init(ttusb_dec_init);
1745 module_exit(ttusb_dec_exit);
1747 MODULE_AUTHOR("Alex Woods <linux-dvb@giblets.org>");
1748 MODULE_DESCRIPTION(DRIVER_NAME);
1749 MODULE_LICENSE("GPL");
1750 MODULE_DEVICE_TABLE(usb, ttusb_dec_table);