Commit | Line | Data |
---|---|---|
866b8695 GKH |
1 | /* |
2 | * Copyright (C) 2005-2006 Micronas USA Inc. | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or modify | |
5 | * it under the terms of the GNU General Public License (Version 2) as | |
6 | * published by the Free Software Foundation. | |
7 | * | |
8 | * This program is distributed in the hope that it will be useful, | |
9 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
10 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
11 | * GNU General Public License for more details. | |
866b8695 GKH |
12 | */ |
13 | ||
14 | #include <linux/kernel.h> | |
15 | #include <linux/module.h> | |
866b8695 | 16 | #include <linux/moduleparam.h> |
866b8695 GKH |
17 | #include <linux/spinlock.h> |
18 | #include <linux/delay.h> | |
19 | #include <linux/sched.h> | |
20 | #include <linux/vmalloc.h> | |
21 | #include <linux/time.h> | |
22 | #include <linux/mm.h> | |
23 | #include <linux/i2c.h> | |
fd9a40da | 24 | #include <linux/mutex.h> |
866b8695 | 25 | #include <linux/uaccess.h> |
5a0e3ad6 | 26 | #include <linux/slab.h> |
866b8695 GKH |
27 | #include <sound/core.h> |
28 | #include <sound/pcm.h> | |
29 | #include <sound/initval.h> | |
30 | ||
31 | #include "go7007-priv.h" | |
32 | ||
33 | static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; | |
34 | static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; | |
90ab5ee9 | 35 | static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; |
866b8695 GKH |
36 | |
37 | module_param_array(index, int, NULL, 0444); | |
38 | module_param_array(id, charp, NULL, 0444); | |
39 | module_param_array(enable, bool, NULL, 0444); | |
40 | MODULE_PARM_DESC(index, "Index value for the go7007 audio driver"); | |
df20d69e RC |
41 | MODULE_PARM_DESC(id, "ID string for the go7007 audio driver"); |
42 | MODULE_PARM_DESC(enable, "Enable for the go7007 audio driver"); | |
866b8695 GKH |
43 | |
44 | struct go7007_snd { | |
45 | struct snd_card *card; | |
46 | struct snd_pcm *pcm; | |
47 | struct snd_pcm_substream *substream; | |
48 | spinlock_t lock; | |
49 | int w_idx; | |
50 | int hw_ptr; | |
51 | int avail; | |
52 | int capturing; | |
53 | }; | |
54 | ||
55 | static struct snd_pcm_hardware go7007_snd_capture_hw = { | |
56 | .info = (SNDRV_PCM_INFO_MMAP | | |
57 | SNDRV_PCM_INFO_INTERLEAVED | | |
58 | SNDRV_PCM_INFO_BLOCK_TRANSFER | | |
59 | SNDRV_PCM_INFO_MMAP_VALID), | |
60 | .formats = SNDRV_PCM_FMTBIT_S16_LE, | |
61 | .rates = SNDRV_PCM_RATE_48000, | |
62 | .rate_min = 48000, | |
63 | .rate_max = 48000, | |
64 | .channels_min = 2, | |
65 | .channels_max = 2, | |
66 | .buffer_bytes_max = (128*1024), | |
67 | .period_bytes_min = 4096, | |
68 | .period_bytes_max = (128*1024), | |
69 | .periods_min = 1, | |
70 | .periods_max = 32, | |
71 | }; | |
72 | ||
73 | static void parse_audio_stream_data(struct go7007 *go, u8 *buf, int length) | |
74 | { | |
75 | struct go7007_snd *gosnd = go->snd_context; | |
76 | struct snd_pcm_runtime *runtime = gosnd->substream->runtime; | |
77 | int frames = bytes_to_frames(runtime, length); | |
78 | ||
79 | spin_lock(&gosnd->lock); | |
80 | gosnd->hw_ptr += frames; | |
81 | if (gosnd->hw_ptr >= runtime->buffer_size) | |
82 | gosnd->hw_ptr -= runtime->buffer_size; | |
83 | gosnd->avail += frames; | |
84 | spin_unlock(&gosnd->lock); | |
85 | if (gosnd->w_idx + length > runtime->dma_bytes) { | |
86 | int cpy = runtime->dma_bytes - gosnd->w_idx; | |
87 | ||
88 | memcpy(runtime->dma_area + gosnd->w_idx, buf, cpy); | |
89 | length -= cpy; | |
90 | buf += cpy; | |
91 | gosnd->w_idx = 0; | |
92 | } | |
93 | memcpy(runtime->dma_area + gosnd->w_idx, buf, length); | |
94 | gosnd->w_idx += length; | |
95 | spin_lock(&gosnd->lock); | |
96 | if (gosnd->avail < runtime->period_size) { | |
97 | spin_unlock(&gosnd->lock); | |
98 | return; | |
99 | } | |
100 | gosnd->avail -= runtime->period_size; | |
101 | spin_unlock(&gosnd->lock); | |
102 | if (gosnd->capturing) | |
103 | snd_pcm_period_elapsed(gosnd->substream); | |
104 | } | |
105 | ||
106 | static int go7007_snd_hw_params(struct snd_pcm_substream *substream, | |
107 | struct snd_pcm_hw_params *hw_params) | |
108 | { | |
109 | struct go7007 *go = snd_pcm_substream_chip(substream); | |
110 | unsigned int bytes; | |
111 | ||
112 | bytes = params_buffer_bytes(hw_params); | |
113 | if (substream->runtime->dma_bytes > 0) | |
114 | vfree(substream->runtime->dma_area); | |
115 | substream->runtime->dma_bytes = 0; | |
116 | substream->runtime->dma_area = vmalloc(bytes); | |
117 | if (substream->runtime->dma_area == NULL) | |
118 | return -ENOMEM; | |
119 | substream->runtime->dma_bytes = bytes; | |
120 | go->audio_deliver = parse_audio_stream_data; | |
121 | return 0; | |
122 | } | |
123 | ||
124 | static int go7007_snd_hw_free(struct snd_pcm_substream *substream) | |
125 | { | |
126 | struct go7007 *go = snd_pcm_substream_chip(substream); | |
127 | ||
128 | go->audio_deliver = NULL; | |
129 | if (substream->runtime->dma_bytes > 0) | |
130 | vfree(substream->runtime->dma_area); | |
131 | substream->runtime->dma_bytes = 0; | |
132 | return 0; | |
133 | } | |
134 | ||
135 | static int go7007_snd_capture_open(struct snd_pcm_substream *substream) | |
136 | { | |
137 | struct go7007 *go = snd_pcm_substream_chip(substream); | |
138 | struct go7007_snd *gosnd = go->snd_context; | |
139 | unsigned long flags; | |
140 | int r; | |
141 | ||
142 | spin_lock_irqsave(&gosnd->lock, flags); | |
143 | if (gosnd->substream == NULL) { | |
144 | gosnd->substream = substream; | |
145 | substream->runtime->hw = go7007_snd_capture_hw; | |
146 | r = 0; | |
147 | } else | |
148 | r = -EBUSY; | |
149 | spin_unlock_irqrestore(&gosnd->lock, flags); | |
150 | return r; | |
151 | } | |
152 | ||
153 | static int go7007_snd_capture_close(struct snd_pcm_substream *substream) | |
154 | { | |
155 | struct go7007 *go = snd_pcm_substream_chip(substream); | |
156 | struct go7007_snd *gosnd = go->snd_context; | |
157 | ||
158 | gosnd->substream = NULL; | |
159 | return 0; | |
160 | } | |
161 | ||
162 | static int go7007_snd_pcm_prepare(struct snd_pcm_substream *substream) | |
163 | { | |
164 | return 0; | |
165 | } | |
166 | ||
167 | static int go7007_snd_pcm_trigger(struct snd_pcm_substream *substream, int cmd) | |
168 | { | |
169 | struct go7007 *go = snd_pcm_substream_chip(substream); | |
170 | struct go7007_snd *gosnd = go->snd_context; | |
171 | ||
172 | switch (cmd) { | |
173 | case SNDRV_PCM_TRIGGER_START: | |
174 | /* Just set a flag to indicate we should signal ALSA when | |
175 | * sound comes in */ | |
176 | gosnd->capturing = 1; | |
177 | return 0; | |
178 | case SNDRV_PCM_TRIGGER_STOP: | |
179 | gosnd->hw_ptr = gosnd->w_idx = gosnd->avail = 0; | |
180 | gosnd->capturing = 0; | |
181 | return 0; | |
182 | default: | |
183 | return -EINVAL; | |
184 | } | |
185 | } | |
186 | ||
187 | static snd_pcm_uframes_t go7007_snd_pcm_pointer(struct snd_pcm_substream *substream) | |
188 | { | |
189 | struct go7007 *go = snd_pcm_substream_chip(substream); | |
190 | struct go7007_snd *gosnd = go->snd_context; | |
191 | ||
192 | return gosnd->hw_ptr; | |
193 | } | |
194 | ||
195 | static struct page *go7007_snd_pcm_page(struct snd_pcm_substream *substream, | |
196 | unsigned long offset) | |
197 | { | |
198 | return vmalloc_to_page(substream->runtime->dma_area + offset); | |
199 | } | |
200 | ||
201 | static struct snd_pcm_ops go7007_snd_capture_ops = { | |
202 | .open = go7007_snd_capture_open, | |
203 | .close = go7007_snd_capture_close, | |
204 | .ioctl = snd_pcm_lib_ioctl, | |
205 | .hw_params = go7007_snd_hw_params, | |
206 | .hw_free = go7007_snd_hw_free, | |
207 | .prepare = go7007_snd_pcm_prepare, | |
208 | .trigger = go7007_snd_pcm_trigger, | |
209 | .pointer = go7007_snd_pcm_pointer, | |
210 | .page = go7007_snd_pcm_page, | |
211 | }; | |
212 | ||
213 | static int go7007_snd_free(struct snd_device *device) | |
214 | { | |
215 | struct go7007 *go = device->device_data; | |
216 | ||
217 | kfree(go->snd_context); | |
218 | go->snd_context = NULL; | |
866b8695 GKH |
219 | return 0; |
220 | } | |
221 | ||
222 | static struct snd_device_ops go7007_snd_device_ops = { | |
223 | .dev_free = go7007_snd_free, | |
224 | }; | |
225 | ||
226 | int go7007_snd_init(struct go7007 *go) | |
227 | { | |
228 | static int dev; | |
229 | struct go7007_snd *gosnd; | |
230 | int ret = 0; | |
231 | ||
232 | if (dev >= SNDRV_CARDS) | |
233 | return -ENODEV; | |
234 | if (!enable[dev]) { | |
235 | dev++; | |
236 | return -ENOENT; | |
237 | } | |
238 | gosnd = kmalloc(sizeof(struct go7007_snd), GFP_KERNEL); | |
239 | if (gosnd == NULL) | |
240 | return -ENOMEM; | |
241 | spin_lock_init(&gosnd->lock); | |
242 | gosnd->hw_ptr = gosnd->w_idx = gosnd->avail = 0; | |
243 | gosnd->capturing = 0; | |
3a3d2afd TI |
244 | ret = snd_card_new(go->dev, index[dev], id[dev], THIS_MODULE, 0, |
245 | &gosnd->card); | |
6ff18716 | 246 | if (ret < 0) { |
866b8695 | 247 | kfree(gosnd); |
6ff18716 | 248 | return ret; |
866b8695 GKH |
249 | } |
250 | ret = snd_device_new(gosnd->card, SNDRV_DEV_LOWLEVEL, go, | |
251 | &go7007_snd_device_ops); | |
252 | if (ret < 0) { | |
253 | kfree(gosnd); | |
254 | return ret; | |
255 | } | |
866b8695 GKH |
256 | ret = snd_pcm_new(gosnd->card, "go7007", 0, 0, 1, &gosnd->pcm); |
257 | if (ret < 0) { | |
258 | snd_card_free(gosnd->card); | |
259 | kfree(gosnd); | |
260 | return ret; | |
261 | } | |
1c3fc152 CG |
262 | strlcpy(gosnd->card->driver, "go7007", sizeof(gosnd->card->driver)); |
263 | strlcpy(gosnd->card->shortname, go->name, sizeof(gosnd->card->driver)); | |
264 | strlcpy(gosnd->card->longname, gosnd->card->shortname, | |
866b8695 GKH |
265 | sizeof(gosnd->card->longname)); |
266 | ||
267 | gosnd->pcm->private_data = go; | |
268 | snd_pcm_set_ops(gosnd->pcm, SNDRV_PCM_STREAM_CAPTURE, | |
269 | &go7007_snd_capture_ops); | |
270 | ||
271 | ret = snd_card_register(gosnd->card); | |
272 | if (ret < 0) { | |
273 | snd_card_free(gosnd->card); | |
274 | kfree(gosnd); | |
275 | return ret; | |
276 | } | |
277 | ||
278 | gosnd->substream = NULL; | |
279 | go->snd_context = gosnd; | |
d5d3a7cc | 280 | v4l2_device_get(&go->v4l2_dev); |
866b8695 | 281 | ++dev; |
866b8695 GKH |
282 | |
283 | return 0; | |
284 | } | |
285 | EXPORT_SYMBOL(go7007_snd_init); | |
286 | ||
287 | int go7007_snd_remove(struct go7007 *go) | |
288 | { | |
289 | struct go7007_snd *gosnd = go->snd_context; | |
290 | ||
291 | snd_card_disconnect(gosnd->card); | |
292 | snd_card_free_when_closed(gosnd->card); | |
d5d3a7cc | 293 | v4l2_device_put(&go->v4l2_dev); |
866b8695 GKH |
294 | return 0; |
295 | } | |
296 | EXPORT_SYMBOL(go7007_snd_remove); | |
297 | ||
298 | MODULE_LICENSE("GPL v2"); |