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