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