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 	enum fe_sec_tone_mode tone;
115 	enum fe_sec_voltage 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,
515 			     enum fe_sec_voltage voltage)
516 {
517 	struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
518 
519 	ttusb->voltage = voltage;
520 	return ttusb_update_lnb(ttusb);
521 }
522 
523 #ifdef TTUSB_TONE
524 static int ttusb_set_tone(struct dvb_frontend *fe, enum fe_sec_tone_mode tone)
525 {
526 	struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
527 
528 	ttusb->tone = tone;
529 	return ttusb_update_lnb(ttusb);
530 }
531 #endif
532 
533 
534 #if 0
535 static void ttusb_set_led_freq(struct ttusb *ttusb, u8 freq)
536 {
537 	u8 b[] = { 0xaa, ++ttusb->c, 0x19, 1, freq };
538 	int err, actual_len;
539 
540 	err = ttusb_cmd(ttusb, b, sizeof(b), 0);
541 	if (err) {
542 		dprintk("%s: usb_bulk_msg() failed, return value %i!\n",
543 			__func__, err);
544 	}
545 }
546 #endif
547 
548 /*****************************************************************************/
549 
550 #ifdef TTUSB_HWSECTIONS
551 static void ttusb_handle_ts_data(struct ttusb_channel *channel,
552 				 const u8 * data, int len);
553 static void ttusb_handle_sec_data(struct ttusb_channel *channel,
554 				  const u8 * data, int len);
555 #endif
556 
557 static int numpkt, numts, numstuff, numsec, numinvalid;
558 static unsigned long lastj;
559 
560 static void ttusb_process_muxpack(struct ttusb *ttusb, const u8 * muxpack,
561 			   int len)
562 {
563 	u16 csum = 0, cc;
564 	int i;
565 
566 	if (len < 4 || len & 0x1) {
567 		pr_warn("%s: muxpack has invalid len %d\n", __func__, len);
568 		numinvalid++;
569 		return;
570 	}
571 
572 	for (i = 0; i < len; i += 2)
573 		csum ^= le16_to_cpup((__le16 *) (muxpack + i));
574 	if (csum) {
575 		printk("%s: muxpack with incorrect checksum, ignoring\n",
576 		       __func__);
577 		numinvalid++;
578 		return;
579 	}
580 
581 	cc = (muxpack[len - 4] << 8) | muxpack[len - 3];
582 	cc &= 0x7FFF;
583 	if ((cc != ttusb->cc) && (ttusb->cc != -1))
584 		printk("%s: cc discontinuity (%d frames missing)\n",
585 		       __func__, (cc - ttusb->cc) & 0x7FFF);
586 	ttusb->cc = (cc + 1) & 0x7FFF;
587 	if (muxpack[0] & 0x80) {
588 #ifdef TTUSB_HWSECTIONS
589 		/* section data */
590 		int pusi = muxpack[0] & 0x40;
591 		int channel = muxpack[0] & 0x1F;
592 		int payload = muxpack[1];
593 		const u8 *data = muxpack + 2;
594 		/* check offset flag */
595 		if (muxpack[0] & 0x20)
596 			data++;
597 
598 		ttusb_handle_sec_data(ttusb->channel + channel, data,
599 				      payload);
600 		data += payload;
601 
602 		if ((!!(ttusb->muxpack[0] & 0x20)) ^
603 		    !!(ttusb->muxpack[1] & 1))
604 			data++;
605 #warning TODO: pusi
606 		printk("cc: %04x\n", (data[0] << 8) | data[1]);
607 #endif
608 		numsec++;
609 	} else if (muxpack[0] == 0x47) {
610 #ifdef TTUSB_HWSECTIONS
611 		/* we have TS data here! */
612 		int pid = ((muxpack[1] & 0x0F) << 8) | muxpack[2];
613 		int channel;
614 		for (channel = 0; channel < TTUSB_MAXCHANNEL; ++channel)
615 			if (ttusb->channel[channel].active
616 			    && (pid == ttusb->channel[channel].pid))
617 				ttusb_handle_ts_data(ttusb->channel +
618 						     channel, muxpack,
619 						     188);
620 #endif
621 		numts++;
622 		dvb_dmx_swfilter_packets(&ttusb->dvb_demux, muxpack, 1);
623 	} else if (muxpack[0] != 0) {
624 		numinvalid++;
625 		printk("illegal muxpack type %02x\n", muxpack[0]);
626 	} else
627 		numstuff++;
628 }
629 
630 static void ttusb_process_frame(struct ttusb *ttusb, u8 * data, int len)
631 {
632 	int maxwork = 1024;
633 	while (len) {
634 		if (!(maxwork--)) {
635 			printk("%s: too much work\n", __func__);
636 			break;
637 		}
638 
639 		switch (ttusb->mux_state) {
640 		case 0:
641 		case 1:
642 		case 2:
643 			len--;
644 			if (*data++ == 0xAA)
645 				++ttusb->mux_state;
646 			else {
647 				ttusb->mux_state = 0;
648 				if (ttusb->insync) {
649 					dprintk("%s: %02x\n",
650 						__func__, data[-1]);
651 					printk(KERN_INFO "%s: lost sync.\n",
652 					       __func__);
653 					ttusb->insync = 0;
654 				}
655 			}
656 			break;
657 		case 3:
658 			ttusb->insync = 1;
659 			len--;
660 			ttusb->mux_npacks = *data++;
661 			++ttusb->mux_state;
662 			ttusb->muxpack_ptr = 0;
663 			/* maximum bytes, until we know the length */
664 			ttusb->muxpack_len = 2;
665 			break;
666 		case 4:
667 			{
668 				int avail;
669 				avail = len;
670 				if (avail >
671 				    (ttusb->muxpack_len -
672 				     ttusb->muxpack_ptr))
673 					avail =
674 					    ttusb->muxpack_len -
675 					    ttusb->muxpack_ptr;
676 				memcpy(ttusb->muxpack + ttusb->muxpack_ptr,
677 				       data, avail);
678 				ttusb->muxpack_ptr += avail;
679 				BUG_ON(ttusb->muxpack_ptr > 264);
680 				data += avail;
681 				len -= avail;
682 				/* determine length */
683 				if (ttusb->muxpack_ptr == 2) {
684 					if (ttusb->muxpack[0] & 0x80) {
685 						ttusb->muxpack_len =
686 						    ttusb->muxpack[1] + 2;
687 						if (ttusb->
688 						    muxpack[0] & 0x20)
689 							ttusb->
690 							    muxpack_len++;
691 						if ((!!
692 						     (ttusb->
693 						      muxpack[0] & 0x20)) ^
694 						    !!(ttusb->
695 						       muxpack[1] & 1))
696 							ttusb->
697 							    muxpack_len++;
698 						ttusb->muxpack_len += 4;
699 					} else if (ttusb->muxpack[0] ==
700 						   0x47)
701 						ttusb->muxpack_len =
702 						    188 + 4;
703 					else if (ttusb->muxpack[0] == 0x00)
704 						ttusb->muxpack_len =
705 						    ttusb->muxpack[1] + 2 +
706 						    4;
707 					else {
708 						dprintk
709 						    ("%s: invalid state: first byte is %x\n",
710 						     __func__,
711 						     ttusb->muxpack[0]);
712 						ttusb->mux_state = 0;
713 					}
714 				}
715 
716 			/**
717 			 * if length is valid and we reached the end:
718 			 * goto next muxpack
719 			 */
720 				if ((ttusb->muxpack_ptr >= 2) &&
721 				    (ttusb->muxpack_ptr ==
722 				     ttusb->muxpack_len)) {
723 					ttusb_process_muxpack(ttusb,
724 							      ttusb->
725 							      muxpack,
726 							      ttusb->
727 							      muxpack_ptr);
728 					ttusb->muxpack_ptr = 0;
729 					/* maximum bytes, until we know the length */
730 					ttusb->muxpack_len = 2;
731 
732 				/**
733 				 * no muxpacks left?
734 				 * return to search-sync state
735 				 */
736 					if (!ttusb->mux_npacks--) {
737 						ttusb->mux_state = 0;
738 						break;
739 					}
740 				}
741 				break;
742 			}
743 		default:
744 			BUG();
745 			break;
746 		}
747 	}
748 }
749 
750 static void ttusb_iso_irq(struct urb *urb)
751 {
752 	struct ttusb *ttusb = urb->context;
753 	struct usb_iso_packet_descriptor *d;
754 	u8 *data;
755 	int len, i;
756 
757 	if (!ttusb->iso_streaming)
758 		return;
759 
760 #if 0
761 	printk("%s: status %d, errcount == %d, length == %i\n",
762 	       __func__,
763 	       urb->status, urb->error_count, urb->actual_length);
764 #endif
765 
766 	if (!urb->status) {
767 		for (i = 0; i < urb->number_of_packets; ++i) {
768 			numpkt++;
769 			if (time_after_eq(jiffies, lastj + HZ)) {
770 				dprintk("frames/s: %lu (ts: %d, stuff %d, 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