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