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