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