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