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