4 * Copyright (C) 2003-2004 Alex Woods <linux-dvb@giblets.org>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 #include <asm/semaphore.h>
23 #include <linux/list.h>
24 #include <linux/module.h>
25 #include <linux/moduleparam.h>
26 #include <linux/pci.h>
27 #include <linux/slab.h>
28 #include <linux/spinlock.h>
29 #include <linux/usb.h>
30 #include <linux/version.h>
31 #include <linux/interrupt.h>
32 #include <linux/firmware.h>
33 #include <linux/crc32.h>
34 #include <linux/init.h>
37 #include "dvb_demux.h"
38 #include "dvb_filter.h"
39 #include "dvb_frontend.h"
41 #include "ttusbdecfe.h"
44 static int output_pva;
46 module_param(debug, int, 0644);
47 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
48 module_param(output_pva, int, 0444);
49 MODULE_PARM_DESC(output_pva, "Output PVA from dvr device (default:off)");
51 #define dprintk if (debug) printk
53 #define DRIVER_NAME "TechnoTrend/Hauppauge DEC USB"
55 #define COMMAND_PIPE 0x03
56 #define RESULT_PIPE 0x84
60 #define COMMAND_PACKET_SIZE 0x3c
61 #define ARM_PACKET_SIZE 0x1000
63 #define ISO_BUF_COUNT 0x04
64 #define FRAMES_PER_ISO_BUF 0x04
65 #define ISO_FRAME_SIZE 0x03FF
67 #define MAX_PVA_LENGTH 6144
69 enum ttusb_dec_model {
75 enum ttusb_dec_packet_type {
77 TTUSB_DEC_PACKET_SECTION,
78 TTUSB_DEC_PACKET_EMPTY
81 enum ttusb_dec_interface {
82 TTUSB_DEC_INTERFACE_INITIAL,
83 TTUSB_DEC_INTERFACE_IN,
84 TTUSB_DEC_INTERFACE_OUT
88 enum ttusb_dec_model model;
94 struct dvb_adapter *adapter;
96 struct dvb_demux demux;
97 struct dmx_frontend frontend;
98 struct dvb_net dvb_net;
99 struct dvb_frontend* fe;
101 u16 pid[DMX_PES_OTHER];
104 struct usb_device *udev;
106 unsigned int command_pipe;
107 unsigned int result_pipe;
108 unsigned int in_pipe;
109 unsigned int out_pipe;
110 enum ttusb_dec_interface interface;
111 struct semaphore usb_sem;
114 dma_addr_t iso_dma_handle;
115 struct urb *iso_urb[ISO_BUF_COUNT];
116 int iso_stream_count;
117 struct semaphore iso_sem;
119 u8 packet[MAX_PVA_LENGTH + 4];
120 enum ttusb_dec_packet_type packet_type;
123 int packet_payload_length;
126 int pva_stream_count;
127 int filter_stream_count;
129 struct dvb_filter_pes2ts a_pes2ts;
130 struct dvb_filter_pes2ts v_pes2ts;
132 u8 v_pes[16 + MAX_PVA_LENGTH];
136 struct list_head urb_frame_list;
137 struct tasklet_struct urb_tasklet;
138 spinlock_t urb_frame_list_lock;
140 struct dvb_demux_filter *audio_filter;
141 struct dvb_demux_filter *video_filter;
142 struct list_head filter_info_list;
143 spinlock_t filter_info_list_lock;
145 int active; /* Loaded successfully */
149 u8 data[ISO_FRAME_SIZE];
151 struct list_head urb_frame_list;
156 struct dvb_demux_filter *filter;
157 struct list_head filter_info_list;
160 static void ttusb_dec_set_model(struct ttusb_dec *dec,
161 enum ttusb_dec_model model);
163 static u16 crc16(u16 crc, const u8 *buf, size_t len)
171 crc ^= (tmp ^ (tmp << 1)) << 4;
176 static int ttusb_dec_send_command(struct ttusb_dec *dec, const u8 command,
177 int param_length, const u8 params[],
178 int *result_length, u8 cmd_result[])
180 int result, actual_len, i;
183 dprintk("%s\n", __FUNCTION__);
185 b = kmalloc(COMMAND_PACKET_SIZE + 4, GFP_KERNEL);
189 if ((result = down_interruptible(&dec->usb_sem))) {
191 printk("%s: Failed to down usb semaphore.\n", __FUNCTION__);
196 b[1] = ++dec->trans_count;
201 memcpy(&b[4], params, param_length);
204 printk("%s: command: ", __FUNCTION__);
205 for (i = 0; i < param_length + 4; i++)
206 printk("0x%02X ", b[i]);
210 result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
211 COMMAND_PACKET_SIZE + 4, &actual_len, HZ);
214 printk("%s: command bulk message failed: error %d\n",
215 __FUNCTION__, result);
221 result = usb_bulk_msg(dec->udev, dec->result_pipe, b,
222 COMMAND_PACKET_SIZE + 4, &actual_len, HZ);
225 printk("%s: result bulk message failed: error %d\n",
226 __FUNCTION__, result);
232 printk("%s: result: ", __FUNCTION__);
233 for (i = 0; i < actual_len; i++)
234 printk("0x%02X ", b[i]);
239 *result_length = b[3];
240 if (cmd_result && b[3] > 0)
241 memcpy(cmd_result, &b[4], b[3]);
250 static int ttusb_dec_get_stb_state (struct ttusb_dec *dec, unsigned int *mode,
251 unsigned int *model, unsigned int *version)
253 u8 c[COMMAND_PACKET_SIZE];
258 dprintk("%s\n", __FUNCTION__);
260 result = ttusb_dec_send_command(dec, 0x08, 0, NULL, &c_length, c);
264 if (c_length >= 0x0c) {
270 memcpy(&tmp, &c[4], 4);
273 if (version != NULL) {
274 memcpy(&tmp, &c[8], 4);
275 *version = ntohl(tmp);
283 static int ttusb_dec_audio_pes2ts_cb(void *priv, unsigned char *data)
285 struct ttusb_dec *dec = (struct ttusb_dec *)priv;
287 dec->audio_filter->feed->cb.ts(data, 188, NULL, 0,
288 &dec->audio_filter->feed->feed.ts,
294 static int ttusb_dec_video_pes2ts_cb(void *priv, unsigned char *data)
296 struct ttusb_dec *dec = (struct ttusb_dec *)priv;
298 dec->video_filter->feed->cb.ts(data, 188, NULL, 0,
299 &dec->video_filter->feed->feed.ts,
305 static void ttusb_dec_set_pids(struct ttusb_dec *dec)
307 u8 b[] = { 0x00, 0x00, 0x00, 0x00,
308 0x00, 0x00, 0xff, 0xff,
309 0xff, 0xff, 0xff, 0xff };
311 u16 pcr = htons(dec->pid[DMX_PES_PCR]);
312 u16 audio = htons(dec->pid[DMX_PES_AUDIO]);
313 u16 video = htons(dec->pid[DMX_PES_VIDEO]);
315 dprintk("%s\n", __FUNCTION__);
317 memcpy(&b[0], &pcr, 2);
318 memcpy(&b[2], &audio, 2);
319 memcpy(&b[4], &video, 2);
321 ttusb_dec_send_command(dec, 0x50, sizeof(b), b, NULL, NULL);
323 dvb_filter_pes2ts_init(&dec->a_pes2ts, dec->pid[DMX_PES_AUDIO],
324 ttusb_dec_audio_pes2ts_cb, dec);
325 dvb_filter_pes2ts_init(&dec->v_pes2ts, dec->pid[DMX_PES_VIDEO],
326 ttusb_dec_video_pes2ts_cb, dec);
327 dec->v_pes_length = 0;
328 dec->v_pes_postbytes = 0;
331 static void ttusb_dec_process_pva(struct ttusb_dec *dec, u8 *pva, int length)
334 printk("%s: packet too short - discarding\n", __FUNCTION__);
338 if (length > 8 + MAX_PVA_LENGTH) {
339 printk("%s: packet too long - discarding\n", __FUNCTION__);
345 case 0x01: { /* VideoStream */
346 int prebytes = pva[5] & 0x03;
347 int postbytes = (pva[5] & 0x0c) >> 2;
348 u16 v_pes_payload_length;
351 dec->video_filter->feed->cb.ts(pva, length, NULL, 0,
352 &dec->video_filter->feed->feed.ts, DMX_OK);
356 if (dec->v_pes_postbytes > 0 &&
357 dec->v_pes_postbytes == prebytes) {
358 memcpy(&dec->v_pes[dec->v_pes_length],
361 dvb_filter_pes2ts(&dec->v_pes2ts, dec->v_pes,
362 dec->v_pes_length + prebytes, 1);
366 dec->v_pes[7] = 0x80;
367 dec->v_pes[8] = 0x05;
369 dec->v_pes[9] = 0x21 | ((pva[8] & 0xc0) >> 5);
370 dec->v_pes[10] = ((pva[8] & 0x3f) << 2) |
371 ((pva[9] & 0xc0) >> 6);
372 dec->v_pes[11] = 0x01 |
373 ((pva[9] & 0x3f) << 2) |
374 ((pva[10] & 0x80) >> 6);
375 dec->v_pes[12] = ((pva[10] & 0x7f) << 1) |
376 ((pva[11] & 0xc0) >> 7);
377 dec->v_pes[13] = 0x01 | ((pva[11] & 0x7f) << 1);
379 memcpy(&dec->v_pes[14], &pva[12 + prebytes],
380 length - 12 - prebytes);
381 dec->v_pes_length = 14 + length - 12 - prebytes;
383 dec->v_pes[7] = 0x00;
384 dec->v_pes[8] = 0x00;
386 memcpy(&dec->v_pes[9], &pva[8], length - 8);
387 dec->v_pes_length = 9 + length - 8;
390 dec->v_pes_postbytes = postbytes;
392 if (dec->v_pes[9 + dec->v_pes[8]] == 0x00 &&
393 dec->v_pes[10 + dec->v_pes[8]] == 0x00 &&
394 dec->v_pes[11 + dec->v_pes[8]] == 0x01)
395 dec->v_pes[6] = 0x84;
397 dec->v_pes[6] = 0x80;
399 v_pes_payload_length = htons(dec->v_pes_length - 6 +
401 memcpy(&dec->v_pes[4], &v_pes_payload_length, 2);
404 dvb_filter_pes2ts(&dec->v_pes2ts, dec->v_pes,
405 dec->v_pes_length, 1);
410 case 0x02: /* MainAudioStream */
412 dec->audio_filter->feed->cb.ts(pva, length, NULL, 0,
413 &dec->audio_filter->feed->feed.ts, DMX_OK);
417 dvb_filter_pes2ts(&dec->a_pes2ts, &pva[8], length - 8,
422 printk("%s: unknown PVA type: %02x.\n", __FUNCTION__,
428 static void ttusb_dec_process_filter(struct ttusb_dec *dec, u8 *packet,
431 struct list_head *item;
432 struct filter_info *finfo;
433 struct dvb_demux_filter *filter = NULL;
438 spin_lock_irqsave(&dec->filter_info_list_lock, flags);
439 for (item = dec->filter_info_list.next; item != &dec->filter_info_list;
441 finfo = list_entry(item, struct filter_info, filter_info_list);
442 if (finfo->stream_id == sid) {
443 filter = finfo->filter;
447 spin_unlock_irqrestore(&dec->filter_info_list_lock, flags);
450 filter->feed->cb.sec(&packet[2], length - 2, NULL, 0,
451 &filter->filter, DMX_OK);
454 static void ttusb_dec_process_packet(struct ttusb_dec *dec)
460 if (dec->packet_length % 2) {
461 printk("%s: odd sized packet - discarding\n", __FUNCTION__);
465 for (i = 0; i < dec->packet_length; i += 2)
466 csum ^= ((dec->packet[i] << 8) + dec->packet[i + 1]);
469 printk("%s: checksum failed - discarding\n", __FUNCTION__);
473 packet_id = dec->packet[dec->packet_length - 4] << 8;
474 packet_id += dec->packet[dec->packet_length - 3];
476 if ((packet_id != dec->next_packet_id) && dec->next_packet_id) {
477 printk("%s: warning: lost packets between %u and %u\n",
478 __FUNCTION__, dec->next_packet_id - 1, packet_id);
481 if (packet_id == 0xffff)
482 dec->next_packet_id = 0x8000;
484 dec->next_packet_id = packet_id + 1;
486 switch (dec->packet_type) {
487 case TTUSB_DEC_PACKET_PVA:
488 if (dec->pva_stream_count)
489 ttusb_dec_process_pva(dec, dec->packet,
490 dec->packet_payload_length);
493 case TTUSB_DEC_PACKET_SECTION:
494 if (dec->filter_stream_count)
495 ttusb_dec_process_filter(dec, dec->packet,
496 dec->packet_payload_length);
499 case TTUSB_DEC_PACKET_EMPTY:
504 static void swap_bytes(u8 *b, int length)
508 length -= length % 2;
509 for (; length; b += 2, length -= 2) {
516 static void ttusb_dec_process_urb_frame(struct ttusb_dec * dec, u8 * b,
519 swap_bytes(b, length);
522 switch (dec->packet_state) {
530 dec->packet_state = 0;
538 dec->packet_length = 0;
539 } else if (*b != 0xaa) {
540 dec->packet_state = 0;
548 dec->packet[dec->packet_length++] = *b++;
550 if (dec->packet_length == 2) {
551 if (dec->packet[0] == 'A' &&
552 dec->packet[1] == 'V') {
554 TTUSB_DEC_PACKET_PVA;
556 } else if (dec->packet[0] == 'S') {
558 TTUSB_DEC_PACKET_SECTION;
560 } else if (dec->packet[0] == 0x00) {
562 TTUSB_DEC_PACKET_EMPTY;
563 dec->packet_payload_length = 2;
564 dec->packet_state = 7;
566 printk("%s: unknown packet type: "
567 "%02x%02x\n", __FUNCTION__,
568 dec->packet[0], dec->packet[1]);
569 dec->packet_state = 0;
577 dec->packet[dec->packet_length++] = *b++;
579 if (dec->packet_type == TTUSB_DEC_PACKET_PVA &&
580 dec->packet_length == 8) {
582 dec->packet_payload_length = 8 +
583 (dec->packet[6] << 8) +
585 } else if (dec->packet_type ==
586 TTUSB_DEC_PACKET_SECTION &&
587 dec->packet_length == 5) {
589 dec->packet_payload_length = 5 +
590 ((dec->packet[3] & 0x0f) << 8) +
598 int remainder = dec->packet_payload_length -
601 if (length >= remainder) {
602 memcpy(dec->packet + dec->packet_length,
604 dec->packet_length += remainder;
609 memcpy(&dec->packet[dec->packet_length],
611 dec->packet_length += length;
621 dec->packet[dec->packet_length++] = *b++;
623 if (dec->packet_type == TTUSB_DEC_PACKET_SECTION &&
624 dec->packet_payload_length % 2)
627 if (dec->packet_length ==
628 dec->packet_payload_length + tail) {
629 ttusb_dec_process_packet(dec);
630 dec->packet_state = 0;
638 printk("%s: illegal packet state encountered.\n",
640 dec->packet_state = 0;
645 static void ttusb_dec_process_urb_frame_list(unsigned long data)
647 struct ttusb_dec *dec = (struct ttusb_dec *)data;
648 struct list_head *item;
649 struct urb_frame *frame;
653 spin_lock_irqsave(&dec->urb_frame_list_lock, flags);
654 if ((item = dec->urb_frame_list.next) != &dec->urb_frame_list) {
655 frame = list_entry(item, struct urb_frame,
657 list_del(&frame->urb_frame_list);
659 spin_unlock_irqrestore(&dec->urb_frame_list_lock,
663 spin_unlock_irqrestore(&dec->urb_frame_list_lock, flags);
665 ttusb_dec_process_urb_frame(dec, frame->data, frame->length);
670 static void ttusb_dec_process_urb(struct urb *urb, struct pt_regs *ptregs)
672 struct ttusb_dec *dec = urb->context;
677 for (i = 0; i < FRAMES_PER_ISO_BUF; i++) {
678 struct usb_iso_packet_descriptor *d;
682 struct urb_frame *frame;
684 d = &urb->iso_frame_desc[i];
685 b = urb->transfer_buffer + d->offset;
686 length = d->actual_length;
688 if ((frame = kmalloc(sizeof(struct urb_frame),
692 memcpy(frame->data, b, length);
693 frame->length = length;
695 spin_lock_irqsave(&dec->urb_frame_list_lock,
697 list_add_tail(&frame->urb_frame_list,
698 &dec->urb_frame_list);
699 spin_unlock_irqrestore(&dec->urb_frame_list_lock,
702 tasklet_schedule(&dec->urb_tasklet);
706 /* -ENOENT is expected when unlinking urbs */
707 if (urb->status != -ENOENT)
708 dprintk("%s: urb error: %d\n", __FUNCTION__,
712 if (dec->iso_stream_count)
713 usb_submit_urb(urb, GFP_ATOMIC);
716 static void ttusb_dec_setup_urbs(struct ttusb_dec *dec)
718 int i, j, buffer_offset = 0;
720 dprintk("%s\n", __FUNCTION__);
722 for (i = 0; i < ISO_BUF_COUNT; i++) {
723 int frame_offset = 0;
724 struct urb *urb = dec->iso_urb[i];
726 urb->dev = dec->udev;
728 urb->complete = ttusb_dec_process_urb;
729 urb->pipe = dec->in_pipe;
730 urb->transfer_flags = URB_ISO_ASAP;
732 urb->number_of_packets = FRAMES_PER_ISO_BUF;
733 urb->transfer_buffer_length = ISO_FRAME_SIZE *
735 urb->transfer_buffer = dec->iso_buffer + buffer_offset;
736 buffer_offset += ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF;
738 for (j = 0; j < FRAMES_PER_ISO_BUF; j++) {
739 urb->iso_frame_desc[j].offset = frame_offset;
740 urb->iso_frame_desc[j].length = ISO_FRAME_SIZE;
741 frame_offset += ISO_FRAME_SIZE;
746 static void ttusb_dec_stop_iso_xfer(struct ttusb_dec *dec)
750 dprintk("%s\n", __FUNCTION__);
752 if (down_interruptible(&dec->iso_sem))
755 dec->iso_stream_count--;
757 if (!dec->iso_stream_count) {
758 for (i = 0; i < ISO_BUF_COUNT; i++)
759 usb_unlink_urb(dec->iso_urb[i]);
765 /* Setting the interface of the DEC tends to take down the USB communications
766 * for a short period, so it's important not to call this function just before
767 * trying to talk to it.
769 static int ttusb_dec_set_interface(struct ttusb_dec *dec,
770 enum ttusb_dec_interface interface)
775 if (interface != dec->interface) {
777 case TTUSB_DEC_INTERFACE_INITIAL:
778 result = usb_set_interface(dec->udev, 0, 0);
780 case TTUSB_DEC_INTERFACE_IN:
781 result = ttusb_dec_send_command(dec, 0x80, sizeof(b),
785 result = usb_set_interface(dec->udev, 0, 7);
787 case TTUSB_DEC_INTERFACE_OUT:
788 result = usb_set_interface(dec->udev, 0, 1);
795 dec->interface = interface;
801 static int ttusb_dec_start_iso_xfer(struct ttusb_dec *dec)
805 dprintk("%s\n", __FUNCTION__);
807 if (down_interruptible(&dec->iso_sem))
810 if (!dec->iso_stream_count) {
811 ttusb_dec_setup_urbs(dec);
813 dec->packet_state = 0;
814 dec->v_pes_postbytes = 0;
815 dec->next_packet_id = 0;
817 for (i = 0; i < ISO_BUF_COUNT; i++) {
818 if ((result = usb_submit_urb(dec->iso_urb[i],
820 printk("%s: failed urb submission %d: "
821 "error %d\n", __FUNCTION__, i, result);
824 usb_unlink_urb(dec->iso_urb[i - 1]);
834 dec->iso_stream_count++;
841 static int ttusb_dec_start_ts_feed(struct dvb_demux_feed *dvbdmxfeed)
843 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
844 struct ttusb_dec *dec = dvbdmx->priv;
848 dprintk("%s\n", __FUNCTION__);
850 dprintk(" ts_type:");
852 if (dvbdmxfeed->ts_type & TS_DECODER)
853 dprintk(" TS_DECODER");
855 if (dvbdmxfeed->ts_type & TS_PACKET)
856 dprintk(" TS_PACKET");
858 if (dvbdmxfeed->ts_type & TS_PAYLOAD_ONLY)
859 dprintk(" TS_PAYLOAD_ONLY");
863 switch (dvbdmxfeed->pes_type) {
865 case DMX_TS_PES_VIDEO:
866 dprintk(" pes_type: DMX_TS_PES_VIDEO\n");
867 dec->pid[DMX_PES_PCR] = dvbdmxfeed->pid;
868 dec->pid[DMX_PES_VIDEO] = dvbdmxfeed->pid;
869 dec->video_filter = dvbdmxfeed->filter;
870 ttusb_dec_set_pids(dec);
873 case DMX_TS_PES_AUDIO:
874 dprintk(" pes_type: DMX_TS_PES_AUDIO\n");
875 dec->pid[DMX_PES_AUDIO] = dvbdmxfeed->pid;
876 dec->audio_filter = dvbdmxfeed->filter;
877 ttusb_dec_set_pids(dec);
880 case DMX_TS_PES_TELETEXT:
881 dec->pid[DMX_PES_TELETEXT] = dvbdmxfeed->pid;
882 dprintk(" pes_type: DMX_TS_PES_TELETEXT\n");
886 dprintk(" pes_type: DMX_TS_PES_PCR\n");
887 dec->pid[DMX_PES_PCR] = dvbdmxfeed->pid;
888 ttusb_dec_set_pids(dec);
891 case DMX_TS_PES_OTHER:
892 dprintk(" pes_type: DMX_TS_PES_OTHER\n");
896 dprintk(" pes_type: unknown (%d)\n", dvbdmxfeed->pes_type);
901 result = ttusb_dec_send_command(dec, 0x80, sizeof(b0), b0, NULL, NULL);
905 dec->pva_stream_count++;
906 return ttusb_dec_start_iso_xfer(dec);
909 static int ttusb_dec_start_sec_feed(struct dvb_demux_feed *dvbdmxfeed)
911 struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
912 u8 b0[] = { 0x00, 0x00, 0x00, 0x01,
913 0x00, 0x00, 0x00, 0x00,
914 0x00, 0x00, 0x00, 0x00,
915 0x00, 0x00, 0x00, 0x00,
916 0x00, 0xff, 0x00, 0x00,
917 0x00, 0x00, 0x00, 0x00,
918 0x00, 0x00, 0x00, 0x00,
921 u8 c[COMMAND_PACKET_SIZE];
924 struct filter_info *finfo;
928 dprintk("%s\n", __FUNCTION__);
930 pid = htons(dvbdmxfeed->pid);
931 memcpy(&b0[0], &pid, 2);
932 memcpy(&b0[4], &x, 1);
933 memcpy(&b0[5], &dvbdmxfeed->filter->filter.filter_value[0], 1);
935 result = ttusb_dec_send_command(dec, 0x60, sizeof(b0), b0,
940 if (!(finfo = kmalloc(sizeof(struct filter_info),
944 finfo->stream_id = c[1];
945 finfo->filter = dvbdmxfeed->filter;
947 spin_lock_irqsave(&dec->filter_info_list_lock, flags);
948 list_add_tail(&finfo->filter_info_list,
949 &dec->filter_info_list);
950 spin_unlock_irqrestore(&dec->filter_info_list_lock,
953 dvbdmxfeed->priv = finfo;
955 dec->filter_stream_count++;
956 return ttusb_dec_start_iso_xfer(dec);
964 static int ttusb_dec_start_feed(struct dvb_demux_feed *dvbdmxfeed)
966 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
968 dprintk("%s\n", __FUNCTION__);
970 if (!dvbdmx->dmx.frontend)
973 dprintk(" pid: 0x%04X\n", dvbdmxfeed->pid);
975 switch (dvbdmxfeed->type) {
978 return ttusb_dec_start_ts_feed(dvbdmxfeed);
982 return ttusb_dec_start_sec_feed(dvbdmxfeed);
986 dprintk(" type: unknown (%d)\n", dvbdmxfeed->type);
992 static int ttusb_dec_stop_ts_feed(struct dvb_demux_feed *dvbdmxfeed)
994 struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
997 ttusb_dec_send_command(dec, 0x81, sizeof(b0), b0, NULL, NULL);
999 dec->pva_stream_count--;
1001 ttusb_dec_stop_iso_xfer(dec);
1006 static int ttusb_dec_stop_sec_feed(struct dvb_demux_feed *dvbdmxfeed)
1008 struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
1009 u8 b0[] = { 0x00, 0x00 };
1010 struct filter_info *finfo = (struct filter_info *)dvbdmxfeed->priv;
1011 unsigned long flags;
1013 b0[1] = finfo->stream_id;
1014 spin_lock_irqsave(&dec->filter_info_list_lock, flags);
1015 list_del(&finfo->filter_info_list);
1016 spin_unlock_irqrestore(&dec->filter_info_list_lock, flags);
1018 ttusb_dec_send_command(dec, 0x62, sizeof(b0), b0, NULL, NULL);
1020 dec->filter_stream_count--;
1022 ttusb_dec_stop_iso_xfer(dec);
1027 static int ttusb_dec_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
1029 dprintk("%s\n", __FUNCTION__);
1031 switch (dvbdmxfeed->type) {
1033 return ttusb_dec_stop_ts_feed(dvbdmxfeed);
1037 return ttusb_dec_stop_sec_feed(dvbdmxfeed);
1044 static void ttusb_dec_free_iso_urbs(struct ttusb_dec *dec)
1048 dprintk("%s\n", __FUNCTION__);
1050 for (i = 0; i < ISO_BUF_COUNT; i++)
1051 if (dec->iso_urb[i])
1052 usb_free_urb(dec->iso_urb[i]);
1054 pci_free_consistent(NULL,
1055 ISO_FRAME_SIZE * (FRAMES_PER_ISO_BUF *
1057 dec->iso_buffer, dec->iso_dma_handle);
1060 static int ttusb_dec_alloc_iso_urbs(struct ttusb_dec *dec)
1064 dprintk("%s\n", __FUNCTION__);
1066 dec->iso_buffer = pci_alloc_consistent(NULL,
1068 (FRAMES_PER_ISO_BUF *
1070 &dec->iso_dma_handle);
1072 memset(dec->iso_buffer, 0,
1073 ISO_FRAME_SIZE * (FRAMES_PER_ISO_BUF * ISO_BUF_COUNT));
1075 for (i = 0; i < ISO_BUF_COUNT; i++) {
1078 if (!(urb = usb_alloc_urb(FRAMES_PER_ISO_BUF, GFP_ATOMIC))) {
1079 ttusb_dec_free_iso_urbs(dec);
1083 dec->iso_urb[i] = urb;
1086 ttusb_dec_setup_urbs(dec);
1091 static void ttusb_dec_init_tasklet(struct ttusb_dec *dec)
1093 dec->urb_frame_list_lock = SPIN_LOCK_UNLOCKED;
1094 INIT_LIST_HEAD(&dec->urb_frame_list);
1095 tasklet_init(&dec->urb_tasklet, ttusb_dec_process_urb_frame_list,
1096 (unsigned long)dec);
1099 static void ttusb_dec_init_v_pes(struct ttusb_dec *dec)
1101 dprintk("%s\n", __FUNCTION__);
1103 dec->v_pes[0] = 0x00;
1104 dec->v_pes[1] = 0x00;
1105 dec->v_pes[2] = 0x01;
1106 dec->v_pes[3] = 0xe0;
1109 static void ttusb_dec_init_usb(struct ttusb_dec *dec)
1111 dprintk("%s\n", __FUNCTION__);
1113 sema_init(&dec->usb_sem, 1);
1114 sema_init(&dec->iso_sem, 1);
1116 dec->command_pipe = usb_sndbulkpipe(dec->udev, COMMAND_PIPE);
1117 dec->result_pipe = usb_rcvbulkpipe(dec->udev, RESULT_PIPE);
1118 dec->in_pipe = usb_rcvisocpipe(dec->udev, IN_PIPE);
1119 dec->out_pipe = usb_sndisocpipe(dec->udev, OUT_PIPE);
1121 ttusb_dec_alloc_iso_urbs(dec);
1124 static int ttusb_dec_boot_dsp(struct ttusb_dec *dec)
1126 int i, j, actual_len, result, size, trans_count;
1127 u8 b0[] = { 0x00, 0x00, 0x00, 0x00,
1128 0x00, 0x00, 0x00, 0x00,
1133 u8 *firmware = NULL;
1134 size_t firmware_size = 0;
1135 u16 firmware_csum = 0;
1136 u16 firmware_csum_ns;
1137 u32 firmware_size_nl;
1138 u32 crc32_csum, crc32_check, tmp;
1139 const struct firmware *fw_entry = NULL;
1141 dprintk("%s\n", __FUNCTION__);
1143 if (request_firmware(&fw_entry, dec->firmware_name, &dec->udev->dev)) {
1144 printk(KERN_ERR "%s: Firmware (%s) unavailable.\n",
1145 __FUNCTION__, dec->firmware_name);
1149 firmware = fw_entry->data;
1150 firmware_size = fw_entry->size;
1152 if (firmware_size < 60) {
1153 printk("%s: firmware size too small for DSP code (%zu < 60).\n",
1154 __FUNCTION__, firmware_size);
1158 /* a 32 bit checksum over the first 56 bytes of the DSP Code is stored
1159 at offset 56 of file, so use it to check if the firmware file is
1161 crc32_csum = crc32(~0L, firmware, 56) ^ ~0L;
1162 memcpy(&tmp, &firmware[56], 4);
1163 crc32_check = htonl(tmp);
1164 if (crc32_csum != crc32_check) {
1165 printk("%s: crc32 check of DSP code failed (calculated "
1166 "0x%08x != 0x%08x in file), file invalid.\n",
1167 __FUNCTION__, crc32_csum, crc32_check);
1170 memcpy(idstring, &firmware[36], 20);
1171 idstring[20] = '\0';
1172 printk(KERN_INFO "ttusb_dec: found DSP code \"%s\".\n", idstring);
1174 firmware_size_nl = htonl(firmware_size);
1175 memcpy(b0, &firmware_size_nl, 4);
1176 firmware_csum = crc16(~0, firmware, firmware_size) ^ ~0;
1177 firmware_csum_ns = htons(firmware_csum);
1178 memcpy(&b0[6], &firmware_csum_ns, 2);
1180 result = ttusb_dec_send_command(dec, 0x41, sizeof(b0), b0, NULL, NULL);
1188 b = kmalloc(ARM_PACKET_SIZE, GFP_KERNEL);
1192 for (i = 0; i < firmware_size; i += COMMAND_PACKET_SIZE) {
1193 size = firmware_size - i;
1194 if (size > COMMAND_PACKET_SIZE)
1195 size = COMMAND_PACKET_SIZE;
1198 b[j + 1] = trans_count++;
1201 memcpy(&b[j + 4], &firmware[i], size);
1203 j += COMMAND_PACKET_SIZE + 4;
1205 if (j >= ARM_PACKET_SIZE) {
1206 result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
1207 ARM_PACKET_SIZE, &actual_len,
1210 } else if (size < COMMAND_PACKET_SIZE) {
1211 result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
1212 j - COMMAND_PACKET_SIZE + size,
1213 &actual_len, HZ / 10);
1217 result = ttusb_dec_send_command(dec, 0x43, sizeof(b1), b1, NULL, NULL);
1224 static int ttusb_dec_init_stb(struct ttusb_dec *dec)
1227 unsigned int mode, model, version;
1229 dprintk("%s\n", __FUNCTION__);
1231 result = ttusb_dec_get_stb_state(dec, &mode, &model, &version);
1235 if (version == 0xABCDEFAB)
1236 printk(KERN_INFO "ttusb_dec: no version "
1237 "info in Firmware\n");
1239 printk(KERN_INFO "ttusb_dec: Firmware "
1241 version >> 24, (version >> 16) & 0xff,
1242 (version >> 8) & 0xff, version & 0xff);
1244 result = ttusb_dec_boot_dsp(dec);
1250 /* We can't trust the USB IDs that some firmwares
1255 ttusb_dec_set_model(dec, TTUSB_DEC3000S);
1259 ttusb_dec_set_model(dec, TTUSB_DEC2000T);
1262 ttusb_dec_set_model(dec, TTUSB_DEC2540T);
1265 printk(KERN_ERR "%s: unknown model returned "
1266 "by firmware (%08x) - please report\n",
1267 __FUNCTION__, model);
1272 if (version >= 0x01770000)
1273 dec->can_playback = 1;
1282 static int ttusb_dec_init_dvb(struct ttusb_dec *dec)
1286 dprintk("%s\n", __FUNCTION__);
1288 if ((result = dvb_register_adapter(&dec->adapter,
1289 dec->model_name, THIS_MODULE)) < 0) {
1290 printk("%s: dvb_register_adapter failed: error %d\n",
1291 __FUNCTION__, result);
1296 dec->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING;
1298 dec->demux.priv = (void *)dec;
1299 dec->demux.filternum = 31;
1300 dec->demux.feednum = 31;
1301 dec->demux.start_feed = ttusb_dec_start_feed;
1302 dec->demux.stop_feed = ttusb_dec_stop_feed;
1303 dec->demux.write_to_decoder = NULL;
1305 if ((result = dvb_dmx_init(&dec->demux)) < 0) {
1306 printk("%s: dvb_dmx_init failed: error %d\n", __FUNCTION__,
1309 dvb_unregister_adapter(dec->adapter);
1314 dec->dmxdev.filternum = 32;
1315 dec->dmxdev.demux = &dec->demux.dmx;
1316 dec->dmxdev.capabilities = 0;
1318 if ((result = dvb_dmxdev_init(&dec->dmxdev, dec->adapter)) < 0) {
1319 printk("%s: dvb_dmxdev_init failed: error %d\n",
1320 __FUNCTION__, result);
1322 dvb_dmx_release(&dec->demux);
1323 dvb_unregister_adapter(dec->adapter);
1328 dec->frontend.source = DMX_FRONTEND_0;
1330 if ((result = dec->demux.dmx.add_frontend(&dec->demux.dmx,
1331 &dec->frontend)) < 0) {
1332 printk("%s: dvb_dmx_init failed: error %d\n", __FUNCTION__,
1335 dvb_dmxdev_release(&dec->dmxdev);
1336 dvb_dmx_release(&dec->demux);
1337 dvb_unregister_adapter(dec->adapter);
1342 if ((result = dec->demux.dmx.connect_frontend(&dec->demux.dmx,
1343 &dec->frontend)) < 0) {
1344 printk("%s: dvb_dmx_init failed: error %d\n", __FUNCTION__,
1347 dec->demux.dmx.remove_frontend(&dec->demux.dmx, &dec->frontend);
1348 dvb_dmxdev_release(&dec->dmxdev);
1349 dvb_dmx_release(&dec->demux);
1350 dvb_unregister_adapter(dec->adapter);
1355 dvb_net_init(dec->adapter, &dec->dvb_net, &dec->demux.dmx);
1360 static void ttusb_dec_exit_dvb(struct ttusb_dec *dec)
1362 dprintk("%s\n", __FUNCTION__);
1364 dvb_net_release(&dec->dvb_net);
1365 dec->demux.dmx.close(&dec->demux.dmx);
1366 dec->demux.dmx.remove_frontend(&dec->demux.dmx, &dec->frontend);
1367 dvb_dmxdev_release(&dec->dmxdev);
1368 dvb_dmx_release(&dec->demux);
1369 if (dec->fe) dvb_unregister_frontend(dec->fe);
1370 dvb_unregister_adapter(dec->adapter);
1373 static void ttusb_dec_exit_usb(struct ttusb_dec *dec)
1377 dprintk("%s\n", __FUNCTION__);
1379 dec->iso_stream_count = 0;
1381 for (i = 0; i < ISO_BUF_COUNT; i++)
1382 usb_unlink_urb(dec->iso_urb[i]);
1384 ttusb_dec_free_iso_urbs(dec);
1387 static void ttusb_dec_exit_tasklet(struct ttusb_dec *dec)
1389 struct list_head *item;
1390 struct urb_frame *frame;
1392 tasklet_kill(&dec->urb_tasklet);
1394 while ((item = dec->urb_frame_list.next) != &dec->urb_frame_list) {
1395 frame = list_entry(item, struct urb_frame, urb_frame_list);
1396 list_del(&frame->urb_frame_list);
1401 static void ttusb_dec_init_filters(struct ttusb_dec *dec)
1403 INIT_LIST_HEAD(&dec->filter_info_list);
1404 dec->filter_info_list_lock = SPIN_LOCK_UNLOCKED;
1407 static void ttusb_dec_exit_filters(struct ttusb_dec *dec)
1409 struct list_head *item;
1410 struct filter_info *finfo;
1412 while ((item = dec->filter_info_list.next) != &dec->filter_info_list) {
1413 finfo = list_entry(item, struct filter_info, filter_info_list);
1414 list_del(&finfo->filter_info_list);
1419 int fe_send_command(struct dvb_frontend* fe, const u8 command,
1420 int param_length, const u8 params[],
1421 int *result_length, u8 cmd_result[])
1423 struct ttusb_dec* dec = (struct ttusb_dec*) fe->dvb->priv;
1424 return ttusb_dec_send_command(dec, command, param_length, params, result_length, cmd_result);
1427 struct ttusbdecfe_config fe_config = {
1428 .send_command = fe_send_command
1431 static int ttusb_dec_probe(struct usb_interface *intf,
1432 const struct usb_device_id *id)
1434 struct usb_device *udev;
1435 struct ttusb_dec *dec;
1437 dprintk("%s\n", __FUNCTION__);
1439 udev = interface_to_usbdev(intf);
1441 if (!(dec = kmalloc(sizeof(struct ttusb_dec), GFP_KERNEL))) {
1442 printk("%s: couldn't allocate memory.\n", __FUNCTION__);
1446 usb_set_intfdata(intf, (void *)dec);
1448 memset(dec, 0, sizeof(struct ttusb_dec));
1450 switch (id->idProduct) {
1452 ttusb_dec_set_model(dec, TTUSB_DEC3000S);
1456 ttusb_dec_set_model(dec, TTUSB_DEC2000T);
1460 ttusb_dec_set_model(dec, TTUSB_DEC2540T);
1466 ttusb_dec_init_usb(dec);
1467 if (ttusb_dec_init_stb(dec)) {
1468 ttusb_dec_exit_usb(dec);
1471 ttusb_dec_init_dvb(dec);
1473 dec->adapter->priv = dec;
1474 switch (id->idProduct) {
1476 dec->fe = ttusbdecfe_dvbs_attach(&fe_config);
1481 dec->fe = ttusbdecfe_dvbt_attach(&fe_config);
1485 if (dec->fe == NULL) {
1486 printk("dvb-ttusb-dec: A frontend driver was not found for device %04x/%04x\n",
1487 dec->udev->descriptor.idVendor,
1488 dec->udev->descriptor.idProduct);
1490 if (dvb_register_frontend(dec->adapter, dec->fe)) {
1491 printk("budget-ci: Frontend registration failed!\n");
1492 if (dec->fe->ops->release)
1493 dec->fe->ops->release(dec->fe);
1498 ttusb_dec_init_v_pes(dec);
1499 ttusb_dec_init_filters(dec);
1500 ttusb_dec_init_tasklet(dec);
1504 ttusb_dec_set_interface(dec, TTUSB_DEC_INTERFACE_IN);
1509 static void ttusb_dec_disconnect(struct usb_interface *intf)
1511 struct ttusb_dec *dec = usb_get_intfdata(intf);
1513 usb_set_intfdata(intf, NULL);
1515 dprintk("%s\n", __FUNCTION__);
1518 ttusb_dec_exit_tasklet(dec);
1519 ttusb_dec_exit_filters(dec);
1520 ttusb_dec_exit_usb(dec);
1521 ttusb_dec_exit_dvb(dec);
1527 static void ttusb_dec_set_model(struct ttusb_dec *dec,
1528 enum ttusb_dec_model model)
1533 case TTUSB_DEC2000T:
1534 dec->model_name = "DEC2000-t";
1535 dec->firmware_name = "dvb-ttusb-dec-2000t.fw";
1538 case TTUSB_DEC2540T:
1539 dec->model_name = "DEC2540-t";
1540 dec->firmware_name = "dvb-ttusb-dec-2540t.fw";
1543 case TTUSB_DEC3000S:
1544 dec->model_name = "DEC3000-s";
1545 dec->firmware_name = "dvb-ttusb-dec-3000s.fw";
1550 static struct usb_device_id ttusb_dec_table[] = {
1551 {USB_DEVICE(0x0b48, 0x1006)}, /* DEC3000-s */
1552 /*{USB_DEVICE(0x0b48, 0x1007)}, Unconfirmed */
1553 {USB_DEVICE(0x0b48, 0x1008)}, /* DEC2000-t */
1554 {USB_DEVICE(0x0b48, 0x1009)}, /* DEC2540-t */
1558 static struct usb_driver ttusb_dec_driver = {
1559 .name = "ttusb-dec",
1560 .probe = ttusb_dec_probe,
1561 .disconnect = ttusb_dec_disconnect,
1562 .id_table = ttusb_dec_table,
1565 static int __init ttusb_dec_init(void)
1569 if ((result = usb_register(&ttusb_dec_driver)) < 0) {
1570 printk("%s: initialisation failed: error %d.\n", __FUNCTION__,
1578 static void __exit ttusb_dec_exit(void)
1580 usb_deregister(&ttusb_dec_driver);
1583 module_init(ttusb_dec_init);
1584 module_exit(ttusb_dec_exit);
1586 MODULE_AUTHOR("Alex Woods <linux-dvb@giblets.org>");
1587 MODULE_DESCRIPTION(DRIVER_NAME);
1588 MODULE_LICENSE("GPL");
1589 MODULE_DEVICE_TABLE(usb, ttusb_dec_table);