1 // SPDX-License-Identifier: GPL-2.0-or-later
5 * Copyright (C) 2003-2004 Alex Woods <linux-dvb@giblets.org>
6 * IR support by Peter Beutner <p.beutner@gmx.net>
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>
21 #include <linux/mutex.h>
23 #include <media/dmxdev.h>
24 #include <media/dvb_demux.h>
25 #include <media/dvb_frontend.h>
26 #include <media/dvb_net.h>
27 #include "ttusbdecfe.h"
30 static int output_pva;
33 module_param(debug, int, 0644);
34 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
35 module_param(output_pva, int, 0444);
36 MODULE_PARM_DESC(output_pva, "Output PVA from dvr device (default:off)");
37 module_param(enable_rc, int, 0644);
38 MODULE_PARM_DESC(enable_rc, "Turn on/off IR remote control(default: off)");
40 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
42 #define dprintk if (debug) printk
44 #define DRIVER_NAME "TechnoTrend/Hauppauge DEC USB"
46 #define COMMAND_PIPE 0x03
47 #define RESULT_PIPE 0x04
52 #define COMMAND_PACKET_SIZE 0x3c
53 #define ARM_PACKET_SIZE 0x1000
54 #define IRQ_PACKET_SIZE 0x8
56 #define ISO_BUF_COUNT 0x04
57 #define FRAMES_PER_ISO_BUF 0x04
58 #define ISO_FRAME_SIZE 0x0380
60 #define MAX_PVA_LENGTH 6144
62 enum ttusb_dec_model {
68 enum ttusb_dec_packet_type {
70 TTUSB_DEC_PACKET_SECTION,
71 TTUSB_DEC_PACKET_EMPTY
74 enum ttusb_dec_interface {
75 TTUSB_DEC_INTERFACE_INITIAL,
76 TTUSB_DEC_INTERFACE_IN,
77 TTUSB_DEC_INTERFACE_OUT
80 typedef int (dvb_filter_pes2ts_cb_t) (void *, unsigned char *);
82 struct dvb_filter_pes2ts {
83 unsigned char buf[188];
85 dvb_filter_pes2ts_cb_t *cb;
90 enum ttusb_dec_model model;
96 struct dvb_adapter adapter;
98 struct dvb_demux demux;
99 struct dmx_frontend frontend;
100 struct dvb_net dvb_net;
101 struct dvb_frontend* fe;
103 u16 pid[DMX_PES_OTHER];
106 struct usb_device *udev;
108 unsigned int command_pipe;
109 unsigned int result_pipe;
110 unsigned int in_pipe;
111 unsigned int out_pipe;
112 unsigned int irq_pipe;
113 enum ttusb_dec_interface interface;
114 struct mutex usb_mutex;
118 dma_addr_t irq_dma_handle;
120 struct urb *iso_urb[ISO_BUF_COUNT];
121 int iso_stream_count;
122 struct mutex iso_mutex;
124 u8 packet[MAX_PVA_LENGTH + 4];
125 enum ttusb_dec_packet_type packet_type;
128 int packet_payload_length;
131 int pva_stream_count;
132 int filter_stream_count;
134 struct dvb_filter_pes2ts a_pes2ts;
135 struct dvb_filter_pes2ts v_pes2ts;
137 u8 v_pes[16 + MAX_PVA_LENGTH];
141 struct list_head urb_frame_list;
142 struct tasklet_struct urb_tasklet;
143 spinlock_t urb_frame_list_lock;
145 struct dvb_demux_filter *audio_filter;
146 struct dvb_demux_filter *video_filter;
147 struct list_head filter_info_list;
148 spinlock_t filter_info_list_lock;
150 struct input_dev *rc_input_dev;
153 int active; /* Loaded successfully */
157 u8 data[ISO_FRAME_SIZE];
159 struct list_head urb_frame_list;
164 struct dvb_demux_filter *filter;
165 struct list_head filter_info_list;
168 static u16 rc_keys[] = {
197 static void dvb_filter_pes2ts_init(struct dvb_filter_pes2ts *p2ts,
199 dvb_filter_pes2ts_cb_t *cb, void *priv)
201 unsigned char *buf=p2ts->buf;
211 static int dvb_filter_pes2ts(struct dvb_filter_pes2ts *p2ts,
212 unsigned char *pes, int len, int payload_start)
214 unsigned char *buf=p2ts->buf;
217 //len=6+((pes[4]<<8)|pes[5]);
224 buf[3]=0x10|((p2ts->cc++)&0x0f);
225 memcpy(buf+4, pes, 184);
226 if ((ret=p2ts->cb(p2ts->priv, buf)))
233 buf[3]=0x30|((p2ts->cc++)&0x0f);
238 memset(buf+6, 0xff, rest-1);
241 memcpy(buf+5+rest, pes, len);
242 return p2ts->cb(p2ts->priv, buf);
245 static void ttusb_dec_set_model(struct ttusb_dec *dec,
246 enum ttusb_dec_model model);
248 static void ttusb_dec_handle_irq( struct urb *urb)
250 struct ttusb_dec *dec = urb->context;
251 char *buffer = dec->irq_buffer;
253 int index = buffer[4];
255 switch(urb->status) {
262 /* this urb is dead, cleanup */
263 dprintk("%s:urb shutting down with status: %d\n",
264 __func__, urb->status);
267 dprintk("%s:nonzero status received: %d\n",
268 __func__,urb->status);
272 if ((buffer[0] == 0x1) && (buffer[2] == 0x15)) {
276 * this is an fact a bit too simple implementation;
277 * the box also reports a keyrepeat signal
278 * (with buffer[3] == 0x40) in an interval of ~100ms.
279 * But to handle this correctly we had to imlemenent some
280 * kind of timer which signals a 'key up' event if no
281 * keyrepeat signal is received for lets say 200ms.
282 * this should/could be added later ...
283 * for now lets report each signal as a key down and up
285 if (index - 1 < ARRAY_SIZE(rc_keys)) {
286 dprintk("%s:rc signal:%d\n", __func__, index);
287 input_report_key(dec->rc_input_dev, rc_keys[index - 1], 1);
288 input_sync(dec->rc_input_dev);
289 input_report_key(dec->rc_input_dev, rc_keys[index - 1], 0);
290 input_sync(dec->rc_input_dev);
295 retval = usb_submit_urb(urb, GFP_ATOMIC);
297 printk("%s - usb_commit_urb failed with result: %d\n",
301 static u16 crc16(u16 crc, const u8 *buf, size_t len)
309 crc ^= (tmp ^ (tmp << 1)) << 4;
314 static int ttusb_dec_send_command(struct ttusb_dec *dec, const u8 command,
315 int param_length, const u8 params[],
316 int *result_length, u8 cmd_result[])
318 int result, actual_len;
321 dprintk("%s\n", __func__);
323 b = kzalloc(COMMAND_PACKET_SIZE + 4, GFP_KERNEL);
327 result = mutex_lock_interruptible(&dec->usb_mutex);
329 printk("%s: Failed to lock usb mutex.\n", __func__);
334 b[1] = ++dec->trans_count;
339 memcpy(&b[4], params, param_length);
342 printk(KERN_DEBUG "%s: command: %*ph\n",
343 __func__, param_length, b);
346 result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
347 COMMAND_PACKET_SIZE + 4, &actual_len, 1000);
350 printk("%s: command bulk message failed: error %d\n",
352 goto err_mutex_unlock;
355 result = usb_bulk_msg(dec->udev, dec->result_pipe, b,
356 COMMAND_PACKET_SIZE + 4, &actual_len, 1000);
359 printk("%s: result bulk message failed: error %d\n",
361 goto err_mutex_unlock;
364 printk(KERN_DEBUG "%s: result: %*ph\n",
365 __func__, actual_len, b);
369 *result_length = b[3];
370 if (cmd_result && b[3] > 0)
371 memcpy(cmd_result, &b[4], b[3]);
375 mutex_unlock(&dec->usb_mutex);
381 static int ttusb_dec_get_stb_state (struct ttusb_dec *dec, unsigned int *mode,
382 unsigned int *model, unsigned int *version)
384 u8 c[COMMAND_PACKET_SIZE];
389 dprintk("%s\n", __func__);
391 result = ttusb_dec_send_command(dec, 0x08, 0, NULL, &c_length, c);
395 if (c_length >= 0x0c) {
401 memcpy(&tmp, &c[4], 4);
404 if (version != NULL) {
405 memcpy(&tmp, &c[8], 4);
406 *version = ntohl(tmp);
414 static int ttusb_dec_audio_pes2ts_cb(void *priv, unsigned char *data)
416 struct ttusb_dec *dec = priv;
418 dec->audio_filter->feed->cb.ts(data, 188, NULL, 0,
419 &dec->audio_filter->feed->feed.ts, NULL);
424 static int ttusb_dec_video_pes2ts_cb(void *priv, unsigned char *data)
426 struct ttusb_dec *dec = priv;
428 dec->video_filter->feed->cb.ts(data, 188, NULL, 0,
429 &dec->video_filter->feed->feed.ts, NULL);
434 static void ttusb_dec_set_pids(struct ttusb_dec *dec)
436 u8 b[] = { 0x00, 0x00, 0x00, 0x00,
437 0x00, 0x00, 0xff, 0xff,
438 0xff, 0xff, 0xff, 0xff };
440 __be16 pcr = htons(dec->pid[DMX_PES_PCR]);
441 __be16 audio = htons(dec->pid[DMX_PES_AUDIO]);
442 __be16 video = htons(dec->pid[DMX_PES_VIDEO]);
444 dprintk("%s\n", __func__);
446 memcpy(&b[0], &pcr, 2);
447 memcpy(&b[2], &audio, 2);
448 memcpy(&b[4], &video, 2);
450 ttusb_dec_send_command(dec, 0x50, sizeof(b), b, NULL, NULL);
452 dvb_filter_pes2ts_init(&dec->a_pes2ts, dec->pid[DMX_PES_AUDIO],
453 ttusb_dec_audio_pes2ts_cb, dec);
454 dvb_filter_pes2ts_init(&dec->v_pes2ts, dec->pid[DMX_PES_VIDEO],
455 ttusb_dec_video_pes2ts_cb, dec);
456 dec->v_pes_length = 0;
457 dec->v_pes_postbytes = 0;
460 static void ttusb_dec_process_pva(struct ttusb_dec *dec, u8 *pva, int length)
463 printk("%s: packet too short - discarding\n", __func__);
467 if (length > 8 + MAX_PVA_LENGTH) {
468 printk("%s: packet too long - discarding\n", __func__);
474 case 0x01: { /* VideoStream */
475 int prebytes = pva[5] & 0x03;
476 int postbytes = (pva[5] & 0x0c) >> 2;
477 __be16 v_pes_payload_length;
480 dec->video_filter->feed->cb.ts(pva, length, NULL, 0,
481 &dec->video_filter->feed->feed.ts, NULL);
485 if (dec->v_pes_postbytes > 0 &&
486 dec->v_pes_postbytes == prebytes) {
487 memcpy(&dec->v_pes[dec->v_pes_length],
490 dvb_filter_pes2ts(&dec->v_pes2ts, dec->v_pes,
491 dec->v_pes_length + prebytes, 1);
495 dec->v_pes[7] = 0x80;
496 dec->v_pes[8] = 0x05;
498 dec->v_pes[9] = 0x21 | ((pva[8] & 0xc0) >> 5);
499 dec->v_pes[10] = ((pva[8] & 0x3f) << 2) |
500 ((pva[9] & 0xc0) >> 6);
501 dec->v_pes[11] = 0x01 |
502 ((pva[9] & 0x3f) << 2) |
503 ((pva[10] & 0x80) >> 6);
504 dec->v_pes[12] = ((pva[10] & 0x7f) << 1) |
505 ((pva[11] & 0xc0) >> 7);
506 dec->v_pes[13] = 0x01 | ((pva[11] & 0x7f) << 1);
508 memcpy(&dec->v_pes[14], &pva[12 + prebytes],
509 length - 12 - prebytes);
510 dec->v_pes_length = 14 + length - 12 - prebytes;
512 dec->v_pes[7] = 0x00;
513 dec->v_pes[8] = 0x00;
515 memcpy(&dec->v_pes[9], &pva[8], length - 8);
516 dec->v_pes_length = 9 + length - 8;
519 dec->v_pes_postbytes = postbytes;
521 if (dec->v_pes[9 + dec->v_pes[8]] == 0x00 &&
522 dec->v_pes[10 + dec->v_pes[8]] == 0x00 &&
523 dec->v_pes[11 + dec->v_pes[8]] == 0x01)
524 dec->v_pes[6] = 0x84;
526 dec->v_pes[6] = 0x80;
528 v_pes_payload_length = htons(dec->v_pes_length - 6 +
530 memcpy(&dec->v_pes[4], &v_pes_payload_length, 2);
533 dvb_filter_pes2ts(&dec->v_pes2ts, dec->v_pes,
534 dec->v_pes_length, 1);
539 case 0x02: /* MainAudioStream */
541 dec->audio_filter->feed->cb.ts(pva, length, NULL, 0,
542 &dec->audio_filter->feed->feed.ts, NULL);
546 dvb_filter_pes2ts(&dec->a_pes2ts, &pva[8], length - 8,
551 printk("%s: unknown PVA type: %02x.\n", __func__,
557 static void ttusb_dec_process_filter(struct ttusb_dec *dec, u8 *packet,
560 struct list_head *item;
561 struct filter_info *finfo;
562 struct dvb_demux_filter *filter = NULL;
567 spin_lock_irqsave(&dec->filter_info_list_lock, flags);
568 for (item = dec->filter_info_list.next; item != &dec->filter_info_list;
570 finfo = list_entry(item, struct filter_info, filter_info_list);
571 if (finfo->stream_id == sid) {
572 filter = finfo->filter;
576 spin_unlock_irqrestore(&dec->filter_info_list_lock, flags);
579 filter->feed->cb.sec(&packet[2], length - 2, NULL, 0,
580 &filter->filter, NULL);
583 static void ttusb_dec_process_packet(struct ttusb_dec *dec)
589 if (dec->packet_length % 2) {
590 printk("%s: odd sized packet - discarding\n", __func__);
594 for (i = 0; i < dec->packet_length; i += 2)
595 csum ^= ((dec->packet[i] << 8) + dec->packet[i + 1]);
598 printk("%s: checksum failed - discarding\n", __func__);
602 packet_id = dec->packet[dec->packet_length - 4] << 8;
603 packet_id += dec->packet[dec->packet_length - 3];
605 if ((packet_id != dec->next_packet_id) && dec->next_packet_id) {
606 printk("%s: warning: lost packets between %u and %u\n",
607 __func__, dec->next_packet_id - 1, packet_id);
610 if (packet_id == 0xffff)
611 dec->next_packet_id = 0x8000;
613 dec->next_packet_id = packet_id + 1;
615 switch (dec->packet_type) {
616 case TTUSB_DEC_PACKET_PVA:
617 if (dec->pva_stream_count)
618 ttusb_dec_process_pva(dec, dec->packet,
619 dec->packet_payload_length);
622 case TTUSB_DEC_PACKET_SECTION:
623 if (dec->filter_stream_count)
624 ttusb_dec_process_filter(dec, dec->packet,
625 dec->packet_payload_length);
628 case TTUSB_DEC_PACKET_EMPTY:
633 static void swap_bytes(u8 *b, int length)
635 length -= length % 2;
636 for (; length; b += 2, length -= 2)
640 static void ttusb_dec_process_urb_frame(struct ttusb_dec *dec, u8 *b,
643 swap_bytes(b, length);
646 switch (dec->packet_state) {
654 dec->packet_state = 0;
662 dec->packet_length = 0;
663 } else if (*b != 0xaa) {
664 dec->packet_state = 0;
672 dec->packet[dec->packet_length++] = *b++;
674 if (dec->packet_length == 2) {
675 if (dec->packet[0] == 'A' &&
676 dec->packet[1] == 'V') {
678 TTUSB_DEC_PACKET_PVA;
680 } else if (dec->packet[0] == 'S') {
682 TTUSB_DEC_PACKET_SECTION;
684 } else if (dec->packet[0] == 0x00) {
686 TTUSB_DEC_PACKET_EMPTY;
687 dec->packet_payload_length = 2;
688 dec->packet_state = 7;
690 printk("%s: unknown packet type: %02x%02x\n",
692 dec->packet[0], dec->packet[1]);
693 dec->packet_state = 0;
701 dec->packet[dec->packet_length++] = *b++;
703 if (dec->packet_type == TTUSB_DEC_PACKET_PVA &&
704 dec->packet_length == 8) {
706 dec->packet_payload_length = 8 +
707 (dec->packet[6] << 8) +
709 } else if (dec->packet_type ==
710 TTUSB_DEC_PACKET_SECTION &&
711 dec->packet_length == 5) {
713 dec->packet_payload_length = 5 +
714 ((dec->packet[3] & 0x0f) << 8) +
722 int remainder = dec->packet_payload_length -
725 if (length >= remainder) {
726 memcpy(dec->packet + dec->packet_length,
728 dec->packet_length += remainder;
733 memcpy(&dec->packet[dec->packet_length],
735 dec->packet_length += length;
745 dec->packet[dec->packet_length++] = *b++;
747 if (dec->packet_type == TTUSB_DEC_PACKET_SECTION &&
748 dec->packet_payload_length % 2)
751 if (dec->packet_length ==
752 dec->packet_payload_length + tail) {
753 ttusb_dec_process_packet(dec);
754 dec->packet_state = 0;
762 printk("%s: illegal packet state encountered.\n",
764 dec->packet_state = 0;
769 static void ttusb_dec_process_urb_frame_list(struct tasklet_struct *t)
771 struct ttusb_dec *dec = from_tasklet(dec, t, urb_tasklet);
772 struct list_head *item;
773 struct urb_frame *frame;
777 spin_lock_irqsave(&dec->urb_frame_list_lock, flags);
778 if ((item = dec->urb_frame_list.next) != &dec->urb_frame_list) {
779 frame = list_entry(item, struct urb_frame,
781 list_del(&frame->urb_frame_list);
783 spin_unlock_irqrestore(&dec->urb_frame_list_lock,
787 spin_unlock_irqrestore(&dec->urb_frame_list_lock, flags);
789 ttusb_dec_process_urb_frame(dec, frame->data, frame->length);
794 static void ttusb_dec_process_urb(struct urb *urb)
796 struct ttusb_dec *dec = urb->context;
801 for (i = 0; i < FRAMES_PER_ISO_BUF; i++) {
802 struct usb_iso_packet_descriptor *d;
805 struct urb_frame *frame;
807 d = &urb->iso_frame_desc[i];
808 b = urb->transfer_buffer + d->offset;
809 length = d->actual_length;
811 if ((frame = kmalloc(sizeof(struct urb_frame),
815 memcpy(frame->data, b, length);
816 frame->length = length;
818 spin_lock_irqsave(&dec->urb_frame_list_lock,
820 list_add_tail(&frame->urb_frame_list,
821 &dec->urb_frame_list);
822 spin_unlock_irqrestore(&dec->urb_frame_list_lock,
825 tasklet_schedule(&dec->urb_tasklet);
829 /* -ENOENT is expected when unlinking urbs */
830 if (urb->status != -ENOENT)
831 dprintk("%s: urb error: %d\n", __func__,
835 if (dec->iso_stream_count)
836 usb_submit_urb(urb, GFP_ATOMIC);
839 static void ttusb_dec_setup_urbs(struct ttusb_dec *dec)
841 int i, j, buffer_offset = 0;
843 dprintk("%s\n", __func__);
845 for (i = 0; i < ISO_BUF_COUNT; i++) {
846 int frame_offset = 0;
847 struct urb *urb = dec->iso_urb[i];
849 urb->dev = dec->udev;
851 urb->complete = ttusb_dec_process_urb;
852 urb->pipe = dec->in_pipe;
853 urb->transfer_flags = URB_ISO_ASAP;
855 urb->number_of_packets = FRAMES_PER_ISO_BUF;
856 urb->transfer_buffer_length = ISO_FRAME_SIZE *
858 urb->transfer_buffer = dec->iso_buffer + buffer_offset;
859 buffer_offset += ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF;
861 for (j = 0; j < FRAMES_PER_ISO_BUF; j++) {
862 urb->iso_frame_desc[j].offset = frame_offset;
863 urb->iso_frame_desc[j].length = ISO_FRAME_SIZE;
864 frame_offset += ISO_FRAME_SIZE;
869 static void ttusb_dec_stop_iso_xfer(struct ttusb_dec *dec)
873 dprintk("%s\n", __func__);
875 if (mutex_lock_interruptible(&dec->iso_mutex))
878 dec->iso_stream_count--;
880 if (!dec->iso_stream_count) {
881 for (i = 0; i < ISO_BUF_COUNT; i++)
882 usb_kill_urb(dec->iso_urb[i]);
885 mutex_unlock(&dec->iso_mutex);
888 /* Setting the interface of the DEC tends to take down the USB communications
889 * for a short period, so it's important not to call this function just before
890 * trying to talk to it.
892 static int ttusb_dec_set_interface(struct ttusb_dec *dec,
893 enum ttusb_dec_interface interface)
898 if (interface != dec->interface) {
900 case TTUSB_DEC_INTERFACE_INITIAL:
901 result = usb_set_interface(dec->udev, 0, 0);
903 case TTUSB_DEC_INTERFACE_IN:
904 result = ttusb_dec_send_command(dec, 0x80, sizeof(b),
908 result = usb_set_interface(dec->udev, 0, 8);
910 case TTUSB_DEC_INTERFACE_OUT:
911 result = usb_set_interface(dec->udev, 0, 1);
918 dec->interface = interface;
924 static int ttusb_dec_start_iso_xfer(struct ttusb_dec *dec)
928 dprintk("%s\n", __func__);
930 if (mutex_lock_interruptible(&dec->iso_mutex))
933 if (!dec->iso_stream_count) {
934 ttusb_dec_setup_urbs(dec);
936 dec->packet_state = 0;
937 dec->v_pes_postbytes = 0;
938 dec->next_packet_id = 0;
940 for (i = 0; i < ISO_BUF_COUNT; i++) {
941 if ((result = usb_submit_urb(dec->iso_urb[i],
943 printk("%s: failed urb submission %d: error %d\n",
944 __func__, i, result);
947 usb_kill_urb(dec->iso_urb[i - 1]);
951 mutex_unlock(&dec->iso_mutex);
957 dec->iso_stream_count++;
959 mutex_unlock(&dec->iso_mutex);
964 static int ttusb_dec_start_ts_feed(struct dvb_demux_feed *dvbdmxfeed)
966 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
967 struct ttusb_dec *dec = dvbdmx->priv;
971 dprintk("%s\n", __func__);
973 dprintk(" ts_type:");
975 if (dvbdmxfeed->ts_type & TS_DECODER)
976 dprintk(" TS_DECODER");
978 if (dvbdmxfeed->ts_type & TS_PACKET)
979 dprintk(" TS_PACKET");
981 if (dvbdmxfeed->ts_type & TS_PAYLOAD_ONLY)
982 dprintk(" TS_PAYLOAD_ONLY");
986 switch (dvbdmxfeed->pes_type) {
989 dprintk(" pes_type: DMX_PES_VIDEO\n");
990 dec->pid[DMX_PES_PCR] = dvbdmxfeed->pid;
991 dec->pid[DMX_PES_VIDEO] = dvbdmxfeed->pid;
992 dec->video_filter = dvbdmxfeed->filter;
993 ttusb_dec_set_pids(dec);
997 dprintk(" pes_type: DMX_PES_AUDIO\n");
998 dec->pid[DMX_PES_AUDIO] = dvbdmxfeed->pid;
999 dec->audio_filter = dvbdmxfeed->filter;
1000 ttusb_dec_set_pids(dec);
1003 case DMX_PES_TELETEXT:
1004 dec->pid[DMX_PES_TELETEXT] = dvbdmxfeed->pid;
1005 dprintk(" pes_type: DMX_PES_TELETEXT(not supported)\n");
1009 dprintk(" pes_type: DMX_PES_PCR\n");
1010 dec->pid[DMX_PES_PCR] = dvbdmxfeed->pid;
1011 ttusb_dec_set_pids(dec);
1015 dprintk(" pes_type: DMX_PES_OTHER(not supported)\n");
1019 dprintk(" pes_type: unknown (%d)\n", dvbdmxfeed->pes_type);
1024 result = ttusb_dec_send_command(dec, 0x80, sizeof(b0), b0, NULL, NULL);
1028 dec->pva_stream_count++;
1029 return ttusb_dec_start_iso_xfer(dec);
1032 static int ttusb_dec_start_sec_feed(struct dvb_demux_feed *dvbdmxfeed)
1034 struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
1035 u8 b0[] = { 0x00, 0x00, 0x00, 0x01,
1036 0x00, 0x00, 0x00, 0x00,
1037 0x00, 0x00, 0x00, 0x00,
1038 0x00, 0x00, 0x00, 0x00,
1039 0x00, 0xff, 0x00, 0x00,
1040 0x00, 0x00, 0x00, 0x00,
1041 0x00, 0x00, 0x00, 0x00,
1044 u8 c[COMMAND_PACKET_SIZE];
1047 struct filter_info *finfo;
1048 unsigned long flags;
1051 dprintk("%s\n", __func__);
1053 pid = htons(dvbdmxfeed->pid);
1054 memcpy(&b0[0], &pid, 2);
1055 memcpy(&b0[4], &x, 1);
1056 memcpy(&b0[5], &dvbdmxfeed->filter->filter.filter_value[0], 1);
1058 result = ttusb_dec_send_command(dec, 0x60, sizeof(b0), b0,
1062 if (c_length == 2) {
1063 if (!(finfo = kmalloc(sizeof(struct filter_info),
1067 finfo->stream_id = c[1];
1068 finfo->filter = dvbdmxfeed->filter;
1070 spin_lock_irqsave(&dec->filter_info_list_lock, flags);
1071 list_add_tail(&finfo->filter_info_list,
1072 &dec->filter_info_list);
1073 spin_unlock_irqrestore(&dec->filter_info_list_lock,
1076 dvbdmxfeed->priv = finfo;
1078 dec->filter_stream_count++;
1079 return ttusb_dec_start_iso_xfer(dec);
1087 static int ttusb_dec_start_feed(struct dvb_demux_feed *dvbdmxfeed)
1089 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
1091 dprintk("%s\n", __func__);
1093 if (!dvbdmx->dmx.frontend)
1096 dprintk(" pid: 0x%04X\n", dvbdmxfeed->pid);
1098 switch (dvbdmxfeed->type) {
1101 return ttusb_dec_start_ts_feed(dvbdmxfeed);
1104 return ttusb_dec_start_sec_feed(dvbdmxfeed);
1107 dprintk(" type: unknown (%d)\n", dvbdmxfeed->type);
1113 static int ttusb_dec_stop_ts_feed(struct dvb_demux_feed *dvbdmxfeed)
1115 struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
1118 ttusb_dec_send_command(dec, 0x81, sizeof(b0), b0, NULL, NULL);
1120 dec->pva_stream_count--;
1122 ttusb_dec_stop_iso_xfer(dec);
1127 static int ttusb_dec_stop_sec_feed(struct dvb_demux_feed *dvbdmxfeed)
1129 struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
1130 u8 b0[] = { 0x00, 0x00 };
1131 struct filter_info *finfo = dvbdmxfeed->priv;
1132 unsigned long flags;
1134 b0[1] = finfo->stream_id;
1135 spin_lock_irqsave(&dec->filter_info_list_lock, flags);
1136 list_del(&finfo->filter_info_list);
1137 spin_unlock_irqrestore(&dec->filter_info_list_lock, flags);
1139 ttusb_dec_send_command(dec, 0x62, sizeof(b0), b0, NULL, NULL);
1141 dec->filter_stream_count--;
1143 ttusb_dec_stop_iso_xfer(dec);
1148 static int ttusb_dec_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
1150 dprintk("%s\n", __func__);
1152 switch (dvbdmxfeed->type) {
1154 return ttusb_dec_stop_ts_feed(dvbdmxfeed);
1157 return ttusb_dec_stop_sec_feed(dvbdmxfeed);
1163 static void ttusb_dec_free_iso_urbs(struct ttusb_dec *dec)
1167 dprintk("%s\n", __func__);
1169 for (i = 0; i < ISO_BUF_COUNT; i++)
1170 usb_free_urb(dec->iso_urb[i]);
1171 kfree(dec->iso_buffer);
1174 static int ttusb_dec_alloc_iso_urbs(struct ttusb_dec *dec)
1178 dprintk("%s\n", __func__);
1180 dec->iso_buffer = kcalloc(FRAMES_PER_ISO_BUF * ISO_BUF_COUNT,
1181 ISO_FRAME_SIZE, GFP_KERNEL);
1182 if (!dec->iso_buffer)
1185 for (i = 0; i < ISO_BUF_COUNT; i++) {
1188 if (!(urb = usb_alloc_urb(FRAMES_PER_ISO_BUF, GFP_ATOMIC))) {
1189 ttusb_dec_free_iso_urbs(dec);
1193 dec->iso_urb[i] = urb;
1196 ttusb_dec_setup_urbs(dec);
1201 static void ttusb_dec_init_tasklet(struct ttusb_dec *dec)
1203 spin_lock_init(&dec->urb_frame_list_lock);
1204 INIT_LIST_HEAD(&dec->urb_frame_list);
1205 tasklet_setup(&dec->urb_tasklet, ttusb_dec_process_urb_frame_list);
1208 static int ttusb_init_rc( struct ttusb_dec *dec)
1210 struct input_dev *input_dev;
1211 u8 b[] = { 0x00, 0x01 };
1215 usb_make_path(dec->udev, dec->rc_phys, sizeof(dec->rc_phys));
1216 strlcat(dec->rc_phys, "/input0", sizeof(dec->rc_phys));
1218 input_dev = input_allocate_device();
1222 input_dev->name = "ttusb_dec remote control";
1223 input_dev->phys = dec->rc_phys;
1224 input_dev->evbit[0] = BIT_MASK(EV_KEY);
1225 input_dev->keycodesize = sizeof(u16);
1226 input_dev->keycodemax = 0x1a;
1227 input_dev->keycode = rc_keys;
1229 for (i = 0; i < ARRAY_SIZE(rc_keys); i++)
1230 set_bit(rc_keys[i], input_dev->keybit);
1232 err = input_register_device(input_dev);
1234 input_free_device(input_dev);
1238 dec->rc_input_dev = input_dev;
1239 if (usb_submit_urb(dec->irq_urb, GFP_KERNEL))
1240 printk("%s: usb_submit_urb failed\n",__func__);
1241 /* enable irq pipe */
1242 ttusb_dec_send_command(dec,0xb0,sizeof(b),b,NULL,NULL);
1247 static void ttusb_dec_init_v_pes(struct ttusb_dec *dec)
1249 dprintk("%s\n", __func__);
1251 dec->v_pes[0] = 0x00;
1252 dec->v_pes[1] = 0x00;
1253 dec->v_pes[2] = 0x01;
1254 dec->v_pes[3] = 0xe0;
1257 static int ttusb_dec_init_usb(struct ttusb_dec *dec)
1261 dprintk("%s\n", __func__);
1263 mutex_init(&dec->usb_mutex);
1264 mutex_init(&dec->iso_mutex);
1266 dec->command_pipe = usb_sndbulkpipe(dec->udev, COMMAND_PIPE);
1267 dec->result_pipe = usb_rcvbulkpipe(dec->udev, RESULT_PIPE);
1268 dec->in_pipe = usb_rcvisocpipe(dec->udev, IN_PIPE);
1269 dec->out_pipe = usb_sndisocpipe(dec->udev, OUT_PIPE);
1270 dec->irq_pipe = usb_rcvintpipe(dec->udev, IRQ_PIPE);
1273 dec->irq_urb = usb_alloc_urb(0, GFP_KERNEL);
1277 dec->irq_buffer = usb_alloc_coherent(dec->udev,IRQ_PACKET_SIZE,
1278 GFP_KERNEL, &dec->irq_dma_handle);
1279 if(!dec->irq_buffer) {
1280 usb_free_urb(dec->irq_urb);
1283 usb_fill_int_urb(dec->irq_urb, dec->udev,dec->irq_pipe,
1284 dec->irq_buffer, IRQ_PACKET_SIZE,
1285 ttusb_dec_handle_irq, dec, 1);
1286 dec->irq_urb->transfer_dma = dec->irq_dma_handle;
1287 dec->irq_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1290 result = ttusb_dec_alloc_iso_urbs(dec);
1292 usb_free_urb(dec->irq_urb);
1293 usb_free_coherent(dec->udev, IRQ_PACKET_SIZE,
1294 dec->irq_buffer, dec->irq_dma_handle);
1299 static int ttusb_dec_boot_dsp(struct ttusb_dec *dec)
1301 int i, j, actual_len, result, size, trans_count;
1302 u8 b0[] = { 0x00, 0x00, 0x00, 0x00,
1303 0x00, 0x00, 0x00, 0x00,
1308 const u8 *firmware = NULL;
1309 size_t firmware_size = 0;
1310 u16 firmware_csum = 0;
1311 __be16 firmware_csum_ns;
1312 __be32 firmware_size_nl;
1313 u32 crc32_csum, crc32_check;
1315 const struct firmware *fw_entry = NULL;
1317 dprintk("%s\n", __func__);
1319 result = reject_firmware(&fw_entry, dec->firmware_name, &dec->udev->dev);
1321 printk(KERN_ERR "%s: Firmware (%s) unavailable.\n",
1322 __func__, dec->firmware_name);
1326 firmware = fw_entry->data;
1327 firmware_size = fw_entry->size;
1329 if (firmware_size < 60) {
1330 printk("%s: firmware size too small for DSP code (%zu < 60).\n",
1331 __func__, firmware_size);
1332 release_firmware(fw_entry);
1336 /* a 32 bit checksum over the first 56 bytes of the DSP Code is stored
1337 at offset 56 of file, so use it to check if the firmware file is
1339 crc32_csum = crc32(~0L, firmware, 56) ^ ~0L;
1340 memcpy(&tmp, &firmware[56], 4);
1341 crc32_check = ntohl(tmp);
1342 if (crc32_csum != crc32_check) {
1343 printk("%s: crc32 check of DSP code failed (calculated 0x%08x != 0x%08x in file), file invalid.\n",
1344 __func__, crc32_csum, crc32_check);
1345 release_firmware(fw_entry);
1348 memcpy(idstring, &firmware[36], 20);
1349 idstring[20] = '\0';
1350 printk(KERN_INFO "ttusb_dec: found DSP code \"%s\".\n", idstring);
1352 firmware_size_nl = htonl(firmware_size);
1353 memcpy(b0, &firmware_size_nl, 4);
1354 firmware_csum = crc16(~0, firmware, firmware_size) ^ ~0;
1355 firmware_csum_ns = htons(firmware_csum);
1356 memcpy(&b0[6], &firmware_csum_ns, 2);
1358 result = ttusb_dec_send_command(dec, 0x41, sizeof(b0), b0, NULL, NULL);
1361 release_firmware(fw_entry);
1368 b = kmalloc(ARM_PACKET_SIZE, GFP_KERNEL);
1370 release_firmware(fw_entry);
1374 for (i = 0; i < firmware_size; i += COMMAND_PACKET_SIZE) {
1375 size = firmware_size - i;
1376 if (size > COMMAND_PACKET_SIZE)
1377 size = COMMAND_PACKET_SIZE;
1380 b[j + 1] = trans_count++;
1383 memcpy(&b[j + 4], &firmware[i], size);
1385 j += COMMAND_PACKET_SIZE + 4;
1387 if (j >= ARM_PACKET_SIZE) {
1388 result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
1389 ARM_PACKET_SIZE, &actual_len,
1392 } else if (size < COMMAND_PACKET_SIZE) {
1393 result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
1394 j - COMMAND_PACKET_SIZE + size,
1399 result = ttusb_dec_send_command(dec, 0x43, sizeof(b1), b1, NULL, NULL);
1401 release_firmware(fw_entry);
1407 static int ttusb_dec_init_stb(struct ttusb_dec *dec)
1410 unsigned int mode = 0, model = 0, version = 0;
1412 dprintk("%s\n", __func__);
1414 result = ttusb_dec_get_stb_state(dec, &mode, &model, &version);
1419 if (version == 0xABCDEFAB)
1420 printk(KERN_INFO "ttusb_dec: no version info in Firmware\n");
1422 printk(KERN_INFO "ttusb_dec: Firmware %x.%02x%c%c\n",
1423 version >> 24, (version >> 16) & 0xff,
1424 (version >> 8) & 0xff, version & 0xff);
1426 result = ttusb_dec_boot_dsp(dec);
1430 /* We can't trust the USB IDs that some firmwares
1436 ttusb_dec_set_model(dec, TTUSB_DEC3000S);
1440 ttusb_dec_set_model(dec, TTUSB_DEC2000T);
1443 ttusb_dec_set_model(dec, TTUSB_DEC2540T);
1446 printk(KERN_ERR "%s: unknown model returned by firmware (%08x) - please report\n",
1450 if (version >= 0x01770000)
1451 dec->can_playback = 1;
1456 static int ttusb_dec_init_dvb(struct ttusb_dec *dec)
1460 dprintk("%s\n", __func__);
1462 if ((result = dvb_register_adapter(&dec->adapter,
1463 dec->model_name, THIS_MODULE,
1466 printk("%s: dvb_register_adapter failed: error %d\n",
1472 dec->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING;
1474 dec->demux.priv = (void *)dec;
1475 dec->demux.filternum = 31;
1476 dec->demux.feednum = 31;
1477 dec->demux.start_feed = ttusb_dec_start_feed;
1478 dec->demux.stop_feed = ttusb_dec_stop_feed;
1479 dec->demux.write_to_decoder = NULL;
1481 if ((result = dvb_dmx_init(&dec->demux)) < 0) {
1482 printk("%s: dvb_dmx_init failed: error %d\n", __func__,
1485 dvb_unregister_adapter(&dec->adapter);
1490 dec->dmxdev.filternum = 32;
1491 dec->dmxdev.demux = &dec->demux.dmx;
1492 dec->dmxdev.capabilities = 0;
1494 if ((result = dvb_dmxdev_init(&dec->dmxdev, &dec->adapter)) < 0) {
1495 printk("%s: dvb_dmxdev_init failed: error %d\n",
1498 dvb_dmx_release(&dec->demux);
1499 dvb_unregister_adapter(&dec->adapter);
1504 dec->frontend.source = DMX_FRONTEND_0;
1506 if ((result = dec->demux.dmx.add_frontend(&dec->demux.dmx,
1507 &dec->frontend)) < 0) {
1508 printk("%s: dvb_dmx_init failed: error %d\n", __func__,
1511 dvb_dmxdev_release(&dec->dmxdev);
1512 dvb_dmx_release(&dec->demux);
1513 dvb_unregister_adapter(&dec->adapter);
1518 if ((result = dec->demux.dmx.connect_frontend(&dec->demux.dmx,
1519 &dec->frontend)) < 0) {
1520 printk("%s: dvb_dmx_init failed: error %d\n", __func__,
1523 dec->demux.dmx.remove_frontend(&dec->demux.dmx, &dec->frontend);
1524 dvb_dmxdev_release(&dec->dmxdev);
1525 dvb_dmx_release(&dec->demux);
1526 dvb_unregister_adapter(&dec->adapter);
1531 dvb_net_init(&dec->adapter, &dec->dvb_net, &dec->demux.dmx);
1536 static void ttusb_dec_exit_dvb(struct ttusb_dec *dec)
1538 dprintk("%s\n", __func__);
1540 dvb_net_release(&dec->dvb_net);
1541 dec->demux.dmx.close(&dec->demux.dmx);
1542 dec->demux.dmx.remove_frontend(&dec->demux.dmx, &dec->frontend);
1543 dvb_dmxdev_release(&dec->dmxdev);
1544 dvb_dmx_release(&dec->demux);
1546 dvb_unregister_frontend(dec->fe);
1547 dvb_frontend_detach(dec->fe);
1549 dvb_unregister_adapter(&dec->adapter);
1552 static void ttusb_dec_exit_rc(struct ttusb_dec *dec)
1554 dprintk("%s\n", __func__);
1556 if (dec->rc_input_dev) {
1557 input_unregister_device(dec->rc_input_dev);
1558 dec->rc_input_dev = NULL;
1563 static void ttusb_dec_exit_usb(struct ttusb_dec *dec)
1567 dprintk("%s\n", __func__);
1570 /* we have to check whether the irq URB is already submitted.
1571 * As the irq is submitted after the interface is changed,
1572 * this is the best method i figured out.
1574 if (dec->interface == TTUSB_DEC_INTERFACE_IN)
1575 usb_kill_urb(dec->irq_urb);
1577 usb_free_urb(dec->irq_urb);
1579 usb_free_coherent(dec->udev, IRQ_PACKET_SIZE,
1580 dec->irq_buffer, dec->irq_dma_handle);
1583 dec->iso_stream_count = 0;
1585 for (i = 0; i < ISO_BUF_COUNT; i++)
1586 usb_kill_urb(dec->iso_urb[i]);
1588 ttusb_dec_free_iso_urbs(dec);
1591 static void ttusb_dec_exit_tasklet(struct ttusb_dec *dec)
1593 struct list_head *item;
1594 struct urb_frame *frame;
1596 tasklet_kill(&dec->urb_tasklet);
1598 while ((item = dec->urb_frame_list.next) != &dec->urb_frame_list) {
1599 frame = list_entry(item, struct urb_frame, urb_frame_list);
1600 list_del(&frame->urb_frame_list);
1605 static void ttusb_dec_init_filters(struct ttusb_dec *dec)
1607 INIT_LIST_HEAD(&dec->filter_info_list);
1608 spin_lock_init(&dec->filter_info_list_lock);
1611 static void ttusb_dec_exit_filters(struct ttusb_dec *dec)
1613 struct list_head *item;
1614 struct filter_info *finfo;
1616 while ((item = dec->filter_info_list.next) != &dec->filter_info_list) {
1617 finfo = list_entry(item, struct filter_info, filter_info_list);
1618 list_del(&finfo->filter_info_list);
1623 static int fe_send_command(struct dvb_frontend* fe, const u8 command,
1624 int param_length, const u8 params[],
1625 int *result_length, u8 cmd_result[])
1627 struct ttusb_dec* dec = fe->dvb->priv;
1628 return ttusb_dec_send_command(dec, command, param_length, params, result_length, cmd_result);
1631 static const struct ttusbdecfe_config fe_config = {
1632 .send_command = fe_send_command
1635 static int ttusb_dec_probe(struct usb_interface *intf,
1636 const struct usb_device_id *id)
1638 struct usb_device *udev;
1639 struct ttusb_dec *dec;
1642 dprintk("%s\n", __func__);
1644 udev = interface_to_usbdev(intf);
1646 if (!(dec = kzalloc(sizeof(struct ttusb_dec), GFP_KERNEL))) {
1647 printk("%s: couldn't allocate memory.\n", __func__);
1651 usb_set_intfdata(intf, (void *)dec);
1653 switch (id->idProduct) {
1655 ttusb_dec_set_model(dec, TTUSB_DEC3000S);
1659 ttusb_dec_set_model(dec, TTUSB_DEC2000T);
1663 ttusb_dec_set_model(dec, TTUSB_DEC2540T);
1669 result = ttusb_dec_init_usb(dec);
1672 result = ttusb_dec_init_stb(dec);
1675 result = ttusb_dec_init_dvb(dec);
1679 dec->adapter.priv = dec;
1680 switch (id->idProduct) {
1682 dec->fe = ttusbdecfe_dvbs_attach(&fe_config);
1687 dec->fe = ttusbdecfe_dvbt_attach(&fe_config);
1691 if (dec->fe == NULL) {
1692 printk("dvb-ttusb-dec: A frontend driver was not found for device [%04x:%04x]\n",
1693 le16_to_cpu(dec->udev->descriptor.idVendor),
1694 le16_to_cpu(dec->udev->descriptor.idProduct));
1696 if (dvb_register_frontend(&dec->adapter, dec->fe)) {
1697 printk("budget-ci: Frontend registration failed!\n");
1698 if (dec->fe->ops.release)
1699 dec->fe->ops.release(dec->fe);
1704 ttusb_dec_init_v_pes(dec);
1705 ttusb_dec_init_filters(dec);
1706 ttusb_dec_init_tasklet(dec);
1710 ttusb_dec_set_interface(dec, TTUSB_DEC_INTERFACE_IN);
1717 ttusb_dec_exit_usb(dec);
1723 static void ttusb_dec_disconnect(struct usb_interface *intf)
1725 struct ttusb_dec *dec = usb_get_intfdata(intf);
1727 usb_set_intfdata(intf, NULL);
1729 dprintk("%s\n", __func__);
1732 ttusb_dec_exit_tasklet(dec);
1733 ttusb_dec_exit_filters(dec);
1735 ttusb_dec_exit_rc(dec);
1736 ttusb_dec_exit_usb(dec);
1737 ttusb_dec_exit_dvb(dec);
1743 static void ttusb_dec_set_model(struct ttusb_dec *dec,
1744 enum ttusb_dec_model model)
1749 case TTUSB_DEC2000T:
1750 dec->model_name = "DEC2000-t";
1751 dec->firmware_name = "/*(DEBLOBBED)*/";
1754 case TTUSB_DEC2540T:
1755 dec->model_name = "DEC2540-t";
1756 dec->firmware_name = "/*(DEBLOBBED)*/";
1759 case TTUSB_DEC3000S:
1760 dec->model_name = "DEC3000-s";
1761 dec->firmware_name = "/*(DEBLOBBED)*/";
1766 static const struct usb_device_id ttusb_dec_table[] = {
1767 {USB_DEVICE(0x0b48, 0x1006)}, /* DEC3000-s */
1768 /*{USB_DEVICE(0x0b48, 0x1007)}, Unconfirmed */
1769 {USB_DEVICE(0x0b48, 0x1008)}, /* DEC2000-t */
1770 {USB_DEVICE(0x0b48, 0x1009)}, /* DEC2540-t */
1774 static struct usb_driver ttusb_dec_driver = {
1775 .name = "ttusb-dec",
1776 .probe = ttusb_dec_probe,
1777 .disconnect = ttusb_dec_disconnect,
1778 .id_table = ttusb_dec_table,
1781 module_usb_driver(ttusb_dec_driver);
1783 MODULE_AUTHOR("Alex Woods <linux-dvb@giblets.org>");
1784 MODULE_DESCRIPTION(DRIVER_NAME);
1785 MODULE_LICENSE("GPL");
1786 MODULE_DEVICE_TABLE(usb, ttusb_dec_table);