← Back to branch summary

~ubuntu-branches/ubuntu/maverick/linux-backports-modules-2.6.32/maverick

« back to all changes in this revision

Viewing changes to updates/alsa-driver/alsa-kernel/arm/pxa2xx-pcm.c

  • Committer: Bazaar Package Importer
  • Author(s): Andy Whitcroft, Andy Whitcroft
  • Date: 2010-02-04 23:15:51 UTC
  • Revision ID: james.westby@ubuntu.com-20100204231551-vjz5pkvxclukjxm1
Tags: 2.6.32-12.1
[ Andy Whitcroft ]

* initial LBM for lucid
* drop generated files
* printchanges -- rebase tree does not have stable tags use changelog
* printenv -- add revisions to printenv output
* formally rename compat-wireless to linux-backports-modules-wireless
* Update to compat-wireless-2.6.33-rc5
* update nouveau to mainline 2.6.33-rc4
* add new LBM package for nouveau
* nouveau -- fix major numbers and proc entry names
* fix up firmware installs for -wireless
* clean up UPDATE-NOVEAU
* update Nouveau to v2.6.33-rc6

Show diffs side-by-side

added added

removed removed

Lines of Context:
updates/alsa-driver/alsa-kernel/arm/pxa2xx-pcm.c
 
1
/*
 
2
 * linux/sound/arm/pxa2xx-pcm.c -- ALSA PCM interface for the Intel PXA2xx chip
 
3
 *
 
4
 * Author:      Nicolas Pitre
 
5
 * Created:     Nov 30, 2004
 
6
 * Copyright:   (C) 2004 MontaVista Software, Inc.
 
7
 *
 
8
 * This program is free software; you can redistribute it and/or modify
 
9
 * it under the terms of the GNU General Public License version 2 as
 
10
 * published by the Free Software Foundation.
 
11
 */
 
12
 
 
13
#include <sound/core.h>
 
14
#include <sound/pxa2xx-lib.h>
 
15
 
 
16
#include "pxa2xx-pcm.h"
 
17
 
 
18
static int pxa2xx_pcm_prepare(struct snd_pcm_substream *substream)
 
19
{
 
20
        struct pxa2xx_pcm_client *client = substream->private_data;
 
21
 
 
22
        __pxa2xx_pcm_prepare(substream);
 
23
 
 
24
        return client->prepare(substream);
 
25
}
 
26
 
 
27
static int pxa2xx_pcm_open(struct snd_pcm_substream *substream)
 
28
{
 
29
        struct pxa2xx_pcm_client *client = substream->private_data;
 
30
        struct snd_pcm_runtime *runtime = substream->runtime;
 
31
        struct pxa2xx_runtime_data *rtd;
 
32
        int ret;
 
33
 
 
34
        ret = __pxa2xx_pcm_open(substream);
 
35
        if (ret)
 
36
                goto out;
 
37
 
 
38
        rtd = runtime->private_data;
 
39
 
 
40
        rtd->params = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
 
41
                      client->playback_params : client->capture_params;
 
42
        ret = pxa_request_dma(rtd->params->name, DMA_PRIO_LOW,
 
43
                              pxa2xx_pcm_dma_irq, substream);
 
44
        if (ret < 0)
 
45
                goto err2;
 
46
        rtd->dma_ch = ret;
 
47
 
 
48
        ret = client->startup(substream);
 
49
        if (!ret)
 
50
                goto out;
 
51
 
 
52
        pxa_free_dma(rtd->dma_ch);
 
53
 err2:
 
54
        __pxa2xx_pcm_close(substream);
 
55
 out:
 
56
        return ret;
 
57
}
 
58
 
 
59
static int pxa2xx_pcm_close(struct snd_pcm_substream *substream)
 
60
{
 
61
        struct pxa2xx_pcm_client *client = substream->private_data;
 
62
        struct pxa2xx_runtime_data *rtd = substream->runtime->private_data;
 
63
 
 
64
        pxa_free_dma(rtd->dma_ch);
 
65
        client->shutdown(substream);
 
66
 
 
67
        return __pxa2xx_pcm_close(substream);
 
68
}
 
69
 
 
70
static struct snd_pcm_ops pxa2xx_pcm_ops = {
 
71
        .open           = pxa2xx_pcm_open,
 
72
        .close          = pxa2xx_pcm_close,
 
73
        .ioctl          = snd_pcm_lib_ioctl,
 
74
        .hw_params      = __pxa2xx_pcm_hw_params,
 
75
        .hw_free        = __pxa2xx_pcm_hw_free,
 
76
        .prepare        = pxa2xx_pcm_prepare,
 
77
        .trigger        = pxa2xx_pcm_trigger,
 
78
        .pointer        = pxa2xx_pcm_pointer,
 
79
        .mmap           = pxa2xx_pcm_mmap,
 
80
};
 
81
 
 
82
static u64 pxa2xx_pcm_dmamask = 0xffffffff;
 
83
 
 
84
int pxa2xx_pcm_new(struct snd_card *card, struct pxa2xx_pcm_client *client,
 
85
                   struct snd_pcm **rpcm)
 
86
{
 
87
        struct snd_pcm *pcm;
 
88
        int play = client->playback_params ? 1 : 0;
 
89
        int capt = client->capture_params ? 1 : 0;
 
90
        int ret;
 
91
 
 
92
        ret = snd_pcm_new(card, "PXA2xx-PCM", 0, play, capt, &pcm);
 
93
        if (ret)
 
94
                goto out;
 
95
 
 
96
        pcm->private_data = client;
 
97
        pcm->private_free = pxa2xx_pcm_free_dma_buffers;
 
98
 
 
99
        if (!card->dev->dma_mask)
 
100
                card->dev->dma_mask = &pxa2xx_pcm_dmamask;
 
101
        if (!card->dev->coherent_dma_mask)
 
102
                card->dev->coherent_dma_mask = 0xffffffff;
 
103
 
 
104
        if (play) {
 
105
                int stream = SNDRV_PCM_STREAM_PLAYBACK;
 
106
                snd_pcm_set_ops(pcm, stream, &pxa2xx_pcm_ops);
 
107
                ret = pxa2xx_pcm_preallocate_dma_buffer(pcm, stream);
 
108
                if (ret)
 
109
                        goto out;
 
110
        }
 
111
        if (capt) {
 
112
                int stream = SNDRV_PCM_STREAM_CAPTURE;
 
113
                snd_pcm_set_ops(pcm, stream, &pxa2xx_pcm_ops);
 
114
                ret = pxa2xx_pcm_preallocate_dma_buffer(pcm, stream);
 
115
                if (ret)
 
116
                        goto out;
 
117
        }
 
118
 
 
119
        if (rpcm)
 
120
                *rpcm = pcm;
 
121
        ret = 0;
 
122
 
 
123
 out:
 
124
        return ret;
 
125
}
 
126
 
 
127
EXPORT_SYMBOL(pxa2xx_pcm_new);
 
128
 
 
129
MODULE_AUTHOR("Nicolas Pitre");
 
130
MODULE_DESCRIPTION("Intel PXA2xx PCM DMA module");
 
131
MODULE_LICENSE("GPL");