?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
get rid of input BIT* duplicate defines
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / media / dvb / ttusb-dec / ttusb_dec.c
blob1ec981d98b91bf60da958e0530dccca725b68474
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 #define dprintk if (debug) printk
56
57 #define DRIVER_NAME "TechnoTrend/Hauppauge DEC USB"
58
59 #define COMMAND_PIPE 0x03
60 #define RESULT_PIPE 0x04
61 #define IN_PIPE 0x08
62 #define OUT_PIPE 0x07
63 #define IRQ_PIPE 0x0A
64
65 #define COMMAND_PACKET_SIZE 0x3c
66 #define ARM_PACKET_SIZE 0x1000
67 #define IRQ_PACKET_SIZE 0x8
68
69 #define ISO_BUF_COUNT 0x04
70 #define FRAMES_PER_ISO_BUF 0x04
71 #define ISO_FRAME_SIZE 0x0380
72
73 #define MAX_PVA_LENGTH 6144
74
75 enum ttusb_dec_model {
76 TTUSB_DEC2000T,
77 TTUSB_DEC2540T,
78 TTUSB_DEC3000S
79 };
80
81 enum ttusb_dec_packet_type {
82 TTUSB_DEC_PACKET_PVA,
83 TTUSB_DEC_PACKET_SECTION,
84 TTUSB_DEC_PACKET_EMPTY
85 };
86
87 enum ttusb_dec_interface {
88 TTUSB_DEC_INTERFACE_INITIAL,
89 TTUSB_DEC_INTERFACE_IN,
90 TTUSB_DEC_INTERFACE_OUT
91 };
92
93 struct ttusb_dec {
94 enum ttusb_dec_model model;
95 char *model_name;
96 char *firmware_name;
97 int can_playback;
98
99 /* DVB bits */
100 struct dvb_adapter adapter;
101 struct dmxdev dmxdev;
102 struct dvb_demux demux;
103 struct dmx_frontend frontend;
104 struct dvb_net dvb_net;
105 struct dvb_frontend* fe;
106
107 u16 pid[DMX_PES_OTHER];
108
109 /* USB bits */
110 struct usb_device *udev;
111 u8 trans_count;
112 unsigned int command_pipe;
113 unsigned int result_pipe;
114 unsigned int in_pipe;
115 unsigned int out_pipe;
116 unsigned int irq_pipe;
117 enum ttusb_dec_interface interface;
118 struct mutex usb_mutex;
119
120 void *irq_buffer;
121 struct urb *irq_urb;
122 dma_addr_t irq_dma_handle;
123 void *iso_buffer;
124 dma_addr_t iso_dma_handle;
125 struct urb *iso_urb[ISO_BUF_COUNT];
126 int iso_stream_count;
127 struct mutex iso_mutex;
128
129 u8 packet[MAX_PVA_LENGTH + 4];
130 enum ttusb_dec_packet_type packet_type;
131 int packet_state;
132 int packet_length;
133 int packet_payload_length;
134 u16 next_packet_id;
135
136 int pva_stream_count;
137 int filter_stream_count;
138
139 struct dvb_filter_pes2ts a_pes2ts;
140 struct dvb_filter_pes2ts v_pes2ts;
141
142 u8 v_pes[16 + MAX_PVA_LENGTH];
143 int v_pes_length;
144 int v_pes_postbytes;
145
146 struct list_head urb_frame_list;
147 struct tasklet_struct urb_tasklet;
148 spinlock_t urb_frame_list_lock;
149
150 struct dvb_demux_filter *audio_filter;
151 struct dvb_demux_filter *video_filter;
152 struct list_head filter_info_list;
153 spinlock_t filter_info_list_lock;
154
155 struct input_dev *rc_input_dev;
156 char rc_phys[64];
157
158 int active; /* Loaded successfully */
159 };
160
161 struct urb_frame {
162 u8 data[ISO_FRAME_SIZE];
163 int length;
164 struct list_head urb_frame_list;
165 };
166
167 struct filter_info {
168 u8 stream_id;
169 struct dvb_demux_filter *filter;
170 struct list_head filter_info_list;
171 };
172
173 static u16 rc_keys[] = {
174 KEY_POWER,
175 KEY_MUTE,
176 KEY_1,
177 KEY_2,
178 KEY_3,
179 KEY_4,
180 KEY_5,
181 KEY_6,
182 KEY_7,
183 KEY_8,
184 KEY_9,
185 KEY_0,
186 KEY_CHANNELUP,
187 KEY_VOLUMEDOWN,
188 KEY_OK,
189 KEY_VOLUMEUP,
190 KEY_CHANNELDOWN,
191 KEY_PREVIOUS,
192 KEY_ESC,
193 KEY_RED,
194 KEY_GREEN,
195 KEY_YELLOW,
196 KEY_BLUE,
197 KEY_OPTION,
198 KEY_M,
199 KEY_RADIO
200 };
201
202 static void ttusb_dec_set_model(struct ttusb_dec *dec,
203 enum ttusb_dec_model model);
204
205 static void ttusb_dec_handle_irq( struct urb *urb)
206 {
207 struct ttusb_dec * dec = urb->context;
208 char *buffer = dec->irq_buffer;
209 int retval;
210
211 switch(urb->status) {
212 case 0: /*success*/
213 break;
214 case -ECONNRESET:
215 case -ENOENT:
216 case -ESHUTDOWN:
217 case -ETIME:
218 /* this urb is dead, cleanup */
219 dprintk("%s:urb shutting down with status: %d\n",
220 __FUNCTION__, urb->status);
221 return;
222 default:
223 dprintk("%s:nonzero status received: %d\n",
224 __FUNCTION__,urb->status);
225 goto exit;
226 }
227
228 if( (buffer[0] == 0x1) && (buffer[2] == 0x15) ) {
229 /* IR - Event */
230 /* this is an fact a bit too simple implementation;
231 * the box also reports a keyrepeat signal
232 * (with buffer[3] == 0x40) in an intervall of ~100ms.
233 * But to handle this correctly we had to imlemenent some
234 * kind of timer which signals a 'key up' event if no
235 * keyrepeat signal is recieved for lets say 200ms.
236 * this should/could be added later ...
237 * for now lets report each signal as a key down and up*/
238 dprintk("%s:rc signal:%d\n", __FUNCTION__, buffer[4]);
239 input_report_key(dec->rc_input_dev, rc_keys[buffer[4] - 1], 1);
240 input_sync(dec->rc_input_dev);
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)
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 usb_free_urb(dec->iso_urb[i]);
1139
1140 pci_free_consistent(NULL,
1141 ISO_FRAME_SIZE * (FRAMES_PER_ISO_BUF *
1142 ISO_BUF_COUNT),
1143 dec->iso_buffer, dec->iso_dma_handle);
1144 }
1145
1146 static int ttusb_dec_alloc_iso_urbs(struct ttusb_dec *dec)
1147 {
1148 int i;
1149
1150 dprintk("%s\n", __FUNCTION__);
1151
1152 dec->iso_buffer = pci_alloc_consistent(NULL,
1153 ISO_FRAME_SIZE *
1154 (FRAMES_PER_ISO_BUF *
1155 ISO_BUF_COUNT),
1156 &dec->iso_dma_handle);
1157
1158 memset(dec->iso_buffer, 0,
1159 ISO_FRAME_SIZE * (FRAMES_PER_ISO_BUF * ISO_BUF_COUNT));
1160
1161 for (i = 0; i < ISO_BUF_COUNT; i++) {
1162 struct urb *urb;
1163
1164 if (!(urb = usb_alloc_urb(FRAMES_PER_ISO_BUF, GFP_ATOMIC))) {
1165 ttusb_dec_free_iso_urbs(dec);
1166 return -ENOMEM;
1167 }
1168
1169 dec->iso_urb[i] = urb;
1170 }
1171
1172 ttusb_dec_setup_urbs(dec);
1173
1174 return 0;
1175 }
1176
1177 static void ttusb_dec_init_tasklet(struct ttusb_dec *dec)
1178 {
1179 spin_lock_init(&dec->urb_frame_list_lock);
1180 INIT_LIST_HEAD(&dec->urb_frame_list);
1181 tasklet_init(&dec->urb_tasklet, ttusb_dec_process_urb_frame_list,
1182 (unsigned long)dec);
1183 }
1184
1185 static int ttusb_init_rc( struct ttusb_dec *dec)
1186 {
1187 struct input_dev *input_dev;
1188 u8 b[] = { 0x00, 0x01 };
1189 int i;
1190 int err;
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 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_MASK(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 err = input_register_device(input_dev);
1210 if (err) {
1211 input_free_device(input_dev);
1212 return err;
1213 }
1214
1215 dec->rc_input_dev = input_dev;
1216 if (usb_submit_urb(dec->irq_urb, GFP_KERNEL))
1217 printk("%s: usb_submit_urb failed\n",__FUNCTION__);
1218 /* enable irq pipe */
1219 ttusb_dec_send_command(dec,0xb0,sizeof(b),b,NULL,NULL);
1220
1221 return 0;
1222 }
1223
1224 static void ttusb_dec_init_v_pes(struct ttusb_dec *dec)
1225 {
1226 dprintk("%s\n", __FUNCTION__);
1227
1228 dec->v_pes[0] = 0x00;
1229 dec->v_pes[1] = 0x00;
1230 dec->v_pes[2] = 0x01;
1231 dec->v_pes[3] = 0xe0;
1232 }
1233
1234 static int ttusb_dec_init_usb(struct ttusb_dec *dec)
1235 {
1236 dprintk("%s\n", __FUNCTION__);
1237
1238 mutex_init(&dec->usb_mutex);
1239 mutex_init(&dec->iso_mutex);
1240
1241 dec->command_pipe = usb_sndbulkpipe(dec->udev, COMMAND_PIPE);
1242 dec->result_pipe = usb_rcvbulkpipe(dec->udev, RESULT_PIPE);
1243 dec->in_pipe = usb_rcvisocpipe(dec->udev, IN_PIPE);
1244 dec->out_pipe = usb_sndisocpipe(dec->udev, OUT_PIPE);
1245 dec->irq_pipe = usb_rcvintpipe(dec->udev, IRQ_PIPE);
1246
1247 if(enable_rc) {
1248 dec->irq_urb = usb_alloc_urb(0, GFP_KERNEL);
1249 if(!dec->irq_urb) {
1250 return -ENOMEM;
1251 }
1252 dec->irq_buffer = usb_buffer_alloc(dec->udev,IRQ_PACKET_SIZE,
1253 GFP_ATOMIC, &dec->irq_dma_handle);
1254 if(!dec->irq_buffer) {
1255 return -ENOMEM;
1256 }
1257 usb_fill_int_urb(dec->irq_urb, dec->udev,dec->irq_pipe,
1258 dec->irq_buffer, IRQ_PACKET_SIZE,
1259 ttusb_dec_handle_irq, dec, 1);
1260 dec->irq_urb->transfer_dma = dec->irq_dma_handle;
1261 dec->irq_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1262 }
1263
1264 return ttusb_dec_alloc_iso_urbs(dec);
1265 }
1266
1267 static int ttusb_dec_boot_dsp(struct ttusb_dec *dec)
1268 {
1269 int i, j, actual_len, result, size, trans_count;
1270 u8 b0[] = { 0x00, 0x00, 0x00, 0x00,
1271 0x00, 0x00, 0x00, 0x00,
1272 0x61, 0x00 };
1273 u8 b1[] = { 0x61 };
1274 u8 *b;
1275 char idstring[21];
1276 u8 *firmware = NULL;
1277 size_t firmware_size = 0;
1278 u16 firmware_csum = 0;
1279 u16 firmware_csum_ns;
1280 u32 firmware_size_nl;
1281 u32 crc32_csum, crc32_check, tmp;
1282 const struct firmware *fw_entry = NULL;
1283
1284 dprintk("%s\n", __FUNCTION__);
1285
1286 if (request_firmware(&fw_entry, dec->firmware_name, &dec->udev->dev)) {
1287 printk(KERN_ERR "%s: Firmware (%s) unavailable.\n",
1288 __FUNCTION__, dec->firmware_name);
1289 return 1;
1290 }
1291
1292 firmware = fw_entry->data;
1293 firmware_size = fw_entry->size;
1294
1295 if (firmware_size < 60) {
1296 printk("%s: firmware size too small for DSP code (%zu < 60).\n",
1297 __FUNCTION__, firmware_size);
1298 release_firmware(fw_entry);
1299 return -1;
1300 }
1301
1302 /* a 32 bit checksum over the first 56 bytes of the DSP Code is stored
1303 at offset 56 of file, so use it to check if the firmware file is
1304 valid. */
1305 crc32_csum = crc32(~0L, firmware, 56) ^ ~0L;
1306 memcpy(&tmp, &firmware[56], 4);
1307 crc32_check = htonl(tmp);
1308 if (crc32_csum != crc32_check) {
1309 printk("%s: crc32 check of DSP code failed (calculated "
1310 "0x%08x != 0x%08x in file), file invalid.\n",
1311 __FUNCTION__, crc32_csum, crc32_check);
1312 release_firmware(fw_entry);
1313 return -1;
1314 }
1315 memcpy(idstring, &firmware[36], 20);
1316 idstring[20] = '\0';
1317 printk(KERN_INFO "ttusb_dec: found DSP code \"%s\".\n", idstring);
1318
1319 firmware_size_nl = htonl(firmware_size);
1320 memcpy(b0, &firmware_size_nl, 4);
1321 firmware_csum = crc16(~0, firmware, firmware_size) ^ ~0;
1322 firmware_csum_ns = htons(firmware_csum);
1323 memcpy(&b0[6], &firmware_csum_ns, 2);
1324
1325 result = ttusb_dec_send_command(dec, 0x41, sizeof(b0), b0, NULL, NULL);
1326
1327 if (result) {
1328 release_firmware(fw_entry);
1329 return result;
1330 }
1331
1332 trans_count = 0;
1333 j = 0;
1334
1335 b = kmalloc(ARM_PACKET_SIZE, GFP_KERNEL);
1336 if (b == NULL) {
1337 release_firmware(fw_entry);
1338 return -ENOMEM;
1339 }
1340
1341 for (i = 0; i < firmware_size; i += COMMAND_PACKET_SIZE) {
1342 size = firmware_size - i;
1343 if (size > COMMAND_PACKET_SIZE)
1344 size = COMMAND_PACKET_SIZE;
1345
1346 b[j + 0] = 0xaa;
1347 b[j + 1] = trans_count++;
1348 b[j + 2] = 0xf0;
1349 b[j + 3] = size;
1350 memcpy(&b[j + 4], &firmware[i], size);
1351
1352 j += COMMAND_PACKET_SIZE + 4;
1353
1354 if (j >= ARM_PACKET_SIZE) {
1355 result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
1356 ARM_PACKET_SIZE, &actual_len,
1357 100);
1358 j = 0;
1359 } else if (size < COMMAND_PACKET_SIZE) {
1360 result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
1361 j - COMMAND_PACKET_SIZE + size,
1362 &actual_len, 100);
1363 }
1364 }
1365
1366 result = ttusb_dec_send_command(dec, 0x43, sizeof(b1), b1, NULL, NULL);
1367
1368 release_firmware(fw_entry);
1369 kfree(b);
1370
1371 return result;
1372 }
1373
1374 static int ttusb_dec_init_stb(struct ttusb_dec *dec)
1375 {
1376 int result;
1377 unsigned int mode, model, version;
1378
1379 dprintk("%s\n", __FUNCTION__);
1380
1381 result = ttusb_dec_get_stb_state(dec, &mode, &model, &version);
1382
1383 if (!result) {
1384 if (!mode) {
1385 if (version == 0xABCDEFAB)
1386 printk(KERN_INFO "ttusb_dec: no version "
1387 "info in Firmware\n");
1388 else
1389 printk(KERN_INFO "ttusb_dec: Firmware "
1390 "%x.%02x%c%c\n",
1391 version >> 24, (version >> 16) & 0xff,
1392 (version >> 8) & 0xff, version & 0xff);
1393
1394 result = ttusb_dec_boot_dsp(dec);
1395 if (result)
1396 return result;
1397 else
1398 return 1;
1399 } else {
1400 /* We can't trust the USB IDs that some firmwares
1401 give the box */
1402 switch (model) {
1403 case 0x00070001:
1404 case 0x00070008:
1405 case 0x0007000c:
1406 ttusb_dec_set_model(dec, TTUSB_DEC3000S);
1407 break;
1408 case 0x00070009:
1409 case 0x00070013:
1410 ttusb_dec_set_model(dec, TTUSB_DEC2000T);
1411 break;
1412 case 0x00070011:
1413 ttusb_dec_set_model(dec, TTUSB_DEC2540T);
1414 break;
1415 default:
1416 printk(KERN_ERR "%s: unknown model returned "
1417 "by firmware (%08x) - please report\n",
1418 __FUNCTION__, model);
1419 return -1;
1420 break;
1421 }
1422
1423 if (version >= 0x01770000)
1424 dec->can_playback = 1;
1425
1426 return 0;
1427 }
1428 }
1429 else
1430 return result;
1431 }
1432
1433 static int ttusb_dec_init_dvb(struct ttusb_dec *dec)
1434 {
1435 int result;
1436
1437 dprintk("%s\n", __FUNCTION__);
1438
1439 if ((result = dvb_register_adapter(&dec->adapter,
1440 dec->model_name, THIS_MODULE, &dec->udev->dev)) < 0) {
1441 printk("%s: dvb_register_adapter failed: error %d\n",
1442 __FUNCTION__, result);
1443
1444 return result;
1445 }
1446
1447 dec->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING;
1448
1449 dec->demux.priv = (void *)dec;
1450 dec->demux.filternum = 31;
1451 dec->demux.feednum = 31;
1452 dec->demux.start_feed = ttusb_dec_start_feed;
1453 dec->demux.stop_feed = ttusb_dec_stop_feed;
1454 dec->demux.write_to_decoder = NULL;
1455
1456 if ((result = dvb_dmx_init(&dec->demux)) < 0) {
1457 printk("%s: dvb_dmx_init failed: error %d\n", __FUNCTION__,
1458 result);
1459
1460 dvb_unregister_adapter(&dec->adapter);
1461
1462 return result;
1463 }
1464
1465 dec->dmxdev.filternum = 32;
1466 dec->dmxdev.demux = &dec->demux.dmx;
1467 dec->dmxdev.capabilities = 0;
1468
1469 if ((result = dvb_dmxdev_init(&dec->dmxdev, &dec->adapter)) < 0) {
1470 printk("%s: dvb_dmxdev_init failed: error %d\n",
1471 __FUNCTION__, result);
1472
1473 dvb_dmx_release(&dec->demux);
1474 dvb_unregister_adapter(&dec->adapter);
1475
1476 return result;
1477 }
1478
1479 dec->frontend.source = DMX_FRONTEND_0;
1480
1481 if ((result = dec->demux.dmx.add_frontend(&dec->demux.dmx,
1482 &dec->frontend)) < 0) {
1483 printk("%s: dvb_dmx_init failed: error %d\n", __FUNCTION__,
1484 result);
1485
1486 dvb_dmxdev_release(&dec->dmxdev);
1487 dvb_dmx_release(&dec->demux);
1488 dvb_unregister_adapter(&dec->adapter);
1489
1490 return result;
1491 }
1492
1493 if ((result = dec->demux.dmx.connect_frontend(&dec->demux.dmx,
1494 &dec->frontend)) < 0) {
1495 printk("%s: dvb_dmx_init failed: error %d\n", __FUNCTION__,
1496 result);
1497
1498 dec->demux.dmx.remove_frontend(&dec->demux.dmx, &dec->frontend);
1499 dvb_dmxdev_release(&dec->dmxdev);
1500 dvb_dmx_release(&dec->demux);
1501 dvb_unregister_adapter(&dec->adapter);
1502
1503 return result;
1504 }
1505
1506 dvb_net_init(&dec->adapter, &dec->dvb_net, &dec->demux.dmx);
1507
1508 return 0;
1509 }
1510
1511 static void ttusb_dec_exit_dvb(struct ttusb_dec *dec)
1512 {
1513 dprintk("%s\n", __FUNCTION__);
1514
1515 dvb_net_release(&dec->dvb_net);
1516 dec->demux.dmx.close(&dec->demux.dmx);
1517 dec->demux.dmx.remove_frontend(&dec->demux.dmx, &dec->frontend);
1518 dvb_dmxdev_release(&dec->dmxdev);
1519 dvb_dmx_release(&dec->demux);
1520 if (dec->fe) {
1521 dvb_unregister_frontend(dec->fe);
1522 if (dec->fe->ops.release)
1523 dec->fe->ops.release(dec->fe);
1524 }
1525 dvb_unregister_adapter(&dec->adapter);
1526 }
1527
1528 static void ttusb_dec_exit_rc(struct ttusb_dec *dec)
1529 {
1530
1531 dprintk("%s\n", __FUNCTION__);
1532 /* we have to check whether the irq URB is already submitted.
1533 * As the irq is submitted after the interface is changed,
1534 * this is the best method i figured out.
1535 * Any others?*/
1536 if (dec->interface == TTUSB_DEC_INTERFACE_IN)
1537 usb_kill_urb(dec->irq_urb);
1538
1539 usb_free_urb(dec->irq_urb);
1540
1541 usb_buffer_free(dec->udev,IRQ_PACKET_SIZE,
1542 dec->irq_buffer, dec->irq_dma_handle);
1543
1544 if (dec->rc_input_dev) {
1545 input_unregister_device(dec->rc_input_dev);
1546 dec->rc_input_dev = NULL;
1547 }
1548 }
1549
1550
1551 static void ttusb_dec_exit_usb(struct ttusb_dec *dec)
1552 {
1553 int i;
1554
1555 dprintk("%s\n", __FUNCTION__);
1556
1557 dec->iso_stream_count = 0;
1558
1559 for (i = 0; i < ISO_BUF_COUNT; i++)
1560 usb_kill_urb(dec->iso_urb[i]);
1561
1562 ttusb_dec_free_iso_urbs(dec);
1563 }
1564
1565 static void ttusb_dec_exit_tasklet(struct ttusb_dec *dec)
1566 {
1567 struct list_head *item;
1568 struct urb_frame *frame;
1569
1570 tasklet_kill(&dec->urb_tasklet);
1571
1572 while ((item = dec->urb_frame_list.next) != &dec->urb_frame_list) {
1573 frame = list_entry(item, struct urb_frame, urb_frame_list);
1574 list_del(&frame->urb_frame_list);
1575 kfree(frame);
1576 }
1577 }
1578
1579 static void ttusb_dec_init_filters(struct ttusb_dec *dec)
1580 {
1581 INIT_LIST_HEAD(&dec->filter_info_list);
1582 spin_lock_init(&dec->filter_info_list_lock);
1583 }
1584
1585 static void ttusb_dec_exit_filters(struct ttusb_dec *dec)
1586 {
1587 struct list_head *item;
1588 struct filter_info *finfo;
1589
1590 while ((item = dec->filter_info_list.next) != &dec->filter_info_list) {
1591 finfo = list_entry(item, struct filter_info, filter_info_list);
1592 list_del(&finfo->filter_info_list);
1593 kfree(finfo);
1594 }
1595 }
1596
1597 static int fe_send_command(struct dvb_frontend* fe, const u8 command,
1598 int param_length, const u8 params[],
1599 int *result_length, u8 cmd_result[])
1600 {
1601 struct ttusb_dec* dec = fe->dvb->priv;
1602 return ttusb_dec_send_command(dec, command, param_length, params, result_length, cmd_result);
1603 }
1604
1605 static struct ttusbdecfe_config fe_config = {
1606 .send_command = fe_send_command
1607 };
1608
1609 static int ttusb_dec_probe(struct usb_interface *intf,
1610 const struct usb_device_id *id)
1611 {
1612 struct usb_device *udev;
1613 struct ttusb_dec *dec;
1614
1615 dprintk("%s\n", __FUNCTION__);
1616
1617 udev = interface_to_usbdev(intf);
1618
1619 if (!(dec = kzalloc(sizeof(struct ttusb_dec), GFP_KERNEL))) {
1620 printk("%s: couldn't allocate memory.\n", __FUNCTION__);
1621 return -ENOMEM;
1622 }
1623
1624 usb_set_intfdata(intf, (void *)dec);
1625
1626 switch (le16_to_cpu(id->idProduct)) {
1627 case 0x1006:
1628 ttusb_dec_set_model(dec, TTUSB_DEC3000S);
1629 break;
1630
1631 case 0x1008:
1632 ttusb_dec_set_model(dec, TTUSB_DEC2000T);
1633 break;
1634
1635 case 0x1009:
1636 ttusb_dec_set_model(dec, TTUSB_DEC2540T);
1637 break;
1638 }
1639
1640 dec->udev = udev;
1641
1642 if (ttusb_dec_init_usb(dec))
1643 return 0;
1644 if (ttusb_dec_init_stb(dec)) {
1645 ttusb_dec_exit_usb(dec);
1646 return 0;
1647 }
1648 ttusb_dec_init_dvb(dec);
1649
1650 dec->adapter.priv = dec;
1651 switch (le16_to_cpu(id->idProduct)) {
1652 case 0x1006:
1653 dec->fe = ttusbdecfe_dvbs_attach(&fe_config);
1654 break;
1655
1656 case 0x1008:
1657 case 0x1009:
1658 dec->fe = ttusbdecfe_dvbt_attach(&fe_config);
1659 break;
1660 }
1661
1662 if (dec->fe == NULL) {
1663 printk("dvb-ttusb-dec: A frontend driver was not found for device %04x/%04x\n",
1664 le16_to_cpu(dec->udev->descriptor.idVendor),
1665 le16_to_cpu(dec->udev->descriptor.idProduct));
1666 } else {
1667 if (dvb_register_frontend(&dec->adapter, dec->fe)) {
1668 printk("budget-ci: Frontend registration failed!\n");
1669 if (dec->fe->ops.release)
1670 dec->fe->ops.release(dec->fe);
1671 dec->fe = NULL;
1672 }
1673 }
1674
1675 ttusb_dec_init_v_pes(dec);
1676 ttusb_dec_init_filters(dec);
1677 ttusb_dec_init_tasklet(dec);
1678
1679 dec->active = 1;
1680
1681 ttusb_dec_set_interface(dec, TTUSB_DEC_INTERFACE_IN);
1682
1683 if (enable_rc)
1684 ttusb_init_rc(dec);
1685
1686 return 0;
1687 }
1688
1689 static void ttusb_dec_disconnect(struct usb_interface *intf)
1690 {
1691 struct ttusb_dec *dec = usb_get_intfdata(intf);
1692
1693 usb_set_intfdata(intf, NULL);
1694
1695 dprintk("%s\n", __FUNCTION__);
1696
1697 if (dec->active) {
1698 ttusb_dec_exit_tasklet(dec);
1699 ttusb_dec_exit_filters(dec);
1700 if(enable_rc)
1701 ttusb_dec_exit_rc(dec);
1702 ttusb_dec_exit_usb(dec);
1703 ttusb_dec_exit_dvb(dec);
1704 }
1705
1706 kfree(dec);
1707 }
1708
1709 static void ttusb_dec_set_model(struct ttusb_dec *dec,
1710 enum ttusb_dec_model model)
1711 {
1712 dec->model = model;
1713
1714 switch (model) {
1715 case TTUSB_DEC2000T:
1716 dec->model_name = "DEC2000-t";
1717 dec->firmware_name = "dvb-ttusb-dec-2000t.fw";
1718 break;
1719
1720 case TTUSB_DEC2540T:
1721 dec->model_name = "DEC2540-t";
1722 dec->firmware_name = "dvb-ttusb-dec-2540t.fw";
1723 break;
1724
1725 case TTUSB_DEC3000S:
1726 dec->model_name = "DEC3000-s";
1727 dec->firmware_name = "dvb-ttusb-dec-3000s.fw";
1728 break;
1729 }
1730 }
1731
1732 static struct usb_device_id ttusb_dec_table[] = {
1733 {USB_DEVICE(0x0b48, 0x1006)}, /* DEC3000-s */
1734 /*{USB_DEVICE(0x0b48, 0x1007)}, Unconfirmed */
1735 {USB_DEVICE(0x0b48, 0x1008)}, /* DEC2000-t */
1736 {USB_DEVICE(0x0b48, 0x1009)}, /* DEC2540-t */
1737 {}
1738 };
1739
1740 static struct usb_driver ttusb_dec_driver = {
1741 .name = "ttusb-dec",
1742 .probe = ttusb_dec_probe,
1743 .disconnect = ttusb_dec_disconnect,
1744 .id_table = ttusb_dec_table,
1745 };
1746
1747 static int __init ttusb_dec_init(void)
1748 {
1749 int result;
1750
1751 if ((result = usb_register(&ttusb_dec_driver)) < 0) {
1752 printk("%s: initialisation failed: error %d.\n", __FUNCTION__,
1753 result);
1754 return result;
1755 }
1756
1757 return 0;
1758 }
1759
1760 static void __exit ttusb_dec_exit(void)
1761 {
1762 usb_deregister(&ttusb_dec_driver);
1763 }
1764
1765 module_init(ttusb_dec_init);
1766 module_exit(ttusb_dec_exit);
1767
1768 MODULE_AUTHOR("Alex Woods <linux-dvb@giblets.org>");
1769 MODULE_DESCRIPTION(DRIVER_NAME);
1770 MODULE_LICENSE("GPL");
1771 MODULE_DEVICE_TABLE(usb, ttusb_dec_table);
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree