← Back to branch summary

~ubuntu-branches/ubuntu/quantal/linux-lowlatency/quantal-proposed

« back to all changes in this revision

Viewing changes to drivers/media/video/cx25821/cx25821-audio-upstream.c

  • Committer: Package Import Robot
  • Author(s): Andy Whitcroft, Andy Whitcroft
  • Date: 2012-06-21 09:16:38 UTC
  • Revision ID: package-import@ubuntu.com-20120621091638-gubhv4nox8xez1ct
Tags: 3.5.0-1.1
[ Andy Whitcroft]

* Rebuild lowlatency against Ubuntu-3.5.0-1.1
* All new configuration system to allow configuration deltas to be
  exposed via debian.lowlatency/config-delta

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/media/video/cx25821/cx25821-audio-upstream.c
107
107
{
108
108
        unsigned int line;
109
109
        struct sram_channel *sram_ch =
110
 
           dev->channels[dev->_audio_upstream_channel].sram_channels;
 
110
                dev->channels[dev->_audio_upstream_channel].sram_channels;
111
111
        int offset = 0;
112
112
 
113
113
        /* scan lines */
175
175
                }
176
176
 
177
177
                rp = cx25821_risc_field_upstream_audio(dev, rp,
178
 
                                                       dev->
179
 
                                                       _audiodata_buf_phys_addr
180
 
                                                       + databuf_offset, bpl,
181
 
                                                       fifo_enable);
 
178
                                dev->_audiodata_buf_phys_addr + databuf_offset,
 
179
                                bpl, fifo_enable);
182
180
 
183
181
                if (USE_RISC_NOOP_AUDIO) {
184
182
                        for (i = 0; i < NUM_NO_OPS; i++)
193
191
 
194
192
                /* Recalculate virtual address based on frame index */
195
193
                rp = dev->_risc_virt_addr + RISC_SYNC_INSTRUCTION_SIZE / 4 +
196
 
                    (AUDIO_RISC_DMA_BUF_SIZE * (frame + 1) / 4);
 
194
                        (AUDIO_RISC_DMA_BUF_SIZE * (frame + 1) / 4);
197
195
        }
198
196
 
199
197
        return 0;
218
216
void cx25821_stop_upstream_audio(struct cx25821_dev *dev)
219
217
{
220
218
        struct sram_channel *sram_ch =
221
 
           dev->channels[AUDIO_UPSTREAM_SRAM_CHANNEL_B].sram_channels;
 
219
                dev->channels[AUDIO_UPSTREAM_SRAM_CHANNEL_B].sram_channels;
222
220
        u32 tmp = 0;
223
221
 
224
222
        if (!dev->_audio_is_running) {
286
284
        } else {
287
285
                if (!(myfile->f_op)) {
288
286
                        pr_err("%s(): File has no file operations registered!\n",
289
 
                               __func__);
 
287
                                __func__);
290
288
                        filp_close(myfile, NULL);
291
289
                        return -EIO;
292
290
                }
293
291
 
294
292
                if (!myfile->f_op->read) {
295
293
                        pr_err("%s(): File has no READ operations registered!\n",
296
 
                               __func__);
 
294
                                __func__);
297
295
                        filp_close(myfile, NULL);
298
296
                        return -EIO;
299
297
                }
305
303
                for (i = 0; i < dev->_audio_lines_count; i++) {
306
304
                        pos = file_offset;
307
305
 
308
 
                        vfs_read_retval =
309
 
                            vfs_read(myfile, mybuf, line_size, &pos);
 
306
                        vfs_read_retval = vfs_read(myfile, mybuf, line_size,
 
307
                                                                        &pos);
310
308
 
311
309
                        if (vfs_read_retval > 0 && vfs_read_retval == line_size
312
310
                            && dev->_audiodata_buf_virt_addr != NULL) {
313
311
                                memcpy((void *)(dev->_audiodata_buf_virt_addr +
314
312
                                                frame_offset / 4), mybuf,
315
 
                                       vfs_read_retval);
 
313
                                        vfs_read_retval);
316
314
                        }
317
315
 
318
316
                        file_offset += vfs_read_retval;
328
326
                if (i > 0)
