← Back to branch summary

~ubuntu-branches/ubuntu/precise/alsa-driver/precise

« back to all changes in this revision

Viewing changes to alsa-kernel/soc/s6000/s6000-pcm.c

  • Committer: Bazaar Package Importer
  • Author(s): Luke Yelavich
  • Date: 2011-02-21 18:06:40 UTC
  • mfrom: (1.1.15 upstream)
  • Revision ID: james.westby@ubuntu.com-20110221180640-a8p2yxtvgf7xbxub
Tags: 1.0.24+dfsg-0ubuntu1
* New upstream release
* Refreshed patches:
  - distinguish_kernel_makefile_and_source_dirs.patch
  - debian_dfsg_configure.patch
* debian/control: Update Vcs-bzr field to point to new branch location

Show diffs side-by-side

added added

removed removed

Lines of Context:
alsa-kernel/soc/s6000/s6000-pcm.c
65
65
        dma_addr_t dma_pos;
66
66
        dma_addr_t src, dst;
67
67
 
68
 
        par = snd_soc_dai_get_dma_data(soc_runtime->dai->cpu_dai, substream);
 
68
        par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
69
69
 
70
70
        period_size = snd_pcm_lib_period_bytes(substream);
71
71
        dma_offset = prtd->period * period_size;
103
103
{
104
104
        struct snd_pcm *pcm = data;
105
105
        struct snd_soc_pcm_runtime *runtime = pcm->private_data;
106
 
        struct s6000_pcm_dma_params *params =
107
 
                snd_soc_dai_get_dma_data(soc_runtime->dai->cpu_dai, substream);
108
106
        struct s6000_runtime_data *prtd;
109
107
        unsigned int has_xrun;
110
108
        int i, ret = IRQ_NONE;
111
 
        u32 channel[2] = {
112
 
                [SNDRV_PCM_STREAM_PLAYBACK] = params->dma_out,
113
 
                [SNDRV_PCM_STREAM_CAPTURE] = params->dma_in
114
 
        };
115
 
 
116
 
        has_xrun = params->check_xrun(runtime->dai->cpu_dai);
117
 
 
118
 
        for (i = 0; i < ARRAY_SIZE(channel); ++i) {
 
109
 
 
110
        for (i = 0; i < 2; ++i) {
119
111
                struct snd_pcm_substream *substream = pcm->streams[i].substream;
 
112
                struct s6000_pcm_dma_params *params =
 
113
                                        snd_soc_dai_get_dma_data(runtime->cpu_dai, substream);
 
114
                u32 channel;
120
115
                unsigned int pending;
121
116
 
122
 
                if (!channel[i])
 
117
                if (substream == SNDRV_PCM_STREAM_PLAYBACK)
 
118
                        channel = params->dma_out;
 
119
                else
 
120
                        channel = params->dma_in;
 
121
 
 
122
                has_xrun = params->check_xrun(runtime->cpu_dai);
 
123
 
 
124
                if (!channel)
123
125
                        continue;
124
126
 
125
127
                if (unlikely(has_xrun & (1 << i)) &&
130
132
                        ret = IRQ_HANDLED;
131
133
                }
132
134
 
133
 
                pending = s6dmac_int_sources(DMA_MASK_DMAC(channel[i]),
134
 
                                             DMA_INDEX_CHNL(channel[i]));
 
135
                pending = s6dmac_int_sources(DMA_MASK_DMAC(channel),
 
136
                                             DMA_INDEX_CHNL(channel));
135
137
 
136
138
                if (pending & 1) {
137
139
                        ret = IRQ_HANDLED;
139
141
                                   snd_pcm_running(substream))) {
140
142
                                snd_pcm_period_elapsed(substream);
141
143
                                dev_dbg(pcm->dev, "period elapsed %x %x\n",
142
 
                                       s6dmac_cur_src(DMA_MASK_DMAC(channel[i]),
143
 
                                                   DMA_INDEX_CHNL(channel[i])),
144
 
                                       s6dmac_cur_dst(DMA_MASK_DMAC(channel[i]),
145
 
                                                   DMA_INDEX_CHNL(channel[i])));
 
144
                                       s6dmac_cur_src(DMA_MASK_DMAC(channel),
 
145
                                                   DMA_INDEX_CHNL(channel)),
 
146
                                       s6dmac_cur_dst(DMA_MASK_DMAC(channel),
 
147
                                                   DMA_INDEX_CHNL(channel)));
146
148
                                prtd = substream->runtime->private_data;
147
149
                                spin_lock(&prtd->lock);
148
150
                                s6000_pcm_enqueue_dma(substream);
154
156
                        if (pending & (1 << 3))
155
157
                                printk(KERN_WARNING
156
158
                                       "s6000-pcm: DMA %x Underflow\n",
157
 
                                       channel[i]);
 
159
                                       channel);
158
160
                        if (pending & (1 << 4))
159
161
                                printk(KERN_WARNING
160
162
                                       "s6000-pcm: DMA %x Overflow\n",
161
 
                                       channel[i]);
 
163
                                       channel);
