Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * TTUSB DEC Driver
0004  *
0005  * Copyright (C) 2003-2004 Alex Woods <linux-dvb@giblets.org>
0006  * IR support by Peter Beutner <p.beutner@gmx.net>
0007  */
0008 
0009 #include <linux/list.h>
0010 #include <linux/module.h>
0011 #include <linux/pci.h>
0012 #include <linux/slab.h>
0013 #include <linux/spinlock.h>
0014 #include <linux/usb.h>
0015 #include <linux/interrupt.h>
0016 #include <linux/firmware.h>
0017 #include <linux/crc32.h>
0018 #include <linux/init.h>
0019 #include <linux/input.h>
0020 
0021 #include <linux/mutex.h>
0022 
0023 #include <media/dmxdev.h>
0024 #include <media/dvb_demux.h>
0025 #include <media/dvb_frontend.h>
0026 #include <media/dvb_net.h>
0027 #include "ttusbdecfe.h"
0028 
0029 static int debug;
0030 static int output_pva;
0031 static int enable_rc;
0032 
0033 module_param(debug, int, 0644);
0034 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
0035 module_param(output_pva, int, 0444);
0036 MODULE_PARM_DESC(output_pva, "Output PVA from dvr device (default:off)");
0037 module_param(enable_rc, int, 0644);
0038 MODULE_PARM_DESC(enable_rc, "Turn on/off IR remote control(default: off)");
0039 
0040 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
0041 
0042 #define dprintk if (debug) printk
0043 
0044 #define DRIVER_NAME     "TechnoTrend/Hauppauge DEC USB"
0045 
0046 #define COMMAND_PIPE        0x03
0047 #define RESULT_PIPE     0x04
0048 #define IN_PIPE         0x08
0049 #define OUT_PIPE        0x07
0050 #define IRQ_PIPE        0x0A
0051 
0052 #define COMMAND_PACKET_SIZE 0x3c
0053 #define ARM_PACKET_SIZE     0x1000
0054 #define IRQ_PACKET_SIZE     0x8
0055 
0056 #define ISO_BUF_COUNT       0x04
0057 #define FRAMES_PER_ISO_BUF  0x04
0058 #define ISO_FRAME_SIZE      0x0380
0059 
0060 #define MAX_PVA_LENGTH      6144
0061 
0062 enum ttusb_dec_model {
0063     TTUSB_DEC2000T,
0064     TTUSB_DEC2540T,
0065     TTUSB_DEC3000S
0066 };
0067 
0068 enum ttusb_dec_packet_type {
0069     TTUSB_DEC_PACKET_PVA,
0070     TTUSB_DEC_PACKET_SECTION,
0071     TTUSB_DEC_PACKET_EMPTY
0072 };
0073 
0074 enum ttusb_dec_interface {
0075     TTUSB_DEC_INTERFACE_INITIAL,
0076     TTUSB_DEC_INTERFACE_IN,
0077     TTUSB_DEC_INTERFACE_OUT
0078 };
0079 
0080 typedef int (dvb_filter_pes2ts_cb_t) (void *, unsigned char *);
0081 
0082 struct dvb_filter_pes2ts {
0083     unsigned char buf[188];
0084     unsigned char cc;
0085     dvb_filter_pes2ts_cb_t *cb;
0086     void *priv;
0087 };
0088 
0089 struct ttusb_dec {
0090     enum ttusb_dec_model        model;
0091     char                *model_name;
0092     char                *firmware_name;
0093     int             can_playback;
0094 
0095     /* DVB bits */
0096     struct dvb_adapter      adapter;
0097     struct dmxdev           dmxdev;
0098     struct dvb_demux        demux;
0099     struct dmx_frontend     frontend;
0100     struct dvb_net          dvb_net;
0101     struct dvb_frontend*        fe;
0102 
0103     u16         pid[DMX_PES_OTHER];
0104 
0105     /* USB bits */
0106     struct usb_device       *udev;
0107     u8              trans_count;
0108     unsigned int            command_pipe;
0109     unsigned int            result_pipe;
0110     unsigned int            in_pipe;
0111     unsigned int            out_pipe;
0112     unsigned int            irq_pipe;
0113     enum ttusb_dec_interface    interface;
0114     struct mutex            usb_mutex;
0115 
0116     void            *irq_buffer;
0117     struct urb      *irq_urb;
0118     dma_addr_t      irq_dma_handle;
0119     void            *iso_buffer;
0120     struct urb      *iso_urb[ISO_BUF_COUNT];
0121     int         iso_stream_count;
0122     struct mutex        iso_mutex;
0123 
0124     u8              packet[MAX_PVA_LENGTH + 4];
0125     enum ttusb_dec_packet_type  packet_type;
0126     int             packet_state;
0127     int             packet_length;
0128     int             packet_payload_length;
0129     u16             next_packet_id;
0130 
0131     int             pva_stream_count;
0132     int             filter_stream_count;
0133 
0134     struct dvb_filter_pes2ts    a_pes2ts;
0135     struct dvb_filter_pes2ts    v_pes2ts;
0136 
0137     u8          v_pes[16 + MAX_PVA_LENGTH];
0138     int         v_pes_length;
0139     int         v_pes_postbytes;
0140 
0141     struct list_head    urb_frame_list;
0142     struct tasklet_struct   urb_tasklet;
0143     spinlock_t      urb_frame_list_lock;
0144 
0145     struct dvb_demux_filter *audio_filter;
0146     struct dvb_demux_filter *video_filter;
0147     struct list_head    filter_info_list;
0148     spinlock_t      filter_info_list_lock;
0149 
0150     struct input_dev    *rc_input_dev;
0151     char            rc_phys[64];
0152 
0153     int         active; /* Loaded successfully */
0154 };
0155 
0156 struct urb_frame {
0157     u8          data[ISO_FRAME_SIZE];
0158     int         length;
0159     struct list_head    urb_frame_list;
0160 };
0161 
0162 struct filter_info {
0163     u8          stream_id;
0164     struct dvb_demux_filter *filter;
0165     struct list_head    filter_info_list;
0166 };
0167 
0168 static u16 rc_keys[] = {
0169     KEY_POWER,
0170     KEY_MUTE,
0171     KEY_1,
0172     KEY_2,
0173     KEY_3,
0174     KEY_4,
0175     KEY_5,
0176     KEY_6,
0177     KEY_7,
0178     KEY_8,
0179     KEY_9,
0180     KEY_0,
0181     KEY_CHANNELUP,
0182     KEY_VOLUMEDOWN,
0183     KEY_OK,
0184     KEY_VOLUMEUP,
0185     KEY_CHANNELDOWN,
0186     KEY_PREVIOUS,
0187     KEY_ESC,
0188     KEY_RED,
0189     KEY_GREEN,
0190     KEY_YELLOW,
0191     KEY_BLUE,
0192     KEY_OPTION,
0193     KEY_M,
0194     KEY_RADIO
0195 };
0196 
0197 static void dvb_filter_pes2ts_init(struct dvb_filter_pes2ts *p2ts,
0198                    unsigned short pid,
0199                    dvb_filter_pes2ts_cb_t *cb, void *priv)
0200 {
0201     unsigned char *buf=p2ts->buf;
0202 
0203     buf[0]=0x47;
0204     buf[1]=(pid>>8);
0205     buf[2]=pid&0xff;
0206     p2ts->cc=0;
0207     p2ts->cb=cb;
0208     p2ts->priv=priv;
0209 }
0210 
0211 static int dvb_filter_pes2ts(struct dvb_filter_pes2ts *p2ts,
0212                  unsigned char *pes, int len, int payload_start)
0213 {
0214     unsigned char *buf=p2ts->buf;
0215     int ret=0, rest;
0216 
0217     //len=6+((pes[4]<<8)|pes[5]);
0218 
0219     if (payload_start)
0220         buf[1]|=0x40;
0221     else
0222         buf[1]&=~0x40;
0223     while (len>=184) {
0224         buf[3]=0x10|((p2ts->cc++)&0x0f);
0225         memcpy(buf+4, pes, 184);
0226         if ((ret=p2ts->cb(p2ts->priv, buf)))
0227             return ret;
0228         len-=184; pes+=184;
0229         buf[1]&=~0x40;
0230     }
0231     if (!len)
0232         return 0;
0233     buf[3]=0x30|((p2ts->cc++)&0x0f);
0234     rest=183-len;
0235     if (rest) {
0236         buf[5]=0x00;
0237         if (rest-1)
0238             memset(buf+6, 0xff, rest-1);
0239     }
0240     buf[4]=rest;
0241     memcpy(buf+5+rest, pes, len);
0242     return p2ts->cb(p2ts->priv, buf);
0243 }
0244 
0245 static void ttusb_dec_set_model(struct ttusb_dec *dec,
0246                 enum ttusb_dec_model model);
0247 
0248 static void ttusb_dec_handle_irq( struct urb *urb)
0249 {
0250     struct ttusb_dec *dec = urb->context;
0251     char *buffer = dec->irq_buffer;
0252     int retval;
0253     int index = buffer[4];
0254 
0255     switch(urb->status) {
0256         case 0: /*success*/
0257             break;
0258         case -ECONNRESET:
0259         case -ENOENT:
0260         case -ESHUTDOWN:
0261         case -ETIME:
0262             /* this urb is dead, cleanup */
0263             dprintk("%s:urb shutting down with status: %d\n",
0264                     __func__, urb->status);
0265             return;
0266         default:
0267             dprintk("%s:nonzero status received: %d\n",
0268                     __func__,urb->status);
0269             goto exit;
0270     }
0271 
0272     if ((buffer[0] == 0x1) && (buffer[2] == 0x15))  {
0273         /*
0274          * IR - Event
0275          *
0276          * this is an fact a bit too simple implementation;
0277          * the box also reports a keyrepeat signal
0278          * (with buffer[3] == 0x40) in an interval of ~100ms.
0279          * But to handle this correctly we had to imlemenent some
0280          * kind of timer which signals a 'key up' event if no
0281          * keyrepeat signal is received for lets say 200ms.
0282          * this should/could be added later ...
0283          * for now lets report each signal as a key down and up
0284          */
0285         if (index - 1 < ARRAY_SIZE(rc_keys)) {
0286             dprintk("%s:rc signal:%d\n", __func__, index);
0287             input_report_key(dec->rc_input_dev, rc_keys[index - 1], 1);
0288             input_sync(dec->rc_input_dev);
0289             input_report_key(dec->rc_input_dev, rc_keys[index - 1], 0);
0290             input_sync(dec->rc_input_dev);
0291         }
0292     }
0293 
0294 exit:
0295     retval = usb_submit_urb(urb, GFP_ATOMIC);
0296     if (retval)
0297         printk("%s - usb_commit_urb failed with result: %d\n",
0298             __func__, retval);
0299 }
0300 
0301 static u16 crc16(u16 crc, const u8 *buf, size_t len)
0302 {
0303     u16 tmp;
0304 
0305     while (len--) {
0306         crc ^= *buf++;
0307         crc ^= (u8)crc >> 4;
0308         tmp = (u8)crc;
0309         crc ^= (tmp ^ (tmp << 1)) << 4;
0310     }
0311     return crc;
0312 }
0313 
0314 static int ttusb_dec_send_command(struct ttusb_dec *dec, const u8 command,
0315                   int param_length, const u8 params[],
0316                   int *result_length, u8 cmd_result[])
0317 {
0318     int result, actual_len;
0319     u8 *b;
0320 
0321     dprintk("%s\n", __func__);
0322 
0323     b = kzalloc(COMMAND_PACKET_SIZE + 4, GFP_KERNEL);
0324     if (!b)
0325         return -ENOMEM;
0326 
0327     result = mutex_lock_interruptible(&dec->usb_mutex);
0328     if (result) {
0329         printk("%s: Failed to lock usb mutex.\n", __func__);
0330         goto err_free;
0331     }
0332 
0333     b[0] = 0xaa;
0334     b[1] = ++dec->trans_count;
0335     b[2] = command;
0336     b[3] = param_length;
0337 
0338     if (params)
0339         memcpy(&b[4], params, param_length);
0340 
0341     if (debug) {
0342         printk(KERN_DEBUG "%s: command: %*ph\n",
0343                __func__, param_length, b);
0344     }
0345 
0346     result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
0347                   COMMAND_PACKET_SIZE + 4, &actual_len, 1000);
0348 
0349     if (result) {
0350         printk("%s: command bulk message failed: error %d\n",
0351                __func__, result);
0352         goto err_mutex_unlock;
0353     }
0354 
0355     result = usb_bulk_msg(dec->udev, dec->result_pipe, b,
0356                   COMMAND_PACKET_SIZE + 4, &actual_len, 1000);
0357 
0358     if (result) {
0359         printk("%s: result bulk message failed: error %d\n",
0360                __func__, result);
0361         goto err_mutex_unlock;
0362     } else {
0363         if (debug) {
0364             printk(KERN_DEBUG "%s: result: %*ph\n",
0365                    __func__, actual_len, b);
0366         }
0367 
0368         if (result_length)
0369             *result_length = b[3];
0370         if (cmd_result && b[3] > 0)
0371             memcpy(cmd_result, &b[4], b[3]);
0372     }
0373 
0374 err_mutex_unlock:
0375     mutex_unlock(&dec->usb_mutex);
0376 err_free:
0377     kfree(b);
0378     return result;
0379 }
0380 
0381 static int ttusb_dec_get_stb_state (struct ttusb_dec *dec, unsigned int *mode,
0382                     unsigned int *model, unsigned int *version)
0383 {
0384     u8 c[COMMAND_PACKET_SIZE];
0385     int c_length;
0386     int result;
0387     __be32 tmp;
0388 
0389     dprintk("%s\n", __func__);
0390 
0391     result = ttusb_dec_send_command(dec, 0x08, 0, NULL, &c_length, c);
0392     if (result)
0393         return result;
0394 
0395     if (c_length >= 0x0c) {
0396         if (mode != NULL) {
0397             memcpy(&tmp, c, 4);
0398             *mode = ntohl(tmp);
0399         }
0400         if (model != NULL) {
0401             memcpy(&tmp, &c[4], 4);
0402             *model = ntohl(tmp);
0403         }
0404         if (version != NULL) {
0405             memcpy(&tmp, &c[8], 4);
0406             *version = ntohl(tmp);
0407         }
0408         return 0;
0409     } else {
0410         return -ENOENT;
0411     }
0412 }
0413 
0414 static int ttusb_dec_audio_pes2ts_cb(void *priv, unsigned char *data)
0415 {
0416     struct ttusb_dec *dec = priv;
0417 
0418     dec->audio_filter->feed->cb.ts(data, 188, NULL, 0,
0419                        &dec->audio_filter->feed->feed.ts, NULL);
0420 
0421     return 0;
0422 }
0423 
0424 static int ttusb_dec_video_pes2ts_cb(void *priv, unsigned char *data)
0425 {
0426     struct ttusb_dec *dec = priv;
0427 
0428     dec->video_filter->feed->cb.ts(data, 188, NULL, 0,
0429                        &dec->video_filter->feed->feed.ts, NULL);
0430 
0431     return 0;
0432 }
0433 
0434 static void ttusb_dec_set_pids(struct ttusb_dec *dec)
0435 {
0436     u8 b[] = { 0x00, 0x00, 0x00, 0x00,
0437            0x00, 0x00, 0xff, 0xff,
0438            0xff, 0xff, 0xff, 0xff };
0439 
0440     __be16 pcr = htons(dec->pid[DMX_PES_PCR]);
0441     __be16 audio = htons(dec->pid[DMX_PES_AUDIO]);
0442     __be16 video = htons(dec->pid[DMX_PES_VIDEO]);
0443 
0444     dprintk("%s\n", __func__);
0445 
0446     memcpy(&b[0], &pcr, 2);
0447     memcpy(&b[2], &audio, 2);
0448     memcpy(&b[4], &video, 2);
0449 
0450     ttusb_dec_send_command(dec, 0x50, sizeof(b), b, NULL, NULL);
0451 
0452     dvb_filter_pes2ts_init(&dec->a_pes2ts, dec->pid[DMX_PES_AUDIO],
0453                    ttusb_dec_audio_pes2ts_cb, dec);
0454     dvb_filter_pes2ts_init(&dec->v_pes2ts, dec->pid[DMX_PES_VIDEO],
0455                    ttusb_dec_video_pes2ts_cb, dec);
0456     dec->v_pes_length = 0;
0457     dec->v_pes_postbytes = 0;
0458 }
0459 
0460 static void ttusb_dec_process_pva(struct ttusb_dec *dec, u8 *pva, int length)
0461 {
0462     if (length < 8) {
0463         printk("%s: packet too short - discarding\n", __func__);
0464         return;
0465     }
0466 
0467     if (length > 8 + MAX_PVA_LENGTH) {
0468         printk("%s: packet too long - discarding\n", __func__);
0469         return;
0470     }
0471 
0472     switch (pva[2]) {
0473 
0474     case 0x01: {        /* VideoStream */
0475         int prebytes = pva[5] & 0x03;
0476         int postbytes = (pva[5] & 0x0c) >> 2;
0477         __be16 v_pes_payload_length;
0478 
0479         if (output_pva) {
0480             dec->video_filter->feed->cb.ts(pva, length, NULL, 0,
0481                 &dec->video_filter->feed->feed.ts, NULL);
0482             return;
0483         }
0484 
0485         if (dec->v_pes_postbytes > 0 &&
0486             dec->v_pes_postbytes == prebytes) {
0487             memcpy(&dec->v_pes[dec->v_pes_length],
0488                    &pva[12], prebytes);
0489 
0490             dvb_filter_pes2ts(&dec->v_pes2ts, dec->v_pes,
0491                       dec->v_pes_length + prebytes, 1);
0492         }
0493 
0494         if (pva[5] & 0x10) {
0495             dec->v_pes[7] = 0x80;
0496             dec->v_pes[8] = 0x05;
0497 
0498             dec->v_pes[9] = 0x21 | ((pva[8] & 0xc0) >> 5);
0499             dec->v_pes[10] = ((pva[8] & 0x3f) << 2) |
0500                      ((pva[9] & 0xc0) >> 6);
0501             dec->v_pes[11] = 0x01 |
0502                      ((pva[9] & 0x3f) << 2) |
0503                      ((pva[10] & 0x80) >> 6);
0504             dec->v_pes[12] = ((pva[10] & 0x7f) << 1) |
0505                      ((pva[11] & 0xc0) >> 7);
0506             dec->v_pes[13] = 0x01 | ((pva[11] & 0x7f) << 1);
0507 
0508             memcpy(&dec->v_pes[14], &pva[12 + prebytes],
0509                    length - 12 - prebytes);
0510             dec->v_pes_length = 14 + length - 12 - prebytes;
0511         } else {
0512             dec->v_pes[7] = 0x00;
0513             dec->v_pes[8] = 0x00;
0514 
0515             memcpy(&dec->v_pes[9], &pva[8], length - 8);
0516             dec->v_pes_length = 9 + length - 8;
0517         }
0518 
0519         dec->v_pes_postbytes = postbytes;
0520 
0521         if (dec->v_pes[9 + dec->v_pes[8]] == 0x00 &&
0522             dec->v_pes[10 + dec->v_pes[8]] == 0x00 &&
0523             dec->v_pes[11 + dec->v_pes[8]] == 0x01)
0524             dec->v_pes[6] = 0x84;
0525         else
0526             dec->v_pes[6] = 0x80;
0527 
0528         v_pes_payload_length = htons(dec->v_pes_length - 6 +
0529                          postbytes);
0530         memcpy(&dec->v_pes[4], &v_pes_payload_length, 2);
0531 
0532         if (postbytes == 0)
0533             dvb_filter_pes2ts(&dec->v_pes2ts, dec->v_pes,
0534                       dec->v_pes_length, 1);
0535 
0536         break;
0537     }
0538 
0539     case 0x02:      /* MainAudioStream */
0540         if (output_pva) {
0541             dec->audio_filter->feed->cb.ts(pva, length, NULL, 0,
0542                 &dec->audio_filter->feed->feed.ts, NULL);
0543             return;
0544         }
0545 
0546         dvb_filter_pes2ts(&dec->a_pes2ts, &pva[8], length - 8,
0547                   pva[5] & 0x10);
0548         break;
0549 
0550     default:
0551         printk("%s: unknown PVA type: %02x.\n", __func__,
0552                pva[2]);
0553         break;
0554     }
0555 }
0556 
0557 static void ttusb_dec_process_filter(struct ttusb_dec *dec, u8 *packet,
0558                      int length)
0559 {
0560     struct list_head *item;
0561     struct filter_info *finfo;
0562     struct dvb_demux_filter *filter = NULL;
0563     unsigned long flags;
0564     u8 sid;
0565 
0566     sid = packet[1];
0567     spin_lock_irqsave(&dec->filter_info_list_lock, flags);
0568     for (item = dec->filter_info_list.next; item != &dec->filter_info_list;
0569          item = item->next) {
0570         finfo = list_entry(item, struct filter_info, filter_info_list);
0571         if (finfo->stream_id == sid) {
0572             filter = finfo->filter;
0573             break;
0574         }
0575     }
0576     spin_unlock_irqrestore(&dec->filter_info_list_lock, flags);
0577 
0578     if (filter)
0579         filter->feed->cb.sec(&packet[2], length - 2, NULL, 0,
0580                      &filter->filter, NULL);
0581 }
0582 
0583 static void ttusb_dec_process_packet(struct ttusb_dec *dec)
0584 {
0585     int i;
0586     u16 csum = 0;
0587     u16 packet_id;
0588 
0589     if (dec->packet_length % 2) {
0590         printk("%s: odd sized packet - discarding\n", __func__);
0591         return;
0592     }
0593 
0594     for (i = 0; i < dec->packet_length; i += 2)
0595         csum ^= ((dec->packet[i] << 8) + dec->packet[i + 1]);
0596 
0597     if (csum) {
0598         printk("%s: checksum failed - discarding\n", __func__);
0599         return;
0600     }
0601 
0602     packet_id = dec->packet[dec->packet_length - 4] << 8;
0603     packet_id += dec->packet[dec->packet_length - 3];
0604 
0605     if ((packet_id != dec->next_packet_id) && dec->next_packet_id) {
0606         printk("%s: warning: lost packets between %u and %u\n",
0607                __func__, dec->next_packet_id - 1, packet_id);
0608     }
0609 
0610     if (packet_id == 0xffff)
0611         dec->next_packet_id = 0x8000;
0612     else
0613         dec->next_packet_id = packet_id + 1;
0614 
0615     switch (dec->packet_type) {
0616     case TTUSB_DEC_PACKET_PVA:
0617         if (dec->pva_stream_count)
0618             ttusb_dec_process_pva(dec, dec->packet,
0619                           dec->packet_payload_length);
0620         break;
0621 
0622     case TTUSB_DEC_PACKET_SECTION:
0623         if (dec->filter_stream_count)
0624             ttusb_dec_process_filter(dec, dec->packet,
0625                          dec->packet_payload_length);
0626         break;
0627 
0628     case TTUSB_DEC_PACKET_EMPTY:
0629         break;
0630     }
0631 }
0632 
0633 static void swap_bytes(u8 *b, int length)
0634 {
0635     length -= length % 2;
0636     for (; length; b += 2, length -= 2)
0637         swap(*b, *(b + 1));
0638 }
0639 
0640 static void ttusb_dec_process_urb_frame(struct ttusb_dec *dec, u8 *b,
0641                     int length)
0642 {
0643     swap_bytes(b, length);
0644 
0645     while (length) {
0646         switch (dec->packet_state) {
0647 
0648         case 0:
0649         case 1:
0650         case 2:
0651             if (*b++ == 0xaa)
0652                 dec->packet_state++;
0653             else
0654                 dec->packet_state = 0;
0655 
0656             length--;
0657             break;
0658 
0659         case 3:
0660             if (*b == 0x00) {
0661                 dec->packet_state++;
0662                 dec->packet_length = 0;
0663             } else if (*b != 0xaa) {
0664                 dec->packet_state = 0;
0665             }
0666 
0667             b++;
0668             length--;
0669             break;
0670 
0671         case 4:
0672             dec->packet[dec->packet_length++] = *b++;
0673 
0674             if (dec->packet_length == 2) {
0675                 if (dec->packet[0] == 'A' &&
0676                     dec->packet[1] == 'V') {
0677                     dec->packet_type =
0678                         TTUSB_DEC_PACKET_PVA;
0679                     dec->packet_state++;
0680                 } else if (dec->packet[0] == 'S') {
0681                     dec->packet_type =
0682                         TTUSB_DEC_PACKET_SECTION;
0683                     dec->packet_state++;
0684                 } else if (dec->packet[0] == 0x00) {
0685                     dec->packet_type =
0686                         TTUSB_DEC_PACKET_EMPTY;
0687                     dec->packet_payload_length = 2;
0688                     dec->packet_state = 7;
0689                 } else {
0690                     printk("%s: unknown packet type: %02x%02x\n",
0691                            __func__,
0692                            dec->packet[0], dec->packet[1]);
0693                     dec->packet_state = 0;
0694                 }
0695             }
0696 
0697             length--;
0698             break;
0699 
0700         case 5:
0701             dec->packet[dec->packet_length++] = *b++;
0702 
0703             if (dec->packet_type == TTUSB_DEC_PACKET_PVA &&
0704                 dec->packet_length == 8) {
0705                 dec->packet_state++;
0706                 dec->packet_payload_length = 8 +
0707                     (dec->packet[6] << 8) +
0708                     dec->packet[7];
0709             } else if (dec->packet_type ==
0710                     TTUSB_DEC_PACKET_SECTION &&
0711                    dec->packet_length == 5) {
0712                 dec->packet_state++;
0713                 dec->packet_payload_length = 5 +
0714                     ((dec->packet[3] & 0x0f) << 8) +
0715                     dec->packet[4];
0716             }
0717 
0718             length--;
0719             break;
0720 
0721         case 6: {
0722             int remainder = dec->packet_payload_length -
0723                     dec->packet_length;
0724 
0725             if (length >= remainder) {
0726                 memcpy(dec->packet + dec->packet_length,
0727                        b, remainder);
0728                 dec->packet_length += remainder;
0729                 b += remainder;
0730                 length -= remainder;
0731                 dec->packet_state++;
0732             } else {
0733                 memcpy(&dec->packet[dec->packet_length],
0734                        b, length);
0735                 dec->packet_length += length;
0736                 length = 0;
0737             }
0738 
0739             break;
0740         }
0741 
0742         case 7: {
0743             int tail = 4;
0744 
0745             dec->packet[dec->packet_length++] = *b++;
0746 
0747             if (dec->packet_type == TTUSB_DEC_PACKET_SECTION &&
0748                 dec->packet_payload_length % 2)
0749                 tail++;
0750 
0751             if (dec->packet_length ==
0752                 dec->packet_payload_length + tail) {
0753                 ttusb_dec_process_packet(dec);
0754                 dec->packet_state = 0;
0755             }
0756 
0757             length--;
0758             break;
0759         }
0760 
0761         default:
0762             printk("%s: illegal packet state encountered.\n",
0763                    __func__);
0764             dec->packet_state = 0;
0765         }
0766     }
0767 }
0768 
0769 static void ttusb_dec_process_urb_frame_list(struct tasklet_struct *t)
0770 {
0771     struct ttusb_dec *dec = from_tasklet(dec, t, urb_tasklet);
0772     struct list_head *item;
0773     struct urb_frame *frame;
0774     unsigned long flags;
0775 
0776     while (1) {
0777         spin_lock_irqsave(&dec->urb_frame_list_lock, flags);
0778         if ((item = dec->urb_frame_list.next) != &dec->urb_frame_list) {
0779             frame = list_entry(item, struct urb_frame,
0780                        urb_frame_list);
0781             list_del(&frame->urb_frame_list);
0782         } else {
0783             spin_unlock_irqrestore(&dec->urb_frame_list_lock,
0784                            flags);
0785             return;
0786         }
0787         spin_unlock_irqrestore(&dec->urb_frame_list_lock, flags);
0788 
0789         ttusb_dec_process_urb_frame(dec, frame->data, frame->length);
0790         kfree(frame);
0791     }
0792 }
0793 
0794 static void ttusb_dec_process_urb(struct urb *urb)
0795 {
0796     struct ttusb_dec *dec = urb->context;
0797 
0798     if (!urb->status) {
0799         int i;
0800 
0801         for (i = 0; i < FRAMES_PER_ISO_BUF; i++) {
0802             struct usb_iso_packet_descriptor *d;
0803             u8 *b;
0804             int length;
0805             struct urb_frame *frame;
0806 
0807             d = &urb->iso_frame_desc[i];
0808             b = urb->transfer_buffer + d->offset;
0809             length = d->actual_length;
0810 
0811             if ((frame = kmalloc(sizeof(struct urb_frame),
0812                          GFP_ATOMIC))) {
0813                 unsigned long flags;
0814 
0815                 memcpy(frame->data, b, length);
0816                 frame->length = length;
0817 
0818                 spin_lock_irqsave(&dec->urb_frame_list_lock,
0819                              flags);
0820                 list_add_tail(&frame->urb_frame_list,
0821                           &dec->urb_frame_list);
0822                 spin_unlock_irqrestore(&dec->urb_frame_list_lock,
0823                                flags);
0824 
0825                 tasklet_schedule(&dec->urb_tasklet);
0826             }
0827         }
0828     } else {
0829          /* -ENOENT is expected when unlinking urbs */
0830         if (urb->status != -ENOENT)
0831             dprintk("%s: urb error: %d\n", __func__,
0832                 urb->status);
0833     }
0834 
0835     if (dec->iso_stream_count)
0836         usb_submit_urb(urb, GFP_ATOMIC);
0837 }
0838 
0839 static void ttusb_dec_setup_urbs(struct ttusb_dec *dec)
0840 {
0841     int i, j, buffer_offset = 0;
0842 
0843     dprintk("%s\n", __func__);
0844 
0845     for (i = 0; i < ISO_BUF_COUNT; i++) {
0846         int frame_offset = 0;
0847         struct urb *urb = dec->iso_urb[i];
0848 
0849         urb->dev = dec->udev;
0850         urb->context = dec;
0851         urb->complete = ttusb_dec_process_urb;
0852         urb->pipe = dec->in_pipe;
0853         urb->transfer_flags = URB_ISO_ASAP;
0854         urb->interval = 1;
0855         urb->number_of_packets = FRAMES_PER_ISO_BUF;
0856         urb->transfer_buffer_length = ISO_FRAME_SIZE *
0857                           FRAMES_PER_ISO_BUF;
0858         urb->transfer_buffer = dec->iso_buffer + buffer_offset;
0859         buffer_offset += ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF;
0860 
0861         for (j = 0; j < FRAMES_PER_ISO_BUF; j++) {
0862             urb->iso_frame_desc[j].offset = frame_offset;
0863             urb->iso_frame_desc[j].length = ISO_FRAME_SIZE;
0864             frame_offset += ISO_FRAME_SIZE;
0865         }
0866     }
0867 }
0868 
0869 static void ttusb_dec_stop_iso_xfer(struct ttusb_dec *dec)
0870 {
0871     int i;
0872 
0873     dprintk("%s\n", __func__);
0874 
0875     if (mutex_lock_interruptible(&dec->iso_mutex))
0876         return;
0877 
0878     dec->iso_stream_count--;
0879 
0880     if (!dec->iso_stream_count) {
0881         for (i = 0; i < ISO_BUF_COUNT; i++)
0882             usb_kill_urb(dec->iso_urb[i]);
0883     }
0884 
0885     mutex_unlock(&dec->iso_mutex);
0886 }
0887 
0888 /* Setting the interface of the DEC tends to take down the USB communications
0889  * for a short period, so it's important not to call this function just before
0890  * trying to talk to it.
0891  */
0892 static int ttusb_dec_set_interface(struct ttusb_dec *dec,
0893                    enum ttusb_dec_interface interface)
0894 {
0895     int result = 0;
0896     u8 b[] = { 0x05 };
0897 
0898     if (interface != dec->interface) {
0899         switch (interface) {
0900         case TTUSB_DEC_INTERFACE_INITIAL:
0901             result = usb_set_interface(dec->udev, 0, 0);
0902             break;
0903         case TTUSB_DEC_INTERFACE_IN:
0904             result = ttusb_dec_send_command(dec, 0x80, sizeof(b),
0905                             b, NULL, NULL);
0906             if (result)
0907                 return result;
0908             result = usb_set_interface(dec->udev, 0, 8);
0909             break;
0910         case TTUSB_DEC_INTERFACE_OUT:
0911             result = usb_set_interface(dec->udev, 0, 1);
0912             break;
0913         }
0914 
0915         if (result)
0916             return result;
0917 
0918         dec->interface = interface;
0919     }
0920 
0921     return 0;
0922 }
0923 
0924 static int ttusb_dec_start_iso_xfer(struct ttusb_dec *dec)
0925 {
0926     int i, result;
0927 
0928     dprintk("%s\n", __func__);
0929 
0930     if (mutex_lock_interruptible(&dec->iso_mutex))
0931         return -EAGAIN;
0932 
0933     if (!dec->iso_stream_count) {
0934         ttusb_dec_setup_urbs(dec);
0935 
0936         dec->packet_state = 0;
0937         dec->v_pes_postbytes = 0;
0938         dec->next_packet_id = 0;
0939 
0940         for (i = 0; i < ISO_BUF_COUNT; i++) {
0941             if ((result = usb_submit_urb(dec->iso_urb[i],
0942                              GFP_ATOMIC))) {
0943                 printk("%s: failed urb submission %d: error %d\n",
0944                        __func__, i, result);
0945 
0946                 while (i) {
0947                     usb_kill_urb(dec->iso_urb[i - 1]);
0948                     i--;
0949                 }
0950 
0951                 mutex_unlock(&dec->iso_mutex);
0952                 return result;
0953             }
0954         }
0955     }
0956 
0957     dec->iso_stream_count++;
0958 
0959     mutex_unlock(&dec->iso_mutex);
0960 
0961     return 0;
0962 }
0963 
0964 static int ttusb_dec_start_ts_feed(struct dvb_demux_feed *dvbdmxfeed)
0965 {
0966     struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
0967     struct ttusb_dec *dec = dvbdmx->priv;
0968     u8 b0[] = { 0x05 };
0969     int result = 0;
0970 
0971     dprintk("%s\n", __func__);
0972 
0973     dprintk("  ts_type:");
0974 
0975     if (dvbdmxfeed->ts_type & TS_DECODER)
0976         dprintk(" TS_DECODER");
0977 
0978     if (dvbdmxfeed->ts_type & TS_PACKET)
0979         dprintk(" TS_PACKET");
0980 
0981     if (dvbdmxfeed->ts_type & TS_PAYLOAD_ONLY)
0982         dprintk(" TS_PAYLOAD_ONLY");
0983 
0984     dprintk("\n");
0985 
0986     switch (dvbdmxfeed->pes_type) {
0987 
0988     case DMX_PES_VIDEO:
0989         dprintk("  pes_type: DMX_PES_VIDEO\n");
0990         dec->pid[DMX_PES_PCR] = dvbdmxfeed->pid;
0991         dec->pid[DMX_PES_VIDEO] = dvbdmxfeed->pid;
0992         dec->video_filter = dvbdmxfeed->filter;
0993         ttusb_dec_set_pids(dec);
0994         break;
0995 
0996     case DMX_PES_AUDIO:
0997         dprintk("  pes_type: DMX_PES_AUDIO\n");
0998         dec->pid[DMX_PES_AUDIO] = dvbdmxfeed->pid;
0999         dec->audio_filter = dvbdmxfeed->filter;
1000         ttusb_dec_set_pids(dec);
1001         break;
1002 
1003     case DMX_PES_TELETEXT:
1004         dec->pid[DMX_PES_TELETEXT] = dvbdmxfeed->pid;
1005         dprintk("  pes_type: DMX_PES_TELETEXT(not supported)\n");
1006         return -ENOSYS;
1007 
1008     case DMX_PES_PCR:
1009         dprintk("  pes_type: DMX_PES_PCR\n");
1010         dec->pid[DMX_PES_PCR] = dvbdmxfeed->pid;
1011         ttusb_dec_set_pids(dec);
1012         break;
1013 
1014     case DMX_PES_OTHER:
1015         dprintk("  pes_type: DMX_PES_OTHER(not supported)\n");
1016         return -ENOSYS;
1017 
1018     default:
1019         dprintk("  pes_type: unknown (%d)\n", dvbdmxfeed->pes_type);
1020         return -EINVAL;
1021 
1022     }
1023 
1024     result = ttusb_dec_send_command(dec, 0x80, sizeof(b0), b0, NULL, NULL);
1025     if (result)
1026         return result;
1027 
1028     dec->pva_stream_count++;
1029     return ttusb_dec_start_iso_xfer(dec);
1030 }
1031 
1032 static int ttusb_dec_start_sec_feed(struct dvb_demux_feed *dvbdmxfeed)
1033 {
1034     struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
1035     u8 b0[] = { 0x00, 0x00, 0x00, 0x01,
1036             0x00, 0x00, 0x00, 0x00,
1037             0x00, 0x00, 0x00, 0x00,
1038             0x00, 0x00, 0x00, 0x00,
1039             0x00, 0xff, 0x00, 0x00,
1040             0x00, 0x00, 0x00, 0x00,
1041             0x00, 0x00, 0x00, 0x00,
1042             0x00 };
1043     __be16 pid;
1044     u8 c[COMMAND_PACKET_SIZE];
1045     int c_length;
1046     int result;
1047     struct filter_info *finfo;
1048     unsigned long flags;
1049     u8 x = 1;
1050 
1051     dprintk("%s\n", __func__);
1052 
1053     pid = htons(dvbdmxfeed->pid);
1054     memcpy(&b0[0], &pid, 2);
1055     memcpy(&b0[4], &x, 1);
1056     memcpy(&b0[5], &dvbdmxfeed->filter->filter.filter_value[0], 1);
1057 
1058     result = ttusb_dec_send_command(dec, 0x60, sizeof(b0), b0,
1059                     &c_length, c);
1060 
1061     if (!result) {
1062         if (c_length == 2) {
1063             if (!(finfo = kmalloc(sizeof(struct filter_info),
1064                           GFP_ATOMIC)))
1065                 return -ENOMEM;
1066 
1067             finfo->stream_id = c[1];
1068             finfo->filter = dvbdmxfeed->filter;
1069 
1070             spin_lock_irqsave(&dec->filter_info_list_lock, flags);
1071             list_add_tail(&finfo->filter_info_list,
1072                       &dec->filter_info_list);
1073             spin_unlock_irqrestore(&dec->filter_info_list_lock,
1074                            flags);
1075 
1076             dvbdmxfeed->priv = finfo;
1077 
1078             dec->filter_stream_count++;
1079             return ttusb_dec_start_iso_xfer(dec);
1080         }
1081 
1082         return -EAGAIN;
1083     } else
1084         return result;
1085 }
1086 
1087 static int ttusb_dec_start_feed(struct dvb_demux_feed *dvbdmxfeed)
1088 {
1089     struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
1090 
1091     dprintk("%s\n", __func__);
1092 
1093     if (!dvbdmx->dmx.frontend)
1094         return -EINVAL;
1095 
1096     dprintk("  pid: 0x%04X\n", dvbdmxfeed->pid);
1097 
1098     switch (dvbdmxfeed->type) {
1099 
1100     case DMX_TYPE_TS:
1101         return ttusb_dec_start_ts_feed(dvbdmxfeed);
1102 
1103     case DMX_TYPE_SEC:
1104         return ttusb_dec_start_sec_feed(dvbdmxfeed);
1105 
1106     default:
1107         dprintk("  type: unknown (%d)\n", dvbdmxfeed->type);
1108         return -EINVAL;
1109 
1110     }
1111 }
1112 
1113 static int ttusb_dec_stop_ts_feed(struct dvb_demux_feed *dvbdmxfeed)
1114 {
1115     struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
1116     u8 b0[] = { 0x00 };
1117 
1118     ttusb_dec_send_command(dec, 0x81, sizeof(b0), b0, NULL, NULL);
1119 
1120     dec->pva_stream_count--;
1121 
1122     ttusb_dec_stop_iso_xfer(dec);
1123 
1124     return 0;
1125 }
1126 
1127 static int ttusb_dec_stop_sec_feed(struct dvb_demux_feed *dvbdmxfeed)
1128 {
1129     struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
1130     u8 b0[] = { 0x00, 0x00 };
1131     struct filter_info *finfo = (struct filter_info *)dvbdmxfeed->priv;
1132     unsigned long flags;
1133 
1134     b0[1] = finfo->stream_id;
1135     spin_lock_irqsave(&dec->filter_info_list_lock, flags);
1136     list_del(&finfo->filter_info_list);
1137     spin_unlock_irqrestore(&dec->filter_info_list_lock, flags);
1138     kfree(finfo);
1139     ttusb_dec_send_command(dec, 0x62, sizeof(b0), b0, NULL, NULL);
1140 
1141     dec->filter_stream_count--;
1142 
1143     ttusb_dec_stop_iso_xfer(dec);
1144 
1145     return 0;
1146 }
1147 
1148 static int ttusb_dec_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
1149 {
1150     dprintk("%s\n", __func__);
1151 
1152     switch (dvbdmxfeed->type) {
1153     case DMX_TYPE_TS:
1154         return ttusb_dec_stop_ts_feed(dvbdmxfeed);
1155 
1156     case DMX_TYPE_SEC:
1157         return ttusb_dec_stop_sec_feed(dvbdmxfeed);
1158     }
1159 
1160     return 0;
1161 }
1162 
1163 static void ttusb_dec_free_iso_urbs(struct ttusb_dec *dec)
1164 {
1165     int i;
1166 
1167     dprintk("%s\n", __func__);
1168 
1169     for (i = 0; i < ISO_BUF_COUNT; i++)
1170         usb_free_urb(dec->iso_urb[i]);
1171     kfree(dec->iso_buffer);
1172 }
1173 
1174 static int ttusb_dec_alloc_iso_urbs(struct ttusb_dec *dec)
1175 {
1176     int i;
1177 
1178     dprintk("%s\n", __func__);
1179 
1180     dec->iso_buffer = kcalloc(FRAMES_PER_ISO_BUF * ISO_BUF_COUNT,
1181             ISO_FRAME_SIZE, GFP_KERNEL);
1182     if (!dec->iso_buffer)
1183         return -ENOMEM;
1184 
1185     for (i = 0; i < ISO_BUF_COUNT; i++) {
1186         struct urb *urb;
1187 
1188         if (!(urb = usb_alloc_urb(FRAMES_PER_ISO_BUF, GFP_ATOMIC))) {
1189             ttusb_dec_free_iso_urbs(dec);
1190             return -ENOMEM;
1191         }
1192 
1193         dec->iso_urb[i] = urb;
1194     }
1195 
1196     ttusb_dec_setup_urbs(dec);
1197 
1198     return 0;
1199 }
1200 
1201 static void ttusb_dec_init_tasklet(struct ttusb_dec *dec)
1202 {
1203     spin_lock_init(&dec->urb_frame_list_lock);
1204     INIT_LIST_HEAD(&dec->urb_frame_list);
1205     tasklet_setup(&dec->urb_tasklet, ttusb_dec_process_urb_frame_list);
1206 }
1207 
1208 static int ttusb_init_rc( struct ttusb_dec *dec)
1209 {
1210     struct input_dev *input_dev;
1211     u8 b[] = { 0x00, 0x01 };
1212     int i;
1213     int err;
1214 
1215     usb_make_path(dec->udev, dec->rc_phys, sizeof(dec->rc_phys));
1216     strlcat(dec->rc_phys, "/input0", sizeof(dec->rc_phys));
1217 
1218     input_dev = input_allocate_device();
1219     if (!input_dev)
1220         return -ENOMEM;
1221 
1222     input_dev->name = "ttusb_dec remote control";
1223     input_dev->phys = dec->rc_phys;
1224     input_dev->evbit[0] = BIT_MASK(EV_KEY);
1225     input_dev->keycodesize = sizeof(u16);
1226     input_dev->keycodemax = 0x1a;
1227     input_dev->keycode = rc_keys;
1228 
1229     for (i = 0; i < ARRAY_SIZE(rc_keys); i++)
1230           set_bit(rc_keys[i], input_dev->keybit);
1231 
1232     err = input_register_device(input_dev);
1233     if (err) {
1234         input_free_device(input_dev);
1235         return err;
1236     }
1237 
1238     dec->rc_input_dev = input_dev;
1239     if (usb_submit_urb(dec->irq_urb, GFP_KERNEL))
1240         printk("%s: usb_submit_urb failed\n",__func__);
1241     /* enable irq pipe */
1242     ttusb_dec_send_command(dec,0xb0,sizeof(b),b,NULL,NULL);
1243 
1244     return 0;
1245 }
1246 
1247 static void ttusb_dec_init_v_pes(struct ttusb_dec *dec)
1248 {
1249     dprintk("%s\n", __func__);
1250 
1251     dec->v_pes[0] = 0x00;
1252     dec->v_pes[1] = 0x00;
1253     dec->v_pes[2] = 0x01;
1254     dec->v_pes[3] = 0xe0;
1255 }
1256 
1257 static int ttusb_dec_init_usb(struct ttusb_dec *dec)
1258 {
1259     int result;
1260 
1261     dprintk("%s\n", __func__);
1262 
1263     mutex_init(&dec->usb_mutex);
1264     mutex_init(&dec->iso_mutex);
1265 
1266     dec->command_pipe = usb_sndbulkpipe(dec->udev, COMMAND_PIPE);
1267     dec->result_pipe = usb_rcvbulkpipe(dec->udev, RESULT_PIPE);
1268     dec->in_pipe = usb_rcvisocpipe(dec->udev, IN_PIPE);
1269     dec->out_pipe = usb_sndisocpipe(dec->udev, OUT_PIPE);
1270     dec->irq_pipe = usb_rcvintpipe(dec->udev, IRQ_PIPE);
1271 
1272     if(enable_rc) {
1273         dec->irq_urb = usb_alloc_urb(0, GFP_KERNEL);
1274         if(!dec->irq_urb) {
1275             return -ENOMEM;
1276         }
1277         dec->irq_buffer = usb_alloc_coherent(dec->udev,IRQ_PACKET_SIZE,
1278                     GFP_KERNEL, &dec->irq_dma_handle);
1279         if(!dec->irq_buffer) {
1280             usb_free_urb(dec->irq_urb);
1281             return -ENOMEM;
1282         }
1283         usb_fill_int_urb(dec->irq_urb, dec->udev,dec->irq_pipe,
1284                  dec->irq_buffer, IRQ_PACKET_SIZE,
1285                  ttusb_dec_handle_irq, dec, 1);
1286         dec->irq_urb->transfer_dma = dec->irq_dma_handle;
1287         dec->irq_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1288     }
1289 
1290     result = ttusb_dec_alloc_iso_urbs(dec);
1291     if (result) {
1292         usb_free_urb(dec->irq_urb);
1293         usb_free_coherent(dec->udev, IRQ_PACKET_SIZE,
1294                   dec->irq_buffer, dec->irq_dma_handle);
1295     }
1296     return result;
1297 }
1298 
1299 static int ttusb_dec_boot_dsp(struct ttusb_dec *dec)
1300 {
1301     int i, j, actual_len, result, size, trans_count;
1302     u8 b0[] = { 0x00, 0x00, 0x00, 0x00,
1303             0x00, 0x00, 0x00, 0x00,
1304             0x61, 0x00 };
1305     u8 b1[] = { 0x61 };
1306     u8 *b;
1307     char idstring[21];
1308     const u8 *firmware = NULL;
1309     size_t firmware_size = 0;
1310     u16 firmware_csum = 0;
1311     __be16 firmware_csum_ns;
1312     __be32 firmware_size_nl;
1313     u32 crc32_csum, crc32_check;
1314     __be32 tmp;
1315     const struct firmware *fw_entry = NULL;
1316 
1317     dprintk("%s\n", __func__);
1318 
1319     result = request_firmware(&fw_entry, dec->firmware_name, &dec->udev->dev);
1320     if (result) {
1321         printk(KERN_ERR "%s: Firmware (%s) unavailable.\n",
1322                __func__, dec->firmware_name);
1323         return result;
1324     }
1325 
1326     firmware = fw_entry->data;
1327     firmware_size = fw_entry->size;
1328 
1329     if (firmware_size < 60) {
1330         printk("%s: firmware size too small for DSP code (%zu < 60).\n",
1331             __func__, firmware_size);
1332         release_firmware(fw_entry);
1333         return -ENOENT;
1334     }
1335 
1336     /* a 32 bit checksum over the first 56 bytes of the DSP Code is stored
1337        at offset 56 of file, so use it to check if the firmware file is
1338        valid. */
1339     crc32_csum = crc32(~0L, firmware, 56) ^ ~0L;
1340     memcpy(&tmp, &firmware[56], 4);
1341     crc32_check = ntohl(tmp);
1342     if (crc32_csum != crc32_check) {
1343         printk("%s: crc32 check of DSP code failed (calculated 0x%08x != 0x%08x in file), file invalid.\n",
1344             __func__, crc32_csum, crc32_check);
1345         release_firmware(fw_entry);
1346         return -ENOENT;
1347     }
1348     memcpy(idstring, &firmware[36], 20);
1349     idstring[20] = '\0';
1350     printk(KERN_INFO "ttusb_dec: found DSP code \"%s\".\n", idstring);
1351 
1352     firmware_size_nl = htonl(firmware_size);
1353     memcpy(b0, &firmware_size_nl, 4);
1354     firmware_csum = crc16(~0, firmware, firmware_size) ^ ~0;
1355     firmware_csum_ns = htons(firmware_csum);
1356     memcpy(&b0[6], &firmware_csum_ns, 2);
1357 
1358     result = ttusb_dec_send_command(dec, 0x41, sizeof(b0), b0, NULL, NULL);
1359 
1360     if (result) {
1361         release_firmware(fw_entry);
1362         return result;
1363     }
1364 
1365     trans_count = 0;
1366     j = 0;
1367 
1368     b = kmalloc(ARM_PACKET_SIZE, GFP_KERNEL);
1369     if (b == NULL) {
1370         release_firmware(fw_entry);
1371         return -ENOMEM;
1372     }
1373 
1374     for (i = 0; i < firmware_size; i += COMMAND_PACKET_SIZE) {
1375         size = firmware_size - i;
1376         if (size > COMMAND_PACKET_SIZE)
1377             size = COMMAND_PACKET_SIZE;
1378 
1379         b[j + 0] = 0xaa;
1380         b[j + 1] = trans_count++;
1381         b[j + 2] = 0xf0;
1382         b[j + 3] = size;
1383         memcpy(&b[j + 4], &firmware[i], size);
1384 
1385         j += COMMAND_PACKET_SIZE + 4;
1386 
1387         if (j >= ARM_PACKET_SIZE) {
1388             result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
1389                           ARM_PACKET_SIZE, &actual_len,
1390                           100);
1391             j = 0;
1392         } else if (size < COMMAND_PACKET_SIZE) {
1393             result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
1394                           j - COMMAND_PACKET_SIZE + size,
1395                           &actual_len, 100);
1396         }
1397     }
1398 
1399     result = ttusb_dec_send_command(dec, 0x43, sizeof(b1), b1, NULL, NULL);
1400 
1401     release_firmware(fw_entry);
1402     kfree(b);
1403 
1404     return result;
1405 }
1406 
1407 static int ttusb_dec_init_stb(struct ttusb_dec *dec)
1408 {
1409     int result;
1410     unsigned int mode = 0, model = 0, version = 0;
1411 
1412     dprintk("%s\n", __func__);
1413 
1414     result = ttusb_dec_get_stb_state(dec, &mode, &model, &version);
1415     if (result)
1416         return result;
1417 
1418     if (!mode) {
1419         if (version == 0xABCDEFAB)
1420             printk(KERN_INFO "ttusb_dec: no version info in Firmware\n");
1421         else
1422             printk(KERN_INFO "ttusb_dec: Firmware %x.%02x%c%c\n",
1423                    version >> 24, (version >> 16) & 0xff,
1424                    (version >> 8) & 0xff, version & 0xff);
1425 
1426         result = ttusb_dec_boot_dsp(dec);
1427         if (result)
1428             return result;
1429     } else {
1430         /* We can't trust the USB IDs that some firmwares
1431            give the box */
1432         switch (model) {
1433         case 0x00070001:
1434         case 0x00070008:
1435         case 0x0007000c:
1436             ttusb_dec_set_model(dec, TTUSB_DEC3000S);
1437             break;
1438         case 0x00070009:
1439         case 0x00070013:
1440             ttusb_dec_set_model(dec, TTUSB_DEC2000T);
1441             break;
1442         case 0x00070011:
1443             ttusb_dec_set_model(dec, TTUSB_DEC2540T);
1444             break;
1445         default:
1446             printk(KERN_ERR "%s: unknown model returned by firmware (%08x) - please report\n",
1447                    __func__, model);
1448             return -ENOENT;
1449         }
1450         if (version >= 0x01770000)
1451             dec->can_playback = 1;
1452     }
1453     return 0;
1454 }
1455 
1456 static int ttusb_dec_init_dvb(struct ttusb_dec *dec)
1457 {
1458     int result;
1459 
1460     dprintk("%s\n", __func__);
1461 
1462     if ((result = dvb_register_adapter(&dec->adapter,
1463                        dec->model_name, THIS_MODULE,
1464                        &dec->udev->dev,
1465                        adapter_nr)) < 0) {
1466         printk("%s: dvb_register_adapter failed: error %d\n",
1467                __func__, result);
1468 
1469         return result;
1470     }
1471 
1472     dec->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING;
1473 
1474     dec->demux.priv = (void *)dec;
1475     dec->demux.filternum = 31;
1476     dec->demux.feednum = 31;
1477     dec->demux.start_feed = ttusb_dec_start_feed;
1478     dec->demux.stop_feed = ttusb_dec_stop_feed;
1479     dec->demux.write_to_decoder = NULL;
1480 
1481     if ((result = dvb_dmx_init(&dec->demux)) < 0) {
1482         printk("%s: dvb_dmx_init failed: error %d\n", __func__,
1483                result);
1484 
1485         dvb_unregister_adapter(&dec->adapter);
1486 
1487         return result;
1488     }
1489 
1490     dec->dmxdev.filternum = 32;
1491     dec->dmxdev.demux = &dec->demux.dmx;
1492     dec->dmxdev.capabilities = 0;
1493 
1494     if ((result = dvb_dmxdev_init(&dec->dmxdev, &dec->adapter)) < 0) {
1495         printk("%s: dvb_dmxdev_init failed: error %d\n",
1496                __func__, result);
1497 
1498         dvb_dmx_release(&dec->demux);
1499         dvb_unregister_adapter(&dec->adapter);
1500 
1501         return result;
1502     }
1503 
1504     dec->frontend.source = DMX_FRONTEND_0;
1505 
1506     if ((result = dec->demux.dmx.add_frontend(&dec->demux.dmx,
1507                           &dec->frontend)) < 0) {
1508         printk("%s: dvb_dmx_init failed: error %d\n", __func__,
1509                result);
1510 
1511         dvb_dmxdev_release(&dec->dmxdev);
1512         dvb_dmx_release(&dec->demux);
1513         dvb_unregister_adapter(&dec->adapter);
1514 
1515         return result;
1516     }
1517 
1518     if ((result = dec->demux.dmx.connect_frontend(&dec->demux.dmx,
1519                               &dec->frontend)) < 0) {
1520         printk("%s: dvb_dmx_init failed: error %d\n", __func__,
1521                result);
1522 
1523         dec->demux.dmx.remove_frontend(&dec->demux.dmx, &dec->frontend);
1524         dvb_dmxdev_release(&dec->dmxdev);
1525         dvb_dmx_release(&dec->demux);
1526         dvb_unregister_adapter(&dec->adapter);
1527 
1528         return result;
1529     }
1530 
1531     dvb_net_init(&dec->adapter, &dec->dvb_net, &dec->demux.dmx);
1532 
1533     return 0;
1534 }
1535 
1536 static void ttusb_dec_exit_dvb(struct ttusb_dec *dec)
1537 {
1538     dprintk("%s\n", __func__);
1539 
1540     dvb_net_release(&dec->dvb_net);
1541     dec->demux.dmx.close(&dec->demux.dmx);
1542     dec->demux.dmx.remove_frontend(&dec->demux.dmx, &dec->frontend);
1543     dvb_dmxdev_release(&dec->dmxdev);
1544     dvb_dmx_release(&dec->demux);
1545     if (dec->fe) {
1546         dvb_unregister_frontend(dec->fe);
1547         if (dec->fe->ops.release)
1548             dec->fe->ops.release(dec->fe);
1549     }
1550     dvb_unregister_adapter(&dec->adapter);
1551 }
1552 
1553 static void ttusb_dec_exit_rc(struct ttusb_dec *dec)
1554 {
1555     dprintk("%s\n", __func__);
1556 
1557     if (dec->rc_input_dev) {
1558         input_unregister_device(dec->rc_input_dev);
1559         dec->rc_input_dev = NULL;
1560     }
1561 }
1562 
1563 
1564 static void ttusb_dec_exit_usb(struct ttusb_dec *dec)
1565 {
1566     int i;
1567 
1568     dprintk("%s\n", __func__);
1569 
1570     if (enable_rc) {
1571         /* we have to check whether the irq URB is already submitted.
1572          * As the irq is submitted after the interface is changed,
1573          * this is the best method i figured out.
1574          * Any others?*/
1575         if (dec->interface == TTUSB_DEC_INTERFACE_IN)
1576             usb_kill_urb(dec->irq_urb);
1577 
1578         usb_free_urb(dec->irq_urb);
1579 
1580         usb_free_coherent(dec->udev, IRQ_PACKET_SIZE,
1581                   dec->irq_buffer, dec->irq_dma_handle);
1582     }
1583 
1584     dec->iso_stream_count = 0;
1585 
1586     for (i = 0; i < ISO_BUF_COUNT; i++)
1587         usb_kill_urb(dec->iso_urb[i]);
1588 
1589     ttusb_dec_free_iso_urbs(dec);
1590 }
1591 
1592 static void ttusb_dec_exit_tasklet(struct ttusb_dec *dec)
1593 {
1594     struct list_head *item;
1595     struct urb_frame *frame;
1596 
1597     tasklet_kill(&dec->urb_tasklet);
1598 
1599     while ((item = dec->urb_frame_list.next) != &dec->urb_frame_list) {
1600         frame = list_entry(item, struct urb_frame, urb_frame_list);
1601         list_del(&frame->urb_frame_list);
1602         kfree(frame);
1603     }
1604 }
1605 
1606 static void ttusb_dec_init_filters(struct ttusb_dec *dec)
1607 {
1608     INIT_LIST_HEAD(&dec->filter_info_list);
1609     spin_lock_init(&dec->filter_info_list_lock);
1610 }
1611 
1612 static void ttusb_dec_exit_filters(struct ttusb_dec *dec)
1613 {
1614     struct list_head *item;
1615     struct filter_info *finfo;
1616 
1617     while ((item = dec->filter_info_list.next) != &dec->filter_info_list) {
1618         finfo = list_entry(item, struct filter_info, filter_info_list);
1619         list_del(&finfo->filter_info_list);
1620         kfree(finfo);
1621     }
1622 }
1623 
1624 static int fe_send_command(struct dvb_frontend* fe, const u8 command,
1625                int param_length, const u8 params[],
1626                int *result_length, u8 cmd_result[])
1627 {
1628     struct ttusb_dec* dec = fe->dvb->priv;
1629     return ttusb_dec_send_command(dec, command, param_length, params, result_length, cmd_result);
1630 }
1631 
1632 static const struct ttusbdecfe_config fe_config = {
1633     .send_command = fe_send_command
1634 };
1635 
1636 static int ttusb_dec_probe(struct usb_interface *intf,
1637                const struct usb_device_id *id)
1638 {
1639     struct usb_device *udev;
1640     struct ttusb_dec *dec;
1641     int result;
1642 
1643     dprintk("%s\n", __func__);
1644 
1645     udev = interface_to_usbdev(intf);
1646 
1647     if (!(dec = kzalloc(sizeof(struct ttusb_dec), GFP_KERNEL))) {
1648         printk("%s: couldn't allocate memory.\n", __func__);
1649         return -ENOMEM;
1650     }
1651 
1652     usb_set_intfdata(intf, (void *)dec);
1653 
1654     switch (id->idProduct) {
1655     case 0x1006:
1656         ttusb_dec_set_model(dec, TTUSB_DEC3000S);
1657         break;
1658 
1659     case 0x1008:
1660         ttusb_dec_set_model(dec, TTUSB_DEC2000T);
1661         break;
1662 
1663     case 0x1009:
1664         ttusb_dec_set_model(dec, TTUSB_DEC2540T);
1665         break;
1666     }
1667 
1668     dec->udev = udev;
1669 
1670     result = ttusb_dec_init_usb(dec);
1671     if (result)
1672         goto err_usb;
1673     result = ttusb_dec_init_stb(dec);
1674     if (result)
1675         goto err_stb;
1676     result = ttusb_dec_init_dvb(dec);
1677     if (result)
1678         goto err_stb;
1679 
1680     dec->adapter.priv = dec;
1681     switch (id->idProduct) {
1682     case 0x1006:
1683         dec->fe = ttusbdecfe_dvbs_attach(&fe_config);
1684         break;
1685 
1686     case 0x1008:
1687     case 0x1009:
1688         dec->fe = ttusbdecfe_dvbt_attach(&fe_config);
1689         break;
1690     }
1691 
1692     if (dec->fe == NULL) {
1693         printk("dvb-ttusb-dec: A frontend driver was not found for device [%04x:%04x]\n",
1694                le16_to_cpu(dec->udev->descriptor.idVendor),
1695                le16_to_cpu(dec->udev->descriptor.idProduct));
1696     } else {
1697         if (dvb_register_frontend(&dec->adapter, dec->fe)) {
1698             printk("budget-ci: Frontend registration failed!\n");
1699             if (dec->fe->ops.release)
1700                 dec->fe->ops.release(dec->fe);
1701             dec->fe = NULL;
1702         }
1703     }
1704 
1705     ttusb_dec_init_v_pes(dec);
1706     ttusb_dec_init_filters(dec);
1707     ttusb_dec_init_tasklet(dec);
1708 
1709     dec->active = 1;
1710 
1711     ttusb_dec_set_interface(dec, TTUSB_DEC_INTERFACE_IN);
1712 
1713     if (enable_rc)
1714         ttusb_init_rc(dec);
1715 
1716     return 0;
1717 err_stb:
1718     ttusb_dec_exit_usb(dec);
1719 err_usb:
1720     kfree(dec);
1721     return result;
1722 }
1723 
1724 static void ttusb_dec_disconnect(struct usb_interface *intf)
1725 {
1726     struct ttusb_dec *dec = usb_get_intfdata(intf);
1727 
1728     usb_set_intfdata(intf, NULL);
1729 
1730     dprintk("%s\n", __func__);
1731 
1732     if (dec->active) {
1733         ttusb_dec_exit_tasklet(dec);
1734         ttusb_dec_exit_filters(dec);
1735         if(enable_rc)
1736             ttusb_dec_exit_rc(dec);
1737         ttusb_dec_exit_usb(dec);
1738         ttusb_dec_exit_dvb(dec);
1739     }
1740 
1741     kfree(dec);
1742 }
1743 
1744 static void ttusb_dec_set_model(struct ttusb_dec *dec,
1745                 enum ttusb_dec_model model)
1746 {
1747     dec->model = model;
1748 
1749     switch (model) {
1750     case TTUSB_DEC2000T:
1751         dec->model_name = "DEC2000-t";
1752         dec->firmware_name = "dvb-ttusb-dec-2000t.fw";
1753         break;
1754 
1755     case TTUSB_DEC2540T:
1756         dec->model_name = "DEC2540-t";
1757         dec->firmware_name = "dvb-ttusb-dec-2540t.fw";
1758         break;
1759 
1760     case TTUSB_DEC3000S:
1761         dec->model_name = "DEC3000-s";
1762         dec->firmware_name = "dvb-ttusb-dec-3000s.fw";
1763         break;
1764     }
1765 }
1766 
1767 static const struct usb_device_id ttusb_dec_table[] = {
1768     {USB_DEVICE(0x0b48, 0x1006)},   /* DEC3000-s */
1769     /*{USB_DEVICE(0x0b48, 0x1007)},    Unconfirmed */
1770     {USB_DEVICE(0x0b48, 0x1008)},   /* DEC2000-t */
1771     {USB_DEVICE(0x0b48, 0x1009)},   /* DEC2540-t */
1772     {}
1773 };
1774 
1775 static struct usb_driver ttusb_dec_driver = {
1776     .name       = "ttusb-dec",
1777     .probe      = ttusb_dec_probe,
1778     .disconnect = ttusb_dec_disconnect,
1779     .id_table   = ttusb_dec_table,
1780 };
1781 
1782 module_usb_driver(ttusb_dec_driver);
1783 
1784 MODULE_AUTHOR("Alex Woods <linux-dvb@giblets.org>");
1785 MODULE_DESCRIPTION(DRIVER_NAME);
1786 MODULE_LICENSE("GPL");
1787 MODULE_DEVICE_TABLE(usb, ttusb_dec_table);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!