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