Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us