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