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