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-budget/dvb-ttusb-budget.c

  1 /*
  2  * TTUSB DVB driver
  3  *
  4  * Copyright (c) 2002 Holger Waechtler <holger@convergence.de>
  5  * Copyright (c) 2003 Felix Domke <tmbinc@elitedvb.net>
  6  *
  7  *      This program is free software; you can redistribute it and/or
  8  *      modify it under the terms of the GNU General Public License as
  9  *      published by the Free Software Foundation; either version 2 of
 10  *      the License, or (at your option) any later version.
 11  */
 12 #include <linux/init.h>
 13 #include <linux/slab.h>
 14 #include <linux/wait.h>
 15 #include <linux/fs.h>
 16 #include <linux/module.h>
 17 #include <linux/usb.h>
 18 #include <linux/delay.h>
 19 #include <linux/time.h>
 20 #include <linux/errno.h>
 21 #include <linux/jiffies.h>
 22 #include <linux/mutex.h>
 23 #include <linux/firmware.h>
 24 
 25 #include "dvb_frontend.h"
 26 #include "dmxdev.h"
 27 #include "dvb_demux.h"
 28 #include "dvb_net.h"
 29 #include "ves1820.h"
 30 #include "cx22700.h"
 31 #include "tda1004x.h"
 32 #include "stv0299.h"
 33 #include "tda8083.h"
 34 #include "stv0297.h"
 35 #include "lnbp21.h"
 36 
 37 #include <linux/dvb/frontend.h>
 38 #include <linux/dvb/dmx.h>
 39 #include <linux/pci.h>
 40 
 41 /*
 42   TTUSB_HWSECTIONS:
 43     the DSP supports filtering in hardware, however, since the "muxstream"
 44     is a bit braindead (no matching channel masks or no matching filter mask),
 45     we won't support this - yet. it doesn't event support negative filters,
 46     so the best way is maybe to keep TTUSB_HWSECTIONS undef'd and just
 47     parse TS data. USB bandwidth will be a problem when having large
 48     datastreams, especially for dvb-net, but hey, that's not my problem.
 49 
 50   TTUSB_DISEQC, TTUSB_TONE:
 51     let the STC do the diseqc/tone stuff. this isn't supported at least with
 52     my TTUSB, so let it undef'd unless you want to implement another
 53     frontend. never tested.
 54 
 55   debug:
 56     define it to > 3 for really hardcore debugging. you probably don't want
 57     this unless the device doesn't load at all. > 2 for bandwidth statistics.
 58 */
 59 
 60 static int debug;
 61 module_param(debug, int, 0644);
 62 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
 63 
 64 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
 65 
 66 #define dprintk(x...) do { if (debug) printk(KERN_DEBUG x); } while (0)
 67 
 68 #define ISO_BUF_COUNT      4
 69 #define FRAMES_PER_ISO_BUF 4
 70 #define ISO_FRAME_SIZE     912
 71 #define TTUSB_MAXCHANNEL   32
 72 #ifdef TTUSB_HWSECTIONS
 73 #define TTUSB_MAXFILTER    16   /* ??? */
 74 #endif
 75 
 76 #define TTUSB_REV_2_2   0x22
 77 #define TTUSB_BUDGET_NAME "ttusb_stc_fw"
 78 
 79 /**
 80  *  since we're casting (struct ttusb*) <-> (struct dvb_demux*) around
 81  *  the dvb_demux field must be the first in struct!!
 82  */
 83 struct ttusb {
 84         struct dvb_demux dvb_demux;
 85         struct dmxdev dmxdev;
 86         struct dvb_net dvbnet;
 87 
 88         /* and one for USB access. */
 89         struct mutex semi2c;
 90         struct mutex semusb;
 91 
 92         struct dvb_adapter adapter;
 93         struct usb_device *dev;
 94 
 95         struct i2c_adapter i2c_adap;
 96 
 97         int disconnecting;
 98         int iso_streaming;
 99 
100         unsigned int bulk_out_pipe;
101         unsigned int bulk_in_pipe;
102         unsigned int isoc_in_pipe;
103 
104         void *iso_buffer;
105         dma_addr_t iso_dma_handle;
106 
107         struct urb *iso_urb[ISO_BUF_COUNT];
108 
109         int running_feed_count;
110         int last_channel;
111         int last_filter;
112 
113         u8 c;                   /* transaction counter, wraps around...  */
114         fe_sec_tone_mode_t tone;
115         fe_sec_voltage_t voltage;
116 
117         int mux_state;          // 0..2 - MuxSyncWord, 3 - nMuxPacks,    4 - muxpack
118         u8 mux_npacks;
119         u8 muxpack[256 + 8];
120         int muxpack_ptr, muxpack_len;
121 
122         int insync;
123 
124         int cc;                 /* MuxCounter - will increment on EVERY MUX PACKET */
125         /* (including stuffing. yes. really.) */
126 
127         u8 last_result[32];
128 
129         int revision;
130 
131         struct dvb_frontend* fe;
132 };
133 
134 /* ugly workaround ... don't know why it's necessary to read */
135 /* all result codes. */
136 
137 static int ttusb_cmd(struct ttusb *ttusb,
138               const u8 * data, int len, int needresult)
139 {
140         int actual_len;
141         int err;
142         int i;
143 
144         if (debug >= 3) {
145                 printk(KERN_DEBUG ">");
146                 for (i = 0; i < len; ++i)
147                         printk(KERN_CONT " %02x", data[i]);
148                 printk(KERN_CONT "\n");
149         }
150 
151         if (mutex_lock_interruptible(&ttusb->semusb) < 0)
152                 return -EAGAIN;
153 
154         err = usb_bulk_msg(ttusb->dev, ttusb->bulk_out_pipe,
155                            (u8 *) data, len, &actual_len, 1000);
156         if (err != 0) {
157                 dprintk("%s: usb_bulk_msg(send) failed, err == %i!\n",
158                         __func__, err);
159                 mutex_unlock(&ttusb->semusb);
160                 return err;
161         }
162         if (actual_len != len) {
163                 dprintk("%s: only wrote %d of %d bytes\n", __func__,
164                         actual_len, len);
165                 mutex_unlock(&ttusb->semusb);
166                 return -1;
167         }
168 
169         err = usb_bulk_msg(ttusb->dev, ttusb->bulk_in_pipe,
170                            ttusb->last_result, 32, &actual_len, 1000);
171 
172         if (err != 0) {
173                 printk("%s: failed, receive error %d\n", __func__,
174                        err);
175                 mutex_unlock(&ttusb->semusb);
176                 return err;
177         }
178 
179         if (debug >= 3) {
180                 actual_len = ttusb->last_result[3] + 4;
181                 printk(KERN_DEBUG "<");
182                 for (i = 0; i < actual_len; ++i)
183                         printk(KERN_CONT " %02x", ttusb->last_result[i]);
184                 printk(KERN_CONT "\n");
185         }
186 
187         if (!needresult)
188                 mutex_unlock(&ttusb->semusb);
189         return 0;
190 }
191 
192 static int ttusb_result(struct ttusb *ttusb, u8 * data, int len)
193 {
194         memcpy(data, ttusb->last_result, len);
195         mutex_unlock(&ttusb->semusb);
196         return 0;
197 }
198 
199 static int ttusb_i2c_msg(struct ttusb *ttusb,
200                   u8 addr, u8 * snd_buf, u8 snd_len, u8 * rcv_buf,
201                   u8 rcv_len)
202 {
203         u8 b[0x28];
204         u8 id = ++ttusb->c;
205         int i, err;
206 
207         if (snd_len > 0x28 - 7 || rcv_len > 0x20 - 7)
208                 return -EINVAL;
209 
210         b[0] = 0xaa;
211         b[1] = id;
212         b[2] = 0x31;
213         b[3] = snd_len + 3;
214         b[4] = addr << 1;
215         b[5] = snd_len;
216         b[6] = rcv_len;
217 
218         for (i = 0; i < snd_len; i++)
219                 b[7 + i] = snd_buf[i];
220 
221         err = ttusb_cmd(ttusb, b, snd_len + 7, 1);
222 
223         if (err)
224                 return -EREMOTEIO;
225 
226         err = ttusb_result(ttusb, b, 0x20);
227 
228         /* check if the i2c transaction was successful */
229         if ((snd_len != b[5]) || (rcv_len != b[6])) return -EREMOTEIO;
230 
231         if (rcv_len > 0) {
232 
233                 if (err || b[0] != 0x55 || b[1] != id) {
234                         dprintk
235                             ("%s: usb_bulk_msg(recv) failed, err == %i, id == %02x, b == ",
236                              __func__, err, id);
237                         return -EREMOTEIO;
238                 }
239 
240                 for (i = 0; i < rcv_len; i++)
241                         rcv_buf[i] = b[7 + i];
242         }
243 
244         return rcv_len;
245 }
246 
247 static int master_xfer(struct i2c_adapter* adapter, struct i2c_msg *msg, int num)
248 {
249         struct ttusb *ttusb = i2c_get_adapdata(adapter);
250         int i = 0;
251         int inc;
252 
253         if (mutex_lock_interruptible(&ttusb->semi2c) < 0)
254                 return -EAGAIN;
255 
256         while (i < num) {
257                 u8 addr, snd_len, rcv_len, *snd_buf, *rcv_buf;
258                 int err;
259 
260                 if (num > i + 1 && (msg[i + 1].flags & I2C_M_RD)) {
261                         addr = msg[i].addr;
262                         snd_buf = msg[i].buf;
263                         snd_len = msg[i].len;
264                         rcv_buf = msg[i + 1].buf;
265                         rcv_len = msg[i + 1].len;
266                         inc = 2;
267                 } else {
268                         addr = msg[i].addr;
269                         snd_buf = msg[i].buf;
270                         snd_len = msg[i].len;
271                         rcv_buf = NULL;
272                         rcv_len = 0;
273                         inc = 1;
274                 }
275 
276                 err = ttusb_i2c_msg(ttusb, addr,
277                                     snd_buf, snd_len, rcv_buf, rcv_len);
278 
279                 if (err < rcv_len) {
280                         dprintk("%s: i == %i\n", __func__, i);
281                         break;
282                 }
283 
284                 i += inc;
285         }
286 
287         mutex_unlock(&ttusb->semi2c);
288         return i;
289 }
290 
291 static int ttusb_boot_dsp(struct ttusb *ttusb)
292 {
293         const struct firmware *fw;
294         int i, err;
295         u8 b[40];
296 
297         err = request_firmware(&fw, "ttusb-budget/dspbootcode.bin",
298                                &ttusb->dev->dev);
299         if (err) {
300                 printk(KERN_ERR "ttusb-budget: failed to request firmware\n");
301                 return err;
302         }
303 
304         /* BootBlock */
305         b[0] = 0xaa;
306         b[2] = 0x13;
307         b[3] = 28;
308 
309         /* upload dsp code in 32 byte steps (36 didn't work for me ...) */
310         /* 32 is max packet size, no messages should be splitted. */
311         for (i = 0; i < fw->size; i += 28) {
312                 memcpy(&b[4], &fw->data[i], 28);
313 
314                 b[1] = ++ttusb->c;
315 
316                 err = ttusb_cmd(ttusb, b, 32, 0);
317                 if (err)
318                         goto done;
319         }
320 
321         /* last block ... */
322         b[1] = ++ttusb->c;
323         b[2] = 0x13;
324         b[3] = 0;
325 
326         err = ttusb_cmd(ttusb, b, 4, 0);
327         if (err)
328                 goto done;
329 
330         /* BootEnd */
331         b[1] = ++ttusb->c;
332         b[2] = 0x14;
333         b[3] = 0;
334 
335         err = ttusb_cmd(ttusb, b, 4, 0);
336 
337       done:
338         release_firmware(fw);
339         if (err) {
340                 dprintk("%s: usb_bulk_msg() failed, return value %i!\n",
341                         __func__, err);
342         }
343 
344         return err;
345 }
346 
347 static int ttusb_set_channel(struct ttusb *ttusb, int chan_id, int filter_type,
348                       int pid)
349 {
350         int err;
351         /* SetChannel */
352         u8 b[] = { 0xaa, ++ttusb->c, 0x22, 4, chan_id, filter_type,
353                 (pid >> 8) & 0xff, pid & 0xff
354         };
355 
356         err = ttusb_cmd(ttusb, b, sizeof(b), 0);
357         return err;
358 }
359 
360 static int ttusb_del_channel(struct ttusb *ttusb, int channel_id)
361 {
362         int err;
363         /* DelChannel */
364         u8 b[] = { 0xaa, ++ttusb->c, 0x23, 1, channel_id };
365 
366         err = ttusb_cmd(ttusb, b, sizeof(b), 0);
367         return err;
368 }
369 
370 #ifdef TTUSB_HWSECTIONS
371 static int ttusb_set_filter(struct ttusb *ttusb, int filter_id,
372                      int associated_chan, u8 filter[8], u8 mask[8])
373 {
374         int err;
375         /* SetFilter */
376         u8 b[] = { 0xaa, 0, 0x24, 0x1a, filter_id, associated_chan,
377                 filter[0], filter[1], filter[2], filter[3],
378                 filter[4], filter[5], filter[6], filter[7],
379                 filter[8], filter[9], filter[10], filter[11],
380                 mask[0], mask[1], mask[2], mask[3],
381                 mask[4], mask[5], mask[6], mask[7],
382                 mask[8], mask[9], mask[10], mask[11]
383         };
384 
385         err = ttusb_cmd(ttusb, b, sizeof(b), 0);
386         return err;
387 }
388 
389 static int ttusb_del_filter(struct ttusb *ttusb, int filter_id)
390 {
391         int err;
392         /* DelFilter */
393         u8 b[] = { 0xaa, ++ttusb->c, 0x25, 1, filter_id };
394 
395         err = ttusb_cmd(ttusb, b, sizeof(b), 0);
396         return err;
397 }
398 #endif
399 
400 static int ttusb_init_controller(struct ttusb *ttusb)
401 {
402         u8 b0[] = { 0xaa, ++ttusb->c, 0x15, 1, 0 };
403         u8 b1[] = { 0xaa, ++ttusb->c, 0x15, 1, 1 };
404         u8 b2[] = { 0xaa, ++ttusb->c, 0x32, 1, 0 };
405         /* i2c write read: 5 bytes, addr 0x10, 0x02 bytes write, 1 bytes read. */
406         u8 b3[] =
407             { 0xaa, ++ttusb->c, 0x31, 5, 0x10, 0x02, 0x01, 0x00, 0x1e };
408         u8 b4[] =
409             { 0x55, ttusb->c, 0x31, 4, 0x10, 0x02, 0x01, 0x00, 0x1e };
410 
411         u8 get_version[] = { 0xaa, ++ttusb->c, 0x17, 5, 0, 0, 0, 0, 0 };
412         u8 get_dsp_version[0x20] =
413             { 0xaa, ++ttusb->c, 0x26, 28, 0, 0, 0, 0, 0 };
414         int err;
415 
416         /* reset board */
417         if ((err = ttusb_cmd(ttusb, b0, sizeof(b0), 0)))
418                 return err;
419 
420         /* reset board (again?) */
421         if ((err = ttusb_cmd(ttusb, b1, sizeof(b1), 0)))
422                 return err;
423 
424         ttusb_boot_dsp(ttusb);
425 
426         /* set i2c bit rate */
427         if ((err = ttusb_cmd(ttusb, b2, sizeof(b2), 0)))
428                 return err;
429 
430         if ((err = ttusb_cmd(ttusb, b3, sizeof(b3), 1)))
431                 return err;
432 
433         err = ttusb_result(ttusb, b4, sizeof(b4));
434 
435         if ((err = ttusb_cmd(ttusb, get_version, sizeof(get_version), 1)))
436                 return err;
437 
438         if ((err = ttusb_result(ttusb, get_version, sizeof(get_version))))
439                 return err;
440 
441         dprintk("%s: stc-version: %c%c%c%c%c\n", __func__,
442                 get_version[4], get_version[5], get_version[6],
443                 get_version[7], get_version[8]);
444 
445         if (memcmp(get_version + 4, "V 0.0", 5) &&
446             memcmp(get_version + 4, "V 1.1", 5) &&
447             memcmp(get_version + 4, "V 2.1", 5) &&
448             memcmp(get_version + 4, "V 2.2", 5)) {
449                 printk
450                     ("%s: unknown STC version %c%c%c%c%c, please report!\n",
451                      __func__, get_version[4], get_version[5],
452                      get_version[6], get_version[7], get_version[8]);
453         }
454 
455         ttusb->revision = ((get_version[6] - '') << 4) |
456                            (get_version[8] - '');
457 
458         err =
459             ttusb_cmd(ttusb, get_dsp_version, sizeof(get_dsp_version), 1);
460         if (err)
461                 return err;
462 
463         err =
464             ttusb_result(ttusb, get_dsp_version, sizeof(get_dsp_version));
465         if (err)
466                 return err;
467         printk("%s: dsp-version: %c%c%c\n", __func__,
468                get_dsp_version[4], get_dsp_version[5], get_dsp_version[6]);
469         return 0;
470 }
471 
472 #ifdef TTUSB_DISEQC
473 static int ttusb_send_diseqc(struct dvb_frontend* fe,
474                              const struct dvb_diseqc_master_cmd *cmd)
475 {
476         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
477         u8 b[12] = { 0xaa, ++ttusb->c, 0x18 };
478 
479         int err;
480 
481         b[3] = 4 + 2 + cmd->msg_len;
482         b[4] = 0xFF;            /* send diseqc master, not burst */
483         b[5] = cmd->msg_len;
484 
485         memcpy(b + 5, cmd->msg, cmd->msg_len);
486 
487         /* Diseqc */
488         if ((err = ttusb_cmd(ttusb, b, 4 + b[3], 0))) {
489                 dprintk("%s: usb_bulk_msg() failed, return value %i!\n",
490                         __func__, err);
491         }
492 
493         return err;
494 }
495 #endif
496 
497 static int ttusb_update_lnb(struct ttusb *ttusb)
498 {
499         u8 b[] = { 0xaa, ++ttusb->c, 0x16, 5, /*power: */ 1,
500                 ttusb->voltage == SEC_VOLTAGE_18 ? 0 : 1,
501                 ttusb->tone == SEC_TONE_ON ? 1 : 0, 1, 1
502         };
503         int err;
504 
505         /* SetLNB */
506         if ((err = ttusb_cmd(ttusb, b, sizeof(b), 0))) {
507                 dprintk("%s: usb_bulk_msg() failed, return value %i!\n",
508                         __func__, err);
509         }
510 
511         return err;
512 }
513 
514 static int ttusb_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage)
515 {
516         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
517 
518         ttusb->voltage = voltage;
519         return ttusb_update_lnb(ttusb);
520 }
521 
522 #ifdef TTUSB_TONE
523 static int ttusb_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
524 {
525         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
526 
527         ttusb->tone = tone;
528         return ttusb_update_lnb(ttusb);
529 }
530 #endif
531 
532 
533 #if 0
534 static void ttusb_set_led_freq(struct ttusb *ttusb, u8 freq)
535 {
536         u8 b[] = { 0xaa, ++ttusb->c, 0x19, 1, freq };
537         int err, actual_len;
538 
539         err = ttusb_cmd(ttusb, b, sizeof(b), 0);
540         if (err) {
541                 dprintk("%s: usb_bulk_msg() failed, return value %i!\n",
542                         __func__, err);
543         }
544 }
545 #endif
546 
547 /*****************************************************************************/
548 
549 #ifdef TTUSB_HWSECTIONS
550 static void ttusb_handle_ts_data(struct ttusb_channel *channel,
551                                  const u8 * data, int len);
552 static void ttusb_handle_sec_data(struct ttusb_channel *channel,
553                                   const u8 * data, int len);
554 #endif
555 
556 static int numpkt, numts, numstuff, numsec, numinvalid;
557 static unsigned long lastj;
558 
559 static void ttusb_process_muxpack(struct ttusb *ttusb, const u8 * muxpack,
560                            int len)
561 {
562         u16 csum = 0, cc;
563         int i;
564 
565         if (len < 4 || len & 0x1) {
566                 pr_warn("%s: muxpack has invalid len %d\n", __func__, len);
567                 numinvalid++;
568                 return;
569         }
570 
571         for (i = 0; i < len; i += 2)
572                 csum ^= le16_to_cpup((__le16 *) (muxpack + i));
573         if (csum) {
574                 printk("%s: muxpack with incorrect checksum, ignoring\n",
575                        __func__);
576                 numinvalid++;
577                 return;
578         }
579 
580         cc = (muxpack[len - 4] << 8) | muxpack[len - 3];
581         cc &= 0x7FFF;
582         if ((cc != ttusb->cc) && (ttusb->cc != -1))
583                 printk("%s: cc discontinuity (%d frames missing)\n",
584                        __func__, (cc - ttusb->cc) & 0x7FFF);
585         ttusb->cc = (cc + 1) & 0x7FFF;
586         if (muxpack[0] & 0x80) {
587 #ifdef TTUSB_HWSECTIONS
588                 /* section data */
589                 int pusi = muxpack[0] & 0x40;
590                 int channel = muxpack[0] & 0x1F;
591                 int payload = muxpack[1];
592                 const u8 *data = muxpack + 2;
593                 /* check offset flag */
594                 if (muxpack[0] & 0x20)
595                         data++;
596 
597                 ttusb_handle_sec_data(ttusb->channel + channel, data,
598                                       payload);
599                 data += payload;
600 
601                 if ((!!(ttusb->muxpack[0] & 0x20)) ^
602                     !!(ttusb->muxpack[1] & 1))
603                         data++;
604 #warning TODO: pusi
605                 printk("cc: %04x\n", (data[0] << 8) | data[1]);
606 #endif
607                 numsec++;
608         } else if (muxpack[0] == 0x47) {
609 #ifdef TTUSB_HWSECTIONS
610                 /* we have TS data here! */
611                 int pid = ((muxpack[1] & 0x0F) << 8) | muxpack[2];
612                 int channel;
613                 for (channel = 0; channel < TTUSB_MAXCHANNEL; ++channel)
614                         if (ttusb->channel[channel].active
615                             && (pid == ttusb->channel[channel].pid))
616                                 ttusb_handle_ts_data(ttusb->channel +
617                                                      channel, muxpack,
618                                                      188);
619 #endif
620                 numts++;
621                 dvb_dmx_swfilter_packets(&ttusb->dvb_demux, muxpack, 1);
622         } else if (muxpack[0] != 0) {
623                 numinvalid++;
624                 printk("illegal muxpack type %02x\n", muxpack[0]);
625         } else
626                 numstuff++;
627 }
628 
629 static void ttusb_process_frame(struct ttusb *ttusb, u8 * data, int len)
630 {
631         int maxwork = 1024;
632         while (len) {
633                 if (!(maxwork--)) {
634                         printk("%s: too much work\n", __func__);
635                         break;
636                 }
637 
638                 switch (ttusb->mux_state) {
639                 case 0:
640                 case 1:
641                 case 2:
642                         len--;
643                         if (*data++ == 0xAA)
644                                 ++ttusb->mux_state;
645                         else {
646                                 ttusb->mux_state = 0;
647                                 if (ttusb->insync) {
648                                         dprintk("%s: %02x\n",
649                                                 __func__, data[-1]);
650                                         printk(KERN_INFO "%s: lost sync.\n",
651                                                __func__);
652                                         ttusb->insync = 0;
653                                 }
654                         }
655                         break;
656                 case 3:
657                         ttusb->insync = 1;
658                         len--;
659                         ttusb->mux_npacks = *data++;
660                         ++ttusb->mux_state;
661                         ttusb->muxpack_ptr = 0;
662                         /* maximum bytes, until we know the length */
663                         ttusb->muxpack_len = 2;
664                         break;
665                 case 4:
666                         {
667                                 int avail;
668                                 avail = len;
669                                 if (avail >
670                                     (ttusb->muxpack_len -
671                                      ttusb->muxpack_ptr))
672                                         avail =
673                                             ttusb->muxpack_len -
674                                             ttusb->muxpack_ptr;
675                                 memcpy(ttusb->muxpack + ttusb->muxpack_ptr,
676                                        data, avail);
677                                 ttusb->muxpack_ptr += avail;
678                                 BUG_ON(ttusb->muxpack_ptr > 264);
679                                 data += avail;
680                                 len -= avail;
681                                 /* determine length */
682                                 if (ttusb->muxpack_ptr == 2) {
683                                         if (ttusb->muxpack[0] & 0x80) {
684                                                 ttusb->muxpack_len =
685                                                     ttusb->muxpack[1] + 2;
686                                                 if (ttusb->
687                                                     muxpack[0] & 0x20)
688                                                         ttusb->
689                                                             muxpack_len++;
690                                                 if ((!!
691                                                      (ttusb->
692                                                       muxpack[0] & 0x20)) ^
693                                                     !!(ttusb->
694                                                        muxpack[1] & 1))
695                                                         ttusb->
696                                                             muxpack_len++;
697                                                 ttusb->muxpack_len += 4;
698                                         } else if (ttusb->muxpack[0] ==
699                                                    0x47)
700                                                 ttusb->muxpack_len =
701                                                     188 + 4;
702                                         else if (ttusb->muxpack[0] == 0x00)
703                                                 ttusb->muxpack_len =
704                                                     ttusb->muxpack[1] + 2 +
705                                                     4;
706                                         else {
707                                                 dprintk
708                                                     ("%s: invalid state: first byte is %x\n",
709                                                      __func__,
710                                                      ttusb->muxpack[0]);
711                                                 ttusb->mux_state = 0;
712                                         }
713                                 }
714 
715                         /**
716                          * if length is valid and we reached the end:
717                          * goto next muxpack
718                          */
719                                 if ((ttusb->muxpack_ptr >= 2) &&
720                                     (ttusb->muxpack_ptr ==
721                                      ttusb->muxpack_len)) {
722                                         ttusb_process_muxpack(ttusb,
723                                                               ttusb->
724                                                               muxpack,
725                                                               ttusb->
726                                                               muxpack_ptr);
727                                         ttusb->muxpack_ptr = 0;
728                                         /* maximum bytes, until we know the length */
729                                         ttusb->muxpack_len = 2;
730 
731                                 /**
732                                  * no muxpacks left?
733                                  * return to search-sync state
734                                  */
735                                         if (!ttusb->mux_npacks--) {
736                                                 ttusb->mux_state = 0;
737                                                 break;
738                                         }
739                                 }
740                                 break;
741                         }
742                 default:
743                         BUG();
744                         break;
745                 }
746         }
747 }
748 
749 static void ttusb_iso_irq(struct urb *urb)
750 {
751         struct ttusb *ttusb = urb->context;
752         struct usb_iso_packet_descriptor *d;
753         u8 *data;
754         int len, i;
755 
756         if (!ttusb->iso_streaming)
757                 return;
758 
759 #if 0
760         printk("%s: status %d, errcount == %d, length == %i\n",
761                __func__,
762                urb->status, urb->error_count, urb->actual_length);
763 #endif
764 
765         if (!urb->status) {
766                 for (i = 0; i < urb->number_of_packets; ++i) {
767                         numpkt++;
768                         if (time_after_eq(jiffies, lastj + HZ)) {
769                                 dprintk("frames/s: %lu (ts: %d, stuff %d, "
770                                         "sec: %d, invalid: %d, all: %d)\n",
771                                         numpkt * HZ / (jiffies - lastj),
772                                         numts, numstuff, numsec, numinvalid,
773                                         numts + numstuff + numsec + numinvalid);
774                                 numts = numstuff = numsec = numinvalid = 0;
775                                 lastj = jiffies;
776                                 numpkt = 0;
777                         }
778                         d = &urb->iso_frame_desc[i];
779                         data = urb->transfer_buffer + d->offset;
780                         len = d->actual_length;
781                         d->actual_length = 0;
782                         d->status = 0;
783                         ttusb_process_frame(ttusb, data, len);
784                 }
785         }
786         usb_submit_urb(urb, GFP_ATOMIC);
787 }
788 
789 static void ttusb_free_iso_urbs(struct ttusb *ttusb)
790 {
791         int i;
792 
793         for (i = 0; i < ISO_BUF_COUNT; i++)
794                 usb_free_urb(ttusb->iso_urb[i]);
795 
796         pci_free_consistent(NULL,
797                             ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF *
798                             ISO_BUF_COUNT, ttusb->iso_buffer,
799                             ttusb->iso_dma_handle);
800 }
801 
802 static int ttusb_alloc_iso_urbs(struct ttusb *ttusb)
803 {
804         int i;
805 
806         ttusb->iso_buffer = pci_zalloc_consistent(NULL,
807                                                   ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF * ISO_BUF_COUNT,
808                                                   &ttusb->iso_dma_handle);
809 
810         if (!ttusb->iso_buffer) {
811                 dprintk("%s: pci_alloc_consistent - not enough memory\n",
812                         __func__);
813                 return -ENOMEM;
814         }
815 
816         for (i = 0; i < ISO_BUF_COUNT; i++) {
817                 struct urb *urb;
818 
819                 if (!
820                     (urb =
821                      usb_alloc_urb(FRAMES_PER_ISO_BUF, GFP_ATOMIC))) {
822                         ttusb_free_iso_urbs(ttusb);
823                         return -ENOMEM;
824                 }
825 
826                 ttusb->iso_urb[i] = urb;
827         }
828 
829         return 0;
830 }
831 
832 static void ttusb_stop_iso_xfer(struct ttusb *ttusb)
833 {
834         int i;
835 
836         for (i = 0; i < ISO_BUF_COUNT; i++)
837                 usb_kill_urb(ttusb->iso_urb[i]);
838 
839         ttusb->iso_streaming = 0;
840 }
841 
842 static int ttusb_start_iso_xfer(struct ttusb *ttusb)
843 {
844         int i, j, err, buffer_offset = 0;
845 
846         if (ttusb->iso_streaming) {
847                 printk("%s: iso xfer already running!\n", __func__);
848                 return 0;
849         }
850 
851         ttusb->cc = -1;
852         ttusb->insync = 0;
853         ttusb->mux_state = 0;
854 
855         for (i = 0; i < ISO_BUF_COUNT; i++) {
856                 int frame_offset = 0;
857                 struct urb *urb = ttusb->iso_urb[i];
858 
859                 urb->dev = ttusb->dev;
860                 urb->context = ttusb;
861                 urb->complete = ttusb_iso_irq;
862                 urb->pipe = ttusb->isoc_in_pipe;
863                 urb->transfer_flags = URB_ISO_ASAP;
864                 urb->interval = 1;
865                 urb->number_of_packets = FRAMES_PER_ISO_BUF;
866                 urb->transfer_buffer_length =
867                     ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF;
868                 urb->transfer_buffer = ttusb->iso_buffer + buffer_offset;
869                 buffer_offset += ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF;
870 
871                 for (j = 0; j < FRAMES_PER_ISO_BUF; j++) {
872                         urb->iso_frame_desc[j].offset = frame_offset;
873                         urb->iso_frame_desc[j].length = ISO_FRAME_SIZE;
874                         frame_offset += ISO_FRAME_SIZE;
875                 }
876         }
877 
878         for (i = 0; i < ISO_BUF_COUNT; i++) {
879                 if ((err = usb_submit_urb(ttusb->iso_urb[i], GFP_ATOMIC))) {
880                         ttusb_stop_iso_xfer(ttusb);
881                         printk
882                             ("%s: failed urb submission (%i: err = %i)!\n",
883                              __func__, i, err);
884                         return err;
885                 }
886         }
887 
888         ttusb->iso_streaming = 1;
889 
890         return 0;
891 }
892 
893 #ifdef TTUSB_HWSECTIONS
894 static void ttusb_handle_ts_data(struct dvb_demux_feed *dvbdmxfeed, const u8 * data,
895                           int len)
896 {
897         dvbdmxfeed->cb.ts(data, len, 0, 0, &dvbdmxfeed->feed.ts, 0);
898 }
899 
900 static void ttusb_handle_sec_data(struct dvb_demux_feed *dvbdmxfeed, const u8 * data,
901                            int len)
902 {
903 //      struct dvb_demux_feed *dvbdmxfeed = channel->dvbdmxfeed;
904 #error TODO: handle ugly stuff
905 //      dvbdmxfeed->cb.sec(data, len, 0, 0, &dvbdmxfeed->feed.sec, 0);
906 }
907 #endif
908 
909 static int ttusb_start_feed(struct dvb_demux_feed *dvbdmxfeed)
910 {
911         struct ttusb *ttusb = (struct ttusb *) dvbdmxfeed->demux;
912         int feed_type = 1;
913 
914         dprintk("ttusb_start_feed\n");
915 
916         switch (dvbdmxfeed->type) {
917         case DMX_TYPE_TS:
918                 break;
919         case DMX_TYPE_SEC:
920                 break;
921         default:
922                 return -EINVAL;
923         }
924 
925         if (dvbdmxfeed->type == DMX_TYPE_TS) {
926                 switch (dvbdmxfeed->pes_type) {
927                 case DMX_PES_VIDEO:
928                 case DMX_PES_AUDIO:
929                 case DMX_PES_TELETEXT:
930                 case DMX_PES_PCR:
931                 case DMX_PES_OTHER:
932                         break;
933                 default:
934                         return -EINVAL;
935                 }
936         }
937 
938 #ifdef TTUSB_HWSECTIONS
939 #error TODO: allocate filters
940         if (dvbdmxfeed->type == DMX_TYPE_TS) {
941                 feed_type = 1;
942         } else if (dvbdmxfeed->type == DMX_TYPE_SEC) {
943                 feed_type = 2;
944         }
945 #endif
946 
947         ttusb_set_channel(ttusb, dvbdmxfeed->index, feed_type, dvbdmxfeed->pid);
948 
949         if (0 == ttusb->running_feed_count++)
950                 ttusb_start_iso_xfer(ttusb);
951 
952         return 0;
953 }
954 
955 static int ttusb_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
956 {
957         struct ttusb *ttusb = (struct ttusb *) dvbdmxfeed->demux;
958 
959         ttusb_del_channel(ttusb, dvbdmxfeed->index);
960 
961         if (--ttusb->running_feed_count == 0)
962                 ttusb_stop_iso_xfer(ttusb);
963 
964         return 0;
965 }
966 
967 static int ttusb_setup_interfaces(struct ttusb *ttusb)
968 {
969         usb_set_interface(ttusb->dev, 1, 1);
970 
971         ttusb->bulk_out_pipe = usb_sndbulkpipe(ttusb->dev, 1);
972         ttusb->bulk_in_pipe = usb_rcvbulkpipe(ttusb->dev, 1);
973         ttusb->isoc_in_pipe = usb_rcvisocpipe(ttusb->dev, 2);
974 
975         return 0;
976 }
977 
978 #if 0
979 static u8 stc_firmware[8192];
980 
981 static int stc_open(struct inode *inode, struct file *file)
982 {
983         struct ttusb *ttusb = file->private_data;
984         int addr;
985 
986         for (addr = 0; addr < 8192; addr += 16) {
987                 u8 snd_buf[2] = { addr >> 8, addr & 0xFF };
988                 ttusb_i2c_msg(ttusb, 0x50, snd_buf, 2, stc_firmware + addr,
989                               16);
990         }
991 
992         return 0;
993 }
994 
995 static ssize_t stc_read(struct file *file, char *buf, size_t count,
996                  loff_t *offset)
997 {
998         return simple_read_from_buffer(buf, count, offset, stc_firmware, 8192);
999 }
1000 
1001 static int stc_release(struct inode *inode, struct file *file)
1002 {
1003         return 0;
1004 }
1005 
1006 static const struct file_operations stc_fops = {
1007         .owner = THIS_MODULE,
1008         .read = stc_read,
1009         .open = stc_open,
1010         .release = stc_release,
1011 };
1012 #endif
1013 
1014 static u32 functionality(struct i2c_adapter *adapter)
1015 {
1016         return I2C_FUNC_I2C;
1017 }
1018 
1019 
1020 
1021 static int alps_tdmb7_tuner_set_params(struct dvb_frontend *fe)
1022 {
1023         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1024         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1025         u8 data[4];
1026         struct i2c_msg msg = {.addr=0x61, .flags=0, .buf=data, .len=sizeof(data) };
1027         u32 div;
1028 
1029         div = (p->frequency + 36166667) / 166667;
1030 
1031         data[0] = (div >> 8) & 0x7f;
1032         data[1] = div & 0xff;
1033         data[2] = ((div >> 10) & 0x60) | 0x85;
1034         data[3] = p->frequency < 592000000 ? 0x40 : 0x80;
1035 
1036         if (fe->ops.i2c_gate_ctrl)
1037                 fe->ops.i2c_gate_ctrl(fe, 1);
1038         if (i2c_transfer(&ttusb->i2c_adap, &msg, 1) != 1) return -EIO;
1039         return 0;
1040 }
1041 
1042 static struct cx22700_config alps_tdmb7_config = {
1043         .demod_address = 0x43,
1044 };
1045 
1046 
1047 
1048 
1049 
1050 static int philips_tdm1316l_tuner_init(struct dvb_frontend* fe)
1051 {
1052         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1053         static u8 td1316_init[] = { 0x0b, 0xf5, 0x85, 0xab };
1054         static u8 disable_mc44BC374c[] = { 0x1d, 0x74, 0xa0, 0x68 };
1055         struct i2c_msg tuner_msg = { .addr=0x60, .flags=0, .buf=td1316_init, .len=sizeof(td1316_init) };
1056 
1057         // setup PLL configuration
1058         if (fe->ops.i2c_gate_ctrl)
1059                 fe->ops.i2c_gate_ctrl(fe, 1);
1060         if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) return -EIO;
1061         msleep(1);
1062 
1063         // disable the mc44BC374c (do not check for errors)
1064         tuner_msg.addr = 0x65;
1065         tuner_msg.buf = disable_mc44BC374c;
1066         tuner_msg.len = sizeof(disable_mc44BC374c);
1067         if (fe->ops.i2c_gate_ctrl)
1068                 fe->ops.i2c_gate_ctrl(fe, 1);
1069         if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) {
1070                 i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1);
1071         }
1072 
1073         return 0;
1074 }
1075 
1076 static int philips_tdm1316l_tuner_set_params(struct dvb_frontend *fe)
1077 {
1078         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1079         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1080         u8 tuner_buf[4];
1081         struct i2c_msg tuner_msg = {.addr=0x60, .flags=0, .buf=tuner_buf, .len=sizeof(tuner_buf) };
1082         int tuner_frequency = 0;
1083         u8 band, cp, filter;
1084 
1085         // determine charge pump
1086         tuner_frequency = p->frequency + 36130000;
1087         if (tuner_frequency < 87000000) return -EINVAL;
1088         else if (tuner_frequency < 130000000) cp = 3;
1089         else if (tuner_frequency < 160000000) cp = 5;
1090         else if (tuner_frequency < 200000000) cp = 6;
1091         else if (tuner_frequency < 290000000) cp = 3;
1092         else if (tuner_frequency < 420000000) cp = 5;
1093         else if (tuner_frequency < 480000000) cp = 6;
1094         else if (tuner_frequency < 620000000) cp = 3;
1095         else if (tuner_frequency < 830000000) cp = 5;
1096         else if (tuner_frequency < 895000000) cp = 7;
1097         else return -EINVAL;
1098 
1099         // determine band
1100         if (p->frequency < 49000000)
1101                 return -EINVAL;
1102         else if (p->frequency < 159000000)
1103                 band = 1;
1104         else if (p->frequency < 444000000)
1105                 band = 2;
1106         else if (p->frequency < 861000000)
1107                 band = 4;
1108         else return -EINVAL;
1109 
1110         // setup PLL filter
1111         switch (p->bandwidth_hz) {
1112         case 6000000:
1113                 tda1004x_writereg(fe, 0x0C, 0);
1114                 filter = 0;
1115                 break;
1116 
1117         case 7000000:
1118                 tda1004x_writereg(fe, 0x0C, 0);
1119                 filter = 0;
1120                 break;
1121 
1122         case 8000000:
1123                 tda1004x_writereg(fe, 0x0C, 0xFF);
1124                 filter = 1;
1125                 break;
1126 
1127         default:
1128                 return -EINVAL;
1129         }
1130 
1131         // calculate divisor
1132         // ((36130000+((1000000/6)/2)) + Finput)/(1000000/6)
1133         tuner_frequency = (((p->frequency / 1000) * 6) + 217280) / 1000;
1134 
1135         // setup tuner buffer
1136         tuner_buf[0] = tuner_frequency >> 8;
1137         tuner_buf[1] = tuner_frequency & 0xff;
1138         tuner_buf[2] = 0xca;
1139         tuner_buf[3] = (cp << 5) | (filter << 3) | band;
1140 
1141         if (fe->ops.i2c_gate_ctrl)
1142                 fe->ops.i2c_gate_ctrl(fe, 1);
1143         if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1)
1144                 return -EIO;
1145 
1146         msleep(1);
1147         return 0;
1148 }
1149 
1150 static int philips_tdm1316l_request_firmware(struct dvb_frontend* fe, const struct firmware **fw, char* name)
1151 {
1152         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1153 
1154         return request_firmware(fw, name, &ttusb->dev->dev);
1155 }
1156 
1157 static struct tda1004x_config philips_tdm1316l_config = {
1158 
1159         .demod_address = 0x8,
1160         .invert = 1,
1161         .invert_oclk = 0,
1162         .request_firmware = philips_tdm1316l_request_firmware,
1163 };
1164 
1165 static u8 alps_bsbe1_inittab[] = {
1166         0x01, 0x15,
1167         0x02, 0x30,
1168         0x03, 0x00,
1169         0x04, 0x7d,             /* F22FR = 0x7d, F22 = f_VCO / 128 / 0x7d = 22 kHz */
1170         0x05, 0x35,             /* I2CT = 0, SCLT = 1, SDAT = 1 */
1171         0x06, 0x40,             /* DAC not used, set to high impendance mode */
1172         0x07, 0x00,             /* DAC LSB */
1173         0x08, 0x40,             /* DiSEqC off, LNB power on OP2/LOCK pin on */
1174         0x09, 0x00,             /* FIFO */
1175         0x0c, 0x51,             /* OP1 ctl = Normal, OP1 val = 1 (LNB Power ON) */
1176         0x0d, 0x82,             /* DC offset compensation = ON, beta_agc1 = 2 */
1177         0x0e, 0x23,             /* alpha_tmg = 2, beta_tmg = 3 */
1178         0x10, 0x3f,             // AGC2  0x3d
1179         0x11, 0x84,
1180         0x12, 0xb9,
1181         0x15, 0xc9,             // lock detector threshold
1182         0x16, 0x00,
1183         0x17, 0x00,
1184         0x18, 0x00,
1185         0x19, 0x00,
1186         0x1a, 0x00,
1187         0x1f, 0x50,
1188         0x20, 0x00,
1189         0x21, 0x00,
1190         0x22, 0x00,
1191         0x23, 0x00,
1192         0x28, 0x00,             // out imp: normal  out type: parallel FEC mode:0
1193         0x29, 0x1e,             // 1/2 threshold
1194         0x2a, 0x14,             // 2/3 threshold
1195         0x2b, 0x0f,             // 3/4 threshold
1196         0x2c, 0x09,             // 5/6 threshold
1197         0x2d, 0x05,             // 7/8 threshold
1198         0x2e, 0x01,
1199         0x31, 0x1f,             // test all FECs
1200         0x32, 0x19,             // viterbi and synchro search
1201         0x33, 0xfc,             // rs control
1202         0x34, 0x93,             // error control
1203         0x0f, 0x92,
1204         0xff, 0xff
1205 };
1206 
1207 static u8 alps_bsru6_inittab[] = {
1208         0x01, 0x15,
1209         0x02, 0x30,
1210         0x03, 0x00,
1211         0x04, 0x7d,             /* F22FR = 0x7d, F22 = f_VCO / 128 / 0x7d = 22 kHz */
1212         0x05, 0x35,             /* I2CT = 0, SCLT = 1, SDAT = 1 */
1213         0x06, 0x40,             /* DAC not used, set to high impendance mode */
1214         0x07, 0x00,             /* DAC LSB */
1215         0x08, 0x40,             /* DiSEqC off, LNB power on OP2/LOCK pin on */
1216         0x09, 0x00,             /* FIFO */
1217         0x0c, 0x51,             /* OP1 ctl = Normal, OP1 val = 1 (LNB Power ON) */
1218         0x0d, 0x82,             /* DC offset compensation = ON, beta_agc1 = 2 */
1219         0x0e, 0x23,             /* alpha_tmg = 2, beta_tmg = 3 */
1220         0x10, 0x3f,             // AGC2  0x3d
1221         0x11, 0x84,
1222         0x12, 0xb9,
1223         0x15, 0xc9,             // lock detector threshold
1224         0x16, 0x00,
1225         0x17, 0x00,
1226         0x18, 0x00,
1227         0x19, 0x00,
1228         0x1a, 0x00,
1229         0x1f, 0x50,
1230         0x20, 0x00,
1231         0x21, 0x00,
1232         0x22, 0x00,
1233         0x23, 0x00,
1234         0x28, 0x00,             // out imp: normal  out type: parallel FEC mode:0
1235         0x29, 0x1e,             // 1/2 threshold
1236         0x2a, 0x14,             // 2/3 threshold
1237         0x2b, 0x0f,             // 3/4 threshold
1238         0x2c, 0x09,             // 5/6 threshold
1239         0x2d, 0x05,             // 7/8 threshold
1240         0x2e, 0x01,
1241         0x31, 0x1f,             // test all FECs
1242         0x32, 0x19,             // viterbi and synchro search
1243         0x33, 0xfc,             // rs control
1244         0x34, 0x93,             // error control
1245         0x0f, 0x52,
1246         0xff, 0xff
1247 };
1248 
1249 static int alps_stv0299_set_symbol_rate(struct dvb_frontend *fe, u32 srate, u32 ratio)
1250 {
1251         u8 aclk = 0;
1252         u8 bclk = 0;
1253 
1254         if (srate < 1500000) {
1255                 aclk = 0xb7;
1256                 bclk = 0x47;
1257         } else if (srate < 3000000) {
1258                 aclk = 0xb7;
1259                 bclk = 0x4b;
1260         } else if (srate < 7000000) {
1261                 aclk = 0xb7;
1262                 bclk = 0x4f;
1263         } else if (srate < 14000000) {
1264                 aclk = 0xb7;
1265                 bclk = 0x53;
1266         } else if (srate < 30000000) {
1267                 aclk = 0xb6;
1268                 bclk = 0x53;
1269         } else if (srate < 45000000) {
1270                 aclk = 0xb4;
1271                 bclk = 0x51;
1272         }
1273 
1274         stv0299_writereg(fe, 0x13, aclk);
1275         stv0299_writereg(fe, 0x14, bclk);
1276         stv0299_writereg(fe, 0x1f, (ratio >> 16) & 0xff);
1277         stv0299_writereg(fe, 0x20, (ratio >> 8) & 0xff);
1278         stv0299_writereg(fe, 0x21, (ratio) & 0xf0);
1279 
1280         return 0;
1281 }
1282 
1283 static int philips_tsa5059_tuner_set_params(struct dvb_frontend *fe)
1284 {
1285         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1286         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1287         u8 buf[4];
1288         u32 div;
1289         struct i2c_msg msg = {.addr = 0x61,.flags = 0,.buf = buf,.len = sizeof(buf) };
1290 
1291         if ((p->frequency < 950000) || (p->frequency > 2150000))
1292                 return -EINVAL;
1293 
1294         div = (p->frequency + (125 - 1)) / 125; /* round correctly */
1295         buf[0] = (div >> 8) & 0x7f;
1296         buf[1] = div & 0xff;
1297         buf[2] = 0x80 | ((div & 0x18000) >> 10) | 4;
1298         buf[3] = 0xC4;
1299 
1300         if (p->frequency > 1530000)
1301                 buf[3] = 0xC0;
1302 
1303         /* BSBE1 wants XCE bit set */
1304         if (ttusb->revision == TTUSB_REV_2_2)
1305                 buf[3] |= 0x20;
1306 
1307         if (fe->ops.i2c_gate_ctrl)
1308                 fe->ops.i2c_gate_ctrl(fe, 1);
1309         if (i2c_transfer(&ttusb->i2c_adap, &msg, 1) != 1)
1310                 return -EIO;
1311 
1312         return 0;
1313 }
1314 
1315 static struct stv0299_config alps_stv0299_config = {
1316         .demod_address = 0x68,
1317         .inittab = alps_bsru6_inittab,
1318         .mclk = 88000000UL,
1319         .invert = 1,
1320         .skip_reinit = 0,
1321         .lock_output = STV0299_LOCKOUTPUT_1,
1322         .volt13_op0_op1 = STV0299_VOLT13_OP1,
1323         .min_delay_ms = 100,
1324         .set_symbol_rate = alps_stv0299_set_symbol_rate,
1325 };
1326 
1327 static int ttusb_novas_grundig_29504_491_tuner_set_params(struct dvb_frontend *fe)
1328 {
1329         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1330         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1331         u8 buf[4];
1332         u32 div;
1333         struct i2c_msg msg = {.addr = 0x61,.flags = 0,.buf = buf,.len = sizeof(buf) };
1334 
1335         div = p->frequency / 125;
1336 
1337         buf[0] = (div >> 8) & 0x7f;
1338         buf[1] = div & 0xff;
1339         buf[2] = 0x8e;
1340         buf[3] = 0x00;
1341 
1342         if (fe->ops.i2c_gate_ctrl)
1343                 fe->ops.i2c_gate_ctrl(fe, 1);
1344         if (i2c_transfer(&ttusb->i2c_adap, &msg, 1) != 1)
1345                 return -EIO;
1346 
1347         return 0;
1348 }
1349 
1350 static struct tda8083_config ttusb_novas_grundig_29504_491_config = {
1351 
1352         .demod_address = 0x68,
1353 };
1354 
1355 static int alps_tdbe2_tuner_set_params(struct dvb_frontend *fe)
1356 {
1357         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1358         struct ttusb* ttusb = fe->dvb->priv;
1359         u32 div;
1360         u8 data[4];
1361         struct i2c_msg msg = { .addr = 0x62, .flags = 0, .buf = data, .len = sizeof(data) };
1362 
1363         div = (p->frequency + 35937500 + 31250) / 62500;
1364 
1365         data[0] = (div >> 8) & 0x7f;
1366         data[1] = div & 0xff;
1367         data[2] = 0x85 | ((div >> 10) & 0x60);
1368         data[3] = (p->frequency < 174000000 ? 0x88 : p->frequency < 470000000 ? 0x84 : 0x81);
1369 
1370         if (fe->ops.i2c_gate_ctrl)
1371                 fe->ops.i2c_gate_ctrl(fe, 1);
1372         if (i2c_transfer (&ttusb->i2c_adap, &msg, 1) != 1)
1373                 return -EIO;
1374 
1375         return 0;
1376 }
1377 
1378 
1379 static struct ves1820_config alps_tdbe2_config = {
1380         .demod_address = 0x09,
1381         .xin = 57840000UL,
1382         .invert = 1,
1383         .selagc = VES1820_SELAGC_SIGNAMPERR,
1384 };
1385 
1386 static u8 read_pwm(struct ttusb* ttusb)
1387 {
1388         u8 b = 0xff;
1389         u8 pwm;
1390         struct i2c_msg msg[] = { { .addr = 0x50,.flags = 0,.buf = &b,.len = 1 },
1391                                 { .addr = 0x50,.flags = I2C_M_RD,.buf = &pwm,.len = 1} };
1392 
1393         if ((i2c_transfer(&ttusb->i2c_adap, msg, 2) != 2) || (pwm == 0xff))
1394                 pwm = 0x48;
1395 
1396         return pwm;
1397 }
1398 
1399 
1400 static int dvbc_philips_tdm1316l_tuner_set_params(struct dvb_frontend *fe)
1401 {
1402         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1403         struct ttusb *ttusb = (struct ttusb *) fe->dvb->priv;
1404         u8 tuner_buf[5];
1405         struct i2c_msg tuner_msg = {.addr = 0x60,
1406                                     .flags = 0,
1407                                     .buf = tuner_buf,
1408                                     .len = sizeof(tuner_buf) };
1409         int tuner_frequency = 0;
1410         u8 band, cp, filter;
1411 
1412         // determine charge pump
1413         tuner_frequency = p->frequency;
1414         if      (tuner_frequency <  87000000) {return -EINVAL;}
1415         else if (tuner_frequency < 130000000) {cp = 3; band = 1;}
1416         else if (tuner_frequency < 160000000) {cp = 5; band = 1;}
1417         else if (tuner_frequency < 200000000) {cp = 6; band = 1;}
1418         else if (tuner_frequency < 290000000) {cp = 3; band = 2;}
1419         else if (tuner_frequency < 420000000) {cp = 5; band = 2;}
1420         else if (tuner_frequency < 480000000) {cp = 6; band = 2;}
1421         else if (tuner_frequency < 620000000) {cp = 3; band = 4;}
1422         else if (tuner_frequency < 830000000) {cp = 5; band = 4;}
1423         else if (tuner_frequency < 895000000) {cp = 7; band = 4;}
1424         else {return -EINVAL;}
1425 
1426         // assume PLL filter should always be 8MHz for the moment.
1427         filter = 1;
1428 
1429         // calculate divisor
1430         // (Finput + Fif)/Fref; Fif = 36125000 Hz, Fref = 62500 Hz
1431         tuner_frequency = ((p->frequency + 36125000) / 62500);
1432 
1433         // setup tuner buffer
1434         tuner_buf[0] = tuner_frequency >> 8;
1435         tuner_buf[1] = tuner_frequency & 0xff;
1436         tuner_buf[2] = 0xc8;
1437         tuner_buf[3] = (cp << 5) | (filter << 3) | band;
1438         tuner_buf[4] = 0x80;
1439 
1440         if (fe->ops.i2c_gate_ctrl)
1441                 fe->ops.i2c_gate_ctrl(fe, 1);
1442         if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) {
1443                 printk("dvb-ttusb-budget: dvbc_philips_tdm1316l_pll_set Error 1\n");
1444                 return -EIO;
1445         }
1446 
1447         msleep(50);
1448 
1449         if (fe->ops.i2c_gate_ctrl)
1450                 fe->ops.i2c_gate_ctrl(fe, 1);
1451         if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) {
1452                 printk("dvb-ttusb-budget: dvbc_philips_tdm1316l_pll_set Error 2\n");
1453                 return -EIO;
1454         }
1455 
1456         msleep(1);
1457 
1458         return 0;
1459 }
1460 
1461 static u8 dvbc_philips_tdm1316l_inittab[] = {
1462         0x80, 0x21,
1463         0x80, 0x20,
1464         0x81, 0x01,
1465         0x81, 0x00,
1466         0x00, 0x09,
1467         0x01, 0x69,
1468         0x03, 0x00,
1469         0x04, 0x00,
1470         0x07, 0x00,
1471         0x08, 0x00,
1472         0x20, 0x00,
1473         0x21, 0x40,
1474         0x22, 0x00,
1475         0x23, 0x00,
1476         0x24, 0x40,
1477         0x25, 0x88,
1478         0x30, 0xff,
1479         0x31, 0x00,
1480         0x32, 0xff,
1481         0x33, 0x00,
1482         0x34, 0x50,
1483         0x35, 0x7f,
1484         0x36, 0x00,
1485         0x37, 0x20,
1486         0x38, 0x00,
1487         0x40, 0x1c,
1488         0x41, 0xff,
1489         0x42, 0x29,
1490         0x43, 0x20,
1491         0x44, 0xff,
1492         0x45, 0x00,
1493         0x46, 0x00,
1494         0x49, 0x04,
1495         0x4a, 0xff,
1496         0x4b, 0x7f,
1497         0x52, 0x30,
1498         0x55, 0xae,
1499         0x56, 0x47,
1500         0x57, 0xe1,
1501         0x58, 0x3a,
1502         0x5a, 0x1e,
1503         0x5b, 0x34,
1504         0x60, 0x00,
1505         0x63, 0x00,
1506         0x64, 0x00,
1507         0x65, 0x00,
1508         0x66, 0x00,
1509         0x67, 0x00,
1510         0x68, 0x00,
1511         0x69, 0x00,
1512         0x6a, 0x02,
1513         0x6b, 0x00,
1514         0x70, 0xff,
1515         0x71, 0x00,
1516         0x72, 0x00,
1517         0x73, 0x00,
1518         0x74, 0x0c,
1519         0x80, 0x00,
1520         0x81, 0x00,
1521         0x82, 0x00,
1522         0x83, 0x00,
1523         0x84, 0x04,
1524         0x85, 0x80,
1525         0x86, 0x24,
1526         0x87, 0x78,
1527         0x88, 0x00,
1528         0x89, 0x00,
1529         0x90, 0x01,
1530         0x91, 0x01,
1531         0xa0, 0x00,
1532         0xa1, 0x00,
1533         0xa2, 0x00,
1534         0xb0, 0x91,
1535         0xb1, 0x0b,
1536         0xc0, 0x4b,
1537         0xc1, 0x00,
1538         0xc2, 0x00,
1539         0xd0, 0x00,
1540         0xd1, 0x00,
1541         0xd2, 0x00,
1542         0xd3, 0x00,
1543         0xd4, 0x00,
1544         0xd5, 0x00,
1545         0xde, 0x00,
1546         0xdf, 0x00,
1547         0x61, 0x38,
1548         0x62, 0x0a,
1549         0x53, 0x13,
1550         0x59, 0x08,
1551         0x55, 0x00,
1552         0x56, 0x40,
1553         0x57, 0x08,
1554         0x58, 0x3d,
1555         0x88, 0x10,
1556         0xa0, 0x00,
1557         0xa0, 0x00,
1558         0xa0, 0x00,
1559         0xa0, 0x04,
1560         0xff, 0xff,
1561 };
1562 
1563 static struct stv0297_config dvbc_philips_tdm1316l_config = {
1564         .demod_address = 0x1c,
1565         .inittab = dvbc_philips_tdm1316l_inittab,
1566         .invert = 0,
1567 };
1568 
1569 static void frontend_init(struct ttusb* ttusb)
1570 {
1571         switch(le16_to_cpu(ttusb->dev->descriptor.idProduct)) {
1572         case 0x1003: // Hauppauge/TT Nova-USB-S budget (stv0299/ALPS BSRU6|BSBE1(tsa5059))
1573                 // try the stv0299 based first
1574                 ttusb->fe = dvb_attach(stv0299_attach, &alps_stv0299_config, &ttusb->i2c_adap);
1575                 if (ttusb->fe != NULL) {
1576                         ttusb->fe->ops.tuner_ops.set_params = philips_tsa5059_tuner_set_params;
1577 
1578                         if(ttusb->revision == TTUSB_REV_2_2) { // ALPS BSBE1
1579                                 alps_stv0299_config.inittab = alps_bsbe1_inittab;
1580                                 dvb_attach(lnbp21_attach, ttusb->fe, &ttusb->i2c_adap, 0, 0);
1581                         } else { // ALPS BSRU6
1582                                 ttusb->fe->ops.set_voltage = ttusb_set_voltage;
1583                         }
1584                         break;
1585                 }
1586 
1587                 // Grundig 29504-491
1588                 ttusb->fe = dvb_attach(tda8083_attach, &ttusb_novas_grundig_29504_491_config, &ttusb->i2c_adap);
1589                 if (ttusb->fe != NULL) {
1590                         ttusb->fe->ops.tuner_ops.set_params = ttusb_novas_grundig_29504_491_tuner_set_params;
1591                         ttusb->fe->ops.set_voltage = ttusb_set_voltage;
1592                         break;
1593                 }
1594                 break;
1595 
1596         case 0x1004: // Hauppauge/TT DVB-C budget (ves1820/ALPS TDBE2(sp5659))
1597                 ttusb->fe = dvb_attach(ves1820_attach, &alps_tdbe2_config, &ttusb->i2c_adap, read_pwm(ttusb));
1598                 if (ttusb->fe != NULL) {
1599                         ttusb->fe->ops.tuner_ops.set_params = alps_tdbe2_tuner_set_params;
1600                         break;
1601                 }
1602 
1603                 ttusb->fe = dvb_attach(stv0297_attach, &dvbc_philips_tdm1316l_config, &ttusb->i2c_adap);
1604                 if (ttusb->fe != NULL) {
1605                         ttusb->fe->ops.tuner_ops.set_params = dvbc_philips_tdm1316l_tuner_set_params;
1606                         break;
1607                 }
1608                 break;
1609 
1610         case 0x1005: // Hauppauge/TT Nova-USB-t budget (tda10046/Philips td1316(tda6651tt) OR cx22700/ALPS TDMB7(??))
1611                 // try the ALPS TDMB7 first
1612                 ttusb->fe = dvb_attach(cx22700_attach, &alps_tdmb7_config, &ttusb->i2c_adap);
1613                 if (ttusb->fe != NULL) {
1614                         ttusb->fe->ops.tuner_ops.set_params = alps_tdmb7_tuner_set_params;
1615                         break;
1616                 }
1617 
1618                 // Philips td1316
1619                 ttusb->fe = dvb_attach(tda10046_attach, &philips_tdm1316l_config, &ttusb->i2c_adap);
1620                 if (ttusb->fe != NULL) {
1621                         ttusb->fe->ops.tuner_ops.init = philips_tdm1316l_tuner_init;
1622                         ttusb->fe->ops.tuner_ops.set_params = philips_tdm1316l_tuner_set_params;
1623                         break;
1624                 }
1625                 break;
1626         }
1627 
1628         if (ttusb->fe == NULL) {
1629                 printk("dvb-ttusb-budget: A frontend driver was not found for device [%04x:%04x]\n",
1630                        le16_to_cpu(ttusb->dev->descriptor.idVendor),
1631                        le16_to_cpu(ttusb->dev->descriptor.idProduct));
1632         } else {
1633                 if (dvb_register_frontend(&ttusb->adapter, ttusb->fe)) {
1634                         printk("dvb-ttusb-budget: Frontend registration failed!\n");
1635                         dvb_frontend_detach(ttusb->fe);
1636                         ttusb->fe = NULL;
1637                 }
1638         }
1639 }
1640 
1641 
1642 
1643 static struct i2c_algorithm ttusb_dec_algo = {
1644         .master_xfer    = master_xfer,
1645         .functionality  = functionality,
1646 };
1647 
1648 static int ttusb_probe(struct usb_interface *intf, const struct usb_device_id *id)
1649 {
1650         struct usb_device *udev;
1651         struct ttusb *ttusb;
1652         int result;
1653 
1654         dprintk("%s: TTUSB DVB connected\n", __func__);
1655 
1656         udev = interface_to_usbdev(intf);
1657 
1658         if (intf->altsetting->desc.bInterfaceNumber != 1) return -ENODEV;
1659 
1660         if (!(ttusb = kzalloc(sizeof(struct ttusb), GFP_KERNEL)))
1661                 return -ENOMEM;
1662 
1663         ttusb->dev = udev;
1664         ttusb->c = 0;
1665         ttusb->mux_state = 0;
1666         mutex_init(&ttusb->semi2c);
1667 
1668         mutex_lock(&ttusb->semi2c);
1669 
1670         mutex_init(&ttusb->semusb);
1671 
1672         ttusb_setup_interfaces(ttusb);
1673 
1674         result = ttusb_alloc_iso_urbs(ttusb);
1675         if (result < 0) {
1676                 dprintk("%s: ttusb_alloc_iso_urbs - failed\n", __func__);
1677                 mutex_unlock(&ttusb->semi2c);
1678                 kfree(ttusb);
1679                 return result;
1680         }
1681 
1682         if (ttusb_init_controller(ttusb))
1683                 printk("ttusb_init_controller: error\n");
1684 
1685         mutex_unlock(&ttusb->semi2c);
1686 
1687         result = dvb_register_adapter(&ttusb->adapter,
1688                                       "Technotrend/Hauppauge Nova-USB",
1689                                       THIS_MODULE, &udev->dev, adapter_nr);
1690         if (result < 0) {
1691                 ttusb_free_iso_urbs(ttusb);
1692                 kfree(ttusb);
1693                 return result;
1694         }
1695         ttusb->adapter.priv = ttusb;
1696 
1697         /* i2c */
1698         memset(&ttusb->i2c_adap, 0, sizeof(struct i2c_adapter));
1699         strcpy(ttusb->i2c_adap.name, "TTUSB DEC");
1700 
1701         i2c_set_adapdata(&ttusb->i2c_adap, ttusb);
1702 
1703         ttusb->i2c_adap.algo              = &ttusb_dec_algo;
1704         ttusb->i2c_adap.algo_data         = NULL;
1705         ttusb->i2c_adap.dev.parent        = &udev->dev;
1706 
1707         result = i2c_add_adapter(&ttusb->i2c_adap);
1708         if (result)
1709                 goto err_unregister_adapter;
1710 
1711         memset(&ttusb->dvb_demux, 0, sizeof(ttusb->dvb_demux));
1712 
1713         ttusb->dvb_demux.dmx.capabilities =
1714             DMX_TS_FILTERING | DMX_SECTION_FILTERING;
1715         ttusb->dvb_demux.priv = NULL;
1716 #ifdef TTUSB_HWSECTIONS
1717         ttusb->dvb_demux.filternum = TTUSB_MAXFILTER;
1718 #else
1719         ttusb->dvb_demux.filternum = 32;
1720 #endif
1721         ttusb->dvb_demux.feednum = TTUSB_MAXCHANNEL;
1722         ttusb->dvb_demux.start_feed = ttusb_start_feed;
1723         ttusb->dvb_demux.stop_feed = ttusb_stop_feed;
1724         ttusb->dvb_demux.write_to_decoder = NULL;
1725 
1726         result = dvb_dmx_init(&ttusb->dvb_demux);
1727         if (result < 0) {
1728                 printk("ttusb_dvb: dvb_dmx_init failed (errno = %d)\n", result);
1729                 result = -ENODEV;
1730                 goto err_i2c_del_adapter;
1731         }
1732 //FIXME dmxdev (nur WAS?)
1733         ttusb->dmxdev.filternum = ttusb->dvb_demux.filternum;
1734         ttusb->dmxdev.demux = &ttusb->dvb_demux.dmx;
1735         ttusb->dmxdev.capabilities = 0;
1736 
1737         result = dvb_dmxdev_init(&ttusb->dmxdev, &ttusb->adapter);
1738         if (result < 0) {
1739                 printk("ttusb_dvb: dvb_dmxdev_init failed (errno = %d)\n",
1740                        result);
1741                 result = -ENODEV;
1742                 goto err_release_dmx;
1743         }
1744 
1745         if (dvb_net_init(&ttusb->adapter, &ttusb->dvbnet, &ttusb->dvb_demux.dmx)) {
1746                 printk("ttusb_dvb: dvb_net_init failed!\n");
1747                 result = -ENODEV;
1748                 goto err_release_dmxdev;
1749         }
1750 
1751         usb_set_intfdata(intf, (void *) ttusb);
1752 
1753         frontend_init(ttusb);
1754 
1755         return 0;
1756 
1757 err_release_dmxdev:
1758         dvb_dmxdev_release(&ttusb->dmxdev);
1759 err_release_dmx:
1760         dvb_dmx_release(&ttusb->dvb_demux);
1761 err_i2c_del_adapter:
1762         i2c_del_adapter(&ttusb->i2c_adap);
1763 err_unregister_adapter:
1764         dvb_unregister_adapter (&ttusb->adapter);
1765         ttusb_free_iso_urbs(ttusb);
1766         kfree(ttusb);
1767         return result;
1768 }
1769 
1770 static void ttusb_disconnect(struct usb_interface *intf)
1771 {
1772         struct ttusb *ttusb = usb_get_intfdata(intf);
1773 
1774         usb_set_intfdata(intf, NULL);
1775 
1776         ttusb->disconnecting = 1;
1777 
1778         ttusb_stop_iso_xfer(ttusb);
1779 
1780         ttusb->dvb_demux.dmx.close(&ttusb->dvb_demux.dmx);
1781         dvb_net_release(&ttusb->dvbnet);
1782         dvb_dmxdev_release(&ttusb->dmxdev);
1783         dvb_dmx_release(&ttusb->dvb_demux);
1784         if (ttusb->fe != NULL) {
1785                 dvb_unregister_frontend(ttusb->fe);
1786                 dvb_frontend_detach(ttusb->fe);
1787         }
1788         i2c_del_adapter(&ttusb->i2c_adap);
1789         dvb_unregister_adapter(&ttusb->adapter);
1790 
1791         ttusb_free_iso_urbs(ttusb);
1792 
1793         kfree(ttusb);
1794 
1795         dprintk("%s: TTUSB DVB disconnected\n", __func__);
1796 }
1797 
1798 static struct usb_device_id ttusb_table[] = {
1799         {USB_DEVICE(0xb48, 0x1003)},
1800         {USB_DEVICE(0xb48, 0x1004)},
1801         {USB_DEVICE(0xb48, 0x1005)},
1802         {}
1803 };
1804 
1805 MODULE_DEVICE_TABLE(usb, ttusb_table);
1806 
1807 static struct usb_driver ttusb_driver = {
1808       .name             = "ttusb",
1809       .probe            = ttusb_probe,
1810       .disconnect       = ttusb_disconnect,
1811       .id_table         = ttusb_table,
1812 };
1813 
1814 module_usb_driver(ttusb_driver);
1815 
1816 MODULE_AUTHOR("Holger Waechtler <holger@convergence.de>");
1817 MODULE_DESCRIPTION("TTUSB DVB Driver");
1818 MODULE_LICENSE("GPL");
1819 MODULE_FIRMWARE("ttusb-budget/dspbootcode.bin");
1820 

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