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