329
327
                        dev->_audioframe_count++;
330
328
 
331
 
                dev->_audiofile_status =
332
 
                    (vfs_read_retval == line_size) ? IN_PROGRESS : END_OF_FILE;
 
329
                dev->_audiofile_status = (vfs_read_retval == line_size) ?
 
330
                                                IN_PROGRESS : END_OF_FILE;
333
331
 
334
332
                set_fs(old_fs);
335
333
                filp_close(myfile, NULL);
340
338
 
341
339
static void cx25821_audioups_handler(struct work_struct *work)
342
340
{
343
 
        struct cx25821_dev *dev =
344
 
            container_of(work, struct cx25821_dev, _audio_work_entry);
 
341
        struct cx25821_dev *dev = container_of(work, struct cx25821_dev,
 
342
                        _audio_work_entry);
345
343
 
346
344
        if (!dev) {
347
345
                pr_err("ERROR %s(): since container_of(work_struct) FAILED!\n",
348
 
                       __func__);
 
346
                        __func__);
349
347
                return;
350
348
        }
351
349
 
370
368
        if (IS_ERR(myfile)) {
371
369
                const int open_errno = -PTR_ERR(myfile);
372
370
                pr_err("%s(): ERROR opening file(%s) with errno = %d!\n",
373
 
                       __func__, dev->_audiofilename, open_errno);
 
371
                        __func__, dev->_audiofilename, open_errno);
374
372
                return PTR_ERR(myfile);
375
373
        } else {
376
374
                if (!(myfile->f_op)) {
377
375
                        pr_err("%s(): File has no file operations registered!\n",
378
 
                               __func__);
 
376
                                __func__);
379
377
                        filp_close(myfile, NULL);
380
378
                        return -EIO;
381
379
                }
382
380
 
383
381
                if (!myfile->f_op->read) {
384
382
                        pr_err("%s(): File has no READ operations registered!\n",
385
 
                               __func__);
 
383
                                __func__);
386
384
                        filp_close(myfile, NULL);
387
385
                        return -EIO;
388
386
                }
