projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
V4L/DVB (5102): make videodev to auto-generate standards
[deliverable/linux.git] / drivers / media / video / cx88 / cx88-core.c
1 /*
2 *
3 * device driver for Conexant 2388x based TV cards
4 * driver core
5 *
6 * (c) 2003 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
7 *
8 * (c) 2005-2006 Mauro Carvalho Chehab <mchehab@infradead.org>
9 * - Multituner support
10 * - video_ioctl2 conversion
11 * - PAL/M fixes
12 *
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
17 *
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 */
27
28 #include <linux/init.h>
29 #include <linux/list.h>
30 #include <linux/module.h>
31 #include <linux/moduleparam.h>
32 #include <linux/kernel.h>
33 #include <linux/slab.h>
34 #include <linux/kmod.h>
35 #include <linux/sound.h>
36 #include <linux/interrupt.h>
37 #include <linux/pci.h>
38 #include <linux/delay.h>
39 #include <linux/videodev2.h>
40 #include <linux/mutex.h>
41
42 #include "cx88.h"
43 #include <media/v4l2-common.h>
44
45 MODULE_DESCRIPTION("v4l2 driver module for cx2388x based TV cards");
46 MODULE_AUTHOR("Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]");
47 MODULE_LICENSE("GPL");
48
49 /* ------------------------------------------------------------------ */
50
51 static unsigned int core_debug = 0;
52 module_param(core_debug,int,0644);
53 MODULE_PARM_DESC(core_debug,"enable debug messages [core]");
54
55 static unsigned int latency = UNSET;
56 module_param(latency,int,0444);
57 MODULE_PARM_DESC(latency,"pci latency timer");
58
59 static unsigned int tuner[] = {[0 ... (CX88_MAXBOARDS - 1)] = UNSET };
60 static unsigned int radio[] = {[0 ... (CX88_MAXBOARDS - 1)] = UNSET };
61 static unsigned int card[] = {[0 ... (CX88_MAXBOARDS - 1)] = UNSET };
62
63 module_param_array(tuner, int, NULL, 0444);
64 module_param_array(radio, int, NULL, 0444);
65 module_param_array(card, int, NULL, 0444);
66
67 MODULE_PARM_DESC(tuner,"tuner type");
68 MODULE_PARM_DESC(radio,"radio tuner type");
69 MODULE_PARM_DESC(card,"card type");
70
71 static unsigned int nicam = 0;
72 module_param(nicam,int,0644);
73 MODULE_PARM_DESC(nicam,"tv audio is nicam");
74
75 static unsigned int nocomb = 0;
76 module_param(nocomb,int,0644);
77 MODULE_PARM_DESC(nocomb,"disable comb filter");
78
79 #define dprintk(level,fmt, arg...) if (core_debug >= level) \
80 printk(KERN_DEBUG "%s: " fmt, core->name , ## arg)
81
82 static unsigned int cx88_devcount;
83 static LIST_HEAD(cx88_devlist);
84 static DEFINE_MUTEX(devlist);
85
86 #define NO_SYNC_LINE (-1U)
87
88 static u32* cx88_risc_field(u32 *rp, struct scatterlist *sglist,
89 unsigned int offset, u32 sync_line,
90 unsigned int bpl, unsigned int padding,
91 unsigned int lines)
92 {
93 struct scatterlist *sg;
94 unsigned int line,todo;
95
96 /* sync instruction */
97 if (sync_line != NO_SYNC_LINE)
98 *(rp++) = cpu_to_le32(RISC_RESYNC | sync_line);
99
100 /* scan lines */
101 sg = sglist;
102 for (line = 0; line < lines; line++) {
103 while (offset && offset >= sg_dma_len(sg)) {
104 offset -= sg_dma_len(sg);
105 sg++;
106 }
107 if (bpl <= sg_dma_len(sg)-offset) {
108 /* fits into current chunk */
109 *(rp++)=cpu_to_le32(RISC_WRITE|RISC_SOL|RISC_EOL|bpl);
110 *(rp++)=cpu_to_le32(sg_dma_address(sg)+offset);
111 offset+=bpl;
112 } else {
113 /* scanline needs to be split */
114 todo = bpl;
115 *(rp++)=cpu_to_le32(RISC_WRITE|RISC_SOL|
116 (sg_dma_len(sg)-offset));
117 *(rp++)=cpu_to_le32(sg_dma_address(sg)+offset);
118 todo -= (sg_dma_len(sg)-offset);
119 offset = 0;
120 sg++;
121 while (todo > sg_dma_len(sg)) {
122 *(rp++)=cpu_to_le32(RISC_WRITE|
123 sg_dma_len(sg));
124 *(rp++)=cpu_to_le32(sg_dma_address(sg));
125 todo -= sg_dma_len(sg);
126 sg++;
127 }
128 *(rp++)=cpu_to_le32(RISC_WRITE|RISC_EOL|todo);
129 *(rp++)=cpu_to_le32(sg_dma_address(sg));
130 offset += todo;
131 }
132 offset += padding;
133 }
134
135 return rp;
136 }
137
138 int cx88_risc_buffer(struct pci_dev *pci, struct btcx_riscmem *risc,
139 struct scatterlist *sglist,
140 unsigned int top_offset, unsigned int bottom_offset,
141 unsigned int bpl, unsigned int padding, unsigned int lines)
142 {
143 u32 instructions,fields;
144 u32 *rp;
145 int rc;
146
147 fields = 0;
148 if (UNSET != top_offset)
149 fields++;
150 if (UNSET != bottom_offset)
151 fields++;
152
153 /* estimate risc mem: worst case is one write per page border +
154 one write per scan line + syncs + jump (all 2 dwords). Padding
155 can cause next bpl to start close to a page border. First DMA
156 region may be smaller than PAGE_SIZE */
157 instructions = fields * (1 + ((bpl + padding) * lines) / PAGE_SIZE + lines);
158 instructions += 2;
159 if ((rc = btcx_riscmem_alloc(pci,risc,instructions*8)) < 0)
160 return rc;
161
162 /* write risc instructions */
163 rp = risc->cpu;
164 if (UNSET != top_offset)
165 rp = cx88_risc_field(rp, sglist, top_offset, 0,
166 bpl, padding, lines);
167 if (UNSET != bottom_offset)
168 rp = cx88_risc_field(rp, sglist, bottom_offset, 0x200,
169 bpl, padding, lines);
170
171 /* save pointer to jmp instruction address */
172 risc->jmp = rp;
173 BUG_ON((risc->jmp - risc->cpu + 2) * sizeof (*risc->cpu) > risc->size);
174 return 0;
175 }
176
177 int cx88_risc_databuffer(struct pci_dev *pci, struct btcx_riscmem *risc,
178 struct scatterlist *sglist, unsigned int bpl,
179 unsigned int lines)
180 {
181 u32 instructions;
182 u32 *rp;
183 int rc;
184
185 /* estimate risc mem: worst case is one write per page border +
186 one write per scan line + syncs + jump (all 2 dwords). Here
187 there is no padding and no sync. First DMA region may be smaller
188 than PAGE_SIZE */
189 instructions = 1 + (bpl * lines) / PAGE_SIZE + lines;
190 instructions += 1;
191 if ((rc = btcx_riscmem_alloc(pci,risc,instructions*8)) < 0)
192 return rc;
193
194 /* write risc instructions */
195 rp = risc->cpu;
196 rp = cx88_risc_field(rp, sglist, 0, NO_SYNC_LINE, bpl, 0, lines);
197
198 /* save pointer to jmp instruction address */
199 risc->jmp = rp;
200 BUG_ON((risc->jmp - risc->cpu + 2) * sizeof (*risc->cpu) > risc->size);
201 return 0;
202 }
203
204 int cx88_risc_stopper(struct pci_dev *pci, struct btcx_riscmem *risc,
205 u32 reg, u32 mask, u32 value)
206 {
207 u32 *rp;
208 int rc;
209
210 if ((rc = btcx_riscmem_alloc(pci, risc, 4*16)) < 0)
211 return rc;
212
213 /* write risc instructions */
214 rp = risc->cpu;
215 *(rp++) = cpu_to_le32(RISC_WRITECR | RISC_IRQ2 | RISC_IMM);
216 *(rp++) = cpu_to_le32(reg);
217 *(rp++) = cpu_to_le32(value);
218 *(rp++) = cpu_to_le32(mask);
219 *(rp++) = cpu_to_le32(RISC_JUMP);
220 *(rp++) = cpu_to_le32(risc->dma);
221 return 0;
222 }
223
224 void
225 cx88_free_buffer(struct videobuf_queue *q, struct cx88_buffer *buf)
226 {
227 BUG_ON(in_interrupt());
228 videobuf_waiton(&buf->vb,0,0);
229 videobuf_dma_unmap(q, &buf->vb.dma);
230 videobuf_dma_free(&buf->vb.dma);
231 btcx_riscmem_free((struct pci_dev *)q->dev, &buf->risc);
232 buf->vb.state = STATE_NEEDS_INIT;
233 }
234
235 /* ------------------------------------------------------------------ */
236 /* our SRAM memory layout */
237
238 /* we are going to put all thr risc programs into host memory, so we
239 * can use the whole SDRAM for the DMA fifos. To simplify things, we
240 * use a static memory layout. That surely will waste memory in case
241 * we don't use all DMA channels at the same time (which will be the
242 * case most of the time). But that still gives us enougth FIFO space
243 * to be able to deal with insane long pci latencies ...
244 *
245 * FIFO space allocations:
246 * channel 21 (y video) - 10.0k
247 * channel 22 (u video) - 2.0k
248 * channel 23 (v video) - 2.0k
249 * channel 24 (vbi) - 4.0k
250 * channels 25+26 (audio) - 4.0k
251 * channel 28 (mpeg) - 4.0k
252 * TOTAL = 29.0k
253 *
254 * Every channel has 160 bytes control data (64 bytes instruction
255 * queue and 6 CDT entries), which is close to 2k total.
256 *
257 * Address layout:
258 * 0x0000 - 0x03ff CMDs / reserved
259 * 0x0400 - 0x0bff instruction queues + CDs
260 * 0x0c00 - FIFOs
261 */
262
263 struct sram_channel cx88_sram_channels[] = {
264 [SRAM_CH21] = {
265 .name = "video y / packed",
266 .cmds_start = 0x180040,
267 .ctrl_start = 0x180400,
268 .cdt = 0x180400 + 64,
269 .fifo_start = 0x180c00,
270 .fifo_size = 0x002800,
271 .ptr1_reg = MO_DMA21_PTR1,
272 .ptr2_reg = MO_DMA21_PTR2,
273 .cnt1_reg = MO_DMA21_CNT1,
274 .cnt2_reg = MO_DMA21_CNT2,
275 },
276 [SRAM_CH22] = {
277 .name = "video u",
278 .cmds_start = 0x180080,
279 .ctrl_start = 0x1804a0,
280 .cdt = 0x1804a0 + 64,
281 .fifo_start = 0x183400,
282 .fifo_size = 0x000800,
283 .ptr1_reg = MO_DMA22_PTR1,
284 .ptr2_reg = MO_DMA22_PTR2,
285 .cnt1_reg = MO_DMA22_CNT1,
286 .cnt2_reg = MO_DMA22_CNT2,
287 },
288 [SRAM_CH23] = {
289 .name = "video v",
290 .cmds_start = 0x1800c0,
291 .ctrl_start = 0x180540,
292 .cdt = 0x180540 + 64,
293 .fifo_start = 0x183c00,
294 .fifo_size = 0x000800,
295 .ptr1_reg = MO_DMA23_PTR1,
296 .ptr2_reg = MO_DMA23_PTR2,
297 .cnt1_reg = MO_DMA23_CNT1,
298 .cnt2_reg = MO_DMA23_CNT2,
299 },
300 [SRAM_CH24] = {
301 .name = "vbi",
302 .cmds_start = 0x180100,
303 .ctrl_start = 0x1805e0,
304 .cdt = 0x1805e0 + 64,
305 .fifo_start = 0x184400,
306 .fifo_size = 0x001000,
307 .ptr1_reg = MO_DMA24_PTR1,
308 .ptr2_reg = MO_DMA24_PTR2,
309 .cnt1_reg = MO_DMA24_CNT1,
310 .cnt2_reg = MO_DMA24_CNT2,
311 },
312 [SRAM_CH25] = {
313 .name = "audio from",
314 .cmds_start = 0x180140,
315 .ctrl_start = 0x180680,
316 .cdt = 0x180680 + 64,
317 .fifo_start = 0x185400,
318 .fifo_size = 0x001000,
319 .ptr1_reg = MO_DMA25_PTR1,
320 .ptr2_reg = MO_DMA25_PTR2,
321 .cnt1_reg = MO_DMA25_CNT1,
322 .cnt2_reg = MO_DMA25_CNT2,
323 },
324 [SRAM_CH26] = {
325 .name = "audio to",
326 .cmds_start = 0x180180,
327 .ctrl_start = 0x180720,
328 .cdt = 0x180680 + 64, /* same as audio IN */
329 .fifo_start = 0x185400, /* same as audio IN */
330 .fifo_size = 0x001000, /* same as audio IN */
331 .ptr1_reg = MO_DMA26_PTR1,
332 .ptr2_reg = MO_DMA26_PTR2,
333 .cnt1_reg = MO_DMA26_CNT1,
334 .cnt2_reg = MO_DMA26_CNT2,
335 },
336 [SRAM_CH28] = {
337 .name = "mpeg",
338 .cmds_start = 0x180200,
339 .ctrl_start = 0x1807C0,
340 .cdt = 0x1807C0 + 64,
341 .fifo_start = 0x186400,
342 .fifo_size = 0x001000,
343 .ptr1_reg = MO_DMA28_PTR1,
344 .ptr2_reg = MO_DMA28_PTR2,
345 .cnt1_reg = MO_DMA28_CNT1,
346 .cnt2_reg = MO_DMA28_CNT2,
347 },
348 };
349
350 int cx88_sram_channel_setup(struct cx88_core *core,
351 struct sram_channel *ch,
352 unsigned int bpl, u32 risc)
353 {
354 unsigned int i,lines;
355 u32 cdt;
356
357 bpl = (bpl + 7) & ~7; /* alignment */
358 cdt = ch->cdt;
359 lines = ch->fifo_size / bpl;
360 if (lines > 6)
361 lines = 6;
362 BUG_ON(lines < 2);
363
364 /* write CDT */
365 for (i = 0; i < lines; i++)
366 cx_write(cdt + 16*i, ch->fifo_start + bpl*i);
367
368 /* write CMDS */
369 cx_write(ch->cmds_start + 0, risc);
370 cx_write(ch->cmds_start + 4, cdt);
371 cx_write(ch->cmds_start + 8, (lines*16) >> 3);
372 cx_write(ch->cmds_start + 12, ch->ctrl_start);
373 cx_write(ch->cmds_start + 16, 64 >> 2);
374 for (i = 20; i < 64; i += 4)
375 cx_write(ch->cmds_start + i, 0);
376
377 /* fill registers */
378 cx_write(ch->ptr1_reg, ch->fifo_start);
379 cx_write(ch->ptr2_reg, cdt);
380 cx_write(ch->cnt1_reg, (bpl >> 3) -1);
381 cx_write(ch->cnt2_reg, (lines*16) >> 3);
382
383 dprintk(2,"sram setup %s: bpl=%d lines=%d\n", ch->name, bpl, lines);
384 return 0;
385 }
386
387 /* ------------------------------------------------------------------ */
388 /* debug helper code */
389
390 static int cx88_risc_decode(u32 risc)
391 {
392 static char *instr[16] = {
393 [ RISC_SYNC >> 28 ] = "sync",
394 [ RISC_WRITE >> 28 ] = "write",
395 [ RISC_WRITEC >> 28 ] = "writec",
396 [ RISC_READ >> 28 ] = "read",
397 [ RISC_READC >> 28 ] = "readc",
398 [ RISC_JUMP >> 28 ] = "jump",
399 [ RISC_SKIP >> 28 ] = "skip",
400 [ RISC_WRITERM >> 28 ] = "writerm",
401 [ RISC_WRITECM >> 28 ] = "writecm",
402 [ RISC_WRITECR >> 28 ] = "writecr",
403 };
404 static int incr[16] = {
405 [ RISC_WRITE >> 28 ] = 2,
406 [ RISC_JUMP >> 28 ] = 2,
407 [ RISC_WRITERM >> 28 ] = 3,
408 [ RISC_WRITECM >> 28 ] = 3,
409 [ RISC_WRITECR >> 28 ] = 4,
410 };
411 static char *bits[] = {
412 "12", "13", "14", "resync",
413 "cnt0", "cnt1", "18", "19",
414 "20", "21", "22", "23",
415 "irq1", "irq2", "eol", "sol",
416 };
417 int i;
418
419 printk("0x%08x [ %s", risc,
420 instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
421 for (i = ARRAY_SIZE(bits)-1; i >= 0; i--)
422 if (risc & (1 << (i + 12)))
423 printk(" %s",bits[i]);
424 printk(" count=%d ]\n", risc & 0xfff);
425 return incr[risc >> 28] ? incr[risc >> 28] : 1;
426 }
427
428
429 void cx88_sram_channel_dump(struct cx88_core *core,
430 struct sram_channel *ch)
431 {
432 static char *name[] = {
433 "initial risc",
434 "cdt base",
435 "cdt size",
436 "iq base",
437 "iq size",
438 "risc pc",
439 "iq wr ptr",
440 "iq rd ptr",
441 "cdt current",
442 "pci target",
443 "line / byte",
444 };
445 u32 risc;
446 unsigned int i,j,n;
447
448 printk("%s: %s - dma channel status dump\n",
449 core->name,ch->name);
450 for (i = 0; i < ARRAY_SIZE(name); i++)
451 printk("%s: cmds: %-12s: 0x%08x\n",
452 core->name,name[i],
453 cx_read(ch->cmds_start + 4*i));
454 for (i = 0; i < 4; i++) {
455 risc = cx_read(ch->cmds_start + 4 * (i+11));
456 printk("%s: risc%d: ", core->name, i);
457 cx88_risc_decode(risc);
458 }
459 for (i = 0; i < 16; i += n) {
460 risc = cx_read(ch->ctrl_start + 4 * i);
461 printk("%s: iq %x: ", core->name, i);
462 n = cx88_risc_decode(risc);
463 for (j = 1; j < n; j++) {
464 risc = cx_read(ch->ctrl_start + 4 * (i+j));
465 printk("%s: iq %x: 0x%08x [ arg #%d ]\n",
466 core->name, i+j, risc, j);
467 }
468 }
469
470 printk("%s: fifo: 0x%08x -> 0x%x\n",
471 core->name, ch->fifo_start, ch->fifo_start+ch->fifo_size);
472 printk("%s: ctrl: 0x%08x -> 0x%x\n",
473 core->name, ch->ctrl_start, ch->ctrl_start+6*16);
474 printk("%s: ptr1_reg: 0x%08x\n",
475 core->name,cx_read(ch->ptr1_reg));
476 printk("%s: ptr2_reg: 0x%08x\n",
477 core->name,cx_read(ch->ptr2_reg));
478 printk("%s: cnt1_reg: 0x%08x\n",
479 core->name,cx_read(ch->cnt1_reg));
480 printk("%s: cnt2_reg: 0x%08x\n",
481 core->name,cx_read(ch->cnt2_reg));
482 }
483
484 static char *cx88_pci_irqs[32] = {
485 "vid", "aud", "ts", "vip", "hst", "5", "6", "tm1",
486 "src_dma", "dst_dma", "risc_rd_err", "risc_wr_err",
487 "brdg_err", "src_dma_err", "dst_dma_err", "ipb_dma_err",
488 "i2c", "i2c_rack", "ir_smp", "gpio0", "gpio1"
489 };
490
491 void cx88_print_irqbits(char *name, char *tag, char **strings,
492 u32 bits, u32 mask)
493 {
494 unsigned int i;
495
496 printk(KERN_DEBUG "%s: %s [0x%x]", name, tag, bits);
497 for (i = 0; i < 32; i++) {
498 if (!(bits & (1 << i)))
499 continue;
500 if (strings[i])
501 printk(" %s", strings[i]);
502 else
503 printk(" %d", i);
504 if (!(mask & (1 << i)))
505 continue;
506 printk("*");
507 }
508 printk("\n");
509 }
510
511 /* ------------------------------------------------------------------ */
512
513 int cx88_core_irq(struct cx88_core *core, u32 status)
514 {
515 int handled = 0;
516
517 if (status & (1<<18)) {
518 cx88_ir_irq(core);
519 handled++;
520 }
521 if (!handled)
522 cx88_print_irqbits(core->name, "irq pci",
523 cx88_pci_irqs, status,
524 core->pci_irqmask);
525 return handled;
526 }
527
528 void cx88_wakeup(struct cx88_core *core,
529 struct cx88_dmaqueue *q, u32 count)
530 {
531 struct cx88_buffer *buf;
532 int bc;
533
534 for (bc = 0;; bc++) {
535 if (list_empty(&q->active))
536 break;
537 buf = list_entry(q->active.next,
538 struct cx88_buffer, vb.queue);
539 /* count comes from the hw and is is 16bit wide --
540 * this trick handles wrap-arounds correctly for
541 * up to 32767 buffers in flight... */
542 if ((s16) (count - buf->count) < 0)
543 break;
544 do_gettimeofday(&buf->vb.ts);
545 dprintk(2,"[%p/%d] wakeup reg=%d buf=%d\n",buf,buf->vb.i,
546 count, buf->count);
547 buf->vb.state = STATE_DONE;
548 list_del(&buf->vb.queue);
549 wake_up(&buf->vb.done);
550 }
551 if (list_empty(&q->active)) {
552 del_timer(&q->timeout);
553 } else {
554 mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
555 }
556 if (bc != 1)
557 printk("%s: %d buffers handled (should be 1)\n",__FUNCTION__,bc);
558 }
559
560 void cx88_shutdown(struct cx88_core *core)
561 {
562 /* disable RISC controller + IRQs */
563 cx_write(MO_DEV_CNTRL2, 0);
564
565 /* stop dma transfers */
566 cx_write(MO_VID_DMACNTRL, 0x0);
567 cx_write(MO_AUD_DMACNTRL, 0x0);
568 cx_write(MO_TS_DMACNTRL, 0x0);
569 cx_write(MO_VIP_DMACNTRL, 0x0);
570 cx_write(MO_GPHST_DMACNTRL, 0x0);
571
572 /* stop interrupts */
573 cx_write(MO_PCI_INTMSK, 0x0);
574 cx_write(MO_VID_INTMSK, 0x0);
575 cx_write(MO_AUD_INTMSK, 0x0);
576 cx_write(MO_TS_INTMSK, 0x0);
577 cx_write(MO_VIP_INTMSK, 0x0);
578 cx_write(MO_GPHST_INTMSK, 0x0);
579
580 /* stop capturing */
581 cx_write(VID_CAPTURE_CONTROL, 0);
582 }
583
584 int cx88_reset(struct cx88_core *core)
585 {
586 dprintk(1,"%s\n",__FUNCTION__);
587 cx88_shutdown(core);
588
589 /* clear irq status */
590 cx_write(MO_VID_INTSTAT, 0xFFFFFFFF); // Clear PIV int
591 cx_write(MO_PCI_INTSTAT, 0xFFFFFFFF); // Clear PCI int
592 cx_write(MO_INT1_STAT, 0xFFFFFFFF); // Clear RISC int
593
594 /* wait a bit */
595 msleep(100);
596
597 /* init sram */
598 cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH21], 720*4, 0);
599 cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH22], 128, 0);
600 cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH23], 128, 0);
601 cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH24], 128, 0);
602 cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH25], 128, 0);
603 cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH26], 128, 0);
604 cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH28], 188*4, 0);
605
606 /* misc init ... */
607 cx_write(MO_INPUT_FORMAT, ((1 << 13) | // agc enable
608 (1 << 12) | // agc gain
609 (1 << 11) | // adaptibe agc
610 (0 << 10) | // chroma agc
611 (0 << 9) | // ckillen
612 (7)));
613
614 /* setup image format */
615 cx_andor(MO_COLOR_CTRL, 0x4000, 0x4000);
616
617 /* setup FIFO Threshholds */
618 cx_write(MO_PDMA_STHRSH, 0x0807);
619 cx_write(MO_PDMA_DTHRSH, 0x0807);
620
621 /* fixes flashing of image */
622 cx_write(MO_AGC_SYNC_TIP1, 0x0380000F);
623 cx_write(MO_AGC_BACK_VBI, 0x00E00555);
624
625 cx_write(MO_VID_INTSTAT, 0xFFFFFFFF); // Clear PIV int
626 cx_write(MO_PCI_INTSTAT, 0xFFFFFFFF); // Clear PCI int
627 cx_write(MO_INT1_STAT, 0xFFFFFFFF); // Clear RISC int
628
629 /* Reset on-board parts */
630 cx_write(MO_SRST_IO, 0);
631 msleep(10);
632 cx_write(MO_SRST_IO, 1);
633
634 return 0;
635 }
636
637 /* ------------------------------------------------------------------ */
638
639 static unsigned int inline norm_swidth(v4l2_std_id norm)
640 {
641 return (norm & (V4L2_STD_MN & ~V4L2_STD_PAL_Nc)) ? 754 : 922;
642 }
643
644 static unsigned int inline norm_hdelay(v4l2_std_id norm)
645 {
646 return (norm & (V4L2_STD_MN & ~V4L2_STD_PAL_Nc)) ? 135 : 186;
647 }
648
649 static unsigned int inline norm_vdelay(v4l2_std_id norm)
650 {
651 return (norm & V4L2_STD_625_50) ? 0x24 : 0x18;
652 }
653
654 static unsigned int inline norm_fsc8(v4l2_std_id norm)
655 {
656 if (norm & V4L2_STD_PAL_M)
657 return 28604892; // 3.575611 MHz
658
659 if (norm & (V4L2_STD_PAL_Nc))
660 return 28656448; // 3.582056 MHz
661
662 if (norm & V4L2_STD_NTSC) // All NTSC/M and variants
663 return 28636360; // 3.57954545 MHz +/- 10 Hz
664
665 /* SECAM have also different sub carrier for chroma,
666 but step_db and step_dr, at cx88_set_tvnorm already handles that.
667
668 The same FSC applies to PAL/BGDKIH, PAL/60, NTSC/4.43 and PAL/N
669 */
670
671 return 35468950; // 4.43361875 MHz +/- 5 Hz
672 }
673
674 static unsigned int inline norm_htotal(v4l2_std_id norm)
675 {
676
677 unsigned int fsc4=norm_fsc8(norm)/2;
678
679 /* returns 4*FSC / vtotal / frames per seconds */
680 return (norm & V4L2_STD_625_50) ?
681 ((fsc4+312)/625+12)/25 :
682 ((fsc4+262)/525*1001+15000)/30000;
683 }
684
685 static unsigned int inline norm_vbipack(v4l2_std_id norm)
686 {
687 return (norm & V4L2_STD_625_50) ? 511 : 400;
688 }
689
690 int cx88_set_scale(struct cx88_core *core, unsigned int width, unsigned int height,
691 enum v4l2_field field)
692 {
693 unsigned int swidth = norm_swidth(core->tvnorm);
694 unsigned int sheight = norm_maxh(core->tvnorm);
695 u32 value;
696
697 dprintk(1,"set_scale: %dx%d [%s%s,%s]\n", width, height,
698 V4L2_FIELD_HAS_TOP(field) ? "T" : "",
699 V4L2_FIELD_HAS_BOTTOM(field) ? "B" : "",
700 v4l2_norm_to_name(core->tvnorm));
701 if (!V4L2_FIELD_HAS_BOTH(field))
702 height *= 2;
703
704 // recalc H delay and scale registers
705 value = (width * norm_hdelay(core->tvnorm)) / swidth;
706 value &= 0x3fe;
707 cx_write(MO_HDELAY_EVEN, value);
708 cx_write(MO_HDELAY_ODD, value);
709 dprintk(1,"set_scale: hdelay 0x%04x (width %d)\n", value,swidth);
710
711 value = (swidth * 4096 / width) - 4096;
712 cx_write(MO_HSCALE_EVEN, value);
713 cx_write(MO_HSCALE_ODD, value);
714 dprintk(1,"set_scale: hscale 0x%04x\n", value);
715
716 cx_write(MO_HACTIVE_EVEN, width);
717 cx_write(MO_HACTIVE_ODD, width);
718 dprintk(1,"set_scale: hactive 0x%04x\n", width);
719
720 // recalc V scale Register (delay is constant)
721 cx_write(MO_VDELAY_EVEN, norm_vdelay(core->tvnorm));
722 cx_write(MO_VDELAY_ODD, norm_vdelay(core->tvnorm));
723 dprintk(1,"set_scale: vdelay 0x%04x\n", norm_vdelay(core->tvnorm));
724
725 value = (0x10000 - (sheight * 512 / height - 512)) & 0x1fff;
726 cx_write(MO_VSCALE_EVEN, value);
727 cx_write(MO_VSCALE_ODD, value);
728 dprintk(1,"set_scale: vscale 0x%04x\n", value);
729
730 cx_write(MO_VACTIVE_EVEN, sheight);
731 cx_write(MO_VACTIVE_ODD, sheight);
732 dprintk(1,"set_scale: vactive 0x%04x\n", sheight);
733
734 // setup filters
735 value = 0;
736 value |= (1 << 19); // CFILT (default)
737 if (core->tvnorm & V4L2_STD_SECAM) {
738 value |= (1 << 15);
739 value |= (1 << 16);
740 }
741 if (INPUT(core->input)->type == CX88_VMUX_SVIDEO)
742 value |= (1 << 13) | (1 << 5);
743 if (V4L2_FIELD_INTERLACED == field)
744 value |= (1 << 3); // VINT (interlaced vertical scaling)
745 if (width < 385)
746 value |= (1 << 0); // 3-tap interpolation
747 if (width < 193)
748 value |= (1 << 1); // 5-tap interpolation
749 if (nocomb)
750 value |= (3 << 5); // disable comb filter
751
752 cx_write(MO_FILTER_EVEN, value);
753 cx_write(MO_FILTER_ODD, value);
754 dprintk(1,"set_scale: filter 0x%04x\n", value);
755
756 return 0;
757 }
758
759 static const u32 xtal = 28636363;
760
761 static int set_pll(struct cx88_core *core, int prescale, u32 ofreq)
762 {
763 static u32 pre[] = { 0, 0, 0, 3, 2, 1 };
764 u64 pll;
765 u32 reg;
766 int i;
767
768 if (prescale < 2)
769 prescale = 2;
770 if (prescale > 5)
771 prescale = 5;
772
773 pll = ofreq * 8 * prescale * (u64)(1 << 20);
774 do_div(pll,xtal);
775 reg = (pll & 0x3ffffff) | (pre[prescale] << 26);
776 if (((reg >> 20) & 0x3f) < 14) {
777 printk("%s/0: pll out of range\n",core->name);
778 return -1;
779 }
780
781 dprintk(1,"set_pll: MO_PLL_REG 0x%08x [old=0x%08x,freq=%d]\n",
782 reg, cx_read(MO_PLL_REG), ofreq);
783 cx_write(MO_PLL_REG, reg);
784 for (i = 0; i < 100; i++) {
785 reg = cx_read(MO_DEVICE_STATUS);
786 if (reg & (1<<2)) {
787 dprintk(1,"pll locked [pre=%d,ofreq=%d]\n",
788 prescale,ofreq);
789 return 0;
790 }
791 dprintk(1,"pll not locked yet, waiting ...\n");
792 msleep(10);
793 }
794 dprintk(1,"pll NOT locked [pre=%d,ofreq=%d]\n",prescale,ofreq);
795 return -1;
796 }
797
798 int cx88_start_audio_dma(struct cx88_core *core)
799 {
800 /* constant 128 made buzz in analog Nicam-stereo for bigger fifo_size */
801 int bpl = cx88_sram_channels[SRAM_CH25].fifo_size/4;
802
803 /* If downstream RISC is enabled, bail out; ALSA is managing DMA */
804 if (cx_read(MO_AUD_DMACNTRL) & 0x10)
805 return 0;
806
807 /* setup fifo + format */
808 cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH25], bpl, 0);
809 cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH26], bpl, 0);
810
811 cx_write(MO_AUDD_LNGTH, bpl); /* fifo bpl size */
812 cx_write(MO_AUDR_LNGTH, bpl); /* fifo bpl size */
813
814 /* start dma */
815 cx_write(MO_AUD_DMACNTRL, 0x0003); /* Up and Down fifo enable */
816
817 return 0;
818 }
819
820 int cx88_stop_audio_dma(struct cx88_core *core)
821 {
822 /* If downstream RISC is enabled, bail out; ALSA is managing DMA */
823 if (cx_read(MO_AUD_DMACNTRL) & 0x10)
824 return 0;
825
826 /* stop dma */
827 cx_write(MO_AUD_DMACNTRL, 0x0000);
828
829 return 0;
830 }
831
832 static int set_tvaudio(struct cx88_core *core)
833 {
834 v4l2_std_id norm = core->tvnorm;
835
836 if (CX88_VMUX_TELEVISION != INPUT(core->input)->type)
837 return 0;
838
839 if (V4L2_STD_PAL_BG & norm) {
840 core->tvaudio = WW_BG;
841
842 } else if (V4L2_STD_PAL_DK & norm) {
843 core->tvaudio = WW_DK;
844
845 } else if (V4L2_STD_PAL_I & norm) {
846 core->tvaudio = WW_I;
847
848 } else if (V4L2_STD_SECAM_L & norm) {
849 core->tvaudio = WW_L;
850
851 } else if (V4L2_STD_SECAM_DK & norm) {
852 core->tvaudio = WW_DK;
853
854 } else if ((V4L2_STD_NTSC_M & norm) ||
855 (V4L2_STD_PAL_M & norm)) {
856 core->tvaudio = WW_BTSC;
857
858 } else if (V4L2_STD_NTSC_M_JP & norm) {
859 core->tvaudio = WW_EIAJ;
860
861 } else {
862 printk("%s/0: tvaudio support needs work for this tv norm [%s], sorry\n",
863 core->name, v4l2_norm_to_name(core->tvnorm));
864 core->tvaudio = 0;
865 return 0;
866 }
867
868 cx_andor(MO_AFECFG_IO, 0x1f, 0x0);
869 cx88_set_tvaudio(core);
870 /* cx88_set_stereo(dev,V4L2_TUNER_MODE_STEREO); */
871
872 /*
873 This should be needed only on cx88-alsa. It seems that some cx88 chips have
874 bugs and does require DMA enabled for it to work.
875 */
876 cx88_start_audio_dma(core);
877 return 0;
878 }
879
880
881
882 int cx88_set_tvnorm(struct cx88_core *core, v4l2_std_id norm)
883 {
884 u32 fsc8;
885 u32 adc_clock;
886 u32 vdec_clock;
887 u32 step_db,step_dr;
888 u64 tmp64;
889 u32 bdelay,agcdelay,htotal;
890 u32 cxiformat, cxoformat;
891
892 core->tvnorm = norm;
893 fsc8 = norm_fsc8(norm);
894 adc_clock = xtal;
895 vdec_clock = fsc8;
896 step_db = fsc8;
897 step_dr = fsc8;
898
899 if (norm & V4L2_STD_NTSC_M_JP) {
900 cxiformat = VideoFormatNTSCJapan;
901 cxoformat = 0x181f0008;
902 } else if (norm & V4L2_STD_NTSC_443) {
903 cxiformat = VideoFormatNTSC443;
904 cxoformat = 0x181f0008;
905 } else if (norm & V4L2_STD_PAL_M) {
906 cxiformat = VideoFormatPALM;
907 cxoformat = 0x1c1f0008;
908 } else if (norm & V4L2_STD_PAL_N) {
909 cxiformat = VideoFormatPALN;
910 cxoformat = 0x1c1f0008;
911 } else if (norm & V4L2_STD_PAL_Nc) {
912 cxiformat = VideoFormatPALNC;
913 cxoformat = 0x1c1f0008;
914 } else if (norm & V4L2_STD_PAL_60) {
915 cxiformat = VideoFormatPAL60;
916 cxoformat = 0x181f0008;
917 } else if (norm & V4L2_STD_NTSC) {
918 cxiformat = VideoFormatNTSC;
919 cxoformat = 0x181f0008;
920 } else if (norm & V4L2_STD_SECAM) {
921 step_db = 4250000 * 8;
922 step_dr = 4406250 * 8;
923
924 cxiformat = VideoFormatSECAM;
925 cxoformat = 0x181f0008;
926 } else { /* PAL */
927 cxiformat = VideoFormatPAL;
928 cxoformat = 0x181f0008;
929 }
930
931 dprintk(1,"set_tvnorm: \"%s\" fsc8=%d adc=%d vdec=%d db/dr=%d/%d\n",
932 v4l2_norm_to_name(core->tvnorm), fsc8, adc_clock, vdec_clock,
933 step_db, step_dr);
934 set_pll(core,2,vdec_clock);
935
936 dprintk(1,"set_tvnorm: MO_INPUT_FORMAT 0x%08x [old=0x%08x]\n",
937 cxiformat, cx_read(MO_INPUT_FORMAT) & 0x0f);
938 cx_andor(MO_INPUT_FORMAT, 0xf, cxiformat);
939
940 // FIXME: as-is from DScaler
941 dprintk(1,"set_tvnorm: MO_OUTPUT_FORMAT 0x%08x [old=0x%08x]\n",
942 cxoformat, cx_read(MO_OUTPUT_FORMAT));
943 cx_write(MO_OUTPUT_FORMAT, cxoformat);
944
945 // MO_SCONV_REG = adc clock / video dec clock * 2^17
946 tmp64 = adc_clock * (u64)(1 << 17);
947 do_div(tmp64, vdec_clock);
948 dprintk(1,"set_tvnorm: MO_SCONV_REG 0x%08x [old=0x%08x]\n",
949 (u32)tmp64, cx_read(MO_SCONV_REG));
950 cx_write(MO_SCONV_REG, (u32)tmp64);
951
952 // MO_SUB_STEP = 8 * fsc / video dec clock * 2^22
953 tmp64 = step_db * (u64)(1 << 22);
954 do_div(tmp64, vdec_clock);
955 dprintk(1,"set_tvnorm: MO_SUB_STEP 0x%08x [old=0x%08x]\n",
956 (u32)tmp64, cx_read(MO_SUB_STEP));
957 cx_write(MO_SUB_STEP, (u32)tmp64);
958
959 // MO_SUB_STEP_DR = 8 * 4406250 / video dec clock * 2^22
960 tmp64 = step_dr * (u64)(1 << 22);
961 do_div(tmp64, vdec_clock);
962 dprintk(1,"set_tvnorm: MO_SUB_STEP_DR 0x%08x [old=0x%08x]\n",
963 (u32)tmp64, cx_read(MO_SUB_STEP_DR));
964 cx_write(MO_SUB_STEP_DR, (u32)tmp64);
965
966 // bdelay + agcdelay
967 bdelay = vdec_clock * 65 / 20000000 + 21;
968 agcdelay = vdec_clock * 68 / 20000000 + 15;
969 dprintk(1,"set_tvnorm: MO_AGC_BURST 0x%08x [old=0x%08x,bdelay=%d,agcdelay=%d]\n",
970 (bdelay << 8) | agcdelay, cx_read(MO_AGC_BURST), bdelay, agcdelay);
971 cx_write(MO_AGC_BURST, (bdelay << 8) | agcdelay);
972
973 // htotal
974 tmp64 = norm_htotal(norm) * (u64)vdec_clock;
975 do_div(tmp64, fsc8);
976 htotal = (u32)tmp64 | (HLNotchFilter4xFsc << 11);
977 dprintk(1,"set_tvnorm: MO_HTOTAL 0x%08x [old=0x%08x,htotal=%d]\n",
978 htotal, cx_read(MO_HTOTAL), (u32)tmp64);
979 cx_write(MO_HTOTAL, htotal);
980
981 // vbi stuff, set vbi offset to 10 (for 20 Clk*2 pixels), this makes
982 // the effective vbi offset ~244 samples, the same as the Bt8x8
983 cx_write(MO_VBI_PACKET, (10<<11) | norm_vbipack(norm));
984
985 // this is needed as well to set all tvnorm parameter
986 cx88_set_scale(core, 320, 240, V4L2_FIELD_INTERLACED);
987
988 // audio
989 set_tvaudio(core);
990
991 // tell i2c chips
992 cx88_call_i2c_clients(core,VIDIOC_S_STD,&norm);
993
994 // done
995 return 0;
996 }
997
998 /* ------------------------------------------------------------------ */
999
1000 static int cx88_pci_quirks(char *name, struct pci_dev *pci)
1001 {
1002 unsigned int lat = UNSET;
1003 u8 ctrl = 0;
1004 u8 value;
1005
1006 /* check pci quirks */
1007 if (pci_pci_problems & PCIPCI_TRITON) {
1008 printk(KERN_INFO "%s: quirk: PCIPCI_TRITON -- set TBFX\n",
1009 name);
1010 ctrl |= CX88X_EN_TBFX;
1011 }
1012 if (pci_pci_problems & PCIPCI_NATOMA) {
1013 printk(KERN_INFO "%s: quirk: PCIPCI_NATOMA -- set TBFX\n",
1014 name);
1015 ctrl |= CX88X_EN_TBFX;
1016 }
1017 if (pci_pci_problems & PCIPCI_VIAETBF) {
1018 printk(KERN_INFO "%s: quirk: PCIPCI_VIAETBF -- set TBFX\n",
1019 name);
1020 ctrl |= CX88X_EN_TBFX;
1021 }
1022 if (pci_pci_problems & PCIPCI_VSFX) {
1023 printk(KERN_INFO "%s: quirk: PCIPCI_VSFX -- set VSFX\n",
1024 name);
1025 ctrl |= CX88X_EN_VSFX;
1026 }
1027 #ifdef PCIPCI_ALIMAGIK
1028 if (pci_pci_problems & PCIPCI_ALIMAGIK) {
1029 printk(KERN_INFO "%s: quirk: PCIPCI_ALIMAGIK -- latency fixup\n",
1030 name);
1031 lat = 0x0A;
1032 }
1033 #endif
1034
1035 /* check insmod options */
1036 if (UNSET != latency)
1037 lat = latency;
1038
1039 /* apply stuff */
1040 if (ctrl) {
1041 pci_read_config_byte(pci, CX88X_DEVCTRL, &value);
1042 value |= ctrl;
1043 pci_write_config_byte(pci, CX88X_DEVCTRL, value);
1044 }
1045 if (UNSET != lat) {
1046 printk(KERN_INFO "%s: setting pci latency timer to %d\n",
1047 name, latency);
1048 pci_write_config_byte(pci, PCI_LATENCY_TIMER, latency);
1049 }
1050 return 0;
1051 }
1052
1053 /* ------------------------------------------------------------------ */
1054
1055 struct video_device *cx88_vdev_init(struct cx88_core *core,
1056 struct pci_dev *pci,
1057 struct video_device *template,
1058 char *type)
1059 {
1060 struct video_device *vfd;
1061
1062 vfd = video_device_alloc();
1063 if (NULL == vfd)
1064 return NULL;
1065 *vfd = *template;
1066 vfd->minor = -1;
1067 vfd->dev = &pci->dev;
1068 vfd->release = video_device_release;
1069 snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)",
1070 core->name, type, cx88_boards[core->board].name);
1071 return vfd;
1072 }
1073
1074 static int get_ressources(struct cx88_core *core, struct pci_dev *pci)
1075 {
1076 if (request_mem_region(pci_resource_start(pci,0),
1077 pci_resource_len(pci,0),
1078 core->name))
1079 return 0;
1080 printk(KERN_ERR "%s: can't get MMIO memory @ 0x%llx\n",
1081 core->name,(unsigned long long)pci_resource_start(pci,0));
1082 return -EBUSY;
1083 }
1084
1085 struct cx88_core* cx88_core_get(struct pci_dev *pci)
1086 {
1087 struct cx88_core *core;
1088 struct list_head *item;
1089 int i;
1090
1091 mutex_lock(&devlist);
1092 list_for_each(item,&cx88_devlist) {
1093 core = list_entry(item, struct cx88_core, devlist);
1094 if (pci->bus->number != core->pci_bus)
1095 continue;
1096 if (PCI_SLOT(pci->devfn) != core->pci_slot)
1097 continue;
1098
1099 if (0 != get_ressources(core,pci))
1100 goto fail_unlock;
1101 atomic_inc(&core->refcount);
1102 mutex_unlock(&devlist);
1103 return core;
1104 }
1105 core = kzalloc(sizeof(*core),GFP_KERNEL);
1106 if (NULL == core)
1107 goto fail_unlock;
1108
1109 atomic_inc(&core->refcount);
1110 core->pci_bus = pci->bus->number;
1111 core->pci_slot = PCI_SLOT(pci->devfn);
1112 core->pci_irqmask = 0x00fc00;
1113 mutex_init(&core->lock);
1114
1115 core->nr = cx88_devcount++;
1116 sprintf(core->name,"cx88[%d]",core->nr);
1117 if (0 != get_ressources(core,pci)) {
1118 printk(KERN_ERR "CORE %s No more PCI ressources for "
1119 "subsystem: %04x:%04x, board: %s\n",
1120 core->name,pci->subsystem_vendor,
1121 pci->subsystem_device,
1122 cx88_boards[core->board].name);
1123
1124 cx88_devcount--;
1125 goto fail_free;
1126 }
1127 list_add_tail(&core->devlist,&cx88_devlist);
1128
1129 /* PCI stuff */
1130 cx88_pci_quirks(core->name, pci);
1131 core->lmmio = ioremap(pci_resource_start(pci,0),
1132 pci_resource_len(pci,0));
1133 core->bmmio = (u8 __iomem *)core->lmmio;
1134
1135 /* board config */
1136 core->board = UNSET;
1137 if (card[core->nr] < cx88_bcount)
1138 core->board = card[core->nr];
1139 for (i = 0; UNSET == core->board && i < cx88_idcount; i++)
1140 if (pci->subsystem_vendor == cx88_subids[i].subvendor &&
1141 pci->subsystem_device == cx88_subids[i].subdevice)
1142 core->board = cx88_subids[i].card;
1143 if (UNSET == core->board) {
1144 core->board = CX88_BOARD_UNKNOWN;
1145 cx88_card_list(core,pci);
1146 }
1147 printk(KERN_INFO "CORE %s: subsystem: %04x:%04x, board: %s [card=%d,%s]\n",
1148 core->name,pci->subsystem_vendor,
1149 pci->subsystem_device,cx88_boards[core->board].name,
1150 core->board, card[core->nr] == core->board ?
1151 "insmod option" : "autodetected");
1152
1153 core->tuner_type = tuner[core->nr];
1154 core->radio_type = radio[core->nr];
1155 if (UNSET == core->tuner_type)
1156 core->tuner_type = cx88_boards[core->board].tuner_type;
1157 if (UNSET == core->radio_type)
1158 core->radio_type = cx88_boards[core->board].radio_type;
1159 if (!core->tuner_addr)
1160 core->tuner_addr = cx88_boards[core->board].tuner_addr;
1161 if (!core->radio_addr)
1162 core->radio_addr = cx88_boards[core->board].radio_addr;
1163
1164 printk(KERN_INFO "TV tuner %d at 0x%02x, Radio tuner %d at 0x%02x\n",
1165 core->tuner_type, core->tuner_addr<<1,
1166 core->radio_type, core->radio_addr<<1);
1167
1168 core->tda9887_conf = cx88_boards[core->board].tda9887_conf;
1169
1170 /* init hardware */
1171 cx88_reset(core);
1172 cx88_card_setup_pre_i2c(core);
1173 cx88_i2c_init(core,pci);
1174 cx88_call_i2c_clients (core, TUNER_SET_STANDBY, NULL);
1175 cx88_card_setup(core);
1176 cx88_ir_init(core,pci);
1177
1178 mutex_unlock(&devlist);
1179 return core;
1180
1181 fail_free:
1182 kfree(core);
1183 fail_unlock:
1184 mutex_unlock(&devlist);
1185 return NULL;
1186 }
1187
1188 void cx88_core_put(struct cx88_core *core, struct pci_dev *pci)
1189 {
1190 release_mem_region(pci_resource_start(pci,0),
1191 pci_resource_len(pci,0));
1192
1193 if (!atomic_dec_and_test(&core->refcount))
1194 return;
1195
1196 mutex_lock(&devlist);
1197 cx88_ir_fini(core);
1198 if (0 == core->i2c_rc)
1199 i2c_del_adapter(&core->i2c_adap);
1200 list_del(&core->devlist);
1201 iounmap(core->lmmio);
1202 cx88_devcount--;
1203 mutex_unlock(&devlist);
1204 kfree(core);
1205 }
1206
1207 /* ------------------------------------------------------------------ */
1208
1209 EXPORT_SYMBOL(cx88_print_irqbits);
1210
1211 EXPORT_SYMBOL(cx88_core_irq);
1212 EXPORT_SYMBOL(cx88_wakeup);
1213 EXPORT_SYMBOL(cx88_reset);
1214 EXPORT_SYMBOL(cx88_shutdown);
1215
1216 EXPORT_SYMBOL(cx88_risc_buffer);
1217 EXPORT_SYMBOL(cx88_risc_databuffer);
1218 EXPORT_SYMBOL(cx88_risc_stopper);
1219 EXPORT_SYMBOL(cx88_free_buffer);
1220
1221 EXPORT_SYMBOL(cx88_sram_channels);
1222 EXPORT_SYMBOL(cx88_sram_channel_setup);
1223 EXPORT_SYMBOL(cx88_sram_channel_dump);
1224
1225 EXPORT_SYMBOL(cx88_set_tvnorm);
1226 EXPORT_SYMBOL(cx88_set_scale);
1227
1228 EXPORT_SYMBOL(cx88_vdev_init);
1229 EXPORT_SYMBOL(cx88_core_get);
1230 EXPORT_SYMBOL(cx88_core_put);
1231
1232 /*
1233 * Local variables:
1234 * c-basic-offset: 8
1235 * End:
1236 * kate: eol "unix"; indent-width 3; remove-trailing-space on; replace-trailing-space-save on; tab-width 8; replace-tabs off; space-indent off; mixed-indent off
1237 */
Linux kernel - Deliverables
This page took 0.05752 seconds and 5 git commands to generate.