]> 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
V4L/DVB (3216): saa7134 card #58 has a newer revision with a new subsystem ID
[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
b7df3910
DT		 155 struct input_dev *rc_input_dev;
156 char rc_phys[64];
1da177e4
LT		 157
158 int active; /* Loaded successfully */
159};
160
161struct urb_frame {
162 u8 data[ISO_FRAME_SIZE];
163 int length;
164 struct list_head urb_frame_list;
165};
166
167struct filter_info {
168 u8 stream_id;
169 struct dvb_demux_filter *filter;
170 struct list_head filter_info_list;
171};
172
173static 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
202static void ttusb_dec_set_model(struct ttusb_dec *dec,
203 enum ttusb_dec_model model);
204
205static void ttusb_dec_handle_irq( struct urb *urb, struct pt_regs *regs)
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 -ETIMEDOUT:
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]);
b7df3910
DT		 239 input_report_key(dec->rc_input_dev, rc_keys[buffer[4] - 1], 1);
240 input_report_key(dec->rc_input_dev, rc_keys[buffer[4] - 1], 0);
241 input_sync(dec->rc_input_dev);
1da177e4
LT		 242 }
243
244exit: retval = usb_submit_urb(urb, GFP_ATOMIC);
245 if(retval)
246 printk("%s - usb_commit_urb failed with result: %d\n",
247 __FUNCTION__, retval);
248}
249
250static u16 crc16(u16 crc, const u8 *buf, size_t len)
251{
252 u16 tmp;
253
254 while (len--) {
255 crc ^= *buf++;
256 crc ^= (u8)crc >> 4;
257 tmp = (u8)crc;
258 crc ^= (tmp ^ (tmp << 1)) << 4;
259 }
260 return crc;
261}
262
263static int ttusb_dec_send_command(struct ttusb_dec *dec, const u8 command,
264 int param_length, const u8 params[],
265 int *result_length, u8 cmd_result[])
266{
267 int result, actual_len, i;
268 u8 *b;
269
270 dprintk("%s\n", __FUNCTION__);
271
272 b = kmalloc(COMMAND_PACKET_SIZE + 4, GFP_KERNEL);
273 if (!b)
274 return -ENOMEM;
275
276 if ((result = down_interruptible(&dec->usb_sem))) {
277 kfree(b);
278 printk("%s: Failed to down usb semaphore.\n", __FUNCTION__);
279 return result;
280 }
281
282 b[0] = 0xaa;
283 b[1] = ++dec->trans_count;
284 b[2] = command;
285 b[3] = param_length;
286
287 if (params)
288 memcpy(&b[4], params, param_length);
289
290 if (debug) {
291 printk("%s: command: ", __FUNCTION__);
292 for (i = 0; i < param_length + 4; i++)
293 printk("0x%02X ", b[i]);
294 printk("\n");
295 }
296
297 result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
298 COMMAND_PACKET_SIZE + 4, &actual_len, 1000);
299
300 if (result) {
301 printk("%s: command bulk message failed: error %d\n",
302 __FUNCTION__, result);
303 up(&dec->usb_sem);
304 kfree(b);
305 return result;
306 }
307
308 result = usb_bulk_msg(dec->udev, dec->result_pipe, b,
309 COMMAND_PACKET_SIZE + 4, &actual_len, 1000);
310
311 if (result) {
312 printk("%s: result bulk message failed: error %d\n",
313 __FUNCTION__, result);
314 up(&dec->usb_sem);
315 kfree(b);
316 return result;
317 } else {
318 if (debug) {
319 printk("%s: result: ", __FUNCTION__);
320 for (i = 0; i < actual_len; i++)
321 printk("0x%02X ", b[i]);
322 printk("\n");
323 }
324
325 if (result_length)
326 *result_length = b[3];
327 if (cmd_result && b[3] > 0)
328 memcpy(cmd_result, &b[4], b[3]);
329
330 up(&dec->usb_sem);
331
332 kfree(b);
333 return 0;
334 }
335}
336
337static int ttusb_dec_get_stb_state (struct ttusb_dec *dec, unsigned int *mode,
338 unsigned int *model, unsigned int *version)
339{
340 u8 c[COMMAND_PACKET_SIZE];
341 int c_length;
342 int result;
343 unsigned int tmp;
344
345 dprintk("%s\n", __FUNCTION__);
346
347 result = ttusb_dec_send_command(dec, 0x08, 0, NULL, &c_length, c);
348 if (result)
349 return result;
350
351 if (c_length >= 0x0c) {
352 if (mode != NULL) {
353 memcpy(&tmp, c, 4);
354 *mode = ntohl(tmp);
355 }
356 if (model != NULL) {
357 memcpy(&tmp, &c[4], 4);
358 *model = ntohl(tmp);
359 }
360 if (version != NULL) {
361 memcpy(&tmp, &c[8], 4);
362 *version = ntohl(tmp);
363 }
364 return 0;
365 } else {
366 return -1;
367 }
368}
369
370static int ttusb_dec_audio_pes2ts_cb(void *priv, unsigned char *data)
371{
f961e71a 372 struct ttusb_dec *dec = priv;
1da177e4
LT		 373
374 dec->audio_filter->feed->cb.ts(data, 188, NULL, 0,
375 &dec->audio_filter->feed->feed.ts,
376 DMX_OK);
377
378 return 0;
379}
380
381static int ttusb_dec_video_pes2ts_cb(void *priv, unsigned char *data)
382{
f961e71a 383 struct ttusb_dec *dec = priv;
1da177e4
LT		 384
385 dec->video_filter->feed->cb.ts(data, 188, NULL, 0,
386 &dec->video_filter->feed->feed.ts,
387 DMX_OK);
388
389 return 0;
390}
391
392static void ttusb_dec_set_pids(struct ttusb_dec *dec)
393{
394 u8 b[] = { 0x00, 0x00, 0x00, 0x00,
395 0x00, 0x00, 0xff, 0xff,
396 0xff, 0xff, 0xff, 0xff };
397
398 u16 pcr = htons(dec->pid[DMX_PES_PCR]);
399 u16 audio = htons(dec->pid[DMX_PES_AUDIO]);
400 u16 video = htons(dec->pid[DMX_PES_VIDEO]);
401
402 dprintk("%s\n", __FUNCTION__);
403
404 memcpy(&b[0], &pcr, 2);
405 memcpy(&b[2], &audio, 2);
406 memcpy(&b[4], &video, 2);
407
408 ttusb_dec_send_command(dec, 0x50, sizeof(b), b, NULL, NULL);
409
410 dvb_filter_pes2ts_init(&dec->a_pes2ts, dec->pid[DMX_PES_AUDIO],
411 ttusb_dec_audio_pes2ts_cb, dec);
412 dvb_filter_pes2ts_init(&dec->v_pes2ts, dec->pid[DMX_PES_VIDEO],
413 ttusb_dec_video_pes2ts_cb, dec);
414 dec->v_pes_length = 0;
415 dec->v_pes_postbytes = 0;
416}
417
418static void ttusb_dec_process_pva(struct ttusb_dec *dec, u8 *pva, int length)
419{
420 if (length < 8) {
421 printk("%s: packet too short - discarding\n", __FUNCTION__);
422 return;
423 }
424
425 if (length > 8 + MAX_PVA_LENGTH) {
426 printk("%s: packet too long - discarding\n", __FUNCTION__);
427 return;
428 }
429
430 switch (pva[2]) {
431
432 case 0x01: { /* VideoStream */
433 int prebytes = pva[5] & 0x03;
434 int postbytes = (pva[5] & 0x0c) >> 2;
435 u16 v_pes_payload_length;
436
437 if (output_pva) {
438 dec->video_filter->feed->cb.ts(pva, length, NULL, 0,
439 &dec->video_filter->feed->feed.ts, DMX_OK);
440 return;
441 }
442
443 if (dec->v_pes_postbytes > 0 &&
444 dec->v_pes_postbytes == prebytes) {
445 memcpy(&dec->v_pes[dec->v_pes_length],
446 &pva[12], prebytes);
447
448 dvb_filter_pes2ts(&dec->v_pes2ts, dec->v_pes,
449 dec->v_pes_length + prebytes, 1);
450 }
451
452 if (pva[5] & 0x10) {
453 dec->v_pes[7] = 0x80;
454 dec->v_pes[8] = 0x05;
455
456 dec->v_pes[9] = 0x21 | ((pva[8] & 0xc0) >> 5);
457 dec->v_pes[10] = ((pva[8] & 0x3f) << 2) |
458 ((pva[9] & 0xc0) >> 6);
459 dec->v_pes[11] = 0x01 |
460 ((pva[9] & 0x3f) << 2) |
461 ((pva[10] & 0x80) >> 6);
462 dec->v_pes[12] = ((pva[10] & 0x7f) << 1) |
463 ((pva[11] & 0xc0) >> 7);
464 dec->v_pes[13] = 0x01 | ((pva[11] & 0x7f) << 1);
465
466 memcpy(&dec->v_pes[14], &pva[12 + prebytes],
467 length - 12 - prebytes);
468 dec->v_pes_length = 14 + length - 12 - prebytes;
469 } else {
470 dec->v_pes[7] = 0x00;
471 dec->v_pes[8] = 0x00;
472
473 memcpy(&dec->v_pes[9], &pva[8], length - 8);
474 dec->v_pes_length = 9 + length - 8;
475 }
476
477 dec->v_pes_postbytes = postbytes;
478
479 if (dec->v_pes[9 + dec->v_pes[8]] == 0x00 &&
480 dec->v_pes[10 + dec->v_pes[8]] == 0x00 &&
481 dec->v_pes[11 + dec->v_pes[8]] == 0x01)
482 dec->v_pes[6] = 0x84;
483 else
484 dec->v_pes[6] = 0x80;
485
486 v_pes_payload_length = htons(dec->v_pes_length - 6 +
487 postbytes);
488 memcpy(&dec->v_pes[4], &v_pes_payload_length, 2);
489
490 if (postbytes == 0)
491 dvb_filter_pes2ts(&dec->v_pes2ts, dec->v_pes,
492 dec->v_pes_length, 1);
493
494 break;
495 }
496
497 case 0x02: /* MainAudioStream */
498 if (output_pva) {
499 dec->audio_filter->feed->cb.ts(pva, length, NULL, 0,
500 &dec->audio_filter->feed->feed.ts, DMX_OK);
501 return;
502 }
503
504 dvb_filter_pes2ts(&dec->a_pes2ts, &pva[8], length - 8,
505 pva[5] & 0x10);
506 break;
507
508 default:
509 printk("%s: unknown PVA type: %02x.\n", __FUNCTION__,
510 pva[2]);
511 break;
512 }
513}
514
515static void ttusb_dec_process_filter(struct ttusb_dec *dec, u8 *packet,
516 int length)
517{
518 struct list_head *item;
519 struct filter_info *finfo;
520 struct dvb_demux_filter *filter = NULL;
521 unsigned long flags;
522 u8 sid;
523
524 sid = packet[1];
525 spin_lock_irqsave(&dec->filter_info_list_lock, flags);
526 for (item = dec->filter_info_list.next; item != &dec->filter_info_list;
527 item = item->next) {
528 finfo = list_entry(item, struct filter_info, filter_info_list);
529 if (finfo->stream_id == sid) {
530 filter = finfo->filter;
531 break;
532 }
533 }
534 spin_unlock_irqrestore(&dec->filter_info_list_lock, flags);
535
536 if (filter)
537 filter->feed->cb.sec(&packet[2], length - 2, NULL, 0,
538 &filter->filter, DMX_OK);
539}
540
541static void ttusb_dec_process_packet(struct ttusb_dec *dec)
542{
543 int i;
544 u16 csum = 0;
545 u16 packet_id;
546
547 if (dec->packet_length % 2) {
548 printk("%s: odd sized packet - discarding\n", __FUNCTION__);
549 return;
550 }
551
552 for (i = 0; i < dec->packet_length; i += 2)
553 csum ^= ((dec->packet[i] << 8) + dec->packet[i + 1]);
554
555 if (csum) {
556 printk("%s: checksum failed - discarding\n", __FUNCTION__);
557 return;
558 }
559
560 packet_id = dec->packet[dec->packet_length - 4] << 8;
561 packet_id += dec->packet[dec->packet_length - 3];
562
563 if ((packet_id != dec->next_packet_id) && dec->next_packet_id) {
564 printk("%s: warning: lost packets between %u and %u\n",
565 __FUNCTION__, dec->next_packet_id - 1, packet_id);
566 }
567
568 if (packet_id == 0xffff)
569 dec->next_packet_id = 0x8000;
570 else
571 dec->next_packet_id = packet_id + 1;
572
573 switch (dec->packet_type) {
574 case TTUSB_DEC_PACKET_PVA:
575 if (dec->pva_stream_count)
576 ttusb_dec_process_pva(dec, dec->packet,
577 dec->packet_payload_length);
578 break;
579
580 case TTUSB_DEC_PACKET_SECTION:
581 if (dec->filter_stream_count)
582 ttusb_dec_process_filter(dec, dec->packet,
583 dec->packet_payload_length);
584 break;
585
586 case TTUSB_DEC_PACKET_EMPTY:
587 break;
588 }
589}
590
591static void swap_bytes(u8 *b, int length)
592{
593 u8 c;
594
595 length -= length % 2;
596 for (; length; b += 2, length -= 2) {
597 c = *b;
598 *b = *(b + 1);
599 *(b + 1) = c;
600 }
601}
602
603static void ttusb_dec_process_urb_frame(struct ttusb_dec *dec, u8 *b,
604 int length)
605{
606 swap_bytes(b, length);
607
608 while (length) {
609 switch (dec->packet_state) {
610
611 case 0:
612 case 1:
613 case 2:
614 if (*b++ == 0xaa)
615 dec->packet_state++;
616 else
617 dec->packet_state = 0;
618
619 length--;
620 break;
621
622 case 3:
623 if (*b == 0x00) {
624 dec->packet_state++;
625 dec->packet_length = 0;
626 } else if (*b != 0xaa) {
627 dec->packet_state = 0;
628 }
629
630 b++;
631 length--;
632 break;
633
634 case 4:
635 dec->packet[dec->packet_length++] = *b++;
636
637 if (dec->packet_length == 2) {
638 if (dec->packet[0] == 'A' &&
639 dec->packet[1] == 'V') {
640 dec->packet_type =
641 TTUSB_DEC_PACKET_PVA;
642 dec->packet_state++;
643 } else if (dec->packet[0] == 'S') {
644 dec->packet_type =
645 TTUSB_DEC_PACKET_SECTION;
646 dec->packet_state++;
647 } else if (dec->packet[0] == 0x00) {
648 dec->packet_type =
649 TTUSB_DEC_PACKET_EMPTY;
650 dec->packet_payload_length = 2;
651 dec->packet_state = 7;
652 } else {
653 printk("%s: unknown packet type: "
654 "%02x%02x\n", __FUNCTION__,
655 dec->packet[0], dec->packet[1]);
656 dec->packet_state = 0;
657 }
658 }
659
660 length--;
661 break;
662
663 case 5:
664 dec->packet[dec->packet_length++] = *b++;
665
666 if (dec->packet_type == TTUSB_DEC_PACKET_PVA &&
667 dec->packet_length == 8) {
668 dec->packet_state++;
669 dec->packet_payload_length = 8 +
670 (dec->packet[6] << 8) +
671 dec->packet[7];
672 } else if (dec->packet_type ==
673 TTUSB_DEC_PACKET_SECTION &&
674 dec->packet_length == 5) {
675 dec->packet_state++;
676 dec->packet_payload_length = 5 +
677 ((dec->packet[3] & 0x0f) << 8) +
678 dec->packet[4];
679 }
680
681 length--;
682 break;
683
684 case 6: {
685 int remainder = dec->packet_payload_length -
686 dec->packet_length;
687
688 if (length >= remainder) {
689 memcpy(dec->packet + dec->packet_length,
690 b, remainder);
691 dec->packet_length += remainder;
692 b += remainder;
693 length -= remainder;
694 dec->packet_state++;
695 } else {
696 memcpy(&dec->packet[dec->packet_length],
697 b, length);
698 dec->packet_length += length;
699 length = 0;
700 }
701
702 break;
703 }
704
705 case 7: {
706 int tail = 4;
707
708 dec->packet[dec->packet_length++] = *b++;
709
710 if (dec->packet_type == TTUSB_DEC_PACKET_SECTION &&
711 dec->packet_payload_length % 2)
712 tail++;
713
714 if (dec->packet_length ==
715 dec->packet_payload_length + tail) {
716 ttusb_dec_process_packet(dec);
717 dec->packet_state = 0;
718 }
719
720 length--;
721 break;
722 }
723
724 default:
725 printk("%s: illegal packet state encountered.\n",
726 __FUNCTION__);
727 dec->packet_state = 0;
728 }
729 }
730}
731
732static void ttusb_dec_process_urb_frame_list(unsigned long data)
733{
734 struct ttusb_dec *dec = (struct ttusb_dec *)data;
735 struct list_head *item;
736 struct urb_frame *frame;
737 unsigned long flags;
738
739 while (1) {
740 spin_lock_irqsave(&dec->urb_frame_list_lock, flags);
741 if ((item = dec->urb_frame_list.next) != &dec->urb_frame_list) {
742 frame = list_entry(item, struct urb_frame,
743 urb_frame_list);
744 list_del(&frame->urb_frame_list);
745 } else {
746 spin_unlock_irqrestore(&dec->urb_frame_list_lock,
747 flags);
748 return;
749 }
750 spin_unlock_irqrestore(&dec->urb_frame_list_lock, flags);
751
752 ttusb_dec_process_urb_frame(dec, frame->data, frame->length);
753 kfree(frame);
754 }
755}
756
757static void ttusb_dec_process_urb(struct urb *urb, struct pt_regs *ptregs)
758{
759 struct ttusb_dec *dec = urb->context;
760
761 if (!urb->status) {
762 int i;
763
764 for (i = 0; i < FRAMES_PER_ISO_BUF; i++) {
765 struct usb_iso_packet_descriptor *d;
766 u8 *b;
767 int length;
768 struct urb_frame *frame;
769
770 d = &urb->iso_frame_desc[i];
771 b = urb->transfer_buffer + d->offset;
772 length = d->actual_length;
773
774 if ((frame = kmalloc(sizeof(struct urb_frame),
775 GFP_ATOMIC))) {
776 unsigned long flags;
777
778 memcpy(frame->data, b, length);
779 frame->length = length;
780
781 spin_lock_irqsave(&dec->urb_frame_list_lock,
782 flags);
783 list_add_tail(&frame->urb_frame_list,
784 &dec->urb_frame_list);
785 spin_unlock_irqrestore(&dec->urb_frame_list_lock,
786 flags);
787
788 tasklet_schedule(&dec->urb_tasklet);
789 }
790 }
791 } else {
792 /* -ENOENT is expected when unlinking urbs */
793 if (urb->status != -ENOENT)
794 dprintk("%s: urb error: %d\n", __FUNCTION__,
795 urb->status);
796 }
797
798 if (dec->iso_stream_count)
799 usb_submit_urb(urb, GFP_ATOMIC);
800}
801
802static void ttusb_dec_setup_urbs(struct ttusb_dec *dec)
803{
804 int i, j, buffer_offset = 0;
805
806 dprintk("%s\n", __FUNCTION__);
807
808 for (i = 0; i < ISO_BUF_COUNT; i++) {
809 int frame_offset = 0;
810 struct urb *urb = dec->iso_urb[i];
811
812 urb->dev = dec->udev;
813 urb->context = dec;
814 urb->complete = ttusb_dec_process_urb;
815 urb->pipe = dec->in_pipe;
816 urb->transfer_flags = URB_ISO_ASAP;
817 urb->interval = 1;
818 urb->number_of_packets = FRAMES_PER_ISO_BUF;
819 urb->transfer_buffer_length = ISO_FRAME_SIZE *
820 FRAMES_PER_ISO_BUF;
821 urb->transfer_buffer = dec->iso_buffer + buffer_offset;
822 buffer_offset += ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF;
823
824 for (j = 0; j < FRAMES_PER_ISO_BUF; j++) {
825 urb->iso_frame_desc[j].offset = frame_offset;
826 urb->iso_frame_desc[j].length = ISO_FRAME_SIZE;
827 frame_offset += ISO_FRAME_SIZE;
828 }
829 }
830}
831
832static void ttusb_dec_stop_iso_xfer(struct ttusb_dec *dec)
833{
834 int i;
835
836 dprintk("%s\n", __FUNCTION__);
837
838 if (down_interruptible(&dec->iso_sem))
839 return;
840
841 dec->iso_stream_count--;
842
843 if (!dec->iso_stream_count) {
844 for (i = 0; i < ISO_BUF_COUNT; i++)
845 usb_kill_urb(dec->iso_urb[i]);
846 }
847
848 up(&dec->iso_sem);
849}
850
851/* Setting the interface of the DEC tends to take down the USB communications
852 * for a short period, so it's important not to call this function just before
853 * trying to talk to it.
854 */
855static int ttusb_dec_set_interface(struct ttusb_dec *dec,
856 enum ttusb_dec_interface interface)
857{
858 int result = 0;
859 u8 b[] = { 0x05 };
860
861 if (interface != dec->interface) {
862 switch (interface) {
863 case TTUSB_DEC_INTERFACE_INITIAL:
864 result = usb_set_interface(dec->udev, 0, 0);
865 break;
866 case TTUSB_DEC_INTERFACE_IN:
867 result = ttusb_dec_send_command(dec, 0x80, sizeof(b),
868 b, NULL, NULL);
869 if (result)
870 return result;
871 result = usb_set_interface(dec->udev, 0, 8);
872 break;
873 case TTUSB_DEC_INTERFACE_OUT:
874 result = usb_set_interface(dec->udev, 0, 1);
875 break;
876 }
877
878 if (result)
879 return result;
880
881 dec->interface = interface;
882 }
883
884 return 0;
885}
886
887static int ttusb_dec_start_iso_xfer(struct ttusb_dec *dec)
888{
889 int i, result;
890
891 dprintk("%s\n", __FUNCTION__);
892
893 if (down_interruptible(&dec->iso_sem))
894 return -EAGAIN;
895
896 if (!dec->iso_stream_count) {
897 ttusb_dec_setup_urbs(dec);
898
899 dec->packet_state = 0;
900 dec->v_pes_postbytes = 0;
901 dec->next_packet_id = 0;
902
903 for (i = 0; i < ISO_BUF_COUNT; i++) {
904 if ((result = usb_submit_urb(dec->iso_urb[i],
905 GFP_ATOMIC))) {
906 printk("%s: failed urb submission %d: "
907 "error %d\n", __FUNCTION__, i, result);
908
909 while (i) {
910 usb_kill_urb(dec->iso_urb[i - 1]);
911 i--;
912 }
913
914 up(&dec->iso_sem);
915 return result;
916 }
917 }
918 }
919
920 dec->iso_stream_count++;
921
922 up(&dec->iso_sem);
923
924 return 0;
925}
926
927static int ttusb_dec_start_ts_feed(struct dvb_demux_feed *dvbdmxfeed)
928{
929 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
930 struct ttusb_dec *dec = dvbdmx->priv;
931 u8 b0[] = { 0x05 };
932 int result = 0;
933
934 dprintk("%s\n", __FUNCTION__);
935
936 dprintk(" ts_type:");
937
938 if (dvbdmxfeed->ts_type & TS_DECODER)
939 dprintk(" TS_DECODER");
940
941 if (dvbdmxfeed->ts_type & TS_PACKET)
942 dprintk(" TS_PACKET");
943
944 if (dvbdmxfeed->ts_type & TS_PAYLOAD_ONLY)
945 dprintk(" TS_PAYLOAD_ONLY");
946
947 dprintk("\n");
948
949 switch (dvbdmxfeed->pes_type) {
950
951 case DMX_TS_PES_VIDEO:
952 dprintk(" pes_type: DMX_TS_PES_VIDEO\n");
953 dec->pid[DMX_PES_PCR] = dvbdmxfeed->pid;
954 dec->pid[DMX_PES_VIDEO] = dvbdmxfeed->pid;
955 dec->video_filter = dvbdmxfeed->filter;
956 ttusb_dec_set_pids(dec);
957 break;
958
959 case DMX_TS_PES_AUDIO:
960 dprintk(" pes_type: DMX_TS_PES_AUDIO\n");
961 dec->pid[DMX_PES_AUDIO] = dvbdmxfeed->pid;
962 dec->audio_filter = dvbdmxfeed->filter;
963 ttusb_dec_set_pids(dec);
964 break;
965
966 case DMX_TS_PES_TELETEXT:
967 dec->pid[DMX_PES_TELETEXT] = dvbdmxfeed->pid;
f961e71a
AW		 968 dprintk(" pes_type: DMX_TS_PES_TELETEXT(not supported)\n");
969 return -ENOSYS;
1da177e4
LT		 970
971 case DMX_TS_PES_PCR:
972 dprintk(" pes_type: DMX_TS_PES_PCR\n");
973 dec->pid[DMX_PES_PCR] = dvbdmxfeed->pid;
974 ttusb_dec_set_pids(dec);
975 break;
976
977 case DMX_TS_PES_OTHER:
f961e71a
AW		 978 dprintk(" pes_type: DMX_TS_PES_OTHER(not supported)\n");
979 return -ENOSYS;
1da177e4
LT		 980
981 default:
982 dprintk(" pes_type: unknown (%d)\n", dvbdmxfeed->pes_type);
983 return -EINVAL;
984
985 }
986
987 result = ttusb_dec_send_command(dec, 0x80, sizeof(b0), b0, NULL, NULL);
988 if (result)
989 return result;
990
991 dec->pva_stream_count++;
992 return ttusb_dec_start_iso_xfer(dec);
993}
994
995static int ttusb_dec_start_sec_feed(struct dvb_demux_feed *dvbdmxfeed)
996{
997 struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
998 u8 b0[] = { 0x00, 0x00, 0x00, 0x01,
999 0x00, 0x00, 0x00, 0x00,
1000 0x00, 0x00, 0x00, 0x00,
1001 0x00, 0x00, 0x00, 0x00,
1002 0x00, 0xff, 0x00, 0x00,
1003 0x00, 0x00, 0x00, 0x00,
1004 0x00, 0x00, 0x00, 0x00,
1005 0x00 };
1006 u16 pid;
1007 u8 c[COMMAND_PACKET_SIZE];
1008 int c_length;
1009 int result;
1010 struct filter_info *finfo;
1011 unsigned long flags;
1012 u8 x = 1;
1013
1014 dprintk("%s\n", __FUNCTION__);
1015
1016 pid = htons(dvbdmxfeed->pid);
1017 memcpy(&b0[0], &pid, 2);
1018 memcpy(&b0[4], &x, 1);
1019 memcpy(&b0[5], &dvbdmxfeed->filter->filter.filter_value[0], 1);
1020
1021 result = ttusb_dec_send_command(dec, 0x60, sizeof(b0), b0,
1022 &c_length, c);
1023
1024 if (!result) {
1025 if (c_length == 2) {
1026 if (!(finfo = kmalloc(sizeof(struct filter_info),
1027 GFP_ATOMIC)))
1028 return -ENOMEM;
1029
1030 finfo->stream_id = c[1];
1031 finfo->filter = dvbdmxfeed->filter;
1032
1033 spin_lock_irqsave(&dec->filter_info_list_lock, flags);
1034 list_add_tail(&finfo->filter_info_list,
1035 &dec->filter_info_list);
1036 spin_unlock_irqrestore(&dec->filter_info_list_lock,
1037 flags);
1038
1039 dvbdmxfeed->priv = finfo;
1040
1041 dec->filter_stream_count++;
1042 return ttusb_dec_start_iso_xfer(dec);
1043 }
1044
1045 return -EAGAIN;
1046 } else
1047 return result;
1048}
1049
1050static int ttusb_dec_start_feed(struct dvb_demux_feed *dvbdmxfeed)
1051{
1052 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
1053
1054 dprintk("%s\n", __FUNCTION__);
1055
1056 if (!dvbdmx->dmx.frontend)
1057 return -EINVAL;
1058
1059 dprintk(" pid: 0x%04X\n", dvbdmxfeed->pid);
1060
1061 switch (dvbdmxfeed->type) {
1062
1063 case DMX_TYPE_TS:
1064 return ttusb_dec_start_ts_feed(dvbdmxfeed);
1065 break;
1066
1067 case DMX_TYPE_SEC:
1068 return ttusb_dec_start_sec_feed(dvbdmxfeed);
1069 break;
1070
1071 default:
1072 dprintk(" type: unknown (%d)\n", dvbdmxfeed->type);
1073 return -EINVAL;
1074
1075 }
1076}
1077
1078static int ttusb_dec_stop_ts_feed(struct dvb_demux_feed *dvbdmxfeed)
1079{
1080 struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
1081 u8 b0[] = { 0x00 };
1082
1083 ttusb_dec_send_command(dec, 0x81, sizeof(b0), b0, NULL, NULL);
1084
1085 dec->pva_stream_count--;
1086
1087 ttusb_dec_stop_iso_xfer(dec);
1088
1089 return 0;
1090}
1091
1092static int ttusb_dec_stop_sec_feed(struct dvb_demux_feed *dvbdmxfeed)
1093{
1094 struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
1095 u8 b0[] = { 0x00, 0x00 };
1096 struct filter_info *finfo = (struct filter_info *)dvbdmxfeed->priv;
1097 unsigned long flags;
1098
1099 b0[1] = finfo->stream_id;
1100 spin_lock_irqsave(&dec->filter_info_list_lock, flags);
1101 list_del(&finfo->filter_info_list);
1102 spin_unlock_irqrestore(&dec->filter_info_list_lock, flags);
1103 kfree(finfo);
1104 ttusb_dec_send_command(dec, 0x62, sizeof(b0), b0, NULL, NULL);
1105
1106 dec->filter_stream_count--;
1107
1108 ttusb_dec_stop_iso_xfer(dec);
1109
1110 return 0;
1111}
1112
1113static int ttusb_dec_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
1114{
1115 dprintk("%s\n", __FUNCTION__);
1116
1117 switch (dvbdmxfeed->type) {
1118 case DMX_TYPE_TS:
1119 return ttusb_dec_stop_ts_feed(dvbdmxfeed);
1120 break;
1121
1122 case DMX_TYPE_SEC:
1123 return ttusb_dec_stop_sec_feed(dvbdmxfeed);
1124 break;
1125 }
1126
1127 return 0;
1128}
1129
1130static void ttusb_dec_free_iso_urbs(struct ttusb_dec *dec)
1131{
1132 int i;
1133
1134 dprintk("%s\n", __FUNCTION__);
1135
1136 for (i = 0; i < ISO_BUF_COUNT; i++)
1137 if (dec->iso_urb[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
1146static 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
1177static 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
b7df3910 1185static int ttusb_init_rc(struct ttusb_dec *dec)
1da177e4 1186{
b7df3910 1187 struct input_dev *input_dev;
1da177e4
LT		 1188 u8 b[] = { 0x00, 0x01 };
1189 int i;
1190
b7df3910
DT		 1191 usb_make_path(dec->udev, dec->rc_phys, sizeof(dec->rc_phys));
1192 strlcpy(dec->rc_phys, "/input0", sizeof(dec->rc_phys));
1da177e4 1193
b7df3910
DT		 1194 dec->rc_input_dev = input_dev = input_allocate_device();
1195 if (!input_dev)
1196 return -ENOMEM;
1197
1198 input_dev->name = "ttusb_dec remote control";
1199 input_dev->phys = dec->rc_phys;
1200 input_dev->evbit[0] = BIT(EV_KEY);
1201 input_dev->keycodesize = sizeof(u16);
1202 input_dev->keycodemax = 0x1a;
1203 input_dev->keycode = rc_keys;
1da177e4 1204
b7df3910 1205 for (i = 0; i < ARRAY_SIZE(rc_keys); i++)
9101e622 1206 set_bit(rc_keys[i], input_dev->keybit);
1da177e4 1207
b7df3910 1208 input_register_device(input_dev);
1da177e4 1209
b7df3910 1210 if (usb_submit_urb(dec->irq_urb, GFP_KERNEL))
1da177e4 1211 printk("%s: usb_submit_urb failed\n",__FUNCTION__);
b7df3910 1212
1da177e4
LT		 1213 /* enable irq pipe */
1214 ttusb_dec_send_command(dec,0xb0,sizeof(b),b,NULL,NULL);
b7df3910
DT		 1215
1216 return 0;
1da177e4
LT		 1217}
1218
1219static 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
1229static int ttusb_dec_init_usb(struct ttusb_dec *dec)
1230{
1231 dprintk("%s\n", __FUNCTION__);
1232
1233 sema_init(&dec->usb_sem, 1);
1234 sema_init(&dec->iso_sem, 1);
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
1262static 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);
0c744b01 1293 release_firmware(fw_entry);
1da177e4
LT		 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);
0c744b01 1307 release_firmware(fw_entry);
1da177e4
LT		 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
0c744b01
AH		 1322 if (result) {
1323 release_firmware(fw_entry);
1da177e4 1324 return result;
0c744b01 1325 }
1da177e4
LT		 1326
1327 trans_count = 0;
1328 j = 0;
1329
1330 b = kmalloc(ARM_PACKET_SIZE, GFP_KERNEL);
0c744b01
AH		 1331 if (b == NULL) {
1332 release_firmware(fw_entry);
1da177e4 1333 return -ENOMEM;
0c744b01 1334 }
1da177e4
LT		 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
0c744b01 1363 release_firmware(fw_entry);
1da177e4
LT		 1364 kfree(b);
1365
1366 return result;
1367}
1368
1369static 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) {
f961e71a 1398 case 0x00070001:
1da177e4
LT		 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
1428static 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)) < 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
fdc53a6d 1455 dvb_unregister_adapter(&dec->adapter);
1da177e4
LT		 1456
1457 return result;
1458 }
1459
1460 dec->dmxdev.filternum = 32;
1461 dec->dmxdev.demux = &dec->demux.dmx;
1462 dec->dmxdev.capabilities = 0;
1463
fdc53a6d 1464 if ((result = dvb_dmxdev_init(&dec->dmxdev, &dec->adapter)) < 0) {
1da177e4
LT		 1465 printk("%s: dvb_dmxdev_init failed: error %d\n",
1466 __FUNCTION__, result);
1467
1468 dvb_dmx_release(&dec->demux);
fdc53a6d 1469 dvb_unregister_adapter(&dec->adapter);
1da177e4
LT		 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);
fdc53a6d 1483 dvb_unregister_adapter(&dec->adapter);
1da177e4
LT		 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);
fdc53a6d 1496 dvb_unregister_adapter(&dec->adapter);
1da177e4
LT		 1497
1498 return result;
1499 }
1500
fdc53a6d 1501 dvb_net_init(&dec->adapter, &dec->dvb_net, &dec->demux.dmx);
1da177e4
LT		 1502
1503 return 0;
1504}
1505
1506static 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);
fdc53a6d 1516 dvb_unregister_adapter(&dec->adapter);
1da177e4
LT		 1517}
1518
1519static 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?*/
b7df3910 1527 if (dec->interface == TTUSB_DEC_INTERFACE_IN)
1da177e4
LT		 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,
9101e622 1533 dec->irq_buffer, dec->irq_dma_handle);
1da177e4 1534
b7df3910
DT		 1535 if (dec->rc_input_dev) {
1536 input_unregister_device(dec->rc_input_dev);
1537 dec->rc_input_dev = NULL;
1538 }
1da177e4
LT		 1539}
1540
1541
1542static 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
1556static 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
1570static 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
1576static 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
d91b730d
JS		 1588static 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[])
1da177e4 1591{
f961e71a 1592 struct ttusb_dec* dec = fe->dvb->priv;
1da177e4
LT		 1593 return ttusb_dec_send_command(dec, command, param_length, params, result_length, cmd_result);
1594}
1595
d91b730d 1596static struct ttusbdecfe_config fe_config = {
1da177e4
LT		 1597 .send_command = fe_send_command
1598};
1599
1600static 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 = kmalloc(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 memset(dec, 0, sizeof(struct ttusb_dec));
1618
1619 switch (le16_to_cpu(id->idProduct)) {
1620 case 0x1006:
1621 ttusb_dec_set_model(dec, TTUSB_DEC3000S);
1622 break;
1623
1624 case 0x1008:
1625 ttusb_dec_set_model(dec, TTUSB_DEC2000T);
1626 break;
1627
1628 case 0x1009:
1629 ttusb_dec_set_model(dec, TTUSB_DEC2540T);
1630 break;
1631 }
1632
1633 dec->udev = udev;
1634
1635 if (ttusb_dec_init_usb(dec))
1636 return 0;
1637 if (ttusb_dec_init_stb(dec)) {
1638 ttusb_dec_exit_usb(dec);
1639 return 0;
1640 }
1641 ttusb_dec_init_dvb(dec);
1642
fdc53a6d 1643 dec->adapter.priv = dec;
1da177e4
LT		 1644 switch (le16_to_cpu(id->idProduct)) {
1645 case 0x1006:
1646 dec->fe = ttusbdecfe_dvbs_attach(&fe_config);
1647 break;
1648
1649 case 0x1008:
1650 case 0x1009:
1651 dec->fe = ttusbdecfe_dvbt_attach(&fe_config);
1652 break;
1653 }
1654
1655 if (dec->fe == NULL) {
1656 printk("dvb-ttusb-dec: A frontend driver was not found for device %04x/%04x\n",
1657 le16_to_cpu(dec->udev->descriptor.idVendor),
1658 le16_to_cpu(dec->udev->descriptor.idProduct));
1659 } else {
fdc53a6d 1660 if (dvb_register_frontend(&dec->adapter, dec->fe)) {
1da177e4
LT		 1661 printk("budget-ci: Frontend registration failed!\n");
1662 if (dec->fe->ops->release)
1663 dec->fe->ops->release(dec->fe);
1664 dec->fe = NULL;
1665 }
1666 }
1667
1668 ttusb_dec_init_v_pes(dec);
1669 ttusb_dec_init_filters(dec);
1670 ttusb_dec_init_tasklet(dec);
1671
1672 dec->active = 1;
1673
1674 ttusb_dec_set_interface(dec, TTUSB_DEC_INTERFACE_IN);
1675
b7df3910 1676 if (enable_rc)
1da177e4
LT		 1677 ttusb_init_rc(dec);
1678
1679 return 0;
1680}
1681
1682static void ttusb_dec_disconnect(struct usb_interface *intf)
1683{
1684 struct ttusb_dec *dec = usb_get_intfdata(intf);
1685
1686 usb_set_intfdata(intf, NULL);
1687
1688 dprintk("%s\n", __FUNCTION__);
1689
1690 if (dec->active) {
1691 ttusb_dec_exit_tasklet(dec);
1692 ttusb_dec_exit_filters(dec);
1693 if(enable_rc)
1694 ttusb_dec_exit_rc(dec);
1695 ttusb_dec_exit_usb(dec);
1696 ttusb_dec_exit_dvb(dec);
1697 }
1698
1699 kfree(dec);
1700}
1701
1702static void ttusb_dec_set_model(struct ttusb_dec *dec,
1703 enum ttusb_dec_model model)
1704{
1705 dec->model = model;
1706
1707 switch (model) {
1708 case TTUSB_DEC2000T:
1709 dec->model_name = "DEC2000-t";
1710 dec->firmware_name = "dvb-ttusb-dec-2000t.fw";
1711 break;
1712
1713 case TTUSB_DEC2540T:
1714 dec->model_name = "DEC2540-t";
1715 dec->firmware_name = "dvb-ttusb-dec-2540t.fw";
1716 break;
1717
1718 case TTUSB_DEC3000S:
1719 dec->model_name = "DEC3000-s";
1720 dec->firmware_name = "dvb-ttusb-dec-3000s.fw";
1721 break;
1722 }
1723}
1724
1725static struct usb_device_id ttusb_dec_table[] = {
1726 {USB_DEVICE(0x0b48, 0x1006)}, /* DEC3000-s */
1727 /*{USB_DEVICE(0x0b48, 0x1007)}, Unconfirmed */
1728 {USB_DEVICE(0x0b48, 0x1008)}, /* DEC2000-t */
1729 {USB_DEVICE(0x0b48, 0x1009)}, /* DEC2540-t */
1730 {}
1731};
1732
1733static struct usb_driver ttusb_dec_driver = {
1734 .name = "ttusb-dec",
1735 .probe = ttusb_dec_probe,
1736 .disconnect = ttusb_dec_disconnect,
1737 .id_table = ttusb_dec_table,
1738};
1739
1740static int __init ttusb_dec_init(void)
1741{
1742 int result;
1743
1744 if ((result = usb_register(&ttusb_dec_driver)) < 0) {
1745 printk("%s: initialisation failed: error %d.\n", __FUNCTION__,
1746 result);
1747 return result;
1748 }
1749
1750 return 0;
1751}
1752
1753static void __exit ttusb_dec_exit(void)
1754{
1755 usb_deregister(&ttusb_dec_driver);
1756}
1757
1758module_init(ttusb_dec_init);
1759module_exit(ttusb_dec_exit);
1760
1761MODULE_AUTHOR("Alex Woods <linux-dvb@giblets.org>");
1762MODULE_DESCRIPTION(DRIVER_NAME);
1763MODULE_LICENSE("GPL");
1764MODULE_DEVICE_TABLE(usb, ttusb_dec_table);
Ubuntu Artful kernel mirror