?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drm/nouveau: consume the return of large GSP message
[drm/drm-misc.git] / drivers / media / usb / ttusb-dec / ttusb_dec.c
blobb4575fe89c952fc4279ec3e410f256622f5880cd
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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(sizeof(struct urb_frame),
813 GFP_ATOMIC))) {
814 unsigned long flags;
815
816 memcpy(frame->data, b, length);
817 frame->length = length;
818
819 spin_lock_irqsave(&dec->urb_frame_list_lock,
820 flags);
821 list_add_tail(&frame->urb_frame_list,
822 &dec->urb_frame_list);
823 spin_unlock_irqrestore(&dec->urb_frame_list_lock,
824 flags);
825
826 queue_work(system_bh_wq, &dec->urb_bh_work);
827 }
828 }
829 } else {
830 /* -ENOENT is expected when unlinking urbs */
831 if (urb->status != -ENOENT)
832 dprintk("%s: urb error: %d\n", __func__,
833 urb->status);
834 }
835
836 if (dec->iso_stream_count)
837 usb_submit_urb(urb, GFP_ATOMIC);
838 }
839
840 static void ttusb_dec_setup_urbs(struct ttusb_dec *dec)
841 {
842 int i, j, buffer_offset = 0;
843
844 dprintk("%s\n", __func__);
845
846 for (i = 0; i < ISO_BUF_COUNT; i++) {
847 int frame_offset = 0;
848 struct urb *urb = dec->iso_urb[i];
849
850 urb->dev = dec->udev;
851 urb->context = dec;
852 urb->complete = ttusb_dec_process_urb;
853 urb->pipe = dec->in_pipe;
854 urb->transfer_flags = URB_ISO_ASAP;
855 urb->interval = 1;
856 urb->number_of_packets = FRAMES_PER_ISO_BUF;
857 urb->transfer_buffer_length = ISO_FRAME_SIZE *
858 FRAMES_PER_ISO_BUF;
859 urb->transfer_buffer = dec->iso_buffer + buffer_offset;
860 buffer_offset += ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF;
861
862 for (j = 0; j < FRAMES_PER_ISO_BUF; j++) {
863 urb->iso_frame_desc[j].offset = frame_offset;
864 urb->iso_frame_desc[j].length = ISO_FRAME_SIZE;
865 frame_offset += ISO_FRAME_SIZE;
866 }
867 }
868 }
869
870 static void ttusb_dec_stop_iso_xfer(struct ttusb_dec *dec)
871 {
872 int i;
873
874 dprintk("%s\n", __func__);
875
876 if (mutex_lock_interruptible(&dec->iso_mutex))
877 return;
878
879 dec->iso_stream_count--;
880
881 if (!dec->iso_stream_count) {
882 for (i = 0; i < ISO_BUF_COUNT; i++)
883 usb_kill_urb(dec->iso_urb[i]);
884 }
885
886 mutex_unlock(&dec->iso_mutex);
887 }
888
889 /* Setting the interface of the DEC tends to take down the USB communications
890 * for a short period, so it's important not to call this function just before
891 * trying to talk to it.
892 */
893 static int ttusb_dec_set_interface(struct ttusb_dec *dec,
894 enum ttusb_dec_interface interface)
895 {
896 int result = 0;
897 u8 b[] = { 0x05 };
898
899 if (interface != dec->interface) {
900 switch (interface) {
901 case TTUSB_DEC_INTERFACE_INITIAL:
902 result = usb_set_interface(dec->udev, 0, 0);
903 break;
904 case TTUSB_DEC_INTERFACE_IN:
905 result = ttusb_dec_send_command(dec, 0x80, sizeof(b),
906 b, NULL, NULL);
907 if (result)
908 return result;
909 result = usb_set_interface(dec->udev, 0, 8);
910 break;
911 case TTUSB_DEC_INTERFACE_OUT:
912 result = usb_set_interface(dec->udev, 0, 1);
913 break;
914 }
915
916 if (result)
917 return result;
918
919 dec->interface = interface;
920 }
921
922 return 0;
923 }
924
925 static int ttusb_dec_start_iso_xfer(struct ttusb_dec *dec)
926 {
927 int i, result;
928
929 dprintk("%s\n", __func__);
930
931 if (mutex_lock_interruptible(&dec->iso_mutex))
932 return -EAGAIN;
933
934 if (!dec->iso_stream_count) {
935 ttusb_dec_setup_urbs(dec);
936
937 dec->packet_state = 0;
938 dec->v_pes_postbytes = 0;
939 dec->next_packet_id = 0;
940
941 for (i = 0; i < ISO_BUF_COUNT; i++) {
942 if ((result = usb_submit_urb(dec->iso_urb[i],
943 GFP_ATOMIC))) {
944 printk("%s: failed urb submission %d: error %d\n",
945 __func__, i, result);
946
947 while (i) {
948 usb_kill_urb(dec->iso_urb[i - 1]);
949 i--;
950 }
951
952 mutex_unlock(&dec->iso_mutex);
953 return result;
954 }
955 }
956 }
957
958 dec->iso_stream_count++;
959
960 mutex_unlock(&dec->iso_mutex);
961
962 return 0;
963 }
964
965 static int ttusb_dec_start_ts_feed(struct dvb_demux_feed *dvbdmxfeed)
966 {
967 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
968 struct ttusb_dec *dec = dvbdmx->priv;
969 u8 b0[] = { 0x05 };
970 int result = 0;
971
972 dprintk("%s\n", __func__);
973
974 dprintk(" ts_type:");
975
976 if (dvbdmxfeed->ts_type & TS_DECODER)
977 dprintk(" TS_DECODER");
978
979 if (dvbdmxfeed->ts_type & TS_PACKET)
980 dprintk(" TS_PACKET");
981
982 if (dvbdmxfeed->ts_type & TS_PAYLOAD_ONLY)
983 dprintk(" TS_PAYLOAD_ONLY");
984
985 dprintk("\n");
986
987 switch (dvbdmxfeed->pes_type) {
988
989 case DMX_PES_VIDEO:
990 dprintk(" pes_type: DMX_PES_VIDEO\n");
991 dec->pid[DMX_PES_PCR] = dvbdmxfeed->pid;
992 dec->pid[DMX_PES_VIDEO] = dvbdmxfeed->pid;
993 dec->video_filter = dvbdmxfeed->filter;
994 ttusb_dec_set_pids(dec);
995 break;
996
997 case DMX_PES_AUDIO:
998 dprintk(" pes_type: DMX_PES_AUDIO\n");
999 dec->pid[DMX_PES_AUDIO] = dvbdmxfeed->pid;
1000 dec->audio_filter = dvbdmxfeed->filter;
1001 ttusb_dec_set_pids(dec);
1002 break;
1003
1004 case DMX_PES_TELETEXT:
1005 dec->pid[DMX_PES_TELETEXT] = dvbdmxfeed->pid;
1006 dprintk(" pes_type: DMX_PES_TELETEXT(not supported)\n");
1007 return -ENOSYS;
1008
1009 case DMX_PES_PCR:
1010 dprintk(" pes_type: DMX_PES_PCR\n");
1011 dec->pid[DMX_PES_PCR] = dvbdmxfeed->pid;
1012 ttusb_dec_set_pids(dec);
1013 break;
1014
1015 case DMX_PES_OTHER:
1016 dprintk(" pes_type: DMX_PES_OTHER(not supported)\n");
1017 return -ENOSYS;
1018
1019 default:
1020 dprintk(" pes_type: unknown (%d)\n", dvbdmxfeed->pes_type);
1021 return -EINVAL;
1022
1023 }
1024
1025 result = ttusb_dec_send_command(dec, 0x80, sizeof(b0), b0, NULL, NULL);
1026 if (result)
1027 return result;
1028
1029 dec->pva_stream_count++;
1030 return ttusb_dec_start_iso_xfer(dec);
1031 }
1032
1033 static int ttusb_dec_start_sec_feed(struct dvb_demux_feed *dvbdmxfeed)
1034 {
1035 struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
1036 u8 b0[] = { 0x00, 0x00, 0x00, 0x01,
1037 0x00, 0x00, 0x00, 0x00,
1038 0x00, 0x00, 0x00, 0x00,
1039 0x00, 0x00, 0x00, 0x00,
1040 0x00, 0xff, 0x00, 0x00,
1041 0x00, 0x00, 0x00, 0x00,
1042 0x00, 0x00, 0x00, 0x00,
1043 0x00 };
1044 __be16 pid;
1045 u8 c[COMMAND_PACKET_SIZE];
1046 int c_length;
1047 int result;
1048 struct filter_info *finfo;
1049 unsigned long flags;
1050 u8 x = 1;
1051
1052 dprintk("%s\n", __func__);
1053
1054 pid = htons(dvbdmxfeed->pid);
1055 memcpy(&b0[0], &pid, 2);
1056 memcpy(&b0[4], &x, 1);
1057 memcpy(&b0[5], &dvbdmxfeed->filter->filter.filter_value[0], 1);
1058
1059 result = ttusb_dec_send_command(dec, 0x60, sizeof(b0), b0,
1060 &c_length, c);
1061
1062 if (!result) {
1063 if (c_length == 2) {
1064 if (!(finfo = kmalloc(sizeof(struct filter_info),
1065 GFP_ATOMIC)))
1066 return -ENOMEM;
1067
1068 finfo->stream_id = c[1];
1069 finfo->filter = dvbdmxfeed->filter;
1070
1071 spin_lock_irqsave(&dec->filter_info_list_lock, flags);
1072 list_add_tail(&finfo->filter_info_list,
1073 &dec->filter_info_list);
1074 spin_unlock_irqrestore(&dec->filter_info_list_lock,
1075 flags);
1076
1077 dvbdmxfeed->priv = finfo;
1078
1079 dec->filter_stream_count++;
1080 return ttusb_dec_start_iso_xfer(dec);
1081 }
1082
1083 return -EAGAIN;
1084 } else
1085 return result;
1086 }
1087
1088 static int ttusb_dec_start_feed(struct dvb_demux_feed *dvbdmxfeed)
1089 {
1090 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
1091
1092 dprintk("%s\n", __func__);
1093
1094 if (!dvbdmx->dmx.frontend)
1095 return -EINVAL;
1096
1097 dprintk(" pid: 0x%04X\n", dvbdmxfeed->pid);
1098
1099 switch (dvbdmxfeed->type) {
1100
1101 case DMX_TYPE_TS:
1102 return ttusb_dec_start_ts_feed(dvbdmxfeed);
1103
1104 case DMX_TYPE_SEC:
1105 return ttusb_dec_start_sec_feed(dvbdmxfeed);
1106
1107 default:
1108 dprintk(" type: unknown (%d)\n", dvbdmxfeed->type);
1109 return -EINVAL;
1110
1111 }
1112 }
1113
1114 static int ttusb_dec_stop_ts_feed(struct dvb_demux_feed *dvbdmxfeed)
1115 {
1116 struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
1117 u8 b0[] = { 0x00 };
1118
1119 ttusb_dec_send_command(dec, 0x81, sizeof(b0), b0, NULL, NULL);
1120
1121 dec->pva_stream_count--;
1122
1123 ttusb_dec_stop_iso_xfer(dec);
1124
1125 return 0;
1126 }
1127
1128 static int ttusb_dec_stop_sec_feed(struct dvb_demux_feed *dvbdmxfeed)
1129 {
1130 struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
1131 u8 b0[] = { 0x00, 0x00 };
1132 struct filter_info *finfo = dvbdmxfeed->priv;
1133 unsigned long flags;
1134
1135 b0[1] = finfo->stream_id;
1136 spin_lock_irqsave(&dec->filter_info_list_lock, flags);
1137 list_del(&finfo->filter_info_list);
1138 spin_unlock_irqrestore(&dec->filter_info_list_lock, flags);
1139 kfree(finfo);
1140 ttusb_dec_send_command(dec, 0x62, sizeof(b0), b0, NULL, NULL);
1141
1142 dec->filter_stream_count--;
1143
1144 ttusb_dec_stop_iso_xfer(dec);
1145
1146 return 0;
1147 }
1148
1149 static int ttusb_dec_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
1150 {
1151 dprintk("%s\n", __func__);
1152
1153 switch (dvbdmxfeed->type) {
1154 case DMX_TYPE_TS:
1155 return ttusb_dec_stop_ts_feed(dvbdmxfeed);
1156
1157 case DMX_TYPE_SEC:
1158 return ttusb_dec_stop_sec_feed(dvbdmxfeed);
1159 }
1160
1161 return 0;
1162 }
1163
1164 static void ttusb_dec_free_iso_urbs(struct ttusb_dec *dec)
1165 {
1166 int i;
1167
1168 dprintk("%s\n", __func__);
1169
1170 for (i = 0; i < ISO_BUF_COUNT; i++)
1171 usb_free_urb(dec->iso_urb[i]);
1172 kfree(dec->iso_buffer);
1173 }
1174
1175 static int ttusb_dec_alloc_iso_urbs(struct ttusb_dec *dec)
1176 {
1177 int i;
1178
1179 dprintk("%s\n", __func__);
1180
1181 dec->iso_buffer = kcalloc(FRAMES_PER_ISO_BUF * ISO_BUF_COUNT,
1182 ISO_FRAME_SIZE, GFP_KERNEL);
1183 if (!dec->iso_buffer)
1184 return -ENOMEM;
1185
1186 for (i = 0; i < ISO_BUF_COUNT; i++) {
1187 struct urb *urb;
1188
1189 if (!(urb = usb_alloc_urb(FRAMES_PER_ISO_BUF, GFP_ATOMIC))) {
1190 ttusb_dec_free_iso_urbs(dec);
1191 return -ENOMEM;
1192 }
1193
1194 dec->iso_urb[i] = urb;
1195 }
1196
1197 ttusb_dec_setup_urbs(dec);
1198
1199 return 0;
1200 }
1201
1202 static void ttusb_dec_init_bh_work(struct ttusb_dec *dec)
1203 {
1204 spin_lock_init(&dec->urb_frame_list_lock);
1205 INIT_LIST_HEAD(&dec->urb_frame_list);
1206 INIT_WORK(&dec->urb_bh_work, ttusb_dec_process_urb_frame_list);
1207 }
1208
1209 static int ttusb_init_rc( struct ttusb_dec *dec)
1210 {
1211 struct input_dev *input_dev;
1212 u8 b[] = { 0x00, 0x01 };
1213 int i;
1214 int err;
1215
1216 usb_make_path(dec->udev, dec->rc_phys, sizeof(dec->rc_phys));
1217 strlcat(dec->rc_phys, "/input0", sizeof(dec->rc_phys));
1218
1219 input_dev = input_allocate_device();
1220 if (!input_dev)
1221 return -ENOMEM;
1222
1223 input_dev->name = "ttusb_dec remote control";
1224 input_dev->phys = dec->rc_phys;
1225 input_dev->evbit[0] = BIT_MASK(EV_KEY);
1226 input_dev->keycodesize = sizeof(u16);
1227 input_dev->keycodemax = 0x1a;
1228 input_dev->keycode = rc_keys;
1229
1230 for (i = 0; i < ARRAY_SIZE(rc_keys); i++)
1231 set_bit(rc_keys[i], input_dev->keybit);
1232
1233 err = input_register_device(input_dev);
1234 if (err) {
1235 input_free_device(input_dev);
1236 return err;
1237 }
1238
1239 dec->rc_input_dev = input_dev;
1240 if (usb_submit_urb(dec->irq_urb, GFP_KERNEL))
1241 printk("%s: usb_submit_urb failed\n",__func__);
1242 /* enable irq pipe */
1243 ttusb_dec_send_command(dec,0xb0,sizeof(b),b,NULL,NULL);
1244
1245 return 0;
1246 }
1247
1248 static void ttusb_dec_init_v_pes(struct ttusb_dec *dec)
1249 {
1250 dprintk("%s\n", __func__);
1251
1252 dec->v_pes[0] = 0x00;
1253 dec->v_pes[1] = 0x00;
1254 dec->v_pes[2] = 0x01;
1255 dec->v_pes[3] = 0xe0;
1256 }
1257
1258 static int ttusb_dec_init_usb(struct ttusb_dec *dec)
1259 {
1260 int result;
1261
1262 dprintk("%s\n", __func__);
1263
1264 mutex_init(&dec->usb_mutex);
1265 mutex_init(&dec->iso_mutex);
1266
1267 dec->command_pipe = usb_sndbulkpipe(dec->udev, COMMAND_PIPE);
1268 dec->result_pipe = usb_rcvbulkpipe(dec->udev, RESULT_PIPE);
1269 dec->in_pipe = usb_rcvisocpipe(dec->udev, IN_PIPE);
1270 dec->out_pipe = usb_sndisocpipe(dec->udev, OUT_PIPE);
1271 dec->irq_pipe = usb_rcvintpipe(dec->udev, IRQ_PIPE);
1272
1273 if(enable_rc) {
1274 dec->irq_urb = usb_alloc_urb(0, GFP_KERNEL);
1275 if(!dec->irq_urb) {
1276 return -ENOMEM;
1277 }
1278 dec->irq_buffer = usb_alloc_coherent(dec->udev,IRQ_PACKET_SIZE,
1279 GFP_KERNEL, &dec->irq_dma_handle);
1280 if(!dec->irq_buffer) {
1281 usb_free_urb(dec->irq_urb);
1282 return -ENOMEM;
1283 }
1284 usb_fill_int_urb(dec->irq_urb, dec->udev,dec->irq_pipe,
1285 dec->irq_buffer, IRQ_PACKET_SIZE,
1286 ttusb_dec_handle_irq, dec, 1);
1287 dec->irq_urb->transfer_dma = dec->irq_dma_handle;
1288 dec->irq_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1289 }
1290
1291 result = ttusb_dec_alloc_iso_urbs(dec);
1292 if (result) {
1293 usb_free_urb(dec->irq_urb);
1294 usb_free_coherent(dec->udev, IRQ_PACKET_SIZE,
1295 dec->irq_buffer, dec->irq_dma_handle);
1296 }
1297 return result;
1298 }
1299
1300 static int ttusb_dec_boot_dsp(struct ttusb_dec *dec)
1301 {
1302 int i, j, actual_len, result, size, trans_count;
1303 u8 b0[] = { 0x00, 0x00, 0x00, 0x00,
1304 0x00, 0x00, 0x00, 0x00,
1305 0x61, 0x00 };
1306 u8 b1[] = { 0x61 };
1307 u8 *b;
1308 char idstring[21];
1309 const u8 *firmware = NULL;
1310 size_t firmware_size = 0;
1311 u16 firmware_csum = 0;
1312 __be16 firmware_csum_ns;
1313 __be32 firmware_size_nl;
1314 u32 crc32_csum, crc32_check;
1315 __be32 tmp;
1316 const struct firmware *fw_entry = NULL;
1317
1318 dprintk("%s\n", __func__);
1319
1320 result = request_firmware(&fw_entry, dec->firmware_name, &dec->udev->dev);
1321 if (result) {
1322 printk(KERN_ERR "%s: Firmware (%s) unavailable.\n",
1323 __func__, dec->firmware_name);
1324 return result;
1325 }
1326
1327 firmware = fw_entry->data;
1328 firmware_size = fw_entry->size;
1329
1330 if (firmware_size < 60) {
1331 printk("%s: firmware size too small for DSP code (%zu < 60).\n",
1332 __func__, firmware_size);
1333 release_firmware(fw_entry);
1334 return -ENOENT;
1335 }
1336
1337 /* a 32 bit checksum over the first 56 bytes of the DSP Code is stored
1338 at offset 56 of file, so use it to check if the firmware file is
1339 valid. */
1340 crc32_csum = crc32(~0L, firmware, 56) ^ ~0L;
1341 memcpy(&tmp, &firmware[56], 4);
1342 crc32_check = ntohl(tmp);
1343 if (crc32_csum != crc32_check) {
1344 printk("%s: crc32 check of DSP code failed (calculated 0x%08x != 0x%08x in file), file invalid.\n",
1345 __func__, crc32_csum, crc32_check);
1346 release_firmware(fw_entry);
1347 return -ENOENT;
1348 }
1349 memcpy(idstring, &firmware[36], 20);
1350 idstring[20] = '\0';
1351 printk(KERN_INFO "ttusb_dec: found DSP code \"%s\".\n", idstring);
1352
1353 firmware_size_nl = htonl(firmware_size);
1354 memcpy(b0, &firmware_size_nl, 4);
1355 firmware_csum = crc16(~0, firmware, firmware_size) ^ ~0;
1356 firmware_csum_ns = htons(firmware_csum);
1357 memcpy(&b0[6], &firmware_csum_ns, 2);
1358
1359 result = ttusb_dec_send_command(dec, 0x41, sizeof(b0), b0, NULL, NULL);
1360
1361 if (result) {
1362 release_firmware(fw_entry);
1363 return result;
1364 }
1365
1366 trans_count = 0;
1367 j = 0;
1368
1369 b = kmalloc(ARM_PACKET_SIZE, GFP_KERNEL);
1370 if (b == NULL) {
1371 release_firmware(fw_entry);
1372 return -ENOMEM;
1373 }
1374
1375 for (i = 0; i < firmware_size; i += COMMAND_PACKET_SIZE) {
1376 size = firmware_size - i;
1377 if (size > COMMAND_PACKET_SIZE)
1378 size = COMMAND_PACKET_SIZE;
1379
1380 b[j + 0] = 0xaa;
1381 b[j + 1] = trans_count++;
1382 b[j + 2] = 0xf0;
1383 b[j + 3] = size;
1384 memcpy(&b[j + 4], &firmware[i], size);
1385
1386 j += COMMAND_PACKET_SIZE + 4;
1387
1388 if (j >= ARM_PACKET_SIZE) {
1389 result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
1390 ARM_PACKET_SIZE, &actual_len,
1391 100);
1392 j = 0;
1393 } else if (size < COMMAND_PACKET_SIZE) {
1394 result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
1395 j - COMMAND_PACKET_SIZE + size,
1396 &actual_len, 100);
1397 }
1398 }
1399
1400 result = ttusb_dec_send_command(dec, 0x43, sizeof(b1), b1, NULL, NULL);
1401
1402 release_firmware(fw_entry);
1403 kfree(b);
1404
1405 return result;
1406 }
1407
1408 static int ttusb_dec_init_stb(struct ttusb_dec *dec)
1409 {
1410 int result;
1411 unsigned int mode = 0, model = 0, version = 0;
1412
1413 dprintk("%s\n", __func__);
1414
1415 result = ttusb_dec_get_stb_state(dec, &mode, &model, &version);
1416 if (result)
1417 return result;
1418
1419 if (!mode) {
1420 if (version == 0xABCDEFAB)
1421 printk(KERN_INFO "ttusb_dec: no version info in Firmware\n");
1422 else
1423 printk(KERN_INFO "ttusb_dec: Firmware %x.%02x%c%c\n",
1424 version >> 24, (version >> 16) & 0xff,
1425 (version >> 8) & 0xff, version & 0xff);
1426
1427 result = ttusb_dec_boot_dsp(dec);
1428 if (result)
1429 return result;
1430 } else {
1431 /* We can't trust the USB IDs that some firmwares
1432 give the box */
1433 switch (model) {
1434 case 0x00070001:
1435 case 0x00070008:
1436 case 0x0007000c:
1437 ttusb_dec_set_model(dec, TTUSB_DEC3000S);
1438 break;
1439 case 0x00070009:
1440 case 0x00070013:
1441 ttusb_dec_set_model(dec, TTUSB_DEC2000T);
1442 break;
1443 case 0x00070011:
1444 ttusb_dec_set_model(dec, TTUSB_DEC2540T);
1445 break;
1446 default:
1447 printk(KERN_ERR "%s: unknown model returned by firmware (%08x) - please report\n",
1448 __func__, model);
1449 return -ENOENT;
1450 }
1451 if (version >= 0x01770000)
1452 dec->can_playback = 1;
1453 }
1454 return 0;
1455 }
1456
1457 static int ttusb_dec_init_dvb(struct ttusb_dec *dec)
1458 {
1459 int result;
1460
1461 dprintk("%s\n", __func__);
1462
1463 if ((result = dvb_register_adapter(&dec->adapter,
1464 dec->model_name, THIS_MODULE,
1465 &dec->udev->dev,
1466 adapter_nr)) < 0) {
1467 printk("%s: dvb_register_adapter failed: error %d\n",
1468 __func__, result);
1469
1470 return result;
1471 }
1472
1473 dec->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING;
1474
1475 dec->demux.priv = (void *)dec;
1476 dec->demux.filternum = 31;
1477 dec->demux.feednum = 31;
1478 dec->demux.start_feed = ttusb_dec_start_feed;
1479 dec->demux.stop_feed = ttusb_dec_stop_feed;
1480 dec->demux.write_to_decoder = NULL;
1481
1482 if ((result = dvb_dmx_init(&dec->demux)) < 0) {
1483 printk("%s: dvb_dmx_init failed: error %d\n", __func__,
1484 result);
1485
1486 dvb_unregister_adapter(&dec->adapter);
1487
1488 return result;
1489 }
1490
1491 dec->dmxdev.filternum = 32;
1492 dec->dmxdev.demux = &dec->demux.dmx;
1493 dec->dmxdev.capabilities = 0;
1494
1495 if ((result = dvb_dmxdev_init(&dec->dmxdev, &dec->adapter)) < 0) {
1496 printk("%s: dvb_dmxdev_init failed: error %d\n",
1497 __func__, result);
1498
1499 dvb_dmx_release(&dec->demux);
1500 dvb_unregister_adapter(&dec->adapter);
1501
1502 return result;
1503 }
1504
1505 dec->frontend.source = DMX_FRONTEND_0;
1506
1507 if ((result = dec->demux.dmx.add_frontend(&dec->demux.dmx,
1508 &dec->frontend)) < 0) {
1509 printk("%s: dvb_dmx_init failed: error %d\n", __func__,
1510 result);
1511
1512 dvb_dmxdev_release(&dec->dmxdev);
1513 dvb_dmx_release(&dec->demux);
1514 dvb_unregister_adapter(&dec->adapter);
1515
1516 return result;
1517 }
1518
1519 if ((result = dec->demux.dmx.connect_frontend(&dec->demux.dmx,
1520 &dec->frontend)) < 0) {
1521 printk("%s: dvb_dmx_init failed: error %d\n", __func__,
1522 result);
1523
1524 dec->demux.dmx.remove_frontend(&dec->demux.dmx, &dec->frontend);
1525 dvb_dmxdev_release(&dec->dmxdev);
1526 dvb_dmx_release(&dec->demux);
1527 dvb_unregister_adapter(&dec->adapter);
1528
1529 return result;
1530 }
1531
1532 dvb_net_init(&dec->adapter, &dec->dvb_net, &dec->demux.dmx);
1533
1534 return 0;
1535 }
1536
1537 static void ttusb_dec_exit_dvb(struct ttusb_dec *dec)
1538 {
1539 dprintk("%s\n", __func__);
1540
1541 dvb_net_release(&dec->dvb_net);
1542 dec->demux.dmx.close(&dec->demux.dmx);
1543 dec->demux.dmx.remove_frontend(&dec->demux.dmx, &dec->frontend);
1544 dvb_dmxdev_release(&dec->dmxdev);
1545 dvb_dmx_release(&dec->demux);
1546 if (dec->fe) {
1547 dvb_unregister_frontend(dec->fe);
1548 dvb_frontend_detach(dec->fe);
1549 }
1550 dvb_unregister_adapter(&dec->adapter);
1551 }
1552
1553 static void ttusb_dec_exit_rc(struct ttusb_dec *dec)
1554 {
1555 dprintk("%s\n", __func__);
1556
1557 if (dec->rc_input_dev) {
1558 input_unregister_device(dec->rc_input_dev);
1559 dec->rc_input_dev = NULL;
1560 }
1561 }
1562
1563
1564 static void ttusb_dec_exit_usb(struct ttusb_dec *dec)
1565 {
1566 int i;
1567
1568 dprintk("%s\n", __func__);
1569
1570 if (enable_rc) {
1571 /* we have to check whether the irq URB is already submitted.
1572 * As the irq is submitted after the interface is changed,
1573 * this is the best method i figured out.
1574 * Any others?*/
1575 if (dec->interface == TTUSB_DEC_INTERFACE_IN)
1576 usb_kill_urb(dec->irq_urb);
1577
1578 usb_free_urb(dec->irq_urb);
1579
1580 usb_free_coherent(dec->udev, IRQ_PACKET_SIZE,
1581 dec->irq_buffer, dec->irq_dma_handle);
1582 }
1583
1584 dec->iso_stream_count = 0;
1585
1586 for (i = 0; i < ISO_BUF_COUNT; i++)
1587 usb_kill_urb(dec->iso_urb[i]);
1588
1589 ttusb_dec_free_iso_urbs(dec);
1590 }
1591
1592 static void ttusb_dec_exit_bh_work(struct ttusb_dec *dec)
1593 {
1594 struct list_head *item;
1595 struct urb_frame *frame;
1596
1597 cancel_work_sync(&dec->urb_bh_work);
1598
1599 while ((item = dec->urb_frame_list.next) != &dec->urb_frame_list) {
1600 frame = list_entry(item, struct urb_frame, urb_frame_list);
1601 list_del(&frame->urb_frame_list);
1602 kfree(frame);
1603 }
1604 }
1605
1606 static void ttusb_dec_init_filters(struct ttusb_dec *dec)
1607 {
1608 INIT_LIST_HEAD(&dec->filter_info_list);
1609 spin_lock_init(&dec->filter_info_list_lock);
1610 }
1611
1612 static void ttusb_dec_exit_filters(struct ttusb_dec *dec)
1613 {
1614 struct list_head *item;
1615 struct filter_info *finfo;
1616
1617 while ((item = dec->filter_info_list.next) != &dec->filter_info_list) {
1618 finfo = list_entry(item, struct filter_info, filter_info_list);
1619 list_del(&finfo->filter_info_list);
1620 kfree(finfo);
1621 }
1622 }
1623
1624 static int fe_send_command(struct dvb_frontend* fe, const u8 command,
1625 int param_length, const u8 params[],
1626 int *result_length, u8 cmd_result[])
1627 {
1628 struct ttusb_dec* dec = fe->dvb->priv;
1629 return ttusb_dec_send_command(dec, command, param_length, params, result_length, cmd_result);
1630 }
1631
1632 static const struct ttusbdecfe_config fe_config = {
1633 .send_command = fe_send_command
1634 };
1635
1636 static int ttusb_dec_probe(struct usb_interface *intf,
1637 const struct usb_device_id *id)
1638 {
1639 struct usb_device *udev;
1640 struct ttusb_dec *dec;
1641 int result;
1642
1643 dprintk("%s\n", __func__);
1644
1645 udev = interface_to_usbdev(intf);
1646
1647 if (!(dec = kzalloc(sizeof(struct ttusb_dec), GFP_KERNEL))) {
1648 printk("%s: couldn't allocate memory.\n", __func__);
1649 return -ENOMEM;
1650 }
1651
1652 usb_set_intfdata(intf, (void *)dec);
1653
1654 switch (id->idProduct) {
1655 case 0x1006:
1656 ttusb_dec_set_model(dec, TTUSB_DEC3000S);
1657 break;
1658
1659 case 0x1008:
1660 ttusb_dec_set_model(dec, TTUSB_DEC2000T);
1661 break;
1662
1663 case 0x1009:
1664 ttusb_dec_set_model(dec, TTUSB_DEC2540T);
1665 break;
1666 }
1667
1668 dec->udev = udev;
1669
1670 result = ttusb_dec_init_usb(dec);
1671 if (result)
1672 goto err_usb;
1673 result = ttusb_dec_init_stb(dec);
1674 if (result)
1675 goto err_stb;
1676 result = ttusb_dec_init_dvb(dec);
1677 if (result)
1678 goto err_stb;
1679
1680 dec->adapter.priv = dec;
1681 switch (id->idProduct) {
1682 case 0x1006:
1683 dec->fe = ttusbdecfe_dvbs_attach(&fe_config);
1684 break;
1685
1686 case 0x1008:
1687 case 0x1009:
1688 dec->fe = ttusbdecfe_dvbt_attach(&fe_config);
1689 break;
1690 }
1691
1692 if (dec->fe == NULL) {
1693 printk("dvb-ttusb-dec: A frontend driver was not found for device [%04x:%04x]\n",
1694 le16_to_cpu(dec->udev->descriptor.idVendor),
1695 le16_to_cpu(dec->udev->descriptor.idProduct));
1696 } else {
1697 if (dvb_register_frontend(&dec->adapter, dec->fe)) {
1698 printk("budget-ci: Frontend registration failed!\n");
1699 if (dec->fe->ops.release)
1700 dec->fe->ops.release(dec->fe);
1701 dec->fe = NULL;
1702 }
1703 }
1704
1705 ttusb_dec_init_v_pes(dec);
1706 ttusb_dec_init_filters(dec);
1707 ttusb_dec_init_bh_work(dec);
1708
1709 dec->active = 1;
1710
1711 ttusb_dec_set_interface(dec, TTUSB_DEC_INTERFACE_IN);
1712
1713 if (enable_rc)
1714 ttusb_init_rc(dec);
1715
1716 return 0;
1717 err_stb:
1718 ttusb_dec_exit_usb(dec);
1719 err_usb:
1720 kfree(dec);
1721 return result;
1722 }
1723
1724 static void ttusb_dec_disconnect(struct usb_interface *intf)
1725 {
1726 struct ttusb_dec *dec = usb_get_intfdata(intf);
1727
1728 usb_set_intfdata(intf, NULL);
1729
1730 dprintk("%s\n", __func__);
1731
1732 if (dec->active) {
1733 ttusb_dec_exit_bh_work(dec);
1734 ttusb_dec_exit_filters(dec);
1735 if(enable_rc)
1736 ttusb_dec_exit_rc(dec);
1737 ttusb_dec_exit_usb(dec);
1738 ttusb_dec_exit_dvb(dec);
1739 }
1740
1741 kfree(dec);
1742 }
1743
1744 static void ttusb_dec_set_model(struct ttusb_dec *dec,
1745 enum ttusb_dec_model model)
1746 {
1747 dec->model = model;
1748
1749 switch (model) {
1750 case TTUSB_DEC2000T:
1751 dec->model_name = "DEC2000-t";
1752 dec->firmware_name = "dvb-ttusb-dec-2000t.fw";
1753 break;
1754
1755 case TTUSB_DEC2540T:
1756 dec->model_name = "DEC2540-t";
1757 dec->firmware_name = "dvb-ttusb-dec-2540t.fw";
1758 break;
1759
1760 case TTUSB_DEC3000S:
1761 dec->model_name = "DEC3000-s";
1762 dec->firmware_name = "dvb-ttusb-dec-3000s.fw";
1763 break;
1764 }
1765 }
1766
1767 static const struct usb_device_id ttusb_dec_table[] = {
1768 {USB_DEVICE(0x0b48, 0x1006)}, /* DEC3000-s */
1769 /*{USB_DEVICE(0x0b48, 0x1007)}, Unconfirmed */
1770 {USB_DEVICE(0x0b48, 0x1008)}, /* DEC2000-t */
1771 {USB_DEVICE(0x0b48, 0x1009)}, /* DEC2540-t */
1772 {}
1773 };
1774
1775 static struct usb_driver ttusb_dec_driver = {
1776 .name = "ttusb-dec",
1777 .probe = ttusb_dec_probe,
1778 .disconnect = ttusb_dec_disconnect,
1779 .id_table = ttusb_dec_table,
1780 };
1781
1782 module_usb_driver(ttusb_dec_driver);
1783
1784 MODULE_AUTHOR("Alex Woods <linux-dvb@giblets.org>");
1785 MODULE_DESCRIPTION(DRIVER_NAME);
1786 MODULE_LICENSE("GPL");
1787 MODULE_DEVICE_TABLE(usb, ttusb_dec_table);
Kernel DRM miscellaneous fixes and cross-tree changes