2 * Driver for the Conexant CX25821 PCIe bridge
4 * Copyright (C) 2009 Conexant Systems Inc.
5 * Authors <hiep.huynh@conexant.com>, <shu.lin@conexant.com>
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.
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
16 * GNU General Public License for more details.
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.
23 #include "cx25821-video.h"
24 #include "cx25821-audio-upstream.h"
27 #include <linux/errno.h>
28 #include <linux/kernel.h>
29 #include <linux/init.h>
30 #include <linux/module.h>
31 #include <linux/syscalls.h>
32 #include <linux/file.h>
33 #include <linux/fcntl.h>
34 #include <linux/delay.h>
35 #include <asm/uaccess.h>
37 MODULE_DESCRIPTION("v4l2 driver module for cx25821 based TV cards");
38 MODULE_AUTHOR("Hiep Huynh <hiep.huynh@conexant.com>");
39 MODULE_LICENSE("GPL");
41 static int _intr_msk =
42 FLD_AUD_SRC_RISCI1 | FLD_AUD_SRC_OF | FLD_AUD_SRC_SYNC |
45 int cx25821_sram_channel_setup_upstream_audio(struct cx25821_dev *dev,
46 struct sram_channel *ch,
47 unsigned int bpl, u32 risc)
49 unsigned int i, lines;
52 if (ch->cmds_start == 0) {
53 cx_write(ch->ptr1_reg, 0);
54 cx_write(ch->ptr2_reg, 0);
55 cx_write(ch->cnt2_reg, 0);
56 cx_write(ch->cnt1_reg, 0);
60 bpl = (bpl + 7) & ~7; /* alignment */
62 lines = ch->fifo_size / bpl;
71 for (i = 0; i < lines; i++) {
72 cx_write(cdt + 16 * i, ch->fifo_start + bpl * i);
73 cx_write(cdt + 16 * i + 4, 0);
74 cx_write(cdt + 16 * i + 8, 0);
75 cx_write(cdt + 16 * i + 12, 0);
79 cx_write(ch->cmds_start + 0, risc);
81 cx_write(ch->cmds_start + 4, 0);
82 cx_write(ch->cmds_start + 8, cdt);
83 cx_write(ch->cmds_start + 12, AUDIO_CDT_SIZE_QW);
84 cx_write(ch->cmds_start + 16, ch->ctrl_start);
87 cx_write(ch->cmds_start + 20, AUDIO_IQ_SIZE_DW);
89 for (i = 24; i < 80; i += 4)
90 cx_write(ch->cmds_start + i, 0);
93 cx_write(ch->ptr1_reg, ch->fifo_start);
94 cx_write(ch->ptr2_reg, cdt);
95 cx_write(ch->cnt2_reg, AUDIO_CDT_SIZE_QW);
96 cx_write(ch->cnt1_reg, AUDIO_CLUSTER_SIZE_QW - 1);
101 static __le32 *cx25821_risc_field_upstream_audio(struct cx25821_dev *dev,
103 dma_addr_t databuf_phys_addr,
108 struct sram_channel *sram_ch =
109 &dev->sram_channels[dev->_audio_upstream_channel_select];
113 for (line = 0; line < LINES_PER_AUDIO_BUFFER; line++) {
114 *(rp++) = cpu_to_le32(RISC_READ | RISC_SOL | RISC_EOL | bpl);
115 *(rp++) = cpu_to_le32(databuf_phys_addr + offset);
116 *(rp++) = cpu_to_le32(0); /* bits 63-32 */
118 // Check if we need to enable the FIFO after the first 3 lines
119 // For the upstream audio channel, the risc engine will enable the FIFO.
120 if (fifo_enable && line == 2) {
121 *(rp++) = RISC_WRITECR;
122 *(rp++) = sram_ch->dma_ctl;
123 *(rp++) = sram_ch->fld_aud_fifo_en;
124 *(rp++) = 0x00000020;
127 offset += AUDIO_LINE_SIZE;
133 int cx25821_risc_buffer_upstream_audio(struct cx25821_dev *dev,
135 unsigned int bpl, unsigned int lines)
139 int frame = 0, i = 0;
140 int frame_size = AUDIO_DATA_BUF_SZ;
141 int databuf_offset = 0;
142 int risc_flag = RISC_CNT_INC;
143 dma_addr_t risc_phys_jump_addr;
145 /* Virtual address of Risc buffer program */
146 rp = dev->_risc_virt_addr;
148 /* sync instruction */
149 *(rp++) = cpu_to_le32(RISC_RESYNC | AUDIO_SYNC_LINE);
151 for (frame = 0; frame < NUM_AUDIO_FRAMES; frame++) {
152 databuf_offset = frame_size * frame;
156 risc_flag = RISC_CNT_RESET;
159 risc_flag = RISC_CNT_INC;
162 //Calculate physical jump address
163 if ((frame + 1) == NUM_AUDIO_FRAMES) {
164 risc_phys_jump_addr =
165 dev->_risc_phys_start_addr +
166 RISC_SYNC_INSTRUCTION_SIZE;
168 risc_phys_jump_addr =
169 dev->_risc_phys_start_addr +
170 RISC_SYNC_INSTRUCTION_SIZE +
171 AUDIO_RISC_DMA_BUF_SIZE * (frame + 1);
174 rp = cx25821_risc_field_upstream_audio(dev, rp,
176 _audiodata_buf_phys_addr
177 + databuf_offset, bpl,
180 if (USE_RISC_NOOP_AUDIO) {
181 for (i = 0; i < NUM_NO_OPS; i++) {
182 *(rp++) = cpu_to_le32(RISC_NOOP);
186 // Loop to (Nth)FrameRISC or to Start of Risc program & generate IRQ
187 *(rp++) = cpu_to_le32(RISC_JUMP | RISC_IRQ1 | risc_flag);
188 *(rp++) = cpu_to_le32(risc_phys_jump_addr);
189 *(rp++) = cpu_to_le32(0);
191 //Recalculate virtual address based on frame index
192 rp = dev->_risc_virt_addr + RISC_SYNC_INSTRUCTION_SIZE / 4 +
193 (AUDIO_RISC_DMA_BUF_SIZE * (frame + 1) / 4);
199 void cx25821_free_memory_audio(struct cx25821_dev *dev)
201 if (dev->_risc_virt_addr) {
202 pci_free_consistent(dev->pci, dev->_audiorisc_size,
203 dev->_risc_virt_addr, dev->_risc_phys_addr);
204 dev->_risc_virt_addr = NULL;
207 if (dev->_audiodata_buf_virt_addr) {
208 pci_free_consistent(dev->pci, dev->_audiodata_buf_size,
209 dev->_audiodata_buf_virt_addr,
210 dev->_audiodata_buf_phys_addr);
211 dev->_audiodata_buf_virt_addr = NULL;
215 void cx25821_stop_upstream_audio(struct cx25821_dev *dev)
217 struct sram_channel *sram_ch =
218 &dev->sram_channels[AUDIO_UPSTREAM_SRAM_CHANNEL_B];
221 if (!dev->_audio_is_running) {
223 ("cx25821: No audio file is currently running so return!\n");
226 //Disable RISC interrupts
227 cx_write(sram_ch->int_msk, 0);
229 //Turn OFF risc and fifo enable in AUD_DMA_CNTRL
230 tmp = cx_read(sram_ch->dma_ctl);
231 cx_write(sram_ch->dma_ctl,
232 tmp & ~(sram_ch->fld_aud_fifo_en | sram_ch->fld_aud_risc_en));
234 //Clear data buffer memory
235 if (dev->_audiodata_buf_virt_addr)
236 memset(dev->_audiodata_buf_virt_addr, 0,
237 dev->_audiodata_buf_size);
239 dev->_audio_is_running = 0;
240 dev->_is_first_audio_frame = 0;
241 dev->_audioframe_count = 0;
242 dev->_audiofile_status = END_OF_FILE;
244 if (dev->_irq_audio_queues) {
245 kfree(dev->_irq_audio_queues);
246 dev->_irq_audio_queues = NULL;
249 if (dev->_audiofilename != NULL)
250 kfree(dev->_audiofilename);
253 void cx25821_free_mem_upstream_audio(struct cx25821_dev *dev)
255 if (dev->_audio_is_running) {
256 cx25821_stop_upstream_audio(dev);
259 cx25821_free_memory_audio(dev);
262 int cx25821_get_audio_data(struct cx25821_dev *dev,
263 struct sram_channel *sram_ch)
266 int frame_index_temp = dev->_audioframe_index;
268 int line_size = AUDIO_LINE_SIZE;
269 int frame_size = AUDIO_DATA_BUF_SZ;
270 int frame_offset = frame_size * frame_index_temp;
271 ssize_t vfs_read_retval = 0;
272 char mybuf[line_size];
273 loff_t file_offset = dev->_audioframe_count * frame_size;
277 if (dev->_audiofile_status == END_OF_FILE)
280 myfile = filp_open(dev->_audiofilename, O_RDONLY | O_LARGEFILE, 0);
282 if (IS_ERR(myfile)) {
283 const int open_errno = -PTR_ERR(myfile);
284 printk("%s(): ERROR opening file(%s) with errno = %d! \n",
285 __func__, dev->_audiofilename, open_errno);
286 return PTR_ERR(myfile);
288 if (!(myfile->f_op)) {
289 printk("%s: File has no file operations registered!\n",
291 filp_close(myfile, NULL);
295 if (!myfile->f_op->read) {
296 printk("%s: File has no READ operations registered! \n",
298 filp_close(myfile, NULL);
306 for (i = 0; i < dev->_audio_lines_count; i++) {
310 vfs_read(myfile, mybuf, line_size, &pos);
312 if (vfs_read_retval > 0 && vfs_read_retval == line_size
313 && dev->_audiodata_buf_virt_addr != NULL) {
314 memcpy((void *)(dev->_audiodata_buf_virt_addr +
315 frame_offset / 4), mybuf,
319 file_offset += vfs_read_retval;
320 frame_offset += vfs_read_retval;
322 if (vfs_read_retval < line_size) {
324 "Done: exit %s() since no more bytes to read from Audio file.\n",
331 dev->_audioframe_count++;
333 dev->_audiofile_status =
334 (vfs_read_retval == line_size) ? IN_PROGRESS : END_OF_FILE;
337 filp_close(myfile, NULL);
343 static void cx25821_audioups_handler(struct work_struct *work)
345 struct cx25821_dev *dev =
346 container_of(work, struct cx25821_dev, _audio_work_entry);
349 printk("ERROR %s(): since container_of(work_struct) FAILED! \n",
354 cx25821_get_audio_data(dev,
355 &dev->sram_channels[dev->
356 _audio_upstream_channel_select]);
359 int cx25821_openfile_audio(struct cx25821_dev *dev,
360 struct sram_channel *sram_ch)
364 int line_size = AUDIO_LINE_SIZE;
365 ssize_t vfs_read_retval = 0;
366 char mybuf[line_size];
368 loff_t offset = (unsigned long)0;
371 myfile = filp_open(dev->_audiofilename, O_RDONLY | O_LARGEFILE, 0);
373 if (IS_ERR(myfile)) {
374 const int open_errno = -PTR_ERR(myfile);
375 printk("%s(): ERROR opening file(%s) with errno = %d! \n",
376 __func__, dev->_audiofilename, open_errno);
377 return PTR_ERR(myfile);
379 if (!(myfile->f_op)) {
380 printk("%s: File has no file operations registered! \n",
382 filp_close(myfile, NULL);
386 if (!myfile->f_op->read) {
387 printk("%s: File has no READ operations registered! \n",
389 filp_close(myfile, NULL);
397 for (j = 0; j < NUM_AUDIO_FRAMES; j++) {
398 for (i = 0; i < dev->_audio_lines_count; i++) {
402 vfs_read(myfile, mybuf, line_size, &pos);
404 if (vfs_read_retval > 0
405 && vfs_read_retval == line_size
406 && dev->_audiodata_buf_virt_addr != NULL) {
407 memcpy((void *)(dev->
408 _audiodata_buf_virt_addr
409 + offset / 4), mybuf,
413 offset += vfs_read_retval;
415 if (vfs_read_retval < line_size) {
417 "Done: exit %s() since no more bytes to read from Audio file.\n",
424 dev->_audioframe_count++;
427 if (vfs_read_retval < line_size) {
432 dev->_audiofile_status =
433 (vfs_read_retval == line_size) ? IN_PROGRESS : END_OF_FILE;
437 filp_close(myfile, NULL);
443 static int cx25821_audio_upstream_buffer_prepare(struct cx25821_dev *dev,
444 struct sram_channel *sram_ch,
449 dma_addr_t data_dma_addr;
451 cx25821_free_memory_audio(dev);
453 dev->_risc_virt_addr =
454 pci_alloc_consistent(dev->pci, dev->audio_upstream_riscbuf_size,
456 dev->_risc_virt_start_addr = dev->_risc_virt_addr;
457 dev->_risc_phys_start_addr = dma_addr;
458 dev->_risc_phys_addr = dma_addr;
459 dev->_audiorisc_size = dev->audio_upstream_riscbuf_size;
461 if (!dev->_risc_virt_addr) {
463 ("cx25821 ERROR: pci_alloc_consistent() FAILED to allocate memory for RISC program! Returning.\n");
466 //Clear out memory at address
467 memset(dev->_risc_virt_addr, 0, dev->_audiorisc_size);
469 //For Audio Data buffer allocation
470 dev->_audiodata_buf_virt_addr =
471 pci_alloc_consistent(dev->pci, dev->audio_upstream_databuf_size,
473 dev->_audiodata_buf_phys_addr = data_dma_addr;
474 dev->_audiodata_buf_size = dev->audio_upstream_databuf_size;
476 if (!dev->_audiodata_buf_virt_addr) {
478 ("cx25821 ERROR: pci_alloc_consistent() FAILED to allocate memory for data buffer! Returning. \n");
481 //Clear out memory at address
482 memset(dev->_audiodata_buf_virt_addr, 0, dev->_audiodata_buf_size);
484 ret = cx25821_openfile_audio(dev, sram_ch);
488 //Creating RISC programs
490 cx25821_risc_buffer_upstream_audio(dev, dev->pci, bpl,
491 dev->_audio_lines_count);
494 "cx25821 ERROR creating audio upstream RISC programs! \n");
504 int cx25821_audio_upstream_irq(struct cx25821_dev *dev, int chan_num,
509 struct sram_channel *channel = &dev->sram_channels[chan_num];
510 dma_addr_t risc_phys_jump_addr;
513 if (status & FLD_AUD_SRC_RISCI1) {
514 //Get interrupt_index of the program that interrupted
515 u32 prog_cnt = cx_read(channel->gpcnt);
517 //Since we've identified our IRQ, clear our bits from the interrupt mask and interrupt status registers
518 cx_write(channel->int_msk, 0);
519 cx_write(channel->int_stat, cx_read(channel->int_stat));
521 spin_lock(&dev->slock);
523 while (prog_cnt != dev->_last_index_irq) {
524 //Update _last_index_irq
525 if (dev->_last_index_irq < (NUMBER_OF_PROGRAMS - 1)) {
526 dev->_last_index_irq++;
528 dev->_last_index_irq = 0;
531 dev->_audioframe_index = dev->_last_index_irq;
533 queue_work(dev->_irq_audio_queues,
534 &dev->_audio_work_entry);
537 if (dev->_is_first_audio_frame) {
538 dev->_is_first_audio_frame = 0;
540 if (dev->_risc_virt_start_addr != NULL) {
541 risc_phys_jump_addr =
542 dev->_risc_phys_start_addr +
543 RISC_SYNC_INSTRUCTION_SIZE +
544 AUDIO_RISC_DMA_BUF_SIZE;
546 rp = cx25821_risc_field_upstream_audio(dev,
548 _risc_virt_start_addr
551 _audiodata_buf_phys_addr,
555 if (USE_RISC_NOOP_AUDIO) {
556 for (i = 0; i < NUM_NO_OPS; i++) {
558 cpu_to_le32(RISC_NOOP);
561 // Jump to 2nd Audio Frame
563 cpu_to_le32(RISC_JUMP | RISC_IRQ1 |
565 *(rp++) = cpu_to_le32(risc_phys_jump_addr);
566 *(rp++) = cpu_to_le32(0);
570 spin_unlock(&dev->slock);
572 if (status & FLD_AUD_SRC_OF)
573 printk("%s: Audio Received Overflow Error Interrupt!\n",
576 if (status & FLD_AUD_SRC_SYNC)
577 printk("%s: Audio Received Sync Error Interrupt!\n",
580 if (status & FLD_AUD_SRC_OPC_ERR)
581 printk("%s: Audio Received OpCode Error Interrupt!\n",
584 // Read and write back the interrupt status register to clear our bits
585 cx_write(channel->int_stat, cx_read(channel->int_stat));
588 if (dev->_audiofile_status == END_OF_FILE) {
589 printk("cx25821: EOF Channel Audio Framecount = %d\n",
590 dev->_audioframe_count);
593 //ElSE, set the interrupt mask register, re-enable irq.
594 int_msk_tmp = cx_read(channel->int_msk);
595 cx_write(channel->int_msk, int_msk_tmp |= _intr_msk);
600 static irqreturn_t cx25821_upstream_irq_audio(int irq, void *dev_id)
602 struct cx25821_dev *dev = dev_id;
603 u32 msk_stat, audio_status;
605 struct sram_channel *sram_ch;
610 sram_ch = &dev->sram_channels[dev->_audio_upstream_channel_select];
612 msk_stat = cx_read(sram_ch->int_mstat);
613 audio_status = cx_read(sram_ch->int_stat);
615 // Only deal with our interrupt
618 cx25821_audio_upstream_irq(dev,
620 _audio_upstream_channel_select,
625 cx25821_stop_upstream_audio(dev);
630 return IRQ_RETVAL(handled);
633 static void cx25821_wait_fifo_enable(struct cx25821_dev *dev,
634 struct sram_channel *sram_ch)
640 //Wait 10 microsecond before checking to see if the FIFO is turned ON.
643 tmp = cx_read(sram_ch->dma_ctl);
645 if (count++ > 1000) //10 millisecond timeout
648 ("cx25821 ERROR: %s() fifo is NOT turned on. Timeout!\n",
653 } while (!(tmp & sram_ch->fld_aud_fifo_en));
657 int cx25821_start_audio_dma_upstream(struct cx25821_dev *dev,
658 struct sram_channel *sram_ch)
663 // Set the physical start address of the RISC program in the initial program counter(IPC) member of the CMDS.
664 cx_write(sram_ch->cmds_start + 0, dev->_risc_phys_addr);
665 cx_write(sram_ch->cmds_start + 4, 0); /* Risc IPC High 64 bits 63-32 */
668 cx_write(sram_ch->gpcnt_ctl, 3);
670 //Set the line length (It looks like we do not need to set the line length)
671 cx_write(sram_ch->aud_length, AUDIO_LINE_SIZE & FLD_AUD_DST_LN_LNGTH);
673 //Set the input mode to 16-bit
674 tmp = cx_read(sram_ch->aud_cfg);
676 FLD_AUD_SRC_ENABLE | FLD_AUD_DST_PK_MODE | FLD_AUD_CLK_ENABLE |
677 FLD_AUD_MASTER_MODE | FLD_AUD_CLK_SELECT_PLL_D | FLD_AUD_SONY_MODE;
678 cx_write(sram_ch->aud_cfg, tmp);
680 // Read and write back the interrupt status register to clear it
681 tmp = cx_read(sram_ch->int_stat);
682 cx_write(sram_ch->int_stat, tmp);
684 // Clear our bits from the interrupt status register.
685 cx_write(sram_ch->int_stat, _intr_msk);
687 //Set the interrupt mask register, enable irq.
688 cx_set(PCI_INT_MSK, cx_read(PCI_INT_MSK) | (1 << sram_ch->irq_bit));
689 tmp = cx_read(sram_ch->int_msk);
690 cx_write(sram_ch->int_msk, tmp |= _intr_msk);
693 request_irq(dev->pci->irq, cx25821_upstream_irq_audio,
694 IRQF_SHARED | IRQF_DISABLED, dev->name, dev);
696 printk(KERN_ERR "%s: can't get upstream IRQ %d\n", dev->name,
701 // Start the DMA engine
702 tmp = cx_read(sram_ch->dma_ctl);
703 cx_set(sram_ch->dma_ctl, tmp | sram_ch->fld_aud_risc_en);
705 dev->_audio_is_running = 1;
706 dev->_is_first_audio_frame = 1;
708 // The fifo_en bit turns on by the first Risc program
709 cx25821_wait_fifo_enable(dev, sram_ch);
714 cx25821_dev_unregister(dev);
718 int cx25821_audio_upstream_init(struct cx25821_dev *dev, int channel_select)
720 struct sram_channel *sram_ch;
725 if (dev->_audio_is_running) {
726 printk("Audio Channel is still running so return!\n");
730 dev->_audio_upstream_channel_select = channel_select;
731 sram_ch = &dev->sram_channels[channel_select];
734 INIT_WORK(&dev->_audio_work_entry, cx25821_audioups_handler);
735 dev->_irq_audio_queues =
736 create_singlethread_workqueue("cx25821_audioworkqueue");
738 if (!dev->_irq_audio_queues) {
740 ("cx25821 ERROR: create_singlethread_workqueue() for Audio FAILED!\n");
744 dev->_last_index_irq = 0;
745 dev->_audio_is_running = 0;
746 dev->_audioframe_count = 0;
747 dev->_audiofile_status = RESET_STATUS;
748 dev->_audio_lines_count = LINES_PER_AUDIO_BUFFER;
749 _line_size = AUDIO_LINE_SIZE;
751 if (dev->input_audiofilename) {
752 str_length = strlen(dev->input_audiofilename);
753 dev->_audiofilename =
754 (char *)kmalloc(str_length + 1, GFP_KERNEL);
756 if (!dev->_audiofilename)
759 memcpy(dev->_audiofilename, dev->input_audiofilename,
762 //Default if filename is empty string
763 if (strcmp(dev->input_audiofilename, "") == 0) {
764 dev->_audiofilename = "/root/audioGOOD.wav";
767 str_length = strlen(_defaultAudioName);
768 dev->_audiofilename =
769 (char *)kmalloc(str_length + 1, GFP_KERNEL);
771 if (!dev->_audiofilename)
774 memcpy(dev->_audiofilename, _defaultAudioName, str_length + 1);
778 cx25821_sram_channel_setup_upstream_audio(dev, sram_ch, _line_size,
781 dev->audio_upstream_riscbuf_size =
782 AUDIO_RISC_DMA_BUF_SIZE * NUM_AUDIO_PROGS +
783 RISC_SYNC_INSTRUCTION_SIZE;
784 dev->audio_upstream_databuf_size = AUDIO_DATA_BUF_SZ * NUM_AUDIO_PROGS;
786 //Allocating buffers and prepare RISC program
788 cx25821_audio_upstream_buffer_prepare(dev, sram_ch, _line_size);
791 "%s: Failed to set up Audio upstream buffers!\n",
796 cx25821_start_audio_dma_upstream(dev, sram_ch);
801 cx25821_dev_unregister(dev);