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