?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
initial commit with v2.6.9
[linux-2.6.9-moxart.git] / drivers / media / dvb / ttusb-budget / dvb-ttusb-budget.c
blobcc14ec76d43b15a1f5965234b5dcbd76b7dec111
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/module.h>
16 #include <linux/usb.h>
17 #include <linux/delay.h>
18 #include <linux/time.h>
19 #include <linux/errno.h>
20 #include <asm/semaphore.h>
21
22 #include "dvb_frontend.h"
23 #include "dmxdev.h"
24 #include "dvb_demux.h"
25 #include "dvb_net.h"
26
27 #include <linux/dvb/frontend.h>
28 #include <linux/dvb/dmx.h>
29 #include <linux/pci.h>
30
31 #include "dvb_functions.h"
32
33 /*
34 TTUSB_HWSECTIONS:
35 the DSP supports filtering in hardware, however, since the "muxstream"
36 is a bit braindead (no matching channel masks or no matching filter mask),
37 we won't support this - yet. it doesn't event support negative filters,
38 so the best way is maybe to keep TTUSB_HWSECTIONS undef'd and just
39 parse TS data. USB bandwith will be a problem when having large
40 datastreams, especially for dvb-net, but hey, that's not my problem.
41
42 TTUSB_DISEQC, TTUSB_TONE:
43 let the STC do the diseqc/tone stuff. this isn't supported at least with
44 my TTUSB, so let it undef'd unless you want to implement another
45 frontend. never tested.
46
47 DEBUG:
48 define it to > 3 for really hardcore debugging. you probably don't want
49 this unless the device doesn't load at all. > 2 for bandwidth statistics.
50 */
51
52 static int debug = 0;
53
54 #define dprintk(x...) do { if (debug) printk(KERN_DEBUG x); } while (0)
55
56 #define ISO_BUF_COUNT 4
57 #define FRAMES_PER_ISO_BUF 4
58 #define ISO_FRAME_SIZE 912
59 #define TTUSB_MAXCHANNEL 32
60 #ifdef TTUSB_HWSECTIONS
61 #define TTUSB_MAXFILTER 16 /* ??? */
62 #endif
63
64 #define TTUSB_BUDGET_NAME "ttusb_stc_fw"
65
66 /**
67 * since we're casting (struct ttusb*) <-> (struct dvb_demux*) around
68 * the dvb_demux field must be the first in struct!!
69 */
70 struct ttusb {
71 struct dvb_demux dvb_demux;
72 struct dmxdev dmxdev;
73 struct dvb_net dvbnet;
74
75 /* our semaphore, for channel allocation/deallocation */
76 struct semaphore sem;
77 /* and one for USB access. */
78 struct semaphore semusb;
79
80 struct dvb_adapter *adapter;
81 struct usb_device *dev;
82
83 int disconnecting;
84 int iso_streaming;
85
86 unsigned int bulk_out_pipe;
87 unsigned int bulk_in_pipe;
88 unsigned int isoc_in_pipe;
89
90 void *iso_buffer;
91 dma_addr_t iso_dma_handle;
92
93 struct urb *iso_urb[ISO_BUF_COUNT];
94
95 int running_feed_count;
96 int last_channel;
97 int last_filter;
98
99 u8 c; /* transaction counter, wraps around... */
100 fe_sec_tone_mode_t tone;
101 fe_sec_voltage_t voltage;
102
103 int mux_state; // 0..2 - MuxSyncWord, 3 - nMuxPacks, 4 - muxpack
104 u8 mux_npacks;
105 u8 muxpack[256 + 8];
106 int muxpack_ptr, muxpack_len;
107
108 int insync;
109
110 int cc; /* MuxCounter - will increment on EVERY MUX PACKET */
111 /* (including stuffing. yes. really.) */
112
113
114 u8 last_result[32];
115
116 struct ttusb_channel {
117 struct ttusb *ttusb;
118 struct dvb_demux_feed *dvbdmxfeed;
119
120 int active;
121 int id;
122 int pid;
123 int type; /* 1 - TS, 2 - Filter */
124 #ifdef TTUSB_HWSECTIONS
125 int filterstate[TTUSB_MAXFILTER]; /* 0: not busy, 1: busy */
126 #endif
127 } channel[TTUSB_MAXCHANNEL];
128 #if 0
129 devfs_handle_t stc_devfs_handle;
130 #endif
131 };
132
133 /* ugly workaround ... don't know why it's neccessary to read */
134 /* all result codes. */
135
136 #define DEBUG 0
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 #if DEBUG >= 3
143 int i;
144
145 printk(">");
146 for (i = 0; i < len; ++i)
147 printk(" %02x", data[i]);
148 printk("\n");
149 #endif
150
151 if (down_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, HZ);
156 if (err != 0) {
157 dprintk("%s: usb_bulk_msg(send) failed, err == %i!\n",
158 __FUNCTION__, err);
159 up(&ttusb->semusb);
160 return err;
161 }
162 if (actual_len != len) {
163 dprintk("%s: only wrote %d of %d bytes\n", __FUNCTION__,
164 actual_len, len);
165 up(&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, HZ);
171
172 if (err != 0) {
173 printk("%s: failed, receive error %d\n", __FUNCTION__,
174 err);
175 up(&ttusb->semusb);
176 return err;
177 }
178 #if DEBUG >= 3
179 actual_len = ttusb->last_result[3] + 4;
180 printk("<");
181 for (i = 0; i < actual_len; ++i)
182 printk(" %02x", ttusb->last_result[i]);
183 printk("\n");
184 #endif
185 if (!needresult)
186 up(&ttusb->semusb);
187 return 0;
188 }
189
190 static int ttusb_result(struct ttusb *ttusb, u8 * data, int len)
191 {
192 memcpy(data, ttusb->last_result, len);
193 up(&ttusb->semusb);
194 return 0;
195 }
196
197 static int ttusb_i2c_msg(struct ttusb *ttusb,
198 u8 addr, u8 * snd_buf, u8 snd_len, u8 * rcv_buf,
199 u8 rcv_len)
200 {
201 u8 b[0x28];
202 u8 id = ++ttusb->c;
203 int i, err;
204
205 if (snd_len > 0x28 - 7 || rcv_len > 0x20 - 7)
206 return -EINVAL;
207
208 b[0] = 0xaa;
209 b[1] = id;
210 b[2] = 0x31;
211 b[3] = snd_len + 3;
212 b[4] = addr << 1;
213 b[5] = snd_len;
214 b[6] = rcv_len;
215
216 for (i = 0; i < snd_len; i++)
217 b[7 + i] = snd_buf[i];
218
219 err = ttusb_cmd(ttusb, b, snd_len + 7, 1);
220
221 if (err)
222 return -EREMOTEIO;
223
224 err = ttusb_result(ttusb, b, 0x20);
225
226 /* check if the i2c transaction was successful */
227 if ((snd_len != b[5]) || (rcv_len != b[6])) return -EREMOTEIO;
228
229 if (rcv_len > 0) {
230
231 if (err || b[0] != 0x55 || b[1] != id) {
232 dprintk
233 ("%s: usb_bulk_msg(recv) failed, err == %i, id == %02x, b == ",
234 __FUNCTION__, err, id);
235 return -EREMOTEIO;
236 }
237
238 for (i = 0; i < rcv_len; i++)
239 rcv_buf[i] = b[7 + i];
240 }
241
242 return rcv_len;
243 }
244
245 static int ttusb_i2c_xfer(struct dvb_i2c_bus *i2c, const struct i2c_msg msg[],
246 int num)
247 {
248 struct ttusb *ttusb = i2c->data;
249 int i = 0;
250 int inc;
251
252 if (down_interruptible(&ttusb->sem) < 0)
253 return -EAGAIN;
254
255 while (i < num) {
256 u8 addr, snd_len, rcv_len, *snd_buf, *rcv_buf;
257 int err;
258
259 if (num > i + 1 && (msg[i + 1].flags & I2C_M_RD)) {
260 addr = msg[i].addr;
261 snd_buf = msg[i].buf;
262 snd_len = msg[i].len;
263 rcv_buf = msg[i + 1].buf;
264 rcv_len = msg[i + 1].len;
265 inc = 2;
266 } else {
267 addr = msg[i].addr;
268 snd_buf = msg[i].buf;
269 snd_len = msg[i].len;
270 rcv_buf = NULL;
271 rcv_len = 0;
272 inc = 1;
273 }
274
275 err = ttusb_i2c_msg(ttusb, addr,
276 snd_buf, snd_len, rcv_buf, rcv_len);
277
278 if (err < rcv_len) {
279 dprintk("%s: i == %i\n", __FUNCTION__, i);
280 break;
281 }
282
283 i += inc;
284 }
285
286 up(&ttusb->sem);
287 return i;
288 }
289
290 #include "dvb-ttusb-dspbootcode.h"
291
292 static int ttusb_boot_dsp(struct ttusb *ttusb)
293 {
294 int i, err;
295 u8 b[40];
296
297 /* BootBlock */
298 b[0] = 0xaa;
299 b[2] = 0x13;
300 b[3] = 28;
301
302 /* upload dsp code in 32 byte steps (36 didn't work for me ...) */
303 /* 32 is max packet size, no messages should be splitted. */
304 for (i = 0; i < sizeof(dsp_bootcode); i += 28) {
305 memcpy(&b[4], &dsp_bootcode[i], 28);
306
307 b[1] = ++ttusb->c;
308
309 err = ttusb_cmd(ttusb, b, 32, 0);
310 if (err)
311 goto done;
312 }
313
314 /* last block ... */
315 b[1] = ++ttusb->c;
316 b[2] = 0x13;
317 b[3] = 0;
318
319 err = ttusb_cmd(ttusb, b, 4, 0);
320 if (err)
321 goto done;
322
323 /* BootEnd */
324 b[1] = ++ttusb->c;
325 b[2] = 0x14;
326 b[3] = 0;
327
328 err = ttusb_cmd(ttusb, b, 4, 0);
329
330 done:
331 if (err) {
332 dprintk("%s: usb_bulk_msg() failed, return value %i!\n",
333 __FUNCTION__, err);
334 }
335
336 return err;
337 }
338
339 static int ttusb_set_channel(struct ttusb *ttusb, int chan_id, int filter_type,
340 int pid)
341 {
342 int err;
343 /* SetChannel */
344 u8 b[] = { 0xaa, ++ttusb->c, 0x22, 4, chan_id, filter_type,
345 (pid >> 8) & 0xff, pid & 0xff
346 };
347
348 err = ttusb_cmd(ttusb, b, sizeof(b), 0);
349 return err;
350 }
351
352 static int ttusb_del_channel(struct ttusb *ttusb, int channel_id)
353 {
354 int err;
355 /* DelChannel */
356 u8 b[] = { 0xaa, ++ttusb->c, 0x23, 1, channel_id };
357
358 err = ttusb_cmd(ttusb, b, sizeof(b), 0);
359 return err;
360 }
361
362 #ifdef TTUSB_HWSECTIONS
363 static int ttusb_set_filter(struct ttusb *ttusb, int filter_id,
364 int associated_chan, u8 filter[8], u8 mask[8])
365 {
366 int err;
367 /* SetFilter */
368 u8 b[] = { 0xaa, 0, 0x24, 0x1a, filter_id, associated_chan,
369 filter[0], filter[1], filter[2], filter[3],
370 filter[4], filter[5], filter[6], filter[7],
371 filter[8], filter[9], filter[10], filter[11],
372 mask[0], mask[1], mask[2], mask[3],
373 mask[4], mask[5], mask[6], mask[7],
374 mask[8], mask[9], mask[10], mask[11]
375 };
376
377 err = ttusb_cmd(ttusb, b, sizeof(b), 0);
378 return err;
379 }
380
381 static int ttusb_del_filter(struct ttusb *ttusb, int filter_id)
382 {
383 int err;
384 /* DelFilter */
385 u8 b[] = { 0xaa, ++ttusb->c, 0x25, 1, filter_id };
386
387 err = ttusb_cmd(ttusb, b, sizeof(b), 0);
388 return err;
389 }
390 #endif
391
392 static int ttusb_init_controller(struct ttusb *ttusb)
393 {
394 u8 b0[] = { 0xaa, ++ttusb->c, 0x15, 1, 0 };
395 u8 b1[] = { 0xaa, ++ttusb->c, 0x15, 1, 1 };
396 u8 b2[] = { 0xaa, ++ttusb->c, 0x32, 1, 0 };
397 /* i2c write read: 5 bytes, addr 0x10, 0x02 bytes write, 1 bytes read. */
398 u8 b3[] =
399 { 0xaa, ++ttusb->c, 0x31, 5, 0x10, 0x02, 0x01, 0x00, 0x1e };
400 u8 b4[] =
401 { 0x55, ttusb->c, 0x31, 4, 0x10, 0x02, 0x01, 0x00, 0x1e };
402
403 u8 get_version[] = { 0xaa, ++ttusb->c, 0x17, 5, 0, 0, 0, 0, 0 };
404 u8 get_dsp_version[0x20] =
405 { 0xaa, ++ttusb->c, 0x26, 28, 0, 0, 0, 0, 0 };
406 int err;
407
408 /* reset board */
409 if ((err = ttusb_cmd(ttusb, b0, sizeof(b0), 0)))
410 return err;
411
412 /* reset board (again?) */
413 if ((err = ttusb_cmd(ttusb, b1, sizeof(b1), 0)))
414 return err;
415
416 ttusb_boot_dsp(ttusb);
417
418 /* set i2c bit rate */
419 if ((err = ttusb_cmd(ttusb, b2, sizeof(b2), 0)))
420 return err;
421
422 if ((err = ttusb_cmd(ttusb, b3, sizeof(b3), 1)))
423 return err;
424
425 err = ttusb_result(ttusb, b4, sizeof(b4));
426
427 if ((err = ttusb_cmd(ttusb, get_version, sizeof(get_version), 1)))
428 return err;
429
430 if ((err = ttusb_result(ttusb, get_version, sizeof(get_version))))
431 return err;
432
433 dprintk("%s: stc-version: %c%c%c%c%c\n", __FUNCTION__,
434 get_version[4], get_version[5], get_version[6],
435 get_version[7], get_version[8]);
436
437 if (memcmp(get_version + 4, "V 0.0", 5) &&
438 memcmp(get_version + 4, "V 1.1", 5) &&
439 memcmp(get_version + 4, "V 2.1", 5)) {
440 printk
441 ("%s: unknown STC version %c%c%c%c%c, please report!\n",
442 __FUNCTION__, get_version[4], get_version[5],
443 get_version[6], get_version[7], get_version[8]);
444 }
445
446 err =
447 ttusb_cmd(ttusb, get_dsp_version, sizeof(get_dsp_version), 1);
448 if (err)
449 return err;
450
451 err =
452 ttusb_result(ttusb, get_dsp_version, sizeof(get_dsp_version));
453 if (err)
454 return err;
455 printk("%s: dsp-version: %c%c%c\n", __FUNCTION__,
456 get_dsp_version[4], get_dsp_version[5], get_dsp_version[6]);
457 return 0;
458 }
459
460 #ifdef TTUSB_DISEQC
461 static int ttusb_send_diseqc(struct ttusb *ttusb,
462 const struct dvb_diseqc_master_cmd *cmd)
463 {
464 u8 b[12] = { 0xaa, ++ttusb->c, 0x18 };
465
466 int err;
467
468 b[3] = 4 + 2 + cmd->msg_len;
469 b[4] = 0xFF; /* send diseqc master, not burst */
470 b[5] = cmd->msg_len;
471
472 memcpy(b + 5, cmd->msg, cmd->msg_len);
473
474 /* Diseqc */
475 if ((err = ttusb_cmd(ttusb, b, 4 + b[3], 0))) {
476 dprintk("%s: usb_bulk_msg() failed, return value %i!\n",
477 __FUNCTION__, err);
478 }
479
480 return err;
481 }
482 #endif
483
484 static int ttusb_update_lnb(struct ttusb *ttusb)
485 {
486 u8 b[] = { 0xaa, ++ttusb->c, 0x16, 5, /*power: */ 1,
487 ttusb->voltage == SEC_VOLTAGE_18 ? 0 : 1,
488 ttusb->tone == SEC_TONE_ON ? 1 : 0, 1, 1
489 };
490 int err;
491
492 /* SetLNB */
493 if ((err = ttusb_cmd(ttusb, b, sizeof(b), 0))) {
494 dprintk("%s: usb_bulk_msg() failed, return value %i!\n",
495 __FUNCTION__, err);
496 }
497
498 return err;
499 }
500
501 static int ttusb_set_voltage(struct ttusb *ttusb, fe_sec_voltage_t voltage)
502 {
503 ttusb->voltage = voltage;
504 return ttusb_update_lnb(ttusb);
505 }
506
507 #ifdef TTUSB_TONE
508 static int ttusb_set_tone(struct ttusb *ttusb, fe_sec_tone_mode_t tone)
509 {
510 ttusb->tone = tone;
511 return ttusb_update_lnb(ttusb);
512 }
513 #endif
514
515 static int ttusb_lnb_ioctl(struct dvb_frontend *fe, unsigned int cmd, void *arg)
516 {
517 struct ttusb *ttusb = fe->i2c->data;
518
519 switch (cmd) {
520 case FE_SET_VOLTAGE:
521 return ttusb_set_voltage(ttusb, (fe_sec_voltage_t) arg);
522 #ifdef TTUSB_TONE
523 case FE_SET_TONE:
524 return ttusb_set_tone(ttusb, (fe_sec_tone_mode_t) arg);
525 #endif
526 #ifdef TTUSB_DISEQC
527 case FE_DISEQC_SEND_MASTER_CMD:
528 return ttusb_send_diseqc(ttusb,
529 (struct dvb_diseqc_master_cmd *)
530 arg);
531 #endif
532 default:
533 return -EOPNOTSUPP;
534 };
535 }
536
537 #if 0
538 static void ttusb_set_led_freq(struct ttusb *ttusb, u8 freq)
539 {
540 u8 b[] = { 0xaa, ++ttusb->c, 0x19, 1, freq };
541 int err, actual_len;
542
543 err = ttusb_cmd(ttusb, b, sizeof(b), 0);
544 if (err) {
545 dprintk("%s: usb_bulk_msg() failed, return value %i!\n",
546 __FUNCTION__, err);
547 }
548 }
549 #endif
550
551 /*****************************************************************************/
552
553 #ifdef TTUSB_HWSECTIONS
554 static void ttusb_handle_ts_data(struct ttusb_channel *channel,
555 const u8 * data, int len);
556 static void ttusb_handle_sec_data(struct ttusb_channel *channel,
557 const u8 * data, int len);
558 #endif
559
560 int numpkt = 0, lastj, numts, numstuff, numsec, numinvalid;
561
562 static void ttusb_process_muxpack(struct ttusb *ttusb, const u8 * muxpack,
563 int len)
564 {
565 u16 csum = 0, cc;
566 int i;
567 for (i = 0; i < len; i += 2)
568 csum ^= le16_to_cpup((u16 *) (muxpack + i));
569 if (csum) {
570 printk("%s: muxpack with incorrect checksum, ignoring\n",
571 __FUNCTION__);
572 numinvalid++;
573 return;
574 }
575
576 cc = (muxpack[len - 4] << 8) | muxpack[len - 3];
577 cc &= 0x7FFF;
578 if ((cc != ttusb->cc) && (ttusb->cc != -1))
579 printk("%s: cc discontinuity (%d frames missing)\n",
580 __FUNCTION__, (cc - ttusb->cc) & 0x7FFF);
581 ttusb->cc = (cc + 1) & 0x7FFF;
582 if (muxpack[0] & 0x80) {
583 #ifdef TTUSB_HWSECTIONS
584 /* section data */
585 int pusi = muxpack[0] & 0x40;
586 int channel = muxpack[0] & 0x1F;
587 int payload = muxpack[1];
588 const u8 *data = muxpack + 2;
589 /* check offset flag */
590 if (muxpack[0] & 0x20)
591 data++;
592
593 ttusb_handle_sec_data(ttusb->channel + channel, data,
594 payload);
595 data += payload;
596
597 if ((!!(ttusb->muxpack[0] & 0x20)) ^
598 !!(ttusb->muxpack[1] & 1))
599 data++;
600 #warning TODO: pusi
601 printk("cc: %04x\n", (data[0] << 8) | data[1]);
602 #endif
603 numsec++;
604 } else if (muxpack[0] == 0x47) {
605 #ifdef TTUSB_HWSECTIONS
606 /* we have TS data here! */
607 int pid = ((muxpack[1] & 0x0F) << 8) | muxpack[2];
608 int channel;
609 for (channel = 0; channel < TTUSB_MAXCHANNEL; ++channel)
610 if (ttusb->channel[channel].active
611 && (pid == ttusb->channel[channel].pid))
612 ttusb_handle_ts_data(ttusb->channel +
613 channel, muxpack,
614 188);
615 #endif
616 numts++;
617 dvb_dmx_swfilter_packets(&ttusb->dvb_demux, muxpack, 1);
618 } else if (muxpack[0] != 0) {
619 numinvalid++;
620 printk("illegal muxpack type %02x\n", muxpack[0]);
621 } else
622 numstuff++;
623 }
624
625 static void ttusb_process_frame(struct ttusb *ttusb, u8 * data, int len)
626 {
627 int maxwork = 1024;
628 while (len) {
629 if (!(maxwork--)) {
630 printk("%s: too much work\n", __FUNCTION__);
631 break;
632 }
633
634 switch (ttusb->mux_state) {
635 case 0:
636 case 1:
637 case 2:
638 len--;
639 if (*data++ == 0xAA)
640 ++ttusb->mux_state;
641 else {
642 ttusb->mux_state = 0;
643 #if DEBUG > 3
644 if (ttusb->insync)
645 printk("%02x ", data[-1]);
646 #else
647 if (ttusb->insync) {
648 printk("%s: lost sync.\n",
649 __FUNCTION__);
650 ttusb->insync = 0;
651 }
652 #endif
653 }
654 break;
655 case 3:
656 ttusb->insync = 1;
657 len--;
658 ttusb->mux_npacks = *data++;
659 ++ttusb->mux_state;
660 ttusb->muxpack_ptr = 0;
661 /* maximum bytes, until we know the length */
662 ttusb->muxpack_len = 2;
663 break;
664 case 4:
665 {
666 int avail;
667 avail = len;
668 if (avail >
669 (ttusb->muxpack_len -
670 ttusb->muxpack_ptr))
671 avail =
672 ttusb->muxpack_len -
673 ttusb->muxpack_ptr;
674 memcpy(ttusb->muxpack + ttusb->muxpack_ptr,
675 data, avail);
676 ttusb->muxpack_ptr += avail;
677 if (ttusb->muxpack_ptr > 264)
678 BUG();
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 __FUNCTION__,
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, struct pt_regs *ptregs)
750 {
751 struct ttusb *ttusb = urb->context;
752
753 if (!ttusb->iso_streaming)
754 return;
755
756 #if 0
757 printk("%s: status %d, errcount == %d, length == %i\n",
758 __FUNCTION__,
759 urb->status, urb->error_count, urb->actual_length);
760 #endif
761
762 if (!urb->status) {
763 int i;
764 for (i = 0; i < urb->number_of_packets; ++i) {
765 struct usb_iso_packet_descriptor *d;
766 u8 *data;
767 int len;
768 numpkt++;
769 if ((jiffies - lastj) >= HZ) {
770 #if DEBUG > 2
771 printk
772 ("frames/s: %d (ts: %d, stuff %d, sec: %d, invalid: %d, all: %d)\n",
773 numpkt * HZ / (jiffies - lastj),
774 numts, numstuff, numsec, numinvalid,
775 numts + numstuff + numsec +
776 numinvalid);
777 #endif
778 numts = numstuff = numsec = numinvalid = 0;
779 lastj = jiffies;
780 numpkt = 0;
781 }
782 d = &urb->iso_frame_desc[i];
783 data = urb->transfer_buffer + d->offset;
784 len = d->actual_length;
785 d->actual_length = 0;
786 d->status = 0;
787 ttusb_process_frame(ttusb, data, len);
788 }
789 }
790 usb_submit_urb(urb, GFP_KERNEL);
791 }
792
793 static void ttusb_free_iso_urbs(struct ttusb *ttusb)
794 {
795 int i;
796
797 for (i = 0; i < ISO_BUF_COUNT; i++)
798 if (ttusb->iso_urb[i])
799 usb_free_urb(ttusb->iso_urb[i]);
800
801 pci_free_consistent(NULL,
802 ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF *
803 ISO_BUF_COUNT, ttusb->iso_buffer,
804 ttusb->iso_dma_handle);
805 }
806
807 static int ttusb_alloc_iso_urbs(struct ttusb *ttusb)
808 {
809 int i;
810
811 ttusb->iso_buffer = pci_alloc_consistent(NULL,
812 ISO_FRAME_SIZE *
813 FRAMES_PER_ISO_BUF *
814 ISO_BUF_COUNT,
815 &ttusb->iso_dma_handle);
816
817 memset(ttusb->iso_buffer, 0,
818 ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF * ISO_BUF_COUNT);
819
820 for (i = 0; i < ISO_BUF_COUNT; i++) {
821 struct urb *urb;
822
823 if (!
824 (urb =
825 usb_alloc_urb(FRAMES_PER_ISO_BUF, GFP_KERNEL))) {
826 ttusb_free_iso_urbs(ttusb);
827 return -ENOMEM;
828 }
829
830 ttusb->iso_urb[i] = urb;
831 }
832
833 return 0;
834 }
835
836 static void ttusb_stop_iso_xfer(struct ttusb *ttusb)
837 {
838 int i;
839
840 for (i = 0; i < ISO_BUF_COUNT; i++)
841 usb_unlink_urb(ttusb->iso_urb[i]);
842
843 ttusb->iso_streaming = 0;
844 }
845
846 static int ttusb_start_iso_xfer(struct ttusb *ttusb)
847 {
848 int i, j, err, buffer_offset = 0;
849
850 if (ttusb->iso_streaming) {
851 printk("%s: iso xfer already running!\n", __FUNCTION__);
852 return 0;
853 }
854
855 ttusb->cc = -1;
856 ttusb->insync = 0;
857 ttusb->mux_state = 0;
858
859 for (i = 0; i < ISO_BUF_COUNT; i++) {
860 int frame_offset = 0;
861 struct urb *urb = ttusb->iso_urb[i];
862
863 urb->dev = ttusb->dev;
864 urb->context = ttusb;
865 urb->complete = ttusb_iso_irq;
866 urb->pipe = ttusb->isoc_in_pipe;
867 urb->transfer_flags = URB_ISO_ASAP;
868 urb->interval = 1;
869 urb->number_of_packets = FRAMES_PER_ISO_BUF;
870 urb->transfer_buffer_length =
871 ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF;
872 urb->transfer_buffer = ttusb->iso_buffer + buffer_offset;
873 buffer_offset += ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF;
874
875 for (j = 0; j < FRAMES_PER_ISO_BUF; j++) {
876 urb->iso_frame_desc[j].offset = frame_offset;
877 urb->iso_frame_desc[j].length = ISO_FRAME_SIZE;
878 frame_offset += ISO_FRAME_SIZE;
879 }
880 }
881
882 for (i = 0; i < ISO_BUF_COUNT; i++) {
883 if ((err = usb_submit_urb(ttusb->iso_urb[i], GFP_KERNEL))) {
884 ttusb_stop_iso_xfer(ttusb);
885 printk
886 ("%s: failed urb submission (%i: err = %i)!\n",
887 __FUNCTION__, i, err);
888 return err;
889 }
890 }
891
892 ttusb->iso_streaming = 1;
893
894 return 0;
895 }
896
897 #ifdef TTUSB_HWSECTIONS
898 static void ttusb_handle_ts_data(struct ttusb_channel *channel, const u8 * data,
899 int len)
900 {
901 struct dvb_demux_feed *dvbdmxfeed = channel->dvbdmxfeed;
902
903 dvbdmxfeed->cb.ts(data, len, 0, 0, &dvbdmxfeed->feed.ts, 0);
904 }
905
906 static void ttusb_handle_sec_data(struct ttusb_channel *channel, 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 struct ttusb_channel *ttusb_channel_allocate(struct ttusb *ttusb)
916 {
917 int i;
918
919 if (down_interruptible(&ttusb->sem))
920 return NULL;
921
922 /* lock! */
923 for (i = 0; i < TTUSB_MAXCHANNEL; ++i) {
924 if (!ttusb->channel[i].active) {
925 ttusb->channel[i].active = 1;
926 up(&ttusb->sem);
927 return ttusb->channel + i;
928 }
929 }
930
931 up(&ttusb->sem);
932
933 return NULL;
934 }
935
936 static int ttusb_start_feed(struct dvb_demux_feed *dvbdmxfeed)
937 {
938 struct ttusb *ttusb = (struct ttusb *) dvbdmxfeed->demux;
939 struct ttusb_channel *channel;
940
941 dprintk("ttusb_start_feed\n");
942
943 switch (dvbdmxfeed->type) {
944 case DMX_TYPE_TS:
945 break;
946 case DMX_TYPE_SEC:
947 break;
948 default:
949 return -EINVAL;
950 }
951
952 if (dvbdmxfeed->type == DMX_TYPE_TS) {
953 switch (dvbdmxfeed->pes_type) {
954 case DMX_TS_PES_VIDEO:
955 case DMX_TS_PES_AUDIO:
956 case DMX_TS_PES_TELETEXT:
957 case DMX_TS_PES_PCR:
958 case DMX_TS_PES_OTHER:
959 channel = ttusb_channel_allocate(ttusb);
960 break;
961 default:
962 return -EINVAL;
963 }
964 } else {
965 channel = ttusb_channel_allocate(ttusb);
966 }
967
968 if (!channel)
969 return -EBUSY;
970
971 dvbdmxfeed->priv = channel;
972 channel->dvbdmxfeed = dvbdmxfeed;
973
974 channel->pid = dvbdmxfeed->pid;
975
976 #ifdef TTUSB_HWSECTIONS
977 if (dvbdmxfeed->type == DMX_TYPE_TS) {
978 channel->type = 1;
979 } else if (dvbdmxfeed->type == DMX_TYPE_SEC) {
980 channel->type = 2;
981 #error TODO: allocate filters
982 }
983 #else
984 channel->type = 1;
985 #endif
986
987 ttusb_set_channel(ttusb, channel->id, channel->type, channel->pid);
988
989 if (0 == ttusb->running_feed_count++)
990 ttusb_start_iso_xfer(ttusb);
991
992 return 0;
993 }
994
995 static int ttusb_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
996 {
997 struct ttusb_channel *channel =
998 (struct ttusb_channel *) dvbdmxfeed->priv;
999 struct ttusb *ttusb = (struct ttusb *) dvbdmxfeed->demux;
1000
1001 ttusb_del_channel(channel->ttusb, channel->id);
1002
1003 if (--ttusb->running_feed_count == 0)
1004 ttusb_stop_iso_xfer(ttusb);
1005
1006 channel->active = 0;
1007
1008 return 0;
1009 }
1010
1011 static int ttusb_setup_interfaces(struct ttusb *ttusb)
1012 {
1013 usb_set_interface(ttusb->dev, 1, 1);
1014
1015 ttusb->bulk_out_pipe = usb_sndbulkpipe(ttusb->dev, 1);
1016 ttusb->bulk_in_pipe = usb_rcvbulkpipe(ttusb->dev, 1);
1017 ttusb->isoc_in_pipe = usb_rcvisocpipe(ttusb->dev, 2);
1018
1019 return 0;
1020 }
1021
1022 #if 0
1023 static u8 stc_firmware[8192];
1024
1025 static int stc_open(struct inode *inode, struct file *file)
1026 {
1027 struct ttusb *ttusb = file->private_data;
1028 int addr;
1029
1030 for (addr = 0; addr < 8192; addr += 16) {
1031 u8 snd_buf[2] = { addr >> 8, addr & 0xFF };
1032 ttusb_i2c_msg(ttusb, 0x50, snd_buf, 2, stc_firmware + addr,
1033 16);
1034 }
1035
1036 return 0;
1037 }
1038
1039 static ssize_t stc_read(struct file *file, char *buf, size_t count,
1040 loff_t * offset)
1041 {
1042 int tc = count;
1043
1044 if ((tc + *offset) > 8192)
1045 tc = 8192 - *offset;
1046
1047 if (tc < 0)
1048 return 0;
1049
1050 if (copy_to_user(buf, stc_firmware + *offset, tc))
1051 return -EFAULT;
1052
1053 *offset += tc;
1054
1055 return tc;
1056 }
1057
1058 static int stc_release(struct inode *inode, struct file *file)
1059 {
1060 return 0;
1061 }
1062
1063 static struct file_operations stc_fops = {
1064 .owner = THIS_MODULE,
1065 .read = stc_read,
1066 .open = stc_open,
1067 .release = stc_release,
1068 };
1069 #endif
1070
1071 static int ttusb_probe(struct usb_interface *intf, const struct usb_device_id *id)
1072 {
1073 struct usb_device *udev;
1074 struct ttusb *ttusb;
1075 int result, channel;
1076
1077 dprintk("%s: TTUSB DVB connected\n", __FUNCTION__);
1078
1079 udev = interface_to_usbdev(intf);
1080
1081 /* Device has already been reset; its configuration was chosen.
1082 * If this fault happens, use a hotplug script to choose the
1083 * right configuration (write bConfigurationValue in sysfs).
1084 */
1085 if (udev->actconfig->desc.bConfigurationValue != 1) {
1086 dev_err(&intf->dev, "device config is #%d, need #1\n",
1087 udev->actconfig->desc.bConfigurationValue);
1088 return -ENODEV;
1089 }
1090
1091
1092 if (intf->altsetting->desc.bInterfaceNumber != 1) return -ENODEV;
1093
1094 if (!(ttusb = kmalloc(sizeof(struct ttusb), GFP_KERNEL)))
1095 return -ENOMEM;
1096
1097 memset(ttusb, 0, sizeof(struct ttusb));
1098
1099 for (channel = 0; channel < TTUSB_MAXCHANNEL; ++channel) {
1100 ttusb->channel[channel].id = channel;
1101 ttusb->channel[channel].ttusb = ttusb;
1102 }
1103
1104 ttusb->dev = udev;
1105 ttusb->c = 0;
1106 ttusb->mux_state = 0;
1107 sema_init(&ttusb->sem, 0);
1108 sema_init(&ttusb->semusb, 1);
1109
1110 ttusb_setup_interfaces(ttusb);
1111
1112 ttusb_alloc_iso_urbs(ttusb);
1113 if (ttusb_init_controller(ttusb))
1114 printk("ttusb_init_controller: error\n");
1115
1116 up(&ttusb->sem);
1117
1118 dvb_register_adapter(&ttusb->adapter, "Technotrend/Hauppauge Nova-USB", THIS_MODULE);
1119
1120 dvb_register_i2c_bus(ttusb_i2c_xfer, ttusb, ttusb->adapter, 0);
1121 dvb_add_frontend_ioctls(ttusb->adapter, ttusb_lnb_ioctl, NULL,
1122 ttusb);
1123
1124 memset(&ttusb->dvb_demux, 0, sizeof(ttusb->dvb_demux));
1125
1126 ttusb->dvb_demux.dmx.capabilities =
1127 DMX_TS_FILTERING | DMX_SECTION_FILTERING;
1128 ttusb->dvb_demux.priv = NULL;
1129 #ifdef TTUSB_HWSECTIONS
1130 ttusb->dvb_demux.filternum = TTUSB_MAXFILTER;
1131 #else
1132 ttusb->dvb_demux.filternum = 32;
1133 #endif
1134 ttusb->dvb_demux.feednum = TTUSB_MAXCHANNEL;
1135 ttusb->dvb_demux.start_feed = ttusb_start_feed;
1136 ttusb->dvb_demux.stop_feed = ttusb_stop_feed;
1137 ttusb->dvb_demux.write_to_decoder = NULL;
1138
1139 if ((result = dvb_dmx_init(&ttusb->dvb_demux)) < 0) {
1140 printk("ttusb_dvb: dvb_dmx_init failed (errno = %d)\n",
1141 result);
1142 goto err;
1143 }
1144 //FIXME dmxdev (nur WAS?)
1145 ttusb->dmxdev.filternum = ttusb->dvb_demux.filternum;
1146 ttusb->dmxdev.demux = &ttusb->dvb_demux.dmx;
1147 ttusb->dmxdev.capabilities = 0;
1148
1149 if ((result = dvb_dmxdev_init(&ttusb->dmxdev, ttusb->adapter)) < 0) {
1150 printk("ttusb_dvb: dvb_dmxdev_init failed (errno = %d)\n",
1151 result);
1152 dvb_dmx_release(&ttusb->dvb_demux);
1153 goto err;
1154 }
1155
1156 if (dvb_net_init
1157 (ttusb->adapter, &ttusb->dvbnet, &ttusb->dvb_demux.dmx)) {
1158 printk("ttusb_dvb: dvb_net_init failed!\n");
1159 }
1160
1161 err:
1162 #if 0
1163 ttusb->stc_devfs_handle =
1164 devfs_register(ttusb->adapter->devfs_handle, TTUSB_BUDGET_NAME,
1165 DEVFS_FL_DEFAULT, 0, 192,
1166 S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP
1167 | S_IROTH | S_IWOTH, &stc_fops, ttusb);
1168 #endif
1169
1170 usb_set_intfdata(intf, (void *) ttusb);
1171
1172 return 0;
1173 }
1174
1175 static void ttusb_disconnect(struct usb_interface *intf)
1176 {
1177 struct ttusb *ttusb = usb_get_intfdata(intf);
1178
1179 usb_set_intfdata(intf, NULL);
1180
1181 ttusb->disconnecting = 1;
1182
1183 ttusb_stop_iso_xfer(ttusb);
1184
1185 ttusb->dvb_demux.dmx.close(&ttusb->dvb_demux.dmx);
1186 dvb_net_release(&ttusb->dvbnet);
1187 dvb_dmxdev_release(&ttusb->dmxdev);
1188 dvb_dmx_release(&ttusb->dvb_demux);
1189
1190 dvb_unregister_i2c_bus(ttusb_i2c_xfer, ttusb->adapter, 0);
1191 dvb_unregister_adapter(ttusb->adapter);
1192
1193 ttusb_free_iso_urbs(ttusb);
1194
1195 kfree(ttusb);
1196
1197 dprintk("%s: TTUSB DVB disconnected\n", __FUNCTION__);
1198 }
1199
1200 static struct usb_device_id ttusb_table[] = {
1201 {USB_DEVICE(0xb48, 0x1003)},
1202 {USB_DEVICE(0xb48, 0x1004)}, /* to be confirmed ???? */
1203 {USB_DEVICE(0xb48, 0x1005)},
1204 {}
1205 };
1206
1207 MODULE_DEVICE_TABLE(usb, ttusb_table);
1208
1209 static struct usb_driver ttusb_driver = {
1210 .name = "Technotrend/Hauppauge USB-Nova",
1211 .probe = ttusb_probe,
1212 .disconnect = ttusb_disconnect,
1213 .id_table = ttusb_table,
1214 };
1215
1216 static int __init ttusb_init(void)
1217 {
1218 int err;
1219
1220 if ((err = usb_register(&ttusb_driver)) < 0) {
1221 printk("%s: usb_register failed! Error number %d",
1222 __FILE__, err);
1223 return err;
1224 }
1225
1226 return 0;
1227 }
1228
1229 static void __exit ttusb_exit(void)
1230 {
1231 usb_deregister(&ttusb_driver);
1232 }
1233
1234 module_init(ttusb_init);
1235 module_exit(ttusb_exit);
1236
1237 MODULE_PARM(debug, "i");
1238 MODULE_PARM_DESC(debug, "Debug or not");
1239
1240 MODULE_AUTHOR("Holger Waechtler <holger@convergence.de>");
1241 MODULE_DESCRIPTION("TTUSB DVB Driver");
1242 MODULE_LICENSE("GPL");
MOXA 2.6.9 from sdlinux-moxaart.tgz