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