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