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