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