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 result = mutex_lock_interruptible(&dec->usb_mutex);
328 if (result) {
329 printk("%s: Failed to lock usb mutex.\n", __func__);
330 goto err_free;
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 goto err_mutex_unlock;
353 }
354
355 result = usb_bulk_msg(dec->udev, dec->result_pipe, b,
356 COMMAND_PACKET_SIZE + 4, &actual_len, 1000);
357
358 if (result) {
359 printk("%s: result bulk message failed: error %d\n",
360 __func__, result);
361 goto err_mutex_unlock;
362 } else {
363 if (debug) {
364 printk(KERN_DEBUG "%s: result: %*ph\n",
365 __func__, actual_len, b);
366 }
367
368 if (result_length)
369 *result_length = b[3];
370 if (cmd_result && b[3] > 0)
371 memcpy(cmd_result, &b[4], b[3]);
372 }
373
374 err_mutex_unlock:
375 mutex_unlock(&dec->usb_mutex);
376 err_free:
377 kfree(b);
378 return result;
379 }
380
ttusb_dec_get_stb_state(struct ttusb_dec * dec,unsigned int * mode,unsigned int * model,unsigned int * version)381 static int ttusb_dec_get_stb_state (struct ttusb_dec *dec, unsigned int *mode,
382 unsigned int *model, unsigned int *version)
383 {
384 u8 c[COMMAND_PACKET_SIZE];
385 int c_length;
386 int result;
387 __be32 tmp;
388
389 dprintk("%s\n", __func__);
390
391 result = ttusb_dec_send_command(dec, 0x08, 0, NULL, &c_length, c);
392 if (result)
393 return result;
394
395 if (c_length >= 0x0c) {
396 if (mode != NULL) {
397 memcpy(&tmp, c, 4);
398 *mode = ntohl(tmp);
399 }
400 if (model != NULL) {
401 memcpy(&tmp, &c[4], 4);
402 *model = ntohl(tmp);
403 }
404 if (version != NULL) {
405 memcpy(&tmp, &c[8], 4);
406 *version = ntohl(tmp);
407 }
408 return 0;
409 } else {
410 return -ENOENT;
411 }
412 }
413
ttusb_dec_audio_pes2ts_cb(void * priv,unsigned char * data)414 static int ttusb_dec_audio_pes2ts_cb(void *priv, unsigned char *data)
415 {
416 struct ttusb_dec *dec = priv;
417
418 dec->audio_filter->feed->cb.ts(data, 188, NULL, 0,
419 &dec->audio_filter->feed->feed.ts, NULL);
420
421 return 0;
422 }
423
ttusb_dec_video_pes2ts_cb(void * priv,unsigned char * data)424 static int ttusb_dec_video_pes2ts_cb(void *priv, unsigned char *data)
425 {
426 struct ttusb_dec *dec = priv;
427
428 dec->video_filter->feed->cb.ts(data, 188, NULL, 0,
429 &dec->video_filter->feed->feed.ts, NULL);
430
431 return 0;
432 }
433
ttusb_dec_set_pids(struct ttusb_dec * dec)434 static void ttusb_dec_set_pids(struct ttusb_dec *dec)
435 {
436 u8 b[] = { 0x00, 0x00, 0x00, 0x00,
437 0x00, 0x00, 0xff, 0xff,
438 0xff, 0xff, 0xff, 0xff };
439
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]);
443
444 dprintk("%s\n", __func__);
445
446 memcpy(&b[0], &pcr, 2);
447 memcpy(&b[2], &audio, 2);
448 memcpy(&b[4], &video, 2);
449
450 ttusb_dec_send_command(dec, 0x50, sizeof(b), b, NULL, NULL);
451
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;
458 }
459
ttusb_dec_process_pva(struct ttusb_dec * dec,u8 * pva,int length)460 static void ttusb_dec_process_pva(struct ttusb_dec *dec, u8 *pva, int length)
461 {
462 if (length < 8) {
463 printk("%s: packet too short - discarding\n", __func__);
464 return;
465 }
466
467 if (length > 8 + MAX_PVA_LENGTH) {
468 printk("%s: packet too long - discarding\n", __func__);
469 return;
470 }
471
472 switch (pva[2]) {
473
474 case 0x01: { /* VideoStream */
475 int prebytes = pva[5] & 0x03;
476 int postbytes = (pva[5] & 0x0c) >> 2;
477 __be16 v_pes_payload_length;
478
479 if (output_pva) {
480 dec->video_filter->feed->cb.ts(pva, length, NULL, 0,
481 &dec->video_filter->feed->feed.ts, NULL);
482 return;
483 }
484
485 if (dec->v_pes_postbytes > 0 &&
486 dec->v_pes_postbytes == prebytes) {
487 memcpy(&dec->v_pes[dec->v_pes_length],
488 &pva[12], prebytes);
489
490 dvb_filter_pes2ts(&dec->v_pes2ts, dec->v_pes,
491 dec->v_pes_length + prebytes, 1);
492 }
493
494 if (pva[5] & 0x10) {
495 dec->v_pes[7] = 0x80;
496 dec->v_pes[8] = 0x05;
497
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);
507
508 memcpy(&dec->v_pes[14], &pva[12 + prebytes],
509 length - 12 - prebytes);
510 dec->v_pes_length = 14 + length - 12 - prebytes;
511 } else {
512 dec->v_pes[7] = 0x00;
513 dec->v_pes[8] = 0x00;
514
515 memcpy(&dec->v_pes[9], &pva[8], length - 8);
516 dec->v_pes_length = 9 + length - 8;
517 }
518
519 dec->v_pes_postbytes = postbytes;
520
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;
525 else
526 dec->v_pes[6] = 0x80;
527
528 v_pes_payload_length = htons(dec->v_pes_length - 6 +
529 postbytes);
530 memcpy(&dec->v_pes[4], &v_pes_payload_length, 2);
531
532 if (postbytes == 0)
533 dvb_filter_pes2ts(&dec->v_pes2ts, dec->v_pes,
534 dec->v_pes_length, 1);
535
536 break;
537 }
538
539 case 0x02: /* MainAudioStream */
540 if (output_pva) {
541 dec->audio_filter->feed->cb.ts(pva, length, NULL, 0,
542 &dec->audio_filter->feed->feed.ts, NULL);
543 return;
544 }
545
546 dvb_filter_pes2ts(&dec->a_pes2ts, &pva[8], length - 8,
547 pva[5] & 0x10);
548 break;
549
550 default:
551 printk("%s: unknown PVA type: %02x.\n", __func__,
552 pva[2]);
553 break;
554 }
555 }
556
ttusb_dec_process_filter(struct ttusb_dec * dec,u8 * packet,int length)557 static void ttusb_dec_process_filter(struct ttusb_dec *dec, u8 *packet,
558 int length)
559 {
560 struct list_head *item;
561 struct filter_info *finfo;
562 struct dvb_demux_filter *filter = NULL;
563 unsigned long flags;
564 u8 sid;
565
566 sid = packet[1];
567 spin_lock_irqsave(&dec->filter_info_list_lock, flags);
568 for (item = dec->filter_info_list.next; item != &dec->filter_info_list;
569 item = item->next) {
570 finfo = list_entry(item, struct filter_info, filter_info_list);
571 if (finfo->stream_id == sid) {
572 filter = finfo->filter;
573 break;
574 }
575 }
576 spin_unlock_irqrestore(&dec->filter_info_list_lock, flags);
577
578 if (filter)
579 filter->feed->cb.sec(&packet[2], length - 2, NULL, 0,
580 &filter->filter, NULL);
581 }
582
ttusb_dec_process_packet(struct ttusb_dec * dec)583 static void ttusb_dec_process_packet(struct ttusb_dec *dec)
584 {
585 int i;
586 u16 csum = 0;
587 u16 packet_id;
588
589 if (dec->packet_length % 2) {
590 printk("%s: odd sized packet - discarding\n", __func__);
591 return;
592 }
593
594 for (i = 0; i < dec->packet_length; i += 2)
595 csum ^= ((dec->packet[i] << 8) + dec->packet[i + 1]);
596
597 if (csum) {
598 printk("%s: checksum failed - discarding\n", __func__);
599 return;
600 }
601
602 packet_id = dec->packet[dec->packet_length - 4] << 8;
603 packet_id += dec->packet[dec->packet_length - 3];
604
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);
608 }
609
610 if (packet_id == 0xffff)
611 dec->next_packet_id = 0x8000;
612 else
613 dec->next_packet_id = packet_id + 1;
614
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);
620 break;
621
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);
626 break;
627
628 case TTUSB_DEC_PACKET_EMPTY:
629 break;
630 }
631 }
632
swap_bytes(u8 * b,int length)633 static void swap_bytes(u8 *b, int length)
634 {
635 length -= length % 2;
636 for (; length; b += 2, length -= 2)
637 swap(*b, *(b + 1));
638 }
639
ttusb_dec_process_urb_frame(struct ttusb_dec * dec,u8 * b,int length)640 static void ttusb_dec_process_urb_frame(struct ttusb_dec *dec, u8 *b,
641 int length)
642 {
643 swap_bytes(b, length);
644
645 while (length) {
646 switch (dec->packet_state) {
647
648 case 0:
649 case 1:
650 case 2:
651 if (*b++ == 0xaa)
652 dec->packet_state++;
653 else
654 dec->packet_state = 0;
655
656 length--;
657 break;
658
659 case 3:
660 if (*b == 0x00) {
661 dec->packet_state++;
662 dec->packet_length = 0;
663 } else if (*b != 0xaa) {
664 dec->packet_state = 0;
665 }
666
667 b++;
668 length--;
669 break;
670
671 case 4:
672 dec->packet[dec->packet_length++] = *b++;
673
674 if (dec->packet_length == 2) {
675 if (dec->packet[0] == 'A' &&
676 dec->packet[1] == 'V') {
677 dec->packet_type =
678 TTUSB_DEC_PACKET_PVA;
679 dec->packet_state++;
680 } else if (dec->packet[0] == 'S') {
681 dec->packet_type =
682 TTUSB_DEC_PACKET_SECTION;
683 dec->packet_state++;
684 } else if (dec->packet[0] == 0x00) {
685 dec->packet_type =
686 TTUSB_DEC_PACKET_EMPTY;
687 dec->packet_payload_length = 2;
688 dec->packet_state = 7;
689 } else {
690 printk("%s: unknown packet type: %02x%02x\n",
691 __func__,
692 dec->packet[0], dec->packet[1]);
693 dec->packet_state = 0;
694 }
695 }
696
697 length--;
698 break;
699
700 case 5:
701 dec->packet[dec->packet_length++] = *b++;
702
703 if (dec->packet_type == TTUSB_DEC_PACKET_PVA &&
704 dec->packet_length == 8) {
705 dec->packet_state++;
706 dec->packet_payload_length = 8 +
707 (dec->packet[6] << 8) +
708 dec->packet[7];
709 } else if (dec->packet_type ==
710 TTUSB_DEC_PACKET_SECTION &&
711 dec->packet_length == 5) {
712 dec->packet_state++;
713 dec->packet_payload_length = 5 +
714 ((dec->packet[3] & 0x0f) << 8) +
715 dec->packet[4];
716 }
717
718 length--;
719 break;
720
721 case 6: {
722 int remainder = dec->packet_payload_length -
723 dec->packet_length;
724
725 if (length >= remainder) {
726 memcpy(dec->packet + dec->packet_length,
727 b, remainder);
728 dec->packet_length += remainder;
729 b += remainder;
730 length -= remainder;
731 dec->packet_state++;
732 } else {
733 memcpy(&dec->packet[dec->packet_length],
734 b, length);
735 dec->packet_length += length;
736 length = 0;
737 }
738
739 break;
740 }
741
742 case 7: {
743 int tail = 4;
744
745 dec->packet[dec->packet_length++] = *b++;
746
747 if (dec->packet_type == TTUSB_DEC_PACKET_SECTION &&
748 dec->packet_payload_length % 2)
749 tail++;
750
751 if (dec->packet_length ==
752 dec->packet_payload_length + tail) {
753 ttusb_dec_process_packet(dec);
754 dec->packet_state = 0;
755 }
756
757 length--;
758 break;
759 }
760
761 default:
762 printk("%s: illegal packet state encountered.\n",
763 __func__);
764 dec->packet_state = 0;
765 }
766 }
767 }
768
ttusb_dec_process_urb_frame_list(struct tasklet_struct * t)769 static void ttusb_dec_process_urb_frame_list(struct tasklet_struct *t)
770 {
771 struct ttusb_dec *dec = from_tasklet(dec, t, urb_tasklet);
772 struct list_head *item;
773 struct urb_frame *frame;
774 unsigned long flags;
775
776 while (1) {
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,
780 urb_frame_list);
781 list_del(&frame->urb_frame_list);
782 } else {
783 spin_unlock_irqrestore(&dec->urb_frame_list_lock,
784 flags);
785 return;
786 }
787 spin_unlock_irqrestore(&dec->urb_frame_list_lock, flags);
788
789 ttusb_dec_process_urb_frame(dec, frame->data, frame->length);
790 kfree(frame);
791 }
792 }
793
ttusb_dec_process_urb(struct urb * urb)794 static void ttusb_dec_process_urb(struct urb *urb)
795 {
796 struct ttusb_dec *dec = urb->context;
797
798 if (!urb->status) {
799 int i;
800
801 for (i = 0; i < FRAMES_PER_ISO_BUF; i++) {
802 struct usb_iso_packet_descriptor *d;
803 u8 *b;
804 int length;
805 struct urb_frame *frame;
806
807 d = &urb->iso_frame_desc[i];
808 b = urb->transfer_buffer + d->offset;
809 length = d->actual_length;
810
811 if ((frame = kmalloc(sizeof(struct urb_frame),
812 GFP_ATOMIC))) {
813 unsigned long flags;
814
815 memcpy(frame->data, b, length);
816 frame->length = length;
817
818 spin_lock_irqsave(&dec->urb_frame_list_lock,
819 flags);
820 list_add_tail(&frame->urb_frame_list,
821 &dec->urb_frame_list);
822 spin_unlock_irqrestore(&dec->urb_frame_list_lock,
823 flags);
824
825 tasklet_schedule(&dec->urb_tasklet);
826 }
827 }
828 } else {
829 /* -ENOENT is expected when unlinking urbs */
830 if (urb->status != -ENOENT)
831 dprintk("%s: urb error: %d\n", __func__,
832 urb->status);
833 }
834
835 if (dec->iso_stream_count)
836 usb_submit_urb(urb, GFP_ATOMIC);
837 }
838
ttusb_dec_setup_urbs(struct ttusb_dec * dec)839 static void ttusb_dec_setup_urbs(struct ttusb_dec *dec)
840 {
841 int i, j, buffer_offset = 0;
842
843 dprintk("%s\n", __func__);
844
845 for (i = 0; i < ISO_BUF_COUNT; i++) {
846 int frame_offset = 0;
847 struct urb *urb = dec->iso_urb[i];
848
849 urb->dev = dec->udev;
850 urb->context = dec;
851 urb->complete = ttusb_dec_process_urb;
852 urb->pipe = dec->in_pipe;
853 urb->transfer_flags = URB_ISO_ASAP;
854 urb->interval = 1;
855 urb->number_of_packets = FRAMES_PER_ISO_BUF;
856 urb->transfer_buffer_length = ISO_FRAME_SIZE *
857 FRAMES_PER_ISO_BUF;
858 urb->transfer_buffer = dec->iso_buffer + buffer_offset;
859 buffer_offset += ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF;
860
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;
865 }
866 }
867 }
868
ttusb_dec_stop_iso_xfer(struct ttusb_dec * dec)869 static void ttusb_dec_stop_iso_xfer(struct ttusb_dec *dec)
870 {
871 int i;
872
873 dprintk("%s\n", __func__);
874
875 if (mutex_lock_interruptible(&dec->iso_mutex))
876 return;
877
878 dec->iso_stream_count--;
879
880 if (!dec->iso_stream_count) {
881 for (i = 0; i < ISO_BUF_COUNT; i++)
882 usb_kill_urb(dec->iso_urb[i]);
883 }
884
885 mutex_unlock(&dec->iso_mutex);
886 }
887
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.
891 */
ttusb_dec_set_interface(struct ttusb_dec * dec,enum ttusb_dec_interface interface)892 static int ttusb_dec_set_interface(struct ttusb_dec *dec,
893 enum ttusb_dec_interface interface)
894 {
895 int result = 0;
896 u8 b[] = { 0x05 };
897
898 if (interface != dec->interface) {
899 switch (interface) {
900 case TTUSB_DEC_INTERFACE_INITIAL:
901 result = usb_set_interface(dec->udev, 0, 0);
902 break;
903 case TTUSB_DEC_INTERFACE_IN:
904 result = ttusb_dec_send_command(dec, 0x80, sizeof(b),
905 b, NULL, NULL);
906 if (result)
907 return result;
908 result = usb_set_interface(dec->udev, 0, 8);
909 break;
910 case TTUSB_DEC_INTERFACE_OUT:
911 result = usb_set_interface(dec->udev, 0, 1);
912 break;
913 }
914
915 if (result)
916 return result;
917
918 dec->interface = interface;
919 }
920
921 return 0;
922 }
923
ttusb_dec_start_iso_xfer(struct ttusb_dec * dec)924 static int ttusb_dec_start_iso_xfer(struct ttusb_dec *dec)
925 {
926 int i, result;
927
928 dprintk("%s\n", __func__);
929
930 if (mutex_lock_interruptible(&dec->iso_mutex))
931 return -EAGAIN;
932
933 if (!dec->iso_stream_count) {
934 ttusb_dec_setup_urbs(dec);
935
936 dec->packet_state = 0;
937 dec->v_pes_postbytes = 0;
938 dec->next_packet_id = 0;
939
940 for (i = 0; i < ISO_BUF_COUNT; i++) {
941 if ((result = usb_submit_urb(dec->iso_urb[i],
942 GFP_ATOMIC))) {
943 printk("%s: failed urb submission %d: error %d\n",
944 __func__, i, result);
945
946 while (i) {
947 usb_kill_urb(dec->iso_urb[i - 1]);
948 i--;
949 }
950
951 mutex_unlock(&dec->iso_mutex);
952 return result;
953 }
954 }
955 }
956
957 dec->iso_stream_count++;
958
959 mutex_unlock(&dec->iso_mutex);
960
961 return 0;
962 }
963
ttusb_dec_start_ts_feed(struct dvb_demux_feed * dvbdmxfeed)964 static int ttusb_dec_start_ts_feed(struct dvb_demux_feed *dvbdmxfeed)
965 {
966 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
967 struct ttusb_dec *dec = dvbdmx->priv;
968 u8 b0[] = { 0x05 };
969 int result = 0;
970
971 dprintk("%s\n", __func__);
972
973 dprintk(" ts_type:");
974
975 if (dvbdmxfeed->ts_type & TS_DECODER)
976 dprintk(" TS_DECODER");
977
978 if (dvbdmxfeed->ts_type & TS_PACKET)
979 dprintk(" TS_PACKET");
980
981 if (dvbdmxfeed->ts_type & TS_PAYLOAD_ONLY)
982 dprintk(" TS_PAYLOAD_ONLY");
983
984 dprintk("\n");
985
986 switch (dvbdmxfeed->pes_type) {
987
988 case DMX_PES_VIDEO:
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);
994 break;
995
996 case DMX_PES_AUDIO:
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);
1001 break;
1002
1003 case DMX_PES_TELETEXT:
1004 dec->pid[DMX_PES_TELETEXT] = dvbdmxfeed->pid;
1005 dprintk(" pes_type: DMX_PES_TELETEXT(not supported)\n");
1006 return -ENOSYS;
1007
1008 case DMX_PES_PCR:
1009 dprintk(" pes_type: DMX_PES_PCR\n");
1010 dec->pid[DMX_PES_PCR] = dvbdmxfeed->pid;
1011 ttusb_dec_set_pids(dec);
1012 break;
1013
1014 case DMX_PES_OTHER:
1015 dprintk(" pes_type: DMX_PES_OTHER(not supported)\n");
1016 return -ENOSYS;
1017
1018 default:
1019 dprintk(" pes_type: unknown (%d)\n", dvbdmxfeed->pes_type);
1020 return -EINVAL;
1021
1022 }
1023
1024 result = ttusb_dec_send_command(dec, 0x80, sizeof(b0), b0, NULL, NULL);
1025 if (result)
1026 return result;
1027
1028 dec->pva_stream_count++;
1029 return ttusb_dec_start_iso_xfer(dec);
1030 }
1031
ttusb_dec_start_sec_feed(struct dvb_demux_feed * dvbdmxfeed)1032 static int ttusb_dec_start_sec_feed(struct dvb_demux_feed *dvbdmxfeed)
1033 {
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,
1042 0x00 };
1043 __be16 pid;
1044 u8 c[COMMAND_PACKET_SIZE];
1045 int c_length;
1046 int result;
1047 struct filter_info *finfo;
1048 unsigned long flags;
1049 u8 x = 1;
1050
1051 dprintk("%s\n", __func__);
1052
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);
1057
1058 result = ttusb_dec_send_command(dec, 0x60, sizeof(b0), b0,
1059 &c_length, c);
1060
1061 if (!result) {
1062 if (c_length == 2) {
1063 if (!(finfo = kmalloc(sizeof(struct filter_info),
1064 GFP_ATOMIC)))
1065 return -ENOMEM;
1066
1067 finfo->stream_id = c[1];
1068 finfo->filter = dvbdmxfeed->filter;
1069
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,
1074 flags);
1075
1076 dvbdmxfeed->priv = finfo;
1077
1078 dec->filter_stream_count++;
1079 return ttusb_dec_start_iso_xfer(dec);
1080 }
1081
1082 return -EAGAIN;
1083 } else
1084 return result;
1085 }
1086
ttusb_dec_start_feed(struct dvb_demux_feed * dvbdmxfeed)1087 static int ttusb_dec_start_feed(struct dvb_demux_feed *dvbdmxfeed)
1088 {
1089 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
1090
1091 dprintk("%s\n", __func__);
1092
1093 if (!dvbdmx->dmx.frontend)
1094 return -EINVAL;
1095
1096 dprintk(" pid: 0x%04X\n", dvbdmxfeed->pid);
1097
1098 switch (dvbdmxfeed->type) {
1099
1100 case DMX_TYPE_TS:
1101 return ttusb_dec_start_ts_feed(dvbdmxfeed);
1102
1103 case DMX_TYPE_SEC:
1104 return ttusb_dec_start_sec_feed(dvbdmxfeed);
1105
1106 default:
1107 dprintk(" type: unknown (%d)\n", dvbdmxfeed->type);
1108 return -EINVAL;
1109
1110 }
1111 }
1112
ttusb_dec_stop_ts_feed(struct dvb_demux_feed * dvbdmxfeed)1113 static int ttusb_dec_stop_ts_feed(struct dvb_demux_feed *dvbdmxfeed)
1114 {
1115 struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
1116 u8 b0[] = { 0x00 };
1117
1118 ttusb_dec_send_command(dec, 0x81, sizeof(b0), b0, NULL, NULL);
1119
1120 dec->pva_stream_count--;
1121
1122 ttusb_dec_stop_iso_xfer(dec);
1123
1124 return 0;
1125 }
1126
ttusb_dec_stop_sec_feed(struct dvb_demux_feed * dvbdmxfeed)1127 static int ttusb_dec_stop_sec_feed(struct dvb_demux_feed *dvbdmxfeed)
1128 {
1129 struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
1130 u8 b0[] = { 0x00, 0x00 };
1131 struct filter_info *finfo = dvbdmxfeed->priv;
1132 unsigned long flags;
1133
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);
1138 kfree(finfo);
1139 ttusb_dec_send_command(dec, 0x62, sizeof(b0), b0, NULL, NULL);
1140
1141 dec->filter_stream_count--;
1142
1143 ttusb_dec_stop_iso_xfer(dec);
1144
1145 return 0;
1146 }
1147
ttusb_dec_stop_feed(struct dvb_demux_feed * dvbdmxfeed)1148 static int ttusb_dec_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
1149 {
1150 dprintk("%s\n", __func__);
1151
1152 switch (dvbdmxfeed->type) {
1153 case DMX_TYPE_TS:
1154 return ttusb_dec_stop_ts_feed(dvbdmxfeed);
1155
1156 case DMX_TYPE_SEC:
1157 return ttusb_dec_stop_sec_feed(dvbdmxfeed);
1158 }
1159
1160 return 0;
1161 }
1162
ttusb_dec_free_iso_urbs(struct ttusb_dec * dec)1163 static void ttusb_dec_free_iso_urbs(struct ttusb_dec *dec)
1164 {
1165 int i;
1166
1167 dprintk("%s\n", __func__);
1168
1169 for (i = 0; i < ISO_BUF_COUNT; i++)
1170 usb_free_urb(dec->iso_urb[i]);
1171 kfree(dec->iso_buffer);
1172 }
1173
ttusb_dec_alloc_iso_urbs(struct ttusb_dec * dec)1174 static int ttusb_dec_alloc_iso_urbs(struct ttusb_dec *dec)
1175 {
1176 int i;
1177
1178 dprintk("%s\n", __func__);
1179
1180 dec->iso_buffer = kcalloc(FRAMES_PER_ISO_BUF * ISO_BUF_COUNT,
1181 ISO_FRAME_SIZE, GFP_KERNEL);
1182 if (!dec->iso_buffer)
1183 return -ENOMEM;
1184
1185 for (i = 0; i < ISO_BUF_COUNT; i++) {
1186 struct urb *urb;
1187
1188 if (!(urb = usb_alloc_urb(FRAMES_PER_ISO_BUF, GFP_ATOMIC))) {
1189 ttusb_dec_free_iso_urbs(dec);
1190 return -ENOMEM;
1191 }
1192
1193 dec->iso_urb[i] = urb;
1194 }
1195
1196 ttusb_dec_setup_urbs(dec);
1197
1198 return 0;
1199 }
1200
ttusb_dec_init_tasklet(struct ttusb_dec * dec)1201 static void ttusb_dec_init_tasklet(struct ttusb_dec *dec)
1202 {
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);
1206 }
1207
ttusb_init_rc(struct ttusb_dec * dec)1208 static int ttusb_init_rc( struct ttusb_dec *dec)
1209 {
1210 struct input_dev *input_dev;
1211 u8 b[] = { 0x00, 0x01 };
1212 int i;
1213 int err;
1214
1215 usb_make_path(dec->udev, dec->rc_phys, sizeof(dec->rc_phys));
1216 strlcat(dec->rc_phys, "/input0", sizeof(dec->rc_phys));
1217
1218 input_dev = input_allocate_device();
1219 if (!input_dev)
1220 return -ENOMEM;
1221
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;
1228
1229 for (i = 0; i < ARRAY_SIZE(rc_keys); i++)
1230 set_bit(rc_keys[i], input_dev->keybit);
1231
1232 err = input_register_device(input_dev);
1233 if (err) {
1234 input_free_device(input_dev);
1235 return err;
1236 }
1237
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);
1243
1244 return 0;
1245 }
1246
ttusb_dec_init_v_pes(struct ttusb_dec * dec)1247 static void ttusb_dec_init_v_pes(struct ttusb_dec *dec)
1248 {
1249 dprintk("%s\n", __func__);
1250
1251 dec->v_pes[0] = 0x00;
1252 dec->v_pes[1] = 0x00;
1253 dec->v_pes[2] = 0x01;
1254 dec->v_pes[3] = 0xe0;
1255 }
1256
ttusb_dec_init_usb(struct ttusb_dec * dec)1257 static int ttusb_dec_init_usb(struct ttusb_dec *dec)
1258 {
1259 int result;
1260
1261 dprintk("%s\n", __func__);
1262
1263 mutex_init(&dec->usb_mutex);
1264 mutex_init(&dec->iso_mutex);
1265
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);
1271
1272 if(enable_rc) {
1273 dec->irq_urb = usb_alloc_urb(0, GFP_KERNEL);
1274 if(!dec->irq_urb) {
1275 return -ENOMEM;
1276 }
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);
1281 return -ENOMEM;
1282 }
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;
1288 }
1289
1290 result = ttusb_dec_alloc_iso_urbs(dec);
1291 if (result) {
1292 usb_free_urb(dec->irq_urb);
1293 usb_free_coherent(dec->udev, IRQ_PACKET_SIZE,
1294 dec->irq_buffer, dec->irq_dma_handle);
1295 }
1296 return result;
1297 }
1298
ttusb_dec_boot_dsp(struct ttusb_dec * dec)1299 static int ttusb_dec_boot_dsp(struct ttusb_dec *dec)
1300 {
1301 int i, j, actual_len, result, size, trans_count;
1302 u8 b0[] = { 0x00, 0x00, 0x00, 0x00,
1303 0x00, 0x00, 0x00, 0x00,
1304 0x61, 0x00 };
1305 u8 b1[] = { 0x61 };
1306 u8 *b;
1307 char idstring[21];
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;
1314 __be32 tmp;
1315 const struct firmware *fw_entry = NULL;
1316
1317 dprintk("%s\n", __func__);
1318
1319 result = request_firmware(&fw_entry, dec->firmware_name, &dec->udev->dev);
1320 if (result) {
1321 printk(KERN_ERR "%s: Firmware (%s) unavailable.\n",
1322 __func__, dec->firmware_name);
1323 return result;
1324 }
1325
1326 firmware = fw_entry->data;
1327 firmware_size = fw_entry->size;
1328
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);
1333 return -ENOENT;
1334 }
1335
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
1338 valid. */
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);
1346 return -ENOENT;
1347 }
1348 memcpy(idstring, &firmware[36], 20);
1349 idstring[20] = '\0';
1350 printk(KERN_INFO "ttusb_dec: found DSP code \"%s\".\n", idstring);
1351
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);
1357
1358 result = ttusb_dec_send_command(dec, 0x41, sizeof(b0), b0, NULL, NULL);
1359
1360 if (result) {
1361 release_firmware(fw_entry);
1362 return result;
1363 }
1364
1365 trans_count = 0;
1366 j = 0;
1367
1368 b = kmalloc(ARM_PACKET_SIZE, GFP_KERNEL);
1369 if (b == NULL) {
1370 release_firmware(fw_entry);
1371 return -ENOMEM;
1372 }
1373
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;
1378
1379 b[j + 0] = 0xaa;
1380 b[j + 1] = trans_count++;
1381 b[j + 2] = 0xf0;
1382 b[j + 3] = size;
1383 memcpy(&b[j + 4], &firmware[i], size);
1384
1385 j += COMMAND_PACKET_SIZE + 4;
1386
1387 if (j >= ARM_PACKET_SIZE) {
1388 result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
1389 ARM_PACKET_SIZE, &actual_len,
1390 100);
1391 j = 0;
1392 } else if (size < COMMAND_PACKET_SIZE) {
1393 result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
1394 j - COMMAND_PACKET_SIZE + size,
1395 &actual_len, 100);
1396 }
1397 }
1398
1399 result = ttusb_dec_send_command(dec, 0x43, sizeof(b1), b1, NULL, NULL);
1400
1401 release_firmware(fw_entry);
1402 kfree(b);
1403
1404 return result;
1405 }
1406
ttusb_dec_init_stb(struct ttusb_dec * dec)1407 static int ttusb_dec_init_stb(struct ttusb_dec *dec)
1408 {
1409 int result;
1410 unsigned int mode = 0, model = 0, version = 0;
1411
1412 dprintk("%s\n", __func__);
1413
1414 result = ttusb_dec_get_stb_state(dec, &mode, &model, &version);
1415 if (result)
1416 return result;
1417
1418 if (!mode) {
1419 if (version == 0xABCDEFAB)
1420 printk(KERN_INFO "ttusb_dec: no version info in Firmware\n");
1421 else
1422 printk(KERN_INFO "ttusb_dec: Firmware %x.%02x%c%c\n",
1423 version >> 24, (version >> 16) & 0xff,
1424 (version >> 8) & 0xff, version & 0xff);
1425
1426 result = ttusb_dec_boot_dsp(dec);
1427 if (result)
1428 return result;
1429 } else {
1430 /* We can't trust the USB IDs that some firmwares
1431 give the box */
1432 switch (model) {
1433 case 0x00070001:
1434 case 0x00070008:
1435 case 0x0007000c:
1436 ttusb_dec_set_model(dec, TTUSB_DEC3000S);
1437 break;
1438 case 0x00070009:
1439 case 0x00070013:
1440 ttusb_dec_set_model(dec, TTUSB_DEC2000T);
1441 break;
1442 case 0x00070011:
1443 ttusb_dec_set_model(dec, TTUSB_DEC2540T);
1444 break;
1445 default:
1446 printk(KERN_ERR "%s: unknown model returned by firmware (%08x) - please report\n",
1447 __func__, model);
1448 return -ENOENT;
1449 }
1450 if (version >= 0x01770000)
1451 dec->can_playback = 1;
1452 }
1453 return 0;
1454 }
1455
ttusb_dec_init_dvb(struct ttusb_dec * dec)1456 static int ttusb_dec_init_dvb(struct ttusb_dec *dec)
1457 {
1458 int result;
1459
1460 dprintk("%s\n", __func__);
1461
1462 if ((result = dvb_register_adapter(&dec->adapter,
1463 dec->model_name, THIS_MODULE,
1464 &dec->udev->dev,
1465 adapter_nr)) < 0) {
1466 printk("%s: dvb_register_adapter failed: error %d\n",
1467 __func__, result);
1468
1469 return result;
1470 }
1471
1472 dec->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING;
1473
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;
1480
1481 if ((result = dvb_dmx_init(&dec->demux)) < 0) {
1482 printk("%s: dvb_dmx_init failed: error %d\n", __func__,
1483 result);
1484
1485 dvb_unregister_adapter(&dec->adapter);
1486
1487 return result;
1488 }
1489
1490 dec->dmxdev.filternum = 32;
1491 dec->dmxdev.demux = &dec->demux.dmx;
1492 dec->dmxdev.capabilities = 0;
1493
1494 if ((result = dvb_dmxdev_init(&dec->dmxdev, &dec->adapter)) < 0) {
1495 printk("%s: dvb_dmxdev_init failed: error %d\n",
1496 __func__, result);
1497
1498 dvb_dmx_release(&dec->demux);
1499 dvb_unregister_adapter(&dec->adapter);
1500
1501 return result;
1502 }
1503
1504 dec->frontend.source = DMX_FRONTEND_0;
1505
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__,
1509 result);
1510
1511 dvb_dmxdev_release(&dec->dmxdev);
1512 dvb_dmx_release(&dec->demux);
1513 dvb_unregister_adapter(&dec->adapter);
1514
1515 return result;
1516 }
1517
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__,
1521 result);
1522
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);
1527
1528 return result;
1529 }
1530
1531 dvb_net_init(&dec->adapter, &dec->dvb_net, &dec->demux.dmx);
1532
1533 return 0;
1534 }
1535
ttusb_dec_exit_dvb(struct ttusb_dec * dec)1536 static void ttusb_dec_exit_dvb(struct ttusb_dec *dec)
1537 {
1538 dprintk("%s\n", __func__);
1539
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);
1545 if (dec->fe) {
1546 dvb_unregister_frontend(dec->fe);
1547 dvb_frontend_detach(dec->fe);
1548 }
1549 dvb_unregister_adapter(&dec->adapter);
1550 }
1551
ttusb_dec_exit_rc(struct ttusb_dec * dec)1552 static void ttusb_dec_exit_rc(struct ttusb_dec *dec)
1553 {
1554 dprintk("%s\n", __func__);
1555
1556 if (dec->rc_input_dev) {
1557 input_unregister_device(dec->rc_input_dev);
1558 dec->rc_input_dev = NULL;
1559 }
1560 }
1561
1562
ttusb_dec_exit_usb(struct ttusb_dec * dec)1563 static void ttusb_dec_exit_usb(struct ttusb_dec *dec)
1564 {
1565 int i;
1566
1567 dprintk("%s\n", __func__);
1568
1569 if (enable_rc) {
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.
1573 * Any others?*/
1574 if (dec->interface == TTUSB_DEC_INTERFACE_IN)
1575 usb_kill_urb(dec->irq_urb);
1576
1577 usb_free_urb(dec->irq_urb);
1578
1579 usb_free_coherent(dec->udev, IRQ_PACKET_SIZE,
1580 dec->irq_buffer, dec->irq_dma_handle);
1581 }
1582
1583 dec->iso_stream_count = 0;
1584
1585 for (i = 0; i < ISO_BUF_COUNT; i++)
1586 usb_kill_urb(dec->iso_urb[i]);
1587
1588 ttusb_dec_free_iso_urbs(dec);
1589 }
1590
ttusb_dec_exit_tasklet(struct ttusb_dec * dec)1591 static void ttusb_dec_exit_tasklet(struct ttusb_dec *dec)
1592 {
1593 struct list_head *item;
1594 struct urb_frame *frame;
1595
1596 tasklet_kill(&dec->urb_tasklet);
1597
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);
1601 kfree(frame);
1602 }
1603 }
1604
ttusb_dec_init_filters(struct ttusb_dec * dec)1605 static void ttusb_dec_init_filters(struct ttusb_dec *dec)
1606 {
1607 INIT_LIST_HEAD(&dec->filter_info_list);
1608 spin_lock_init(&dec->filter_info_list_lock);
1609 }
1610
ttusb_dec_exit_filters(struct ttusb_dec * dec)1611 static void ttusb_dec_exit_filters(struct ttusb_dec *dec)
1612 {
1613 struct list_head *item;
1614 struct filter_info *finfo;
1615
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);
1619 kfree(finfo);
1620 }
1621 }
1622
fe_send_command(struct dvb_frontend * fe,const u8 command,int param_length,const u8 params[],int * result_length,u8 cmd_result[])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[])
1626 {
1627 struct ttusb_dec* dec = fe->dvb->priv;
1628 return ttusb_dec_send_command(dec, command, param_length, params, result_length, cmd_result);
1629 }
1630
1631 static const struct ttusbdecfe_config fe_config = {
1632 .send_command = fe_send_command
1633 };
1634
ttusb_dec_probe(struct usb_interface * intf,const struct usb_device_id * id)1635 static int ttusb_dec_probe(struct usb_interface *intf,
1636 const struct usb_device_id *id)
1637 {
1638 struct usb_device *udev;
1639 struct ttusb_dec *dec;
1640 int result;
1641
1642 dprintk("%s\n", __func__);
1643
1644 udev = interface_to_usbdev(intf);
1645
1646 if (!(dec = kzalloc(sizeof(struct ttusb_dec), GFP_KERNEL))) {
1647 printk("%s: couldn't allocate memory.\n", __func__);
1648 return -ENOMEM;
1649 }
1650
1651 usb_set_intfdata(intf, (void *)dec);
1652
1653 switch (id->idProduct) {
1654 case 0x1006:
1655 ttusb_dec_set_model(dec, TTUSB_DEC3000S);
1656 break;
1657
1658 case 0x1008:
1659 ttusb_dec_set_model(dec, TTUSB_DEC2000T);
1660 break;
1661
1662 case 0x1009:
1663 ttusb_dec_set_model(dec, TTUSB_DEC2540T);
1664 break;
1665 }
1666
1667 dec->udev = udev;
1668
1669 result = ttusb_dec_init_usb(dec);
1670 if (result)
1671 goto err_usb;
1672 result = ttusb_dec_init_stb(dec);
1673 if (result)
1674 goto err_stb;
1675 result = ttusb_dec_init_dvb(dec);
1676 if (result)
1677 goto err_stb;
1678
1679 dec->adapter.priv = dec;
1680 switch (id->idProduct) {
1681 case 0x1006:
1682 dec->fe = ttusbdecfe_dvbs_attach(&fe_config);
1683 break;
1684
1685 case 0x1008:
1686 case 0x1009:
1687 dec->fe = ttusbdecfe_dvbt_attach(&fe_config);
1688 break;
1689 }
1690
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));
1695 } else {
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);
1700 dec->fe = NULL;
1701 }
1702 }
1703
1704 ttusb_dec_init_v_pes(dec);
1705 ttusb_dec_init_filters(dec);
1706 ttusb_dec_init_tasklet(dec);
1707
1708 dec->active = 1;
1709
1710 ttusb_dec_set_interface(dec, TTUSB_DEC_INTERFACE_IN);
1711
1712 if (enable_rc)
1713 ttusb_init_rc(dec);
1714
1715 return 0;
1716 err_stb:
1717 ttusb_dec_exit_usb(dec);
1718 err_usb:
1719 kfree(dec);
1720 return result;
1721 }
1722
ttusb_dec_disconnect(struct usb_interface * intf)1723 static void ttusb_dec_disconnect(struct usb_interface *intf)
1724 {
1725 struct ttusb_dec *dec = usb_get_intfdata(intf);
1726
1727 usb_set_intfdata(intf, NULL);
1728
1729 dprintk("%s\n", __func__);
1730
1731 if (dec->active) {
1732 ttusb_dec_exit_tasklet(dec);
1733 ttusb_dec_exit_filters(dec);
1734 if(enable_rc)
1735 ttusb_dec_exit_rc(dec);
1736 ttusb_dec_exit_usb(dec);
1737 ttusb_dec_exit_dvb(dec);
1738 }
1739
1740 kfree(dec);
1741 }
1742
ttusb_dec_set_model(struct ttusb_dec * dec,enum ttusb_dec_model model)1743 static void ttusb_dec_set_model(struct ttusb_dec *dec,
1744 enum ttusb_dec_model model)
1745 {
1746 dec->model = model;
1747
1748 switch (model) {
1749 case TTUSB_DEC2000T:
1750 dec->model_name = "DEC2000-t";
1751 dec->firmware_name = "dvb-ttusb-dec-2000t.fw";
1752 break;
1753
1754 case TTUSB_DEC2540T:
1755 dec->model_name = "DEC2540-t";
1756 dec->firmware_name = "dvb-ttusb-dec-2540t.fw";
1757 break;
1758
1759 case TTUSB_DEC3000S:
1760 dec->model_name = "DEC3000-s";
1761 dec->firmware_name = "dvb-ttusb-dec-3000s.fw";
1762 break;
1763 }
1764 }
1765
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 */
1771 {}
1772 };
1773
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,
1779 };
1780
1781 module_usb_driver(ttusb_dec_driver);
1782
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);
1787