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