1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
25
26#include <linux/i2c.h>
27#include <linux/slab.h>
28#include "cx25821.h"
29#include "cx25821-sram.h"
30#include "cx25821-video.h"
31
32MODULE_DESCRIPTION("Driver for Athena cards");
33MODULE_AUTHOR("Shu Lin - Hiep Huynh");
34MODULE_LICENSE("GPL");
35
36static unsigned int debug;
37module_param(debug, int, 0644);
38MODULE_PARM_DESC(debug, "enable debug messages");
39
40static unsigned int card[] = {[0 ... (CX25821_MAXBOARDS - 1)] = UNSET };
41module_param_array(card, int, NULL, 0444);
42MODULE_PARM_DESC(card, "card type");
43
44static unsigned int cx25821_devcount;
45
46DEFINE_MUTEX(cx25821_devlist_mutex);
47EXPORT_SYMBOL(cx25821_devlist_mutex);
48LIST_HEAD(cx25821_devlist);
49EXPORT_SYMBOL(cx25821_devlist);
50
51struct sram_channel cx25821_sram_channels[] = {
52 [SRAM_CH00] = {
53 .i = SRAM_CH00,
54 .name = "VID A",
55 .cmds_start = VID_A_DOWN_CMDS,
56 .ctrl_start = VID_A_IQ,
57 .cdt = VID_A_CDT,
58 .fifo_start = VID_A_DOWN_CLUSTER_1,
59 .fifo_size = (VID_CLUSTER_SIZE << 2),
60 .ptr1_reg = DMA1_PTR1,
61 .ptr2_reg = DMA1_PTR2,
62 .cnt1_reg = DMA1_CNT1,
63 .cnt2_reg = DMA1_CNT2,
64 .int_msk = VID_A_INT_MSK,
65 .int_stat = VID_A_INT_STAT,
66 .int_mstat = VID_A_INT_MSTAT,
67 .dma_ctl = VID_DST_A_DMA_CTL,
68 .gpcnt_ctl = VID_DST_A_GPCNT_CTL,
69 .gpcnt = VID_DST_A_GPCNT,
70 .vip_ctl = VID_DST_A_VIP_CTL,
71 .pix_frmt = VID_DST_A_PIX_FRMT,
72 },
73
74 [SRAM_CH01] = {
75 .i = SRAM_CH01,
76 .name = "VID B",
77 .cmds_start = VID_B_DOWN_CMDS,
78 .ctrl_start = VID_B_IQ,
79 .cdt = VID_B_CDT,
80 .fifo_start = VID_B_DOWN_CLUSTER_1,
81 .fifo_size = (VID_CLUSTER_SIZE << 2),
82 .ptr1_reg = DMA2_PTR1,
83 .ptr2_reg = DMA2_PTR2,
84 .cnt1_reg = DMA2_CNT1,
85 .cnt2_reg = DMA2_CNT2,
86 .int_msk = VID_B_INT_MSK,
87 .int_stat = VID_B_INT_STAT,
88 .int_mstat = VID_B_INT_MSTAT,
89 .dma_ctl = VID_DST_B_DMA_CTL,
90 .gpcnt_ctl = VID_DST_B_GPCNT_CTL,
91 .gpcnt = VID_DST_B_GPCNT,
92 .vip_ctl = VID_DST_B_VIP_CTL,
93 .pix_frmt = VID_DST_B_PIX_FRMT,
94 },
95
96 [SRAM_CH02] = {
97 .i = SRAM_CH02,
98 .name = "VID C",
99 .cmds_start = VID_C_DOWN_CMDS,
100 .ctrl_start = VID_C_IQ,
101 .cdt = VID_C_CDT,
102 .fifo_start = VID_C_DOWN_CLUSTER_1,
103 .fifo_size = (VID_CLUSTER_SIZE << 2),
104 .ptr1_reg = DMA3_PTR1,
105 .ptr2_reg = DMA3_PTR2,
106 .cnt1_reg = DMA3_CNT1,
107 .cnt2_reg = DMA3_CNT2,
108 .int_msk = VID_C_INT_MSK,
109 .int_stat = VID_C_INT_STAT,
110 .int_mstat = VID_C_INT_MSTAT,
111 .dma_ctl = VID_DST_C_DMA_CTL,
112 .gpcnt_ctl = VID_DST_C_GPCNT_CTL,
113 .gpcnt = VID_DST_C_GPCNT,
114 .vip_ctl = VID_DST_C_VIP_CTL,
115 .pix_frmt = VID_DST_C_PIX_FRMT,
116 },
117
118 [SRAM_CH03] = {
119 .i = SRAM_CH03,
120 .name = "VID D",
121 .cmds_start = VID_D_DOWN_CMDS,
122 .ctrl_start = VID_D_IQ,
123 .cdt = VID_D_CDT,
124 .fifo_start = VID_D_DOWN_CLUSTER_1,
125 .fifo_size = (VID_CLUSTER_SIZE << 2),
126 .ptr1_reg = DMA4_PTR1,
127 .ptr2_reg = DMA4_PTR2,
128 .cnt1_reg = DMA4_CNT1,
129 .cnt2_reg = DMA4_CNT2,
130 .int_msk = VID_D_INT_MSK,
131 .int_stat = VID_D_INT_STAT,
132 .int_mstat = VID_D_INT_MSTAT,
133 .dma_ctl = VID_DST_D_DMA_CTL,
134 .gpcnt_ctl = VID_DST_D_GPCNT_CTL,
135 .gpcnt = VID_DST_D_GPCNT,
136 .vip_ctl = VID_DST_D_VIP_CTL,
137 .pix_frmt = VID_DST_D_PIX_FRMT,
138 },
139
140 [SRAM_CH04] = {
141 .i = SRAM_CH04,
142 .name = "VID E",
143 .cmds_start = VID_E_DOWN_CMDS,
144 .ctrl_start = VID_E_IQ,
145 .cdt = VID_E_CDT,
146 .fifo_start = VID_E_DOWN_CLUSTER_1,
147 .fifo_size = (VID_CLUSTER_SIZE << 2),
148 .ptr1_reg = DMA5_PTR1,
149 .ptr2_reg = DMA5_PTR2,
150 .cnt1_reg = DMA5_CNT1,
151 .cnt2_reg = DMA5_CNT2,
152 .int_msk = VID_E_INT_MSK,
153 .int_stat = VID_E_INT_STAT,
154 .int_mstat = VID_E_INT_MSTAT,
155 .dma_ctl = VID_DST_E_DMA_CTL,
156 .gpcnt_ctl = VID_DST_E_GPCNT_CTL,
157 .gpcnt = VID_DST_E_GPCNT,
158 .vip_ctl = VID_DST_E_VIP_CTL,
159 .pix_frmt = VID_DST_E_PIX_FRMT,
160 },
161
162 [SRAM_CH05] = {
163 .i = SRAM_CH05,
164 .name = "VID F",
165 .cmds_start = VID_F_DOWN_CMDS,
166 .ctrl_start = VID_F_IQ,
167 .cdt = VID_F_CDT,
168 .fifo_start = VID_F_DOWN_CLUSTER_1,
169 .fifo_size = (VID_CLUSTER_SIZE << 2),
170 .ptr1_reg = DMA6_PTR1,
171 .ptr2_reg = DMA6_PTR2,
172 .cnt1_reg = DMA6_CNT1,
173 .cnt2_reg = DMA6_CNT2,
174 .int_msk = VID_F_INT_MSK,
175 .int_stat = VID_F_INT_STAT,
176 .int_mstat = VID_F_INT_MSTAT,
177 .dma_ctl = VID_DST_F_DMA_CTL,
178 .gpcnt_ctl = VID_DST_F_GPCNT_CTL,
179 .gpcnt = VID_DST_F_GPCNT,
180 .vip_ctl = VID_DST_F_VIP_CTL,
181 .pix_frmt = VID_DST_F_PIX_FRMT,
182 },
183
184 [SRAM_CH06] = {
185 .i = SRAM_CH06,
186 .name = "VID G",
187 .cmds_start = VID_G_DOWN_CMDS,
188 .ctrl_start = VID_G_IQ,
189 .cdt = VID_G_CDT,
190 .fifo_start = VID_G_DOWN_CLUSTER_1,
191 .fifo_size = (VID_CLUSTER_SIZE << 2),
192 .ptr1_reg = DMA7_PTR1,
193 .ptr2_reg = DMA7_PTR2,
194 .cnt1_reg = DMA7_CNT1,
195 .cnt2_reg = DMA7_CNT2,
196 .int_msk = VID_G_INT_MSK,
197 .int_stat = VID_G_INT_STAT,
198 .int_mstat = VID_G_INT_MSTAT,
199 .dma_ctl = VID_DST_G_DMA_CTL,
200 .gpcnt_ctl = VID_DST_G_GPCNT_CTL,
201 .gpcnt = VID_DST_G_GPCNT,
202 .vip_ctl = VID_DST_G_VIP_CTL,
203 .pix_frmt = VID_DST_G_PIX_FRMT,
204 },
205
206 [SRAM_CH07] = {
207 .i = SRAM_CH07,
208 .name = "VID H",
209 .cmds_start = VID_H_DOWN_CMDS,
210 .ctrl_start = VID_H_IQ,
211 .cdt = VID_H_CDT,
212 .fifo_start = VID_H_DOWN_CLUSTER_1,
213 .fifo_size = (VID_CLUSTER_SIZE << 2),
214 .ptr1_reg = DMA8_PTR1,
215 .ptr2_reg = DMA8_PTR2,
216 .cnt1_reg = DMA8_CNT1,
217 .cnt2_reg = DMA8_CNT2,
218 .int_msk = VID_H_INT_MSK,
219 .int_stat = VID_H_INT_STAT,
220 .int_mstat = VID_H_INT_MSTAT,
221 .dma_ctl = VID_DST_H_DMA_CTL,
222 .gpcnt_ctl = VID_DST_H_GPCNT_CTL,
223 .gpcnt = VID_DST_H_GPCNT,
224 .vip_ctl = VID_DST_H_VIP_CTL,
225 .pix_frmt = VID_DST_H_PIX_FRMT,
226 },
227
228 [SRAM_CH08] = {
229 .name = "audio from",
230 .cmds_start = AUD_A_DOWN_CMDS,
231 .ctrl_start = AUD_A_IQ,
232 .cdt = AUD_A_CDT,
233 .fifo_start = AUD_A_DOWN_CLUSTER_1,
234 .fifo_size = AUDIO_CLUSTER_SIZE * 3,
235 .ptr1_reg = DMA17_PTR1,
236 .ptr2_reg = DMA17_PTR2,
237 .cnt1_reg = DMA17_CNT1,
238 .cnt2_reg = DMA17_CNT2,
239 },
240
241 [SRAM_CH09] = {
242 .i = SRAM_CH09,
243 .name = "VID Upstream I",
244 .cmds_start = VID_I_UP_CMDS,
245 .ctrl_start = VID_I_IQ,
246 .cdt = VID_I_CDT,
247 .fifo_start = VID_I_UP_CLUSTER_1,
248 .fifo_size = (VID_CLUSTER_SIZE << 2),
249 .ptr1_reg = DMA15_PTR1,
250 .ptr2_reg = DMA15_PTR2,
251 .cnt1_reg = DMA15_CNT1,
252 .cnt2_reg = DMA15_CNT2,
253 .int_msk = VID_I_INT_MSK,
254 .int_stat = VID_I_INT_STAT,
255 .int_mstat = VID_I_INT_MSTAT,
256 .dma_ctl = VID_SRC_I_DMA_CTL,
257 .gpcnt_ctl = VID_SRC_I_GPCNT_CTL,
258 .gpcnt = VID_SRC_I_GPCNT,
259
260 .vid_fmt_ctl = VID_SRC_I_FMT_CTL,
261 .vid_active_ctl1 = VID_SRC_I_ACTIVE_CTL1,
262 .vid_active_ctl2 = VID_SRC_I_ACTIVE_CTL2,
263 .vid_cdt_size = VID_SRC_I_CDT_SZ,
264 .irq_bit = 8,
265 },
266
267 [SRAM_CH10] = {
268 .i = SRAM_CH10,
269 .name = "VID Upstream J",
270 .cmds_start = VID_J_UP_CMDS,
271 .ctrl_start = VID_J_IQ,
272 .cdt = VID_J_CDT,
273 .fifo_start = VID_J_UP_CLUSTER_1,
274 .fifo_size = (VID_CLUSTER_SIZE << 2),
275 .ptr1_reg = DMA16_PTR1,
276 .ptr2_reg = DMA16_PTR2,
277 .cnt1_reg = DMA16_CNT1,
278 .cnt2_reg = DMA16_CNT2,
279 .int_msk = VID_J_INT_MSK,
280 .int_stat = VID_J_INT_STAT,
281 .int_mstat = VID_J_INT_MSTAT,
282 .dma_ctl = VID_SRC_J_DMA_CTL,
283 .gpcnt_ctl = VID_SRC_J_GPCNT_CTL,
284 .gpcnt = VID_SRC_J_GPCNT,
285
286 .vid_fmt_ctl = VID_SRC_J_FMT_CTL,
287 .vid_active_ctl1 = VID_SRC_J_ACTIVE_CTL1,
288 .vid_active_ctl2 = VID_SRC_J_ACTIVE_CTL2,
289 .vid_cdt_size = VID_SRC_J_CDT_SZ,
290 .irq_bit = 9,
291 },
292
293 [SRAM_CH11] = {
294 .i = SRAM_CH11,
295 .name = "Audio Upstream Channel B",
296 .cmds_start = AUD_B_UP_CMDS,
297 .ctrl_start = AUD_B_IQ,
298 .cdt = AUD_B_CDT,
299 .fifo_start = AUD_B_UP_CLUSTER_1,
300 .fifo_size = (AUDIO_CLUSTER_SIZE * 3),
301 .ptr1_reg = DMA22_PTR1,
302 .ptr2_reg = DMA22_PTR2,
303 .cnt1_reg = DMA22_CNT1,
304 .cnt2_reg = DMA22_CNT2,
305 .int_msk = AUD_B_INT_MSK,
306 .int_stat = AUD_B_INT_STAT,
307 .int_mstat = AUD_B_INT_MSTAT,
308 .dma_ctl = AUD_INT_DMA_CTL,
309 .gpcnt_ctl = AUD_B_GPCNT_CTL,
310 .gpcnt = AUD_B_GPCNT,
311 .aud_length = AUD_B_LNGTH,
312 .aud_cfg = AUD_B_CFG,
313 .fld_aud_fifo_en = FLD_AUD_SRC_B_FIFO_EN,
314 .fld_aud_risc_en = FLD_AUD_SRC_B_RISC_EN,
315 .irq_bit = 11,
316 },
317};
318EXPORT_SYMBOL(cx25821_sram_channels);
319
320struct sram_channel *channel0 = &cx25821_sram_channels[SRAM_CH00];
321struct sram_channel *channel1 = &cx25821_sram_channels[SRAM_CH01];
322struct sram_channel *channel2 = &cx25821_sram_channels[SRAM_CH02];
323struct sram_channel *channel3 = &cx25821_sram_channels[SRAM_CH03];
324struct sram_channel *channel4 = &cx25821_sram_channels[SRAM_CH04];
325struct sram_channel *channel5 = &cx25821_sram_channels[SRAM_CH05];
326struct sram_channel *channel6 = &cx25821_sram_channels[SRAM_CH06];
327struct sram_channel *channel7 = &cx25821_sram_channels[SRAM_CH07];
328struct sram_channel *channel9 = &cx25821_sram_channels[SRAM_CH09];
329struct sram_channel *channel10 = &cx25821_sram_channels[SRAM_CH10];
330struct sram_channel *channel11 = &cx25821_sram_channels[SRAM_CH11];
331
332struct cx25821_dmaqueue mpegq;
333
334static int cx25821_risc_decode(u32 risc)
335{
336 static const char * const instr[16] = {
337 [RISC_SYNC >> 28] = "sync",
338 [RISC_WRITE >> 28] = "write",
339 [RISC_WRITEC >> 28] = "writec",
340 [RISC_READ >> 28] = "read",
341 [RISC_READC >> 28] = "readc",
342 [RISC_JUMP >> 28] = "jump",
343 [RISC_SKIP >> 28] = "skip",
344 [RISC_WRITERM >> 28] = "writerm",
345 [RISC_WRITECM >> 28] = "writecm",
346 [RISC_WRITECR >> 28] = "writecr",
347 };
348 static const int incr[16] = {
349 [RISC_WRITE >> 28] = 3,
350 [RISC_JUMP >> 28] = 3,
351 [RISC_SKIP >> 28] = 1,
352 [RISC_SYNC >> 28] = 1,
353 [RISC_WRITERM >> 28] = 3,
354 [RISC_WRITECM >> 28] = 3,
355 [RISC_WRITECR >> 28] = 4,
356 };
357 static const char * const bits[] = {
358 "12", "13", "14", "resync",
359 "cnt0", "cnt1", "18", "19",
360 "20", "21", "22", "23",
361 "irq1", "irq2", "eol", "sol",
362 };
363 int i;
364
365 pr_cont("0x%08x [ %s",
366 risc, instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
367 for (i = ARRAY_SIZE(bits) - 1; i >= 0; i--) {
368 if (risc & (1 << (i + 12)))
369 pr_cont(" %s", bits[i]);
370 }
371 pr_cont(" count=%d ]\n", risc & 0xfff);
372 return incr[risc >> 28] ? incr[risc >> 28] : 1;
373}
374
375static inline int i2c_slave_did_ack(struct i2c_adapter *i2c_adap)
376{
377 struct cx25821_i2c *bus = i2c_adap->algo_data;
378 struct cx25821_dev *dev = bus->dev;
379 return cx_read(bus->reg_stat) & 0x01;
380}
381
382void cx_i2c_read_print(struct cx25821_dev *dev, u32 reg, const char *reg_string)
383{
384 int tmp = 0;
385 u32 value = 0;
386
387 value = cx25821_i2c_read(&dev->i2c_bus[0], reg, &tmp);
388}
389
390static void cx25821_registers_init(struct cx25821_dev *dev)
391{
392 u32 tmp;
393
394
395 cx_write(DEV_CNTRL2, 0x20);
396
397
398
399
400 cx_write(PCI_INT_MSK, 0x2001FFFF);
401
402 tmp = cx_read(RDR_TLCTL0);
403 tmp &= ~FLD_CFG_RCB_CK_EN;
404 cx_write(RDR_TLCTL0, tmp);
405
406
407 cx_write(PLL_A_INT_FRAC, 0x9807A58B);
408
409
410 cx_write(PLL_A_POST_STAT_BIST, 0x8000019C);
411
412
413 tmp = cx_read(PLL_A_INT_FRAC);
414 cx_write(PLL_A_INT_FRAC, tmp & 0x7FFFFFFF);
415
416
417 cx_write(PLL_B_INT_FRAC, 0x9883A86F);
418
419
420 cx_write(PLL_B_POST_STAT_BIST, 0x8000018D);
421
422
423 tmp = cx_read(PLL_B_INT_FRAC);
424 cx_write(PLL_B_INT_FRAC, tmp & 0x7FFFFFFF);
425
426
427 cx_write(PLL_C_INT_FRAC, 0x96A0EA3F);
428
429
430 cx_write(PLL_C_POST_STAT_BIST, 0x80000103);
431
432
433 tmp = cx_read(PLL_C_INT_FRAC);
434 cx_write(PLL_C_INT_FRAC, tmp & 0x7FFFFFFF);
435
436
437 cx_write(PLL_D_INT_FRAC, 0x98757F5B);
438
439
440 cx_write(PLL_D_POST_STAT_BIST, 0x80000113);
441
442
443 tmp = cx_read(PLL_D_INT_FRAC);
444 cx_write(PLL_D_INT_FRAC, tmp & 0x7FFFFFFF);
445
446
447
448 tmp = cx_read(VID_CH_CLK_SEL);
449 cx_write(VID_CH_CLK_SEL, (tmp & 0x00FFFFFF) | 0x24000000);
450
451
452
453
454 tmp = cx_read(VID_CH_MODE_SEL);
455
456 cx_write(VID_CH_MODE_SEL, tmp & 0xFFFFFE00);
457
458
459 tmp = cx_read(CLK_RST);
460
461 tmp |= FLD_USE_ALT_PLL_REF;
462 cx_write(CLK_RST, tmp & ~(FLD_VID_I_CLK_NOE | FLD_VID_J_CLK_NOE));
463
464 mdelay(100);
465}
466
467int cx25821_sram_channel_setup(struct cx25821_dev *dev,
468 struct sram_channel *ch,
469 unsigned int bpl, u32 risc)
470{
471 unsigned int i, lines;
472 u32 cdt;
473
474 if (ch->cmds_start == 0) {
475 cx_write(ch->ptr1_reg, 0);
476 cx_write(ch->ptr2_reg, 0);
477 cx_write(ch->cnt2_reg, 0);
478 cx_write(ch->cnt1_reg, 0);
479 return 0;
480 }
481
482 bpl = (bpl + 7) & ~7;
483 cdt = ch->cdt;
484 lines = ch->fifo_size / bpl;
485
486 if (lines > 4)
487 lines = 4;
488
489 BUG_ON(lines < 2);
490
491 cx_write(8 + 0, RISC_JUMP | RISC_IRQ1 | RISC_CNT_INC);
492 cx_write(8 + 4, 8);
493 cx_write(8 + 8, 0);
494
495
496 for (i = 0; i < lines; i++) {
497 cx_write(cdt + 16 * i, ch->fifo_start + bpl * i);
498 cx_write(cdt + 16 * i + 4, 0);
499 cx_write(cdt + 16 * i + 8, 0);
500 cx_write(cdt + 16 * i + 12, 0);
501 }
502
503
504 for (i = 0; i < 128; i++)
505 cx_write(ch->fifo_start + 4 * i, i);
506
507
508 if (ch->jumponly)
509 cx_write(ch->cmds_start + 0, 8);
510 else
511 cx_write(ch->cmds_start + 0, risc);
512
513 cx_write(ch->cmds_start + 4, 0);
514 cx_write(ch->cmds_start + 8, cdt);
515 cx_write(ch->cmds_start + 12, (lines * 16) >> 3);
516 cx_write(ch->cmds_start + 16, ch->ctrl_start);
517
518 if (ch->jumponly)
519 cx_write(ch->cmds_start + 20, 0x80000000 | (64 >> 2));
520 else
521 cx_write(ch->cmds_start + 20, 64 >> 2);
522
523 for (i = 24; i < 80; i += 4)
524 cx_write(ch->cmds_start + i, 0);
525
526
527 cx_write(ch->ptr1_reg, ch->fifo_start);
528 cx_write(ch->ptr2_reg, cdt);
529 cx_write(ch->cnt2_reg, (lines * 16) >> 3);
530 cx_write(ch->cnt1_reg, (bpl >> 3) - 1);
531
532 return 0;
533}
534EXPORT_SYMBOL(cx25821_sram_channel_setup);
535
536int cx25821_sram_channel_setup_audio(struct cx25821_dev *dev,
537 struct sram_channel *ch,
538 unsigned int bpl, u32 risc)
539{
540 unsigned int i, lines;
541 u32 cdt;
542
543 if (ch->cmds_start == 0) {
544 cx_write(ch->ptr1_reg, 0);
545 cx_write(ch->ptr2_reg, 0);
546 cx_write(ch->cnt2_reg, 0);
547 cx_write(ch->cnt1_reg, 0);
548 return 0;
549 }
550
551 bpl = (bpl + 7) & ~7;
552 cdt = ch->cdt;
553 lines = ch->fifo_size / bpl;
554
555 if (lines > 3)
556 lines = 3;
557
558 BUG_ON(lines < 2);
559
560 cx_write(8 + 0, RISC_JUMP | RISC_IRQ1 | RISC_CNT_INC);
561 cx_write(8 + 4, 8);
562 cx_write(8 + 8, 0);
563
564
565 for (i = 0; i < lines; i++) {
566 cx_write(cdt + 16 * i, ch->fifo_start + bpl * i);
567 cx_write(cdt + 16 * i + 4, 0);
568 cx_write(cdt + 16 * i + 8, 0);
569 cx_write(cdt + 16 * i + 12, 0);
570 }
571
572
573 if (ch->jumponly)
574 cx_write(ch->cmds_start + 0, 8);
575 else
576 cx_write(ch->cmds_start + 0, risc);
577
578 cx_write(ch->cmds_start + 4, 0);
579 cx_write(ch->cmds_start + 8, cdt);
580 cx_write(ch->cmds_start + 12, (lines * 16) >> 3);
581 cx_write(ch->cmds_start + 16, ch->ctrl_start);
582
583
584 if (ch->jumponly)
585 cx_write(ch->cmds_start + 20, 0x80000000 | (64 >> 2));
586 else
587 cx_write(ch->cmds_start + 20, 64 >> 2);
588
589
590 for (i = 24; i < 80; i += 4)
591 cx_write(ch->cmds_start + i, 0);
592
593
594 cx_write(ch->ptr1_reg, ch->fifo_start);
595 cx_write(ch->ptr2_reg, cdt);
596 cx_write(ch->cnt2_reg, (lines * 16) >> 3);
597 cx_write(ch->cnt1_reg, (bpl >> 3) - 1);
598
599 return 0;
600}
601EXPORT_SYMBOL(cx25821_sram_channel_setup_audio);
602
603void cx25821_sram_channel_dump(struct cx25821_dev *dev, struct sram_channel *ch)
604{
605 static char *name[] = {
606 "init risc lo",
607 "init risc hi",
608 "cdt base",
609 "cdt size",
610 "iq base",
611 "iq size",
612 "risc pc lo",
613 "risc pc hi",
614 "iq wr ptr",
615 "iq rd ptr",
616 "cdt current",
617 "pci target lo",
618 "pci target hi",
619 "line / byte",
620 };
621 u32 risc;
622 unsigned int i, j, n;
623
624 pr_warn("%s: %s - dma channel status dump\n", dev->name, ch->name);
625 for (i = 0; i < ARRAY_SIZE(name); i++)
626 pr_warn("cmds + 0x%2x: %-15s: 0x%08x\n",
627 i * 4, name[i], cx_read(ch->cmds_start + 4 * i));
628
629 j = i * 4;
630 for (i = 0; i < 4;) {
631 risc = cx_read(ch->cmds_start + 4 * (i + 14));
632 pr_warn("cmds + 0x%2x: risc%d: ", j + i * 4, i);
633 i += cx25821_risc_decode(risc);
634 }
635
636 for (i = 0; i < (64 >> 2); i += n) {
637 risc = cx_read(ch->ctrl_start + 4 * i);
638
639
640 pr_warn("ctrl + 0x%2x (0x%08x): iq %x: ",
641 i * 4, ch->ctrl_start + 4 * i, i);
642 n = cx25821_risc_decode(risc);
643 for (j = 1; j < n; j++) {
644 risc = cx_read(ch->ctrl_start + 4 * (i + j));
645 pr_warn("ctrl + 0x%2x : iq %x: 0x%08x [ arg #%d ]\n",
646 4 * (i + j), i + j, risc, j);
647 }
648 }
649
650 pr_warn(" : fifo: 0x%08x -> 0x%x\n",
651 ch->fifo_start, ch->fifo_start + ch->fifo_size);
652 pr_warn(" : ctrl: 0x%08x -> 0x%x\n",
653 ch->ctrl_start, ch->ctrl_start + 6 * 16);
654 pr_warn(" : ptr1_reg: 0x%08x\n",
655 cx_read(ch->ptr1_reg));
656 pr_warn(" : ptr2_reg: 0x%08x\n",
657 cx_read(ch->ptr2_reg));
658 pr_warn(" : cnt1_reg: 0x%08x\n",
659 cx_read(ch->cnt1_reg));
660 pr_warn(" : cnt2_reg: 0x%08x\n",
661 cx_read(ch->cnt2_reg));
662}
663EXPORT_SYMBOL(cx25821_sram_channel_dump);
664
665void cx25821_sram_channel_dump_audio(struct cx25821_dev *dev,
666 struct sram_channel *ch)
667{
668 static const char * const name[] = {
669 "init risc lo",
670 "init risc hi",
671 "cdt base",
672 "cdt size",
673 "iq base",
674 "iq size",
675 "risc pc lo",
676 "risc pc hi",
677 "iq wr ptr",
678 "iq rd ptr",
679 "cdt current",
680 "pci target lo",
681 "pci target hi",
682 "line / byte",
683 };
684
685 u32 risc, value, tmp;
686 unsigned int i, j, n;
687
688 pr_info("\n%s: %s - dma Audio channel status dump\n",
689 dev->name, ch->name);
690
691 for (i = 0; i < ARRAY_SIZE(name); i++)
692 pr_info("%s: cmds + 0x%2x: %-15s: 0x%08x\n",
693 dev->name, i * 4, name[i],
694 cx_read(ch->cmds_start + 4 * i));
695
696 j = i * 4;
697 for (i = 0; i < 4;) {
698 risc = cx_read(ch->cmds_start + 4 * (i + 14));
699 pr_warn("cmds + 0x%2x: risc%d: ", j + i * 4, i);
700 i += cx25821_risc_decode(risc);
701 }
702
703 for (i = 0; i < (64 >> 2); i += n) {
704 risc = cx_read(ch->ctrl_start + 4 * i);
705
706
707 pr_warn("ctrl + 0x%2x (0x%08x): iq %x: ",
708 i * 4, ch->ctrl_start + 4 * i, i);
709 n = cx25821_risc_decode(risc);
710
711 for (j = 1; j < n; j++) {
712 risc = cx_read(ch->ctrl_start + 4 * (i + j));
713 pr_warn("ctrl + 0x%2x : iq %x: 0x%08x [ arg #%d ]\n",
714 4 * (i + j), i + j, risc, j);
715 }
716 }
717
718 pr_warn(" : fifo: 0x%08x -> 0x%x\n",
719 ch->fifo_start, ch->fifo_start + ch->fifo_size);
720 pr_warn(" : ctrl: 0x%08x -> 0x%x\n",
721 ch->ctrl_start, ch->ctrl_start + 6 * 16);
722 pr_warn(" : ptr1_reg: 0x%08x\n",
723 cx_read(ch->ptr1_reg));
724 pr_warn(" : ptr2_reg: 0x%08x\n",
725 cx_read(ch->ptr2_reg));
726 pr_warn(" : cnt1_reg: 0x%08x\n",
727 cx_read(ch->cnt1_reg));
728 pr_warn(" : cnt2_reg: 0x%08x\n",
729 cx_read(ch->cnt2_reg));
730
731 for (i = 0; i < 4; i++) {
732 risc = cx_read(ch->cmds_start + 56 + (i * 4));
733 pr_warn("instruction %d = 0x%x\n", i, risc);
734 }
735
736
737 risc = cx_read(AUD_A_CDT);
738 pr_warn("\nread cdt loc=0x%x\n", risc);
739 for (i = 0; i < 8; i++) {
740 n = cx_read(risc + i * 4);
741 pr_cont("0x%x ", n);
742 }
743 pr_cont("\n\n");
744
745 value = cx_read(CLK_RST);
746 CX25821_INFO(" CLK_RST = 0x%x\n\n", value);
747
748 value = cx_read(PLL_A_POST_STAT_BIST);
749 CX25821_INFO(" PLL_A_POST_STAT_BIST = 0x%x\n\n", value);
750 value = cx_read(PLL_A_INT_FRAC);
751 CX25821_INFO(" PLL_A_INT_FRAC = 0x%x\n\n", value);
752
753 value = cx_read(PLL_B_POST_STAT_BIST);
754 CX25821_INFO(" PLL_B_POST_STAT_BIST = 0x%x\n\n", value);
755 value = cx_read(PLL_B_INT_FRAC);
756 CX25821_INFO(" PLL_B_INT_FRAC = 0x%x\n\n", value);
757
758 value = cx_read(PLL_C_POST_STAT_BIST);
759 CX25821_INFO(" PLL_C_POST_STAT_BIST = 0x%x\n\n", value);
760 value = cx_read(PLL_C_INT_FRAC);
761 CX25821_INFO(" PLL_C_INT_FRAC = 0x%x\n\n", value);
762
763 value = cx_read(PLL_D_POST_STAT_BIST);
764 CX25821_INFO(" PLL_D_POST_STAT_BIST = 0x%x\n\n", value);
765 value = cx_read(PLL_D_INT_FRAC);
766 CX25821_INFO(" PLL_D_INT_FRAC = 0x%x\n\n", value);
767
768 value = cx25821_i2c_read(&dev->i2c_bus[0], AFE_AB_DIAG_CTRL, &tmp);
769 CX25821_INFO(" AFE_AB_DIAG_CTRL (0x10900090) = 0x%x\n\n", value);
770}
771EXPORT_SYMBOL(cx25821_sram_channel_dump_audio);
772
773static void cx25821_shutdown(struct cx25821_dev *dev)
774{
775 int i;
776
777
778 cx_write(DEV_CNTRL2, 0);
779
780
781 for (i = 0; i < VID_CHANNEL_NUM; i++) {
782 cx_write(dev->channels[i].sram_channels->dma_ctl, 0);
783 cx_write(dev->channels[i].sram_channels->int_msk, 0);
784 }
785
786 for (i = VID_UPSTREAM_SRAM_CHANNEL_I;
787 i <= VID_UPSTREAM_SRAM_CHANNEL_J; i++) {
788 cx_write(dev->channels[i].sram_channels->dma_ctl, 0);
789 cx_write(dev->channels[i].sram_channels->int_msk, 0);
790 }
791
792
793 cx_write(AUD_INT_DMA_CTL, 0);
794
795
796 cx_write(UART_CTL, 0);
797
798
799 cx_write(PCI_INT_MSK, 0);
800 cx_write(AUD_A_INT_MSK, 0);
801}
802
803void cx25821_set_pixel_format(struct cx25821_dev *dev, int channel_select,
804 u32 format)
805{
806 if (channel_select <= 7 && channel_select >= 0) {
807 cx_write(dev->channels[channel_select].sram_channels->pix_frmt,
808 format);
809 dev->channels[channel_select].pixel_formats = format;
810 }
811}
812
813static void cx25821_set_vip_mode(struct cx25821_dev *dev,
814 struct sram_channel *ch)
815{
816 cx_write(ch->pix_frmt, PIXEL_FRMT_422);
817 cx_write(ch->vip_ctl, PIXEL_ENGINE_VIP1);
818}
819
820static void cx25821_initialize(struct cx25821_dev *dev)
821{
822 int i;
823
824 dprintk(1, "%s()\n", __func__);
825
826 cx25821_shutdown(dev);
827 cx_write(PCI_INT_STAT, 0xffffffff);
828
829 for (i = 0; i < VID_CHANNEL_NUM; i++)
830 cx_write(dev->channels[i].sram_channels->int_stat, 0xffffffff);
831
832 cx_write(AUD_A_INT_STAT, 0xffffffff);
833 cx_write(AUD_B_INT_STAT, 0xffffffff);
834 cx_write(AUD_C_INT_STAT, 0xffffffff);
835 cx_write(AUD_D_INT_STAT, 0xffffffff);
836 cx_write(AUD_E_INT_STAT, 0xffffffff);
837
838 cx_write(CLK_DELAY, cx_read(CLK_DELAY) & 0x80000000);
839 cx_write(PAD_CTRL, 0x12);
840 cx25821_registers_init(dev);
841 mdelay(100);
842
843 for (i = 0; i < VID_CHANNEL_NUM; i++) {
844 cx25821_set_vip_mode(dev, dev->channels[i].sram_channels);
845 cx25821_sram_channel_setup(dev, dev->channels[i].sram_channels,
846 1440, 0);
847 dev->channels[i].pixel_formats = PIXEL_FRMT_422;
848 dev->channels[i].use_cif_resolution = FALSE;
849 }
850
851
852 for (i = VID_UPSTREAM_SRAM_CHANNEL_I;
853 i <= VID_UPSTREAM_SRAM_CHANNEL_J; i++) {
854 cx25821_set_vip_mode(dev, dev->channels[i].sram_channels);
855 }
856
857 cx25821_sram_channel_setup_audio(dev,
858 dev->channels[SRAM_CH08].sram_channels, 128, 0);
859
860 cx25821_gpio_init(dev);
861}
862
863static int cx25821_get_resources(struct cx25821_dev *dev)
864{
865 if (request_mem_region(pci_resource_start(dev->pci, 0),
866 pci_resource_len(dev->pci, 0), dev->name))
867 return 0;
868
869 pr_err("%s: can't get MMIO memory @ 0x%llx\n",
870 dev->name, (unsigned long long)pci_resource_start(dev->pci, 0));
871
872 return -EBUSY;
873}
874
875static void cx25821_dev_checkrevision(struct cx25821_dev *dev)
876{
877 dev->hwrevision = cx_read(RDR_CFG2) & 0xff;
878
879 pr_info("%s(): Hardware revision = 0x%02x\n",
880 __func__, dev->hwrevision);
881}
882
883static void cx25821_iounmap(struct cx25821_dev *dev)
884{
885 if (dev == NULL)
886 return;
887
888
889 if (dev->lmmio != NULL) {
890 CX25821_INFO("Releasing lmmio.\n");
891 iounmap(dev->lmmio);
892 dev->lmmio = NULL;
893 }
894}
895
896static int cx25821_dev_setup(struct cx25821_dev *dev)
897{
898 int io_size = 0, i;
899
900 pr_info("\n***********************************\n");
901 pr_info("cx25821 set up\n");
902 pr_info("***********************************\n\n");
903
904 mutex_init(&dev->lock);
905
906 atomic_inc(&dev->refcount);
907
908 dev->nr = ++cx25821_devcount;
909 sprintf(dev->name, "cx25821[%d]", dev->nr);
910
911 mutex_lock(&cx25821_devlist_mutex);
912 list_add_tail(&dev->devlist, &cx25821_devlist);
913 mutex_unlock(&cx25821_devlist_mutex);
914
915 strcpy(cx25821_boards[UNKNOWN_BOARD].name, "unknown");
916 strcpy(cx25821_boards[CX25821_BOARD].name, "cx25821");
917
918 if (dev->pci->device != 0x8210) {
919 pr_info("%s(): Exiting. Incorrect Hardware device = 0x%02x\n",
920 __func__, dev->pci->device);
921 return -1;
922 } else {
923 pr_info("Athena Hardware device = 0x%02x\n", dev->pci->device);
924 }
925
926
927 dev->clk_freq = 28000000;
928 for (i = 0; i < MAX_VID_CHANNEL_NUM; i++)
929 dev->channels[i].sram_channels = &cx25821_sram_channels[i];
930
931 if (dev->nr > 1)
932 CX25821_INFO("dev->nr > 1!");
933
934
935 dev->board = 1;
936 dev->_max_num_decoders = MAX_DECODERS;
937
938 dev->pci_bus = dev->pci->bus->number;
939 dev->pci_slot = PCI_SLOT(dev->pci->devfn);
940 dev->pci_irqmask = 0x001f00;
941
942
943 dev->i2c_bus[0].nr = 0;
944 dev->i2c_bus[0].dev = dev;
945 dev->i2c_bus[0].reg_stat = I2C1_STAT;
946 dev->i2c_bus[0].reg_ctrl = I2C1_CTRL;
947 dev->i2c_bus[0].reg_addr = I2C1_ADDR;
948 dev->i2c_bus[0].reg_rdata = I2C1_RDATA;
949 dev->i2c_bus[0].reg_wdata = I2C1_WDATA;
950 dev->i2c_bus[0].i2c_period = (0x07 << 24);
951
952 if (cx25821_get_resources(dev) < 0) {
953 pr_err("%s: No more PCIe resources for subsystem: %04x:%04x\n",
954 dev->name, dev->pci->subsystem_vendor,
955 dev->pci->subsystem_device);
956
957 cx25821_devcount--;
958 return -EBUSY;
959 }
960
961
962 dev->base_io_addr = pci_resource_start(dev->pci, 0);
963 io_size = pci_resource_len(dev->pci, 0);
964
965 if (!dev->base_io_addr) {
966 CX25821_ERR("No PCI Memory resources, exiting!\n");
967 return -ENODEV;
968 }
969
970 dev->lmmio = ioremap(dev->base_io_addr, pci_resource_len(dev->pci, 0));
971
972 if (!dev->lmmio) {
973 CX25821_ERR("ioremap failed, maybe increasing __VMALLOC_RESERVE in page.h\n");
974 cx25821_iounmap(dev);
975 return -ENOMEM;
976 }
977
978 dev->bmmio = (u8 __iomem *) dev->lmmio;
979
980 pr_info("%s: subsystem: %04x:%04x, board: %s [card=%d,%s]\n",
981 dev->name, dev->pci->subsystem_vendor,
982 dev->pci->subsystem_device, cx25821_boards[dev->board].name,
983 dev->board, card[dev->nr] == dev->board ?
984 "insmod option" : "autodetected");
985
986
987 cx25821_initialize(dev);
988
989 cx25821_i2c_register(&dev->i2c_bus[0]);
990
991
992
993 CX25821_INFO("i2c register! bus->i2c_rc = %d\n",
994 dev->i2c_bus[0].i2c_rc);
995
996 cx25821_card_setup(dev);
997
998 if (medusa_video_init(dev) < 0)
999 CX25821_ERR("%s(): Failed to initialize medusa!\n", __func__);
1000
1001 cx25821_video_register(dev);
1002
1003
1004 dev->ioctl_dev = cx25821_vdev_init(dev, dev->pci,
1005 &cx25821_videoioctl_template, "video");
1006
1007 if (video_register_device
1008 (dev->ioctl_dev, VFL_TYPE_GRABBER, VIDEO_IOCTL_CH) < 0) {
1009 cx25821_videoioctl_unregister(dev);
1010 pr_err("%s(): Failed to register video adapter for IOCTL, so unregistering videoioctl device\n",
1011 __func__);
1012 }
1013
1014 cx25821_dev_checkrevision(dev);
1015 CX25821_INFO("setup done!\n");
1016
1017 return 0;
1018}
1019
1020void cx25821_start_upstream_video_ch1(struct cx25821_dev *dev,
1021 struct upstream_user_struct *up_data)
1022{
1023 dev->_isNTSC = !strcmp(dev->vid_stdname, "NTSC") ? 1 : 0;
1024
1025 dev->tvnorm = !dev->_isNTSC ? V4L2_STD_PAL_BG : V4L2_STD_NTSC_M;
1026 medusa_set_videostandard(dev);
1027
1028 cx25821_vidupstream_init_ch1(dev, dev->channel_select,
1029 dev->pixel_format);
1030}
1031
1032void cx25821_start_upstream_video_ch2(struct cx25821_dev *dev,
1033 struct upstream_user_struct *up_data)
1034{
1035 dev->_isNTSC_ch2 = !strcmp(dev->vid_stdname_ch2, "NTSC") ? 1 : 0;
1036
1037 dev->tvnorm = !dev->_isNTSC_ch2 ? V4L2_STD_PAL_BG : V4L2_STD_NTSC_M;
1038 medusa_set_videostandard(dev);
1039
1040 cx25821_vidupstream_init_ch2(dev, dev->channel_select_ch2,
1041 dev->pixel_format_ch2);
1042}
1043
1044void cx25821_start_upstream_audio(struct cx25821_dev *dev,
1045 struct upstream_user_struct *up_data)
1046{
1047 cx25821_audio_upstream_init(dev, AUDIO_UPSTREAM_SRAM_CHANNEL_B);
1048}
1049
1050void cx25821_dev_unregister(struct cx25821_dev *dev)
1051{
1052 int i;
1053
1054 if (!dev->base_io_addr)
1055 return;
1056
1057 cx25821_free_mem_upstream_ch1(dev);
1058 cx25821_free_mem_upstream_ch2(dev);
1059 cx25821_free_mem_upstream_audio(dev);
1060
1061 release_mem_region(dev->base_io_addr, pci_resource_len(dev->pci, 0));
1062
1063 if (!atomic_dec_and_test(&dev->refcount))
1064 return;
1065
1066 for (i = 0; i < VID_CHANNEL_NUM; i++)
1067 cx25821_video_unregister(dev, i);
1068
1069 for (i = VID_UPSTREAM_SRAM_CHANNEL_I;
1070 i <= AUDIO_UPSTREAM_SRAM_CHANNEL_B; i++) {
1071 cx25821_video_unregister(dev, i);
1072 }
1073
1074 cx25821_videoioctl_unregister(dev);
1075
1076 cx25821_i2c_unregister(&dev->i2c_bus[0]);
1077 cx25821_iounmap(dev);
1078}
1079EXPORT_SYMBOL(cx25821_dev_unregister);
1080
1081static __le32 *cx25821_risc_field(__le32 * rp, struct scatterlist *sglist,
1082 unsigned int offset, u32 sync_line,
1083 unsigned int bpl, unsigned int padding,
1084 unsigned int lines)
1085{
1086 struct scatterlist *sg;
1087 unsigned int line, todo;
1088
1089
1090 if (sync_line != NO_SYNC_LINE)
1091 *(rp++) = cpu_to_le32(RISC_RESYNC | sync_line);
1092
1093
1094 sg = sglist;
1095 for (line = 0; line < lines; line++) {
1096 while (offset && offset >= sg_dma_len(sg)) {
1097 offset -= sg_dma_len(sg);
1098 sg++;
1099 }
1100 if (bpl <= sg_dma_len(sg) - offset) {
1101
1102 *(rp++) = cpu_to_le32(RISC_WRITE | RISC_SOL | RISC_EOL |
1103 bpl);
1104 *(rp++) = cpu_to_le32(sg_dma_address(sg) + offset);
1105 *(rp++) = cpu_to_le32(0);
1106 offset += bpl;
1107 } else {
1108
1109 todo = bpl;
1110 *(rp++) = cpu_to_le32(RISC_WRITE | RISC_SOL |
1111 (sg_dma_len(sg) - offset));
1112 *(rp++) = cpu_to_le32(sg_dma_address(sg) + offset);
1113 *(rp++) = cpu_to_le32(0);
1114 todo -= (sg_dma_len(sg) - offset);
1115 offset = 0;
1116 sg++;
1117 while (todo > sg_dma_len(sg)) {
1118 *(rp++) = cpu_to_le32(RISC_WRITE |
1119 sg_dma_len(sg));
1120 *(rp++) = cpu_to_le32(sg_dma_address(sg));
1121 *(rp++) = cpu_to_le32(0);
1122 todo -= sg_dma_len(sg);
1123 sg++;
1124 }
1125 *(rp++) = cpu_to_le32(RISC_WRITE | RISC_EOL | todo);
1126 *(rp++) = cpu_to_le32(sg_dma_address(sg));
1127 *(rp++) = cpu_to_le32(0);
1128 offset += todo;
1129 }
1130
1131 offset += padding;
1132 }
1133
1134 return rp;
1135}
1136
1137int cx25821_risc_buffer(struct pci_dev *pci, struct btcx_riscmem *risc,
1138 struct scatterlist *sglist, unsigned int top_offset,
1139 unsigned int bottom_offset, unsigned int bpl,
1140 unsigned int padding, unsigned int lines)
1141{
1142 u32 instructions;
1143 u32 fields;
1144 __le32 *rp;
1145 int rc;
1146
1147 fields = 0;
1148 if (UNSET != top_offset)
1149 fields++;
1150 if (UNSET != bottom_offset)
1151 fields++;
1152
1153
1154
1155
1156
1157
1158 instructions = fields * (1 + ((bpl + padding) * lines) / PAGE_SIZE +
1159 lines);
1160 instructions += 2;
1161 rc = btcx_riscmem_alloc(pci, risc, instructions * 12);
1162
1163 if (rc < 0)
1164 return rc;
1165
1166
1167 rp = risc->cpu;
1168
1169 if (UNSET != top_offset) {
1170 rp = cx25821_risc_field(rp, sglist, top_offset, 0, bpl, padding,
1171 lines);
1172 }
1173
1174 if (UNSET != bottom_offset) {
1175 rp = cx25821_risc_field(rp, sglist, bottom_offset, 0x200, bpl,
1176 padding, lines);
1177 }
1178
1179
1180 risc->jmp = rp;
1181 BUG_ON((risc->jmp - risc->cpu + 2) * sizeof(*risc->cpu) > risc->size);
1182
1183 return 0;
1184}
1185
1186static __le32 *cx25821_risc_field_audio(__le32 * rp, struct scatterlist *sglist,
1187 unsigned int offset, u32 sync_line,
1188 unsigned int bpl, unsigned int padding,
1189 unsigned int lines, unsigned int lpi)
1190{
1191 struct scatterlist *sg;
1192 unsigned int line, todo, sol;
1193
1194
1195 if (sync_line != NO_SYNC_LINE)
1196 *(rp++) = cpu_to_le32(RISC_RESYNC | sync_line);
1197
1198
1199 sg = sglist;
1200 for (line = 0; line < lines; line++) {
1201 while (offset && offset >= sg_dma_len(sg)) {
1202 offset -= sg_dma_len(sg);
1203 sg++;
1204 }
1205
1206 if (lpi && line > 0 && !(line % lpi))
1207 sol = RISC_SOL | RISC_IRQ1 | RISC_CNT_INC;
1208 else
1209 sol = RISC_SOL;
1210
1211 if (bpl <= sg_dma_len(sg) - offset) {
1212
1213 *(rp++) = cpu_to_le32(RISC_WRITE | sol | RISC_EOL |
1214 bpl);
1215 *(rp++) = cpu_to_le32(sg_dma_address(sg) + offset);
1216 *(rp++) = cpu_to_le32(0);
1217 offset += bpl;
1218 } else {
1219
1220 todo = bpl;
1221 *(rp++) = cpu_to_le32(RISC_WRITE | sol |
1222 (sg_dma_len(sg) - offset));
1223 *(rp++) = cpu_to_le32(sg_dma_address(sg) + offset);
1224 *(rp++) = cpu_to_le32(0);
1225 todo -= (sg_dma_len(sg) - offset);
1226 offset = 0;
1227 sg++;
1228 while (todo > sg_dma_len(sg)) {
1229 *(rp++) = cpu_to_le32(RISC_WRITE |
1230 sg_dma_len(sg));
1231 *(rp++) = cpu_to_le32(sg_dma_address(sg));
1232 *(rp++) = cpu_to_le32(0);
1233 todo -= sg_dma_len(sg);
1234 sg++;
1235 }
1236 *(rp++) = cpu_to_le32(RISC_WRITE | RISC_EOL | todo);
1237 *(rp++) = cpu_to_le32(sg_dma_address(sg));
1238 *(rp++) = cpu_to_le32(0);
1239 offset += todo;
1240 }
1241 offset += padding;
1242 }
1243
1244 return rp;
1245}
1246
1247int cx25821_risc_databuffer_audio(struct pci_dev *pci,
1248 struct btcx_riscmem *risc,
1249 struct scatterlist *sglist,
1250 unsigned int bpl,
1251 unsigned int lines, unsigned int lpi)
1252{
1253 u32 instructions;
1254 __le32 *rp;
1255 int rc;
1256
1257
1258
1259
1260
1261
1262 instructions = 1 + (bpl * lines) / PAGE_SIZE + lines;
1263 instructions += 1;
1264
1265 rc = btcx_riscmem_alloc(pci, risc, instructions * 12);
1266 if (rc < 0)
1267 return rc;
1268
1269
1270 rp = risc->cpu;
1271 rp = cx25821_risc_field_audio(rp, sglist, 0, NO_SYNC_LINE, bpl, 0,
1272 lines, lpi);
1273
1274
1275 risc->jmp = rp;
1276 BUG_ON((risc->jmp - risc->cpu + 2) * sizeof(*risc->cpu) > risc->size);
1277 return 0;
1278}
1279EXPORT_SYMBOL(cx25821_risc_databuffer_audio);
1280
1281int cx25821_risc_stopper(struct pci_dev *pci, struct btcx_riscmem *risc,
1282 u32 reg, u32 mask, u32 value)
1283{
1284 __le32 *rp;
1285 int rc;
1286
1287 rc = btcx_riscmem_alloc(pci, risc, 4 * 16);
1288
1289 if (rc < 0)
1290 return rc;
1291
1292
1293 rp = risc->cpu;
1294
1295 *(rp++) = cpu_to_le32(RISC_WRITECR | RISC_IRQ1);
1296 *(rp++) = cpu_to_le32(reg);
1297 *(rp++) = cpu_to_le32(value);
1298 *(rp++) = cpu_to_le32(mask);
1299 *(rp++) = cpu_to_le32(RISC_JUMP);
1300 *(rp++) = cpu_to_le32(risc->dma);
1301 *(rp++) = cpu_to_le32(0);
1302 return 0;
1303}
1304
1305void cx25821_free_buffer(struct videobuf_queue *q, struct cx25821_buffer *buf)
1306{
1307 struct videobuf_dmabuf *dma = videobuf_to_dma(&buf->vb);
1308
1309 BUG_ON(in_interrupt());
1310 videobuf_waiton(q, &buf->vb, 0, 0);
1311 videobuf_dma_unmap(q->dev, dma);
1312 videobuf_dma_free(dma);
1313 btcx_riscmem_free(to_pci_dev(q->dev), &buf->risc);
1314 buf->vb.state = VIDEOBUF_NEEDS_INIT;
1315}
1316
1317static irqreturn_t cx25821_irq(int irq, void *dev_id)
1318{
1319 struct cx25821_dev *dev = dev_id;
1320 u32 pci_status, pci_mask;
1321 u32 vid_status;
1322 int i, handled = 0;
1323 u32 mask[8] = { 1, 2, 4, 8, 16, 32, 64, 128 };
1324
1325 pci_status = cx_read(PCI_INT_STAT);
1326 pci_mask = cx_read(PCI_INT_MSK);
1327
1328 if (pci_status == 0)
1329 goto out;
1330
1331 for (i = 0; i < VID_CHANNEL_NUM; i++) {
1332 if (pci_status & mask[i]) {
1333 vid_status = cx_read(dev->channels[i].
1334 sram_channels->int_stat);
1335
1336 if (vid_status)
1337 handled += cx25821_video_irq(dev, i,
1338 vid_status);
1339
1340 cx_write(PCI_INT_STAT, mask[i]);
1341 }
1342 }
1343
1344out:
1345 return IRQ_RETVAL(handled);
1346}
1347
1348void cx25821_print_irqbits(char *name, char *tag, char **strings,
1349 int len, u32 bits, u32 mask)
1350{
1351 unsigned int i;
1352
1353 printk(KERN_DEBUG pr_fmt("%s: %s [0x%x]"), name, tag, bits);
1354
1355 for (i = 0; i < len; i++) {
1356 if (!(bits & (1 << i)))
1357 continue;
1358 if (strings[i])
1359 pr_cont(" %s", strings[i]);
1360 else
1361 pr_cont(" %d", i);
1362 if (!(mask & (1 << i)))
1363 continue;
1364 pr_cont("*");
1365 }
1366 pr_cont("\n");
1367}
1368EXPORT_SYMBOL(cx25821_print_irqbits);
1369
1370struct cx25821_dev *cx25821_dev_get(struct pci_dev *pci)
1371{
1372 struct cx25821_dev *dev = pci_get_drvdata(pci);
1373 return dev;
1374}
1375EXPORT_SYMBOL(cx25821_dev_get);
1376
1377static int __devinit cx25821_initdev(struct pci_dev *pci_dev,
1378 const struct pci_device_id *pci_id)
1379{
1380 struct cx25821_dev *dev;
1381 int err = 0;
1382
1383 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1384 if (NULL == dev)
1385 return -ENOMEM;
1386
1387 err = v4l2_device_register(&pci_dev->dev, &dev->v4l2_dev);
1388 if (err < 0)
1389 goto fail_free;
1390
1391
1392 dev->pci = pci_dev;
1393 if (pci_enable_device(pci_dev)) {
1394 err = -EIO;
1395
1396 pr_info("pci enable failed!\n");
1397
1398 goto fail_unregister_device;
1399 }
1400
1401 pr_info("Athena pci enable !\n");
1402
1403 err = cx25821_dev_setup(dev);
1404 if (err) {
1405 if (err == -EBUSY)
1406 goto fail_unregister_device;
1407 else
1408 goto fail_unregister_pci;
1409 }
1410
1411
1412 pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &dev->pci_rev);
1413 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &dev->pci_lat);
1414 pr_info("%s/0: found at %s, rev: %d, irq: %d, latency: %d, mmio: 0x%llx\n",
1415 dev->name, pci_name(pci_dev), dev->pci_rev, pci_dev->irq,
1416 dev->pci_lat, (unsigned long long)dev->base_io_addr);
1417
1418 pci_set_master(pci_dev);
1419 if (!pci_dma_supported(pci_dev, 0xffffffff)) {
1420 pr_err("%s/0: Oops: no 32bit PCI DMA ???\n", dev->name);
1421 err = -EIO;
1422 goto fail_irq;
1423 }
1424
1425 err = request_irq(pci_dev->irq, cx25821_irq,
1426 IRQF_SHARED, dev->name, dev);
1427
1428 if (err < 0) {
1429 pr_err("%s: can't get IRQ %d\n", dev->name, pci_dev->irq);
1430 goto fail_irq;
1431 }
1432
1433 return 0;
1434
1435fail_irq:
1436 pr_info("cx25821_initdev() can't get IRQ !\n");
1437 cx25821_dev_unregister(dev);
1438
1439fail_unregister_pci:
1440 pci_disable_device(pci_dev);
1441fail_unregister_device:
1442 v4l2_device_unregister(&dev->v4l2_dev);
1443
1444fail_free:
1445 kfree(dev);
1446 return err;
1447}
1448
1449static void __devexit cx25821_finidev(struct pci_dev *pci_dev)
1450{
1451 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
1452 struct cx25821_dev *dev = get_cx25821(v4l2_dev);
1453
1454 cx25821_shutdown(dev);
1455 pci_disable_device(pci_dev);
1456
1457
1458 if (pci_dev->irq)
1459 free_irq(pci_dev->irq, dev);
1460
1461 mutex_lock(&cx25821_devlist_mutex);
1462 list_del(&dev->devlist);
1463 mutex_unlock(&cx25821_devlist_mutex);
1464
1465 cx25821_dev_unregister(dev);
1466 v4l2_device_unregister(v4l2_dev);
1467 kfree(dev);
1468}
1469
1470static DEFINE_PCI_DEVICE_TABLE(cx25821_pci_tbl) = {
1471 {
1472
1473 .vendor = 0x14f1,
1474 .device = 0x8210,
1475 .subvendor = 0x14f1,
1476 .subdevice = 0x0920,
1477 },
1478 {
1479
1480 }
1481};
1482
1483MODULE_DEVICE_TABLE(pci, cx25821_pci_tbl);
1484
1485static struct pci_driver cx25821_pci_driver = {
1486 .name = "cx25821",
1487 .id_table = cx25821_pci_tbl,
1488 .probe = cx25821_initdev,
1489 .remove = __devexit_p(cx25821_finidev),
1490
1491 .suspend = NULL,
1492 .resume = NULL,
1493};
1494
1495static int __init cx25821_init(void)
1496{
1497 pr_info("driver version %d.%d.%d loaded\n",
1498 (CX25821_VERSION_CODE >> 16) & 0xff,
1499 (CX25821_VERSION_CODE >> 8) & 0xff,
1500 CX25821_VERSION_CODE & 0xff);
1501 return pci_register_driver(&cx25821_pci_driver);
1502}
1503
1504static void __exit cx25821_fini(void)
1505{
1506 pci_unregister_driver(&cx25821_pci_driver);
1507}
1508
1509module_init(cx25821_init);
1510module_exit(cx25821_fini);
1511
