?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
V4L/DVB: follow lspci device/vendor style
[linux-2.6/mini2440.git] / drivers / media / dvb / ttusb-budget / dvb-ttusb-budget.c
blob66ab0c6e9783da4f8a99cca3699c3a32dd51ec58
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 memset(ttusb->iso_buffer, 0,
812 ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF * ISO_BUF_COUNT);
813
814 for (i = 0; i < ISO_BUF_COUNT; i++) {
815 struct urb *urb;
816
817 if (!
818 (urb =
819 usb_alloc_urb(FRAMES_PER_ISO_BUF, GFP_ATOMIC))) {
820 ttusb_free_iso_urbs(ttusb);
821 return -ENOMEM;
822 }
823
824 ttusb->iso_urb[i] = urb;
825 }
826
827 return 0;
828 }
829
830 static void ttusb_stop_iso_xfer(struct ttusb *ttusb)
831 {
832 int i;
833
834 for (i = 0; i < ISO_BUF_COUNT; i++)
835 usb_kill_urb(ttusb->iso_urb[i]);
836
837 ttusb->iso_streaming = 0;
838 }
839
840 static int ttusb_start_iso_xfer(struct ttusb *ttusb)
841 {
842 int i, j, err, buffer_offset = 0;
843
844 if (ttusb->iso_streaming) {
845 printk("%s: iso xfer already running!\n", __func__);
846 return 0;
847 }
848
849 ttusb->cc = -1;
850 ttusb->insync = 0;
851 ttusb->mux_state = 0;
852
853 for (i = 0; i < ISO_BUF_COUNT; i++) {
854 int frame_offset = 0;
855 struct urb *urb = ttusb->iso_urb[i];
856
857 urb->dev = ttusb->dev;
858 urb->context = ttusb;
859 urb->complete = ttusb_iso_irq;
860 urb->pipe = ttusb->isoc_in_pipe;
861 urb->transfer_flags = URB_ISO_ASAP;
862 urb->interval = 1;
863 urb->number_of_packets = FRAMES_PER_ISO_BUF;
864 urb->transfer_buffer_length =
865 ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF;
866 urb->transfer_buffer = ttusb->iso_buffer + buffer_offset;
867 buffer_offset += ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF;
868
869 for (j = 0; j < FRAMES_PER_ISO_BUF; j++) {
870 urb->iso_frame_desc[j].offset = frame_offset;
871 urb->iso_frame_desc[j].length = ISO_FRAME_SIZE;
872 frame_offset += ISO_FRAME_SIZE;
873 }
874 }
875
876 for (i = 0; i < ISO_BUF_COUNT; i++) {
877 if ((err = usb_submit_urb(ttusb->iso_urb[i], GFP_ATOMIC))) {
878 ttusb_stop_iso_xfer(ttusb);
879 printk
880 ("%s: failed urb submission (%i: err = %i)!\n",
881 __func__, i, err);
882 return err;
883 }
884 }
885
886 ttusb->iso_streaming = 1;
887
888 return 0;
889 }
890
891 #ifdef TTUSB_HWSECTIONS
892 static void ttusb_handle_ts_data(struct dvb_demux_feed *dvbdmxfeed, const u8 * data,
893 int len)
894 {
895 dvbdmxfeed->cb.ts(data, len, 0, 0, &dvbdmxfeed->feed.ts, 0);
896 }
897
898 static void ttusb_handle_sec_data(struct dvb_demux_feed *dvbdmxfeed, const u8 * data,
899 int len)
900 {
901 // struct dvb_demux_feed *dvbdmxfeed = channel->dvbdmxfeed;
902 #error TODO: handle ugly stuff
903 // dvbdmxfeed->cb.sec(data, len, 0, 0, &dvbdmxfeed->feed.sec, 0);
904 }
905 #endif
906
907 static int ttusb_start_feed(struct dvb_demux_feed *dvbdmxfeed)
908 {
909 struct ttusb *ttusb = (struct ttusb *) dvbdmxfeed->demux;
910 int feed_type = 1;
911
912 dprintk("ttusb_start_feed\n");
913
914 switch (dvbdmxfeed->type) {
915 case DMX_TYPE_TS:
916 break;
917 case DMX_TYPE_SEC:
918 break;
919 default:
920 return -EINVAL;
921 }
922
923 if (dvbdmxfeed->type == DMX_TYPE_TS) {
924 switch (dvbdmxfeed->pes_type) {
925 case DMX_TS_PES_VIDEO:
926 case DMX_TS_PES_AUDIO:
927 case DMX_TS_PES_TELETEXT:
928 case DMX_TS_PES_PCR:
929 case DMX_TS_PES_OTHER:
930 break;
931 default:
932 return -EINVAL;
933 }
934 }
935
936 #ifdef TTUSB_HWSECTIONS
937 #error TODO: allocate filters
938 if (dvbdmxfeed->type == DMX_TYPE_TS) {
939 feed_type = 1;
940 } else if (dvbdmxfeed->type == DMX_TYPE_SEC) {
941 feed_type = 2;
942 }
943 #endif
944
945 ttusb_set_channel(ttusb, dvbdmxfeed->index, feed_type, dvbdmxfeed->pid);
946
947 if (0 == ttusb->running_feed_count++)
948 ttusb_start_iso_xfer(ttusb);
949
950 return 0;
951 }
952
953 static int ttusb_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
954 {
955 struct ttusb *ttusb = (struct ttusb *) dvbdmxfeed->demux;
956
957 ttusb_del_channel(ttusb, dvbdmxfeed->index);
958
959 if (--ttusb->running_feed_count == 0)
960 ttusb_stop_iso_xfer(ttusb);
961
962 return 0;
963 }
964
965 static int ttusb_setup_interfaces(struct ttusb *ttusb)
966 {
967 usb_set_interface(ttusb->dev, 1, 1);
968
969 ttusb->bulk_out_pipe = usb_sndbulkpipe(ttusb->dev, 1);
970 ttusb->bulk_in_pipe = usb_rcvbulkpipe(ttusb->dev, 1);
971 ttusb->isoc_in_pipe = usb_rcvisocpipe(ttusb->dev, 2);
972
973 return 0;
974 }
975
976 #if 0
977 static u8 stc_firmware[8192];
978
979 static int stc_open(struct inode *inode, struct file *file)
980 {
981 struct ttusb *ttusb = file->private_data;
982 int addr;
983
984 for (addr = 0; addr < 8192; addr += 16) {
985 u8 snd_buf[2] = { addr >> 8, addr & 0xFF };
986 ttusb_i2c_msg(ttusb, 0x50, snd_buf, 2, stc_firmware + addr,
987 16);
988 }
989
990 return 0;
991 }
992
993 static ssize_t stc_read(struct file *file, char *buf, size_t count,
994 loff_t *offset)
995 {
996 return simple_read_from_buffer(buf, count, offset, stc_firmware, 8192);
997 }
998
999 static int stc_release(struct inode *inode, struct file *file)
1000 {
1001 return 0;
1002 }
1003
1004 static const struct file_operations stc_fops = {
1005 .owner = THIS_MODULE,
1006 .read = stc_read,
1007 .open = stc_open,
1008 .release = stc_release,
1009 };
1010 #endif
1011
1012 static u32 functionality(struct i2c_adapter *adapter)
1013 {
1014 return I2C_FUNC_I2C;
1015 }
1016
1017
1018
1019 static int alps_tdmb7_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1020 {
1021 struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1022 u8 data[4];
1023 struct i2c_msg msg = {.addr=0x61, .flags=0, .buf=data, .len=sizeof(data) };
1024 u32 div;
1025
1026 div = (params->frequency + 36166667) / 166667;
1027
1028 data[0] = (div >> 8) & 0x7f;
1029 data[1] = div & 0xff;
1030 data[2] = ((div >> 10) & 0x60) | 0x85;
1031 data[3] = params->frequency < 592000000 ? 0x40 : 0x80;
1032
1033 if (fe->ops.i2c_gate_ctrl)
1034 fe->ops.i2c_gate_ctrl(fe, 1);
1035 if (i2c_transfer(&ttusb->i2c_adap, &msg, 1) != 1) return -EIO;
1036 return 0;
1037 }
1038
1039 static struct cx22700_config alps_tdmb7_config = {
1040 .demod_address = 0x43,
1041 };
1042
1043
1044
1045
1046
1047 static int philips_tdm1316l_tuner_init(struct dvb_frontend* fe)
1048 {
1049 struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1050 static u8 td1316_init[] = { 0x0b, 0xf5, 0x85, 0xab };
1051 static u8 disable_mc44BC374c[] = { 0x1d, 0x74, 0xa0, 0x68 };
1052 struct i2c_msg tuner_msg = { .addr=0x60, .flags=0, .buf=td1316_init, .len=sizeof(td1316_init) };
1053
1054 // setup PLL configuration
1055 if (fe->ops.i2c_gate_ctrl)
1056 fe->ops.i2c_gate_ctrl(fe, 1);
1057 if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) return -EIO;
1058 msleep(1);
1059
1060 // disable the mc44BC374c (do not check for errors)
1061 tuner_msg.addr = 0x65;
1062 tuner_msg.buf = disable_mc44BC374c;
1063 tuner_msg.len = sizeof(disable_mc44BC374c);
1064 if (fe->ops.i2c_gate_ctrl)
1065 fe->ops.i2c_gate_ctrl(fe, 1);
1066 if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) {
1067 i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1);
1068 }
1069
1070 return 0;
1071 }
1072
1073 static int philips_tdm1316l_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1074 {
1075 struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1076 u8 tuner_buf[4];
1077 struct i2c_msg tuner_msg = {.addr=0x60, .flags=0, .buf=tuner_buf, .len=sizeof(tuner_buf) };
1078 int tuner_frequency = 0;
1079 u8 band, cp, filter;
1080
1081 // determine charge pump
1082 tuner_frequency = params->frequency + 36130000;
1083 if (tuner_frequency < 87000000) return -EINVAL;
1084 else if (tuner_frequency < 130000000) cp = 3;
1085 else if (tuner_frequency < 160000000) cp = 5;
1086 else if (tuner_frequency < 200000000) cp = 6;
1087 else if (tuner_frequency < 290000000) cp = 3;
1088 else if (tuner_frequency < 420000000) cp = 5;
1089 else if (tuner_frequency < 480000000) cp = 6;
1090 else if (tuner_frequency < 620000000) cp = 3;
1091 else if (tuner_frequency < 830000000) cp = 5;
1092 else if (tuner_frequency < 895000000) cp = 7;
1093 else return -EINVAL;
1094
1095 // determine band
1096 if (params->frequency < 49000000) return -EINVAL;
1097 else if (params->frequency < 159000000) band = 1;
1098 else if (params->frequency < 444000000) band = 2;
1099 else if (params->frequency < 861000000) band = 4;
1100 else return -EINVAL;
1101
1102 // setup PLL filter
1103 switch (params->u.ofdm.bandwidth) {
1104 case BANDWIDTH_6_MHZ:
1105 tda1004x_writereg(fe, 0x0C, 0);
1106 filter = 0;
1107 break;
1108
1109 case BANDWIDTH_7_MHZ:
1110 tda1004x_writereg(fe, 0x0C, 0);
1111 filter = 0;
1112 break;
1113
1114 case BANDWIDTH_8_MHZ:
1115 tda1004x_writereg(fe, 0x0C, 0xFF);
1116 filter = 1;
1117 break;
1118
1119 default:
1120 return -EINVAL;
1121 }
1122
1123 // calculate divisor
1124 // ((36130000+((1000000/6)/2)) + Finput)/(1000000/6)
1125 tuner_frequency = (((params->frequency / 1000) * 6) + 217280) / 1000;
1126
1127 // setup tuner buffer
1128 tuner_buf[0] = tuner_frequency >> 8;
1129 tuner_buf[1] = tuner_frequency & 0xff;
1130 tuner_buf[2] = 0xca;
1131 tuner_buf[3] = (cp << 5) | (filter << 3) | band;
1132
1133 if (fe->ops.i2c_gate_ctrl)
1134 fe->ops.i2c_gate_ctrl(fe, 1);
1135 if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1)
1136 return -EIO;
1137
1138 msleep(1);
1139 return 0;
1140 }
1141
1142 static int philips_tdm1316l_request_firmware(struct dvb_frontend* fe, const struct firmware **fw, char* name)
1143 {
1144 struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1145
1146 return request_firmware(fw, name, &ttusb->dev->dev);
1147 }
1148
1149 static struct tda1004x_config philips_tdm1316l_config = {
1150
1151 .demod_address = 0x8,
1152 .invert = 1,
1153 .invert_oclk = 0,
1154 .request_firmware = philips_tdm1316l_request_firmware,
1155 };
1156
1157 static u8 alps_bsbe1_inittab[] = {
1158 0x01, 0x15,
1159 0x02, 0x30,
1160 0x03, 0x00,
1161 0x04, 0x7d, /* F22FR = 0x7d, F22 = f_VCO / 128 / 0x7d = 22 kHz */
1162 0x05, 0x35, /* I2CT = 0, SCLT = 1, SDAT = 1 */
1163 0x06, 0x40, /* DAC not used, set to high impendance mode */
1164 0x07, 0x00, /* DAC LSB */
1165 0x08, 0x40, /* DiSEqC off, LNB power on OP2/LOCK pin on */
1166 0x09, 0x00, /* FIFO */
1167 0x0c, 0x51, /* OP1 ctl = Normal, OP1 val = 1 (LNB Power ON) */
1168 0x0d, 0x82, /* DC offset compensation = ON, beta_agc1 = 2 */
1169 0x0e, 0x23, /* alpha_tmg = 2, beta_tmg = 3 */
1170 0x10, 0x3f, // AGC2 0x3d
1171 0x11, 0x84,
1172 0x12, 0xb9,
1173 0x15, 0xc9, // lock detector threshold
1174 0x16, 0x00,
1175 0x17, 0x00,
1176 0x18, 0x00,
1177 0x19, 0x00,
1178 0x1a, 0x00,
1179 0x1f, 0x50,
1180 0x20, 0x00,
1181 0x21, 0x00,
1182 0x22, 0x00,
1183 0x23, 0x00,
1184 0x28, 0x00, // out imp: normal out type: parallel FEC mode:0
1185 0x29, 0x1e, // 1/2 threshold
1186 0x2a, 0x14, // 2/3 threshold
1187 0x2b, 0x0f, // 3/4 threshold
1188 0x2c, 0x09, // 5/6 threshold
1189 0x2d, 0x05, // 7/8 threshold
1190 0x2e, 0x01,
1191 0x31, 0x1f, // test all FECs
1192 0x32, 0x19, // viterbi and synchro search
1193 0x33, 0xfc, // rs control
1194 0x34, 0x93, // error control
1195 0x0f, 0x92,
1196 0xff, 0xff
1197 };
1198
1199 static u8 alps_bsru6_inittab[] = {
1200 0x01, 0x15,
1201 0x02, 0x30,
1202 0x03, 0x00,
1203 0x04, 0x7d, /* F22FR = 0x7d, F22 = f_VCO / 128 / 0x7d = 22 kHz */
1204 0x05, 0x35, /* I2CT = 0, SCLT = 1, SDAT = 1 */
1205 0x06, 0x40, /* DAC not used, set to high impendance mode */
1206 0x07, 0x00, /* DAC LSB */
1207 0x08, 0x40, /* DiSEqC off, LNB power on OP2/LOCK pin on */
1208 0x09, 0x00, /* FIFO */
1209 0x0c, 0x51, /* OP1 ctl = Normal, OP1 val = 1 (LNB Power ON) */
1210 0x0d, 0x82, /* DC offset compensation = ON, beta_agc1 = 2 */
1211 0x0e, 0x23, /* alpha_tmg = 2, beta_tmg = 3 */
1212 0x10, 0x3f, // AGC2 0x3d
1213 0x11, 0x84,
1214 0x12, 0xb9,
1215 0x15, 0xc9, // lock detector threshold
1216 0x16, 0x00,
1217 0x17, 0x00,
1218 0x18, 0x00,
1219 0x19, 0x00,
1220 0x1a, 0x00,
1221 0x1f, 0x50,
1222 0x20, 0x00,
1223 0x21, 0x00,
1224 0x22, 0x00,
1225 0x23, 0x00,
1226 0x28, 0x00, // out imp: normal out type: parallel FEC mode:0
1227 0x29, 0x1e, // 1/2 threshold
1228 0x2a, 0x14, // 2/3 threshold
1229 0x2b, 0x0f, // 3/4 threshold
1230 0x2c, 0x09, // 5/6 threshold
1231 0x2d, 0x05, // 7/8 threshold
1232 0x2e, 0x01,
1233 0x31, 0x1f, // test all FECs
1234 0x32, 0x19, // viterbi and synchro search
1235 0x33, 0xfc, // rs control
1236 0x34, 0x93, // error control
1237 0x0f, 0x52,
1238 0xff, 0xff
1239 };
1240
1241 static int alps_stv0299_set_symbol_rate(struct dvb_frontend *fe, u32 srate, u32 ratio)
1242 {
1243 u8 aclk = 0;
1244 u8 bclk = 0;
1245
1246 if (srate < 1500000) {
1247 aclk = 0xb7;
1248 bclk = 0x47;
1249 } else if (srate < 3000000) {
1250 aclk = 0xb7;
1251 bclk = 0x4b;
1252 } else if (srate < 7000000) {
1253 aclk = 0xb7;
1254 bclk = 0x4f;
1255 } else if (srate < 14000000) {
1256 aclk = 0xb7;
1257 bclk = 0x53;
1258 } else if (srate < 30000000) {
1259 aclk = 0xb6;
1260 bclk = 0x53;
1261 } else if (srate < 45000000) {
1262 aclk = 0xb4;
1263 bclk = 0x51;
1264 }
1265
1266 stv0299_writereg(fe, 0x13, aclk);
1267 stv0299_writereg(fe, 0x14, bclk);
1268 stv0299_writereg(fe, 0x1f, (ratio >> 16) & 0xff);
1269 stv0299_writereg(fe, 0x20, (ratio >> 8) & 0xff);
1270 stv0299_writereg(fe, 0x21, (ratio) & 0xf0);
1271
1272 return 0;
1273 }
1274
1275 static int philips_tsa5059_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
1276 {
1277 struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1278 u8 buf[4];
1279 u32 div;
1280 struct i2c_msg msg = {.addr = 0x61,.flags = 0,.buf = buf,.len = sizeof(buf) };
1281
1282 if ((params->frequency < 950000) || (params->frequency > 2150000))
1283 return -EINVAL;
1284
1285 div = (params->frequency + (125 - 1)) / 125; // round correctly
1286 buf[0] = (div >> 8) & 0x7f;
1287 buf[1] = div & 0xff;
1288 buf[2] = 0x80 | ((div & 0x18000) >> 10) | 4;
1289 buf[3] = 0xC4;
1290
1291 if (params->frequency > 1530000)
1292 buf[3] = 0xC0;
1293
1294 /* BSBE1 wants XCE bit set */
1295 if (ttusb->revision == TTUSB_REV_2_2)
1296 buf[3] |= 0x20;
1297
1298 if (fe->ops.i2c_gate_ctrl)
1299 fe->ops.i2c_gate_ctrl(fe, 1);
1300 if (i2c_transfer(&ttusb->i2c_adap, &msg, 1) != 1)
1301 return -EIO;
1302
1303 return 0;
1304 }
1305
1306 static struct stv0299_config alps_stv0299_config = {
1307 .demod_address = 0x68,
1308 .inittab = alps_bsru6_inittab,
1309 .mclk = 88000000UL,
1310 .invert = 1,
1311 .skip_reinit = 0,
1312 .lock_output = STV0299_LOCKOUTPUT_1,
1313 .volt13_op0_op1 = STV0299_VOLT13_OP1,
1314 .min_delay_ms = 100,
1315 .set_symbol_rate = alps_stv0299_set_symbol_rate,
1316 };
1317
1318 static int ttusb_novas_grundig_29504_491_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
1319 {
1320 struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
1321 u8 buf[4];
1322 u32 div;
1323 struct i2c_msg msg = {.addr = 0x61,.flags = 0,.buf = buf,.len = sizeof(buf) };
1324
1325 div = params->frequency / 125;
1326
1327 buf[0] = (div >> 8) & 0x7f;
1328 buf[1] = div & 0xff;
1329 buf[2] = 0x8e;
1330 buf[3] = 0x00;
1331
1332 if (fe->ops.i2c_gate_ctrl)
1333 fe->ops.i2c_gate_ctrl(fe, 1);
1334 if (i2c_transfer(&ttusb->i2c_adap, &msg, 1) != 1)
1335 return -EIO;
1336
1337 return 0;
1338 }
1339
1340 static struct tda8083_config ttusb_novas_grundig_29504_491_config = {
1341
1342 .demod_address = 0x68,
1343 };
1344
1345 static int alps_tdbe2_tuner_set_params(struct dvb_frontend* fe, struct dvb_frontend_parameters* params)
1346 {
1347 struct ttusb* ttusb = fe->dvb->priv;
1348 u32 div;
1349 u8 data[4];
1350 struct i2c_msg msg = { .addr = 0x62, .flags = 0, .buf = data, .len = sizeof(data) };
1351
1352 div = (params->frequency + 35937500 + 31250) / 62500;
1353
1354 data[0] = (div >> 8) & 0x7f;
1355 data[1] = div & 0xff;
1356 data[2] = 0x85 | ((div >> 10) & 0x60);
1357 data[3] = (params->frequency < 174000000 ? 0x88 : params->frequency < 470000000 ? 0x84 : 0x81);
1358
1359 if (fe->ops.i2c_gate_ctrl)
1360 fe->ops.i2c_gate_ctrl(fe, 1);
1361 if (i2c_transfer (&ttusb->i2c_adap, &msg, 1) != 1)
1362 return -EIO;
1363
1364 return 0;
1365 }
1366
1367
1368 static struct ves1820_config alps_tdbe2_config = {
1369 .demod_address = 0x09,
1370 .xin = 57840000UL,
1371 .invert = 1,
1372 .selagc = VES1820_SELAGC_SIGNAMPERR,
1373 };
1374
1375 static u8 read_pwm(struct ttusb* ttusb)
1376 {
1377 u8 b = 0xff;
1378 u8 pwm;
1379 struct i2c_msg msg[] = { { .addr = 0x50,.flags = 0,.buf = &b,.len = 1 },
1380 { .addr = 0x50,.flags = I2C_M_RD,.buf = &pwm,.len = 1} };
1381
1382 if ((i2c_transfer(&ttusb->i2c_adap, msg, 2) != 2) || (pwm == 0xff))
1383 pwm = 0x48;
1384
1385 return pwm;
1386 }
1387
1388
1389 static int dvbc_philips_tdm1316l_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
1390 {
1391 struct ttusb *ttusb = (struct ttusb *) fe->dvb->priv;
1392 u8 tuner_buf[5];
1393 struct i2c_msg tuner_msg = {.addr = 0x60,
1394 .flags = 0,
1395 .buf = tuner_buf,
1396 .len = sizeof(tuner_buf) };
1397 int tuner_frequency = 0;
1398 u8 band, cp, filter;
1399
1400 // determine charge pump
1401 tuner_frequency = params->frequency;
1402 if (tuner_frequency < 87000000) {return -EINVAL;}
1403 else if (tuner_frequency < 130000000) {cp = 3; band = 1;}
1404 else if (tuner_frequency < 160000000) {cp = 5; band = 1;}
1405 else if (tuner_frequency < 200000000) {cp = 6; band = 1;}
1406 else if (tuner_frequency < 290000000) {cp = 3; band = 2;}
1407 else if (tuner_frequency < 420000000) {cp = 5; band = 2;}
1408 else if (tuner_frequency < 480000000) {cp = 6; band = 2;}
1409 else if (tuner_frequency < 620000000) {cp = 3; band = 4;}
1410 else if (tuner_frequency < 830000000) {cp = 5; band = 4;}
1411 else if (tuner_frequency < 895000000) {cp = 7; band = 4;}
1412 else {return -EINVAL;}
1413
1414 // assume PLL filter should always be 8MHz for the moment.
1415 filter = 1;
1416
1417 // calculate divisor
1418 // (Finput + Fif)/Fref; Fif = 36125000 Hz, Fref = 62500 Hz
1419 tuner_frequency = ((params->frequency + 36125000) / 62500);
1420
1421 // setup tuner buffer
1422 tuner_buf[0] = tuner_frequency >> 8;
1423 tuner_buf[1] = tuner_frequency & 0xff;
1424 tuner_buf[2] = 0xc8;
1425 tuner_buf[3] = (cp << 5) | (filter << 3) | band;
1426 tuner_buf[4] = 0x80;
1427
1428 if (fe->ops.i2c_gate_ctrl)
1429 fe->ops.i2c_gate_ctrl(fe, 1);
1430 if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) {
1431 printk("dvb-ttusb-budget: dvbc_philips_tdm1316l_pll_set Error 1\n");
1432 return -EIO;
1433 }
1434
1435 msleep(50);
1436
1437 if (fe->ops.i2c_gate_ctrl)
1438 fe->ops.i2c_gate_ctrl(fe, 1);
1439 if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) {
1440 printk("dvb-ttusb-budget: dvbc_philips_tdm1316l_pll_set Error 2\n");
1441 return -EIO;
1442 }
1443
1444 msleep(1);
1445
1446 return 0;
1447 }
1448
1449 static u8 dvbc_philips_tdm1316l_inittab[] = {
1450 0x80, 0x21,
1451 0x80, 0x20,
1452 0x81, 0x01,
1453 0x81, 0x00,
1454 0x00, 0x09,
1455 0x01, 0x69,
1456 0x03, 0x00,
1457 0x04, 0x00,
1458 0x07, 0x00,
1459 0x08, 0x00,
1460 0x20, 0x00,
1461 0x21, 0x40,
1462 0x22, 0x00,
1463 0x23, 0x00,
1464 0x24, 0x40,
1465 0x25, 0x88,
1466 0x30, 0xff,
1467 0x31, 0x00,
1468 0x32, 0xff,
1469 0x33, 0x00,
1470 0x34, 0x50,
1471 0x35, 0x7f,
1472 0x36, 0x00,
1473 0x37, 0x20,
1474 0x38, 0x00,
1475 0x40, 0x1c,
1476 0x41, 0xff,
1477 0x42, 0x29,
1478 0x43, 0x20,
1479 0x44, 0xff,
1480 0x45, 0x00,
1481 0x46, 0x00,
1482 0x49, 0x04,
1483 0x4a, 0xff,
1484 0x4b, 0x7f,
1485 0x52, 0x30,
1486 0x55, 0xae,
1487 0x56, 0x47,
1488 0x57, 0xe1,
1489 0x58, 0x3a,
1490 0x5a, 0x1e,
1491 0x5b, 0x34,
1492 0x60, 0x00,
1493 0x63, 0x00,
1494 0x64, 0x00,
1495 0x65, 0x00,
1496 0x66, 0x00,
1497 0x67, 0x00,
1498 0x68, 0x00,
1499 0x69, 0x00,
1500 0x6a, 0x02,
1501 0x6b, 0x00,
1502 0x70, 0xff,
1503 0x71, 0x00,
1504 0x72, 0x00,
1505 0x73, 0x00,
1506 0x74, 0x0c,
1507 0x80, 0x00,
1508 0x81, 0x00,
1509 0x82, 0x00,
1510 0x83, 0x00,
1511 0x84, 0x04,
1512 0x85, 0x80,
1513 0x86, 0x24,
1514 0x87, 0x78,
1515 0x88, 0x00,
1516 0x89, 0x00,
1517 0x90, 0x01,
1518 0x91, 0x01,
1519 0xa0, 0x00,
1520 0xa1, 0x00,
1521 0xa2, 0x00,
1522 0xb0, 0x91,
1523 0xb1, 0x0b,
1524 0xc0, 0x4b,
1525 0xc1, 0x00,
1526 0xc2, 0x00,
1527 0xd0, 0x00,
1528 0xd1, 0x00,
1529 0xd2, 0x00,
1530 0xd3, 0x00,
1531 0xd4, 0x00,
1532 0xd5, 0x00,
1533 0xde, 0x00,
1534 0xdf, 0x00,
1535 0x61, 0x38,
1536 0x62, 0x0a,
1537 0x53, 0x13,
1538 0x59, 0x08,
1539 0x55, 0x00,
1540 0x56, 0x40,
1541 0x57, 0x08,
1542 0x58, 0x3d,
1543 0x88, 0x10,
1544 0xa0, 0x00,
1545 0xa0, 0x00,
1546 0xa0, 0x00,
1547 0xa0, 0x04,
1548 0xff, 0xff,
1549 };
1550
1551 static struct stv0297_config dvbc_philips_tdm1316l_config = {
1552 .demod_address = 0x1c,
1553 .inittab = dvbc_philips_tdm1316l_inittab,
1554 .invert = 0,
1555 };
1556
1557 static void frontend_init(struct ttusb* ttusb)
1558 {
1559 switch(le16_to_cpu(ttusb->dev->descriptor.idProduct)) {
1560 case 0x1003: // Hauppauge/TT Nova-USB-S budget (stv0299/ALPS BSRU6|BSBE1(tsa5059))
1561 // try the stv0299 based first
1562 ttusb->fe = dvb_attach(stv0299_attach, &alps_stv0299_config, &ttusb->i2c_adap);
1563 if (ttusb->fe != NULL) {
1564 ttusb->fe->ops.tuner_ops.set_params = philips_tsa5059_tuner_set_params;
1565
1566 if(ttusb->revision == TTUSB_REV_2_2) { // ALPS BSBE1
1567 alps_stv0299_config.inittab = alps_bsbe1_inittab;
1568 dvb_attach(lnbp21_attach, ttusb->fe, &ttusb->i2c_adap, 0, 0);
1569 } else { // ALPS BSRU6
1570 ttusb->fe->ops.set_voltage = ttusb_set_voltage;
1571 }
1572 break;
1573 }
1574
1575 // Grundig 29504-491
1576 ttusb->fe = dvb_attach(tda8083_attach, &ttusb_novas_grundig_29504_491_config, &ttusb->i2c_adap);
1577 if (ttusb->fe != NULL) {
1578 ttusb->fe->ops.tuner_ops.set_params = ttusb_novas_grundig_29504_491_tuner_set_params;
1579 ttusb->fe->ops.set_voltage = ttusb_set_voltage;
1580 break;
1581 }
1582 break;
1583
1584 case 0x1004: // Hauppauge/TT DVB-C budget (ves1820/ALPS TDBE2(sp5659))
1585 ttusb->fe = dvb_attach(ves1820_attach, &alps_tdbe2_config, &ttusb->i2c_adap, read_pwm(ttusb));
1586 if (ttusb->fe != NULL) {
1587 ttusb->fe->ops.tuner_ops.set_params = alps_tdbe2_tuner_set_params;
1588 break;
1589 }
1590
1591 ttusb->fe = dvb_attach(stv0297_attach, &dvbc_philips_tdm1316l_config, &ttusb->i2c_adap);
1592 if (ttusb->fe != NULL) {
1593 ttusb->fe->ops.tuner_ops.set_params = dvbc_philips_tdm1316l_tuner_set_params;
1594 break;
1595 }
1596 break;
1597
1598 case 0x1005: // Hauppauge/TT Nova-USB-t budget (tda10046/Philips td1316(tda6651tt) OR cx22700/ALPS TDMB7(??))
1599 // try the ALPS TDMB7 first
1600 ttusb->fe = dvb_attach(cx22700_attach, &alps_tdmb7_config, &ttusb->i2c_adap);
1601 if (ttusb->fe != NULL) {
1602 ttusb->fe->ops.tuner_ops.set_params = alps_tdmb7_tuner_set_params;
1603 break;
1604 }
1605
1606 // Philips td1316
1607 ttusb->fe = dvb_attach(tda10046_attach, &philips_tdm1316l_config, &ttusb->i2c_adap);
1608 if (ttusb->fe != NULL) {
1609 ttusb->fe->ops.tuner_ops.init = philips_tdm1316l_tuner_init;
1610 ttusb->fe->ops.tuner_ops.set_params = philips_tdm1316l_tuner_set_params;
1611 break;
1612 }
1613 break;
1614 }
1615
1616 if (ttusb->fe == NULL) {
1617 printk("dvb-ttusb-budget: A frontend driver was not found for device [%04x:%04x]\n",
1618 le16_to_cpu(ttusb->dev->descriptor.idVendor),
1619 le16_to_cpu(ttusb->dev->descriptor.idProduct));
1620 } else {
1621 if (dvb_register_frontend(&ttusb->adapter, ttusb->fe)) {
1622 printk("dvb-ttusb-budget: Frontend registration failed!\n");
1623 dvb_frontend_detach(ttusb->fe);
1624 ttusb->fe = NULL;
1625 }
1626 }
1627 }
1628
1629
1630
1631 static struct i2c_algorithm ttusb_dec_algo = {
1632 .master_xfer = master_xfer,
1633 .functionality = functionality,
1634 };
1635
1636 static int ttusb_probe(struct usb_interface *intf, const struct usb_device_id *id)
1637 {
1638 struct usb_device *udev;
1639 struct ttusb *ttusb;
1640 int result;
1641
1642 dprintk("%s: TTUSB DVB connected\n", __func__);
1643
1644 udev = interface_to_usbdev(intf);
1645
1646 if (intf->altsetting->desc.bInterfaceNumber != 1) return -ENODEV;
1647
1648 if (!(ttusb = kzalloc(sizeof(struct ttusb), GFP_KERNEL)))
1649 return -ENOMEM;
1650
1651 ttusb->dev = udev;
1652 ttusb->c = 0;
1653 ttusb->mux_state = 0;
1654 mutex_init(&ttusb->semi2c);
1655
1656 mutex_lock(&ttusb->semi2c);
1657
1658 mutex_init(&ttusb->semusb);
1659
1660 ttusb_setup_interfaces(ttusb);
1661
1662 ttusb_alloc_iso_urbs(ttusb);
1663 if (ttusb_init_controller(ttusb))
1664 printk("ttusb_init_controller: error\n");
1665
1666 mutex_unlock(&ttusb->semi2c);
1667
1668 result = dvb_register_adapter(&ttusb->adapter,
1669 "Technotrend/Hauppauge Nova-USB",
1670 THIS_MODULE, &udev->dev, adapter_nr);
1671 if (result < 0) {
1672 ttusb_free_iso_urbs(ttusb);
1673 kfree(ttusb);
1674 return result;
1675 }
1676 ttusb->adapter.priv = ttusb;
1677
1678 /* i2c */
1679 memset(&ttusb->i2c_adap, 0, sizeof(struct i2c_adapter));
1680 strcpy(ttusb->i2c_adap.name, "TTUSB DEC");
1681
1682 i2c_set_adapdata(&ttusb->i2c_adap, ttusb);
1683
1684 ttusb->i2c_adap.class = I2C_CLASS_TV_DIGITAL;
1685 ttusb->i2c_adap.algo = &ttusb_dec_algo;
1686 ttusb->i2c_adap.algo_data = NULL;
1687 ttusb->i2c_adap.dev.parent = &udev->dev;
1688
1689 result = i2c_add_adapter(&ttusb->i2c_adap);
1690 if (result) {
1691 dvb_unregister_adapter (&ttusb->adapter);
1692 return result;
1693 }
1694
1695 memset(&ttusb->dvb_demux, 0, sizeof(ttusb->dvb_demux));
1696
1697 ttusb->dvb_demux.dmx.capabilities =
1698 DMX_TS_FILTERING | DMX_SECTION_FILTERING;
1699 ttusb->dvb_demux.priv = NULL;
1700 #ifdef TTUSB_HWSECTIONS
1701 ttusb->dvb_demux.filternum = TTUSB_MAXFILTER;
1702 #else
1703 ttusb->dvb_demux.filternum = 32;
1704 #endif
1705 ttusb->dvb_demux.feednum = TTUSB_MAXCHANNEL;
1706 ttusb->dvb_demux.start_feed = ttusb_start_feed;
1707 ttusb->dvb_demux.stop_feed = ttusb_stop_feed;
1708 ttusb->dvb_demux.write_to_decoder = NULL;
1709
1710 if ((result = dvb_dmx_init(&ttusb->dvb_demux)) < 0) {
1711 printk("ttusb_dvb: dvb_dmx_init failed (errno = %d)\n", result);
1712 i2c_del_adapter(&ttusb->i2c_adap);
1713 dvb_unregister_adapter (&ttusb->adapter);
1714 return -ENODEV;
1715 }
1716 //FIXME dmxdev (nur WAS?)
1717 ttusb->dmxdev.filternum = ttusb->dvb_demux.filternum;
1718 ttusb->dmxdev.demux = &ttusb->dvb_demux.dmx;
1719 ttusb->dmxdev.capabilities = 0;
1720
1721 if ((result = dvb_dmxdev_init(&ttusb->dmxdev, &ttusb->adapter)) < 0) {
1722 printk("ttusb_dvb: dvb_dmxdev_init failed (errno = %d)\n",
1723 result);
1724 dvb_dmx_release(&ttusb->dvb_demux);
1725 i2c_del_adapter(&ttusb->i2c_adap);
1726 dvb_unregister_adapter (&ttusb->adapter);
1727 return -ENODEV;
1728 }
1729
1730 if (dvb_net_init(&ttusb->adapter, &ttusb->dvbnet, &ttusb->dvb_demux.dmx)) {
1731 printk("ttusb_dvb: dvb_net_init failed!\n");
1732 dvb_dmxdev_release(&ttusb->dmxdev);
1733 dvb_dmx_release(&ttusb->dvb_demux);
1734 i2c_del_adapter(&ttusb->i2c_adap);
1735 dvb_unregister_adapter (&ttusb->adapter);
1736 return -ENODEV;
1737 }
1738
1739 usb_set_intfdata(intf, (void *) ttusb);
1740
1741 frontend_init(ttusb);
1742
1743 return 0;
1744 }
1745
1746 static void ttusb_disconnect(struct usb_interface *intf)
1747 {
1748 struct ttusb *ttusb = usb_get_intfdata(intf);
1749
1750 usb_set_intfdata(intf, NULL);
1751
1752 ttusb->disconnecting = 1;
1753
1754 ttusb_stop_iso_xfer(ttusb);
1755
1756 ttusb->dvb_demux.dmx.close(&ttusb->dvb_demux.dmx);
1757 dvb_net_release(&ttusb->dvbnet);
1758 dvb_dmxdev_release(&ttusb->dmxdev);
1759 dvb_dmx_release(&ttusb->dvb_demux);
1760 if (ttusb->fe != NULL) {
1761 dvb_unregister_frontend(ttusb->fe);
1762 dvb_frontend_detach(ttusb->fe);
1763 }
1764 i2c_del_adapter(&ttusb->i2c_adap);
1765 dvb_unregister_adapter(&ttusb->adapter);
1766
1767 ttusb_free_iso_urbs(ttusb);
1768
1769 kfree(ttusb);
1770
1771 dprintk("%s: TTUSB DVB disconnected\n", __func__);
1772 }
1773
1774 static struct usb_device_id ttusb_table[] = {
1775 {USB_DEVICE(0xb48, 0x1003)},
1776 {USB_DEVICE(0xb48, 0x1004)},
1777 {USB_DEVICE(0xb48, 0x1005)},
1778 {}
1779 };
1780
1781 MODULE_DEVICE_TABLE(usb, ttusb_table);
1782
1783 static struct usb_driver ttusb_driver = {
1784 .name = "ttusb",
1785 .probe = ttusb_probe,
1786 .disconnect = ttusb_disconnect,
1787 .id_table = ttusb_table,
1788 };
1789
1790 static int __init ttusb_init(void)
1791 {
1792 int err;
1793
1794 if ((err = usb_register(&ttusb_driver)) < 0) {
1795 printk("%s: usb_register failed! Error number %d",
1796 __FILE__, err);
1797 return err;
1798 }
1799
1800 return 0;
1801 }
1802
1803 static void __exit ttusb_exit(void)
1804 {
1805 usb_deregister(&ttusb_driver);
1806 }
1807
1808 module_init(ttusb_init);
1809 module_exit(ttusb_exit);
1810
1811 MODULE_AUTHOR("Holger Waechtler <holger@convergence.de>");
1812 MODULE_DESCRIPTION("TTUSB DVB Driver");
1813 MODULE_LICENSE("GPL");
1814 MODULE_FIRMWARE("ttusb-budget/dspbootcode.bin");
Support for the Chinese Samsung S3C2440 based development boards