1 /*
2  *  Driver for the NXP SAA7164 PCIe bridge
3  *
4  *  Copyright (c) 2010-2015 Steven Toth <stoth@kernellabs.com>
5  *
6  *  This program is free software; you can redistribute it and/or modify
7  *  it under the terms of the GNU General Public License as published by
8  *  the Free Software Foundation; either version 2 of the License, or
9  *  (at your option) any later version.
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *
15  *  GNU General Public License for more details.
16  *
17  *  You should have received a copy of the GNU General Public License
18  *  along with this program; if not, write to the Free Software
19  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20  */
21 
22 #include <linux/init.h>
23 #include <linux/list.h>
24 #include <linux/module.h>
25 #include <linux/moduleparam.h>
26 #include <linux/kmod.h>
27 #include <linux/kernel.h>
28 #include <linux/slab.h>
29 #include <linux/interrupt.h>
30 #include <linux/delay.h>
31 #include <asm/div64.h>
32 
33 #ifdef CONFIG_PROC_FS
34 #include <linux/proc_fs.h>
35 #endif
36 #include "saa7164.h"
37 
38 MODULE_DESCRIPTION("Driver for NXP SAA7164 based TV cards");
39 MODULE_AUTHOR("Steven Toth <stoth@kernellabs.com>");
40 MODULE_LICENSE("GPL");
41 
42 /*
43  *  1 Basic
44  *  2
45  *  4 i2c
46  *  8 api
47  * 16 cmd
48  * 32 bus
49  */
50 
51 unsigned int saa_debug;
52 module_param_named(debug, saa_debug, int, 0644);
53 MODULE_PARM_DESC(debug, "enable debug messages");
54 
55 static unsigned int fw_debug;
56 module_param(fw_debug, int, 0644);
57 MODULE_PARM_DESC(fw_debug, "Firmware debug level def:2");
58 
59 unsigned int encoder_buffers = SAA7164_MAX_ENCODER_BUFFERS;
60 module_param(encoder_buffers, int, 0644);
61 MODULE_PARM_DESC(encoder_buffers, "Total buffers in read queue 16-512 def:64");
62 
63 unsigned int vbi_buffers = SAA7164_MAX_VBI_BUFFERS;
64 module_param(vbi_buffers, int, 0644);
65 MODULE_PARM_DESC(vbi_buffers, "Total buffers in read queue 16-512 def:64");
66 
67 unsigned int waitsecs = 10;
68 module_param(waitsecs, int, 0644);
69 MODULE_PARM_DESC(waitsecs, "timeout on firmware messages");
70 
71 static unsigned int card[]  = {[0 ... (SAA7164_MAXBOARDS - 1)] = UNSET };
72 module_param_array(card,  int, NULL, 0444);
73 MODULE_PARM_DESC(card, "card type");
74 
75 static unsigned int print_histogram = 64;
76 module_param(print_histogram, int, 0644);
77 MODULE_PARM_DESC(print_histogram, "print histogram values once");
78 
79 unsigned int crc_checking = 1;
80 module_param(crc_checking, int, 0644);
81 MODULE_PARM_DESC(crc_checking, "enable crc sanity checking on buffers");
82 
83 static unsigned int guard_checking = 1;
84 module_param(guard_checking, int, 0644);
85 MODULE_PARM_DESC(guard_checking,
86 	"enable dma sanity checking for buffer overruns");
87 
88 static bool enable_msi = true;
89 module_param(enable_msi, bool, 0444);
90 MODULE_PARM_DESC(enable_msi,
91 		"enable the use of an msi interrupt if available");
92 
93 static unsigned int saa7164_devcount;
94 
95 static DEFINE_MUTEX(devlist);
96 LIST_HEAD(saa7164_devlist);
97 
98 #define INT_SIZE 16
99 
100 static void saa7164_pack_verifier(struct saa7164_buffer *buf)
101 {
102 	u8 *p = (u8 *)buf->cpu;
103 	int i;
104 
105 	for (i = 0; i < buf->actual_size; i += 2048) {
106 
107 		if ((*(p + i + 0) != 0x00) || (*(p + i + 1) != 0x00) ||
108 			(*(p + i + 2) != 0x01) || (*(p + i + 3) != 0xBA)) {
109 			printk(KERN_ERR "No pack at 0x%x\n", i);
110 #if 0
111 			print_hex_dump(KERN_INFO, "", DUMP_PREFIX_OFFSET, 16, 1,
112 				       p + 1, 32, false);
113 #endif
114 		}
115 	}
116 }
117 
118 #define FIXED_VIDEO_PID 0xf1
119 #define FIXED_AUDIO_PID 0xf2
120 
121 static void saa7164_ts_verifier(struct saa7164_buffer *buf)
122 {
123 	struct saa7164_port *port = buf->port;
124 	u32 i;
125 	u8 cc, a;
126 	u16 pid;
127 	u8 *bufcpu = (u8 *)buf->cpu;
128 
129 	port->sync_errors = 0;
130 	port->v_cc_errors = 0;
131 	port->a_cc_errors = 0;
132 
133 	for (i = 0; i < buf->actual_size; i += 188) {
134 		if (*(bufcpu + i) != 0x47)
135 			port->sync_errors++;
136 
137 		/* TODO: Query pid lower 8 bits, ignoring upper bits intensionally */
138 		pid = ((*(bufcpu + i + 1) & 0x1f) << 8) | *(bufcpu + i + 2);
139 		cc = *(bufcpu + i + 3) & 0x0f;
140 
141 		if (pid == FIXED_VIDEO_PID) {
142 			a = ((port->last_v_cc + 1) & 0x0f);
143 			if (a != cc) {
144 				printk(KERN_ERR "video cc last = %x current = %x i = %d\n",
145 					port->last_v_cc, cc, i);
146 				port->v_cc_errors++;
147 			}
148 
149 			port->last_v_cc = cc;
150 		} else
151 		if (pid == FIXED_AUDIO_PID) {
152 			a = ((port->last_a_cc + 1) & 0x0f);
153 			if (a != cc) {
154 				printk(KERN_ERR "audio cc last = %x current = %x i = %d\n",
155 					port->last_a_cc, cc, i);
156 				port->a_cc_errors++;
157 			}
158 
159 			port->last_a_cc = cc;
160 		}
161 
162 	}
163 
164 	/* Only report errors if we've been through this function atleast
165 	 * once already and the cached cc values are primed. First time through
166 	 * always generates errors.
167 	 */
168 	if (port->v_cc_errors && (port->done_first_interrupt > 1))
169 		printk(KERN_ERR "video pid cc, %d errors\n", port->v_cc_errors);
170 
171 	if (port->a_cc_errors && (port->done_first_interrupt > 1))
172 		printk(KERN_ERR "audio pid cc, %d errors\n", port->a_cc_errors);
173 
174 	if (port->sync_errors && (port->done_first_interrupt > 1))
175 		printk(KERN_ERR "sync_errors = %d\n", port->sync_errors);
176 
177 	if (port->done_first_interrupt == 1)
178 		port->done_first_interrupt++;
179 }
180 
181 static void saa7164_histogram_reset(struct saa7164_histogram *hg, char *name)
182 {
183 	int i;
184 
185 	memset(hg, 0, sizeof(struct saa7164_histogram));
186 	strcpy(hg->name, name);
187 
188 	/* First 30ms x 1ms */
189 	for (i = 0; i < 30; i++)
190 		hg->counter1[0 + i].val = i;
191 
192 	/* 30 - 200ms x 10ms  */
193 	for (i = 0; i < 18; i++)
194 		hg->counter1[30 + i].val = 30 + (i * 10);
195 
196 	/* 200 - 2000ms x 100ms  */
197 	for (i = 0; i < 15; i++)
198 		hg->counter1[48 + i].val = 200 + (i * 200);
199 
200 	/* Catch all massive value (2secs) */
201 	hg->counter1[55].val = 2000;
202 
203 	/* Catch all massive value (4secs) */
204 	hg->counter1[56].val = 4000;
205 
206 	/* Catch all massive value (8secs) */
207 	hg->counter1[57].val = 8000;
208 
209 	/* Catch all massive value (15secs) */
210 	hg->counter1[58].val = 15000;
211 
212 	/* Catch all massive value (30secs) */
213 	hg->counter1[59].val = 30000;
214 
215 	/* Catch all massive value (60secs) */
216 	hg->counter1[60].val = 60000;
217 
218 	/* Catch all massive value (5mins) */
219 	hg->counter1[61].val = 300000;
220 
221 	/* Catch all massive value (15mins) */
222 	hg->counter1[62].val = 900000;
223 
224 	/* Catch all massive values (1hr) */
225 	hg->counter1[63].val = 3600000;
226 }
227 
228 void saa7164_histogram_update(struct saa7164_histogram *hg, u32 val)
229 {
230 	int i;
231 	for (i = 0; i < 64; i++) {
232 		if (val <= hg->counter1[i].val) {
233 			hg->counter1[i].count++;
234 			hg->counter1[i].update_time = jiffies;
235 			break;
236 		}
237 	}
238 }
239 
240 static void saa7164_histogram_print(struct saa7164_port *port,
241 	struct saa7164_histogram *hg)
242 {
243 	u32 entries = 0;
244 	int i;
245 
246 	printk(KERN_ERR "Histogram named %s (ms, count, last_update_jiffy)\n", hg->name);
247 	for (i = 0; i < 64; i++) {
248 		if (hg->counter1[i].count == 0)
249 			continue;
250 
251 		printk(KERN_ERR " %4d %12d %Ld\n",
252 			hg->counter1[i].val,
253 			hg->counter1[i].count,
254 			hg->counter1[i].update_time);
255 
256 		entries++;
257 	}
258 	printk(KERN_ERR "Total: %d\n", entries);
259 }
260 
261 static void saa7164_work_enchandler_helper(struct saa7164_port *port, int bufnr)
262 {
263 	struct saa7164_dev *dev = port->dev;
264 	struct saa7164_buffer *buf = NULL;
265 	struct saa7164_user_buffer *ubuf = NULL;
266 	struct list_head *c, *n;
267 	int i = 0;
268 	u8 *p;
269 
270 	mutex_lock(&port->dmaqueue_lock);
271 	list_for_each_safe(c, n, &port->dmaqueue.list) {
272 
273 		buf = list_entry(c, struct saa7164_buffer, list);
274 		if (i++ > port->hwcfg.buffercount) {
275 			printk(KERN_ERR "%s() illegal i count %d\n",
276 				__func__, i);
277 			break;
278 		}
279 
280 		if (buf->idx == bufnr) {
281 
282 			/* Found the buffer, deal with it */
283 			dprintk(DBGLVL_IRQ, "%s() bufnr: %d\n", __func__, bufnr);
284 
285 			if (crc_checking) {
286 				/* Throw a new checksum on the dma buffer */
287 				buf->crc = crc32(0, buf->cpu, buf->actual_size);
288 			}
289 
290 			if (guard_checking) {
291 				p = (u8 *)buf->cpu;
292 				if ((*(p + buf->actual_size + 0) != 0xff) ||
293 					(*(p + buf->actual_size + 1) != 0xff) ||
294 					(*(p + buf->actual_size + 2) != 0xff) ||
295 					(*(p + buf->actual_size + 3) != 0xff) ||
296 					(*(p + buf->actual_size + 0x10) != 0xff) ||
297 					(*(p + buf->actual_size + 0x11) != 0xff) ||
298 					(*(p + buf->actual_size + 0x12) != 0xff) ||
299 					(*(p + buf->actual_size + 0x13) != 0xff)) {
300 						printk(KERN_ERR "%s() buf %p guard buffer breach\n",
301 							__func__, buf);
302 #if 0
303 			print_hex_dump(KERN_INFO, "", DUMP_PREFIX_OFFSET, 16, 1,
304 				       p + buf->actual_size - 32, 64, false);
305 #endif
306 				}
307 			}
308 
309 			if ((port->nr != SAA7164_PORT_VBI1) && (port->nr != SAA7164_PORT_VBI2)) {
310 				/* Validate the incoming buffer content */
311 				if (port->encoder_params.stream_type == V4L2_MPEG_STREAM_TYPE_MPEG2_TS)
312 					saa7164_ts_verifier(buf);
313 				else if (port->encoder_params.stream_type == V4L2_MPEG_STREAM_TYPE_MPEG2_PS)
314 					saa7164_pack_verifier(buf);
315 			}
316 
317 			/* find a free user buffer and clone to it */
318 			if (!list_empty(&port->list_buf_free.list)) {
319 
320 				/* Pull the first buffer from the used list */
321 				ubuf = list_first_entry(&port->list_buf_free.list,
322 					struct saa7164_user_buffer, list);
323 
324 				if (buf->actual_size <= ubuf->actual_size) {
325 
326 					memcpy(ubuf->data, buf->cpu, ubuf->actual_size);
327 
328 					if (crc_checking) {
329 						/* Throw a new checksum on the read buffer */
330 						ubuf->crc = crc32(0, ubuf->data, ubuf->actual_size);
331 					}
332 
333 					/* Requeue the buffer on the free list */
334 					ubuf->pos = 0;
335 
336 					list_move_tail(&ubuf->list,
337 						&port->list_buf_used.list);
338 
339 					/* Flag any userland waiters */
340 					wake_up_interruptible(&port->wait_read);
341 
342 				} else {
343 					printk(KERN_ERR "buf %p bufsize fails match\n", buf);
344 				}
345 
346 			} else
347 				printk(KERN_ERR "encirq no free buffers, increase param encoder_buffers\n");
348 
349 			/* Ensure offset into buffer remains 0, fill buffer
350 			 * with known bad data. We check for this data at a later point
351 			 * in time. */
352 			saa7164_buffer_zero_offsets(port, bufnr);
353 			memset(buf->cpu, 0xff, buf->pci_size);
354 			if (crc_checking) {
355 				/* Throw yet aanother new checksum on the dma buffer */
356 				buf->crc = crc32(0, buf->cpu, buf->actual_size);
357 			}
358 
359 			break;
360 		}
361 	}
362 	mutex_unlock(&port->dmaqueue_lock);
363 }
364 
365 static void saa7164_work_enchandler(struct work_struct *w)
366 {
367 	struct saa7164_port *port =
368 		container_of(w, struct saa7164_port, workenc);
369 	struct saa7164_dev *dev = port->dev;
370 
371 	u32 wp, mcb, rp, cnt = 0;
372 
373 	port->last_svc_msecs_diff = port->last_svc_msecs;
374 	port->last_svc_msecs = jiffies_to_msecs(jiffies);
375 
376 	port->last_svc_msecs_diff = port->last_svc_msecs -
377 		port->last_svc_msecs_diff;
378 
379 	saa7164_histogram_update(&port->svc_interval,
380 		port->last_svc_msecs_diff);
381 
382 	port->last_irq_svc_msecs_diff = port->last_svc_msecs -
383 		port->last_irq_msecs;
384 
385 	saa7164_histogram_update(&port->irq_svc_interval,
386 		port->last_irq_svc_msecs_diff);
387 
388 	dprintk(DBGLVL_IRQ,
389 		"%s() %Ldms elapsed irq->deferred %Ldms wp: %d rp: %d\n",
390 		__func__,
391 		port->last_svc_msecs_diff,
392 		port->last_irq_svc_msecs_diff,
393 		port->last_svc_wp,
394 		port->last_svc_rp
395 		);
396 
397 	/* Current write position */
398 	wp = saa7164_readl(port->bufcounter);
399 	if (wp > (port->hwcfg.buffercount - 1)) {
400 		printk(KERN_ERR "%s() illegal buf count %d\n", __func__, wp);
401 		return;
402 	}
403 
404 	/* Most current complete buffer */
405 	if (wp == 0)
406 		mcb = (port->hwcfg.buffercount - 1);
407 	else
408 		mcb = wp - 1;
409 
410 	while (1) {
411 		if (port->done_first_interrupt == 0) {
412 			port->done_first_interrupt++;
413 			rp = mcb;
414 		} else
415 			rp = (port->last_svc_rp + 1) % 8;
416 
417 		if (rp > (port->hwcfg.buffercount - 1)) {
418 			printk(KERN_ERR "%s() illegal rp count %d\n", __func__, rp);
419 			break;
420 		}
421 
422 		saa7164_work_enchandler_helper(port, rp);
423 		port->last_svc_rp = rp;
424 		cnt++;
425 
426 		if (rp == mcb)
427 			break;
428 	}
429 
430 	/* TODO: Convert this into a /proc/saa7164 style readable file */
431 	if (print_histogram == port->nr) {
432 		saa7164_histogram_print(port, &port->irq_interval);
433 		saa7164_histogram_print(port, &port->svc_interval);
434 		saa7164_histogram_print(port, &port->irq_svc_interval);
435 		saa7164_histogram_print(port, &port->read_interval);
436 		saa7164_histogram_print(port, &port->poll_interval);
437 		/* TODO: fix this to preserve any previous state */
438 		print_histogram = 64 + port->nr;
439 	}
440 }
441 
442 static void saa7164_work_vbihandler(struct work_struct *w)
443 {
444 	struct saa7164_port *port =
445 		container_of(w, struct saa7164_port, workenc);
446 	struct saa7164_dev *dev = port->dev;
447 
448 	u32 wp, mcb, rp, cnt = 0;
449 
450 	port->last_svc_msecs_diff = port->last_svc_msecs;
451 	port->last_svc_msecs = jiffies_to_msecs(jiffies);
452 	port->last_svc_msecs_diff = port->last_svc_msecs -
453 		port->last_svc_msecs_diff;
454 
455 	saa7164_histogram_update(&port->svc_interval,
456 		port->last_svc_msecs_diff);
457 
458 	port->last_irq_svc_msecs_diff = port->last_svc_msecs -
459 		port->last_irq_msecs;
460 
461 	saa7164_histogram_update(&port->irq_svc_interval,
462 		port->last_irq_svc_msecs_diff);
463 
464 	dprintk(DBGLVL_IRQ,
465 		"%s() %Ldms elapsed irq->deferred %Ldms wp: %d rp: %d\n",
466 		__func__,
467 		port->last_svc_msecs_diff,
468 		port->last_irq_svc_msecs_diff,
469 		port->last_svc_wp,
470 		port->last_svc_rp
471 		);
472 
473 	/* Current write position */
474 	wp = saa7164_readl(port->bufcounter);
475 	if (wp > (port->hwcfg.buffercount - 1)) {
476 		printk(KERN_ERR "%s() illegal buf count %d\n", __func__, wp);
477 		return;
478 	}
479 
480 	/* Most current complete buffer */
481 	if (wp == 0)
482 		mcb = (port->hwcfg.buffercount - 1);
483 	else
484 		mcb = wp - 1;
485 
486 	while (1) {
487 		if (port->done_first_interrupt == 0) {
488 			port->done_first_interrupt++;
489 			rp = mcb;
490 		} else
491 			rp = (port->last_svc_rp + 1) % 8;
492 
493 		if (rp > (port->hwcfg.buffercount - 1)) {
494 			printk(KERN_ERR "%s() illegal rp count %d\n", __func__, rp);
495 			break;
496 		}
497 
498 		saa7164_work_enchandler_helper(port, rp);
499 		port->last_svc_rp = rp;
500 		cnt++;
501 
502 		if (rp == mcb)
503 			break;
504 	}
505 
506 	/* TODO: Convert this into a /proc/saa7164 style readable file */
507 	if (print_histogram == port->nr) {
508 		saa7164_histogram_print(port, &port->irq_interval);
509 		saa7164_histogram_print(port, &port->svc_interval);
510 		saa7164_histogram_print(port, &port->irq_svc_interval);
511 		saa7164_histogram_print(port, &port->read_interval);
512 		saa7164_histogram_print(port, &port->poll_interval);
513 		/* TODO: fix this to preserve any previous state */
514 		print_histogram = 64 + port->nr;
515 	}
516 }
517 
518 static void saa7164_work_cmdhandler(struct work_struct *w)
519 {
520 	struct saa7164_dev *dev = container_of(w, struct saa7164_dev, workcmd);
521 
522 	/* Wake up any complete commands */
523 	saa7164_irq_dequeue(dev);
524 }
525 
526 static void saa7164_buffer_deliver(struct saa7164_buffer *buf)
527 {
528 	struct saa7164_port *port = buf->port;
529 
530 	/* Feed the transport payload into the kernel demux */
531 	dvb_dmx_swfilter_packets(&port->dvb.demux, (u8 *)buf->cpu,
532 		SAA7164_TS_NUMBER_OF_LINES);
533 
534 }
535 
536 static irqreturn_t saa7164_irq_vbi(struct saa7164_port *port)
537 {
538 	struct saa7164_dev *dev = port->dev;
539 
540 	/* Store old time */
541 	port->last_irq_msecs_diff = port->last_irq_msecs;
542 
543 	/* Collect new stats */
544 	port->last_irq_msecs = jiffies_to_msecs(jiffies);
545 
546 	/* Calculate stats */
547 	port->last_irq_msecs_diff = port->last_irq_msecs -
548 		port->last_irq_msecs_diff;
549 
550 	saa7164_histogram_update(&port->irq_interval,
551 		port->last_irq_msecs_diff);
552 
553 	dprintk(DBGLVL_IRQ, "%s() %Ldms elapsed\n", __func__,
554 		port->last_irq_msecs_diff);
555 
556 	/* Tis calls the vbi irq handler */
557 	schedule_work(&port->workenc);
558 	return 0;
559 }
560 
561 static irqreturn_t saa7164_irq_encoder(struct saa7164_port *port)
562 {
563 	struct saa7164_dev *dev = port->dev;
564 
565 	/* Store old time */
566 	port->last_irq_msecs_diff = port->last_irq_msecs;
567 
568 	/* Collect new stats */
569 	port->last_irq_msecs = jiffies_to_msecs(jiffies);
570 
571 	/* Calculate stats */
572 	port->last_irq_msecs_diff = port->last_irq_msecs -
573 		port->last_irq_msecs_diff;
574 
575 	saa7164_histogram_update(&port->irq_interval,
576 		port->last_irq_msecs_diff);
577 
578 	dprintk(DBGLVL_IRQ, "%s() %Ldms elapsed\n", __func__,
579 		port->last_irq_msecs_diff);
580 
581 	schedule_work(&port->workenc);
582 	return 0;
583 }
584 
585 static irqreturn_t saa7164_irq_ts(struct saa7164_port *port)
586 {
587 	struct saa7164_dev *dev = port->dev;
588 	struct saa7164_buffer *buf;
589 	struct list_head *c, *n;
590 	int wp, i = 0, rp;
591 
592 	/* Find the current write point from the hardware */
593 	wp = saa7164_readl(port->bufcounter);
594 	if (wp > (port->hwcfg.buffercount - 1))
595 		BUG();
596 
597 	/* Find the previous buffer to the current write point */
598 	if (wp == 0)
599 		rp = (port->hwcfg.buffercount - 1);
600 	else
601 		rp = wp - 1;
602 
603 	/* Lookup the WP in the buffer list */
604 	/* TODO: turn this into a worker thread */
605 	list_for_each_safe(c, n, &port->dmaqueue.list) {
606 		buf = list_entry(c, struct saa7164_buffer, list);
607 		if (i++ > port->hwcfg.buffercount)
608 			BUG();
609 
610 		if (buf->idx == rp) {
611 			/* Found the buffer, deal with it */
612 			dprintk(DBGLVL_IRQ, "%s() wp: %d processing: %d\n",
613 				__func__, wp, rp);
614 			saa7164_buffer_deliver(buf);
615 			break;
616 		}
617 
618 	}
619 	return 0;
620 }
621 
622 /* Primary IRQ handler and dispatch mechanism */
623 static irqreturn_t saa7164_irq(int irq, void *dev_id)
624 {
625 	struct saa7164_dev *dev = dev_id;
626 	struct saa7164_port *porta, *portb, *portc, *portd, *porte, *portf;
627 
628 	u32 intid, intstat[INT_SIZE/4];
629 	int i, handled = 0, bit;
630 
631 	if (dev == NULL) {
632 		printk(KERN_ERR "%s() No device specified\n", __func__);
633 		handled = 0;
634 		goto out;
635 	}
636 
637 	porta = &dev->ports[SAA7164_PORT_TS1];
638 	portb = &dev->ports[SAA7164_PORT_TS2];
639 	portc = &dev->ports[SAA7164_PORT_ENC1];
640 	portd = &dev->ports[SAA7164_PORT_ENC2];
641 	porte = &dev->ports[SAA7164_PORT_VBI1];
642 	portf = &dev->ports[SAA7164_PORT_VBI2];
643 
644 	/* Check that the hardware is accessible. If the status bytes are
645 	 * 0xFF then the device is not accessible, the the IRQ belongs
646 	 * to another driver.
647 	 * 4 x u32 interrupt registers.
648 	 */
649 	for (i = 0; i < INT_SIZE/4; i++) {
650 
651 		/* TODO: Convert into saa7164_readl() */
652 		/* Read the 4 hardware interrupt registers */
653 		intstat[i] = saa7164_readl(dev->int_status + (i * 4));
654 
655 		if (intstat[i])
656 			handled = 1;
657 	}
658 	if (handled == 0)
659 		goto out;
660 
661 	/* For each of the HW interrupt registers */
662 	for (i = 0; i < INT_SIZE/4; i++) {
663 
664 		if (intstat[i]) {
665 			/* Each function of the board has it's own interruptid.
666 			 * Find the function that triggered then call
667 			 * it's handler.
668 			 */
669 			for (bit = 0; bit < 32; bit++) {
670 
671 				if (((intstat[i] >> bit) & 0x00000001) == 0)
672 					continue;
673 
674 				/* Calculate the interrupt id (0x00 to 0x7f) */
675 
676 				intid = (i * 32) + bit;
677 				if (intid == dev->intfdesc.bInterruptId) {
678 					/* A response to an cmd/api call */
679 					schedule_work(&dev->workcmd);
680 				} else if (intid == porta->hwcfg.interruptid) {
681 
682 					/* Transport path 1 */
683 					saa7164_irq_ts(porta);
684 
685 				} else if (intid == portb->hwcfg.interruptid) {
686 
687 					/* Transport path 2 */
688 					saa7164_irq_ts(portb);
689 
690 				} else if (intid == portc->hwcfg.interruptid) {
691 
692 					/* Encoder path 1 */
693 					saa7164_irq_encoder(portc);
694 
695 				} else if (intid == portd->hwcfg.interruptid) {
696 
697 					/* Encoder path 2 */
698 					saa7164_irq_encoder(portd);
699 
700 				} else if (intid == porte->hwcfg.interruptid) {
701 
702 					/* VBI path 1 */
703 					saa7164_irq_vbi(porte);
704 
705 				} else if (intid == portf->hwcfg.interruptid) {
706 
707 					/* VBI path 2 */
708 					saa7164_irq_vbi(portf);
709 
710 				} else {
711 					/* Find the function */
712 					dprintk(DBGLVL_IRQ,
713 						"%s() unhandled interrupt "
714 						"reg 0x%x bit 0x%x "
715 						"intid = 0x%x\n",
716 						__func__, i, bit, intid);
717 				}
718 			}
719 
720 			/* Ack it */
721 			saa7164_writel(dev->int_ack + (i * 4), intstat[i]);
722 
723 		}
724 	}
725 out:
726 	return IRQ_RETVAL(handled);
727 }
728 
729 void saa7164_getfirmwarestatus(struct saa7164_dev *dev)
730 {
731 	struct saa7164_fw_status *s = &dev->fw_status;
732 
733 	dev->fw_status.status = saa7164_readl(SAA_DEVICE_SYSINIT_STATUS);
734 	dev->fw_status.mode = saa7164_readl(SAA_DEVICE_SYSINIT_MODE);
735 	dev->fw_status.spec = saa7164_readl(SAA_DEVICE_SYSINIT_SPEC);
736 	dev->fw_status.inst = saa7164_readl(SAA_DEVICE_SYSINIT_INST);
737 	dev->fw_status.cpuload = saa7164_readl(SAA_DEVICE_SYSINIT_CPULOAD);
738 	dev->fw_status.remainheap =
739 		saa7164_readl(SAA_DEVICE_SYSINIT_REMAINHEAP);
740 
741 	dprintk(1, "Firmware status:\n");
742 	dprintk(1, " .status     = 0x%08x\n", s->status);
743 	dprintk(1, " .mode       = 0x%08x\n", s->mode);
744 	dprintk(1, " .spec       = 0x%08x\n", s->spec);
745 	dprintk(1, " .inst       = 0x%08x\n", s->inst);
746 	dprintk(1, " .cpuload    = 0x%08x\n", s->cpuload);
747 	dprintk(1, " .remainheap = 0x%08x\n", s->remainheap);
748 }
749 
750 u32 saa7164_getcurrentfirmwareversion(struct saa7164_dev *dev)
751 {
752 	u32 reg;
753 
754 	reg = saa7164_readl(SAA_DEVICE_VERSION);
755 	dprintk(1, "Device running firmware version %d.%d.%d.%d (0x%x)\n",
756 		(reg & 0x0000fc00) >> 10,
757 		(reg & 0x000003e0) >> 5,
758 		(reg & 0x0000001f),
759 		(reg & 0xffff0000) >> 16,
760 		reg);
761 
762 	return reg;
763 }
764 
765 /* TODO: Debugging func, remove */
766 void saa7164_dumpregs(struct saa7164_dev *dev, u32 addr)
767 {
768 	int i;
769 
770 	dprintk(1, "--------------------> "
771 		"00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f\n");
772 
773 	for (i = 0; i < 0x100; i += 16)
774 		dprintk(1, "region0[0x%08x] = "
775 			"%02x %02x %02x %02x %02x %02x %02x %02x"
776 			" %02x %02x %02x %02x %02x %02x %02x %02x\n", i,
777 			(u8)saa7164_readb(addr + i + 0),
778 			(u8)saa7164_readb(addr + i + 1),
779 			(u8)saa7164_readb(addr + i + 2),
780 			(u8)saa7164_readb(addr + i + 3),
781 			(u8)saa7164_readb(addr + i + 4),
782 			(u8)saa7164_readb(addr + i + 5),
783 			(u8)saa7164_readb(addr + i + 6),
784 			(u8)saa7164_readb(addr + i + 7),
785 			(u8)saa7164_readb(addr + i + 8),
786 			(u8)saa7164_readb(addr + i + 9),
787 			(u8)saa7164_readb(addr + i + 10),
788 			(u8)saa7164_readb(addr + i + 11),
789 			(u8)saa7164_readb(addr + i + 12),
790 			(u8)saa7164_readb(addr + i + 13),
791 			(u8)saa7164_readb(addr + i + 14),
792 			(u8)saa7164_readb(addr + i + 15)
793 			);
794 }
795 
796 static void saa7164_dump_hwdesc(struct saa7164_dev *dev)
797 {
798 	dprintk(1, "@0x%p hwdesc sizeof(struct tmComResHWDescr) = %d bytes\n",
799 		&dev->hwdesc, (u32)sizeof(struct tmComResHWDescr));
800 
801 	dprintk(1, " .bLength = 0x%x\n", dev->hwdesc.bLength);
802 	dprintk(1, " .bDescriptorType = 0x%x\n", dev->hwdesc.bDescriptorType);
803 	dprintk(1, " .bDescriptorSubtype = 0x%x\n",
804 		dev->hwdesc.bDescriptorSubtype);
805 
806 	dprintk(1, " .bcdSpecVersion = 0x%x\n", dev->hwdesc.bcdSpecVersion);
807 	dprintk(1, " .dwClockFrequency = 0x%x\n", dev->hwdesc.dwClockFrequency);
808 	dprintk(1, " .dwClockUpdateRes = 0x%x\n", dev->hwdesc.dwClockUpdateRes);
809 	dprintk(1, " .bCapabilities = 0x%x\n", dev->hwdesc.bCapabilities);
810 	dprintk(1, " .dwDeviceRegistersLocation = 0x%x\n",
811 		dev->hwdesc.dwDeviceRegistersLocation);
812 
813 	dprintk(1, " .dwHostMemoryRegion = 0x%x\n",
814 		dev->hwdesc.dwHostMemoryRegion);
815 
816 	dprintk(1, " .dwHostMemoryRegionSize = 0x%x\n",
817 		dev->hwdesc.dwHostMemoryRegionSize);
818 
819 	dprintk(1, " .dwHostHibernatMemRegion = 0x%x\n",
820 		dev->hwdesc.dwHostHibernatMemRegion);
821 
822 	dprintk(1, " .dwHostHibernatMemRegionSize = 0x%x\n",
823 		dev->hwdesc.dwHostHibernatMemRegionSize);
824 }
825 
826 static void saa7164_dump_intfdesc(struct saa7164_dev *dev)
827 {
828 	dprintk(1, "@0x%p intfdesc "
829 		"sizeof(struct tmComResInterfaceDescr) = %d bytes\n",
830 		&dev->intfdesc, (u32)sizeof(struct tmComResInterfaceDescr));
831 
832 	dprintk(1, " .bLength = 0x%x\n", dev->intfdesc.bLength);
833 	dprintk(1, " .bDescriptorType = 0x%x\n", dev->intfdesc.bDescriptorType);
834 	dprintk(1, " .bDescriptorSubtype = 0x%x\n",
835 		dev->intfdesc.bDescriptorSubtype);
836 
837 	dprintk(1, " .bFlags = 0x%x\n", dev->intfdesc.bFlags);
838 	dprintk(1, " .bInterfaceType = 0x%x\n", dev->intfdesc.bInterfaceType);
839 	dprintk(1, " .bInterfaceId = 0x%x\n", dev->intfdesc.bInterfaceId);
840 	dprintk(1, " .bBaseInterface = 0x%x\n", dev->intfdesc.bBaseInterface);
841 	dprintk(1, " .bInterruptId = 0x%x\n", dev->intfdesc.bInterruptId);
842 	dprintk(1, " .bDebugInterruptId = 0x%x\n",
843 		dev->intfdesc.bDebugInterruptId);
844 
845 	dprintk(1, " .BARLocation = 0x%x\n", dev->intfdesc.BARLocation);
846 }
847 
848 static void saa7164_dump_busdesc(struct saa7164_dev *dev)
849 {
850 	dprintk(1, "@0x%p busdesc sizeof(struct tmComResBusDescr) = %d bytes\n",
851 		&dev->busdesc, (u32)sizeof(struct tmComResBusDescr));
852 
853 	dprintk(1, " .CommandRing   = 0x%016Lx\n", dev->busdesc.CommandRing);
854 	dprintk(1, " .ResponseRing  = 0x%016Lx\n", dev->busdesc.ResponseRing);
855 	dprintk(1, " .CommandWrite  = 0x%x\n", dev->busdesc.CommandWrite);
856 	dprintk(1, " .CommandRead   = 0x%x\n", dev->busdesc.CommandRead);
857 	dprintk(1, " .ResponseWrite = 0x%x\n", dev->busdesc.ResponseWrite);
858 	dprintk(1, " .ResponseRead  = 0x%x\n", dev->busdesc.ResponseRead);
859 }
860 
861 /* Much of the hardware configuration and PCI registers are configured
862  * dynamically depending on firmware. We have to cache some initial
863  * structures then use these to locate other important structures
864  * from PCI space.
865  */
866 static void saa7164_get_descriptors(struct saa7164_dev *dev)
867 {
868 	memcpy_fromio(&dev->hwdesc, dev->bmmio, sizeof(struct tmComResHWDescr));
869 	memcpy_fromio(&dev->intfdesc, dev->bmmio + sizeof(struct tmComResHWDescr),
870 		sizeof(struct tmComResInterfaceDescr));
871 	memcpy_fromio(&dev->busdesc, dev->bmmio + dev->intfdesc.BARLocation,
872 		sizeof(struct tmComResBusDescr));
873 
874 	if (dev->hwdesc.bLength != sizeof(struct tmComResHWDescr)) {
875 		printk(KERN_ERR "Structure struct tmComResHWDescr is mangled\n");
876 		printk(KERN_ERR "Need %x got %d\n", dev->hwdesc.bLength,
877 			(u32)sizeof(struct tmComResHWDescr));
878 	} else
879 		saa7164_dump_hwdesc(dev);
880 
881 	if (dev->intfdesc.bLength != sizeof(struct tmComResInterfaceDescr)) {
882 		printk(KERN_ERR "struct struct tmComResInterfaceDescr is mangled\n");
883 		printk(KERN_ERR "Need %x got %d\n", dev->intfdesc.bLength,
884 			(u32)sizeof(struct tmComResInterfaceDescr));
885 	} else
886 		saa7164_dump_intfdesc(dev);
887 
888 	saa7164_dump_busdesc(dev);
889 }
890 
891 static int saa7164_pci_quirks(struct saa7164_dev *dev)
892 {
893 	return 0;
894 }
895 
896 static int get_resources(struct saa7164_dev *dev)
897 {
898 	if (request_mem_region(pci_resource_start(dev->pci, 0),
899 		pci_resource_len(dev->pci, 0), dev->name)) {
900 
901 		if (request_mem_region(pci_resource_start(dev->pci, 2),
902 			pci_resource_len(dev->pci, 2), dev->name))
903 			return 0;
904 	}
905 
906 	printk(KERN_ERR "%s: can't get MMIO memory @ 0x%llx or 0x%llx\n",
907 		dev->name,
908 		(u64)pci_resource_start(dev->pci, 0),
909 		(u64)pci_resource_start(dev->pci, 2));
910 
911 	return -EBUSY;
912 }
913 
914 static int saa7164_port_init(struct saa7164_dev *dev, int portnr)
915 {
916 	struct saa7164_port *port = NULL;
917 
918 	if ((portnr < 0) || (portnr >= SAA7164_MAX_PORTS))
919 		BUG();
920 
921 	port = &dev->ports[portnr];
922 
923 	port->dev = dev;
924 	port->nr = portnr;
925 
926 	if ((portnr == SAA7164_PORT_TS1) || (portnr == SAA7164_PORT_TS2))
927 		port->type = SAA7164_MPEG_DVB;
928 	else
929 	if ((portnr == SAA7164_PORT_ENC1) || (portnr == SAA7164_PORT_ENC2)) {
930 		port->type = SAA7164_MPEG_ENCODER;
931 
932 		/* We need a deferred interrupt handler for cmd handling */
933 		INIT_WORK(&port->workenc, saa7164_work_enchandler);
934 	} else if ((portnr == SAA7164_PORT_VBI1) || (portnr == SAA7164_PORT_VBI2)) {
935 		port->type = SAA7164_MPEG_VBI;
936 
937 		/* We need a deferred interrupt handler for cmd handling */
938 		INIT_WORK(&port->workenc, saa7164_work_vbihandler);
939 	} else
940 		BUG();
941 
942 	/* Init all the critical resources */
943 	mutex_init(&port->dvb.lock);
944 	INIT_LIST_HEAD(&port->dmaqueue.list);
945 	mutex_init(&port->dmaqueue_lock);
946 
947 	INIT_LIST_HEAD(&port->list_buf_used.list);
948 	INIT_LIST_HEAD(&port->list_buf_free.list);
949 	init_waitqueue_head(&port->wait_read);
950 
951 
952 	saa7164_histogram_reset(&port->irq_interval, "irq intervals");
953 	saa7164_histogram_reset(&port->svc_interval, "deferred intervals");
954 	saa7164_histogram_reset(&port->irq_svc_interval,
955 		"irq to deferred intervals");
956 	saa7164_histogram_reset(&port->read_interval,
957 		"encoder/vbi read() intervals");
958 	saa7164_histogram_reset(&port->poll_interval,
959 		"encoder/vbi poll() intervals");
960 
961 	return 0;
962 }
963 
964 static int saa7164_dev_setup(struct saa7164_dev *dev)
965 {
966 	int i;
967 
968 	mutex_init(&dev->lock);
969 	atomic_inc(&dev->refcount);
970 	dev->nr = saa7164_devcount++;
971 
972 	snprintf(dev->name, sizeof(dev->name), "saa7164[%d]", dev->nr);
973 
974 	mutex_lock(&devlist);
975 	list_add_tail(&dev->devlist, &saa7164_devlist);
976 	mutex_unlock(&devlist);
977 
978 	/* board config */
979 	dev->board = UNSET;
980 	if (card[dev->nr] < saa7164_bcount)
981 		dev->board = card[dev->nr];
982 
983 	for (i = 0; UNSET == dev->board  &&  i < saa7164_idcount; i++)
984 		if (dev->pci->subsystem_vendor == saa7164_subids[i].subvendor &&
985 			dev->pci->subsystem_device ==
986 				saa7164_subids[i].subdevice)
987 				dev->board = saa7164_subids[i].card;
988 
989 	if (UNSET == dev->board) {
990 		dev->board = SAA7164_BOARD_UNKNOWN;
991 		saa7164_card_list(dev);
992 	}
993 
994 	dev->pci_bus  = dev->pci->bus->number;
995 	dev->pci_slot = PCI_SLOT(dev->pci->devfn);
996 
997 	/* I2C Defaults / setup */
998 	dev->i2c_bus[0].dev = dev;
999 	dev->i2c_bus[0].nr = 0;
1000 	dev->i2c_bus[1].dev = dev;
1001 	dev->i2c_bus[1].nr = 1;
1002 	dev->i2c_bus[2].dev = dev;
1003 	dev->i2c_bus[2].nr = 2;
1004 
1005 	/* Transport + Encoder ports 1, 2, 3, 4 - Defaults / setup */
1006 	saa7164_port_init(dev, SAA7164_PORT_TS1);
1007 	saa7164_port_init(dev, SAA7164_PORT_TS2);
1008 	saa7164_port_init(dev, SAA7164_PORT_ENC1);
1009 	saa7164_port_init(dev, SAA7164_PORT_ENC2);
1010 	saa7164_port_init(dev, SAA7164_PORT_VBI1);
1011 	saa7164_port_init(dev, SAA7164_PORT_VBI2);
1012 
1013 	if (get_resources(dev) < 0) {
1014 		printk(KERN_ERR "CORE %s No more PCIe resources for "
1015 		       "subsystem: %04x:%04x\n",
1016 		       dev->name, dev->pci->subsystem_vendor,
1017 		       dev->pci->subsystem_device);
1018 
1019 		saa7164_devcount--;
1020 		return -ENODEV;
1021 	}
1022 
1023 	/* PCI/e allocations */
1024 	dev->lmmio = ioremap(pci_resource_start(dev->pci, 0),
1025 			     pci_resource_len(dev->pci, 0));
1026 
1027 	dev->lmmio2 = ioremap(pci_resource_start(dev->pci, 2),
1028 			     pci_resource_len(dev->pci, 2));
1029 
1030 	dev->bmmio = (u8 __iomem *)dev->lmmio;
1031 	dev->bmmio2 = (u8 __iomem *)dev->lmmio2;
1032 
1033 	/* Inerrupt and ack register locations offset of bmmio */
1034 	dev->int_status = 0x183000 + 0xf80;
1035 	dev->int_ack = 0x183000 + 0xf90;
1036 
1037 	printk(KERN_INFO
1038 		"CORE %s: subsystem: %04x:%04x, board: %s [card=%d,%s]\n",
1039 	       dev->name, dev->pci->subsystem_vendor,
1040 	       dev->pci->subsystem_device, saa7164_boards[dev->board].name,
1041 	       dev->board, card[dev->nr] == dev->board ?
1042 	       "insmod option" : "autodetected");
1043 
1044 	saa7164_pci_quirks(dev);
1045 
1046 	return 0;
1047 }
1048 
1049 static void saa7164_dev_unregister(struct saa7164_dev *dev)
1050 {
1051 	dprintk(1, "%s()\n", __func__);
1052 
1053 	release_mem_region(pci_resource_start(dev->pci, 0),
1054 		pci_resource_len(dev->pci, 0));
1055 
1056 	release_mem_region(pci_resource_start(dev->pci, 2),
1057 		pci_resource_len(dev->pci, 2));
1058 
1059 	if (!atomic_dec_and_test(&dev->refcount))
1060 		return;
1061 
1062 	iounmap(dev->lmmio);
1063 	iounmap(dev->lmmio2);
1064 
1065 	return;
1066 }
1067 
1068 #ifdef CONFIG_PROC_FS
1069 static int saa7164_proc_show(struct seq_file *m, void *v)
1070 {
1071 	struct saa7164_dev *dev;
1072 	struct tmComResBusInfo *b;
1073 	struct list_head *list;
1074 	int i, c;
1075 
1076 	if (saa7164_devcount == 0)
1077 		return 0;
1078 
1079 	list_for_each(list, &saa7164_devlist) {
1080 		dev = list_entry(list, struct saa7164_dev, devlist);
1081 		seq_printf(m, "%s = %p\n", dev->name, dev);
1082 
1083 		/* Lock the bus from any other access */
1084 		b = &dev->bus;
1085 		mutex_lock(&b->lock);
1086 
1087 		seq_printf(m, " .m_pdwSetWritePos = 0x%x (0x%08x)\n",
1088 			b->m_dwSetReadPos, saa7164_readl(b->m_dwSetReadPos));
1089 
1090 		seq_printf(m, " .m_pdwSetReadPos  = 0x%x (0x%08x)\n",
1091 			b->m_dwSetWritePos, saa7164_readl(b->m_dwSetWritePos));
1092 
1093 		seq_printf(m, " .m_pdwGetWritePos = 0x%x (0x%08x)\n",
1094 			b->m_dwGetReadPos, saa7164_readl(b->m_dwGetReadPos));
1095 
1096 		seq_printf(m, " .m_pdwGetReadPos  = 0x%x (0x%08x)\n",
1097 			b->m_dwGetWritePos, saa7164_readl(b->m_dwGetWritePos));
1098 		c = 0;
1099 		seq_printf(m, "\n  Set Ring:\n");
1100 		seq_printf(m, "\n addr  00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f\n");
1101 		for (i = 0; i < b->m_dwSizeSetRing; i++) {
1102 			if (c == 0)
1103 				seq_printf(m, " %04x:", i);
1104 
1105 			seq_printf(m, " %02x", readb(b->m_pdwSetRing + i));
1106 
1107 			if (++c == 16) {
1108 				seq_printf(m, "\n");
1109 				c = 0;
1110 			}
1111 		}
1112 
1113 		c = 0;
1114 		seq_printf(m, "\n  Get Ring:\n");
1115 		seq_printf(m, "\n addr  00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f\n");
1116 		for (i = 0; i < b->m_dwSizeGetRing; i++) {
1117 			if (c == 0)
1118 				seq_printf(m, " %04x:", i);
1119 
1120 			seq_printf(m, " %02x", readb(b->m_pdwGetRing + i));
1121 
1122 			if (++c == 16) {
1123 				seq_printf(m, "\n");
1124 				c = 0;
1125 			}
1126 		}
1127 
1128 		mutex_unlock(&b->lock);
1129 
1130 	}
1131 
1132 	return 0;
1133 }
1134 
1135 static int saa7164_proc_open(struct inode *inode, struct file *filp)
1136 {
1137 	return single_open(filp, saa7164_proc_show, NULL);
1138 }
1139 
1140 static const struct file_operations saa7164_proc_fops = {
1141 	.open		= saa7164_proc_open,
1142 	.read		= seq_read,
1143 	.llseek		= seq_lseek,
1144 	.release	= single_release,
1145 };
1146 
1147 static int saa7164_proc_create(void)
1148 {
1149 	struct proc_dir_entry *pe;
1150 
1151 	pe = proc_create("saa7164", S_IRUGO, NULL, &saa7164_proc_fops);
1152 	if (!pe)
1153 		return -ENOMEM;
1154 
1155 	return 0;
1156 }
1157 #endif
1158 
1159 static int saa7164_thread_function(void *data)
1160 {
1161 	struct saa7164_dev *dev = data;
1162 	struct tmFwInfoStruct fwinfo;
1163 	u64 last_poll_time = 0;
1164 
1165 	dprintk(DBGLVL_THR, "thread started\n");
1166 
1167 	set_freezable();
1168 
1169 	while (1) {
1170 		msleep_interruptible(100);
1171 		if (kthread_should_stop())
1172 			break;
1173 		try_to_freeze();
1174 
1175 		dprintk(DBGLVL_THR, "thread running\n");
1176 
1177 		/* Dump the firmware debug message to console */
1178 		/* Polling this costs us 1-2% of the arm CPU */
1179 		/* convert this into a respnde to interrupt 0x7a */
1180 		saa7164_api_collect_debug(dev);
1181 
1182 		/* Monitor CPU load every 1 second */
1183 		if ((last_poll_time + 1000 /* ms */) < jiffies_to_msecs(jiffies)) {
1184 			saa7164_api_get_load_info(dev, &fwinfo);
1185 			last_poll_time = jiffies_to_msecs(jiffies);
1186 		}
1187 
1188 	}
1189 
1190 	dprintk(DBGLVL_THR, "thread exiting\n");
1191 	return 0;
1192 }
1193 
1194 static bool saa7164_enable_msi(struct pci_dev *pci_dev, struct saa7164_dev *dev)
1195 {
1196 	int err;
1197 
1198 	if (!enable_msi) {
1199 		printk(KERN_WARNING "%s() MSI disabled by module parameter 'enable_msi'"
1200 		       , __func__);
1201 		return false;
1202 	}
1203 
1204 	err = pci_enable_msi(pci_dev);
1205 
1206 	if (err) {
1207 		printk(KERN_ERR "%s() Failed to enable MSI interrupt."
1208 			" Falling back to a shared IRQ\n", __func__);
1209 		return false;
1210 	}
1211 
1212 	/* no error - so request an msi interrupt */
1213 	err = request_irq(pci_dev->irq, saa7164_irq, 0,
1214 						dev->name, dev);
1215 
1216 	if (err) {
1217 		/* fall back to legacy interrupt */
1218 		printk(KERN_ERR "%s() Failed to get an MSI interrupt."
1219 		       " Falling back to a shared IRQ\n", __func__);
1220 		pci_disable_msi(pci_dev);
1221 		return false;
1222 	}
1223 
1224 	return true;
1225 }
1226 
1227 static int saa7164_initdev(struct pci_dev *pci_dev,
1228 			   const struct pci_device_id *pci_id)
1229 {
1230 	struct saa7164_dev *dev;
1231 	int err, i;
1232 	u32 version;
1233 
1234 	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1235 	if (NULL == dev)
1236 		return -ENOMEM;
1237 
1238 	err = v4l2_device_register(&pci_dev->dev, &dev->v4l2_dev);
1239 	if (err < 0) {
1240 		dev_err(&pci_dev->dev, "v4l2_device_register failed\n");
1241 		goto fail_free;
1242 	}
1243 
1244 	/* pci init */
1245 	dev->pci = pci_dev;
1246 	if (pci_enable_device(pci_dev)) {
1247 		err = -EIO;
1248 		goto fail_free;
1249 	}
1250 
1251 	if (saa7164_dev_setup(dev) < 0) {
1252 		err = -EINVAL;
1253 		goto fail_free;
1254 	}
1255 
1256 	/* print pci info */
1257 	dev->pci_rev = pci_dev->revision;
1258 	pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER,  &dev->pci_lat);
1259 	printk(KERN_INFO "%s/0: found at %s, rev: %d, irq: %d, "
1260 	       "latency: %d, mmio: 0x%llx\n", dev->name,
1261 	       pci_name(pci_dev), dev->pci_rev, pci_dev->irq,
1262 	       dev->pci_lat,
1263 		(unsigned long long)pci_resource_start(pci_dev, 0));
1264 
1265 	pci_set_master(pci_dev);
1266 	/* TODO */
1267 	if (!pci_dma_supported(pci_dev, 0xffffffff)) {
1268 		printk("%s/0: Oops: no 32bit PCI DMA ???\n", dev->name);
1269 		err = -EIO;
1270 		goto fail_irq;
1271 	}
1272 
1273 	/* irq bit */
1274 	if (saa7164_enable_msi(pci_dev, dev)) {
1275 		dev->msi = true;
1276 	} else {
1277 		/* if we have an error (i.e. we don't have an interrupt)
1278 			 or msi is not enabled - fallback to shared interrupt */
1279 
1280 		err = request_irq(pci_dev->irq, saa7164_irq,
1281 				IRQF_SHARED, dev->name, dev);
1282 
1283 		if (err < 0) {
1284 			printk(KERN_ERR "%s: can't get IRQ %d\n", dev->name,
1285 			       pci_dev->irq);
1286 			err = -EIO;
1287 			goto fail_irq;
1288 		}
1289 	}
1290 
1291 	pci_set_drvdata(pci_dev, dev);
1292 
1293 	/* Init the internal command list */
1294 	for (i = 0; i < SAA_CMD_MAX_MSG_UNITS; i++) {
1295 		dev->cmds[i].seqno = i;
1296 		dev->cmds[i].inuse = 0;
1297 		mutex_init(&dev->cmds[i].lock);
1298 		init_waitqueue_head(&dev->cmds[i].wait);
1299 	}
1300 
1301 	/* We need a deferred interrupt handler for cmd handling */
1302 	INIT_WORK(&dev->workcmd, saa7164_work_cmdhandler);
1303 
1304 	/* Only load the firmware if we know the board */
1305 	if (dev->board != SAA7164_BOARD_UNKNOWN) {
1306 
1307 		err = saa7164_downloadfirmware(dev);
1308 		if (err < 0) {
1309 			printk(KERN_ERR
1310 				"Failed to boot firmware, no features "
1311 				"registered\n");
1312 			goto fail_fw;
1313 		}
1314 
1315 		saa7164_get_descriptors(dev);
1316 		saa7164_dumpregs(dev, 0);
1317 		saa7164_getcurrentfirmwareversion(dev);
1318 		saa7164_getfirmwarestatus(dev);
1319 		err = saa7164_bus_setup(dev);
1320 		if (err < 0)
1321 			printk(KERN_ERR
1322 				"Failed to setup the bus, will continue\n");
1323 		saa7164_bus_dump(dev);
1324 
1325 		/* Ping the running firmware via the command bus and get the
1326 		 * firmware version, this checks the bus is running OK.
1327 		 */
1328 		version = 0;
1329 		if (saa7164_api_get_fw_version(dev, &version) == SAA_OK)
1330 			dprintk(1, "Bus is operating correctly using "
1331 				"version %d.%d.%d.%d (0x%x)\n",
1332 				(version & 0x0000fc00) >> 10,
1333 				(version & 0x000003e0) >> 5,
1334 				(version & 0x0000001f),
1335 				(version & 0xffff0000) >> 16,
1336 				version);
1337 		else
1338 			printk(KERN_ERR
1339 				"Failed to communicate with the firmware\n");
1340 
1341 		/* Bring up the I2C buses */
1342 		saa7164_i2c_register(&dev->i2c_bus[0]);
1343 		saa7164_i2c_register(&dev->i2c_bus[1]);
1344 		saa7164_i2c_register(&dev->i2c_bus[2]);
1345 		saa7164_gpio_setup(dev);
1346 		saa7164_card_setup(dev);
1347 
1348 		/* Parse the dynamic device configuration, find various
1349 		 * media endpoints (MPEG, WMV, PS, TS) and cache their
1350 		 * configuration details into the driver, so we can
1351 		 * reference them later during simething_register() func,
1352 		 * interrupt handlers, deferred work handlers etc.
1353 		 */
1354 		saa7164_api_enum_subdevs(dev);
1355 
1356 		/* Begin to create the video sub-systems and register funcs */
1357 		if (saa7164_boards[dev->board].porta == SAA7164_MPEG_DVB) {
1358 			if (saa7164_dvb_register(&dev->ports[SAA7164_PORT_TS1]) < 0) {
1359 				printk(KERN_ERR "%s() Failed to register "
1360 					"dvb adapters on porta\n",
1361 					__func__);
1362 			}
1363 		}
1364 
1365 		if (saa7164_boards[dev->board].portb == SAA7164_MPEG_DVB) {
1366 			if (saa7164_dvb_register(&dev->ports[SAA7164_PORT_TS2]) < 0) {
1367 				printk(KERN_ERR"%s() Failed to register "
1368 					"dvb adapters on portb\n",
1369 					__func__);
1370 			}
1371 		}
1372 
1373 		if (saa7164_boards[dev->board].portc == SAA7164_MPEG_ENCODER) {
1374 			if (saa7164_encoder_register(&dev->ports[SAA7164_PORT_ENC1]) < 0) {
1375 				printk(KERN_ERR"%s() Failed to register "
1376 					"mpeg encoder\n", __func__);
1377 			}
1378 		}
1379 
1380 		if (saa7164_boards[dev->board].portd == SAA7164_MPEG_ENCODER) {
1381 			if (saa7164_encoder_register(&dev->ports[SAA7164_PORT_ENC2]) < 0) {
1382 				printk(KERN_ERR"%s() Failed to register "
1383 					"mpeg encoder\n", __func__);
1384 			}
1385 		}
1386 
1387 		if (saa7164_boards[dev->board].porte == SAA7164_MPEG_VBI) {
1388 			if (saa7164_vbi_register(&dev->ports[SAA7164_PORT_VBI1]) < 0) {
1389 				printk(KERN_ERR"%s() Failed to register "
1390 					"vbi device\n", __func__);
1391 			}
1392 		}
1393 
1394 		if (saa7164_boards[dev->board].portf == SAA7164_MPEG_VBI) {
1395 			if (saa7164_vbi_register(&dev->ports[SAA7164_PORT_VBI2]) < 0) {
1396 				printk(KERN_ERR"%s() Failed to register "
1397 					"vbi device\n", __func__);
1398 			}
1399 		}
1400 		saa7164_api_set_debug(dev, fw_debug);
1401 
1402 		if (fw_debug) {
1403 			dev->kthread = kthread_run(saa7164_thread_function, dev,
1404 				"saa7164 debug");
1405 			if (IS_ERR(dev->kthread)) {
1406 				dev->kthread = NULL;
1407 				printk(KERN_ERR "%s() Failed to create "
1408 					"debug kernel thread\n", __func__);
1409 			}
1410 		}
1411 
1412 	} /* != BOARD_UNKNOWN */
1413 	else
1414 		printk(KERN_ERR "%s() Unsupported board detected, "
1415 			"registering without firmware\n", __func__);
1416 
1417 	dprintk(1, "%s() parameter debug = %d\n", __func__, saa_debug);
1418 	dprintk(1, "%s() parameter waitsecs = %d\n", __func__, waitsecs);
1419 
1420 fail_fw:
1421 	return 0;
1422 
1423 fail_irq:
1424 	saa7164_dev_unregister(dev);
1425 fail_free:
1426 	v4l2_device_unregister(&dev->v4l2_dev);
1427 	kfree(dev);
1428 	return err;
1429 }
1430 
1431 static void saa7164_shutdown(struct saa7164_dev *dev)
1432 {
1433 	dprintk(1, "%s()\n", __func__);
1434 }
1435 
1436 static void saa7164_finidev(struct pci_dev *pci_dev)
1437 {
1438 	struct saa7164_dev *dev = pci_get_drvdata(pci_dev);
1439 
1440 	if (dev->board != SAA7164_BOARD_UNKNOWN) {
1441 		if (fw_debug && dev->kthread) {
1442 			kthread_stop(dev->kthread);
1443 			dev->kthread = NULL;
1444 		}
1445 		if (dev->firmwareloaded)
1446 			saa7164_api_set_debug(dev, 0x00);
1447 	}
1448 
1449 	saa7164_histogram_print(&dev->ports[SAA7164_PORT_ENC1],
1450 		&dev->ports[SAA7164_PORT_ENC1].irq_interval);
1451 	saa7164_histogram_print(&dev->ports[SAA7164_PORT_ENC1],
1452 		&dev->ports[SAA7164_PORT_ENC1].svc_interval);
1453 	saa7164_histogram_print(&dev->ports[SAA7164_PORT_ENC1],
1454 		&dev->ports[SAA7164_PORT_ENC1].irq_svc_interval);
1455 	saa7164_histogram_print(&dev->ports[SAA7164_PORT_ENC1],
1456 		&dev->ports[SAA7164_PORT_ENC1].read_interval);
1457 	saa7164_histogram_print(&dev->ports[SAA7164_PORT_ENC1],
1458 		&dev->ports[SAA7164_PORT_ENC1].poll_interval);
1459 	saa7164_histogram_print(&dev->ports[SAA7164_PORT_VBI1],
1460 		&dev->ports[SAA7164_PORT_VBI1].read_interval);
1461 	saa7164_histogram_print(&dev->ports[SAA7164_PORT_VBI2],
1462 		&dev->ports[SAA7164_PORT_VBI2].poll_interval);
1463 
1464 	saa7164_shutdown(dev);
1465 
1466 	if (saa7164_boards[dev->board].porta == SAA7164_MPEG_DVB)
1467 		saa7164_dvb_unregister(&dev->ports[SAA7164_PORT_TS1]);
1468 
1469 	if (saa7164_boards[dev->board].portb == SAA7164_MPEG_DVB)
1470 		saa7164_dvb_unregister(&dev->ports[SAA7164_PORT_TS2]);
1471 
1472 	if (saa7164_boards[dev->board].portc == SAA7164_MPEG_ENCODER)
1473 		saa7164_encoder_unregister(&dev->ports[SAA7164_PORT_ENC1]);
1474 
1475 	if (saa7164_boards[dev->board].portd == SAA7164_MPEG_ENCODER)
1476 		saa7164_encoder_unregister(&dev->ports[SAA7164_PORT_ENC2]);
1477 
1478 	if (saa7164_boards[dev->board].porte == SAA7164_MPEG_VBI)
1479 		saa7164_vbi_unregister(&dev->ports[SAA7164_PORT_VBI1]);
1480 
1481 	if (saa7164_boards[dev->board].portf == SAA7164_MPEG_VBI)
1482 		saa7164_vbi_unregister(&dev->ports[SAA7164_PORT_VBI2]);
1483 
1484 	saa7164_i2c_unregister(&dev->i2c_bus[0]);
1485 	saa7164_i2c_unregister(&dev->i2c_bus[1]);
1486 	saa7164_i2c_unregister(&dev->i2c_bus[2]);
1487 
1488 	/* unregister stuff */
1489 	free_irq(pci_dev->irq, dev);
1490 
1491 	if (dev->msi) {
1492 		pci_disable_msi(pci_dev);
1493 		dev->msi = false;
1494 	}
1495 
1496 	pci_disable_device(pci_dev);
1497 
1498 	mutex_lock(&devlist);
1499 	list_del(&dev->devlist);
1500 	mutex_unlock(&devlist);
1501 
1502 	saa7164_dev_unregister(dev);
1503 	v4l2_device_unregister(&dev->v4l2_dev);
1504 	kfree(dev);
1505 }
1506 
1507 static struct pci_device_id saa7164_pci_tbl[] = {
1508 	{
1509 		/* SAA7164 */
1510 		.vendor       = 0x1131,
1511 		.device       = 0x7164,
1512 		.subvendor    = PCI_ANY_ID,
1513 		.subdevice    = PCI_ANY_ID,
1514 	}, {
1515 		/* --- end of list --- */
1516 	}
1517 };
1518 MODULE_DEVICE_TABLE(pci, saa7164_pci_tbl);
1519 
1520 static struct pci_driver saa7164_pci_driver = {
1521 	.name     = "saa7164",
1522 	.id_table = saa7164_pci_tbl,
1523 	.probe    = saa7164_initdev,
1524 	.remove   = saa7164_finidev,
1525 	/* TODO */
1526 	.suspend  = NULL,
1527 	.resume   = NULL,
1528 };
1529 
1530 static int __init saa7164_init(void)
1531 {
1532 	printk(KERN_INFO "saa7164 driver loaded\n");
1533 
1534 #ifdef CONFIG_PROC_FS
1535 	saa7164_proc_create();
1536 #endif
1537 	return pci_register_driver(&saa7164_pci_driver);
1538 }
1539 
1540 static void __exit saa7164_fini(void)
1541 {
1542 #ifdef CONFIG_PROC_FS
1543 	remove_proc_entry("saa7164", NULL);
1544 #endif
1545 	pci_unregister_driver(&saa7164_pci_driver);
1546 }
1547 
1548 module_init(saa7164_init);
1549 module_exit(saa7164_fini);
1550 
1551