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