Commit | Line | Data |
---|---|---|
1a9fc855 MCC |
1 | /* |
2 | * Driver for the Conexant CX25821 PCIe bridge | |
3 | * | |
4 | * Copyright (C) 2009 Conexant Systems Inc. | |
5 | * Authors <hiep.huynh@conexant.com>, <shu.lin@conexant.com> | |
6 | * | |
7 | * This program is free software; you can redistribute it and/or modify | |
8 | * it under the terms of the GNU General Public License as published by | |
9 | * the Free Software Foundation; either version 2 of the License, or | |
10 | * (at your option) any later version. | |
11 | * | |
12 | * This program is distributed in the hope that it will be useful, | |
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | * | |
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 | ||
36d89f7d JP |
23 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
24 | ||
1a9fc855 MCC |
25 | #include "cx25821-video.h" |
26 | #include "cx25821-audio-upstream.h" | |
27 | ||
28 | #include <linux/fs.h> | |
29 | #include <linux/errno.h> | |
30 | #include <linux/kernel.h> | |
31 | #include <linux/init.h> | |
32 | #include <linux/module.h> | |
33 | #include <linux/syscalls.h> | |
34 | #include <linux/file.h> | |
35 | #include <linux/fcntl.h> | |
36 | #include <linux/delay.h> | |
5a0e3ad6 | 37 | #include <linux/slab.h> |
b5f11cc7 | 38 | #include <linux/uaccess.h> |
1a9fc855 MCC |
39 | |
40 | MODULE_DESCRIPTION("v4l2 driver module for cx25821 based TV cards"); | |
41 | MODULE_AUTHOR("Hiep Huynh <hiep.huynh@conexant.com>"); | |
42 | MODULE_LICENSE("GPL"); | |
43 | ||
f063a0c0 LT |
44 | static int _intr_msk = FLD_AUD_SRC_RISCI1 | FLD_AUD_SRC_OF | |
45 | FLD_AUD_SRC_SYNC | FLD_AUD_SRC_OPC_ERR; | |
1a9fc855 MCC |
46 | |
47 | int cx25821_sram_channel_setup_upstream_audio(struct cx25821_dev *dev, | |
48 | struct sram_channel *ch, | |
49 | unsigned int bpl, u32 risc) | |
50 | { | |
51 | unsigned int i, lines; | |
52 | u32 cdt; | |
53 | ||
54 | if (ch->cmds_start == 0) { | |
55 | cx_write(ch->ptr1_reg, 0); | |
56 | cx_write(ch->ptr2_reg, 0); | |
57 | cx_write(ch->cnt2_reg, 0); | |
58 | cx_write(ch->cnt1_reg, 0); | |
59 | return 0; | |
60 | } | |
61 | ||
62 | bpl = (bpl + 7) & ~7; /* alignment */ | |
63 | cdt = ch->cdt; | |
64 | lines = ch->fifo_size / bpl; | |
65 | ||
b5f11cc7 | 66 | if (lines > 3) |
1a9fc855 | 67 | lines = 3; |
1a9fc855 MCC |
68 | |
69 | BUG_ON(lines < 2); | |
70 | ||
71 | /* write CDT */ | |
72 | for (i = 0; i < lines; i++) { | |
73 | cx_write(cdt + 16 * i, ch->fifo_start + bpl * i); | |
74 | cx_write(cdt + 16 * i + 4, 0); | |
75 | cx_write(cdt + 16 * i + 8, 0); | |
76 | cx_write(cdt + 16 * i + 12, 0); | |
77 | } | |
78 | ||
79 | /* write CMDS */ | |
80 | cx_write(ch->cmds_start + 0, risc); | |
81 | ||
82 | cx_write(ch->cmds_start + 4, 0); | |
83 | cx_write(ch->cmds_start + 8, cdt); | |
84 | cx_write(ch->cmds_start + 12, AUDIO_CDT_SIZE_QW); | |
85 | cx_write(ch->cmds_start + 16, ch->ctrl_start); | |
86 | ||
b5f11cc7 | 87 | /* IQ size */ |
1a9fc855 MCC |
88 | cx_write(ch->cmds_start + 20, AUDIO_IQ_SIZE_DW); |
89 | ||
90 | for (i = 24; i < 80; i += 4) | |
91 | cx_write(ch->cmds_start + i, 0); | |
92 | ||
93 | /* fill registers */ | |
94 | cx_write(ch->ptr1_reg, ch->fifo_start); | |
95 | cx_write(ch->ptr2_reg, cdt); | |
96 | cx_write(ch->cnt2_reg, AUDIO_CDT_SIZE_QW); | |
97 | cx_write(ch->cnt1_reg, AUDIO_CLUSTER_SIZE_QW - 1); | |
98 | ||
99 | return 0; | |
100 | } | |
101 | ||
102 | static __le32 *cx25821_risc_field_upstream_audio(struct cx25821_dev *dev, | |
b5f11cc7 | 103 | __le32 *rp, |
1a9fc855 MCC |
104 | dma_addr_t databuf_phys_addr, |
105 | unsigned int bpl, | |
106 | int fifo_enable) | |
107 | { | |
108 | unsigned int line; | |
109 | struct sram_channel *sram_ch = | |
6100c579 | 110 | dev->channels[dev->_audio_upstream_channel].sram_channels; |
1a9fc855 MCC |
111 | int offset = 0; |
112 | ||
113 | /* scan lines */ | |
114 | for (line = 0; line < LINES_PER_AUDIO_BUFFER; line++) { | |
115 | *(rp++) = cpu_to_le32(RISC_READ | RISC_SOL | RISC_EOL | bpl); | |
116 | *(rp++) = cpu_to_le32(databuf_phys_addr + offset); | |
117 | *(rp++) = cpu_to_le32(0); /* bits 63-32 */ | |
118 | ||
b5f11cc7 MCC |
119 | /* Check if we need to enable the FIFO |
120 | * after the first 3 lines. | |
121 | * For the upstream audio channel, | |
122 | * the risc engine will enable the FIFO */ | |
1a9fc855 MCC |
123 | if (fifo_enable && line == 2) { |
124 | *(rp++) = RISC_WRITECR; | |
125 | *(rp++) = sram_ch->dma_ctl; | |
126 | *(rp++) = sram_ch->fld_aud_fifo_en; | |
127 | *(rp++) = 0x00000020; | |
128 | } | |
129 | ||
130 | offset += AUDIO_LINE_SIZE; | |
131 | } | |
132 | ||
133 | return rp; | |
134 | } | |
135 | ||
136 | int cx25821_risc_buffer_upstream_audio(struct cx25821_dev *dev, | |
137 | struct pci_dev *pci, | |
138 | unsigned int bpl, unsigned int lines) | |
139 | { | |
140 | __le32 *rp; | |
141 | int fifo_enable = 0; | |
142 | int frame = 0, i = 0; | |
143 | int frame_size = AUDIO_DATA_BUF_SZ; | |
144 | int databuf_offset = 0; | |
145 | int risc_flag = RISC_CNT_INC; | |
146 | dma_addr_t risc_phys_jump_addr; | |
147 | ||
148 | /* Virtual address of Risc buffer program */ | |
149 | rp = dev->_risc_virt_addr; | |
150 | ||
151 | /* sync instruction */ | |
152 | *(rp++) = cpu_to_le32(RISC_RESYNC | AUDIO_SYNC_LINE); | |
153 | ||
154 | for (frame = 0; frame < NUM_AUDIO_FRAMES; frame++) { | |
155 | databuf_offset = frame_size * frame; | |
156 | ||
157 | if (frame == 0) { | |
158 | fifo_enable = 1; | |
159 | risc_flag = RISC_CNT_RESET; | |
160 | } else { | |
161 | fifo_enable = 0; | |
162 | risc_flag = RISC_CNT_INC; | |
163 | } | |
164 | ||
b5f11cc7 | 165 | /* Calculate physical jump address */ |
1a9fc855 MCC |
166 | if ((frame + 1) == NUM_AUDIO_FRAMES) { |
167 | risc_phys_jump_addr = | |
168 | dev->_risc_phys_start_addr + | |
169 | RISC_SYNC_INSTRUCTION_SIZE; | |
170 | } else { | |
171 | risc_phys_jump_addr = | |
172 | dev->_risc_phys_start_addr + | |
173 | RISC_SYNC_INSTRUCTION_SIZE + | |
174 | AUDIO_RISC_DMA_BUF_SIZE * (frame + 1); | |
175 | } | |
176 | ||
177 | rp = cx25821_risc_field_upstream_audio(dev, rp, | |
178 | dev-> | |
179 | _audiodata_buf_phys_addr | |
180 | + databuf_offset, bpl, | |
181 | fifo_enable); | |
182 | ||
183 | if (USE_RISC_NOOP_AUDIO) { | |
b5f11cc7 | 184 | for (i = 0; i < NUM_NO_OPS; i++) |
1a9fc855 | 185 | *(rp++) = cpu_to_le32(RISC_NOOP); |
1a9fc855 MCC |
186 | } |
187 | ||
b5f11cc7 MCC |
188 | /* Loop to (Nth)FrameRISC or to Start of Risc program & |
189 | * generate IRQ */ | |
1a9fc855 MCC |
190 | *(rp++) = cpu_to_le32(RISC_JUMP | RISC_IRQ1 | risc_flag); |
191 | *(rp++) = cpu_to_le32(risc_phys_jump_addr); | |
192 | *(rp++) = cpu_to_le32(0); | |
193 | ||
b5f11cc7 | 194 | /* Recalculate virtual address based on frame index */ |
1a9fc855 MCC |
195 | rp = dev->_risc_virt_addr + RISC_SYNC_INSTRUCTION_SIZE / 4 + |
196 | (AUDIO_RISC_DMA_BUF_SIZE * (frame + 1) / 4); | |
197 | } | |
198 | ||
199 | return 0; | |
200 | } | |
201 | ||
202 | void cx25821_free_memory_audio(struct cx25821_dev *dev) | |
203 | { | |
204 | if (dev->_risc_virt_addr) { | |
205 | pci_free_consistent(dev->pci, dev->_audiorisc_size, | |
206 | dev->_risc_virt_addr, dev->_risc_phys_addr); | |
207 | dev->_risc_virt_addr = NULL; | |
208 | } | |
209 | ||
210 | if (dev->_audiodata_buf_virt_addr) { | |
211 | pci_free_consistent(dev->pci, dev->_audiodata_buf_size, | |
212 | dev->_audiodata_buf_virt_addr, | |
213 | dev->_audiodata_buf_phys_addr); | |
214 | dev->_audiodata_buf_virt_addr = NULL; | |
215 | } | |
216 | } | |
217 | ||
218 | void cx25821_stop_upstream_audio(struct cx25821_dev *dev) | |
219 | { | |
220 | struct sram_channel *sram_ch = | |
3e9442c6 | 221 | dev->channels[AUDIO_UPSTREAM_SRAM_CHANNEL_B].sram_channels; |
1a9fc855 MCC |
222 | u32 tmp = 0; |
223 | ||
224 | if (!dev->_audio_is_running) { | |
b5f11cc7 | 225 | printk(KERN_DEBUG |
36d89f7d | 226 | pr_fmt("No audio file is currently running so return!\n")); |
1a9fc855 MCC |
227 | return; |
228 | } | |
b5f11cc7 | 229 | /* Disable RISC interrupts */ |
1a9fc855 MCC |
230 | cx_write(sram_ch->int_msk, 0); |
231 | ||
b5f11cc7 | 232 | /* Turn OFF risc and fifo enable in AUD_DMA_CNTRL */ |
1a9fc855 MCC |
233 | tmp = cx_read(sram_ch->dma_ctl); |
234 | cx_write(sram_ch->dma_ctl, | |
235 | tmp & ~(sram_ch->fld_aud_fifo_en | sram_ch->fld_aud_risc_en)); | |
236 | ||
b5f11cc7 | 237 | /* Clear data buffer memory */ |
1a9fc855 MCC |
238 | if (dev->_audiodata_buf_virt_addr) |
239 | memset(dev->_audiodata_buf_virt_addr, 0, | |
240 | dev->_audiodata_buf_size); | |
241 | ||
242 | dev->_audio_is_running = 0; | |
243 | dev->_is_first_audio_frame = 0; | |
244 | dev->_audioframe_count = 0; | |
245 | dev->_audiofile_status = END_OF_FILE; | |
246 | ||
b0091780 IM |
247 | kfree(dev->_irq_audio_queues); |
248 | dev->_irq_audio_queues = NULL; | |
1a9fc855 | 249 | |
b0091780 | 250 | kfree(dev->_audiofilename); |
1a9fc855 MCC |
251 | } |
252 | ||
253 | void cx25821_free_mem_upstream_audio(struct cx25821_dev *dev) | |
254 | { | |
b5f11cc7 | 255 | if (dev->_audio_is_running) |
1a9fc855 | 256 | cx25821_stop_upstream_audio(dev); |
1a9fc855 MCC |
257 | |
258 | cx25821_free_memory_audio(dev); | |
259 | } | |
260 | ||
261 | int cx25821_get_audio_data(struct cx25821_dev *dev, | |
262 | struct sram_channel *sram_ch) | |
263 | { | |
264 | struct file *myfile; | |
265 | int frame_index_temp = dev->_audioframe_index; | |
266 | int i = 0; | |
267 | int line_size = AUDIO_LINE_SIZE; | |
268 | int frame_size = AUDIO_DATA_BUF_SZ; | |
269 | int frame_offset = frame_size * frame_index_temp; | |
270 | ssize_t vfs_read_retval = 0; | |
271 | char mybuf[line_size]; | |
272 | loff_t file_offset = dev->_audioframe_count * frame_size; | |
273 | loff_t pos; | |
274 | mm_segment_t old_fs; | |
275 | ||
276 | if (dev->_audiofile_status == END_OF_FILE) | |
277 | return 0; | |
278 | ||
279 | myfile = filp_open(dev->_audiofilename, O_RDONLY | O_LARGEFILE, 0); | |
280 | ||
281 | if (IS_ERR(myfile)) { | |
282 | const int open_errno = -PTR_ERR(myfile); | |
36d89f7d | 283 | pr_err("%s(): ERROR opening file(%s) with errno = %d!\n", |
1a9fc855 MCC |
284 | __func__, dev->_audiofilename, open_errno); |
285 | return PTR_ERR(myfile); | |
286 | } else { | |
287 | if (!(myfile->f_op)) { | |
36d89f7d | 288 | pr_err("%s(): File has no file operations registered!\n", |
1a9fc855 MCC |
289 | __func__); |
290 | filp_close(myfile, NULL); | |
291 | return -EIO; | |
292 | } | |
293 | ||
294 | if (!myfile->f_op->read) { | |
36d89f7d | 295 | pr_err("%s(): File has no READ operations registered!\n", |
1a9fc855 MCC |
296 | __func__); |
297 | filp_close(myfile, NULL); | |
298 | return -EIO; | |
299 | } | |
300 | ||
301 | pos = myfile->f_pos; | |
302 | old_fs = get_fs(); | |
303 | set_fs(KERNEL_DS); | |
304 | ||
305 | for (i = 0; i < dev->_audio_lines_count; i++) { | |
306 | pos = file_offset; | |
307 | ||
308 | vfs_read_retval = | |
309 | vfs_read(myfile, mybuf, line_size, &pos); | |
310 | ||
311 | if (vfs_read_retval > 0 && vfs_read_retval == line_size | |
312 | && dev->_audiodata_buf_virt_addr != NULL) { | |
313 | memcpy((void *)(dev->_audiodata_buf_virt_addr + | |
314 | frame_offset / 4), mybuf, | |
315 | vfs_read_retval); | |
316 | } | |
317 | ||
318 | file_offset += vfs_read_retval; | |
319 | frame_offset += vfs_read_retval; | |
320 | ||
321 | if (vfs_read_retval < line_size) { | |
36d89f7d JP |
322 | pr_info("Done: exit %s() since no more bytes to read from Audio file\n", |
323 | __func__); | |
1a9fc855 MCC |
324 | break; |
325 | } | |
326 | } | |
327 | ||
328 | if (i > 0) | |
329 | dev->_audioframe_count++; | |
330 | ||
331 | dev->_audiofile_status = | |
332 | (vfs_read_retval == line_size) ? IN_PROGRESS : END_OF_FILE; | |
333 | ||
334 | set_fs(old_fs); | |
335 | filp_close(myfile, NULL); | |
336 | } | |
337 | ||
338 | return 0; | |
339 | } | |
340 | ||
341 | static void cx25821_audioups_handler(struct work_struct *work) | |
342 | { | |
343 | struct cx25821_dev *dev = | |
344 | container_of(work, struct cx25821_dev, _audio_work_entry); | |
345 | ||
346 | if (!dev) { | |
36d89f7d | 347 | pr_err("ERROR %s(): since container_of(work_struct) FAILED!\n", |
1a9fc855 MCC |
348 | __func__); |
349 | return; | |
350 | } | |
351 | ||
1531e889 LF |
352 | cx25821_get_audio_data(dev, dev->channels[dev->_audio_upstream_channel]. |
353 | sram_channels); | |
1a9fc855 MCC |
354 | } |
355 | ||
356 | int cx25821_openfile_audio(struct cx25821_dev *dev, | |
357 | struct sram_channel *sram_ch) | |
358 | { | |
359 | struct file *myfile; | |
360 | int i = 0, j = 0; | |
361 | int line_size = AUDIO_LINE_SIZE; | |
362 | ssize_t vfs_read_retval = 0; | |
363 | char mybuf[line_size]; | |
364 | loff_t pos; | |
365 | loff_t offset = (unsigned long)0; | |
366 | mm_segment_t old_fs; | |
367 | ||
368 | myfile = filp_open(dev->_audiofilename, O_RDONLY | O_LARGEFILE, 0); | |
369 | ||
370 | if (IS_ERR(myfile)) { | |
371 | const int open_errno = -PTR_ERR(myfile); | |
36d89f7d | 372 | pr_err("%s(): ERROR opening file(%s) with errno = %d!\n", |
1a9fc855 MCC |
373 | __func__, dev->_audiofilename, open_errno); |
374 | return PTR_ERR(myfile); | |
375 | } else { | |
376 | if (!(myfile->f_op)) { | |
36d89f7d | 377 | pr_err("%s(): File has no file operations registered!\n", |
1a9fc855 MCC |
378 | __func__); |
379 | filp_close(myfile, NULL); | |
380 | return -EIO; | |
381 | } | |
382 | ||
383 | if (!myfile->f_op->read) { | |
36d89f7d | 384 | pr_err("%s(): File has no READ operations registered!\n", |
1a9fc855 MCC |
385 | __func__); |
386 | filp_close(myfile, NULL); | |
387 | return -EIO; | |
388 | } | |
389 | ||
390 | pos = myfile->f_pos; | |
391 | old_fs = get_fs(); | |
392 | set_fs(KERNEL_DS); | |
393 | ||
394 | for (j = 0; j < NUM_AUDIO_FRAMES; j++) { | |
395 | for (i = 0; i < dev->_audio_lines_count; i++) { | |
396 | pos = offset; | |
397 | ||
398 | vfs_read_retval = | |
399 | vfs_read(myfile, mybuf, line_size, &pos); | |
400 | ||
401 | if (vfs_read_retval > 0 | |
402 | && vfs_read_retval == line_size | |
403 | && dev->_audiodata_buf_virt_addr != NULL) { | |
404 | memcpy((void *)(dev-> | |
405 | _audiodata_buf_virt_addr | |
406 | + offset / 4), mybuf, | |
407 | vfs_read_retval); | |
408 | } | |
409 | ||
410 | offset += vfs_read_retval; | |
411 | ||
412 | if (vfs_read_retval < line_size) { | |
36d89f7d JP |
413 | pr_info("Done: exit %s() since no more bytes to read from Audio file\n", |
414 | __func__); | |
1a9fc855 MCC |
415 | break; |
416 | } | |
417 | } | |
418 | ||
b5f11cc7 | 419 | if (i > 0) |
1a9fc855 | 420 | dev->_audioframe_count++; |
1a9fc855 | 421 | |
b5f11cc7 | 422 | if (vfs_read_retval < line_size) |
1a9fc855 | 423 | break; |
1a9fc855 MCC |
424 | } |
425 | ||
426 | dev->_audiofile_status = | |
427 | (vfs_read_retval == line_size) ? IN_PROGRESS : END_OF_FILE; | |
428 | ||
429 | set_fs(old_fs); | |
430 | myfile->f_pos = 0; | |
431 | filp_close(myfile, NULL); | |
432 | } | |
433 | ||
434 | return 0; | |
435 | } | |
436 | ||
437 | static int cx25821_audio_upstream_buffer_prepare(struct cx25821_dev *dev, | |
438 | struct sram_channel *sram_ch, | |
439 | int bpl) | |
440 | { | |
441 | int ret = 0; | |
442 | dma_addr_t dma_addr; | |
443 | dma_addr_t data_dma_addr; | |
444 | ||
445 | cx25821_free_memory_audio(dev); | |
446 | ||
447 | dev->_risc_virt_addr = | |
448 | pci_alloc_consistent(dev->pci, dev->audio_upstream_riscbuf_size, | |
449 | &dma_addr); | |
450 | dev->_risc_virt_start_addr = dev->_risc_virt_addr; | |
451 | dev->_risc_phys_start_addr = dma_addr; | |
452 | dev->_risc_phys_addr = dma_addr; | |
453 | dev->_audiorisc_size = dev->audio_upstream_riscbuf_size; | |
454 | ||
455 | if (!dev->_risc_virt_addr) { | |
b5f11cc7 | 456 | printk(KERN_DEBUG |
36d89f7d | 457 | pr_fmt("ERROR: pci_alloc_consistent() FAILED to allocate memory for RISC program! Returning\n")); |
1a9fc855 MCC |
458 | return -ENOMEM; |
459 | } | |
b5f11cc7 | 460 | /* Clear out memory at address */ |
1a9fc855 MCC |
461 | memset(dev->_risc_virt_addr, 0, dev->_audiorisc_size); |
462 | ||
b5f11cc7 | 463 | /* For Audio Data buffer allocation */ |
1a9fc855 MCC |
464 | dev->_audiodata_buf_virt_addr = |
465 | pci_alloc_consistent(dev->pci, dev->audio_upstream_databuf_size, | |
466 | &data_dma_addr); | |
467 | dev->_audiodata_buf_phys_addr = data_dma_addr; | |
468 | dev->_audiodata_buf_size = dev->audio_upstream_databuf_size; | |
469 | ||
470 | if (!dev->_audiodata_buf_virt_addr) { | |
b5f11cc7 | 471 | printk(KERN_DEBUG |
36d89f7d | 472 | pr_fmt("ERROR: pci_alloc_consistent() FAILED to allocate memory for data buffer! Returning\n")); |
1a9fc855 MCC |
473 | return -ENOMEM; |
474 | } | |
b5f11cc7 | 475 | /* Clear out memory at address */ |
1a9fc855 MCC |
476 | memset(dev->_audiodata_buf_virt_addr, 0, dev->_audiodata_buf_size); |
477 | ||
478 | ret = cx25821_openfile_audio(dev, sram_ch); | |
479 | if (ret < 0) | |
480 | return ret; | |
481 | ||
b5f11cc7 | 482 | /* Creating RISC programs */ |
1a9fc855 MCC |
483 | ret = |
484 | cx25821_risc_buffer_upstream_audio(dev, dev->pci, bpl, | |
485 | dev->_audio_lines_count); | |
486 | if (ret < 0) { | |
487 | printk(KERN_DEBUG | |
36d89f7d | 488 | pr_fmt("ERROR creating audio upstream RISC programs!\n")); |
1a9fc855 MCC |
489 | goto error; |
490 | } | |
491 | ||
492 | return 0; | |
493 | ||
b5f11cc7 | 494 | error: |
1a9fc855 MCC |
495 | return ret; |
496 | } | |
497 | ||
498 | int cx25821_audio_upstream_irq(struct cx25821_dev *dev, int chan_num, | |
499 | u32 status) | |
500 | { | |
501 | int i = 0; | |
502 | u32 int_msk_tmp; | |
e4115bb2 | 503 | struct sram_channel *channel = dev->channels[chan_num].sram_channels; |
1a9fc855 MCC |
504 | dma_addr_t risc_phys_jump_addr; |
505 | __le32 *rp; | |
506 | ||
507 | if (status & FLD_AUD_SRC_RISCI1) { | |
b5f11cc7 | 508 | /* Get interrupt_index of the program that interrupted */ |
1a9fc855 MCC |
509 | u32 prog_cnt = cx_read(channel->gpcnt); |
510 | ||
b5f11cc7 MCC |
511 | /* Since we've identified our IRQ, clear our bits from the |
512 | * interrupt mask and interrupt status registers */ | |
1a9fc855 MCC |
513 | cx_write(channel->int_msk, 0); |
514 | cx_write(channel->int_stat, cx_read(channel->int_stat)); | |
515 | ||
516 | spin_lock(&dev->slock); | |
517 | ||
518 | while (prog_cnt != dev->_last_index_irq) { | |
b5f11cc7 MCC |
519 | /* Update _last_index_irq */ |
520 | if (dev->_last_index_irq < (NUMBER_OF_PROGRAMS - 1)) | |
1a9fc855 | 521 | dev->_last_index_irq++; |
b5f11cc7 | 522 | else |
1a9fc855 | 523 | dev->_last_index_irq = 0; |
1a9fc855 MCC |
524 | |
525 | dev->_audioframe_index = dev->_last_index_irq; | |
526 | ||
527 | queue_work(dev->_irq_audio_queues, | |
528 | &dev->_audio_work_entry); | |
529 | } | |
530 | ||
531 | if (dev->_is_first_audio_frame) { | |
532 | dev->_is_first_audio_frame = 0; | |
533 | ||
534 | if (dev->_risc_virt_start_addr != NULL) { | |
535 | risc_phys_jump_addr = | |
536 | dev->_risc_phys_start_addr + | |
537 | RISC_SYNC_INSTRUCTION_SIZE + | |
538 | AUDIO_RISC_DMA_BUF_SIZE; | |
539 | ||
540 | rp = cx25821_risc_field_upstream_audio(dev, | |
54082f1d LF |
541 | dev->_risc_virt_start_addr + 1, |
542 | dev->_audiodata_buf_phys_addr, | |
543 | AUDIO_LINE_SIZE, FIFO_DISABLE); | |
1a9fc855 MCC |
544 | |
545 | if (USE_RISC_NOOP_AUDIO) { | |
546 | for (i = 0; i < NUM_NO_OPS; i++) { | |
547 | *(rp++) = | |
548 | cpu_to_le32(RISC_NOOP); | |
549 | } | |
550 | } | |
b5f11cc7 | 551 | /* Jump to 2nd Audio Frame */ |
1531e889 | 552 | *(rp++) = cpu_to_le32(RISC_JUMP | RISC_IRQ1 | |
1a9fc855 MCC |
553 | RISC_CNT_RESET); |
554 | *(rp++) = cpu_to_le32(risc_phys_jump_addr); | |
555 | *(rp++) = cpu_to_le32(0); | |
556 | } | |
557 | } | |
558 | ||
559 | spin_unlock(&dev->slock); | |
560 | } else { | |
561 | if (status & FLD_AUD_SRC_OF) | |
36d89f7d JP |
562 | pr_warn("%s(): Audio Received Overflow Error Interrupt!\n", |
563 | __func__); | |
1a9fc855 MCC |
564 | |
565 | if (status & FLD_AUD_SRC_SYNC) | |
36d89f7d JP |
566 | pr_warn("%s(): Audio Received Sync Error Interrupt!\n", |
567 | __func__); | |
1a9fc855 MCC |
568 | |
569 | if (status & FLD_AUD_SRC_OPC_ERR) | |
36d89f7d JP |
570 | pr_warn("%s(): Audio Received OpCode Error Interrupt!\n", |
571 | __func__); | |
1a9fc855 | 572 | |
b5f11cc7 MCC |
573 | /* Read and write back the interrupt status register to clear |
574 | * our bits */ | |
1a9fc855 MCC |
575 | cx_write(channel->int_stat, cx_read(channel->int_stat)); |
576 | } | |
577 | ||
578 | if (dev->_audiofile_status == END_OF_FILE) { | |
36d89f7d JP |
579 | pr_warn("EOF Channel Audio Framecount = %d\n", |
580 | dev->_audioframe_count); | |
1a9fc855 MCC |
581 | return -1; |
582 | } | |
b5f11cc7 | 583 | /* ElSE, set the interrupt mask register, re-enable irq. */ |
1a9fc855 MCC |
584 | int_msk_tmp = cx_read(channel->int_msk); |
585 | cx_write(channel->int_msk, int_msk_tmp |= _intr_msk); | |
586 | ||
587 | return 0; | |
588 | } | |
589 | ||
590 | static irqreturn_t cx25821_upstream_irq_audio(int irq, void *dev_id) | |
591 | { | |
592 | struct cx25821_dev *dev = dev_id; | |
593 | u32 msk_stat, audio_status; | |
594 | int handled = 0; | |
595 | struct sram_channel *sram_ch; | |
596 | ||
597 | if (!dev) | |
598 | return -1; | |
599 | ||
6100c579 | 600 | sram_ch = dev->channels[dev->_audio_upstream_channel].sram_channels; |
1a9fc855 MCC |
601 | |
602 | msk_stat = cx_read(sram_ch->int_mstat); | |
603 | audio_status = cx_read(sram_ch->int_stat); | |
604 | ||
b5f11cc7 | 605 | /* Only deal with our interrupt */ |
1a9fc855 | 606 | if (audio_status) { |
1531e889 LF |
607 | handled = cx25821_audio_upstream_irq(dev, |
608 | dev->_audio_upstream_channel, audio_status); | |
1a9fc855 MCC |
609 | } |
610 | ||
b5f11cc7 | 611 | if (handled < 0) |
1a9fc855 | 612 | cx25821_stop_upstream_audio(dev); |
b5f11cc7 | 613 | else |
1a9fc855 | 614 | handled += handled; |
1a9fc855 MCC |
615 | |
616 | return IRQ_RETVAL(handled); | |
617 | } | |
618 | ||
619 | static void cx25821_wait_fifo_enable(struct cx25821_dev *dev, | |
620 | struct sram_channel *sram_ch) | |
621 | { | |
622 | int count = 0; | |
623 | u32 tmp; | |
624 | ||
625 | do { | |
b5f11cc7 MCC |
626 | /* Wait 10 microsecond before checking to see if the FIFO is |
627 | * turned ON. */ | |
1a9fc855 MCC |
628 | udelay(10); |
629 | ||
630 | tmp = cx_read(sram_ch->dma_ctl); | |
631 | ||
b5f11cc7 MCC |
632 | /* 10 millisecond timeout */ |
633 | if (count++ > 1000) { | |
36d89f7d JP |
634 | pr_err("ERROR: %s() fifo is NOT turned on. Timeout!\n", |
635 | __func__); | |
1a9fc855 MCC |
636 | return; |
637 | } | |
638 | ||
639 | } while (!(tmp & sram_ch->fld_aud_fifo_en)); | |
640 | ||
641 | } | |
642 | ||
643 | int cx25821_start_audio_dma_upstream(struct cx25821_dev *dev, | |
644 | struct sram_channel *sram_ch) | |
645 | { | |
646 | u32 tmp = 0; | |
647 | int err = 0; | |
648 | ||
b5f11cc7 MCC |
649 | /* Set the physical start address of the RISC program in the initial |
650 | * program counter(IPC) member of the CMDS. */ | |
1a9fc855 | 651 | cx_write(sram_ch->cmds_start + 0, dev->_risc_phys_addr); |
b5f11cc7 MCC |
652 | /* Risc IPC High 64 bits 63-32 */ |
653 | cx_write(sram_ch->cmds_start + 4, 0); | |
1a9fc855 MCC |
654 | |
655 | /* reset counter */ | |
656 | cx_write(sram_ch->gpcnt_ctl, 3); | |
657 | ||
b5f11cc7 MCC |
658 | /* Set the line length (It looks like we do not need to set the |
659 | * line length) */ | |
1a9fc855 MCC |
660 | cx_write(sram_ch->aud_length, AUDIO_LINE_SIZE & FLD_AUD_DST_LN_LNGTH); |
661 | ||
b5f11cc7 | 662 | /* Set the input mode to 16-bit */ |
1a9fc855 MCC |
663 | tmp = cx_read(sram_ch->aud_cfg); |
664 | tmp |= | |
665 | FLD_AUD_SRC_ENABLE | FLD_AUD_DST_PK_MODE | FLD_AUD_CLK_ENABLE | | |
666 | FLD_AUD_MASTER_MODE | FLD_AUD_CLK_SELECT_PLL_D | FLD_AUD_SONY_MODE; | |
667 | cx_write(sram_ch->aud_cfg, tmp); | |
668 | ||
b5f11cc7 | 669 | /* Read and write back the interrupt status register to clear it */ |
1a9fc855 MCC |
670 | tmp = cx_read(sram_ch->int_stat); |
671 | cx_write(sram_ch->int_stat, tmp); | |
672 | ||
b5f11cc7 | 673 | /* Clear our bits from the interrupt status register. */ |
1a9fc855 MCC |
674 | cx_write(sram_ch->int_stat, _intr_msk); |
675 | ||
b5f11cc7 | 676 | /* Set the interrupt mask register, enable irq. */ |
1a9fc855 MCC |
677 | cx_set(PCI_INT_MSK, cx_read(PCI_INT_MSK) | (1 << sram_ch->irq_bit)); |
678 | tmp = cx_read(sram_ch->int_msk); | |
679 | cx_write(sram_ch->int_msk, tmp |= _intr_msk); | |
680 | ||
681 | err = | |
682 | request_irq(dev->pci->irq, cx25821_upstream_irq_audio, | |
18e9351e | 683 | IRQF_SHARED, dev->name, dev); |
1a9fc855 | 684 | if (err < 0) { |
36d89f7d JP |
685 | pr_err("%s: can't get upstream IRQ %d\n", |
686 | dev->name, dev->pci->irq); | |
1a9fc855 MCC |
687 | goto fail_irq; |
688 | } | |
689 | ||
b5f11cc7 | 690 | /* Start the DMA engine */ |
1a9fc855 MCC |
691 | tmp = cx_read(sram_ch->dma_ctl); |
692 | cx_set(sram_ch->dma_ctl, tmp | sram_ch->fld_aud_risc_en); | |
693 | ||
694 | dev->_audio_is_running = 1; | |
695 | dev->_is_first_audio_frame = 1; | |
696 | ||
b5f11cc7 | 697 | /* The fifo_en bit turns on by the first Risc program */ |
1a9fc855 MCC |
698 | cx25821_wait_fifo_enable(dev, sram_ch); |
699 | ||
700 | return 0; | |
701 | ||
b5f11cc7 | 702 | fail_irq: |
1a9fc855 MCC |
703 | cx25821_dev_unregister(dev); |
704 | return err; | |
705 | } | |
706 | ||
707 | int cx25821_audio_upstream_init(struct cx25821_dev *dev, int channel_select) | |
708 | { | |
709 | struct sram_channel *sram_ch; | |
710 | int retval = 0; | |
711 | int err = 0; | |
712 | int str_length = 0; | |
713 | ||
714 | if (dev->_audio_is_running) { | |
36d89f7d | 715 | pr_warn("Audio Channel is still running so return!\n"); |
1a9fc855 MCC |
716 | return 0; |
717 | } | |
718 | ||
6100c579 | 719 | dev->_audio_upstream_channel = channel_select; |
e4115bb2 | 720 | sram_ch = dev->channels[channel_select].sram_channels; |
1a9fc855 | 721 | |
b5f11cc7 | 722 | /* Work queue */ |
1a9fc855 MCC |
723 | INIT_WORK(&dev->_audio_work_entry, cx25821_audioups_handler); |
724 | dev->_irq_audio_queues = | |
725 | create_singlethread_workqueue("cx25821_audioworkqueue"); | |
726 | ||
727 | if (!dev->_irq_audio_queues) { | |
b5f11cc7 | 728 | printk(KERN_DEBUG |
36d89f7d | 729 | pr_fmt("ERROR: create_singlethread_workqueue() for Audio FAILED!\n")); |
1a9fc855 MCC |
730 | return -ENOMEM; |
731 | } | |
732 | ||
733 | dev->_last_index_irq = 0; | |
734 | dev->_audio_is_running = 0; | |
735 | dev->_audioframe_count = 0; | |
736 | dev->_audiofile_status = RESET_STATUS; | |
737 | dev->_audio_lines_count = LINES_PER_AUDIO_BUFFER; | |
738 | _line_size = AUDIO_LINE_SIZE; | |
739 | ||
740 | if (dev->input_audiofilename) { | |
741 | str_length = strlen(dev->input_audiofilename); | |
32414878 | 742 | dev->_audiofilename = kmalloc(str_length + 1, GFP_KERNEL); |
1a9fc855 MCC |
743 | |
744 | if (!dev->_audiofilename) | |
745 | goto error; | |
746 | ||
747 | memcpy(dev->_audiofilename, dev->input_audiofilename, | |
748 | str_length + 1); | |
749 | ||
b5f11cc7 | 750 | /* Default if filename is empty string */ |
e4115bb2 | 751 | if (strcmp(dev->input_audiofilename, "") == 0) |
1a9fc855 | 752 | dev->_audiofilename = "/root/audioGOOD.wav"; |
1a9fc855 MCC |
753 | } else { |
754 | str_length = strlen(_defaultAudioName); | |
32414878 | 755 | dev->_audiofilename = kmalloc(str_length + 1, GFP_KERNEL); |
1a9fc855 MCC |
756 | |
757 | if (!dev->_audiofilename) | |
758 | goto error; | |
759 | ||
760 | memcpy(dev->_audiofilename, _defaultAudioName, str_length + 1); | |
761 | } | |
762 | ||
1531e889 LF |
763 | retval = cx25821_sram_channel_setup_upstream_audio(dev, sram_ch, |
764 | _line_size, 0); | |
1a9fc855 MCC |
765 | |
766 | dev->audio_upstream_riscbuf_size = | |
767 | AUDIO_RISC_DMA_BUF_SIZE * NUM_AUDIO_PROGS + | |
768 | RISC_SYNC_INSTRUCTION_SIZE; | |
769 | dev->audio_upstream_databuf_size = AUDIO_DATA_BUF_SZ * NUM_AUDIO_PROGS; | |
770 | ||
b5f11cc7 | 771 | /* Allocating buffers and prepare RISC program */ |
1531e889 LF |
772 | retval = cx25821_audio_upstream_buffer_prepare(dev, sram_ch, |
773 | _line_size); | |
1a9fc855 | 774 | if (retval < 0) { |
36d89f7d | 775 | pr_err("%s: Failed to set up Audio upstream buffers!\n", |
1a9fc855 MCC |
776 | dev->name); |
777 | goto error; | |
778 | } | |
b5f11cc7 | 779 | /* Start RISC engine */ |
1a9fc855 MCC |
780 | cx25821_start_audio_dma_upstream(dev, sram_ch); |
781 | ||
782 | return 0; | |
783 | ||
b5f11cc7 | 784 | error: |
1a9fc855 MCC |
785 | cx25821_dev_unregister(dev); |
786 | ||
787 | return err; | |
788 | } |