395
393
                        for (i = 0; i < dev->_audio_lines_count; i++) {
396
394
                                pos = offset;
397
395
 
398
 
                                vfs_read_retval =
399
 
                                    vfs_read(myfile, mybuf, line_size, &pos);
 
396
                                vfs_read_retval = vfs_read(myfile, mybuf,
 
397
                                                line_size, &pos);
400
398
 
401
 
                                if (vfs_read_retval > 0
402
 
                                    && vfs_read_retval == line_size
403
 
                                    && dev->_audiodata_buf_virt_addr != NULL) {
 
399
                                if (vfs_read_retval > 0 &&
 
400
                                    vfs_read_retval == line_size &&
 
401
                                    dev->_audiodata_buf_virt_addr != NULL) {
404
402
                                        memcpy((void *)(dev->
405
403
                                                        _audiodata_buf_virt_addr
406
404
                                                        + offset / 4), mybuf,
423
421
                                break;
424
422
                }
425
423
 
426
 
                dev->_audiofile_status =
427
 
                    (vfs_read_retval == line_size) ? IN_PROGRESS : END_OF_FILE;
 
424
                dev->_audiofile_status = (vfs_read_retval == line_size) ?
 
425
                                                IN_PROGRESS : END_OF_FILE;
428
426
 
429
427
                set_fs(old_fs);
430
428
                myfile->f_pos = 0;
444
442
 
445
443
        cx25821_free_memory_audio(dev);
446
444
 
447
 
        dev->_risc_virt_addr =
448
 
            pci_alloc_consistent(dev->pci, dev->audio_upstream_riscbuf_size,
449
 
                                 &dma_addr);
 
445
        dev->_risc_virt_addr = pci_alloc_consistent(dev->pci,
 
446
                        dev->audio_upstream_riscbuf_size, &dma_addr);
450
447
        dev->_risc_virt_start_addr = dev->_risc_virt_addr;
451
448
        dev->_risc_phys_start_addr = dma_addr;
452
449
        dev->_risc_phys_addr = dma_addr;
454
451
 
455
452
        if (!dev->_risc_virt_addr) {
456
453
                printk(KERN_DEBUG
457
 
                       pr_fmt("ERROR: pci_alloc_consistent() FAILED to allocate memory for RISC program! Returning\n"));
 
454
                        pr_fmt("ERROR: pci_alloc_consistent() FAILED to allocate memory for RISC program! Returning\n"));
458
455
                return -ENOMEM;
459
456
        }
460
457
        /* Clear out memory at address */
461
458
        memset(dev->_risc_virt_addr, 0, dev->_audiorisc_size);
462
459
 
463
460
        /* For Audio Data buffer allocation */
464
 
        dev->_audiodata_buf_virt_addr =
465
 
            pci_alloc_consistent(dev->pci, dev->audio_upstream_databuf_size,
466
 
                                 &data_dma_addr);
 
461
        dev->_audiodata_buf_virt_addr = pci_alloc_consistent(dev->pci,
 
462
                        dev->audio_upstream_databuf_size, &data_dma_addr);
467
463
        dev->_audiodata_buf_phys_addr = data_dma_addr;
468
464
        dev->_audiodata_buf_size = dev->audio_upstream_databuf_size;
469
465
 
470
466
        if (!dev->_audiodata_buf_virt_addr) {
471
467
                printk(KERN_DEBUG
472
 
                       pr_fmt("ERROR: pci_alloc_consistent() FAILED to allocate memory for data buffer! Returning\n"));
 
468
                        pr_fmt("ERROR: pci_alloc_consistent() FAILED to allocate memory for data buffer! Returning\n"));
473
469
                return -ENOMEM;
474
470
        }
475
471
        /* Clear out memory at address */
480
476
                return ret;
481
477
 
482
478
        /* Creating RISC programs */
483
 
        ret =
484
 
            cx25821_risc_buffer_upstream_audio(dev, dev->pci, bpl,
485
 
                                               dev->_audio_lines_count);
 
479
        ret = cx25821_risc_buffer_upstream_audio(dev, dev->pci, bpl,
 
480
                                                dev->_audio_lines_count);
486
481
        if (ret < 0) {
487
482
                printk(KERN_DEBUG
488
 
                       pr_fmt("ERROR creating audio upstream RISC programs!\n"));
 
483
                        pr_fmt("ERROR creating audio upstream RISC programs!\n"));
489
484
                goto error;
490
485
        }
491
486
 
533
528
 
