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