162
164
                        if (pending & 0x1e0)
163
165
                                printk(KERN_WARNING
164
166
                                       "s6000-pcm: DMA %x Master Error "
165
167
                                       "(mask %x)\n",
166
 
                                       channel[i], pending >> 5);
 
168
                                       channel, pending >> 5);
167
169
 
168
170
                }
169
171
        }
180
182
        int srcinc;
181
183
        u32 dma;
182
184
 
183
 
        par = snd_soc_dai_get_dma_data(soc_runtime->dai->cpu_dai, substream);
 
185
        par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
184
186
 
185
187
        spin_lock_irqsave(&prtd->lock, flags);
186
188
 
221
223
        unsigned long flags;
222
224
        u32 channel;
223
225
 
224
 
        par = snd_soc_dai_get_dma_data(soc_runtime->dai->cpu_dai, substream);
 
226
        par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
225
227
 
226
228
        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
227
229
                channel = par->dma_out;
246
248
        struct s6000_pcm_dma_params *par;
247
249
        int ret;
248
250
 
249
 
        par = snd_soc_dai_get_dma_data(soc_runtime->dai->cpu_dai, substream);
 
251
        par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
250
252
 
251
253
        ret = par->trigger(substream, cmd, 0);
252
254
        if (ret < 0)
291
293
        unsigned int offset;
292
294
        dma_addr_t count;
293
295
 
294
 
        par = snd_soc_dai_get_dma_data(soc_runtime->dai->cpu_dai, substream);
 
296
        par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
295
297
 
296
298
        spin_lock_irqsave(&prtd->lock, flags);
297
299
 
321
323
        struct s6000_runtime_data *prtd;
322
324
        int ret;
323
325
 
324
 
        par = snd_soc_dai_get_dma_data(soc_runtime->dai->cpu_dai, substream);
 
326
        par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
325
327
        snd_soc_set_runtime_hwparams(substream, &s6000_pcm_hardware);
326
328
 
327
329
        ret = snd_pcm_hw_constraint_step(runtime, 0,
385
387
                return ret;
386
388
        }
387
389
 
388
 
        par = snd_soc_dai_get_dma_data(soc_runtime->dai->cpu_dai, substream);
 
390
        par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
389
391
 
