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