projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/hid
[deliverable/linux.git] / drivers / media / video / cx23885 / cx23885-core.c
1 /*
2 * Driver for the Conexant CX23885 PCIe bridge
3 *
4 * Copyright (c) 2006 Steven Toth <stoth@linuxtv.org>
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 #include "cx23885.h"
34
35 MODULE_DESCRIPTION("Driver for cx23885 based TV cards");
36 MODULE_AUTHOR("Steven Toth <stoth@linuxtv.org>");
37 MODULE_LICENSE("GPL");
38
39 static unsigned int debug;
40 module_param(debug, int, 0644);
41 MODULE_PARM_DESC(debug, "enable debug messages");
42
43 static unsigned int card[] = {[0 ... (CX23885_MAXBOARDS - 1)] = UNSET };
44 module_param_array(card, int, NULL, 0444);
45 MODULE_PARM_DESC(card, "card type");
46
47 #define dprintk(level, fmt, arg...)\
48 do { if (debug >= level)\
49 printk(KERN_DEBUG "%s/0: " fmt, dev->name, ## arg);\
50 } while (0)
51
52 static unsigned int cx23885_devcount;
53
54 static DEFINE_MUTEX(devlist);
55 LIST_HEAD(cx23885_devlist);
56
57 #define NO_SYNC_LINE (-1U)
58
59 /* FIXME, these allocations will change when
60 * analog arrives. The be reviewed.
61 * CX23887 Assumptions
62 * 1 line = 16 bytes of CDT
63 * cmds size = 80
64 * cdt size = 16 * linesize
65 * iqsize = 64
66 * maxlines = 6
67 *
68 * Address Space:
69 * 0x00000000 0x00008fff FIFO clusters
70 * 0x00010000 0x000104af Channel Management Data Structures
71 * 0x000104b0 0x000104ff Free
72 * 0x00010500 0x000108bf 15 channels * iqsize
73 * 0x000108c0 0x000108ff Free
74 * 0x00010900 0x00010e9f IQ's + Cluster Descriptor Tables
75 * 15 channels * (iqsize + (maxlines * linesize))
76 * 0x00010ea0 0x00010xxx Free
77 */
78
79 static struct sram_channel cx23885_sram_channels[] = {
80 [SRAM_CH01] = {
81 .name = "VID A",
82 .cmds_start = 0x10000,
83 .ctrl_start = 0x10380,
84 .cdt = 0x104c0,
85 .fifo_start = 0x40,
86 .fifo_size = 0x2800,
87 .ptr1_reg = DMA1_PTR1,
88 .ptr2_reg = DMA1_PTR2,
89 .cnt1_reg = DMA1_CNT1,
90 .cnt2_reg = DMA1_CNT2,
91 },
92 [SRAM_CH02] = {
93 .name = "ch2",
94 .cmds_start = 0x0,
95 .ctrl_start = 0x0,
96 .cdt = 0x0,
97 .fifo_start = 0x0,
98 .fifo_size = 0x0,
99 .ptr1_reg = DMA2_PTR1,
100 .ptr2_reg = DMA2_PTR2,
101 .cnt1_reg = DMA2_CNT1,
102 .cnt2_reg = DMA2_CNT2,
103 },
104 [SRAM_CH03] = {
105 .name = "TS1 B",
106 .cmds_start = 0x100A0,
107 .ctrl_start = 0x10400,
108 .cdt = 0x10580,
109 .fifo_start = 0x5000,
110 .fifo_size = 0x1000,
111 .ptr1_reg = DMA3_PTR1,
112 .ptr2_reg = DMA3_PTR2,
113 .cnt1_reg = DMA3_CNT1,
114 .cnt2_reg = DMA3_CNT2,
115 },
116 [SRAM_CH04] = {
117 .name = "ch4",
118 .cmds_start = 0x0,
119 .ctrl_start = 0x0,
120 .cdt = 0x0,
121 .fifo_start = 0x0,
122 .fifo_size = 0x0,
123 .ptr1_reg = DMA4_PTR1,
124 .ptr2_reg = DMA4_PTR2,
125 .cnt1_reg = DMA4_CNT1,
126 .cnt2_reg = DMA4_CNT2,
127 },
128 [SRAM_CH05] = {
129 .name = "ch5",
130 .cmds_start = 0x0,
131 .ctrl_start = 0x0,
132 .cdt = 0x0,
133 .fifo_start = 0x0,
134 .fifo_size = 0x0,
135 .ptr1_reg = DMA5_PTR1,
136 .ptr2_reg = DMA5_PTR2,
137 .cnt1_reg = DMA5_CNT1,
138 .cnt2_reg = DMA5_CNT2,
139 },
140 [SRAM_CH06] = {
141 .name = "TS2 C",
142 .cmds_start = 0x10140,
143 .ctrl_start = 0x10440,
144 .cdt = 0x105e0,
145 .fifo_start = 0x6000,
146 .fifo_size = 0x1000,
147 .ptr1_reg = DMA5_PTR1,
148 .ptr2_reg = DMA5_PTR2,
149 .cnt1_reg = DMA5_CNT1,
150 .cnt2_reg = DMA5_CNT2,
151 },
152 [SRAM_CH07] = {
153 .name = "ch7",
154 .cmds_start = 0x0,
155 .ctrl_start = 0x0,
156 .cdt = 0x0,
157 .fifo_start = 0x0,
158 .fifo_size = 0x0,
159 .ptr1_reg = DMA6_PTR1,
160 .ptr2_reg = DMA6_PTR2,
161 .cnt1_reg = DMA6_CNT1,
162 .cnt2_reg = DMA6_CNT2,
163 },
164 [SRAM_CH08] = {
165 .name = "ch8",
166 .cmds_start = 0x0,
167 .ctrl_start = 0x0,
168 .cdt = 0x0,
169 .fifo_start = 0x0,
170 .fifo_size = 0x0,
171 .ptr1_reg = DMA7_PTR1,
172 .ptr2_reg = DMA7_PTR2,
173 .cnt1_reg = DMA7_CNT1,
174 .cnt2_reg = DMA7_CNT2,
175 },
176 [SRAM_CH09] = {
177 .name = "ch9",
178 .cmds_start = 0x0,
179 .ctrl_start = 0x0,
180 .cdt = 0x0,
181 .fifo_start = 0x0,
182 .fifo_size = 0x0,
183 .ptr1_reg = DMA8_PTR1,
184 .ptr2_reg = DMA8_PTR2,
185 .cnt1_reg = DMA8_CNT1,
186 .cnt2_reg = DMA8_CNT2,
187 },
188 };
189
190 static struct sram_channel cx23887_sram_channels[] = {
191 [SRAM_CH01] = {
192 .name = "VID A",
193 .cmds_start = 0x10000,
194 .ctrl_start = 0x105b0,
195 .cdt = 0x107b0,
196 .fifo_start = 0x40,
197 .fifo_size = 0x2800,
198 .ptr1_reg = DMA1_PTR1,
199 .ptr2_reg = DMA1_PTR2,
200 .cnt1_reg = DMA1_CNT1,
201 .cnt2_reg = DMA1_CNT2,
202 },
203 [SRAM_CH02] = {
204 .name = "ch2",
205 .cmds_start = 0x0,
206 .ctrl_start = 0x0,
207 .cdt = 0x0,
208 .fifo_start = 0x0,
209 .fifo_size = 0x0,
210 .ptr1_reg = DMA2_PTR1,
211 .ptr2_reg = DMA2_PTR2,
212 .cnt1_reg = DMA2_CNT1,
213 .cnt2_reg = DMA2_CNT2,
214 },
215 [SRAM_CH03] = {
216 .name = "TS1 B",
217 .cmds_start = 0x100A0,
218 .ctrl_start = 0x10630,
219 .cdt = 0x10870,
220 .fifo_start = 0x5000,
221 .fifo_size = 0x1000,
222 .ptr1_reg = DMA3_PTR1,
223 .ptr2_reg = DMA3_PTR2,
224 .cnt1_reg = DMA3_CNT1,
225 .cnt2_reg = DMA3_CNT2,
226 },
227 [SRAM_CH04] = {
228 .name = "ch4",
229 .cmds_start = 0x0,
230 .ctrl_start = 0x0,
231 .cdt = 0x0,
232 .fifo_start = 0x0,
233 .fifo_size = 0x0,
234 .ptr1_reg = DMA4_PTR1,
235 .ptr2_reg = DMA4_PTR2,
236 .cnt1_reg = DMA4_CNT1,
237 .cnt2_reg = DMA4_CNT2,
238 },
239 [SRAM_CH05] = {
240 .name = "ch5",
241 .cmds_start = 0x0,
242 .ctrl_start = 0x0,
243 .cdt = 0x0,
244 .fifo_start = 0x0,
245 .fifo_size = 0x0,
246 .ptr1_reg = DMA5_PTR1,
247 .ptr2_reg = DMA5_PTR2,
248 .cnt1_reg = DMA5_CNT1,
249 .cnt2_reg = DMA5_CNT2,
250 },
251 [SRAM_CH06] = {
252 .name = "TS2 C",
253 .cmds_start = 0x10140,
254 .ctrl_start = 0x10670,
255 .cdt = 0x108d0,
256 .fifo_start = 0x6000,
257 .fifo_size = 0x1000,
258 .ptr1_reg = DMA5_PTR1,
259 .ptr2_reg = DMA5_PTR2,
260 .cnt1_reg = DMA5_CNT1,
261 .cnt2_reg = DMA5_CNT2,
262 },
263 [SRAM_CH07] = {
264 .name = "ch7",
265 .cmds_start = 0x0,
266 .ctrl_start = 0x0,
267 .cdt = 0x0,
268 .fifo_start = 0x0,
269 .fifo_size = 0x0,
270 .ptr1_reg = DMA6_PTR1,
271 .ptr2_reg = DMA6_PTR2,
272 .cnt1_reg = DMA6_CNT1,
273 .cnt2_reg = DMA6_CNT2,
274 },
275 [SRAM_CH08] = {
276 .name = "ch8",
277 .cmds_start = 0x0,
278 .ctrl_start = 0x0,
279 .cdt = 0x0,
280 .fifo_start = 0x0,
281 .fifo_size = 0x0,
282 .ptr1_reg = DMA7_PTR1,
283 .ptr2_reg = DMA7_PTR2,
284 .cnt1_reg = DMA7_CNT1,
285 .cnt2_reg = DMA7_CNT2,
286 },
287 [SRAM_CH09] = {
288 .name = "ch9",
289 .cmds_start = 0x0,
290 .ctrl_start = 0x0,
291 .cdt = 0x0,
292 .fifo_start = 0x0,
293 .fifo_size = 0x0,
294 .ptr1_reg = DMA8_PTR1,
295 .ptr2_reg = DMA8_PTR2,
296 .cnt1_reg = DMA8_CNT1,
297 .cnt2_reg = DMA8_CNT2,
298 },
299 };
300
301 static int cx23885_risc_decode(u32 risc)
302 {
303 static char *instr[16] = {
304 [RISC_SYNC >> 28] = "sync",
305 [RISC_WRITE >> 28] = "write",
306 [RISC_WRITEC >> 28] = "writec",
307 [RISC_READ >> 28] = "read",
308 [RISC_READC >> 28] = "readc",
309 [RISC_JUMP >> 28] = "jump",
310 [RISC_SKIP >> 28] = "skip",
311 [RISC_WRITERM >> 28] = "writerm",
312 [RISC_WRITECM >> 28] = "writecm",
313 [RISC_WRITECR >> 28] = "writecr",
314 };
315 static int incr[16] = {
316 [RISC_WRITE >> 28] = 3,
317 [RISC_JUMP >> 28] = 3,
318 [RISC_SKIP >> 28] = 1,
319 [RISC_SYNC >> 28] = 1,
320 [RISC_WRITERM >> 28] = 3,
321 [RISC_WRITECM >> 28] = 3,
322 [RISC_WRITECR >> 28] = 4,
323 };
324 static char *bits[] = {
325 "12", "13", "14", "resync",
326 "cnt0", "cnt1", "18", "19",
327 "20", "21", "22", "23",
328 "irq1", "irq2", "eol", "sol",
329 };
330 int i;
331
332 printk("0x%08x [ %s", risc,
333 instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
334 for (i = ARRAY_SIZE(bits) - 1; i >= 0; i--)
335 if (risc & (1 << (i + 12)))
336 printk(" %s", bits[i]);
337 printk(" count=%d ]\n", risc & 0xfff);
338 return incr[risc >> 28] ? incr[risc >> 28] : 1;
339 }
340
341 void cx23885_wakeup(struct cx23885_tsport *port,
342 struct cx23885_dmaqueue *q, u32 count)
343 {
344 struct cx23885_dev *dev = port->dev;
345 struct cx23885_buffer *buf;
346 int bc;
347
348 for (bc = 0;; bc++) {
349 if (list_empty(&q->active))
350 break;
351 buf = list_entry(q->active.next,
352 struct cx23885_buffer, vb.queue);
353
354 /* count comes from the hw and is is 16bit wide --
355 * this trick handles wrap-arounds correctly for
356 * up to 32767 buffers in flight... */
357 if ((s16) (count - buf->count) < 0)
358 break;
359
360 do_gettimeofday(&buf->vb.ts);
361 dprintk(2, "[%p/%d] wakeup reg=%d buf=%d\n", buf, buf->vb.i,
362 count, buf->count);
363 buf->vb.state = VIDEOBUF_DONE;
364 list_del(&buf->vb.queue);
365 wake_up(&buf->vb.done);
366 }
367 if (list_empty(&q->active))
368 del_timer(&q->timeout);
369 else
370 mod_timer(&q->timeout, jiffies + BUFFER_TIMEOUT);
371 if (bc != 1)
372 printk(KERN_WARNING "%s: %d buffers handled (should be 1)\n",
373 __func__, bc);
374 }
375
376 int cx23885_sram_channel_setup(struct cx23885_dev *dev,
377 struct sram_channel *ch,
378 unsigned int bpl, u32 risc)
379 {
380 unsigned int i, lines;
381 u32 cdt;
382
383 if (ch->cmds_start == 0) {
384 dprintk(1, "%s() Erasing channel [%s]\n", __func__,
385 ch->name);
386 cx_write(ch->ptr1_reg, 0);
387 cx_write(ch->ptr2_reg, 0);
388 cx_write(ch->cnt2_reg, 0);
389 cx_write(ch->cnt1_reg, 0);
390 return 0;
391 } else {
392 dprintk(1, "%s() Configuring channel [%s]\n", __func__,
393 ch->name);
394 }
395
396 bpl = (bpl + 7) & ~7; /* alignment */
397 cdt = ch->cdt;
398 lines = ch->fifo_size / bpl;
399 if (lines > 6)
400 lines = 6;
401 BUG_ON(lines < 2);
402
403 cx_write(8 + 0, RISC_JUMP | RISC_IRQ1 | RISC_CNT_INC);
404 cx_write(8 + 4, 8);
405 cx_write(8 + 8, 0);
406
407 /* write CDT */
408 for (i = 0; i < lines; i++) {
409 dprintk(2, "%s() 0x%08x <- 0x%08x\n", __func__, cdt + 16*i,
410 ch->fifo_start + bpl*i);
411 cx_write(cdt + 16*i, ch->fifo_start + bpl*i);
412 cx_write(cdt + 16*i + 4, 0);
413 cx_write(cdt + 16*i + 8, 0);
414 cx_write(cdt + 16*i + 12, 0);
415 }
416
417 /* write CMDS */
418 if (ch->jumponly)
419 cx_write(ch->cmds_start + 0, 8);
420 else
421 cx_write(ch->cmds_start + 0, risc);
422 cx_write(ch->cmds_start + 4, 0); /* 64 bits 63-32 */
423 cx_write(ch->cmds_start + 8, cdt);
424 cx_write(ch->cmds_start + 12, (lines*16) >> 3);
425 cx_write(ch->cmds_start + 16, ch->ctrl_start);
426 if (ch->jumponly)
427 cx_write(ch->cmds_start + 20, 0x80000000 | (64 >> 2));
428 else
429 cx_write(ch->cmds_start + 20, 64 >> 2);
430 for (i = 24; i < 80; i += 4)
431 cx_write(ch->cmds_start + i, 0);
432
433 /* fill registers */
434 cx_write(ch->ptr1_reg, ch->fifo_start);
435 cx_write(ch->ptr2_reg, cdt);
436 cx_write(ch->cnt2_reg, (lines*16) >> 3);
437 cx_write(ch->cnt1_reg, (bpl >> 3) - 1);
438
439 dprintk(2, "[bridge %d] sram setup %s: bpl=%d lines=%d\n",
440 dev->bridge,
441 ch->name,
442 bpl,
443 lines);
444
445 return 0;
446 }
447
448 void cx23885_sram_channel_dump(struct cx23885_dev *dev,
449 struct sram_channel *ch)
450 {
451 static char *name[] = {
452 "init risc lo",
453 "init risc hi",
454 "cdt base",
455 "cdt size",
456 "iq base",
457 "iq size",
458 "risc pc lo",
459 "risc pc hi",
460 "iq wr ptr",
461 "iq rd ptr",
462 "cdt current",
463 "pci target lo",
464 "pci target hi",
465 "line / byte",
466 };
467 u32 risc;
468 unsigned int i, j, n;
469
470 printk(KERN_WARNING "%s: %s - dma channel status dump\n",
471 dev->name, ch->name);
472 for (i = 0; i < ARRAY_SIZE(name); i++)
473 printk(KERN_WARNING "%s: cmds: %-15s: 0x%08x\n",
474 dev->name, name[i],
475 cx_read(ch->cmds_start + 4*i));
476
477 for (i = 0; i < 4; i++) {
478 risc = cx_read(ch->cmds_start + 4 * (i + 14));
479 printk(KERN_WARNING "%s: risc%d: ", dev->name, i);
480 cx23885_risc_decode(risc);
481 }
482 for (i = 0; i < (64 >> 2); i += n) {
483 risc = cx_read(ch->ctrl_start + 4 * i);
484 /* No consideration for bits 63-32 */
485
486 printk(KERN_WARNING "%s: (0x%08x) iq %x: ", dev->name,
487 ch->ctrl_start + 4 * i, i);
488 n = cx23885_risc_decode(risc);
489 for (j = 1; j < n; j++) {
490 risc = cx_read(ch->ctrl_start + 4 * (i + j));
491 printk(KERN_WARNING "%s: iq %x: 0x%08x [ arg #%d ]\n",
492 dev->name, i+j, risc, j);
493 }
494 }
495
496 printk(KERN_WARNING "%s: fifo: 0x%08x -> 0x%x\n",
497 dev->name, ch->fifo_start, ch->fifo_start+ch->fifo_size);
498 printk(KERN_WARNING "%s: ctrl: 0x%08x -> 0x%x\n",
499 dev->name, ch->ctrl_start, ch->ctrl_start + 6*16);
500 printk(KERN_WARNING "%s: ptr1_reg: 0x%08x\n",
501 dev->name, cx_read(ch->ptr1_reg));
502 printk(KERN_WARNING "%s: ptr2_reg: 0x%08x\n",
503 dev->name, cx_read(ch->ptr2_reg));
504 printk(KERN_WARNING "%s: cnt1_reg: 0x%08x\n",
505 dev->name, cx_read(ch->cnt1_reg));
506 printk(KERN_WARNING "%s: cnt2_reg: 0x%08x\n",
507 dev->name, cx_read(ch->cnt2_reg));
508 }
509
510 static void cx23885_risc_disasm(struct cx23885_tsport *port,
511 struct btcx_riscmem *risc)
512 {
513 struct cx23885_dev *dev = port->dev;
514 unsigned int i, j, n;
515
516 printk(KERN_INFO "%s: risc disasm: %p [dma=0x%08lx]\n",
517 dev->name, risc->cpu, (unsigned long)risc->dma);
518 for (i = 0; i < (risc->size >> 2); i += n) {
519 printk(KERN_INFO "%s: %04d: ", dev->name, i);
520 n = cx23885_risc_decode(le32_to_cpu(risc->cpu[i]));
521 for (j = 1; j < n; j++)
522 printk(KERN_INFO "%s: %04d: 0x%08x [ arg #%d ]\n",
523 dev->name, i + j, risc->cpu[i + j], j);
524 if (risc->cpu[i] == cpu_to_le32(RISC_JUMP))
525 break;
526 }
527 }
528
529 static void cx23885_shutdown(struct cx23885_dev *dev)
530 {
531 /* disable RISC controller */
532 cx_write(DEV_CNTRL2, 0);
533
534 /* Disable all IR activity */
535 cx_write(IR_CNTRL_REG, 0);
536
537 /* Disable Video A/B activity */
538 cx_write(VID_A_DMA_CTL, 0);
539 cx_write(VID_B_DMA_CTL, 0);
540 cx_write(VID_C_DMA_CTL, 0);
541
542 /* Disable Audio activity */
543 cx_write(AUD_INT_DMA_CTL, 0);
544 cx_write(AUD_EXT_DMA_CTL, 0);
545
546 /* Disable Serial port */
547 cx_write(UART_CTL, 0);
548
549 /* Disable Interrupts */
550 cx_write(PCI_INT_MSK, 0);
551 cx_write(VID_A_INT_MSK, 0);
552 cx_write(VID_B_INT_MSK, 0);
553 cx_write(VID_C_INT_MSK, 0);
554 cx_write(AUDIO_INT_INT_MSK, 0);
555 cx_write(AUDIO_EXT_INT_MSK, 0);
556
557 }
558
559 static void cx23885_reset(struct cx23885_dev *dev)
560 {
561 dprintk(1, "%s()\n", __func__);
562
563 cx23885_shutdown(dev);
564
565 cx_write(PCI_INT_STAT, 0xffffffff);
566 cx_write(VID_A_INT_STAT, 0xffffffff);
567 cx_write(VID_B_INT_STAT, 0xffffffff);
568 cx_write(VID_C_INT_STAT, 0xffffffff);
569 cx_write(AUDIO_INT_INT_STAT, 0xffffffff);
570 cx_write(AUDIO_EXT_INT_STAT, 0xffffffff);
571 cx_write(CLK_DELAY, cx_read(CLK_DELAY) & 0x80000000);
572 cx_write(PAD_CTRL, 0x00500300);
573
574 mdelay(100);
575
576 cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH01],
577 720*4, 0);
578 cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH02], 128, 0);
579 cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH03],
580 188*4, 0);
581 cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH04], 128, 0);
582 cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH05], 128, 0);
583 cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH06],
584 188*4, 0);
585 cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH07], 128, 0);
586 cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH08], 128, 0);
587 cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH09], 128, 0);
588
589 cx23885_gpio_setup(dev);
590 }
591
592
593 static int cx23885_pci_quirks(struct cx23885_dev *dev)
594 {
595 dprintk(1, "%s()\n", __func__);
596
597 /* The cx23885 bridge has a weird bug which causes NMI to be asserted
598 * when DMA begins if RDR_TLCTL0 bit4 is not cleared. It does not
599 * occur on the cx23887 bridge.
600 */
601 if (dev->bridge == CX23885_BRIDGE_885)
602 cx_clear(RDR_TLCTL0, 1 << 4);
603
604 return 0;
605 }
606
607 static int get_resources(struct cx23885_dev *dev)
608 {
609 if (request_mem_region(pci_resource_start(dev->pci, 0),
610 pci_resource_len(dev->pci, 0),
611 dev->name))
612 return 0;
613
614 printk(KERN_ERR "%s: can't get MMIO memory @ 0x%llx\n",
615 dev->name, (unsigned long long)pci_resource_start(dev->pci, 0));
616
617 return -EBUSY;
618 }
619
620 static void cx23885_timeout(unsigned long data);
621 int cx23885_risc_stopper(struct pci_dev *pci, struct btcx_riscmem *risc,
622 u32 reg, u32 mask, u32 value);
623
624 static int cx23885_init_tsport(struct cx23885_dev *dev,
625 struct cx23885_tsport *port, int portno)
626 {
627 dprintk(1, "%s(portno=%d)\n", __func__, portno);
628
629 /* Transport bus init dma queue - Common settings */
630 port->dma_ctl_val = 0x11; /* Enable RISC controller and Fifo */
631 port->ts_int_msk_val = 0x1111; /* TS port bits for RISC */
632 port->vld_misc_val = 0x0;
633 port->hw_sop_ctrl_val = (0x47 << 16 | 188 << 4);
634
635 spin_lock_init(&port->slock);
636 port->dev = dev;
637 port->nr = portno;
638
639 INIT_LIST_HEAD(&port->mpegq.active);
640 INIT_LIST_HEAD(&port->mpegq.queued);
641 port->mpegq.timeout.function = cx23885_timeout;
642 port->mpegq.timeout.data = (unsigned long)port;
643 init_timer(&port->mpegq.timeout);
644
645 mutex_init(&port->frontends.lock);
646 INIT_LIST_HEAD(&port->frontends.felist);
647 port->frontends.active_fe_id = 0;
648
649 /* This should be hardcoded allow a single frontend
650 * attachment to this tsport, keeping the -dvb.c
651 * code clean and safe.
652 */
653 if (!port->num_frontends)
654 port->num_frontends = 1;
655
656 switch (portno) {
657 case 1:
658 port->reg_gpcnt = VID_B_GPCNT;
659 port->reg_gpcnt_ctl = VID_B_GPCNT_CTL;
660 port->reg_dma_ctl = VID_B_DMA_CTL;
661 port->reg_lngth = VID_B_LNGTH;
662 port->reg_hw_sop_ctrl = VID_B_HW_SOP_CTL;
663 port->reg_gen_ctrl = VID_B_GEN_CTL;
664 port->reg_bd_pkt_status = VID_B_BD_PKT_STATUS;
665 port->reg_sop_status = VID_B_SOP_STATUS;
666 port->reg_fifo_ovfl_stat = VID_B_FIFO_OVFL_STAT;
667 port->reg_vld_misc = VID_B_VLD_MISC;
668 port->reg_ts_clk_en = VID_B_TS_CLK_EN;
669 port->reg_src_sel = VID_B_SRC_SEL;
670 port->reg_ts_int_msk = VID_B_INT_MSK;
671 port->reg_ts_int_stat = VID_B_INT_STAT;
672 port->sram_chno = SRAM_CH03; /* VID_B */
673 port->pci_irqmask = 0x02; /* VID_B bit1 */
674 break;
675 case 2:
676 port->reg_gpcnt = VID_C_GPCNT;
677 port->reg_gpcnt_ctl = VID_C_GPCNT_CTL;
678 port->reg_dma_ctl = VID_C_DMA_CTL;
679 port->reg_lngth = VID_C_LNGTH;
680 port->reg_hw_sop_ctrl = VID_C_HW_SOP_CTL;
681 port->reg_gen_ctrl = VID_C_GEN_CTL;
682 port->reg_bd_pkt_status = VID_C_BD_PKT_STATUS;
683 port->reg_sop_status = VID_C_SOP_STATUS;
684 port->reg_fifo_ovfl_stat = VID_C_FIFO_OVFL_STAT;
685 port->reg_vld_misc = VID_C_VLD_MISC;
686 port->reg_ts_clk_en = VID_C_TS_CLK_EN;
687 port->reg_src_sel = 0;
688 port->reg_ts_int_msk = VID_C_INT_MSK;
689 port->reg_ts_int_stat = VID_C_INT_STAT;
690 port->sram_chno = SRAM_CH06; /* VID_C */
691 port->pci_irqmask = 0x04; /* VID_C bit2 */
692 break;
693 default:
694 BUG();
695 }
696
697 cx23885_risc_stopper(dev->pci, &port->mpegq.stopper,
698 port->reg_dma_ctl, port->dma_ctl_val, 0x00);
699
700 return 0;
701 }
702
703 static void cx23885_dev_checkrevision(struct cx23885_dev *dev)
704 {
705 switch (cx_read(RDR_CFG2) & 0xff) {
706 case 0x00:
707 /* cx23885 */
708 dev->hwrevision = 0xa0;
709 break;
710 case 0x01:
711 /* CX23885-12Z */
712 dev->hwrevision = 0xa1;
713 break;
714 case 0x02:
715 /* CX23885-13Z */
716 dev->hwrevision = 0xb0;
717 break;
718 case 0x03:
719 /* CX23888-22Z */
720 dev->hwrevision = 0xc0;
721 break;
722 case 0x0e:
723 /* CX23887-15Z */
724 dev->hwrevision = 0xc0;
725 case 0x0f:
726 /* CX23887-14Z */
727 dev->hwrevision = 0xb1;
728 break;
729 default:
730 printk(KERN_ERR "%s() New hardware revision found 0x%x\n",
731 __func__, dev->hwrevision);
732 }
733 if (dev->hwrevision)
734 printk(KERN_INFO "%s() Hardware revision = 0x%02x\n",
735 __func__, dev->hwrevision);
736 else
737 printk(KERN_ERR "%s() Hardware revision unknown 0x%x\n",
738 __func__, dev->hwrevision);
739 }
740
741 static int cx23885_dev_setup(struct cx23885_dev *dev)
742 {
743 int i;
744
745 mutex_init(&dev->lock);
746
747 atomic_inc(&dev->refcount);
748
749 dev->nr = cx23885_devcount++;
750 sprintf(dev->name, "cx23885[%d]", dev->nr);
751
752 mutex_lock(&devlist);
753 list_add_tail(&dev->devlist, &cx23885_devlist);
754 mutex_unlock(&devlist);
755
756 /* Configure the internal memory */
757 if (dev->pci->device == 0x8880) {
758 dev->bridge = CX23885_BRIDGE_887;
759 /* Apply a sensible clock frequency for the PCIe bridge */
760 dev->clk_freq = 25000000;
761 dev->sram_channels = cx23887_sram_channels;
762 } else
763 if (dev->pci->device == 0x8852) {
764 dev->bridge = CX23885_BRIDGE_885;
765 /* Apply a sensible clock frequency for the PCIe bridge */
766 dev->clk_freq = 28000000;
767 dev->sram_channels = cx23885_sram_channels;
768 } else
769 BUG();
770
771 dprintk(1, "%s() Memory configured for PCIe bridge type %d\n",
772 __func__, dev->bridge);
773
774 /* board config */
775 dev->board = UNSET;
776 if (card[dev->nr] < cx23885_bcount)
777 dev->board = card[dev->nr];
778 for (i = 0; UNSET == dev->board && i < cx23885_idcount; i++)
779 if (dev->pci->subsystem_vendor == cx23885_subids[i].subvendor &&
780 dev->pci->subsystem_device == cx23885_subids[i].subdevice)
781 dev->board = cx23885_subids[i].card;
782 if (UNSET == dev->board) {
783 dev->board = CX23885_BOARD_UNKNOWN;
784 cx23885_card_list(dev);
785 }
786
787 /* If the user specific a clk freq override, apply it */
788 if (cx23885_boards[dev->board].clk_freq > 0)
789 dev->clk_freq = cx23885_boards[dev->board].clk_freq;
790
791 dev->pci_bus = dev->pci->bus->number;
792 dev->pci_slot = PCI_SLOT(dev->pci->devfn);
793 dev->pci_irqmask = 0x001f00;
794
795 /* External Master 1 Bus */
796 dev->i2c_bus[0].nr = 0;
797 dev->i2c_bus[0].dev = dev;
798 dev->i2c_bus[0].reg_stat = I2C1_STAT;
799 dev->i2c_bus[0].reg_ctrl = I2C1_CTRL;
800 dev->i2c_bus[0].reg_addr = I2C1_ADDR;
801 dev->i2c_bus[0].reg_rdata = I2C1_RDATA;
802 dev->i2c_bus[0].reg_wdata = I2C1_WDATA;
803 dev->i2c_bus[0].i2c_period = (0x9d << 24); /* 100kHz */
804
805 /* External Master 2 Bus */
806 dev->i2c_bus[1].nr = 1;
807 dev->i2c_bus[1].dev = dev;
808 dev->i2c_bus[1].reg_stat = I2C2_STAT;
809 dev->i2c_bus[1].reg_ctrl = I2C2_CTRL;
810 dev->i2c_bus[1].reg_addr = I2C2_ADDR;
811 dev->i2c_bus[1].reg_rdata = I2C2_RDATA;
812 dev->i2c_bus[1].reg_wdata = I2C2_WDATA;
813 dev->i2c_bus[1].i2c_period = (0x9d << 24); /* 100kHz */
814
815 /* Internal Master 3 Bus */
816 dev->i2c_bus[2].nr = 2;
817 dev->i2c_bus[2].dev = dev;
818 dev->i2c_bus[2].reg_stat = I2C3_STAT;
819 dev->i2c_bus[2].reg_ctrl = I2C3_CTRL;
820 dev->i2c_bus[2].reg_addr = I2C3_ADDR;
821 dev->i2c_bus[2].reg_rdata = I2C3_RDATA;
822 dev->i2c_bus[2].reg_wdata = I2C3_WDATA;
823 dev->i2c_bus[2].i2c_period = (0x07 << 24); /* 1.95MHz */
824
825 if ((cx23885_boards[dev->board].portb == CX23885_MPEG_DVB) ||
826 (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER))
827 cx23885_init_tsport(dev, &dev->ts1, 1);
828
829 if ((cx23885_boards[dev->board].portc == CX23885_MPEG_DVB) ||
830 (cx23885_boards[dev->board].portc == CX23885_MPEG_ENCODER))
831 cx23885_init_tsport(dev, &dev->ts2, 2);
832
833 if (get_resources(dev) < 0) {
834 printk(KERN_ERR "CORE %s No more PCIe resources for "
835 "subsystem: %04x:%04x\n",
836 dev->name, dev->pci->subsystem_vendor,
837 dev->pci->subsystem_device);
838
839 cx23885_devcount--;
840 return -ENODEV;
841 }
842
843 /* PCIe stuff */
844 dev->lmmio = ioremap(pci_resource_start(dev->pci, 0),
845 pci_resource_len(dev->pci, 0));
846
847 dev->bmmio = (u8 __iomem *)dev->lmmio;
848
849 printk(KERN_INFO "CORE %s: subsystem: %04x:%04x, board: %s [card=%d,%s]\n",
850 dev->name, dev->pci->subsystem_vendor,
851 dev->pci->subsystem_device, cx23885_boards[dev->board].name,
852 dev->board, card[dev->nr] == dev->board ?
853 "insmod option" : "autodetected");
854
855 cx23885_pci_quirks(dev);
856
857 /* Assume some sensible defaults */
858 dev->tuner_type = cx23885_boards[dev->board].tuner_type;
859 dev->tuner_addr = cx23885_boards[dev->board].tuner_addr;
860 dev->radio_type = cx23885_boards[dev->board].radio_type;
861 dev->radio_addr = cx23885_boards[dev->board].radio_addr;
862
863 dprintk(1, "%s() tuner_type = 0x%x tuner_addr = 0x%x\n",
864 __func__, dev->tuner_type, dev->tuner_addr);
865 dprintk(1, "%s() radio_type = 0x%x radio_addr = 0x%x\n",
866 __func__, dev->radio_type, dev->radio_addr);
867
868 /* init hardware */
869 cx23885_reset(dev);
870
871 cx23885_i2c_register(&dev->i2c_bus[0]);
872 cx23885_i2c_register(&dev->i2c_bus[1]);
873 cx23885_i2c_register(&dev->i2c_bus[2]);
874 cx23885_card_setup(dev);
875 cx23885_call_i2c_clients(&dev->i2c_bus[0], TUNER_SET_STANDBY, NULL);
876 cx23885_ir_init(dev);
877
878 if (cx23885_boards[dev->board].porta == CX23885_ANALOG_VIDEO) {
879 if (cx23885_video_register(dev) < 0) {
880 printk(KERN_ERR "%s() Failed to register analog "
881 "video adapters on VID_A\n", __func__);
882 }
883 }
884
885 if (cx23885_boards[dev->board].portb == CX23885_MPEG_DVB) {
886 if (cx23885_dvb_register(&dev->ts1) < 0) {
887 printk(KERN_ERR "%s() Failed to register dvb adapters on VID_B\n",
888 __func__);
889 }
890 } else
891 if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER) {
892 if (cx23885_417_register(dev) < 0) {
893 printk(KERN_ERR
894 "%s() Failed to register 417 on VID_B\n",
895 __func__);
896 }
897 }
898
899 if (cx23885_boards[dev->board].portc == CX23885_MPEG_DVB) {
900 if (cx23885_dvb_register(&dev->ts2) < 0) {
901 printk(KERN_ERR
902 "%s() Failed to register dvb on VID_C\n",
903 __func__);
904 }
905 } else
906 if (cx23885_boards[dev->board].portc == CX23885_MPEG_ENCODER) {
907 if (cx23885_417_register(dev) < 0) {
908 printk(KERN_ERR
909 "%s() Failed to register 417 on VID_C\n",
910 __func__);
911 }
912 }
913
914 cx23885_dev_checkrevision(dev);
915
916 return 0;
917 }
918
919 static void cx23885_dev_unregister(struct cx23885_dev *dev)
920 {
921 release_mem_region(pci_resource_start(dev->pci, 0),
922 pci_resource_len(dev->pci, 0));
923
924 if (!atomic_dec_and_test(&dev->refcount))
925 return;
926
927 if (cx23885_boards[dev->board].porta == CX23885_ANALOG_VIDEO)
928 cx23885_video_unregister(dev);
929
930 if (cx23885_boards[dev->board].portb == CX23885_MPEG_DVB)
931 cx23885_dvb_unregister(&dev->ts1);
932
933 if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER)
934 cx23885_417_unregister(dev);
935
936 if (cx23885_boards[dev->board].portc == CX23885_MPEG_DVB)
937 cx23885_dvb_unregister(&dev->ts2);
938
939 if (cx23885_boards[dev->board].portc == CX23885_MPEG_ENCODER)
940 cx23885_417_unregister(dev);
941
942 cx23885_i2c_unregister(&dev->i2c_bus[2]);
943 cx23885_i2c_unregister(&dev->i2c_bus[1]);
944 cx23885_i2c_unregister(&dev->i2c_bus[0]);
945
946 iounmap(dev->lmmio);
947 }
948
949 static __le32 *cx23885_risc_field(__le32 *rp, struct scatterlist *sglist,
950 unsigned int offset, u32 sync_line,
951 unsigned int bpl, unsigned int padding,
952 unsigned int lines)
953 {
954 struct scatterlist *sg;
955 unsigned int line, todo;
956
957 /* sync instruction */
958 if (sync_line != NO_SYNC_LINE)
959 *(rp++) = cpu_to_le32(RISC_RESYNC | sync_line);
960
961 /* scan lines */
962 sg = sglist;
963 for (line = 0; line < lines; line++) {
964 while (offset && offset >= sg_dma_len(sg)) {
965 offset -= sg_dma_len(sg);
966 sg++;
967 }
968 if (bpl <= sg_dma_len(sg)-offset) {
969 /* fits into current chunk */
970 *(rp++) = cpu_to_le32(RISC_WRITE|RISC_SOL|RISC_EOL|bpl);
971 *(rp++) = cpu_to_le32(sg_dma_address(sg)+offset);
972 *(rp++) = cpu_to_le32(0); /* bits 63-32 */
973 offset += bpl;
974 } else {
975 /* scanline needs to be split */
976 todo = bpl;
977 *(rp++) = cpu_to_le32(RISC_WRITE|RISC_SOL|
978 (sg_dma_len(sg)-offset));
979 *(rp++) = cpu_to_le32(sg_dma_address(sg)+offset);
980 *(rp++) = cpu_to_le32(0); /* bits 63-32 */
981 todo -= (sg_dma_len(sg)-offset);
982 offset = 0;
983 sg++;
984 while (todo > sg_dma_len(sg)) {
985 *(rp++) = cpu_to_le32(RISC_WRITE|
986 sg_dma_len(sg));
987 *(rp++) = cpu_to_le32(sg_dma_address(sg));
988 *(rp++) = cpu_to_le32(0); /* bits 63-32 */
989 todo -= sg_dma_len(sg);
990 sg++;
991 }
992 *(rp++) = cpu_to_le32(RISC_WRITE|RISC_EOL|todo);
993 *(rp++) = cpu_to_le32(sg_dma_address(sg));
994 *(rp++) = cpu_to_le32(0); /* bits 63-32 */
995 offset += todo;
996 }
997 offset += padding;
998 }
999
1000 return rp;
1001 }
1002
1003 int cx23885_risc_buffer(struct pci_dev *pci, struct btcx_riscmem *risc,
1004 struct scatterlist *sglist, unsigned int top_offset,
1005 unsigned int bottom_offset, unsigned int bpl,
1006 unsigned int padding, unsigned int lines)
1007 {
1008 u32 instructions, fields;
1009 __le32 *rp;
1010 int rc;
1011
1012 fields = 0;
1013 if (UNSET != top_offset)
1014 fields++;
1015 if (UNSET != bottom_offset)
1016 fields++;
1017
1018 /* estimate risc mem: worst case is one write per page border +
1019 one write per scan line + syncs + jump (all 2 dwords). Padding
1020 can cause next bpl to start close to a page border. First DMA
1021 region may be smaller than PAGE_SIZE */
1022 /* write and jump need and extra dword */
1023 instructions = fields * (1 + ((bpl + padding) * lines)
1024 / PAGE_SIZE + lines);
1025 instructions += 2;
1026 rc = btcx_riscmem_alloc(pci, risc, instructions*12);
1027 if (rc < 0)
1028 return rc;
1029
1030 /* write risc instructions */
1031 rp = risc->cpu;
1032 if (UNSET != top_offset)
1033 rp = cx23885_risc_field(rp, sglist, top_offset, 0,
1034 bpl, padding, lines);
1035 if (UNSET != bottom_offset)
1036 rp = cx23885_risc_field(rp, sglist, bottom_offset, 0x200,
1037 bpl, padding, lines);
1038
1039 /* save pointer to jmp instruction address */
1040 risc->jmp = rp;
1041 BUG_ON((risc->jmp - risc->cpu + 2) * sizeof(*risc->cpu) > risc->size);
1042 return 0;
1043 }
1044
1045 static int cx23885_risc_databuffer(struct pci_dev *pci,
1046 struct btcx_riscmem *risc,
1047 struct scatterlist *sglist,
1048 unsigned int bpl,
1049 unsigned int lines)
1050 {
1051 u32 instructions;
1052 __le32 *rp;
1053 int rc;
1054
1055 /* estimate risc mem: worst case is one write per page border +
1056 one write per scan line + syncs + jump (all 2 dwords). Here
1057 there is no padding and no sync. First DMA region may be smaller
1058 than PAGE_SIZE */
1059 /* Jump and write need an extra dword */
1060 instructions = 1 + (bpl * lines) / PAGE_SIZE + lines;
1061 instructions += 1;
1062
1063 rc = btcx_riscmem_alloc(pci, risc, instructions*12);
1064 if (rc < 0)
1065 return rc;
1066
1067 /* write risc instructions */
1068 rp = risc->cpu;
1069 rp = cx23885_risc_field(rp, sglist, 0, NO_SYNC_LINE, bpl, 0, lines);
1070
1071 /* save pointer to jmp instruction address */
1072 risc->jmp = rp;
1073 BUG_ON((risc->jmp - risc->cpu + 2) * sizeof(*risc->cpu) > risc->size);
1074 return 0;
1075 }
1076
1077 int cx23885_risc_stopper(struct pci_dev *pci, struct btcx_riscmem *risc,
1078 u32 reg, u32 mask, u32 value)
1079 {
1080 __le32 *rp;
1081 int rc;
1082
1083 rc = btcx_riscmem_alloc(pci, risc, 4*16);
1084 if (rc < 0)
1085 return rc;
1086
1087 /* write risc instructions */
1088 rp = risc->cpu;
1089 *(rp++) = cpu_to_le32(RISC_WRITECR | RISC_IRQ2);
1090 *(rp++) = cpu_to_le32(reg);
1091 *(rp++) = cpu_to_le32(value);
1092 *(rp++) = cpu_to_le32(mask);
1093 *(rp++) = cpu_to_le32(RISC_JUMP);
1094 *(rp++) = cpu_to_le32(risc->dma);
1095 *(rp++) = cpu_to_le32(0); /* bits 63-32 */
1096 return 0;
1097 }
1098
1099 void cx23885_free_buffer(struct videobuf_queue *q, struct cx23885_buffer *buf)
1100 {
1101 struct videobuf_dmabuf *dma = videobuf_to_dma(&buf->vb);
1102
1103 BUG_ON(in_interrupt());
1104 videobuf_waiton(&buf->vb, 0, 0);
1105 videobuf_dma_unmap(q, dma);
1106 videobuf_dma_free(dma);
1107 btcx_riscmem_free(to_pci_dev(q->dev), &buf->risc);
1108 buf->vb.state = VIDEOBUF_NEEDS_INIT;
1109 }
1110
1111 static void cx23885_tsport_reg_dump(struct cx23885_tsport *port)
1112 {
1113 struct cx23885_dev *dev = port->dev;
1114
1115 dprintk(1, "%s() Register Dump\n", __func__);
1116 dprintk(1, "%s() DEV_CNTRL2 0x%08X\n", __func__,
1117 cx_read(DEV_CNTRL2));
1118 dprintk(1, "%s() PCI_INT_MSK 0x%08X\n", __func__,
1119 cx_read(PCI_INT_MSK));
1120 dprintk(1, "%s() AUD_INT_INT_MSK 0x%08X\n", __func__,
1121 cx_read(AUDIO_INT_INT_MSK));
1122 dprintk(1, "%s() AUD_INT_DMA_CTL 0x%08X\n", __func__,
1123 cx_read(AUD_INT_DMA_CTL));
1124 dprintk(1, "%s() AUD_EXT_INT_MSK 0x%08X\n", __func__,
1125 cx_read(AUDIO_EXT_INT_MSK));
1126 dprintk(1, "%s() AUD_EXT_DMA_CTL 0x%08X\n", __func__,
1127 cx_read(AUD_EXT_DMA_CTL));
1128 dprintk(1, "%s() PAD_CTRL 0x%08X\n", __func__,
1129 cx_read(PAD_CTRL));
1130 dprintk(1, "%s() ALT_PIN_OUT_SEL 0x%08X\n", __func__,
1131 cx_read(ALT_PIN_OUT_SEL));
1132 dprintk(1, "%s() GPIO2 0x%08X\n", __func__,
1133 cx_read(GPIO2));
1134 dprintk(1, "%s() gpcnt(0x%08X) 0x%08X\n", __func__,
1135 port->reg_gpcnt, cx_read(port->reg_gpcnt));
1136 dprintk(1, "%s() gpcnt_ctl(0x%08X) 0x%08x\n", __func__,
1137 port->reg_gpcnt_ctl, cx_read(port->reg_gpcnt_ctl));
1138 dprintk(1, "%s() dma_ctl(0x%08X) 0x%08x\n", __func__,
1139 port->reg_dma_ctl, cx_read(port->reg_dma_ctl));
1140 if (port->reg_src_sel)
1141 dprintk(1, "%s() src_sel(0x%08X) 0x%08x\n", __func__,
1142 port->reg_src_sel, cx_read(port->reg_src_sel));
1143 dprintk(1, "%s() lngth(0x%08X) 0x%08x\n", __func__,
1144 port->reg_lngth, cx_read(port->reg_lngth));
1145 dprintk(1, "%s() hw_sop_ctrl(0x%08X) 0x%08x\n", __func__,
1146 port->reg_hw_sop_ctrl, cx_read(port->reg_hw_sop_ctrl));
1147 dprintk(1, "%s() gen_ctrl(0x%08X) 0x%08x\n", __func__,
1148 port->reg_gen_ctrl, cx_read(port->reg_gen_ctrl));
1149 dprintk(1, "%s() bd_pkt_status(0x%08X) 0x%08x\n", __func__,
1150 port->reg_bd_pkt_status, cx_read(port->reg_bd_pkt_status));
1151 dprintk(1, "%s() sop_status(0x%08X) 0x%08x\n", __func__,
1152 port->reg_sop_status, cx_read(port->reg_sop_status));
1153 dprintk(1, "%s() fifo_ovfl_stat(0x%08X) 0x%08x\n", __func__,
1154 port->reg_fifo_ovfl_stat, cx_read(port->reg_fifo_ovfl_stat));
1155 dprintk(1, "%s() vld_misc(0x%08X) 0x%08x\n", __func__,
1156 port->reg_vld_misc, cx_read(port->reg_vld_misc));
1157 dprintk(1, "%s() ts_clk_en(0x%08X) 0x%08x\n", __func__,
1158 port->reg_ts_clk_en, cx_read(port->reg_ts_clk_en));
1159 dprintk(1, "%s() ts_int_msk(0x%08X) 0x%08x\n", __func__,
1160 port->reg_ts_int_msk, cx_read(port->reg_ts_int_msk));
1161 }
1162
1163 static int cx23885_start_dma(struct cx23885_tsport *port,
1164 struct cx23885_dmaqueue *q,
1165 struct cx23885_buffer *buf)
1166 {
1167 struct cx23885_dev *dev = port->dev;
1168 u32 reg;
1169
1170 dprintk(1, "%s() w: %d, h: %d, f: %d\n", __func__,
1171 buf->vb.width, buf->vb.height, buf->vb.field);
1172
1173 /* Stop the fifo and risc engine for this port */
1174 cx_clear(port->reg_dma_ctl, port->dma_ctl_val);
1175
1176 /* setup fifo + format */
1177 cx23885_sram_channel_setup(dev,
1178 &dev->sram_channels[port->sram_chno],
1179 port->ts_packet_size, buf->risc.dma);
1180 if (debug > 5) {
1181 cx23885_sram_channel_dump(dev,
1182 &dev->sram_channels[port->sram_chno]);
1183 cx23885_risc_disasm(port, &buf->risc);
1184 }
1185
1186 /* write TS length to chip */
1187 cx_write(port->reg_lngth, buf->vb.width);
1188
1189 if ((!(cx23885_boards[dev->board].portb & CX23885_MPEG_DVB)) &&
1190 (!(cx23885_boards[dev->board].portc & CX23885_MPEG_DVB))) {
1191 printk("%s() Unsupported .portb/c (0x%08x)/(0x%08x)\n",
1192 __func__,
1193 cx23885_boards[dev->board].portb,
1194 cx23885_boards[dev->board].portc);
1195 return -EINVAL;
1196 }
1197
1198 if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER)
1199 cx23885_av_clk(dev, 0);
1200
1201 udelay(100);
1202
1203 /* If the port supports SRC SELECT, configure it */
1204 if (port->reg_src_sel)
1205 cx_write(port->reg_src_sel, port->src_sel_val);
1206
1207 cx_write(port->reg_hw_sop_ctrl, port->hw_sop_ctrl_val);
1208 cx_write(port->reg_ts_clk_en, port->ts_clk_en_val);
1209 cx_write(port->reg_vld_misc, port->vld_misc_val);
1210 cx_write(port->reg_gen_ctrl, port->gen_ctrl_val);
1211 udelay(100);
1212
1213 /* NOTE: this is 2 (reserved) for portb, does it matter? */
1214 /* reset counter to zero */
1215 cx_write(port->reg_gpcnt_ctl, 3);
1216 q->count = 1;
1217
1218 /* Set VIDB pins to input */
1219 if (cx23885_boards[dev->board].portb == CX23885_MPEG_DVB) {
1220 reg = cx_read(PAD_CTRL);
1221 reg &= ~0x3; /* Clear TS1_OE & TS1_SOP_OE */
1222 cx_write(PAD_CTRL, reg);
1223 }
1224
1225 /* Set VIDC pins to input */
1226 if (cx23885_boards[dev->board].portc == CX23885_MPEG_DVB) {
1227 reg = cx_read(PAD_CTRL);
1228 reg &= ~0x4; /* Clear TS2_SOP_OE */
1229 cx_write(PAD_CTRL, reg);
1230 }
1231
1232 if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER) {
1233
1234 reg = cx_read(PAD_CTRL);
1235 reg = reg & ~0x1; /* Clear TS1_OE */
1236
1237 /* FIXME, bit 2 writing here is questionable */
1238 /* set TS1_SOP_OE and TS1_OE_HI */
1239 reg = reg | 0xa;
1240 cx_write(PAD_CTRL, reg);
1241
1242 /* FIXME and these two registers should be documented. */
1243 cx_write(CLK_DELAY, cx_read(CLK_DELAY) | 0x80000011);
1244 cx_write(ALT_PIN_OUT_SEL, 0x10100045);
1245 }
1246
1247 switch (dev->bridge) {
1248 case CX23885_BRIDGE_885:
1249 case CX23885_BRIDGE_887:
1250 /* enable irqs */
1251 dprintk(1, "%s() enabling TS int's and DMA\n", __func__);
1252 cx_set(port->reg_ts_int_msk, port->ts_int_msk_val);
1253 cx_set(port->reg_dma_ctl, port->dma_ctl_val);
1254 cx_set(PCI_INT_MSK, dev->pci_irqmask | port->pci_irqmask);
1255 break;
1256 default:
1257 BUG();
1258 }
1259
1260 cx_set(DEV_CNTRL2, (1<<5)); /* Enable RISC controller */
1261
1262 if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER)
1263 cx23885_av_clk(dev, 1);
1264
1265 if (debug > 4)
1266 cx23885_tsport_reg_dump(port);
1267
1268 return 0;
1269 }
1270
1271 static int cx23885_stop_dma(struct cx23885_tsport *port)
1272 {
1273 struct cx23885_dev *dev = port->dev;
1274 u32 reg;
1275
1276 dprintk(1, "%s()\n", __func__);
1277
1278 /* Stop interrupts and DMA */
1279 cx_clear(port->reg_ts_int_msk, port->ts_int_msk_val);
1280 cx_clear(port->reg_dma_ctl, port->dma_ctl_val);
1281
1282 if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER) {
1283
1284 reg = cx_read(PAD_CTRL);
1285
1286 /* Set TS1_OE */
1287 reg = reg | 0x1;
1288
1289 /* clear TS1_SOP_OE and TS1_OE_HI */
1290 reg = reg & ~0xa;
1291 cx_write(PAD_CTRL, reg);
1292 cx_write(port->reg_src_sel, 0);
1293 cx_write(port->reg_gen_ctrl, 8);
1294
1295 }
1296
1297 if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER)
1298 cx23885_av_clk(dev, 0);
1299
1300 return 0;
1301 }
1302
1303 int cx23885_restart_queue(struct cx23885_tsport *port,
1304 struct cx23885_dmaqueue *q)
1305 {
1306 struct cx23885_dev *dev = port->dev;
1307 struct cx23885_buffer *buf;
1308
1309 dprintk(5, "%s()\n", __func__);
1310 if (list_empty(&q->active)) {
1311 struct cx23885_buffer *prev;
1312 prev = NULL;
1313
1314 dprintk(5, "%s() queue is empty\n", __func__);
1315
1316 for (;;) {
1317 if (list_empty(&q->queued))
1318 return 0;
1319 buf = list_entry(q->queued.next, struct cx23885_buffer,
1320 vb.queue);
1321 if (NULL == prev) {
1322 list_del(&buf->vb.queue);
1323 list_add_tail(&buf->vb.queue, &q->active);
1324 cx23885_start_dma(port, q, buf);
1325 buf->vb.state = VIDEOBUF_ACTIVE;
1326 buf->count = q->count++;
1327 mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
1328 dprintk(5, "[%p/%d] restart_queue - f/active\n",
1329 buf, buf->vb.i);
1330
1331 } else if (prev->vb.width == buf->vb.width &&
1332 prev->vb.height == buf->vb.height &&
1333 prev->fmt == buf->fmt) {
1334 list_del(&buf->vb.queue);
1335 list_add_tail(&buf->vb.queue, &q->active);
1336 buf->vb.state = VIDEOBUF_ACTIVE;
1337 buf->count = q->count++;
1338 prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
1339 /* 64 bit bits 63-32 */
1340 prev->risc.jmp[2] = cpu_to_le32(0);
1341 dprintk(5, "[%p/%d] restart_queue - m/active\n",
1342 buf, buf->vb.i);
1343 } else {
1344 return 0;
1345 }
1346 prev = buf;
1347 }
1348 return 0;
1349 }
1350
1351 buf = list_entry(q->active.next, struct cx23885_buffer, vb.queue);
1352 dprintk(2, "restart_queue [%p/%d]: restart dma\n",
1353 buf, buf->vb.i);
1354 cx23885_start_dma(port, q, buf);
1355 list_for_each_entry(buf, &q->active, vb.queue)
1356 buf->count = q->count++;
1357 mod_timer(&q->timeout, jiffies + BUFFER_TIMEOUT);
1358 return 0;
1359 }
1360
1361 /* ------------------------------------------------------------------ */
1362
1363 int cx23885_buf_prepare(struct videobuf_queue *q, struct cx23885_tsport *port,
1364 struct cx23885_buffer *buf, enum v4l2_field field)
1365 {
1366 struct cx23885_dev *dev = port->dev;
1367 int size = port->ts_packet_size * port->ts_packet_count;
1368 int rc;
1369
1370 dprintk(1, "%s: %p\n", __func__, buf);
1371 if (0 != buf->vb.baddr && buf->vb.bsize < size)
1372 return -EINVAL;
1373
1374 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
1375 buf->vb.width = port->ts_packet_size;
1376 buf->vb.height = port->ts_packet_count;
1377 buf->vb.size = size;
1378 buf->vb.field = field /*V4L2_FIELD_TOP*/;
1379
1380 rc = videobuf_iolock(q, &buf->vb, NULL);
1381 if (0 != rc)
1382 goto fail;
1383 cx23885_risc_databuffer(dev->pci, &buf->risc,
1384 videobuf_to_dma(&buf->vb)->sglist,
1385 buf->vb.width, buf->vb.height);
1386 }
1387 buf->vb.state = VIDEOBUF_PREPARED;
1388 return 0;
1389
1390 fail:
1391 cx23885_free_buffer(q, buf);
1392 return rc;
1393 }
1394
1395 void cx23885_buf_queue(struct cx23885_tsport *port, struct cx23885_buffer *buf)
1396 {
1397 struct cx23885_buffer *prev;
1398 struct cx23885_dev *dev = port->dev;
1399 struct cx23885_dmaqueue *cx88q = &port->mpegq;
1400
1401 /* add jump to stopper */
1402 buf->risc.jmp[0] = cpu_to_le32(RISC_JUMP | RISC_IRQ1 | RISC_CNT_INC);
1403 buf->risc.jmp[1] = cpu_to_le32(cx88q->stopper.dma);
1404 buf->risc.jmp[2] = cpu_to_le32(0); /* bits 63-32 */
1405
1406 if (list_empty(&cx88q->active)) {
1407 dprintk(1, "queue is empty - first active\n");
1408 list_add_tail(&buf->vb.queue, &cx88q->active);
1409 cx23885_start_dma(port, cx88q, buf);
1410 buf->vb.state = VIDEOBUF_ACTIVE;
1411 buf->count = cx88q->count++;
1412 mod_timer(&cx88q->timeout, jiffies + BUFFER_TIMEOUT);
1413 dprintk(1, "[%p/%d] %s - first active\n",
1414 buf, buf->vb.i, __func__);
1415 } else {
1416 dprintk(1, "queue is not empty - append to active\n");
1417 prev = list_entry(cx88q->active.prev, struct cx23885_buffer,
1418 vb.queue);
1419 list_add_tail(&buf->vb.queue, &cx88q->active);
1420 buf->vb.state = VIDEOBUF_ACTIVE;
1421 buf->count = cx88q->count++;
1422 prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
1423 prev->risc.jmp[2] = cpu_to_le32(0); /* 64 bit bits 63-32 */
1424 dprintk(1, "[%p/%d] %s - append to active\n",
1425 buf, buf->vb.i, __func__);
1426 }
1427 }
1428
1429 /* ----------------------------------------------------------- */
1430
1431 static void do_cancel_buffers(struct cx23885_tsport *port, char *reason,
1432 int restart)
1433 {
1434 struct cx23885_dev *dev = port->dev;
1435 struct cx23885_dmaqueue *q = &port->mpegq;
1436 struct cx23885_buffer *buf;
1437 unsigned long flags;
1438
1439 spin_lock_irqsave(&port->slock, flags);
1440 while (!list_empty(&q->active)) {
1441 buf = list_entry(q->active.next, struct cx23885_buffer,
1442 vb.queue);
1443 list_del(&buf->vb.queue);
1444 buf->vb.state = VIDEOBUF_ERROR;
1445 wake_up(&buf->vb.done);
1446 dprintk(1, "[%p/%d] %s - dma=0x%08lx\n",
1447 buf, buf->vb.i, reason, (unsigned long)buf->risc.dma);
1448 }
1449 if (restart) {
1450 dprintk(1, "restarting queue\n");
1451 cx23885_restart_queue(port, q);
1452 }
1453 spin_unlock_irqrestore(&port->slock, flags);
1454 }
1455
1456 void cx23885_cancel_buffers(struct cx23885_tsport *port)
1457 {
1458 struct cx23885_dev *dev = port->dev;
1459 struct cx23885_dmaqueue *q = &port->mpegq;
1460
1461 dprintk(1, "%s()\n", __func__);
1462 del_timer_sync(&q->timeout);
1463 cx23885_stop_dma(port);
1464 do_cancel_buffers(port, "cancel", 0);
1465 }
1466
1467 static void cx23885_timeout(unsigned long data)
1468 {
1469 struct cx23885_tsport *port = (struct cx23885_tsport *)data;
1470 struct cx23885_dev *dev = port->dev;
1471
1472 dprintk(1, "%s()\n", __func__);
1473
1474 if (debug > 5)
1475 cx23885_sram_channel_dump(dev,
1476 &dev->sram_channels[port->sram_chno]);
1477
1478 cx23885_stop_dma(port);
1479 do_cancel_buffers(port, "timeout", 1);
1480 }
1481
1482 int cx23885_irq_417(struct cx23885_dev *dev, u32 status)
1483 {
1484 /* FIXME: port1 assumption here. */
1485 struct cx23885_tsport *port = &dev->ts1;
1486 int count = 0;
1487 int handled = 0;
1488
1489 if (status == 0)
1490 return handled;
1491
1492 count = cx_read(port->reg_gpcnt);
1493 dprintk(7, "status: 0x%08x mask: 0x%08x count: 0x%x\n",
1494 status, cx_read(port->reg_ts_int_msk), count);
1495
1496 if ((status & VID_B_MSK_BAD_PKT) ||
1497 (status & VID_B_MSK_OPC_ERR) ||
1498 (status & VID_B_MSK_VBI_OPC_ERR) ||
1499 (status & VID_B_MSK_SYNC) ||
1500 (status & VID_B_MSK_VBI_SYNC) ||
1501 (status & VID_B_MSK_OF) ||
1502 (status & VID_B_MSK_VBI_OF)) {
1503 printk(KERN_ERR "%s: V4L mpeg risc op code error, status "
1504 "= 0x%x\n", dev->name, status);
1505 if (status & VID_B_MSK_BAD_PKT)
1506 dprintk(1, " VID_B_MSK_BAD_PKT\n");
1507 if (status & VID_B_MSK_OPC_ERR)
1508 dprintk(1, " VID_B_MSK_OPC_ERR\n");
1509 if (status & VID_B_MSK_VBI_OPC_ERR)
1510 dprintk(1, " VID_B_MSK_VBI_OPC_ERR\n");
1511 if (status & VID_B_MSK_SYNC)
1512 dprintk(1, " VID_B_MSK_SYNC\n");
1513 if (status & VID_B_MSK_VBI_SYNC)
1514 dprintk(1, " VID_B_MSK_VBI_SYNC\n");
1515 if (status & VID_B_MSK_OF)
1516 dprintk(1, " VID_B_MSK_OF\n");
1517 if (status & VID_B_MSK_VBI_OF)
1518 dprintk(1, " VID_B_MSK_VBI_OF\n");
1519
1520 cx_clear(port->reg_dma_ctl, port->dma_ctl_val);
1521 cx23885_sram_channel_dump(dev,
1522 &dev->sram_channels[port->sram_chno]);
1523 cx23885_417_check_encoder(dev);
1524 } else if (status & VID_B_MSK_RISCI1) {
1525 dprintk(7, " VID_B_MSK_RISCI1\n");
1526 spin_lock(&port->slock);
1527 cx23885_wakeup(port, &port->mpegq, count);
1528 spin_unlock(&port->slock);
1529 } else if (status & VID_B_MSK_RISCI2) {
1530 dprintk(7, " VID_B_MSK_RISCI2\n");
1531 spin_lock(&port->slock);
1532 cx23885_restart_queue(port, &port->mpegq);
1533 spin_unlock(&port->slock);
1534 }
1535 if (status) {
1536 cx_write(port->reg_ts_int_stat, status);
1537 handled = 1;
1538 }
1539
1540 return handled;
1541 }
1542
1543 static int cx23885_irq_ts(struct cx23885_tsport *port, u32 status)
1544 {
1545 struct cx23885_dev *dev = port->dev;
1546 int handled = 0;
1547 u32 count;
1548
1549 if ((status & VID_BC_MSK_OPC_ERR) ||
1550 (status & VID_BC_MSK_BAD_PKT) ||
1551 (status & VID_BC_MSK_SYNC) ||
1552 (status & VID_BC_MSK_OF)) {
1553
1554 if (status & VID_BC_MSK_OPC_ERR)
1555 dprintk(7, " (VID_BC_MSK_OPC_ERR 0x%08x)\n",
1556 VID_BC_MSK_OPC_ERR);
1557
1558 if (status & VID_BC_MSK_BAD_PKT)
1559 dprintk(7, " (VID_BC_MSK_BAD_PKT 0x%08x)\n",
1560 VID_BC_MSK_BAD_PKT);
1561
1562 if (status & VID_BC_MSK_SYNC)
1563 dprintk(7, " (VID_BC_MSK_SYNC 0x%08x)\n",
1564 VID_BC_MSK_SYNC);
1565
1566 if (status & VID_BC_MSK_OF)
1567 dprintk(7, " (VID_BC_MSK_OF 0x%08x)\n",
1568 VID_BC_MSK_OF);
1569
1570 printk(KERN_ERR "%s: mpeg risc op code error\n", dev->name);
1571
1572 cx_clear(port->reg_dma_ctl, port->dma_ctl_val);
1573 cx23885_sram_channel_dump(dev,
1574 &dev->sram_channels[port->sram_chno]);
1575
1576 } else if (status & VID_BC_MSK_RISCI1) {
1577
1578 dprintk(7, " (RISCI1 0x%08x)\n", VID_BC_MSK_RISCI1);
1579
1580 spin_lock(&port->slock);
1581 count = cx_read(port->reg_gpcnt);
1582 cx23885_wakeup(port, &port->mpegq, count);
1583 spin_unlock(&port->slock);
1584
1585 } else if (status & VID_BC_MSK_RISCI2) {
1586
1587 dprintk(7, " (RISCI2 0x%08x)\n", VID_BC_MSK_RISCI2);
1588
1589 spin_lock(&port->slock);
1590 cx23885_restart_queue(port, &port->mpegq);
1591 spin_unlock(&port->slock);
1592
1593 }
1594 if (status) {
1595 cx_write(port->reg_ts_int_stat, status);
1596 handled = 1;
1597 }
1598
1599 return handled;
1600 }
1601
1602 static irqreturn_t cx23885_irq(int irq, void *dev_id)
1603 {
1604 struct cx23885_dev *dev = dev_id;
1605 struct cx23885_tsport *ts1 = &dev->ts1;
1606 struct cx23885_tsport *ts2 = &dev->ts2;
1607 u32 pci_status, pci_mask;
1608 u32 vida_status, vida_mask;
1609 u32 ts1_status, ts1_mask;
1610 u32 ts2_status, ts2_mask;
1611 int vida_count = 0, ts1_count = 0, ts2_count = 0, handled = 0;
1612
1613 pci_status = cx_read(PCI_INT_STAT);
1614 pci_mask = cx_read(PCI_INT_MSK);
1615 vida_status = cx_read(VID_A_INT_STAT);
1616 vida_mask = cx_read(VID_A_INT_MSK);
1617 ts1_status = cx_read(VID_B_INT_STAT);
1618 ts1_mask = cx_read(VID_B_INT_MSK);
1619 ts2_status = cx_read(VID_C_INT_STAT);
1620 ts2_mask = cx_read(VID_C_INT_MSK);
1621
1622 if ((pci_status == 0) && (ts2_status == 0) && (ts1_status == 0))
1623 goto out;
1624
1625 vida_count = cx_read(VID_A_GPCNT);
1626 ts1_count = cx_read(ts1->reg_gpcnt);
1627 ts2_count = cx_read(ts2->reg_gpcnt);
1628 dprintk(7, "pci_status: 0x%08x pci_mask: 0x%08x\n",
1629 pci_status, pci_mask);
1630 dprintk(7, "vida_status: 0x%08x vida_mask: 0x%08x count: 0x%x\n",
1631 vida_status, vida_mask, vida_count);
1632 dprintk(7, "ts1_status: 0x%08x ts1_mask: 0x%08x count: 0x%x\n",
1633 ts1_status, ts1_mask, ts1_count);
1634 dprintk(7, "ts2_status: 0x%08x ts2_mask: 0x%08x count: 0x%x\n",
1635 ts2_status, ts2_mask, ts2_count);
1636
1637 if ((pci_status & PCI_MSK_RISC_RD) ||
1638 (pci_status & PCI_MSK_RISC_WR) ||
1639 (pci_status & PCI_MSK_AL_RD) ||
1640 (pci_status & PCI_MSK_AL_WR) ||
1641 (pci_status & PCI_MSK_APB_DMA) ||
1642 (pci_status & PCI_MSK_VID_C) ||
1643 (pci_status & PCI_MSK_VID_B) ||
1644 (pci_status & PCI_MSK_VID_A) ||
1645 (pci_status & PCI_MSK_AUD_INT) ||
1646 (pci_status & PCI_MSK_AUD_EXT)) {
1647
1648 if (pci_status & PCI_MSK_RISC_RD)
1649 dprintk(7, " (PCI_MSK_RISC_RD 0x%08x)\n",
1650 PCI_MSK_RISC_RD);
1651
1652 if (pci_status & PCI_MSK_RISC_WR)
1653 dprintk(7, " (PCI_MSK_RISC_WR 0x%08x)\n",
1654 PCI_MSK_RISC_WR);
1655
1656 if (pci_status & PCI_MSK_AL_RD)
1657 dprintk(7, " (PCI_MSK_AL_RD 0x%08x)\n",
1658 PCI_MSK_AL_RD);
1659
1660 if (pci_status & PCI_MSK_AL_WR)
1661 dprintk(7, " (PCI_MSK_AL_WR 0x%08x)\n",
1662 PCI_MSK_AL_WR);
1663
1664 if (pci_status & PCI_MSK_APB_DMA)
1665 dprintk(7, " (PCI_MSK_APB_DMA 0x%08x)\n",
1666 PCI_MSK_APB_DMA);
1667
1668 if (pci_status & PCI_MSK_VID_C)
1669 dprintk(7, " (PCI_MSK_VID_C 0x%08x)\n",
1670 PCI_MSK_VID_C);
1671
1672 if (pci_status & PCI_MSK_VID_B)
1673 dprintk(7, " (PCI_MSK_VID_B 0x%08x)\n",
1674 PCI_MSK_VID_B);
1675
1676 if (pci_status & PCI_MSK_VID_A)
1677 dprintk(7, " (PCI_MSK_VID_A 0x%08x)\n",
1678 PCI_MSK_VID_A);
1679
1680 if (pci_status & PCI_MSK_AUD_INT)
1681 dprintk(7, " (PCI_MSK_AUD_INT 0x%08x)\n",
1682 PCI_MSK_AUD_INT);
1683
1684 if (pci_status & PCI_MSK_AUD_EXT)
1685 dprintk(7, " (PCI_MSK_AUD_EXT 0x%08x)\n",
1686 PCI_MSK_AUD_EXT);
1687
1688 }
1689
1690 if (ts1_status) {
1691 if (cx23885_boards[dev->board].portb == CX23885_MPEG_DVB)
1692 handled += cx23885_irq_ts(ts1, ts1_status);
1693 else
1694 if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER)
1695 handled += cx23885_irq_417(dev, ts1_status);
1696 }
1697
1698 if (ts2_status) {
1699 if (cx23885_boards[dev->board].portc == CX23885_MPEG_DVB)
1700 handled += cx23885_irq_ts(ts2, ts2_status);
1701 else
1702 if (cx23885_boards[dev->board].portc == CX23885_MPEG_ENCODER)
1703 handled += cx23885_irq_417(dev, ts2_status);
1704 }
1705
1706 if (vida_status)
1707 handled += cx23885_video_irq(dev, vida_status);
1708
1709 if (handled)
1710 cx_write(PCI_INT_STAT, pci_status);
1711 out:
1712 return IRQ_RETVAL(handled);
1713 }
1714
1715 static int __devinit cx23885_initdev(struct pci_dev *pci_dev,
1716 const struct pci_device_id *pci_id)
1717 {
1718 struct cx23885_dev *dev;
1719 int err;
1720
1721 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1722 if (NULL == dev)
1723 return -ENOMEM;
1724
1725 /* pci init */
1726 dev->pci = pci_dev;
1727 if (pci_enable_device(pci_dev)) {
1728 err = -EIO;
1729 goto fail_free;
1730 }
1731
1732 if (cx23885_dev_setup(dev) < 0) {
1733 err = -EINVAL;
1734 goto fail_free;
1735 }
1736
1737 /* print pci info */
1738 pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &dev->pci_rev);
1739 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &dev->pci_lat);
1740 printk(KERN_INFO "%s/0: found at %s, rev: %d, irq: %d, "
1741 "latency: %d, mmio: 0x%llx\n", dev->name,
1742 pci_name(pci_dev), dev->pci_rev, pci_dev->irq,
1743 dev->pci_lat,
1744 (unsigned long long)pci_resource_start(pci_dev, 0));
1745
1746 pci_set_master(pci_dev);
1747 if (!pci_dma_supported(pci_dev, 0xffffffff)) {
1748 printk("%s/0: Oops: no 32bit PCI DMA ???\n", dev->name);
1749 err = -EIO;
1750 goto fail_irq;
1751 }
1752
1753 err = request_irq(pci_dev->irq, cx23885_irq,
1754 IRQF_SHARED | IRQF_DISABLED, dev->name, dev);
1755 if (err < 0) {
1756 printk(KERN_ERR "%s: can't get IRQ %d\n",
1757 dev->name, pci_dev->irq);
1758 goto fail_irq;
1759 }
1760
1761 pci_set_drvdata(pci_dev, dev);
1762 return 0;
1763
1764 fail_irq:
1765 cx23885_dev_unregister(dev);
1766 fail_free:
1767 kfree(dev);
1768 return err;
1769 }
1770
1771 static void __devexit cx23885_finidev(struct pci_dev *pci_dev)
1772 {
1773 struct cx23885_dev *dev = pci_get_drvdata(pci_dev);
1774
1775 cx23885_shutdown(dev);
1776
1777 pci_disable_device(pci_dev);
1778
1779 /* unregister stuff */
1780 free_irq(pci_dev->irq, dev);
1781 pci_set_drvdata(pci_dev, NULL);
1782
1783 mutex_lock(&devlist);
1784 list_del(&dev->devlist);
1785 mutex_unlock(&devlist);
1786
1787 cx23885_dev_unregister(dev);
1788 kfree(dev);
1789 }
1790
1791 static struct pci_device_id cx23885_pci_tbl[] = {
1792 {
1793 /* CX23885 */
1794 .vendor = 0x14f1,
1795 .device = 0x8852,
1796 .subvendor = PCI_ANY_ID,
1797 .subdevice = PCI_ANY_ID,
1798 }, {
1799 /* CX23887 Rev 2 */
1800 .vendor = 0x14f1,
1801 .device = 0x8880,
1802 .subvendor = PCI_ANY_ID,
1803 .subdevice = PCI_ANY_ID,
1804 }, {
1805 /* --- end of list --- */
1806 }
1807 };
1808 MODULE_DEVICE_TABLE(pci, cx23885_pci_tbl);
1809
1810 static struct pci_driver cx23885_pci_driver = {
1811 .name = "cx23885",
1812 .id_table = cx23885_pci_tbl,
1813 .probe = cx23885_initdev,
1814 .remove = __devexit_p(cx23885_finidev),
1815 /* TODO */
1816 .suspend = NULL,
1817 .resume = NULL,
1818 };
1819
1820 static int cx23885_init(void)
1821 {
1822 printk(KERN_INFO "cx23885 driver version %d.%d.%d loaded\n",
1823 (CX23885_VERSION_CODE >> 16) & 0xff,
1824 (CX23885_VERSION_CODE >> 8) & 0xff,
1825 CX23885_VERSION_CODE & 0xff);
1826 #ifdef SNAPSHOT
1827 printk(KERN_INFO "cx23885: snapshot date %04d-%02d-%02d\n",
1828 SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
1829 #endif
1830 return pci_register_driver(&cx23885_pci_driver);
1831 }
1832
1833 static void cx23885_fini(void)
1834 {
1835 pci_unregister_driver(&cx23885_pci_driver);
1836 }
1837
1838 module_init(cx23885_init);
1839 module_exit(cx23885_fini);
1840
1841 /* ----------------------------------------------------------- */
Linux kernel - Deliverables
This page took 0.078816 seconds and 6 git commands to generate.