1
2
3
4
5
6
7
8#include "cx23885.h"
9
10#include <linux/init.h>
11#include <linux/list.h>
12#include <linux/module.h>
13#include <linux/moduleparam.h>
14#include <linux/kmod.h>
15#include <linux/kernel.h>
16#include <linux/pci.h>
17#include <linux/slab.h>
18#include <linux/interrupt.h>
19#include <linux/delay.h>
20#include <asm/div64.h>
21#include <linux/firmware.h>
22
23#include "cimax2.h"
24#include "altera-ci.h"
25#include "cx23888-ir.h"
26#include "cx23885-ir.h"
27#include "cx23885-av.h"
28#include "cx23885-input.h"
29
30MODULE_DESCRIPTION("Driver for cx23885 based TV cards");
31MODULE_AUTHOR("Steven Toth <stoth@linuxtv.org>");
32MODULE_LICENSE("GPL");
33MODULE_VERSION(CX23885_VERSION);
34
35
36
37
38
39
40
41
42
43static unsigned int dma_reset_workaround = 1;
44module_param(dma_reset_workaround, int, 0644);
45MODULE_PARM_DESC(dma_reset_workaround, "periodic RiSC dma engine reset; 0-force disable, 1-driver detect (default), 2-force enable");
46
47static unsigned int debug;
48module_param(debug, int, 0644);
49MODULE_PARM_DESC(debug, "enable debug messages");
50
51static unsigned int card[] = {[0 ... (CX23885_MAXBOARDS - 1)] = UNSET };
52module_param_array(card, int, NULL, 0444);
53MODULE_PARM_DESC(card, "card type");
54
55#define dprintk(level, fmt, arg...)\
56 do { if (debug >= level)\
57 printk(KERN_DEBUG pr_fmt("%s: " fmt), \
58 __func__, ##arg); \
59 } while (0)
60
61static unsigned int cx23885_devcount;
62
63#define NO_SYNC_LINE (-1U)
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85static struct sram_channel cx23885_sram_channels[] = {
86 [SRAM_CH01] = {
87 .name = "VID A",
88 .cmds_start = 0x10000,
89 .ctrl_start = 0x10380,
90 .cdt = 0x104c0,
91 .fifo_start = 0x40,
92 .fifo_size = 0x2800,
93 .ptr1_reg = DMA1_PTR1,
94 .ptr2_reg = DMA1_PTR2,
95 .cnt1_reg = DMA1_CNT1,
96 .cnt2_reg = DMA1_CNT2,
97 },
98 [SRAM_CH02] = {
99 .name = "ch2",
100 .cmds_start = 0x0,
101 .ctrl_start = 0x0,
102 .cdt = 0x0,
103 .fifo_start = 0x0,
104 .fifo_size = 0x0,
105 .ptr1_reg = DMA2_PTR1,
106 .ptr2_reg = DMA2_PTR2,
107 .cnt1_reg = DMA2_CNT1,
108 .cnt2_reg = DMA2_CNT2,
109 },
110 [SRAM_CH03] = {
111 .name = "TS1 B",
112 .cmds_start = 0x100A0,
113 .ctrl_start = 0x10400,
114 .cdt = 0x10580,
115 .fifo_start = 0x5000,
116 .fifo_size = 0x1000,
117 .ptr1_reg = DMA3_PTR1,
118 .ptr2_reg = DMA3_PTR2,
119 .cnt1_reg = DMA3_CNT1,
120 .cnt2_reg = DMA3_CNT2,
121 },
122 [SRAM_CH04] = {
123 .name = "ch4",
124 .cmds_start = 0x0,
125 .ctrl_start = 0x0,
126 .cdt = 0x0,
127 .fifo_start = 0x0,
128 .fifo_size = 0x0,
129 .ptr1_reg = DMA4_PTR1,
130 .ptr2_reg = DMA4_PTR2,
131 .cnt1_reg = DMA4_CNT1,
132 .cnt2_reg = DMA4_CNT2,
133 },
134 [SRAM_CH05] = {
135 .name = "ch5",
136 .cmds_start = 0x0,
137 .ctrl_start = 0x0,
138 .cdt = 0x0,
139 .fifo_start = 0x0,
140 .fifo_size = 0x0,
141 .ptr1_reg = DMA5_PTR1,
142 .ptr2_reg = DMA5_PTR2,
143 .cnt1_reg = DMA5_CNT1,
144 .cnt2_reg = DMA5_CNT2,
145 },
146 [SRAM_CH06] = {
147 .name = "TS2 C",
148 .cmds_start = 0x10140,
149 .ctrl_start = 0x10440,
150 .cdt = 0x105e0,
151 .fifo_start = 0x6000,
152 .fifo_size = 0x1000,
153 .ptr1_reg = DMA5_PTR1,
154 .ptr2_reg = DMA5_PTR2,
155 .cnt1_reg = DMA5_CNT1,
156 .cnt2_reg = DMA5_CNT2,
157 },
158 [SRAM_CH07] = {
159 .name = "TV Audio",
160 .cmds_start = 0x10190,
161 .ctrl_start = 0x10480,
162 .cdt = 0x10a00,
163 .fifo_start = 0x7000,
164 .fifo_size = 0x1000,
165 .ptr1_reg = DMA6_PTR1,
166 .ptr2_reg = DMA6_PTR2,
167 .cnt1_reg = DMA6_CNT1,
168 .cnt2_reg = DMA6_CNT2,
169 },
170 [SRAM_CH08] = {
171 .name = "ch8",
172 .cmds_start = 0x0,
173 .ctrl_start = 0x0,
174 .cdt = 0x0,
175 .fifo_start = 0x0,
176 .fifo_size = 0x0,
177 .ptr1_reg = DMA7_PTR1,
178 .ptr2_reg = DMA7_PTR2,
179 .cnt1_reg = DMA7_CNT1,
180 .cnt2_reg = DMA7_CNT2,
181 },
182 [SRAM_CH09] = {
183 .name = "ch9",
184 .cmds_start = 0x0,
185 .ctrl_start = 0x0,
186 .cdt = 0x0,
187 .fifo_start = 0x0,
188 .fifo_size = 0x0,
189 .ptr1_reg = DMA8_PTR1,
190 .ptr2_reg = DMA8_PTR2,
191 .cnt1_reg = DMA8_CNT1,
192 .cnt2_reg = DMA8_CNT2,
193 },
194};
195
196static struct sram_channel cx23887_sram_channels[] = {
197 [SRAM_CH01] = {
198 .name = "VID A",
199 .cmds_start = 0x10000,
200 .ctrl_start = 0x105b0,
201 .cdt = 0x107b0,
202 .fifo_start = 0x40,
203 .fifo_size = 0x2800,
204 .ptr1_reg = DMA1_PTR1,
205 .ptr2_reg = DMA1_PTR2,
206 .cnt1_reg = DMA1_CNT1,
207 .cnt2_reg = DMA1_CNT2,
208 },
209 [SRAM_CH02] = {
210 .name = "VID A (VBI)",
211 .cmds_start = 0x10050,
212 .ctrl_start = 0x105F0,
213 .cdt = 0x10810,
214 .fifo_start = 0x3000,
215 .fifo_size = 0x1000,
216 .ptr1_reg = DMA2_PTR1,
217 .ptr2_reg = DMA2_PTR2,
218 .cnt1_reg = DMA2_CNT1,
219 .cnt2_reg = DMA2_CNT2,
220 },
221 [SRAM_CH03] = {
222 .name = "TS1 B",
223 .cmds_start = 0x100A0,
224 .ctrl_start = 0x10630,
225 .cdt = 0x10870,
226 .fifo_start = 0x5000,
227 .fifo_size = 0x1000,
228 .ptr1_reg = DMA3_PTR1,
229 .ptr2_reg = DMA3_PTR2,
230 .cnt1_reg = DMA3_CNT1,
231 .cnt2_reg = DMA3_CNT2,
232 },
233 [SRAM_CH04] = {
234 .name = "ch4",
235 .cmds_start = 0x0,
236 .ctrl_start = 0x0,
237 .cdt = 0x0,
238 .fifo_start = 0x0,
239 .fifo_size = 0x0,
240 .ptr1_reg = DMA4_PTR1,
241 .ptr2_reg = DMA4_PTR2,
242 .cnt1_reg = DMA4_CNT1,
243 .cnt2_reg = DMA4_CNT2,
244 },
245 [SRAM_CH05] = {
246 .name = "ch5",
247 .cmds_start = 0x0,
248 .ctrl_start = 0x0,
249 .cdt = 0x0,
250 .fifo_start = 0x0,
251 .fifo_size = 0x0,
252 .ptr1_reg = DMA5_PTR1,
253 .ptr2_reg = DMA5_PTR2,
254 .cnt1_reg = DMA5_CNT1,
255 .cnt2_reg = DMA5_CNT2,
256 },
257 [SRAM_CH06] = {
258 .name = "TS2 C",
259 .cmds_start = 0x10140,
260 .ctrl_start = 0x10670,
261 .cdt = 0x108d0,
262 .fifo_start = 0x6000,
263 .fifo_size = 0x1000,
264 .ptr1_reg = DMA5_PTR1,
265 .ptr2_reg = DMA5_PTR2,
266 .cnt1_reg = DMA5_CNT1,
267 .cnt2_reg = DMA5_CNT2,
268 },
269 [SRAM_CH07] = {
270 .name = "TV Audio",
271 .cmds_start = 0x10190,
272 .ctrl_start = 0x106B0,
273 .cdt = 0x10930,
274 .fifo_start = 0x7000,
275 .fifo_size = 0x1000,
276 .ptr1_reg = DMA6_PTR1,
277 .ptr2_reg = DMA6_PTR2,
278 .cnt1_reg = DMA6_CNT1,
279 .cnt2_reg = DMA6_CNT2,
280 },
281 [SRAM_CH08] = {
282 .name = "ch8",
283 .cmds_start = 0x0,
284 .ctrl_start = 0x0,
285 .cdt = 0x0,
286 .fifo_start = 0x0,
287 .fifo_size = 0x0,
288 .ptr1_reg = DMA7_PTR1,
289 .ptr2_reg = DMA7_PTR2,
290 .cnt1_reg = DMA7_CNT1,
291 .cnt2_reg = DMA7_CNT2,
292 },
293 [SRAM_CH09] = {
294 .name = "ch9",
295 .cmds_start = 0x0,
296 .ctrl_start = 0x0,
297 .cdt = 0x0,
298 .fifo_start = 0x0,
299 .fifo_size = 0x0,
300 .ptr1_reg = DMA8_PTR1,
301 .ptr2_reg = DMA8_PTR2,
302 .cnt1_reg = DMA8_CNT1,
303 .cnt2_reg = DMA8_CNT2,
304 },
305};
306
307static void cx23885_irq_add(struct cx23885_dev *dev, u32 mask)
308{
309 unsigned long flags;
310 spin_lock_irqsave(&dev->pci_irqmask_lock, flags);
311
312 dev->pci_irqmask |= mask;
313
314 spin_unlock_irqrestore(&dev->pci_irqmask_lock, flags);
315}
316
317void cx23885_irq_add_enable(struct cx23885_dev *dev, u32 mask)
318{
319 unsigned long flags;
320 spin_lock_irqsave(&dev->pci_irqmask_lock, flags);
321
322 dev->pci_irqmask |= mask;
323 cx_set(PCI_INT_MSK, mask);
324
325 spin_unlock_irqrestore(&dev->pci_irqmask_lock, flags);
326}
327
328void cx23885_irq_enable(struct cx23885_dev *dev, u32 mask)
329{
330 u32 v;
331 unsigned long flags;
332 spin_lock_irqsave(&dev->pci_irqmask_lock, flags);
333
334 v = mask & dev->pci_irqmask;
335 if (v)
336 cx_set(PCI_INT_MSK, v);
337
338 spin_unlock_irqrestore(&dev->pci_irqmask_lock, flags);
339}
340
341static inline void cx23885_irq_enable_all(struct cx23885_dev *dev)
342{
343 cx23885_irq_enable(dev, 0xffffffff);
344}
345
346void cx23885_irq_disable(struct cx23885_dev *dev, u32 mask)
347{
348 unsigned long flags;
349 spin_lock_irqsave(&dev->pci_irqmask_lock, flags);
350
351 cx_clear(PCI_INT_MSK, mask);
352
353 spin_unlock_irqrestore(&dev->pci_irqmask_lock, flags);
354}
355
356static inline void cx23885_irq_disable_all(struct cx23885_dev *dev)
357{
358 cx23885_irq_disable(dev, 0xffffffff);
359}
360
361void cx23885_irq_remove(struct cx23885_dev *dev, u32 mask)
362{
363 unsigned long flags;
364 spin_lock_irqsave(&dev->pci_irqmask_lock, flags);
365
366 dev->pci_irqmask &= ~mask;
367 cx_clear(PCI_INT_MSK, mask);
368
369 spin_unlock_irqrestore(&dev->pci_irqmask_lock, flags);
370}
371
372static u32 cx23885_irq_get_mask(struct cx23885_dev *dev)
373{
374 u32 v;
375 unsigned long flags;
376 spin_lock_irqsave(&dev->pci_irqmask_lock, flags);
377
378 v = cx_read(PCI_INT_MSK);
379
380 spin_unlock_irqrestore(&dev->pci_irqmask_lock, flags);
381 return v;
382}
383
384static int cx23885_risc_decode(u32 risc)
385{
386 static char *instr[16] = {
387 [RISC_SYNC >> 28] = "sync",
388 [RISC_WRITE >> 28] = "write",
389 [RISC_WRITEC >> 28] = "writec",
390 [RISC_READ >> 28] = "read",
391 [RISC_READC >> 28] = "readc",
392 [RISC_JUMP >> 28] = "jump",
393 [RISC_SKIP >> 28] = "skip",
394 [RISC_WRITERM >> 28] = "writerm",
395 [RISC_WRITECM >> 28] = "writecm",
396 [RISC_WRITECR >> 28] = "writecr",
397 };
398 static int incr[16] = {
399 [RISC_WRITE >> 28] = 3,
400 [RISC_JUMP >> 28] = 3,
401 [RISC_SKIP >> 28] = 1,
402 [RISC_SYNC >> 28] = 1,
403 [RISC_WRITERM >> 28] = 3,
404 [RISC_WRITECM >> 28] = 3,
405 [RISC_WRITECR >> 28] = 4,
406 };
407 static char *bits[] = {
408 "12", "13", "14", "resync",
409 "cnt0", "cnt1", "18", "19",
410 "20", "21", "22", "23",
411 "irq1", "irq2", "eol", "sol",
412 };
413 int i;
414
415 printk(KERN_DEBUG "0x%08x [ %s", risc,
416 instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
417 for (i = ARRAY_SIZE(bits) - 1; i >= 0; i--)
418 if (risc & (1 << (i + 12)))
419 pr_cont(" %s", bits[i]);
420 pr_cont(" count=%d ]\n", risc & 0xfff);
421 return incr[risc >> 28] ? incr[risc >> 28] : 1;
422}
423
424static void cx23885_wakeup(struct cx23885_tsport *port,
425 struct cx23885_dmaqueue *q, u32 count)
426{
427 struct cx23885_buffer *buf;
428 int count_delta;
429 int max_buf_done = 5;
430
431 do {
432 if (list_empty(&q->active))
433 return;
434 buf = list_entry(q->active.next,
435 struct cx23885_buffer, queue);
436
437 buf->vb.vb2_buf.timestamp = ktime_get_ns();
438 buf->vb.sequence = q->count++;
439 if (count != (q->count % 65536)) {
440 dprintk(1, "[%p/%d] wakeup reg=%d buf=%d\n", buf,
441 buf->vb.vb2_buf.index, count, q->count);
442 } else {
443 dprintk(7, "[%p/%d] wakeup reg=%d buf=%d\n", buf,
444 buf->vb.vb2_buf.index, count, q->count);
445 }
446 list_del(&buf->queue);
447 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_DONE);
448 max_buf_done--;
449
450 count_delta = ((int)count - (int)(q->count % 65536));
451 } while ((count_delta > 0) && (max_buf_done > 0));
452}
453
454int cx23885_sram_channel_setup(struct cx23885_dev *dev,
455 struct sram_channel *ch,
456 unsigned int bpl, u32 risc)
457{
458 unsigned int i, lines;
459 u32 cdt;
460
461 if (ch->cmds_start == 0) {
462 dprintk(1, "%s() Erasing channel [%s]\n", __func__,
463 ch->name);
464 cx_write(ch->ptr1_reg, 0);
465 cx_write(ch->ptr2_reg, 0);
466 cx_write(ch->cnt2_reg, 0);
467 cx_write(ch->cnt1_reg, 0);
468 return 0;
469 } else {
470 dprintk(1, "%s() Configuring channel [%s]\n", __func__,
471 ch->name);
472 }
473
474 bpl = (bpl + 7) & ~7;
475 cdt = ch->cdt;
476 lines = ch->fifo_size / bpl;
477 if (lines > 6)
478 lines = 6;
479 BUG_ON(lines < 2);
480
481 cx_write(8 + 0, RISC_JUMP | RISC_CNT_RESET);
482 cx_write(8 + 4, 12);
483 cx_write(8 + 8, 0);
484
485
486 for (i = 0; i < lines; i++) {
487 dprintk(2, "%s() 0x%08x <- 0x%08x\n", __func__, cdt + 16*i,
488 ch->fifo_start + bpl*i);
489 cx_write(cdt + 16*i, ch->fifo_start + bpl*i);
490 cx_write(cdt + 16*i + 4, 0);
491 cx_write(cdt + 16*i + 8, 0);
492 cx_write(cdt + 16*i + 12, 0);
493 }
494
495
496 if (ch->jumponly)
497 cx_write(ch->cmds_start + 0, 8);
498 else
499 cx_write(ch->cmds_start + 0, risc);
500 cx_write(ch->cmds_start + 4, 0);
501 cx_write(ch->cmds_start + 8, cdt);
502 cx_write(ch->cmds_start + 12, (lines*16) >> 3);
503 cx_write(ch->cmds_start + 16, ch->ctrl_start);
504 if (ch->jumponly)
505 cx_write(ch->cmds_start + 20, 0x80000000 | (64 >> 2));
506 else
507 cx_write(ch->cmds_start + 20, 64 >> 2);
508 for (i = 24; i < 80; i += 4)
509 cx_write(ch->cmds_start + i, 0);
510
511
512 cx_write(ch->ptr1_reg, ch->fifo_start);
513 cx_write(ch->ptr2_reg, cdt);
514 cx_write(ch->cnt2_reg, (lines*16) >> 3);
515 cx_write(ch->cnt1_reg, (bpl >> 3) - 1);
516
517 dprintk(2, "[bridge %d] sram setup %s: bpl=%d lines=%d\n",
518 dev->bridge,
519 ch->name,
520 bpl,
521 lines);
522
523 return 0;
524}
525
526void cx23885_sram_channel_dump(struct cx23885_dev *dev,
527 struct sram_channel *ch)
528{
529 static char *name[] = {
530 "init risc lo",
531 "init risc hi",
532 "cdt base",
533 "cdt size",
534 "iq base",
535 "iq size",
536 "risc pc lo",
537 "risc pc hi",
538 "iq wr ptr",
539 "iq rd ptr",
540 "cdt current",
541 "pci target lo",
542 "pci target hi",
543 "line / byte",
544 };
545 u32 risc;
546 unsigned int i, j, n;
547
548 pr_warn("%s: %s - dma channel status dump\n",
549 dev->name, ch->name);
550 for (i = 0; i < ARRAY_SIZE(name); i++)
551 pr_warn("%s: cmds: %-15s: 0x%08x\n",
552 dev->name, name[i],
553 cx_read(ch->cmds_start + 4*i));
554
555 for (i = 0; i < 4; i++) {
556 risc = cx_read(ch->cmds_start + 4 * (i + 14));
557 pr_warn("%s: risc%d: ", dev->name, i);
558 cx23885_risc_decode(risc);
559 }
560 for (i = 0; i < (64 >> 2); i += n) {
561 risc = cx_read(ch->ctrl_start + 4 * i);
562
563
564 pr_warn("%s: (0x%08x) iq %x: ", dev->name,
565 ch->ctrl_start + 4 * i, i);
566 n = cx23885_risc_decode(risc);
567 for (j = 1; j < n; j++) {
568 risc = cx_read(ch->ctrl_start + 4 * (i + j));
569 pr_warn("%s: iq %x: 0x%08x [ arg #%d ]\n",
570 dev->name, i+j, risc, j);
571 }
572 }
573
574 pr_warn("%s: fifo: 0x%08x -> 0x%x\n",
575 dev->name, ch->fifo_start, ch->fifo_start+ch->fifo_size);
576 pr_warn("%s: ctrl: 0x%08x -> 0x%x\n",
577 dev->name, ch->ctrl_start, ch->ctrl_start + 6*16);
578 pr_warn("%s: ptr1_reg: 0x%08x\n",
579 dev->name, cx_read(ch->ptr1_reg));
580 pr_warn("%s: ptr2_reg: 0x%08x\n",
581 dev->name, cx_read(ch->ptr2_reg));
582 pr_warn("%s: cnt1_reg: 0x%08x\n",
583 dev->name, cx_read(ch->cnt1_reg));
584 pr_warn("%s: cnt2_reg: 0x%08x\n",
585 dev->name, cx_read(ch->cnt2_reg));
586}
587
588static void cx23885_risc_disasm(struct cx23885_tsport *port,
589 struct cx23885_riscmem *risc)
590{
591 struct cx23885_dev *dev = port->dev;
592 unsigned int i, j, n;
593
594 pr_info("%s: risc disasm: %p [dma=0x%08lx]\n",
595 dev->name, risc->cpu, (unsigned long)risc->dma);
596 for (i = 0; i < (risc->size >> 2); i += n) {
597 pr_info("%s: %04d: ", dev->name, i);
598 n = cx23885_risc_decode(le32_to_cpu(risc->cpu[i]));
599 for (j = 1; j < n; j++)
600 pr_info("%s: %04d: 0x%08x [ arg #%d ]\n",
601 dev->name, i + j, risc->cpu[i + j], j);
602 if (risc->cpu[i] == cpu_to_le32(RISC_JUMP))
603 break;
604 }
605}
606
607static void cx23885_clear_bridge_error(struct cx23885_dev *dev)
608{
609 uint32_t reg1_val, reg2_val;
610
611 if (!dev->need_dma_reset)
612 return;
613
614 reg1_val = cx_read(TC_REQ);
615 reg2_val = cx_read(TC_REQ_SET);
616
617 if (reg1_val && reg2_val) {
618 cx_write(TC_REQ, reg1_val);
619 cx_write(TC_REQ_SET, reg2_val);
620 cx_read(VID_B_DMA);
621 cx_read(VBI_B_DMA);
622 cx_read(VID_C_DMA);
623 cx_read(VBI_C_DMA);
624
625 dev_info(&dev->pci->dev,
626 "dma in progress detected 0x%08x 0x%08x, clearing\n",
627 reg1_val, reg2_val);
628 }
629}
630
631static void cx23885_shutdown(struct cx23885_dev *dev)
632{
633
634 cx_write(DEV_CNTRL2, 0);
635
636
637 cx_write(IR_CNTRL_REG, 0);
638
639
640 cx_write(VID_A_DMA_CTL, 0);
641 cx_write(VID_B_DMA_CTL, 0);
642 cx_write(VID_C_DMA_CTL, 0);
643
644
645 cx_write(AUD_INT_DMA_CTL, 0);
646 cx_write(AUD_EXT_DMA_CTL, 0);
647
648
649 cx_write(UART_CTL, 0);
650
651
652 cx23885_irq_disable_all(dev);
653 cx_write(VID_A_INT_MSK, 0);
654 cx_write(VID_B_INT_MSK, 0);
655 cx_write(VID_C_INT_MSK, 0);
656 cx_write(AUDIO_INT_INT_MSK, 0);
657 cx_write(AUDIO_EXT_INT_MSK, 0);
658
659}
660
661static void cx23885_reset(struct cx23885_dev *dev)
662{
663 dprintk(1, "%s()\n", __func__);
664
665 cx23885_shutdown(dev);
666
667 cx_write(PCI_INT_STAT, 0xffffffff);
668 cx_write(VID_A_INT_STAT, 0xffffffff);
669 cx_write(VID_B_INT_STAT, 0xffffffff);
670 cx_write(VID_C_INT_STAT, 0xffffffff);
671 cx_write(AUDIO_INT_INT_STAT, 0xffffffff);
672 cx_write(AUDIO_EXT_INT_STAT, 0xffffffff);
673 cx_write(CLK_DELAY, cx_read(CLK_DELAY) & 0x80000000);
674 cx_write(PAD_CTRL, 0x00500300);
675
676
677 cx23885_clear_bridge_error(dev);
678 msleep(100);
679
680 cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH01],
681 720*4, 0);
682 cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH02], 128, 0);
683 cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH03],
684 188*4, 0);
685 cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH04], 128, 0);
686 cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH05], 128, 0);
687 cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH06],
688 188*4, 0);
689 cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH07], 128, 0);
690 cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH08], 128, 0);
691 cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH09], 128, 0);
692
693 cx23885_gpio_setup(dev);
694
695 cx23885_irq_get_mask(dev);
696
697
698 cx23885_clear_bridge_error(dev);
699}
700
701
702static int cx23885_pci_quirks(struct cx23885_dev *dev)
703{
704 dprintk(1, "%s()\n", __func__);
705
706
707
708
709
710 if (dev->bridge == CX23885_BRIDGE_885)
711 cx_clear(RDR_TLCTL0, 1 << 4);
712
713
714 cx23885_clear_bridge_error(dev);
715 return 0;
716}
717
718static int get_resources(struct cx23885_dev *dev)
719{
720 if (request_mem_region(pci_resource_start(dev->pci, 0),
721 pci_resource_len(dev->pci, 0),
722 dev->name))
723 return 0;
724
725 pr_err("%s: can't get MMIO memory @ 0x%llx\n",
726 dev->name, (unsigned long long)pci_resource_start(dev->pci, 0));
727
728 return -EBUSY;
729}
730
731static int cx23885_init_tsport(struct cx23885_dev *dev,
732 struct cx23885_tsport *port, int portno)
733{
734 dprintk(1, "%s(portno=%d)\n", __func__, portno);
735
736
737 port->dma_ctl_val = 0x11;
738 port->ts_int_msk_val = 0x1111;
739 port->vld_misc_val = 0x0;
740 port->hw_sop_ctrl_val = (0x47 << 16 | 188 << 4);
741
742 spin_lock_init(&port->slock);
743 port->dev = dev;
744 port->nr = portno;
745
746 INIT_LIST_HEAD(&port->mpegq.active);
747 mutex_init(&port->frontends.lock);
748 INIT_LIST_HEAD(&port->frontends.felist);
749 port->frontends.active_fe_id = 0;
750
751
752
753
754
755 if (!port->num_frontends)
756 port->num_frontends = 1;
757
758 switch (portno) {
759 case 1:
760 port->reg_gpcnt = VID_B_GPCNT;
761 port->reg_gpcnt_ctl = VID_B_GPCNT_CTL;
762 port->reg_dma_ctl = VID_B_DMA_CTL;
763 port->reg_lngth = VID_B_LNGTH;
764 port->reg_hw_sop_ctrl = VID_B_HW_SOP_CTL;
765 port->reg_gen_ctrl = VID_B_GEN_CTL;
766 port->reg_bd_pkt_status = VID_B_BD_PKT_STATUS;
767 port->reg_sop_status = VID_B_SOP_STATUS;
768 port->reg_fifo_ovfl_stat = VID_B_FIFO_OVFL_STAT;
769 port->reg_vld_misc = VID_B_VLD_MISC;
770 port->reg_ts_clk_en = VID_B_TS_CLK_EN;
771 port->reg_src_sel = VID_B_SRC_SEL;
772 port->reg_ts_int_msk = VID_B_INT_MSK;
773 port->reg_ts_int_stat = VID_B_INT_STAT;
774 port->sram_chno = SRAM_CH03;
775 port->pci_irqmask = 0x02;
776 break;
777 case 2:
778 port->reg_gpcnt = VID_C_GPCNT;
779 port->reg_gpcnt_ctl = VID_C_GPCNT_CTL;
780 port->reg_dma_ctl = VID_C_DMA_CTL;
781 port->reg_lngth = VID_C_LNGTH;
782 port->reg_hw_sop_ctrl = VID_C_HW_SOP_CTL;
783 port->reg_gen_ctrl = VID_C_GEN_CTL;
784 port->reg_bd_pkt_status = VID_C_BD_PKT_STATUS;
785 port->reg_sop_status = VID_C_SOP_STATUS;
786 port->reg_fifo_ovfl_stat = VID_C_FIFO_OVFL_STAT;
787 port->reg_vld_misc = VID_C_VLD_MISC;
788 port->reg_ts_clk_en = VID_C_TS_CLK_EN;
789 port->reg_src_sel = 0;
790 port->reg_ts_int_msk = VID_C_INT_MSK;
791 port->reg_ts_int_stat = VID_C_INT_STAT;
792 port->sram_chno = SRAM_CH06;
793 port->pci_irqmask = 0x04;
794 break;
795 default:
796 BUG();
797 }
798
799 return 0;
800}
801
802static void cx23885_dev_checkrevision(struct cx23885_dev *dev)
803{
804 switch (cx_read(RDR_CFG2) & 0xff) {
805 case 0x00:
806
807 dev->hwrevision = 0xa0;
808 break;
809 case 0x01:
810
811 dev->hwrevision = 0xa1;
812 break;
813 case 0x02:
814
815 dev->hwrevision = 0xb0;
816 break;
817 case 0x03:
818 if (dev->pci->device == 0x8880) {
819
820 dev->hwrevision = 0xc0;
821 } else {
822
823 dev->hwrevision = 0xa4;
824 }
825 break;
826 case 0x04:
827 if (dev->pci->device == 0x8880) {
828
829 dev->hwrevision = 0xd0;
830 } else {
831
832 dev->hwrevision = 0xa5;
833 }
834 break;
835 case 0x0e:
836
837 dev->hwrevision = 0xc0;
838 break;
839 case 0x0f:
840
841 dev->hwrevision = 0xb1;
842 break;
843 default:
844 pr_err("%s() New hardware revision found 0x%x\n",
845 __func__, dev->hwrevision);
846 }
847 if (dev->hwrevision)
848 pr_info("%s() Hardware revision = 0x%02x\n",
849 __func__, dev->hwrevision);
850 else
851 pr_err("%s() Hardware revision unknown 0x%x\n",
852 __func__, dev->hwrevision);
853}
854
855
856struct v4l2_subdev *cx23885_find_hw(struct cx23885_dev *dev, u32 hw)
857{
858 struct v4l2_subdev *result = NULL;
859 struct v4l2_subdev *sd;
860
861 spin_lock(&dev->v4l2_dev.lock);
862 v4l2_device_for_each_subdev(sd, &dev->v4l2_dev) {
863 if (sd->grp_id == hw) {
864 result = sd;
865 break;
866 }
867 }
868 spin_unlock(&dev->v4l2_dev.lock);
869 return result;
870}
871
872static int cx23885_dev_setup(struct cx23885_dev *dev)
873{
874 int i;
875
876 spin_lock_init(&dev->pci_irqmask_lock);
877 spin_lock_init(&dev->slock);
878
879 mutex_init(&dev->lock);
880 mutex_init(&dev->gpio_lock);
881
882 atomic_inc(&dev->refcount);
883
884 dev->nr = cx23885_devcount++;
885 sprintf(dev->name, "cx23885[%d]", dev->nr);
886
887
888 if (dev->pci->device == 0x8880) {
889
890 dev->bridge = CX23885_BRIDGE_888;
891
892 dev->clk_freq = 50000000;
893 dev->sram_channels = cx23887_sram_channels;
894 } else
895 if (dev->pci->device == 0x8852) {
896 dev->bridge = CX23885_BRIDGE_885;
897
898 dev->clk_freq = 28000000;
899 dev->sram_channels = cx23885_sram_channels;
900 } else
901 BUG();
902
903 dprintk(1, "%s() Memory configured for PCIe bridge type %d\n",
904 __func__, dev->bridge);
905
906
907 dev->board = UNSET;
908 if (card[dev->nr] < cx23885_bcount)
909 dev->board = card[dev->nr];
910 for (i = 0; UNSET == dev->board && i < cx23885_idcount; i++)
911 if (dev->pci->subsystem_vendor == cx23885_subids[i].subvendor &&
912 dev->pci->subsystem_device == cx23885_subids[i].subdevice)
913 dev->board = cx23885_subids[i].card;
914 if (UNSET == dev->board) {
915 dev->board = CX23885_BOARD_UNKNOWN;
916 cx23885_card_list(dev);
917 }
918
919 if (dev->pci->device == 0x8852) {
920
921 if (dev->board == CX23885_BOARD_HAUPPAUGE_QUADHD_ATSC)
922 dev->board = CX23885_BOARD_HAUPPAUGE_QUADHD_ATSC_885;
923 else if (dev->board == CX23885_BOARD_HAUPPAUGE_QUADHD_DVB)
924 dev->board = CX23885_BOARD_HAUPPAUGE_QUADHD_DVB_885;
925 }
926
927
928 if (cx23885_boards[dev->board].clk_freq > 0)
929 dev->clk_freq = cx23885_boards[dev->board].clk_freq;
930
931 if (dev->board == CX23885_BOARD_HAUPPAUGE_IMPACTVCBE &&
932 dev->pci->subsystem_device == 0x7137) {
933
934
935
936
937
938 dev->clk_freq = 25000000;
939 }
940
941 dev->pci_bus = dev->pci->bus->number;
942 dev->pci_slot = PCI_SLOT(dev->pci->devfn);
943 cx23885_irq_add(dev, 0x001f00);
944
945
946 dev->i2c_bus[0].nr = 0;
947 dev->i2c_bus[0].dev = dev;
948 dev->i2c_bus[0].reg_stat = I2C1_STAT;
949 dev->i2c_bus[0].reg_ctrl = I2C1_CTRL;
950 dev->i2c_bus[0].reg_addr = I2C1_ADDR;
951 dev->i2c_bus[0].reg_rdata = I2C1_RDATA;
952 dev->i2c_bus[0].reg_wdata = I2C1_WDATA;
953 dev->i2c_bus[0].i2c_period = (0x9d << 24);
954
955
956 dev->i2c_bus[1].nr = 1;
957 dev->i2c_bus[1].dev = dev;
958 dev->i2c_bus[1].reg_stat = I2C2_STAT;
959 dev->i2c_bus[1].reg_ctrl = I2C2_CTRL;
960 dev->i2c_bus[1].reg_addr = I2C2_ADDR;
961 dev->i2c_bus[1].reg_rdata = I2C2_RDATA;
962 dev->i2c_bus[1].reg_wdata = I2C2_WDATA;
963 dev->i2c_bus[1].i2c_period = (0x9d << 24);
964
965
966 dev->i2c_bus[2].nr = 2;
967 dev->i2c_bus[2].dev = dev;
968 dev->i2c_bus[2].reg_stat = I2C3_STAT;
969 dev->i2c_bus[2].reg_ctrl = I2C3_CTRL;
970 dev->i2c_bus[2].reg_addr = I2C3_ADDR;
971 dev->i2c_bus[2].reg_rdata = I2C3_RDATA;
972 dev->i2c_bus[2].reg_wdata = I2C3_WDATA;
973 dev->i2c_bus[2].i2c_period = (0x07 << 24);
974
975 if ((cx23885_boards[dev->board].portb == CX23885_MPEG_DVB) ||
976 (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER))
977 cx23885_init_tsport(dev, &dev->ts1, 1);
978
979 if ((cx23885_boards[dev->board].portc == CX23885_MPEG_DVB) ||
980 (cx23885_boards[dev->board].portc == CX23885_MPEG_ENCODER))
981 cx23885_init_tsport(dev, &dev->ts2, 2);
982
983 if (get_resources(dev) < 0) {
984 pr_err("CORE %s No more PCIe resources for subsystem: %04x:%04x\n",
985 dev->name, dev->pci->subsystem_vendor,
986 dev->pci->subsystem_device);
987
988 cx23885_devcount--;
989 return -ENODEV;
990 }
991
992
993 dev->lmmio = ioremap(pci_resource_start(dev->pci, 0),
994 pci_resource_len(dev->pci, 0));
995
996 dev->bmmio = (u8 __iomem *)dev->lmmio;
997
998 pr_info("CORE %s: subsystem: %04x:%04x, board: %s [card=%d,%s]\n",
999 dev->name, dev->pci->subsystem_vendor,
1000 dev->pci->subsystem_device, cx23885_boards[dev->board].name,
1001 dev->board, card[dev->nr] == dev->board ?
1002 "insmod option" : "autodetected");
1003
1004 cx23885_pci_quirks(dev);
1005
1006
1007 dev->tuner_type = cx23885_boards[dev->board].tuner_type;
1008 dev->tuner_addr = cx23885_boards[dev->board].tuner_addr;
1009 dev->tuner_bus = cx23885_boards[dev->board].tuner_bus;
1010 dev->radio_type = cx23885_boards[dev->board].radio_type;
1011 dev->radio_addr = cx23885_boards[dev->board].radio_addr;
1012
1013 dprintk(1, "%s() tuner_type = 0x%x tuner_addr = 0x%x tuner_bus = %d\n",
1014 __func__, dev->tuner_type, dev->tuner_addr, dev->tuner_bus);
1015 dprintk(1, "%s() radio_type = 0x%x radio_addr = 0x%x\n",
1016 __func__, dev->radio_type, dev->radio_addr);
1017
1018
1019
1020
1021
1022 if ((cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER) ||
1023 (cx23885_boards[dev->board].portc == CX23885_MPEG_ENCODER))
1024 cx23885_mc417_init(dev);
1025
1026
1027 cx23885_reset(dev);
1028
1029 cx23885_i2c_register(&dev->i2c_bus[0]);
1030 cx23885_i2c_register(&dev->i2c_bus[1]);
1031 cx23885_i2c_register(&dev->i2c_bus[2]);
1032 cx23885_card_setup(dev);
1033 call_all(dev, tuner, standby);
1034 cx23885_ir_init(dev);
1035
1036 if (dev->board == CX23885_BOARD_VIEWCAST_460E) {
1037
1038
1039
1040
1041
1042
1043 cx23885_gpio_enable(dev, 0x300, 0);
1044 }
1045
1046 if (cx23885_boards[dev->board].porta == CX23885_ANALOG_VIDEO) {
1047 if (cx23885_video_register(dev) < 0) {
1048 pr_err("%s() Failed to register analog video adapters on VID_A\n",
1049 __func__);
1050 }
1051 }
1052
1053 if (cx23885_boards[dev->board].portb == CX23885_MPEG_DVB) {
1054 if (cx23885_boards[dev->board].num_fds_portb)
1055 dev->ts1.num_frontends =
1056 cx23885_boards[dev->board].num_fds_portb;
1057 if (cx23885_dvb_register(&dev->ts1) < 0) {
1058 pr_err("%s() Failed to register dvb adapters on VID_B\n",
1059 __func__);
1060 }
1061 } else
1062 if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER) {
1063 if (cx23885_417_register(dev) < 0) {
1064 pr_err("%s() Failed to register 417 on VID_B\n",
1065 __func__);
1066 }
1067 }
1068
1069 if (cx23885_boards[dev->board].portc == CX23885_MPEG_DVB) {
1070 if (cx23885_boards[dev->board].num_fds_portc)
1071 dev->ts2.num_frontends =
1072 cx23885_boards[dev->board].num_fds_portc;
1073 if (cx23885_dvb_register(&dev->ts2) < 0) {
1074 pr_err("%s() Failed to register dvb on VID_C\n",
1075 __func__);
1076 }
1077 } else
1078 if (cx23885_boards[dev->board].portc == CX23885_MPEG_ENCODER) {
1079 if (cx23885_417_register(dev) < 0) {
1080 pr_err("%s() Failed to register 417 on VID_C\n",
1081 __func__);
1082 }
1083 }
1084
1085 cx23885_dev_checkrevision(dev);
1086
1087
1088 if (cx23885_boards[dev->board].ci_type > 0)
1089 cx_clear(RDR_RDRCTL1, 1 << 8);
1090
1091 switch (dev->board) {
1092 case CX23885_BOARD_TEVII_S470:
1093 case CX23885_BOARD_TEVII_S471:
1094 cx_clear(RDR_RDRCTL1, 1 << 8);
1095 break;
1096 }
1097
1098 return 0;
1099}
1100
1101static void cx23885_dev_unregister(struct cx23885_dev *dev)
1102{
1103 release_mem_region(pci_resource_start(dev->pci, 0),
1104 pci_resource_len(dev->pci, 0));
1105
1106 if (!atomic_dec_and_test(&dev->refcount))
1107 return;
1108
1109 if (cx23885_boards[dev->board].porta == CX23885_ANALOG_VIDEO)
1110 cx23885_video_unregister(dev);
1111
1112 if (cx23885_boards[dev->board].portb == CX23885_MPEG_DVB)
1113 cx23885_dvb_unregister(&dev->ts1);
1114
1115 if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER)
1116 cx23885_417_unregister(dev);
1117
1118 if (cx23885_boards[dev->board].portc == CX23885_MPEG_DVB)
1119 cx23885_dvb_unregister(&dev->ts2);
1120
1121 if (cx23885_boards[dev->board].portc == CX23885_MPEG_ENCODER)
1122 cx23885_417_unregister(dev);
1123
1124 cx23885_i2c_unregister(&dev->i2c_bus[2]);
1125 cx23885_i2c_unregister(&dev->i2c_bus[1]);
1126 cx23885_i2c_unregister(&dev->i2c_bus[0]);
1127
1128 iounmap(dev->lmmio);
1129}
1130
1131static __le32 *cx23885_risc_field(__le32 *rp, struct scatterlist *sglist,
1132 unsigned int offset, u32 sync_line,
1133 unsigned int bpl, unsigned int padding,
1134 unsigned int lines, unsigned int lpi, bool jump)
1135{
1136 struct scatterlist *sg;
1137 unsigned int line, todo, sol;
1138
1139
1140 if (jump) {
1141 *(rp++) = cpu_to_le32(RISC_JUMP);
1142 *(rp++) = cpu_to_le32(0);
1143 *(rp++) = cpu_to_le32(0);
1144 }
1145
1146
1147 if (sync_line != NO_SYNC_LINE)
1148 *(rp++) = cpu_to_le32(RISC_RESYNC | sync_line);
1149
1150
1151 sg = sglist;
1152 for (line = 0; line < lines; line++) {
1153 while (offset && offset >= sg_dma_len(sg)) {
1154 offset -= sg_dma_len(sg);
1155 sg = sg_next(sg);
1156 }
1157
1158 if (lpi && line > 0 && !(line % lpi))
1159 sol = RISC_SOL | RISC_IRQ1 | RISC_CNT_INC;
1160 else
1161 sol = RISC_SOL;
1162
1163 if (bpl <= sg_dma_len(sg)-offset) {
1164
1165 *(rp++) = cpu_to_le32(RISC_WRITE|sol|RISC_EOL|bpl);
1166 *(rp++) = cpu_to_le32(sg_dma_address(sg)+offset);
1167 *(rp++) = cpu_to_le32(0);
1168 offset += bpl;
1169 } else {
1170
1171 todo = bpl;
1172 *(rp++) = cpu_to_le32(RISC_WRITE|sol|
1173 (sg_dma_len(sg)-offset));
1174 *(rp++) = cpu_to_le32(sg_dma_address(sg)+offset);
1175 *(rp++) = cpu_to_le32(0);
1176 todo -= (sg_dma_len(sg)-offset);
1177 offset = 0;
1178 sg = sg_next(sg);
1179 while (todo > sg_dma_len(sg)) {
1180 *(rp++) = cpu_to_le32(RISC_WRITE|
1181 sg_dma_len(sg));
1182 *(rp++) = cpu_to_le32(sg_dma_address(sg));
1183 *(rp++) = cpu_to_le32(0);
1184 todo -= sg_dma_len(sg);
1185 sg = sg_next(sg);
1186 }
1187 *(rp++) = cpu_to_le32(RISC_WRITE|RISC_EOL|todo);
1188 *(rp++) = cpu_to_le32(sg_dma_address(sg));
1189 *(rp++) = cpu_to_le32(0);
1190 offset += todo;
1191 }
1192 offset += padding;
1193 }
1194
1195 return rp;
1196}
1197
1198int cx23885_risc_buffer(struct pci_dev *pci, struct cx23885_riscmem *risc,
1199 struct scatterlist *sglist, unsigned int top_offset,
1200 unsigned int bottom_offset, unsigned int bpl,
1201 unsigned int padding, unsigned int lines)
1202{
1203 u32 instructions, fields;
1204 __le32 *rp;
1205
1206 fields = 0;
1207 if (UNSET != top_offset)
1208 fields++;
1209 if (UNSET != bottom_offset)
1210 fields++;
1211
1212
1213
1214
1215
1216
1217 instructions = fields * (1 + ((bpl + padding) * lines)
1218 / PAGE_SIZE + lines);
1219 instructions += 5;
1220 risc->size = instructions * 12;
1221 risc->cpu = dma_alloc_coherent(&pci->dev, risc->size, &risc->dma,
1222 GFP_KERNEL);
1223 if (risc->cpu == NULL)
1224 return -ENOMEM;
1225
1226
1227 rp = risc->cpu;
1228 if (UNSET != top_offset)
1229 rp = cx23885_risc_field(rp, sglist, top_offset, 0,
1230 bpl, padding, lines, 0, true);
1231 if (UNSET != bottom_offset)
1232 rp = cx23885_risc_field(rp, sglist, bottom_offset, 0x200,
1233 bpl, padding, lines, 0, UNSET == top_offset);
1234
1235
1236 risc->jmp = rp;
1237 BUG_ON((risc->jmp - risc->cpu + 2) * sizeof(*risc->cpu) > risc->size);
1238 return 0;
1239}
1240
1241int cx23885_risc_databuffer(struct pci_dev *pci,
1242 struct cx23885_riscmem *risc,
1243 struct scatterlist *sglist,
1244 unsigned int bpl,
1245 unsigned int lines, unsigned int lpi)
1246{
1247 u32 instructions;
1248 __le32 *rp;
1249
1250
1251
1252
1253
1254
1255 instructions = 1 + (bpl * lines) / PAGE_SIZE + lines;
1256 instructions += 4;
1257
1258 risc->size = instructions * 12;
1259 risc->cpu = dma_alloc_coherent(&pci->dev, risc->size, &risc->dma,
1260 GFP_KERNEL);
1261 if (risc->cpu == NULL)
1262 return -ENOMEM;
1263
1264
1265 rp = risc->cpu;
1266 rp = cx23885_risc_field(rp, sglist, 0, NO_SYNC_LINE,
1267 bpl, 0, lines, lpi, lpi == 0);
1268
1269
1270 risc->jmp = rp;
1271 BUG_ON((risc->jmp - risc->cpu + 2) * sizeof(*risc->cpu) > risc->size);
1272 return 0;
1273}
1274
1275int cx23885_risc_vbibuffer(struct pci_dev *pci, struct cx23885_riscmem *risc,
1276 struct scatterlist *sglist, unsigned int top_offset,
1277 unsigned int bottom_offset, unsigned int bpl,
1278 unsigned int padding, unsigned int lines)
1279{
1280 u32 instructions, fields;
1281 __le32 *rp;
1282
1283 fields = 0;
1284 if (UNSET != top_offset)
1285 fields++;
1286 if (UNSET != bottom_offset)
1287 fields++;
1288
1289
1290
1291
1292
1293
1294 instructions = fields * (1 + ((bpl + padding) * lines)
1295 / PAGE_SIZE + lines);
1296 instructions += 5;
1297 risc->size = instructions * 12;
1298 risc->cpu = dma_alloc_coherent(&pci->dev, risc->size, &risc->dma,
1299 GFP_KERNEL);
1300 if (risc->cpu == NULL)
1301 return -ENOMEM;
1302
1303 rp = risc->cpu;
1304
1305
1306
1307 if (UNSET != top_offset)
1308 rp = cx23885_risc_field(rp, sglist, top_offset, 0,
1309 bpl, padding, lines, 0, true);
1310
1311 if (UNSET != bottom_offset)
1312 rp = cx23885_risc_field(rp, sglist, bottom_offset, 0x200,
1313 bpl, padding, lines, 0, UNSET == top_offset);
1314
1315
1316
1317
1318 risc->jmp = rp;
1319 BUG_ON((risc->jmp - risc->cpu + 2) * sizeof(*risc->cpu) > risc->size);
1320 return 0;
1321}
1322
1323
1324void cx23885_free_buffer(struct cx23885_dev *dev, struct cx23885_buffer *buf)
1325{
1326 struct cx23885_riscmem *risc = &buf->risc;
1327
1328 dma_free_coherent(&dev->pci->dev, risc->size, risc->cpu, risc->dma);
1329}
1330
1331static void cx23885_tsport_reg_dump(struct cx23885_tsport *port)
1332{
1333 struct cx23885_dev *dev = port->dev;
1334
1335 dprintk(1, "%s() Register Dump\n", __func__);
1336 dprintk(1, "%s() DEV_CNTRL2 0x%08X\n", __func__,
1337 cx_read(DEV_CNTRL2));
1338 dprintk(1, "%s() PCI_INT_MSK 0x%08X\n", __func__,
1339 cx23885_irq_get_mask(dev));
1340 dprintk(1, "%s() AUD_INT_INT_MSK 0x%08X\n", __func__,
1341 cx_read(AUDIO_INT_INT_MSK));
1342 dprintk(1, "%s() AUD_INT_DMA_CTL 0x%08X\n", __func__,
1343 cx_read(AUD_INT_DMA_CTL));
1344 dprintk(1, "%s() AUD_EXT_INT_MSK 0x%08X\n", __func__,
1345 cx_read(AUDIO_EXT_INT_MSK));
1346 dprintk(1, "%s() AUD_EXT_DMA_CTL 0x%08X\n", __func__,
1347 cx_read(AUD_EXT_DMA_CTL));
1348 dprintk(1, "%s() PAD_CTRL 0x%08X\n", __func__,
1349 cx_read(PAD_CTRL));
1350 dprintk(1, "%s() ALT_PIN_OUT_SEL 0x%08X\n", __func__,
1351 cx_read(ALT_PIN_OUT_SEL));
1352 dprintk(1, "%s() GPIO2 0x%08X\n", __func__,
1353 cx_read(GPIO2));
1354 dprintk(1, "%s() gpcnt(0x%08X) 0x%08X\n", __func__,
1355 port->reg_gpcnt, cx_read(port->reg_gpcnt));
1356 dprintk(1, "%s() gpcnt_ctl(0x%08X) 0x%08x\n", __func__,
1357 port->reg_gpcnt_ctl, cx_read(port->reg_gpcnt_ctl));
1358 dprintk(1, "%s() dma_ctl(0x%08X) 0x%08x\n", __func__,
1359 port->reg_dma_ctl, cx_read(port->reg_dma_ctl));
1360 if (port->reg_src_sel)
1361 dprintk(1, "%s() src_sel(0x%08X) 0x%08x\n", __func__,
1362 port->reg_src_sel, cx_read(port->reg_src_sel));
1363 dprintk(1, "%s() lngth(0x%08X) 0x%08x\n", __func__,
1364 port->reg_lngth, cx_read(port->reg_lngth));
1365 dprintk(1, "%s() hw_sop_ctrl(0x%08X) 0x%08x\n", __func__,
1366 port->reg_hw_sop_ctrl, cx_read(port->reg_hw_sop_ctrl));
1367 dprintk(1, "%s() gen_ctrl(0x%08X) 0x%08x\n", __func__,
1368 port->reg_gen_ctrl, cx_read(port->reg_gen_ctrl));
1369 dprintk(1, "%s() bd_pkt_status(0x%08X) 0x%08x\n", __func__,
1370 port->reg_bd_pkt_status, cx_read(port->reg_bd_pkt_status));
1371 dprintk(1, "%s() sop_status(0x%08X) 0x%08x\n", __func__,
1372 port->reg_sop_status, cx_read(port->reg_sop_status));
1373 dprintk(1, "%s() fifo_ovfl_stat(0x%08X) 0x%08x\n", __func__,
1374 port->reg_fifo_ovfl_stat, cx_read(port->reg_fifo_ovfl_stat));
1375 dprintk(1, "%s() vld_misc(0x%08X) 0x%08x\n", __func__,
1376 port->reg_vld_misc, cx_read(port->reg_vld_misc));
1377 dprintk(1, "%s() ts_clk_en(0x%08X) 0x%08x\n", __func__,
1378 port->reg_ts_clk_en, cx_read(port->reg_ts_clk_en));
1379 dprintk(1, "%s() ts_int_msk(0x%08X) 0x%08x\n", __func__,
1380 port->reg_ts_int_msk, cx_read(port->reg_ts_int_msk));
1381 dprintk(1, "%s() ts_int_status(0x%08X) 0x%08x\n", __func__,
1382 port->reg_ts_int_stat, cx_read(port->reg_ts_int_stat));
1383 dprintk(1, "%s() PCI_INT_STAT 0x%08X\n", __func__,
1384 cx_read(PCI_INT_STAT));
1385 dprintk(1, "%s() VID_B_INT_MSTAT 0x%08X\n", __func__,
1386 cx_read(VID_B_INT_MSTAT));
1387 dprintk(1, "%s() VID_B_INT_SSTAT 0x%08X\n", __func__,
1388 cx_read(VID_B_INT_SSTAT));
1389 dprintk(1, "%s() VID_C_INT_MSTAT 0x%08X\n", __func__,
1390 cx_read(VID_C_INT_MSTAT));
1391 dprintk(1, "%s() VID_C_INT_SSTAT 0x%08X\n", __func__,
1392 cx_read(VID_C_INT_SSTAT));
1393}
1394
1395int cx23885_start_dma(struct cx23885_tsport *port,
1396 struct cx23885_dmaqueue *q,
1397 struct cx23885_buffer *buf)
1398{
1399 struct cx23885_dev *dev = port->dev;
1400 u32 reg;
1401
1402 dprintk(1, "%s() w: %d, h: %d, f: %d\n", __func__,
1403 dev->width, dev->height, dev->field);
1404
1405
1406 cx23885_clear_bridge_error(dev);
1407
1408
1409 cx_clear(port->reg_dma_ctl, port->dma_ctl_val);
1410
1411
1412 cx23885_sram_channel_setup(dev,
1413 &dev->sram_channels[port->sram_chno],
1414 port->ts_packet_size, buf->risc.dma);
1415 if (debug > 5) {
1416 cx23885_sram_channel_dump(dev,
1417 &dev->sram_channels[port->sram_chno]);
1418 cx23885_risc_disasm(port, &buf->risc);
1419 }
1420
1421
1422 cx_write(port->reg_lngth, port->ts_packet_size);
1423
1424 if ((!(cx23885_boards[dev->board].portb & CX23885_MPEG_DVB)) &&
1425 (!(cx23885_boards[dev->board].portc & CX23885_MPEG_DVB))) {
1426 pr_err("%s() Unsupported .portb/c (0x%08x)/(0x%08x)\n",
1427 __func__,
1428 cx23885_boards[dev->board].portb,
1429 cx23885_boards[dev->board].portc);
1430 return -EINVAL;
1431 }
1432
1433 if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER)
1434 cx23885_av_clk(dev, 0);
1435
1436 udelay(100);
1437
1438
1439 if (port->reg_src_sel)
1440 cx_write(port->reg_src_sel, port->src_sel_val);
1441
1442 cx_write(port->reg_hw_sop_ctrl, port->hw_sop_ctrl_val);
1443 cx_write(port->reg_ts_clk_en, port->ts_clk_en_val);
1444 cx_write(port->reg_vld_misc, port->vld_misc_val);
1445 cx_write(port->reg_gen_ctrl, port->gen_ctrl_val);
1446 udelay(100);
1447
1448
1449
1450 cx_write(port->reg_gpcnt_ctl, 3);
1451 q->count = 0;
1452
1453
1454 if (cx23885_boards[dev->board].portb == CX23885_MPEG_DVB) {
1455 reg = cx_read(PAD_CTRL);
1456 reg &= ~0x3;
1457 cx_write(PAD_CTRL, reg);
1458 }
1459
1460
1461 if (cx23885_boards[dev->board].portc == CX23885_MPEG_DVB) {
1462 reg = cx_read(PAD_CTRL);
1463 reg &= ~0x4;
1464 cx_write(PAD_CTRL, reg);
1465 }
1466
1467 if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER) {
1468
1469 reg = cx_read(PAD_CTRL);
1470 reg = reg & ~0x1;
1471
1472
1473
1474 reg = reg | 0xa;
1475 cx_write(PAD_CTRL, reg);
1476
1477
1478
1479 cx_write(CLK_DELAY, cx_read(CLK_DELAY) | 0x80000011);
1480
1481
1482
1483
1484
1485
1486 cx_write(ALT_PIN_OUT_SEL, 0x10100045);
1487 }
1488
1489 switch (dev->bridge) {
1490 case CX23885_BRIDGE_885:
1491 case CX23885_BRIDGE_887:
1492 case CX23885_BRIDGE_888:
1493
1494 dprintk(1, "%s() enabling TS int's and DMA\n", __func__);
1495
1496 cx23885_clear_bridge_error(dev);
1497 cx_set(port->reg_ts_int_msk, port->ts_int_msk_val);
1498 cx_set(port->reg_dma_ctl, port->dma_ctl_val);
1499
1500
1501 cx23885_clear_bridge_error(dev);
1502 cx23885_irq_add(dev, port->pci_irqmask);
1503 cx23885_irq_enable_all(dev);
1504
1505
1506 cx23885_clear_bridge_error(dev);
1507 break;
1508 default:
1509 BUG();
1510 }
1511
1512 cx_set(DEV_CNTRL2, (1<<5));
1513
1514 cx23885_clear_bridge_error(dev);
1515
1516 if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER)
1517 cx23885_av_clk(dev, 1);
1518
1519 if (debug > 4)
1520 cx23885_tsport_reg_dump(port);
1521
1522 cx23885_irq_get_mask(dev);
1523
1524
1525 cx23885_clear_bridge_error(dev);
1526
1527 return 0;
1528}
1529
1530static int cx23885_stop_dma(struct cx23885_tsport *port)
1531{
1532 struct cx23885_dev *dev = port->dev;
1533 u32 reg;
1534 int delay = 0;
1535 uint32_t reg1_val;
1536 uint32_t reg2_val;
1537
1538 dprintk(1, "%s()\n", __func__);
1539
1540
1541 cx_clear(port->reg_ts_int_msk, port->ts_int_msk_val);
1542 cx_clear(port->reg_dma_ctl, port->dma_ctl_val);
1543
1544 mdelay(20);
1545 for (delay = 0; delay < 100; delay++) {
1546 reg1_val = cx_read(TC_REQ);
1547 reg2_val = cx_read(TC_REQ_SET);
1548 if (reg1_val == 0 || reg2_val == 0)
1549 break;
1550 mdelay(1);
1551 }
1552 dev_dbg(&dev->pci->dev, "delay=%d reg1=0x%08x reg2=0x%08x\n",
1553 delay, reg1_val, reg2_val);
1554
1555 if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER) {
1556 reg = cx_read(PAD_CTRL);
1557
1558
1559 reg = reg | 0x1;
1560
1561
1562 reg = reg & ~0xa;
1563 cx_write(PAD_CTRL, reg);
1564 cx_write(port->reg_src_sel, 0);
1565 cx_write(port->reg_gen_ctrl, 8);
1566 }
1567
1568 if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER)
1569 cx23885_av_clk(dev, 0);
1570
1571 return 0;
1572}
1573
1574
1575
1576int cx23885_buf_prepare(struct cx23885_buffer *buf, struct cx23885_tsport *port)
1577{
1578 struct cx23885_dev *dev = port->dev;
1579 int size = port->ts_packet_size * port->ts_packet_count;
1580 struct sg_table *sgt = vb2_dma_sg_plane_desc(&buf->vb.vb2_buf, 0);
1581
1582 dprintk(1, "%s: %p\n", __func__, buf);
1583 if (vb2_plane_size(&buf->vb.vb2_buf, 0) < size)
1584 return -EINVAL;
1585 vb2_set_plane_payload(&buf->vb.vb2_buf, 0, size);
1586
1587 cx23885_risc_databuffer(dev->pci, &buf->risc,
1588 sgt->sgl,
1589 port->ts_packet_size, port->ts_packet_count, 0);
1590 return 0;
1591}
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614void cx23885_buf_queue(struct cx23885_tsport *port, struct cx23885_buffer *buf)
1615{
1616 struct cx23885_buffer *prev;
1617 struct cx23885_dev *dev = port->dev;
1618 struct cx23885_dmaqueue *cx88q = &port->mpegq;
1619 unsigned long flags;
1620
1621 buf->risc.cpu[1] = cpu_to_le32(buf->risc.dma + 12);
1622 buf->risc.jmp[0] = cpu_to_le32(RISC_JUMP | RISC_CNT_INC);
1623 buf->risc.jmp[1] = cpu_to_le32(buf->risc.dma + 12);
1624 buf->risc.jmp[2] = cpu_to_le32(0);
1625
1626 spin_lock_irqsave(&dev->slock, flags);
1627 if (list_empty(&cx88q->active)) {
1628 list_add_tail(&buf->queue, &cx88q->active);
1629 dprintk(1, "[%p/%d] %s - first active\n",
1630 buf, buf->vb.vb2_buf.index, __func__);
1631 } else {
1632 buf->risc.cpu[0] |= cpu_to_le32(RISC_IRQ1);
1633 prev = list_entry(cx88q->active.prev, struct cx23885_buffer,
1634 queue);
1635 list_add_tail(&buf->queue, &cx88q->active);
1636 prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
1637 dprintk(1, "[%p/%d] %s - append to active\n",
1638 buf, buf->vb.vb2_buf.index, __func__);
1639 }
1640 spin_unlock_irqrestore(&dev->slock, flags);
1641}
1642
1643
1644
1645static void do_cancel_buffers(struct cx23885_tsport *port, char *reason)
1646{
1647 struct cx23885_dmaqueue *q = &port->mpegq;
1648 struct cx23885_buffer *buf;
1649 unsigned long flags;
1650
1651 spin_lock_irqsave(&port->slock, flags);
1652 while (!list_empty(&q->active)) {
1653 buf = list_entry(q->active.next, struct cx23885_buffer,
1654 queue);
1655 list_del(&buf->queue);
1656 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
1657 dprintk(1, "[%p/%d] %s - dma=0x%08lx\n",
1658 buf, buf->vb.vb2_buf.index, reason,
1659 (unsigned long)buf->risc.dma);
1660 }
1661 spin_unlock_irqrestore(&port->slock, flags);
1662}
1663
1664void cx23885_cancel_buffers(struct cx23885_tsport *port)
1665{
1666 dprintk(1, "%s()\n", __func__);
1667 cx23885_stop_dma(port);
1668 do_cancel_buffers(port, "cancel");
1669}
1670
1671int cx23885_irq_417(struct cx23885_dev *dev, u32 status)
1672{
1673
1674 struct cx23885_tsport *port = &dev->ts1;
1675 int count = 0;
1676 int handled = 0;
1677
1678 if (status == 0)
1679 return handled;
1680
1681 count = cx_read(port->reg_gpcnt);
1682 dprintk(7, "status: 0x%08x mask: 0x%08x count: 0x%x\n",
1683 status, cx_read(port->reg_ts_int_msk), count);
1684
1685 if ((status & VID_B_MSK_BAD_PKT) ||
1686 (status & VID_B_MSK_OPC_ERR) ||
1687 (status & VID_B_MSK_VBI_OPC_ERR) ||
1688 (status & VID_B_MSK_SYNC) ||
1689 (status & VID_B_MSK_VBI_SYNC) ||
1690 (status & VID_B_MSK_OF) ||
1691 (status & VID_B_MSK_VBI_OF)) {
1692 pr_err("%s: V4L mpeg risc op code error, status = 0x%x\n",
1693 dev->name, status);
1694 if (status & VID_B_MSK_BAD_PKT)
1695 dprintk(1, " VID_B_MSK_BAD_PKT\n");
1696 if (status & VID_B_MSK_OPC_ERR)
1697 dprintk(1, " VID_B_MSK_OPC_ERR\n");
1698 if (status & VID_B_MSK_VBI_OPC_ERR)
1699 dprintk(1, " VID_B_MSK_VBI_OPC_ERR\n");
1700 if (status & VID_B_MSK_SYNC)
1701 dprintk(1, " VID_B_MSK_SYNC\n");
1702 if (status & VID_B_MSK_VBI_SYNC)
1703 dprintk(1, " VID_B_MSK_VBI_SYNC\n");
1704 if (status & VID_B_MSK_OF)
1705 dprintk(1, " VID_B_MSK_OF\n");
1706 if (status & VID_B_MSK_VBI_OF)
1707 dprintk(1, " VID_B_MSK_VBI_OF\n");
1708
1709 cx_clear(port->reg_dma_ctl, port->dma_ctl_val);
1710 cx23885_sram_channel_dump(dev,
1711 &dev->sram_channels[port->sram_chno]);
1712 cx23885_417_check_encoder(dev);
1713 } else if (status & VID_B_MSK_RISCI1) {
1714 dprintk(7, " VID_B_MSK_RISCI1\n");
1715 spin_lock(&port->slock);
1716 cx23885_wakeup(port, &port->mpegq, count);
1717 spin_unlock(&port->slock);
1718 }
1719 if (status) {
1720 cx_write(port->reg_ts_int_stat, status);
1721 handled = 1;
1722 }
1723
1724 return handled;
1725}
1726
1727static int cx23885_irq_ts(struct cx23885_tsport *port, u32 status)
1728{
1729 struct cx23885_dev *dev = port->dev;
1730 int handled = 0;
1731 u32 count;
1732
1733 if ((status & VID_BC_MSK_OPC_ERR) ||
1734 (status & VID_BC_MSK_BAD_PKT) ||
1735 (status & VID_BC_MSK_SYNC) ||
1736 (status & VID_BC_MSK_OF)) {
1737
1738 if (status & VID_BC_MSK_OPC_ERR)
1739 dprintk(7, " (VID_BC_MSK_OPC_ERR 0x%08x)\n",
1740 VID_BC_MSK_OPC_ERR);
1741
1742 if (status & VID_BC_MSK_BAD_PKT)
1743 dprintk(7, " (VID_BC_MSK_BAD_PKT 0x%08x)\n",
1744 VID_BC_MSK_BAD_PKT);
1745
1746 if (status & VID_BC_MSK_SYNC)
1747 dprintk(7, " (VID_BC_MSK_SYNC 0x%08x)\n",
1748 VID_BC_MSK_SYNC);
1749
1750 if (status & VID_BC_MSK_OF)
1751 dprintk(7, " (VID_BC_MSK_OF 0x%08x)\n",
1752 VID_BC_MSK_OF);
1753
1754 pr_err("%s: mpeg risc op code error\n", dev->name);
1755
1756 cx_clear(port->reg_dma_ctl, port->dma_ctl_val);
1757 cx23885_sram_channel_dump(dev,
1758 &dev->sram_channels[port->sram_chno]);
1759
1760 } else if (status & VID_BC_MSK_RISCI1) {
1761
1762 dprintk(7, " (RISCI1 0x%08x)\n", VID_BC_MSK_RISCI1);
1763
1764 spin_lock(&port->slock);
1765 count = cx_read(port->reg_gpcnt);
1766 cx23885_wakeup(port, &port->mpegq, count);
1767 spin_unlock(&port->slock);
1768
1769 }
1770 if (status) {
1771 cx_write(port->reg_ts_int_stat, status);
1772 handled = 1;
1773 }
1774
1775 return handled;
1776}
1777
1778static irqreturn_t cx23885_irq(int irq, void *dev_id)
1779{
1780 struct cx23885_dev *dev = dev_id;
1781 struct cx23885_tsport *ts1 = &dev->ts1;
1782 struct cx23885_tsport *ts2 = &dev->ts2;
1783 u32 pci_status, pci_mask;
1784 u32 vida_status, vida_mask;
1785 u32 audint_status, audint_mask;
1786 u32 ts1_status, ts1_mask;
1787 u32 ts2_status, ts2_mask;
1788 int vida_count = 0, ts1_count = 0, ts2_count = 0, handled = 0;
1789 int audint_count = 0;
1790 bool subdev_handled;
1791
1792 pci_status = cx_read(PCI_INT_STAT);
1793 pci_mask = cx23885_irq_get_mask(dev);
1794 if ((pci_status & pci_mask) == 0) {
1795 dprintk(7, "pci_status: 0x%08x pci_mask: 0x%08x\n",
1796 pci_status, pci_mask);
1797 goto out;
1798 }
1799
1800 vida_status = cx_read(VID_A_INT_STAT);
1801 vida_mask = cx_read(VID_A_INT_MSK);
1802 audint_status = cx_read(AUDIO_INT_INT_STAT);
1803 audint_mask = cx_read(AUDIO_INT_INT_MSK);
1804 ts1_status = cx_read(VID_B_INT_STAT);
1805 ts1_mask = cx_read(VID_B_INT_MSK);
1806 ts2_status = cx_read(VID_C_INT_STAT);
1807 ts2_mask = cx_read(VID_C_INT_MSK);
1808
1809 if (((pci_status & pci_mask) == 0) &&
1810 ((ts2_status & ts2_mask) == 0) &&
1811 ((ts1_status & ts1_mask) == 0))
1812 goto out;
1813
1814 vida_count = cx_read(VID_A_GPCNT);
1815 audint_count = cx_read(AUD_INT_A_GPCNT);
1816 ts1_count = cx_read(ts1->reg_gpcnt);
1817 ts2_count = cx_read(ts2->reg_gpcnt);
1818 dprintk(7, "pci_status: 0x%08x pci_mask: 0x%08x\n",
1819 pci_status, pci_mask);
1820 dprintk(7, "vida_status: 0x%08x vida_mask: 0x%08x count: 0x%x\n",
1821 vida_status, vida_mask, vida_count);
1822 dprintk(7, "audint_status: 0x%08x audint_mask: 0x%08x count: 0x%x\n",
1823 audint_status, audint_mask, audint_count);
1824 dprintk(7, "ts1_status: 0x%08x ts1_mask: 0x%08x count: 0x%x\n",
1825 ts1_status, ts1_mask, ts1_count);
1826 dprintk(7, "ts2_status: 0x%08x ts2_mask: 0x%08x count: 0x%x\n",
1827 ts2_status, ts2_mask, ts2_count);
1828
1829 if (pci_status & (PCI_MSK_RISC_RD | PCI_MSK_RISC_WR |
1830 PCI_MSK_AL_RD | PCI_MSK_AL_WR | PCI_MSK_APB_DMA |
1831 PCI_MSK_VID_C | PCI_MSK_VID_B | PCI_MSK_VID_A |
1832 PCI_MSK_AUD_INT | PCI_MSK_AUD_EXT |
1833 PCI_MSK_GPIO0 | PCI_MSK_GPIO1 |
1834 PCI_MSK_AV_CORE | PCI_MSK_IR)) {
1835
1836 if (pci_status & PCI_MSK_RISC_RD)
1837 dprintk(7, " (PCI_MSK_RISC_RD 0x%08x)\n",
1838 PCI_MSK_RISC_RD);
1839
1840 if (pci_status & PCI_MSK_RISC_WR)
1841 dprintk(7, " (PCI_MSK_RISC_WR 0x%08x)\n",
1842 PCI_MSK_RISC_WR);
1843
1844 if (pci_status & PCI_MSK_AL_RD)
1845 dprintk(7, " (PCI_MSK_AL_RD 0x%08x)\n",
1846 PCI_MSK_AL_RD);
1847
1848 if (pci_status & PCI_MSK_AL_WR)
1849 dprintk(7, " (PCI_MSK_AL_WR 0x%08x)\n",
1850 PCI_MSK_AL_WR);
1851
1852 if (pci_status & PCI_MSK_APB_DMA)
1853 dprintk(7, " (PCI_MSK_APB_DMA 0x%08x)\n",
1854 PCI_MSK_APB_DMA);
1855
1856 if (pci_status & PCI_MSK_VID_C)
1857 dprintk(7, " (PCI_MSK_VID_C 0x%08x)\n",
1858 PCI_MSK_VID_C);
1859
1860 if (pci_status & PCI_MSK_VID_B)
1861 dprintk(7, " (PCI_MSK_VID_B 0x%08x)\n",
1862 PCI_MSK_VID_B);
1863
1864 if (pci_status & PCI_MSK_VID_A)
1865 dprintk(7, " (PCI_MSK_VID_A 0x%08x)\n",
1866 PCI_MSK_VID_A);
1867
1868 if (pci_status & PCI_MSK_AUD_INT)
1869 dprintk(7, " (PCI_MSK_AUD_INT 0x%08x)\n",
1870 PCI_MSK_AUD_INT);
1871
1872 if (pci_status & PCI_MSK_AUD_EXT)
1873 dprintk(7, " (PCI_MSK_AUD_EXT 0x%08x)\n",
1874 PCI_MSK_AUD_EXT);
1875
1876 if (pci_status & PCI_MSK_GPIO0)
1877 dprintk(7, " (PCI_MSK_GPIO0 0x%08x)\n",
1878 PCI_MSK_GPIO0);
1879
1880 if (pci_status & PCI_MSK_GPIO1)
1881 dprintk(7, " (PCI_MSK_GPIO1 0x%08x)\n",
1882 PCI_MSK_GPIO1);
1883
1884 if (pci_status & PCI_MSK_AV_CORE)
1885 dprintk(7, " (PCI_MSK_AV_CORE 0x%08x)\n",
1886 PCI_MSK_AV_CORE);
1887
1888 if (pci_status & PCI_MSK_IR)
1889 dprintk(7, " (PCI_MSK_IR 0x%08x)\n",
1890 PCI_MSK_IR);
1891 }
1892
1893 if (cx23885_boards[dev->board].ci_type == 1 &&
1894 (pci_status & (PCI_MSK_GPIO1 | PCI_MSK_GPIO0)))
1895 handled += netup_ci_slot_status(dev, pci_status);
1896
1897 if (cx23885_boards[dev->board].ci_type == 2 &&
1898 (pci_status & PCI_MSK_GPIO0))
1899 handled += altera_ci_irq(dev);
1900
1901 if (ts1_status) {
1902 if (cx23885_boards[dev->board].portb == CX23885_MPEG_DVB)
1903 handled += cx23885_irq_ts(ts1, ts1_status);
1904 else
1905 if (cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER)
1906 handled += cx23885_irq_417(dev, ts1_status);
1907 }
1908
1909 if (ts2_status) {
1910 if (cx23885_boards[dev->board].portc == CX23885_MPEG_DVB)
1911 handled += cx23885_irq_ts(ts2, ts2_status);
1912 else
1913 if (cx23885_boards[dev->board].portc == CX23885_MPEG_ENCODER)
1914 handled += cx23885_irq_417(dev, ts2_status);
1915 }
1916
1917 if (vida_status)
1918 handled += cx23885_video_irq(dev, vida_status);
1919
1920 if (audint_status)
1921 handled += cx23885_audio_irq(dev, audint_status, audint_mask);
1922
1923 if (pci_status & PCI_MSK_IR) {
1924 subdev_handled = false;
1925 v4l2_subdev_call(dev->sd_ir, core, interrupt_service_routine,
1926 pci_status, &subdev_handled);
1927 if (subdev_handled)
1928 handled++;
1929 }
1930
1931 if ((pci_status & pci_mask) & PCI_MSK_AV_CORE) {
1932 cx23885_irq_disable(dev, PCI_MSK_AV_CORE);
1933 schedule_work(&dev->cx25840_work);
1934 handled++;
1935 }
1936
1937 if (handled)
1938 cx_write(PCI_INT_STAT, pci_status & pci_mask);
1939out:
1940 return IRQ_RETVAL(handled);
1941}
1942
1943static void cx23885_v4l2_dev_notify(struct v4l2_subdev *sd,
1944 unsigned int notification, void *arg)
1945{
1946 struct cx23885_dev *dev;
1947
1948 if (sd == NULL)
1949 return;
1950
1951 dev = to_cx23885(sd->v4l2_dev);
1952
1953 switch (notification) {
1954 case V4L2_SUBDEV_IR_RX_NOTIFY:
1955 if (sd == dev->sd_ir)
1956 cx23885_ir_rx_v4l2_dev_notify(sd, *(u32 *)arg);
1957 break;
1958 case V4L2_SUBDEV_IR_TX_NOTIFY:
1959 if (sd == dev->sd_ir)
1960 cx23885_ir_tx_v4l2_dev_notify(sd, *(u32 *)arg);
1961 break;
1962 }
1963}
1964
1965static void cx23885_v4l2_dev_notify_init(struct cx23885_dev *dev)
1966{
1967 INIT_WORK(&dev->cx25840_work, cx23885_av_work_handler);
1968 INIT_WORK(&dev->ir_rx_work, cx23885_ir_rx_work_handler);
1969 INIT_WORK(&dev->ir_tx_work, cx23885_ir_tx_work_handler);
1970 dev->v4l2_dev.notify = cx23885_v4l2_dev_notify;
1971}
1972
1973static inline int encoder_on_portb(struct cx23885_dev *dev)
1974{
1975 return cx23885_boards[dev->board].portb == CX23885_MPEG_ENCODER;
1976}
1977
1978static inline int encoder_on_portc(struct cx23885_dev *dev)
1979{
1980 return cx23885_boards[dev->board].portc == CX23885_MPEG_ENCODER;
1981}
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995void cx23885_gpio_set(struct cx23885_dev *dev, u32 mask)
1996{
1997 if (mask & 0x7)
1998 cx_set(GP0_IO, mask & 0x7);
1999
2000 if (mask & 0x0007fff8) {
2001 if (encoder_on_portb(dev) || encoder_on_portc(dev))
2002 pr_err("%s: Setting GPIO on encoder ports\n",
2003 dev->name);
2004 cx_set(MC417_RWD, (mask & 0x0007fff8) >> 3);
2005 }
2006
2007
2008 if (mask & 0x00f80000)
2009 pr_info("%s: Unsupported\n", dev->name);
2010}
2011
2012void cx23885_gpio_clear(struct cx23885_dev *dev, u32 mask)
2013{
2014 if (mask & 0x00000007)
2015 cx_clear(GP0_IO, mask & 0x7);
2016
2017 if (mask & 0x0007fff8) {
2018 if (encoder_on_portb(dev) || encoder_on_portc(dev))
2019 pr_err("%s: Clearing GPIO moving on encoder ports\n",
2020 dev->name);
2021 cx_clear(MC417_RWD, (mask & 0x7fff8) >> 3);
2022 }
2023
2024
2025 if (mask & 0x00f80000)
2026 pr_info("%s: Unsupported\n", dev->name);
2027}
2028
2029u32 cx23885_gpio_get(struct cx23885_dev *dev, u32 mask)
2030{
2031 if (mask & 0x00000007)
2032 return (cx_read(GP0_IO) >> 8) & mask & 0x7;
2033
2034 if (mask & 0x0007fff8) {
2035 if (encoder_on_portb(dev) || encoder_on_portc(dev))
2036 pr_err("%s: Reading GPIO moving on encoder ports\n",
2037 dev->name);
2038 return (cx_read(MC417_RWD) & ((mask & 0x7fff8) >> 3)) << 3;
2039 }
2040
2041
2042 if (mask & 0x00f80000)
2043 pr_info("%s: Unsupported\n", dev->name);
2044
2045 return 0;
2046}
2047
2048void cx23885_gpio_enable(struct cx23885_dev *dev, u32 mask, int asoutput)
2049{
2050 if ((mask & 0x00000007) && asoutput)
2051 cx_set(GP0_IO, (mask & 0x7) << 16);
2052 else if ((mask & 0x00000007) && !asoutput)
2053 cx_clear(GP0_IO, (mask & 0x7) << 16);
2054
2055 if (mask & 0x0007fff8) {
2056 if (encoder_on_portb(dev) || encoder_on_portc(dev))
2057 pr_err("%s: Enabling GPIO on encoder ports\n",
2058 dev->name);
2059 }
2060
2061
2062 if ((mask & 0x0007fff8) && asoutput)
2063 cx_clear(MC417_OEN, (mask & 0x7fff8) >> 3);
2064
2065 else if ((mask & 0x0007fff8) && !asoutput)
2066 cx_set(MC417_OEN, (mask & 0x7fff8) >> 3);
2067
2068
2069}
2070
2071static struct {
2072 int vendor, dev;
2073} const broken_dev_id[] = {
2074
2075
2076
2077
2078 { PCI_VENDOR_ID_AMD, 0x1451 },
2079
2080
2081
2082 { PCI_VENDOR_ID_AMD, 0x1423 },
2083
2084
2085 { PCI_VENDOR_ID_AMD, 0x1481 },
2086
2087
2088 { PCI_VENDOR_ID_AMD, 0x1419 },
2089
2090
2091 { PCI_VENDOR_ID_ATI, 0x5a23 },
2092};
2093
2094static bool cx23885_does_need_dma_reset(void)
2095{
2096 int i;
2097 struct pci_dev *pdev = NULL;
2098
2099 if (dma_reset_workaround == 0)
2100 return false;
2101 else if (dma_reset_workaround == 2)
2102 return true;
2103
2104 for (i = 0; i < ARRAY_SIZE(broken_dev_id); i++) {
2105 pdev = pci_get_device(broken_dev_id[i].vendor,
2106 broken_dev_id[i].dev, NULL);
2107 if (pdev) {
2108 pci_dev_put(pdev);
2109 return true;
2110 }
2111 }
2112 return false;
2113}
2114
2115static int cx23885_initdev(struct pci_dev *pci_dev,
2116 const struct pci_device_id *pci_id)
2117{
2118 struct cx23885_dev *dev;
2119 struct v4l2_ctrl_handler *hdl;
2120 int err;
2121
2122 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
2123 if (NULL == dev)
2124 return -ENOMEM;
2125
2126 dev->need_dma_reset = cx23885_does_need_dma_reset();
2127
2128 err = v4l2_device_register(&pci_dev->dev, &dev->v4l2_dev);
2129 if (err < 0)
2130 goto fail_free;
2131
2132 hdl = &dev->ctrl_handler;
2133 v4l2_ctrl_handler_init(hdl, 6);
2134 if (hdl->error) {
2135 err = hdl->error;
2136 goto fail_ctrl;
2137 }
2138 dev->v4l2_dev.ctrl_handler = hdl;
2139
2140
2141 cx23885_v4l2_dev_notify_init(dev);
2142
2143
2144 dev->pci = pci_dev;
2145 if (pci_enable_device(pci_dev)) {
2146 err = -EIO;
2147 goto fail_ctrl;
2148 }
2149
2150 if (cx23885_dev_setup(dev) < 0) {
2151 err = -EINVAL;
2152 goto fail_ctrl;
2153 }
2154
2155
2156 dev->pci_rev = pci_dev->revision;
2157 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &dev->pci_lat);
2158 pr_info("%s/0: found at %s, rev: %d, irq: %d, latency: %d, mmio: 0x%llx\n",
2159 dev->name,
2160 pci_name(pci_dev), dev->pci_rev, pci_dev->irq,
2161 dev->pci_lat,
2162 (unsigned long long)pci_resource_start(pci_dev, 0));
2163
2164 pci_set_master(pci_dev);
2165 err = dma_set_mask(&pci_dev->dev, 0xffffffff);
2166 if (err) {
2167 pr_err("%s/0: Oops: no 32bit PCI DMA ???\n", dev->name);
2168 goto fail_ctrl;
2169 }
2170
2171 err = request_irq(pci_dev->irq, cx23885_irq,
2172 IRQF_SHARED, dev->name, dev);
2173 if (err < 0) {
2174 pr_err("%s: can't get IRQ %d\n",
2175 dev->name, pci_dev->irq);
2176 goto fail_irq;
2177 }
2178
2179 switch (dev->board) {
2180 case CX23885_BOARD_NETUP_DUAL_DVBS2_CI:
2181 cx23885_irq_add_enable(dev, PCI_MSK_GPIO1 | PCI_MSK_GPIO0);
2182 break;
2183 case CX23885_BOARD_NETUP_DUAL_DVB_T_C_CI_RF:
2184 cx23885_irq_add_enable(dev, PCI_MSK_GPIO0);
2185 break;
2186 }
2187
2188
2189
2190
2191
2192
2193 cx23885_ir_pci_int_enable(dev);
2194 cx23885_input_init(dev);
2195
2196 return 0;
2197
2198fail_irq:
2199 cx23885_dev_unregister(dev);
2200fail_ctrl:
2201 v4l2_ctrl_handler_free(hdl);
2202 v4l2_device_unregister(&dev->v4l2_dev);
2203fail_free:
2204 kfree(dev);
2205 return err;
2206}
2207
2208static void cx23885_finidev(struct pci_dev *pci_dev)
2209{
2210 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
2211 struct cx23885_dev *dev = to_cx23885(v4l2_dev);
2212
2213 cx23885_input_fini(dev);
2214 cx23885_ir_fini(dev);
2215
2216 cx23885_shutdown(dev);
2217
2218
2219 free_irq(pci_dev->irq, dev);
2220
2221 pci_disable_device(pci_dev);
2222
2223 cx23885_dev_unregister(dev);
2224 v4l2_ctrl_handler_free(&dev->ctrl_handler);
2225 v4l2_device_unregister(v4l2_dev);
2226 kfree(dev);
2227}
2228
2229static const struct pci_device_id cx23885_pci_tbl[] = {
2230 {
2231
2232 .vendor = 0x14f1,
2233 .device = 0x8852,
2234 .subvendor = PCI_ANY_ID,
2235 .subdevice = PCI_ANY_ID,
2236 }, {
2237
2238 .vendor = 0x14f1,
2239 .device = 0x8880,
2240 .subvendor = PCI_ANY_ID,
2241 .subdevice = PCI_ANY_ID,
2242 }, {
2243
2244 }
2245};
2246MODULE_DEVICE_TABLE(pci, cx23885_pci_tbl);
2247
2248static struct pci_driver cx23885_pci_driver = {
2249 .name = "cx23885",
2250 .id_table = cx23885_pci_tbl,
2251 .probe = cx23885_initdev,
2252 .remove = cx23885_finidev,
2253};
2254
2255static int __init cx23885_init(void)
2256{
2257 pr_info("cx23885 driver version %s loaded\n",
2258 CX23885_VERSION);
2259 return pci_register_driver(&cx23885_pci_driver);
2260}
2261
2262static void __exit cx23885_fini(void)
2263{
2264 pci_unregister_driver(&cx23885_pci_driver);
2265}
2266
2267module_init(cx23885_init);
2268module_exit(cx23885_fini);
2269