534
529
                        if (dev->_risc_virt_start_addr != NULL) {
535
530
                                risc_phys_jump_addr =
536
 
                                    dev->_risc_phys_start_addr +
537
 
                                    RISC_SYNC_INSTRUCTION_SIZE +
538
 
                                    AUDIO_RISC_DMA_BUF_SIZE;
 
531
                                        dev->_risc_phys_start_addr +
 
532
                                        RISC_SYNC_INSTRUCTION_SIZE +
 
533
                                        AUDIO_RISC_DMA_BUF_SIZE;
539
534
 
540
535
                                rp = cx25821_risc_field_upstream_audio(dev,
541
536
                                                dev->_risc_virt_start_addr + 1,
590
585
static irqreturn_t cx25821_upstream_irq_audio(int irq, void *dev_id)
591
586
{
592
587
        struct cx25821_dev *dev = dev_id;
593
 
        u32 msk_stat, audio_status;
 
588
        u32 audio_status;
594
589
        int handled = 0;
595
590
        struct sram_channel *sram_ch;
596
591
 
599
594
 
600
595
        sram_ch = dev->channels[dev->_audio_upstream_channel].sram_channels;
601
596
 
602
 
        msk_stat = cx_read(sram_ch->int_mstat);
603
597
        audio_status = cx_read(sram_ch->int_stat);
604
598
 
605
599
        /* Only deal with our interrupt */
632
626
                /* 10 millisecond timeout */
633
627
                if (count++ > 1000) {
634
628
                        pr_err("ERROR: %s() fifo is NOT turned on. Timeout!\n",
635
 
                               __func__);
 
629
                                __func__);
636
630
                        return;
637
631
                }
638
632
 
661
655
 
662
656
        /* Set the input mode to 16-bit */
663
657
        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;
 
658
        tmp |= FLD_AUD_SRC_ENABLE | FLD_AUD_DST_PK_MODE | FLD_AUD_CLK_ENABLE |
 
659
                FLD_AUD_MASTER_MODE | FLD_AUD_CLK_SELECT_PLL_D |
 
660
                FLD_AUD_SONY_MODE;
667
661
        cx_write(sram_ch->aud_cfg, tmp);
668
662
 
669
663
        /* Read and write back the interrupt status register to clear it */
678
672
        tmp = cx_read(sram_ch->int_msk);
679
673
        cx_write(sram_ch->int_msk, tmp |= _intr_msk);
680
674
 
681
 
        err =
682
 
            request_irq(dev->pci->irq, cx25821_upstream_irq_audio,
 
675
        err = request_irq(dev->pci->irq, cx25821_upstream_irq_audio,
683
676
                        IRQF_SHARED, dev->name, dev);
684
677
        if (err < 0) {
685
 
                pr_err("%s: can't get upstream IRQ %d\n",
686
 
                       dev->name, dev->pci->irq);
 
678
                pr_err("%s: can't get upstream IRQ %d\n", dev->name,
 
679
                                dev->pci->irq);
687
680
                goto fail_irq;
688
681
        }
689
682
 
726
719
 
727
720
        if (!dev->_irq_audio_queues) {
728
721
                printk(KERN_DEBUG
729
 
                       pr_fmt("ERROR: create_singlethread_workqueue() for Audio FAILED!\n"));
 
722
                        pr_fmt("ERROR: create_singlethread_workqueue() for Audio FAILED!\n"));
730
723
                return -ENOMEM;
731
724
        }
732
725
 
739
732
 
740
733
        if (dev->input_audiofilename) {
741
734
                str_length = strlen(dev->input_audiofilename);
742
 
                dev->_audiofilename = kmalloc(str_length + 1, GFP_KERNEL);
 
735
                dev->_audiofilename = kmemdup(dev->input_audiofilename,
 
736
                                              str_length + 1, GFP_KERNEL);
743
737
 
744
738
                if (!dev->_audiofilename)
745
739
                        goto error;
746
740
 
747
 
                memcpy(dev->_audiofilename, dev->input_audiofilename,
748
 
                       str_length + 1);
749
 
 
750
741
                /* Default if filename is empty string */
751
742
                if (strcmp(dev->input_audiofilename, "") == 0)
752
743
                        dev->_audiofilename = "/root/audioGOOD.wav";
753
744
        } else {
754
745
                str_length = strlen(_defaultAudioName);
755
 
                dev->_audiofilename = kmalloc(str_length + 1, GFP_KERNEL);
 
746
                dev->_audiofilename = kmemdup(_defaultAudioName,
 
747
                                              str_length + 1, GFP_KERNEL);
756
748
 
757
749
                if (!dev->_audiofilename)
758
750
                        goto error;
759
 
 
760
 
                memcpy(dev->_audiofilename, _defaultAudioName, str_length + 1);
761
751
        }
762
752
 
763
753
        retval = cx25821_sram_channel_setup_upstream_audio(dev, sram_ch,
764
754
                                                        _line_size, 0);
765
755
 
766
756
        dev->audio_upstream_riscbuf_size =
767
 
            AUDIO_RISC_DMA_BUF_SIZE * NUM_AUDIO_PROGS +
768
 
            RISC_SYNC_INSTRUCTION_SIZE;
 
757
                AUDIO_RISC_DMA_BUF_SIZE * NUM_AUDIO_PROGS +
 
758
                RISC_SYNC_INSTRUCTION_SIZE;
769
759
        dev->audio_upstream_databuf_size = AUDIO_DATA_BUF_SZ * NUM_AUDIO_PROGS;
770
760
 
771
761
        /* Allocating buffers and prepare RISC program */
773
763
                                                        _line_size);
774
764
        if (retval < 0) {
775
765
                pr_err("%s: Failed to set up Audio upstream buffers!\n",
776
 
                       dev->name);
 
766
                        dev->name);
777
767
                goto error;
778
768
        }
779
769
        /* Start RISC engine */