390
392
        if (par->same_rate) {
391
393
                spin_lock(&par->lock);
407
409
{
408
410
        struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
409
411
        struct s6000_pcm_dma_params *par =
410
 
                snd_soc_dai_get_dma_data(soc_runtime->dai->cpu_dai, substream);
 
412
                snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
411
413
 
412
414
        spin_lock(&par->lock);
413
415
        par->in_use &= ~(1 << substream->stream);
433
435
{
434
436
        struct snd_soc_pcm_runtime *runtime = pcm->private_data;
435
437
        struct s6000_pcm_dma_params *params =
436
 
                snd_soc_dai_get_dma_data(soc_runtime->dai->cpu_dai, substream);
 
438
                snd_soc_dai_get_dma_data(runtime->cpu_dai, pcm->streams[0].substream);
437
439
 
438
440
        free_irq(params->irq, pcm);
439
441
        snd_pcm_lib_preallocate_free_for_all(pcm);
448
450
        struct s6000_pcm_dma_params *params;
449
451
        int res;
450
452
 
451
 
        params = snd_soc_dai_get_dma_data(soc_runtime->dai->cpu_dai, substream);
 
453
        params = snd_soc_dai_get_dma_data(runtime->cpu_dai,
 
454
                        pcm->streams[0].substream);
452
455
 
453
456
        if (!card->dev->dma_mask)
454
457
                card->dev->dma_mask = &s6000_pcm_dmamask;
470
473
        }
471
474
 
472
475
        res = request_irq(params->irq, s6000_pcm_irq, IRQF_SHARED,
473
 
                          s6000_soc_platform.name, pcm);
 
476
                          "s6000-audio", pcm);
474
477
        if (res) {
475
478
                printk(KERN_ERR "s6000-pcm couldn't get IRQ\n");
476
479
                return res;
490
493
        return 0;
491
494
}
492
495
 
493
 
struct snd_soc_platform s6000_soc_platform = {
494
 
        .name =         "s6000-audio",
495
 
        .pcm_ops =      &s6000_pcm_ops,
 
496
static struct snd_soc_platform_driver s6000_soc_platform = {
 
497
        .ops =          &s6000_pcm_ops,
496
498
        .pcm_new =      s6000_pcm_new,
497
499
        .pcm_free =     s6000_pcm_free,
498
500
};
499
 
EXPORT_SYMBOL_GPL(s6000_soc_platform);
500
 
 
501
 
static int __init s6000_pcm_init(void)
502
 
{
503
 
        return snd_soc_register_platform(&s6000_soc_platform);
504
 
}
505
 
module_init(s6000_pcm_init);
506
 
 
507
 
static void __exit s6000_pcm_exit(void)
508
 
{
509
 
        snd_soc_unregister_platform(&s6000_soc_platform);
510
 
}
511
 
module_exit(s6000_pcm_exit);
 
501
 
 
502
static int __devinit s6000_soc_platform_probe(struct platform_device *pdev)
 
503
{
 
504
        return snd_soc_register_platform(&pdev->dev, &s6000_soc_platform);
 
505
}
 
506
 
 
507
static int __devexit s6000_soc_platform_remove(struct platform_device *pdev)
 
508
{
 
509
        snd_soc_unregister_platform(&pdev->dev);
 
510
        return 0;
 
511
}
 
512
 
 
513
static struct platform_driver s6000_pcm_driver = {
 
514
        .driver = {
 
515
                        .name = "s6000-pcm-audio",
 
516
                        .owner = THIS_MODULE,
 
517
        },
 
518
 
 
519
        .probe = s6000_soc_platform_probe,
 
520
        .remove = __devexit_p(s6000_soc_platform_remove),
 
521
};
 
522
 
 
523
static int __init snd_s6000_pcm_init(void)
 
524
{
 
525
        return platform_driver_register(&s6000_pcm_driver);
 
526
}
 
527
module_init(snd_s6000_pcm_init);
 
528
 
 
529
static void __exit snd_s6000_pcm_exit(void)
 
530
{
 
531
        platform_driver_unregister(&s6000_pcm_driver);
 
532
}
 
533
module_exit(snd_s6000_pcm_exit);
512
534
 
513
535
MODULE_AUTHOR("Daniel Gloeckner");
514
536
MODULE_DESCRIPTION("Stretch s6000 family PCM DMA module");