Merge branch 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab...
[linux-2.6.git] / drivers / media / dvb / 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] - '0') << 4) |
456                            (get_version[8] - '0');
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         for (i = 0; i < len; i += 2)
565                 csum ^= le16_to_cpup((__le16 *) (muxpack + i));
566         if (csum) {
567                 printk("%s: muxpack with incorrect checksum, ignoring\n",
568                        __func__);
569                 numinvalid++;
570                 return;
571         }
572
573         cc = (muxpack[len - 4] << 8) | muxpack[len - 3];
574         cc &= 0x7FFF;
575         if ((cc != ttusb->cc) && (ttusb->cc != -1))
576                 printk("%s: cc discontinuity (%d frames missing)\n",
577                        __func__, (cc - ttusb->cc) & 0x7FFF);
578         ttusb->cc = (cc + 1) & 0x7FFF;
579         if (muxpack[0] & 0x80) {
580 #ifdef TTUSB_HWSECTIONS
581                 /* section data */
582                 int pusi = muxpack[0] & 0x40;
583                 int channel = muxpack[0] & 0x1F;
584                 int payload = muxpack[1];
585                 const u8 *data = muxpack + 2;
586                 /* check offset flag */
587                 if (muxpack[0] & 0x20)
588                         data++;
589
590                 ttusb_handle_sec_data(ttusb->channel + channel, data,
591                                       payload);
592                 data += payload;
593
594                 if ((!!(ttusb->muxpack[0] & 0x20)) ^
595                     !!(ttusb->muxpack[1] & 1))
596                         data++;
597 #warning TODO: pusi
598                 printk("cc: %04x\n", (data[0] << 8) | data[1]);
599 #endif
600                 numsec++;
601         } else if (muxpack[0] == 0x47) {
602 #ifdef TTUSB_HWSECTIONS
603                 /* we have TS data here! */
604                 int pid = ((muxpack[1] & 0x0F) << 8) | muxpack[2];
605                 int channel;
606                 for (channel = 0; channel < TTUSB_MAXCHANNEL; ++channel)
607                         if (ttusb->channel[channel].active
608                             && (pid == ttusb->channel[channel].pid))
609                                 ttusb_handle_ts_data(ttusb->channel +
610                                                      channel, muxpack,
611                                                      188);
612 #endif
613                 numts++;
614                 dvb_dmx_swfilter_packets(&ttusb->dvb_demux, muxpack, 1);
615         } else if (muxpack[0] != 0) {
616                 numinvalid++;
617                 printk("illegal muxpack type %02x\n", muxpack[0]);
618         } else
619                 numstuff++;
620 }
621
622 static void ttusb_process_frame(struct ttusb *ttusb, u8 * data, int len)
623 {
624         int maxwork = 1024;
625         while (len) {
626                 if (!(maxwork--)) {
627                         printk("%s: too much work\n", __func__);
628                         break;
629                 }
630
631                 switch (ttusb->mux_state) {
632                 case 0:
633                 case 1:
634                 case 2:
635                         len--;
636                         if (*data++ == 0xAA)
637                                 ++ttusb->mux_state;
638                         else {
639                                 ttusb->mux_state = 0;
640                                 if (ttusb->insync) {
641                                         dprintk("%s: %02x\n",
642                                                 __func__, data[-1]);
643                                         printk(KERN_INFO "%s: lost sync.\n",
644                                                __func__);
645                                         ttusb->insync = 0;
646                                 }
647                         }
648                         break;
649                 case 3:
650                         ttusb->insync = 1;
651                         len--;
652                         ttusb->mux_npacks = *data++;
653                         ++ttusb->mux_state;
654                         ttusb->muxpack_ptr = 0;
655                         /* maximum bytes, until we know the length */
656                         ttusb->muxpack_len = 2;
657                         break;
658                 case 4:
659                         {
660                                 int avail;
661                                 avail = len;
662                                 if (avail >
663                                     (ttusb->muxpack_len -
664                                      ttusb->muxpack_ptr))
665                                         avail =
666                                             ttusb->muxpack_len -
667                                             ttusb->muxpack_ptr;
668                                 memcpy(ttusb->muxpack + ttusb->muxpack_ptr,
669                                        data, avail);
670                                 ttusb->muxpack_ptr += avail;
671                                 BUG_ON(ttusb->muxpack_ptr > 264);
672                                 data += avail;
673                                 len -= avail;
674                                 /* determine length */
675                                 if (ttusb->muxpack_ptr == 2) {
676                                         if (ttusb->muxpack[0] & 0x80) {
677                                                 ttusb->muxpack_len =
678                                                     ttusb->muxpack[1] + 2;
679                                                 if (ttusb->
680                                                     muxpack[0] & 0x20)
681                                                         ttusb->
682                                                             muxpack_len++;
683                                                 if ((!!
684                                                      (ttusb->
685                                                       muxpack[0] & 0x20)) ^
686                                                     !!(ttusb->
687                                                        muxpack[1] & 1))
688                                                         ttusb->
689                                                             muxpack_len++;
690                                                 ttusb->muxpack_len += 4;
691                                         } else if (ttusb->muxpack[0] ==
692                                                    0x47)
693                                                 ttusb->muxpack_len =
694                                                     188 + 4;
695                                         else if (ttusb->muxpack[0] == 0x00)
696                                                 ttusb->muxpack_len =
697                                                     ttusb->muxpack[1] + 2 +
698                                                     4;
699                                         else {
700                                                 dprintk
701                                                     ("%s: invalid state: first byte is %x\n",
702                                                      __func__,
703                                                      ttusb->muxpack[0]);
704                                                 ttusb->mux_state = 0;
705                                         }
706                                 }
707
708                         /**
709                          * if length is valid and we reached the end:
710                          * goto next muxpack
711                          */
712                                 if ((ttusb->muxpack_ptr >= 2) &&
713                                     (ttusb->muxpack_ptr ==
714                                      ttusb->muxpack_len)) {
715                                         ttusb_process_muxpack(ttusb,
716                                                               ttusb->
717                                                               muxpack,
718                                                               ttusb->
719                                                               muxpack_ptr);
720                                         ttusb->muxpack_ptr = 0;
721                                         /* maximum bytes, until we know the length */
722                                         ttusb->muxpack_len = 2;
723
724                                 /**
725                                  * no muxpacks left?
726                                  * return to search-sync state
727                                  */
728                                         if (!ttusb->mux_npacks--) {
729                                                 ttusb->mux_state = 0;
730                                                 break;
731                                         }
732                                 }
733                                 break;
734                         }
735                 default:
736                         BUG();
737                         break;
738                 }
739         }
740 }
741
742 static void ttusb_iso_irq(struct urb *urb)
743 {
744         struct ttusb *ttusb = urb->context;
745         struct usb_iso_packet_descriptor *d;
746         u8 *data;
747         int len, i;
748
749         if (!ttusb->iso_streaming)
750                 return;
751
752 #if 0
753         printk("%s: status %d, errcount == %d, length == %i\n",
754                __func__,
755                urb->status, urb->error_count, urb->actual_length);
756 #endif
757
758         if (!urb->status) {
759                 for (i = 0; i < urb->number_of_packets; ++i) {
760                         numpkt++;
761                         if (time_after_eq(jiffies, lastj + HZ)) {
762                                 dprintk("frames/s: %lu (ts: %d, stuff %d, "
763                                         "sec: %d, invalid: %d, all: %d)\n",
764                                         numpkt * HZ / (jiffies - lastj),
765                                         numts, numstuff, numsec, numinvalid,
766                                         numts + numstuff + numsec + numinvalid);
767                                 numts = numstuff = numsec = numinvalid = 0;
768                                 lastj = jiffies;
769                                 numpkt = 0;
770                         }
771                         d = &urb->iso_frame_desc[i];
772                         data = urb->transfer_buffer + d->offset;
773                         len = d->actual_length;
774                         d->actual_length = 0;
775                         d->status = 0;
776                         ttusb_process_frame(ttusb, data, len);
777                 }
778         }
779         usb_submit_urb(urb, GFP_ATOMIC);
780 }
781
782 static void ttusb_free_iso_urbs(struct ttusb *ttusb)
783 {
784         int i;
785
786         for (i = 0; i < ISO_BUF_COUNT; i++)
787                 if (ttusb->iso_urb[i])
788                         usb_free_urb(ttusb->iso_urb[i]);
789
790         pci_free_consistent(NULL,
791                             ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF *
792                             ISO_BUF_COUNT, ttusb->iso_buffer,
793                             ttusb->iso_dma_handle);
794 }
795
796 static int ttusb_alloc_iso_urbs(struct ttusb *ttusb)
797 {
798         int i;
799
800         ttusb->iso_buffer = pci_alloc_consistent(NULL,
801                                                  ISO_FRAME_SIZE *
802                                                  FRAMES_PER_ISO_BUF *
803                                                  ISO_BUF_COUNT,
804                                                  &ttusb->iso_dma_handle);
805
806         if (!ttusb->iso_buffer) {
807                 dprintk("%s: pci_alloc_consistent - not enough memory\n",
808                         __func__);
809                 return -ENOMEM;
810         }
811
812         memset(ttusb->iso_buffer, 0,
813                ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF * ISO_BUF_COUNT);
814
815         for (i = 0; i < ISO_BUF_COUNT; i++) {
816                 struct urb *urb;
817
818                 if (!
819                     (urb =
820                      usb_alloc_urb(FRAMES_PER_ISO_BUF, GFP_ATOMIC))) {
821                         ttusb_free_iso_urbs(ttusb);
822                         return -ENOMEM;
823                 }
824
825                 ttusb->iso_urb[i] = urb;
826         }
827
828         return 0;
829 }
830
831 static void ttusb_stop_iso_xfer(struct ttusb *ttusb)
832 {
833         int i;
834
835         for (i = 0; i < ISO_BUF_COUNT; i++)
836                 usb_kill_urb(ttusb->iso_urb[i]);
837
838         ttusb->iso_streaming = 0;
839 }
840
841 static int ttusb_start_iso_xfer(struct ttusb *ttusb)
842 {
843         int i, j, err, buffer_offset = 0;
844
845         if (ttusb->iso_streaming) {
846                 printk("%s: iso xfer already running!\n", __func__);
847                 return 0;
848         }
849
850         ttusb->cc = -1;
851         ttusb->insync = 0;
852         ttusb->mux_state = 0;
853
854         for (i = 0; i < ISO_BUF_COUNT; i++) {
855                 int frame_offset = 0;
856                 struct urb *urb = ttusb->iso_urb[i];
857
858                 urb->dev = ttusb->dev;
859                 urb->context = ttusb;
860                 urb->complete = ttusb_iso_irq;
861                 urb->pipe = ttusb->isoc_in_pipe;
862                 urb->transfer_flags = URB_ISO_ASAP;
863                 urb->interval = 1;
864                 urb->number_of_packets = FRAMES_PER_ISO_BUF;
865                 urb->transfer_buffer_length =
866                     ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF;
867                 urb->transfer_buffer = ttusb->iso_buffer + buffer_offset;
868                 buffer_offset += ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF;
869
870                 for (j = 0; j < FRAMES_PER_ISO_BUF; j++) {
871                         urb->iso_frame_desc[j].offset = frame_offset;
872                         urb->iso_frame_desc[j].length = ISO_FRAME_SIZE;
873                         frame_offset += ISO_FRAME_SIZE;
874                 }
875         }
876
877         for (i = 0; i < ISO_BUF_COUNT; i++) {
878                 if ((err = usb_submit_urb(ttusb->iso_urb[i], GFP_ATOMIC))) {
879                         ttusb_stop_iso_xfer(ttusb);
880                         printk
881                             ("%s: failed urb submission (%i: err = %i)!\n",
882                              __func__, i, err);
883                         return err;
884                 }
885         }
886
887         ttusb->iso_streaming = 1;
888
889         return 0;
890 }
891
892 #ifdef TTUSB_HWSECTIONS
893 static void ttusb_handle_ts_data(struct dvb_demux_feed *dvbdmxfeed, const u8 * data,
894                           int len)
895 {
896         dvbdmxfeed->cb.ts(data, len, 0, 0, &dvbdmxfeed->feed.ts, 0);
897 }
898
899 static void ttusb_handle_sec_data(struct dvb_demux_feed *dvbdmxfeed, const u8 * data,
900                            int len)
901 {
902 //      struct dvb_demux_feed *dvbdmxfeed = channel->dvbdmxfeed;
903 #error TODO: handle ugly stuff
904 //      dvbdmxfeed->cb.sec(data, len, 0, 0, &dvbdmxfeed->feed.sec, 0);
905 }
906 #endif
907
908 static int ttusb_start_feed(struct dvb_demux_feed *dvbdmxfeed)
909 {
910         struct ttusb *ttusb = (struct ttusb *) dvbdmxfeed->demux;
911         int feed_type = 1;
912
913         dprintk("ttusb_start_feed\n");
914
915         switch (dvbdmxfeed->type) {
916         case DMX_TYPE_TS:
917                 break;
918         case DMX_TYPE_SEC:
919                 break;
920         default:
921                 return -EINVAL;
922         }
923
924         if (dvbdmxfeed->type == DMX_TYPE_TS) {
925                 switch (dvbdmxfeed->pes_type) {
926                 case DMX_TS_PES_VIDEO:
927                 case DMX_TS_PES_AUDIO:
928                 case DMX_TS_PES_TELETEXT:
929                 case DMX_TS_PES_PCR:
930                 case DMX_TS_PES_OTHER:
931                         break;
932                 default:
933                         return -EINVAL;
934                 }
935         }
936
937 #ifdef TTUSB_HWSECTIONS
938 #error TODO: allocate filters
939         if (dvbdmxfeed->type == DMX_TYPE_TS) {
940                 feed_type = 1;
941         } else if (dvbdmxfeed->type == DMX_TYPE_SEC) {
942                 feed_type = 2;
943         }
944 #endif
945
946         ttusb_set_channel(ttusb, dvbdmxfeed->index, feed_type, dvbdmxfeed->pid);
947
948         if (0 == ttusb->running_feed_count++)
949                 ttusb_start_iso_xfer(ttusb);
950
951         return 0;
952 }
953
954 static int ttusb_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
955 {
956         struct ttusb *ttusb = (struct ttusb *) dvbdmxfeed->demux;
957
958         ttusb_del_channel(ttusb, dvbdmxfeed->index);
959
960         if (--ttusb->running_feed_count == 0)
961                 ttusb_stop_iso_xfer(ttusb);
962
963         return 0;
964 }
965
966 static int ttusb_setup_interfaces(struct ttusb *ttusb)
967 {
968         usb_set_interface(ttusb->dev, 1, 1);
969
970         ttusb->bulk_out_pipe = usb_sndbulkpipe(ttusb->dev, 1);
971         ttusb->bulk_in_pipe = usb_rcvbulkpipe(ttusb->dev, 1);
972         ttusb->isoc_in_pipe = usb_rcvisocpipe(ttusb->dev, 2);
973
974         return 0;
975 }
976
977 #if 0
978 static u8 stc_firmware[8192];
979
980 static int stc_open(struct inode *inode, struct file *file)
981 {
982         struct ttusb *ttusb = file->private_data;
983         int addr;
984
985         for (addr = 0; addr < 8192; addr += 16) {
986                 u8 snd_buf[2] = { addr >> 8, addr & 0xFF };
987                 ttusb_i2c_msg(ttusb, 0x50, snd_buf, 2, stc_firmware + addr,
988                               16);
989         }
990
991         return 0;
992 }
993
994 static ssize_t stc_read(struct file *file, char *buf, size_t count,
995                  loff_t *offset)
996 {
997         return simple_read_from_buffer(buf, count, offset, stc_firmware, 8192);
998 }
999
1000 static int stc_release(struct inode *inode, struct file *file)
1001 {
1002         return 0;
1003 }
1004
1005 static const struct file_operations stc_fops = {
1006         .owner = THIS_MODULE,
1007         .read = stc_read,
1008         .open = stc_open,
1009         .release = stc_release,
1010 };
1011 #endif
1012
1013 static u32 functionality(struct i2c_adapter *adapter)
1014 {
1015         return I2C_FUNC_I2C;
1016 }
1017
1018
1019
1020 static int alps_tdmb7_tuner_set_params(struct dvb_frontend *fe)
1021 {
1022         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1023         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1024         u8 data[4];
1025         struct i2c_msg msg = {.addr=0x61, .flags=0, .buf=data, .len=sizeof(data) };
1026         u32 div;
1027
1028         div = (p->frequency + 36166667) / 166667;
1029
1030         data[0] = (div >> 8) & 0x7f;
1031         data[1] = div & 0xff;
1032         data[2] = ((div >> 10) & 0x60) | 0x85;
1033         data[3] = p->frequency < 592000000 ? 0x40 : 0x80;
1034
1035         if (fe->ops.i2c_gate_ctrl)
1036                 fe->ops.i2c_gate_ctrl(fe, 1);
1037         if (i2c_transfer(&ttusb->i2c_adap, &msg, 1) != 1) return -EIO;
1038         return 0;
1039 }
1040
1041 static struct cx22700_config alps_tdmb7_config = {
1042         .demod_address = 0x43,
1043 };
1044
1045
1046
1047
1048
1049 static int philips_tdm1316l_tuner_init(struct dvb_frontend* fe)
1050 {
1051         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1052         static u8 td1316_init[] = { 0x0b, 0xf5, 0x85, 0xab };
1053         static u8 disable_mc44BC374c[] = { 0x1d, 0x74, 0xa0, 0x68 };
1054         struct i2c_msg tuner_msg = { .addr=0x60, .flags=0, .buf=td1316_init, .len=sizeof(td1316_init) };
1055
1056         // setup PLL configuration
1057         if (fe->ops.i2c_gate_ctrl)
1058                 fe->ops.i2c_gate_ctrl(fe, 1);
1059         if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) return -EIO;
1060         msleep(1);
1061
1062         // disable the mc44BC374c (do not check for errors)
1063         tuner_msg.addr = 0x65;
1064         tuner_msg.buf = disable_mc44BC374c;
1065         tuner_msg.len = sizeof(disable_mc44BC374c);
1066         if (fe->ops.i2c_gate_ctrl)
1067                 fe->ops.i2c_gate_ctrl(fe, 1);
1068         if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) {
1069                 i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1);
1070         }
1071
1072         return 0;
1073 }
1074
1075 static int philips_tdm1316l_tuner_set_params(struct dvb_frontend *fe)
1076 {
1077         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1078         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1079         u8 tuner_buf[4];
1080         struct i2c_msg tuner_msg = {.addr=0x60, .flags=0, .buf=tuner_buf, .len=sizeof(tuner_buf) };
1081         int tuner_frequency = 0;
1082         u8 band, cp, filter;
1083
1084         // determine charge pump
1085         tuner_frequency = p->frequency + 36130000;
1086         if (tuner_frequency < 87000000) return -EINVAL;
1087         else if (tuner_frequency < 130000000) cp = 3;
1088         else if (tuner_frequency < 160000000) cp = 5;
1089         else if (tuner_frequency < 200000000) cp = 6;
1090         else if (tuner_frequency < 290000000) cp = 3;
1091         else if (tuner_frequency < 420000000) cp = 5;
1092         else if (tuner_frequency < 480000000) cp = 6;
1093         else if (tuner_frequency < 620000000) cp = 3;
1094         else if (tuner_frequency < 830000000) cp = 5;
1095         else if (tuner_frequency < 895000000) cp = 7;
1096         else return -EINVAL;
1097
1098         // determine band
1099         if (p->frequency < 49000000)
1100                 return -EINVAL;
1101         else if (p->frequency < 159000000)
1102                 band = 1;
1103         else if (p->frequency < 444000000)
1104                 band = 2;
1105         else if (p->frequency < 861000000)
1106                 band = 4;
1107         else return -EINVAL;
1108
1109         // setup PLL filter
1110         switch (p->bandwidth_hz) {
1111         case 6000000:
1112                 tda1004x_writereg(fe, 0x0C, 0);
1113                 filter = 0;
1114                 break;
1115
1116         case 7000000:
1117                 tda1004x_writereg(fe, 0x0C, 0);
1118                 filter = 0;
1119                 break;
1120
1121         case 8000000:
1122                 tda1004x_writereg(fe, 0x0C, 0xFF);
1123                 filter = 1;
1124                 break;
1125
1126         default:
1127                 return -EINVAL;
1128         }
1129
1130         // calculate divisor
1131         // ((36130000+((1000000/6)/2)) + Finput)/(1000000/6)
1132         tuner_frequency = (((p->frequency / 1000) * 6) + 217280) / 1000;
1133
1134         // setup tuner buffer
1135         tuner_buf[0] = tuner_frequency >> 8;
1136         tuner_buf[1] = tuner_frequency & 0xff;
1137         tuner_buf[2] = 0xca;
1138         tuner_buf[3] = (cp << 5) | (filter << 3) | band;
1139
1140         if (fe->ops.i2c_gate_ctrl)
1141                 fe->ops.i2c_gate_ctrl(fe, 1);
1142         if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1)
1143                 return -EIO;
1144
1145         msleep(1);
1146         return 0;
1147 }
1148
1149 static int philips_tdm1316l_request_firmware(struct dvb_frontend* fe, const struct firmware **fw, char* name)
1150 {
1151         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1152
1153         return request_firmware(fw, name, &ttusb->dev->dev);
1154 }
1155
1156 static struct tda1004x_config philips_tdm1316l_config = {
1157
1158         .demod_address = 0x8,
1159         .invert = 1,
1160         .invert_oclk = 0,
1161         .request_firmware = philips_tdm1316l_request_firmware,
1162 };
1163
1164 static u8 alps_bsbe1_inittab[] = {
1165         0x01, 0x15,
1166         0x02, 0x30,
1167         0x03, 0x00,
1168         0x04, 0x7d,             /* F22FR = 0x7d, F22 = f_VCO / 128 / 0x7d = 22 kHz */
1169         0x05, 0x35,             /* I2CT = 0, SCLT = 1, SDAT = 1 */
1170         0x06, 0x40,             /* DAC not used, set to high impendance mode */
1171         0x07, 0x00,             /* DAC LSB */
1172         0x08, 0x40,             /* DiSEqC off, LNB power on OP2/LOCK pin on */
1173         0x09, 0x00,             /* FIFO */
1174         0x0c, 0x51,             /* OP1 ctl = Normal, OP1 val = 1 (LNB Power ON) */
1175         0x0d, 0x82,             /* DC offset compensation = ON, beta_agc1 = 2 */
1176         0x0e, 0x23,             /* alpha_tmg = 2, beta_tmg = 3 */
1177         0x10, 0x3f,             // AGC2  0x3d
1178         0x11, 0x84,
1179         0x12, 0xb9,
1180         0x15, 0xc9,             // lock detector threshold
1181         0x16, 0x00,
1182         0x17, 0x00,
1183         0x18, 0x00,
1184         0x19, 0x00,
1185         0x1a, 0x00,
1186         0x1f, 0x50,
1187         0x20, 0x00,
1188         0x21, 0x00,
1189         0x22, 0x00,
1190         0x23, 0x00,
1191         0x28, 0x00,             // out imp: normal  out type: parallel FEC mode:0
1192         0x29, 0x1e,             // 1/2 threshold
1193         0x2a, 0x14,             // 2/3 threshold
1194         0x2b, 0x0f,             // 3/4 threshold
1195         0x2c, 0x09,             // 5/6 threshold
1196         0x2d, 0x05,             // 7/8 threshold
1197         0x2e, 0x01,
1198         0x31, 0x1f,             // test all FECs
1199         0x32, 0x19,             // viterbi and synchro search
1200         0x33, 0xfc,             // rs control
1201         0x34, 0x93,             // error control
1202         0x0f, 0x92,
1203         0xff, 0xff
1204 };
1205
1206 static u8 alps_bsru6_inittab[] = {
1207         0x01, 0x15,
1208         0x02, 0x30,
1209         0x03, 0x00,
1210         0x04, 0x7d,             /* F22FR = 0x7d, F22 = f_VCO / 128 / 0x7d = 22 kHz */
1211         0x05, 0x35,             /* I2CT = 0, SCLT = 1, SDAT = 1 */
1212         0x06, 0x40,             /* DAC not used, set to high impendance mode */
1213         0x07, 0x00,             /* DAC LSB */
1214         0x08, 0x40,             /* DiSEqC off, LNB power on OP2/LOCK pin on */
1215         0x09, 0x00,             /* FIFO */
1216         0x0c, 0x51,             /* OP1 ctl = Normal, OP1 val = 1 (LNB Power ON) */
1217         0x0d, 0x82,             /* DC offset compensation = ON, beta_agc1 = 2 */
1218         0x0e, 0x23,             /* alpha_tmg = 2, beta_tmg = 3 */
1219         0x10, 0x3f,             // AGC2  0x3d
1220         0x11, 0x84,
1221         0x12, 0xb9,
1222         0x15, 0xc9,             // lock detector threshold
1223         0x16, 0x00,
1224         0x17, 0x00,
1225         0x18, 0x00,
1226         0x19, 0x00,
1227         0x1a, 0x00,
1228         0x1f, 0x50,
1229         0x20, 0x00,
1230         0x21, 0x00,
1231         0x22, 0x00,
1232         0x23, 0x00,
1233         0x28, 0x00,             // out imp: normal  out type: parallel FEC mode:0
1234         0x29, 0x1e,             // 1/2 threshold
1235         0x2a, 0x14,             // 2/3 threshold
1236         0x2b, 0x0f,             // 3/4 threshold
1237         0x2c, 0x09,             // 5/6 threshold
1238         0x2d, 0x05,             // 7/8 threshold
1239         0x2e, 0x01,
1240         0x31, 0x1f,             // test all FECs
1241         0x32, 0x19,             // viterbi and synchro search
1242         0x33, 0xfc,             // rs control
1243         0x34, 0x93,             // error control
1244         0x0f, 0x52,
1245         0xff, 0xff
1246 };
1247
1248 static int alps_stv0299_set_symbol_rate(struct dvb_frontend *fe, u32 srate, u32 ratio)
1249 {
1250         u8 aclk = 0;
1251         u8 bclk = 0;
1252
1253         if (srate < 1500000) {
1254                 aclk = 0xb7;
1255                 bclk = 0x47;
1256         } else if (srate < 3000000) {
1257                 aclk = 0xb7;
1258                 bclk = 0x4b;
1259         } else if (srate < 7000000) {
1260                 aclk = 0xb7;
1261                 bclk = 0x4f;
1262         } else if (srate < 14000000) {
1263                 aclk = 0xb7;
1264                 bclk = 0x53;
1265         } else if (srate < 30000000) {
1266                 aclk = 0xb6;
1267                 bclk = 0x53;
1268         } else if (srate < 45000000) {
1269                 aclk = 0xb4;
1270                 bclk = 0x51;
1271         }
1272
1273         stv0299_writereg(fe, 0x13, aclk);
1274         stv0299_writereg(fe, 0x14, bclk);
1275         stv0299_writereg(fe, 0x1f, (ratio >> 16) & 0xff);
1276         stv0299_writereg(fe, 0x20, (ratio >> 8) & 0xff);
1277         stv0299_writereg(fe, 0x21, (ratio) & 0xf0);
1278
1279         return 0;
1280 }
1281
1282 static int philips_tsa5059_tuner_set_params(struct dvb_frontend *fe)
1283 {
1284         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1285         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1286         u8 buf[4];
1287         u32 div;
1288         struct i2c_msg msg = {.addr = 0x61,.flags = 0,.buf = buf,.len = sizeof(buf) };
1289
1290         if ((p->frequency < 950000) || (p->frequency > 2150000))
1291                 return -EINVAL;
1292
1293         div = (p->frequency + (125 - 1)) / 125; /* round correctly */
1294         buf[0] = (div >> 8) & 0x7f;
1295         buf[1] = div & 0xff;
1296         buf[2] = 0x80 | ((div & 0x18000) >> 10) | 4;
1297         buf[3] = 0xC4;
1298
1299         if (p->frequency > 1530000)
1300                 buf[3] = 0xC0;
1301
1302         /* BSBE1 wants XCE bit set */
1303         if (ttusb->revision == TTUSB_REV_2_2)
1304                 buf[3] |= 0x20;
1305
1306         if (fe->ops.i2c_gate_ctrl)
1307                 fe->ops.i2c_gate_ctrl(fe, 1);
1308         if (i2c_transfer(&ttusb->i2c_adap, &msg, 1) != 1)
1309                 return -EIO;
1310
1311         return 0;
1312 }
1313
1314 static struct stv0299_config alps_stv0299_config = {
1315         .demod_address = 0x68,
1316         .inittab = alps_bsru6_inittab,
1317         .mclk = 88000000UL,
1318         .invert = 1,
1319         .skip_reinit = 0,
1320         .lock_output = STV0299_LOCKOUTPUT_1,
1321         .volt13_op0_op1 = STV0299_VOLT13_OP1,
1322         .min_delay_ms = 100,
1323         .set_symbol_rate = alps_stv0299_set_symbol_rate,
1324 };
1325
1326 static int ttusb_novas_grundig_29504_491_tuner_set_params(struct dvb_frontend *fe)
1327 {
1328         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1329         struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1330         u8 buf[4];
1331         u32 div;
1332         struct i2c_msg msg = {.addr = 0x61,.flags = 0,.buf = buf,.len = sizeof(buf) };
1333
1334         div = p->frequency / 125;
1335
1336         buf[0] = (div >> 8) & 0x7f;
1337         buf[1] = div & 0xff;
1338         buf[2] = 0x8e;
1339         buf[3] = 0x00;
1340
1341         if (fe->ops.i2c_gate_ctrl)
1342                 fe->ops.i2c_gate_ctrl(fe, 1);
1343         if (i2c_transfer(&ttusb->i2c_adap, &msg, 1) != 1)
1344                 return -EIO;
1345
1346         return 0;
1347 }
1348
1349 static struct tda8083_config ttusb_novas_grundig_29504_491_config = {
1350
1351         .demod_address = 0x68,
1352 };
1353
1354 static int alps_tdbe2_tuner_set_params(struct dvb_frontend *fe)
1355 {
1356         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1357         struct ttusb* ttusb = fe->dvb->priv;
1358         u32 div;
1359         u8 data[4];
1360         struct i2c_msg msg = { .addr = 0x62, .flags = 0, .buf = data, .len = sizeof(data) };
1361
1362         div = (p->frequency + 35937500 + 31250) / 62500;
1363
1364         data[0] = (div >> 8) & 0x7f;
1365         data[1] = div & 0xff;
1366         data[2] = 0x85 | ((div >> 10) & 0x60);
1367         data[3] = (p->frequency < 174000000 ? 0x88 : p->frequency < 470000000 ? 0x84 : 0x81);
1368
1369         if (fe->ops.i2c_gate_ctrl)
1370                 fe->ops.i2c_gate_ctrl(fe, 1);
1371         if (i2c_transfer (&ttusb->i2c_adap, &msg, 1) != 1)
1372                 return -EIO;
1373
1374         return 0;
1375 }
1376
1377
1378 static struct ves1820_config alps_tdbe2_config = {
1379         .demod_address = 0x09,
1380         .xin = 57840000UL,
1381         .invert = 1,
1382         .selagc = VES1820_SELAGC_SIGNAMPERR,
1383 };
1384
1385 static u8 read_pwm(struct ttusb* ttusb)
1386 {
1387         u8 b = 0xff;
1388         u8 pwm;
1389         struct i2c_msg msg[] = { { .addr = 0x50,.flags = 0,.buf = &b,.len = 1 },
1390                                 { .addr = 0x50,.flags = I2C_M_RD,.buf = &pwm,.len = 1} };
1391
1392         if ((i2c_transfer(&ttusb->i2c_adap, msg, 2) != 2) || (pwm == 0xff))
1393                 pwm = 0x48;
1394
1395         return pwm;
1396 }
1397
1398
1399 static int dvbc_philips_tdm1316l_tuner_set_params(struct dvb_frontend *fe)
1400 {
1401         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1402         struct ttusb *ttusb = (struct ttusb *) fe->dvb->priv;
1403         u8 tuner_buf[5];
1404         struct i2c_msg tuner_msg = {.addr = 0x60,
1405                                     .flags = 0,
1406                                     .buf = tuner_buf,
1407                                     .len = sizeof(tuner_buf) };
1408         int tuner_frequency = 0;
1409         u8 band, cp, filter;
1410
1411         // determine charge pump
1412         tuner_frequency = p->frequency;
1413         if      (tuner_frequency <  87000000) {return -EINVAL;}
1414         else if (tuner_frequency < 130000000) {cp = 3; band = 1;}
1415         else if (tuner_frequency < 160000000) {cp = 5; band = 1;}
1416         else if (tuner_frequency < 200000000) {cp = 6; band = 1;}
1417         else if (tuner_frequency < 290000000) {cp = 3; band = 2;}
1418         else if (tuner_frequency < 420000000) {cp = 5; band = 2;}
1419         else if (tuner_frequency < 480000000) {cp = 6; band = 2;}
1420         else if (tuner_frequency < 620000000) {cp = 3; band = 4;}
1421         else if (tuner_frequency < 830000000) {cp = 5; band = 4;}
1422         else if (tuner_frequency < 895000000) {cp = 7; band = 4;}
1423         else {return -EINVAL;}
1424
1425         // assume PLL filter should always be 8MHz for the moment.
1426         filter = 1;
1427
1428         // calculate divisor
1429         // (Finput + Fif)/Fref; Fif = 36125000 Hz, Fref = 62500 Hz
1430         tuner_frequency = ((p->frequency + 36125000) / 62500);
1431
1432         // setup tuner buffer
1433         tuner_buf[0] = tuner_frequency >> 8;
1434         tuner_buf[1] = tuner_frequency & 0xff;
1435         tuner_buf[2] = 0xc8;
1436         tuner_buf[3] = (cp << 5) | (filter << 3) | band;
1437         tuner_buf[4] = 0x80;
1438
1439         if (fe->ops.i2c_gate_ctrl)
1440                 fe->ops.i2c_gate_ctrl(fe, 1);
1441         if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) {
1442                 printk("dvb-ttusb-budget: dvbc_philips_tdm1316l_pll_set Error 1\n");
1443                 return -EIO;
1444         }
1445
1446         msleep(50);
1447
1448         if (fe->ops.i2c_gate_ctrl)
1449                 fe->ops.i2c_gate_ctrl(fe, 1);
1450         if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) {
1451                 printk("dvb-ttusb-budget: dvbc_philips_tdm1316l_pll_set Error 2\n");
1452                 return -EIO;
1453         }
1454
1455         msleep(1);
1456
1457         return 0;
1458 }
1459
1460 static u8 dvbc_philips_tdm1316l_inittab[] = {
1461         0x80, 0x21,
1462         0x80, 0x20,
1463         0x81, 0x01,
1464         0x81, 0x00,
1465         0x00, 0x09,
1466         0x01, 0x69,
1467         0x03, 0x00,
1468         0x04, 0x00,
1469         0x07, 0x00,
1470         0x08, 0x00,
1471         0x20, 0x00,
1472         0x21, 0x40,
1473         0x22, 0x00,
1474         0x23, 0x00,
1475         0x24, 0x40,
1476         0x25, 0x88,
1477         0x30, 0xff,
1478         0x31, 0x00,
1479         0x32, 0xff,
1480         0x33, 0x00,
1481         0x34, 0x50,
1482         0x35, 0x7f,
1483         0x36, 0x00,
1484         0x37, 0x20,
1485         0x38, 0x00,
1486         0x40, 0x1c,
1487         0x41, 0xff,
1488         0x42, 0x29,
1489         0x43, 0x20,
1490         0x44, 0xff,
1491         0x45, 0x00,
1492         0x46, 0x00,
1493         0x49, 0x04,
1494         0x4a, 0xff,
1495         0x4b, 0x7f,
1496         0x52, 0x30,
1497         0x55, 0xae,
1498         0x56, 0x47,
1499         0x57, 0xe1,
1500         0x58, 0x3a,
1501         0x5a, 0x1e,
1502         0x5b, 0x34,
1503         0x60, 0x00,
1504         0x63, 0x00,
1505         0x64, 0x00,
1506         0x65, 0x00,
1507         0x66, 0x00,
1508         0x67, 0x00,
1509         0x68, 0x00,
1510         0x69, 0x00,
1511         0x6a, 0x02,
1512         0x6b, 0x00,
1513         0x70, 0xff,
1514         0x71, 0x00,
1515         0x72, 0x00,
1516         0x73, 0x00,
1517         0x74, 0x0c,
1518         0x80, 0x00,
1519         0x81, 0x00,
1520         0x82, 0x00,
1521         0x83, 0x00,
1522         0x84, 0x04,
1523         0x85, 0x80,
1524         0x86, 0x24,
1525         0x87, 0x78,
1526         0x88, 0x00,
1527         0x89, 0x00,
1528         0x90, 0x01,
1529         0x91, 0x01,
1530         0xa0, 0x00,
1531         0xa1, 0x00,
1532         0xa2, 0x00,
1533         0xb0, 0x91,
1534         0xb1, 0x0b,
1535         0xc0, 0x4b,
1536         0xc1, 0x00,
1537         0xc2, 0x00,
1538         0xd0, 0x00,
1539         0xd1, 0x00,
1540         0xd2, 0x00,
1541         0xd3, 0x00,
1542         0xd4, 0x00,
1543         0xd5, 0x00,
1544         0xde, 0x00,
1545         0xdf, 0x00,
1546         0x61, 0x38,
1547         0x62, 0x0a,
1548         0x53, 0x13,
1549         0x59, 0x08,
1550         0x55, 0x00,
1551         0x56, 0x40,
1552         0x57, 0x08,
1553         0x58, 0x3d,
1554         0x88, 0x10,
1555         0xa0, 0x00,
1556         0xa0, 0x00,
1557         0xa0, 0x00,
1558         0xa0, 0x04,
1559         0xff, 0xff,
1560 };
1561
1562 static struct stv0297_config dvbc_philips_tdm1316l_config = {
1563         .demod_address = 0x1c,
1564         .inittab = dvbc_philips_tdm1316l_inittab,
1565         .invert = 0,
1566 };
1567
1568 static void frontend_init(struct ttusb* ttusb)
1569 {
1570         switch(le16_to_cpu(ttusb->dev->descriptor.idProduct)) {
1571         case 0x1003: // Hauppauge/TT Nova-USB-S budget (stv0299/ALPS BSRU6|BSBE1(tsa5059))
1572                 // try the stv0299 based first
1573                 ttusb->fe = dvb_attach(stv0299_attach, &alps_stv0299_config, &ttusb->i2c_adap);
1574                 if (ttusb->fe != NULL) {
1575                         ttusb->fe->ops.tuner_ops.set_params = philips_tsa5059_tuner_set_params;
1576
1577                         if(ttusb->revision == TTUSB_REV_2_2) { // ALPS BSBE1
1578                                 alps_stv0299_config.inittab = alps_bsbe1_inittab;
1579                                 dvb_attach(lnbp21_attach, ttusb->fe, &ttusb->i2c_adap, 0, 0);
1580                         } else { // ALPS BSRU6
1581                                 ttusb->fe->ops.set_voltage = ttusb_set_voltage;
1582                         }
1583                         break;
1584                 }
1585
1586                 // Grundig 29504-491
1587                 ttusb->fe = dvb_attach(tda8083_attach, &ttusb_novas_grundig_29504_491_config, &ttusb->i2c_adap);
1588                 if (ttusb->fe != NULL) {
1589                         ttusb->fe->ops.tuner_ops.set_params = ttusb_novas_grundig_29504_491_tuner_set_params;
1590                         ttusb->fe->ops.set_voltage = ttusb_set_voltage;
1591                         break;
1592                 }
1593                 break;
1594
1595         case 0x1004: // Hauppauge/TT DVB-C budget (ves1820/ALPS TDBE2(sp5659))
1596                 ttusb->fe = dvb_attach(ves1820_attach, &alps_tdbe2_config, &ttusb->i2c_adap, read_pwm(ttusb));
1597                 if (ttusb->fe != NULL) {
1598                         ttusb->fe->ops.tuner_ops.set_params = alps_tdbe2_tuner_set_params;
1599                         break;
1600                 }
1601
1602                 ttusb->fe = dvb_attach(stv0297_attach, &dvbc_philips_tdm1316l_config, &ttusb->i2c_adap);
1603                 if (ttusb->fe != NULL) {
1604                         ttusb->fe->ops.tuner_ops.set_params = dvbc_philips_tdm1316l_tuner_set_params;
1605                         break;
1606                 }
1607                 break;
1608
1609         case 0x1005: // Hauppauge/TT Nova-USB-t budget (tda10046/Philips td1316(tda6651tt) OR cx22700/ALPS TDMB7(??))
1610                 // try the ALPS TDMB7 first
1611                 ttusb->fe = dvb_attach(cx22700_attach, &alps_tdmb7_config, &ttusb->i2c_adap);
1612                 if (ttusb->fe != NULL) {
1613                         ttusb->fe->ops.tuner_ops.set_params = alps_tdmb7_tuner_set_params;
1614                         break;
1615                 }
1616
1617                 // Philips td1316
1618                 ttusb->fe = dvb_attach(tda10046_attach, &philips_tdm1316l_config, &ttusb->i2c_adap);
1619                 if (ttusb->fe != NULL) {
1620                         ttusb->fe->ops.tuner_ops.init = philips_tdm1316l_tuner_init;
1621                         ttusb->fe->ops.tuner_ops.set_params = philips_tdm1316l_tuner_set_params;
1622                         break;
1623                 }
1624                 break;
1625         }
1626
1627         if (ttusb->fe == NULL) {
1628                 printk("dvb-ttusb-budget: A frontend driver was not found for device [%04x:%04x]\n",
1629                        le16_to_cpu(ttusb->dev->descriptor.idVendor),
1630                        le16_to_cpu(ttusb->dev->descriptor.idProduct));
1631         } else {
1632                 if (dvb_register_frontend(&ttusb->adapter, ttusb->fe)) {
1633                         printk("dvb-ttusb-budget: Frontend registration failed!\n");
1634                         dvb_frontend_detach(ttusb->fe);
1635                         ttusb->fe = NULL;
1636                 }
1637         }
1638 }
1639
1640
1641
1642 static struct i2c_algorithm ttusb_dec_algo = {
1643         .master_xfer    = master_xfer,
1644         .functionality  = functionality,
1645 };
1646
1647 static int ttusb_probe(struct usb_interface *intf, const struct usb_device_id *id)
1648 {
1649         struct usb_device *udev;
1650         struct ttusb *ttusb;
1651         int result;
1652
1653         dprintk("%s: TTUSB DVB connected\n", __func__);
1654
1655         udev = interface_to_usbdev(intf);
1656
1657         if (intf->altsetting->desc.bInterfaceNumber != 1) return -ENODEV;
1658
1659         if (!(ttusb = kzalloc(sizeof(struct ttusb), GFP_KERNEL)))
1660                 return -ENOMEM;
1661
1662         ttusb->dev = udev;
1663         ttusb->c = 0;
1664         ttusb->mux_state = 0;
1665         mutex_init(&ttusb->semi2c);
1666
1667         mutex_lock(&ttusb->semi2c);
1668
1669         mutex_init(&ttusb->semusb);
1670
1671         ttusb_setup_interfaces(ttusb);
1672
1673         result = ttusb_alloc_iso_urbs(ttusb);
1674         if (result < 0) {
1675                 dprintk("%s: ttusb_alloc_iso_urbs - failed\n", __func__);
1676                 mutex_unlock(&ttusb->semi2c);
1677                 kfree(ttusb);
1678                 return result;
1679         }
1680
1681         if (ttusb_init_controller(ttusb))
1682                 printk("ttusb_init_controller: error\n");
1683
1684         mutex_unlock(&ttusb->semi2c);
1685
1686         result = dvb_register_adapter(&ttusb->adapter,
1687                                       "Technotrend/Hauppauge Nova-USB",
1688                                       THIS_MODULE, &udev->dev, adapter_nr);
1689         if (result < 0) {
1690                 ttusb_free_iso_urbs(ttusb);
1691                 kfree(ttusb);
1692                 return result;
1693         }
1694         ttusb->adapter.priv = ttusb;
1695
1696         /* i2c */
1697         memset(&ttusb->i2c_adap, 0, sizeof(struct i2c_adapter));
1698         strcpy(ttusb->i2c_adap.name, "TTUSB DEC");
1699
1700         i2c_set_adapdata(&ttusb->i2c_adap, ttusb);
1701
1702         ttusb->i2c_adap.algo              = &ttusb_dec_algo;
1703         ttusb->i2c_adap.algo_data         = NULL;
1704         ttusb->i2c_adap.dev.parent        = &udev->dev;
1705
1706         result = i2c_add_adapter(&ttusb->i2c_adap);
1707         if (result)
1708                 goto err_unregister_adapter;
1709
1710         memset(&ttusb->dvb_demux, 0, sizeof(ttusb->dvb_demux));
1711
1712         ttusb->dvb_demux.dmx.capabilities =
1713             DMX_TS_FILTERING | DMX_SECTION_FILTERING;
1714         ttusb->dvb_demux.priv = NULL;
1715 #ifdef TTUSB_HWSECTIONS
1716         ttusb->dvb_demux.filternum = TTUSB_MAXFILTER;
1717 #else
1718         ttusb->dvb_demux.filternum = 32;
1719 #endif
1720         ttusb->dvb_demux.feednum = TTUSB_MAXCHANNEL;
1721         ttusb->dvb_demux.start_feed = ttusb_start_feed;
1722         ttusb->dvb_demux.stop_feed = ttusb_stop_feed;
1723         ttusb->dvb_demux.write_to_decoder = NULL;
1724
1725         result = dvb_dmx_init(&ttusb->dvb_demux);
1726         if (result < 0) {
1727                 printk("ttusb_dvb: dvb_dmx_init failed (errno = %d)\n", result);
1728                 result = -ENODEV;
1729                 goto err_i2c_del_adapter;
1730         }
1731 //FIXME dmxdev (nur WAS?)
1732         ttusb->dmxdev.filternum = ttusb->dvb_demux.filternum;
1733         ttusb->dmxdev.demux = &ttusb->dvb_demux.dmx;
1734         ttusb->dmxdev.capabilities = 0;
1735
1736         result = dvb_dmxdev_init(&ttusb->dmxdev, &ttusb->adapter);
1737         if (result < 0) {
1738                 printk("ttusb_dvb: dvb_dmxdev_init failed (errno = %d)\n",
1739                        result);
1740                 result = -ENODEV;
1741                 goto err_release_dmx;
1742         }
1743
1744         if (dvb_net_init(&ttusb->adapter, &ttusb->dvbnet, &ttusb->dvb_demux.dmx)) {
1745                 printk("ttusb_dvb: dvb_net_init failed!\n");
1746                 result = -ENODEV;
1747                 goto err_release_dmxdev;
1748         }
1749
1750         usb_set_intfdata(intf, (void *) ttusb);
1751
1752         frontend_init(ttusb);
1753
1754         return 0;
1755
1756 err_release_dmxdev:
1757         dvb_dmxdev_release(&ttusb->dmxdev);
1758 err_release_dmx:
1759         dvb_dmx_release(&ttusb->dvb_demux);
1760 err_i2c_del_adapter:
1761         i2c_del_adapter(&ttusb->i2c_adap);
1762 err_unregister_adapter:
1763         dvb_unregister_adapter (&ttusb->adapter);
1764         return result;
1765 }
1766
1767 static void ttusb_disconnect(struct usb_interface *intf)
1768 {
1769         struct ttusb *ttusb = usb_get_intfdata(intf);
1770
1771         usb_set_intfdata(intf, NULL);
1772
1773         ttusb->disconnecting = 1;
1774
1775         ttusb_stop_iso_xfer(ttusb);
1776
1777         ttusb->dvb_demux.dmx.close(&ttusb->dvb_demux.dmx);
1778         dvb_net_release(&ttusb->dvbnet);
1779         dvb_dmxdev_release(&ttusb->dmxdev);
1780         dvb_dmx_release(&ttusb->dvb_demux);
1781         if (ttusb->fe != NULL) {
1782                 dvb_unregister_frontend(ttusb->fe);
1783                 dvb_frontend_detach(ttusb->fe);
1784         }
1785         i2c_del_adapter(&ttusb->i2c_adap);
1786         dvb_unregister_adapter(&ttusb->adapter);
1787
1788         ttusb_free_iso_urbs(ttusb);
1789
1790         kfree(ttusb);
1791
1792         dprintk("%s: TTUSB DVB disconnected\n", __func__);
1793 }
1794
1795 static struct usb_device_id ttusb_table[] = {
1796         {USB_DEVICE(0xb48, 0x1003)},
1797         {USB_DEVICE(0xb48, 0x1004)},
1798         {USB_DEVICE(0xb48, 0x1005)},
1799         {}
1800 };
1801
1802 MODULE_DEVICE_TABLE(usb, ttusb_table);
1803
1804 static struct usb_driver ttusb_driver = {
1805       .name             = "ttusb",
1806       .probe            = ttusb_probe,
1807       .disconnect       = ttusb_disconnect,
1808       .id_table         = ttusb_table,
1809 };
1810
1811 module_usb_driver(ttusb_driver);
1812
1813 MODULE_AUTHOR("Holger Waechtler <holger@convergence.de>");
1814 MODULE_DESCRIPTION("TTUSB DVB Driver");
1815 MODULE_LICENSE("GPL");
1816 MODULE_FIRMWARE("ttusb-budget/dspbootcode.bin");