projects / openwrt / openwrt.git / blob
? search:


93d77fd8426ec95d0126e81b48e0af6934f4cde5
[openwrt/openwrt.git] / target / linux / brcm2708 / patches-3.14 / 0009-bcm2708-alsa-sound-driver.patch
1 From a7e31a16c66c5ecd1665250cfee9f3cfb64cfa67 Mon Sep 17 00:00:00 2001
2 From: popcornmix <popcornmix@gmail.com>
3 Date: Mon, 26 Mar 2012 22:15:50 +0100
4 Subject: [PATCH 09/54] bcm2708: alsa sound driver
5
6 Signed-off-by: popcornmix <popcornmix@gmail.com>
7 ---
8 arch/arm/configs/bcmrpi_cutdown_defconfig | 20 +
9 arch/arm/configs/bcmrpi_defconfig | 20 +
10 arch/arm/mach-bcm2708/bcm2708.c | 54 ++
11 sound/arm/Kconfig | 7 +
12 sound/arm/Makefile | 5 +
13 sound/arm/bcm2835-ctl.c | 200 +++++++
14 sound/arm/bcm2835-pcm.c | 409 +++++++++++++++
15 sound/arm/bcm2835-vchiq.c | 844 ++++++++++++++++++++++++++++++
16 sound/arm/bcm2835.c | 413 +++++++++++++++
17 sound/arm/bcm2835.h | 155 ++++++
18 sound/arm/vc_vchi_audioserv_defs.h | 116 ++++
19 11 files changed, 2243 insertions(+)
20 create mode 100755 sound/arm/bcm2835-ctl.c
21 create mode 100755 sound/arm/bcm2835-pcm.c
22 create mode 100755 sound/arm/bcm2835-vchiq.c
23 create mode 100755 sound/arm/bcm2835.c
24 create mode 100755 sound/arm/bcm2835.h
25 create mode 100644 sound/arm/vc_vchi_audioserv_defs.h
26
27 diff --git a/arch/arm/configs/bcmrpi_cutdown_defconfig b/arch/arm/configs/bcmrpi_cutdown_defconfig
28 index 74f2dc9..e519412 100644
29 --- a/arch/arm/configs/bcmrpi_cutdown_defconfig
30 +++ b/arch/arm/configs/bcmrpi_cutdown_defconfig
31 @@ -208,6 +208,26 @@ CONFIG_FRAMEBUFFER_CONSOLE=y
32 CONFIG_LOGO=y
33 # CONFIG_LOGO_LINUX_MONO is not set
34 # CONFIG_LOGO_LINUX_VGA16 is not set
35 +CONFIG_SOUND=y
36 +CONFIG_SND=m
37 +CONFIG_SND_SEQUENCER=m
38 +CONFIG_SND_SEQ_DUMMY=m
39 +CONFIG_SND_MIXER_OSS=m
40 +CONFIG_SND_PCM_OSS=m
41 +CONFIG_SND_SEQUENCER_OSS=y
42 +CONFIG_SND_HRTIMER=m
43 +CONFIG_SND_DUMMY=m
44 +CONFIG_SND_ALOOP=m
45 +CONFIG_SND_VIRMIDI=m
46 +CONFIG_SND_MTPAV=m
47 +CONFIG_SND_SERIAL_U16550=m
48 +CONFIG_SND_MPU401=m
49 +CONFIG_SND_BCM2835=m
50 +CONFIG_SND_USB_AUDIO=m
51 +CONFIG_SND_USB_UA101=m
52 +CONFIG_SND_USB_CAIAQ=m
53 +CONFIG_SND_USB_6FIRE=m
54 +CONFIG_SOUND_PRIME=m
55 CONFIG_HID_PID=y
56 CONFIG_USB_HIDDEV=y
57 CONFIG_HID_A4TECH=m
58 diff --git a/arch/arm/configs/bcmrpi_defconfig b/arch/arm/configs/bcmrpi_defconfig
59 index 339aabf..df947e5 100644
60 --- a/arch/arm/configs/bcmrpi_defconfig
61 +++ b/arch/arm/configs/bcmrpi_defconfig
62 @@ -225,6 +225,26 @@ CONFIG_FRAMEBUFFER_CONSOLE=y
63 CONFIG_LOGO=y
64 # CONFIG_LOGO_LINUX_MONO is not set
65 # CONFIG_LOGO_LINUX_VGA16 is not set
66 +CONFIG_SOUND=y
67 +CONFIG_SND=m
68 +CONFIG_SND_SEQUENCER=m
69 +CONFIG_SND_SEQ_DUMMY=m
70 +CONFIG_SND_MIXER_OSS=m
71 +CONFIG_SND_PCM_OSS=m
72 +CONFIG_SND_SEQUENCER_OSS=y
73 +CONFIG_SND_HRTIMER=m
74 +CONFIG_SND_DUMMY=m
75 +CONFIG_SND_ALOOP=m
76 +CONFIG_SND_VIRMIDI=m
77 +CONFIG_SND_MTPAV=m
78 +CONFIG_SND_SERIAL_U16550=m
79 +CONFIG_SND_MPU401=m
80 +CONFIG_SND_BCM2835=m
81 +CONFIG_SND_USB_AUDIO=m
82 +CONFIG_SND_USB_UA101=m
83 +CONFIG_SND_USB_CAIAQ=m
84 +CONFIG_SND_USB_6FIRE=m
85 +CONFIG_SOUND_PRIME=m
86 CONFIG_HID_PID=y
87 CONFIG_USB_HIDDEV=y
88 CONFIG_HID_A4TECH=m
89 diff --git a/arch/arm/mach-bcm2708/bcm2708.c b/arch/arm/mach-bcm2708/bcm2708.c
90 index a5af6ec..1904066 100644
91 --- a/arch/arm/mach-bcm2708/bcm2708.c
92 +++ b/arch/arm/mach-bcm2708/bcm2708.c
93 @@ -431,6 +431,58 @@ struct platform_device bcm2708_powerman_device = {
94 .coherent_dma_mask = 0xffffffffUL},
95 };
96
97 +
98 +static struct platform_device bcm2708_alsa_devices[] = {
99 + [0] = {
100 + .name = "bcm2835_AUD0",
101 + .id = 0, /* first audio device */
102 + .resource = 0,
103 + .num_resources = 0,
104 + },
105 + [1] = {
106 + .name = "bcm2835_AUD1",
107 + .id = 1, /* second audio device */
108 + .resource = 0,
109 + .num_resources = 0,
110 + },
111 + [2] = {
112 + .name = "bcm2835_AUD2",
113 + .id = 2, /* third audio device */
114 + .resource = 0,
115 + .num_resources = 0,
116 + },
117 + [3] = {
118 + .name = "bcm2835_AUD3",
119 + .id = 3, /* forth audio device */
120 + .resource = 0,
121 + .num_resources = 0,
122 + },
123 + [4] = {
124 + .name = "bcm2835_AUD4",
125 + .id = 4, /* fifth audio device */
126 + .resource = 0,
127 + .num_resources = 0,
128 + },
129 + [5] = {
130 + .name = "bcm2835_AUD5",
131 + .id = 5, /* sixth audio device */
132 + .resource = 0,
133 + .num_resources = 0,
134 + },
135 + [6] = {
136 + .name = "bcm2835_AUD6",
137 + .id = 6, /* seventh audio device */
138 + .resource = 0,
139 + .num_resources = 0,
140 + },
141 + [7] = {
142 + .name = "bcm2835_AUD7",
143 + .id = 7, /* eighth audio device */
144 + .resource = 0,
145 + .num_resources = 0,
146 + },
147 +};
148 +
149 int __init bcm_register_device(struct platform_device *pdev)
150 {
151 int ret;
152 @@ -539,6 +591,8 @@ void __init bcm2708_init(void)
153 bcm_register_device(&bcm2708_emmc_device);
154 #endif
155 bcm2708_init_led();
156 + for (i = 0; i < ARRAY_SIZE(bcm2708_alsa_devices); i++)
157 + bcm_register_device(&bcm2708_alsa_devices[i]);
158
159 for (i = 0; i < ARRAY_SIZE(amba_devs); i++) {
160 struct amba_device *d = amba_devs[i];
161 diff --git a/sound/arm/Kconfig b/sound/arm/Kconfig
162 index 885683a..f7ceafd 100644
163 --- a/sound/arm/Kconfig
164 +++ b/sound/arm/Kconfig
165 @@ -39,5 +39,12 @@ config SND_PXA2XX_AC97
166 Say Y or M if you want to support any AC97 codec attached to
167 the PXA2xx AC97 interface.
168
169 +config SND_BCM2835
170 + tristate "BCM2835 ALSA driver"
171 + depends on ARCH_BCM2708 && BCM2708_VCHIQ && SND
172 + select SND_PCM
173 + help
174 + Say Y or M if you want to support BCM2835 Alsa pcm card driver
175 +
176 endif # SND_ARM
177
178 diff --git a/sound/arm/Makefile b/sound/arm/Makefile
179 index 8c0c851..6796d7f 100644
180 --- a/sound/arm/Makefile
181 +++ b/sound/arm/Makefile
182 @@ -14,3 +14,8 @@ snd-pxa2xx-lib-$(CONFIG_SND_PXA2XX_LIB_AC97) += pxa2xx-ac97-lib.o
183
184 obj-$(CONFIG_SND_PXA2XX_AC97) += snd-pxa2xx-ac97.o
185 snd-pxa2xx-ac97-objs := pxa2xx-ac97.o
186 +
187 +obj-$(CONFIG_SND_BCM2835) += snd-bcm2835.o
188 +snd-bcm2835-objs := bcm2835.o bcm2835-ctl.o bcm2835-pcm.o bcm2835-vchiq.o
189 +
190 +ccflags-y += -Idrivers/misc/vc04_services -Idrivers/misc/vc04_services/interface/vcos/linuxkernel -D__VCCOREVER__=0x04000000
191 diff --git a/sound/arm/bcm2835-ctl.c b/sound/arm/bcm2835-ctl.c
192 new file mode 100755
193 index 0000000..8c5334a
194 --- /dev/null
195 +++ b/sound/arm/bcm2835-ctl.c
196 @@ -0,0 +1,200 @@
197 +/*****************************************************************************
198 +* Copyright 2011 Broadcom Corporation. All rights reserved.
199 +*
200 +* Unless you and Broadcom execute a separate written software license
201 +* agreement governing use of this software, this software is licensed to you
202 +* under the terms of the GNU General Public License version 2, available at
203 +* http://www.broadcom.com/licenses/GPLv2.php (the "GPL").
204 +*
205 +* Notwithstanding the above, under no circumstances may you combine this
206 +* software in any way with any other Broadcom software provided under a
207 +* license other than the GPL, without Broadcom's express prior written
208 +* consent.
209 +*****************************************************************************/
210 +
211 +#include <linux/platform_device.h>
212 +#include <linux/init.h>
213 +#include <linux/io.h>
214 +#include <linux/jiffies.h>
215 +#include <linux/slab.h>
216 +#include <linux/time.h>
217 +#include <linux/wait.h>
218 +#include <linux/delay.h>
219 +#include <linux/moduleparam.h>
220 +#include <linux/sched.h>
221 +
222 +#include <sound/core.h>
223 +#include <sound/control.h>
224 +#include <sound/pcm.h>
225 +#include <sound/pcm_params.h>
226 +#include <sound/rawmidi.h>
227 +#include <sound/initval.h>
228 +#include <sound/tlv.h>
229 +
230 +#include "bcm2835.h"
231 +
232 +/* volume maximum and minimum in terms of 0.01dB */
233 +#define CTRL_VOL_MAX 400
234 +#define CTRL_VOL_MIN -10239 /* originally -10240 */
235 +
236 +
237 +static int snd_bcm2835_ctl_info(struct snd_kcontrol *kcontrol,
238 + struct snd_ctl_elem_info *uinfo)
239 +{
240 + audio_info(" ... IN\n");
241 + if (kcontrol->private_value == PCM_PLAYBACK_VOLUME) {
242 + uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
243 + uinfo->count = 1;
244 + uinfo->value.integer.min = CTRL_VOL_MIN;
245 + uinfo->value.integer.max = CTRL_VOL_MAX; /* 2303 */
246 + } else if (kcontrol->private_value == PCM_PLAYBACK_MUTE) {
247 + uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
248 + uinfo->count = 1;
249 + uinfo->value.integer.min = 0;
250 + uinfo->value.integer.max = 1;
251 + } else if (kcontrol->private_value == PCM_PLAYBACK_DEVICE) {
252 + uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
253 + uinfo->count = 1;
254 + uinfo->value.integer.min = 0;
255 + uinfo->value.integer.max = AUDIO_DEST_MAX-1;
256 + }
257 + audio_info(" ... OUT\n");
258 + return 0;
259 +}
260 +
261 +/* toggles mute on or off depending on the value of nmute, and returns
262 + * 1 if the mute value was changed, otherwise 0
263 + */
264 +static int toggle_mute(struct bcm2835_chip *chip, int nmute)
265 +{
266 + /* if settings are ok, just return 0 */
267 + if(chip->mute == nmute)
268 + return 0;
269 +
270 + /* if the sound is muted then we need to unmute */
271 + if(chip->mute == CTRL_VOL_MUTE)
272 + {
273 + chip->volume = chip->old_volume; /* copy the old volume back */
274 + audio_info("Unmuting, old_volume = %d, volume = %d ...\n", chip->old_volume, chip->volume);
275 + }
276 + else /* otherwise we mute */
277 + {
278 + chip->old_volume = chip->volume;
279 + chip->volume = 26214; /* set volume to minimum level AKA mute */
280 + audio_info("Muting, old_volume = %d, volume = %d ...\n", chip->old_volume, chip->volume);
281 + }
282 +
283 + chip->mute = nmute;
284 + return 1;
285 +}
286 +
287 +static int snd_bcm2835_ctl_get(struct snd_kcontrol *kcontrol,
288 + struct snd_ctl_elem_value *ucontrol)
289 +{
290 + struct bcm2835_chip *chip = snd_kcontrol_chip(kcontrol);
291 +
292 + BUG_ON(!chip && !(chip->avail_substreams & AVAIL_SUBSTREAMS_MASK));
293 +
294 + if (kcontrol->private_value == PCM_PLAYBACK_VOLUME)
295 + ucontrol->value.integer.value[0] = chip2alsa(chip->volume);
296 + else if (kcontrol->private_value == PCM_PLAYBACK_MUTE)
297 + ucontrol->value.integer.value[0] = chip->mute;
298 + else if (kcontrol->private_value == PCM_PLAYBACK_DEVICE)
299 + ucontrol->value.integer.value[0] = chip->dest;
300 +
301 + return 0;
302 +}
303 +
304 +static int snd_bcm2835_ctl_put(struct snd_kcontrol *kcontrol,
305 + struct snd_ctl_elem_value *ucontrol)
306 +{
307 + struct bcm2835_chip *chip = snd_kcontrol_chip(kcontrol);
308 + int changed = 0;
309 +
310 + if (kcontrol->private_value == PCM_PLAYBACK_VOLUME) {
311 + audio_info("Volume change attempted.. volume = %d new_volume = %d\n", chip->volume, (int)ucontrol->value.integer.value[0]);
312 + if (chip->mute == CTRL_VOL_MUTE) {
313 + /* changed = toggle_mute(chip, CTRL_VOL_UNMUTE); */
314 + return 1; /* should return 0 to signify no change but the mixer takes this as the opposite sign (no idea why) */
315 + }
316 + if (changed
317 + || (ucontrol->value.integer.value[0] != chip2alsa(chip->volume))) {
318 +
319 + chip->volume = alsa2chip(ucontrol->value.integer.value[0]);
320 + changed = 1;
321 + }
322 +
323 + } else if (kcontrol->private_value == PCM_PLAYBACK_MUTE) {
324 + /* Now implemented */
325 + audio_info(" Mute attempted\n");
326 + changed = toggle_mute(chip, ucontrol->value.integer.value[0]);
327 +
328 + } else if (kcontrol->private_value == PCM_PLAYBACK_DEVICE) {
329 + if (ucontrol->value.integer.value[0] != chip->dest) {
330 + chip->dest = ucontrol->value.integer.value[0];
331 + changed = 1;
332 + }
333 + }
334 +
335 + if (changed) {
336 + if (bcm2835_audio_set_ctls(chip))
337 + printk(KERN_ERR "Failed to set ALSA controls..\n");
338 + }
339 +
340 + return changed;
341 +}
342 +
343 +static DECLARE_TLV_DB_SCALE(snd_bcm2835_db_scale, CTRL_VOL_MIN, 1, 1);
344 +
345 +static struct snd_kcontrol_new snd_bcm2835_ctl[] = {
346 + {
347 + .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
348 + .name = "PCM Playback Volume",
349 + .index = 0,
350 + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,
351 + .private_value = PCM_PLAYBACK_VOLUME,
352 + .info = snd_bcm2835_ctl_info,
353 + .get = snd_bcm2835_ctl_get,
354 + .put = snd_bcm2835_ctl_put,
355 + .count = 1,
356 + .tlv = {.p = snd_bcm2835_db_scale}
357 + },
358 + {
359 + .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
360 + .name = "PCM Playback Switch",
361 + .index = 0,
362 + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
363 + .private_value = PCM_PLAYBACK_MUTE,
364 + .info = snd_bcm2835_ctl_info,
365 + .get = snd_bcm2835_ctl_get,
366 + .put = snd_bcm2835_ctl_put,
367 + .count = 1,
368 + },
369 + {
370 + .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
371 + .name = "PCM Playback Route",
372 + .index = 0,
373 + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
374 + .private_value = PCM_PLAYBACK_DEVICE,
375 + .info = snd_bcm2835_ctl_info,
376 + .get = snd_bcm2835_ctl_get,
377 + .put = snd_bcm2835_ctl_put,
378 + .count = 1,
379 + },
380 +};
381 +
382 +int snd_bcm2835_new_ctl(bcm2835_chip_t * chip)
383 +{
384 + int err;
385 + unsigned int idx;
386 +
387 + strcpy(chip->card->mixername, "Broadcom Mixer");
388 + for (idx = 0; idx < ARRAY_SIZE(snd_bcm2835_ctl); idx++) {
389 + err =
390 + snd_ctl_add(chip->card,
391 + snd_ctl_new1(&snd_bcm2835_ctl[idx], chip));
392 + if (err < 0)
393 + return err;
394 + }
395 + return 0;
396 +}
397 diff --git a/sound/arm/bcm2835-pcm.c b/sound/arm/bcm2835-pcm.c
398 new file mode 100755
399 index 0000000..2e7d405
400 --- /dev/null
401 +++ b/sound/arm/bcm2835-pcm.c
402 @@ -0,0 +1,409 @@
403 +/*****************************************************************************
404 +* Copyright 2011 Broadcom Corporation. All rights reserved.
405 +*
406 +* Unless you and Broadcom execute a separate written software license
407 +* agreement governing use of this software, this software is licensed to you
408 +* under the terms of the GNU General Public License version 2, available at
409 +* http://www.broadcom.com/licenses/GPLv2.php (the "GPL").
410 +*
411 +* Notwithstanding the above, under no circumstances may you combine this
412 +* software in any way with any other Broadcom software provided under a
413 +* license other than the GPL, without Broadcom's express prior written
414 +* consent.
415 +*****************************************************************************/
416 +
417 +#include <linux/interrupt.h>
418 +#include <linux/slab.h>
419 +
420 +#include "bcm2835.h"
421 +
422 +/* hardware definition */
423 +static struct snd_pcm_hardware snd_bcm2835_playback_hw = {
424 + .info = (SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER),
425 + .formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE,
426 + .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
427 + .rate_min = 8000,
428 + .rate_max = 48000,
429 + .channels_min = 1,
430 + .channels_max = 2,
431 + .buffer_bytes_max = 128 * 1024,
432 + .period_bytes_min = 1 * 1024,
433 + .period_bytes_max = 128 * 1024,
434 + .periods_min = 1,
435 + .periods_max = 128,
436 +};
437 +
438 +static void snd_bcm2835_playback_free(struct snd_pcm_runtime *runtime)
439 +{
440 + audio_info("Freeing up alsa stream here ..\n");
441 + if (runtime->private_data)
442 + kfree(runtime->private_data);
443 + runtime->private_data = NULL;
444 +}
445 +
446 +static irqreturn_t bcm2835_playback_fifo_irq(int irq, void *dev_id)
447 +{
448 + bcm2835_alsa_stream_t *alsa_stream = (bcm2835_alsa_stream_t *) dev_id;
449 + uint32_t consumed = 0;
450 + int new_period = 0;
451 +
452 + audio_info(" .. IN\n");
453 +
454 + audio_info("alsa_stream=%p substream=%p\n", alsa_stream,
455 + alsa_stream ? alsa_stream->substream : 0);
456 +
457 + if (alsa_stream->open)
458 + consumed = bcm2835_audio_retrieve_buffers(alsa_stream);
459 +
460 + /* We get called only if playback was triggered, So, the number of buffers we retrieve in
461 + * each iteration are the buffers that have been played out already
462 + */
463 +
464 + if (alsa_stream->period_size) {
465 + if ((alsa_stream->pos / alsa_stream->period_size) !=
466 + ((alsa_stream->pos + consumed) / alsa_stream->period_size))
467 + new_period = 1;
468 + }
469 + audio_debug("updating pos cur: %d + %d max:%d period_bytes:%d, hw_ptr: %d new_period:%d\n",
470 + alsa_stream->pos,
471 + consumed,
472 + alsa_stream->buffer_size,
473 + (int)(alsa_stream->period_size*alsa_stream->substream->runtime->periods),
474 + frames_to_bytes(alsa_stream->substream->runtime, alsa_stream->substream->runtime->status->hw_ptr),
475 + new_period);
476 + if (alsa_stream->buffer_size) {
477 + alsa_stream->pos += consumed &~ (1<<30);
478 + alsa_stream->pos %= alsa_stream->buffer_size;
479 + }
480 +
481 + if (alsa_stream->substream) {
482 + if (new_period)
483 + snd_pcm_period_elapsed(alsa_stream->substream);
484 + } else {
485 + audio_warning(" unexpected NULL substream\n");
486 + }
487 + audio_info(" .. OUT\n");
488 +
489 + return IRQ_HANDLED;
490 +}
491 +
492 +/* open callback */
493 +static int snd_bcm2835_playback_open(struct snd_pcm_substream *substream)
494 +{
495 + bcm2835_chip_t *chip = snd_pcm_substream_chip(substream);
496 + struct snd_pcm_runtime *runtime = substream->runtime;
497 + bcm2835_alsa_stream_t *alsa_stream;
498 + int idx;
499 + int err;
500 +
501 + audio_info(" .. IN (%d)\n", substream->number);
502 +
503 + audio_info("Alsa open (%d)\n", substream->number);
504 + idx = substream->number;
505 +
506 + if (idx > MAX_SUBSTREAMS) {
507 + audio_error
508 + ("substream(%d) device doesn't exist max(%d) substreams allowed\n",
509 + idx, MAX_SUBSTREAMS);
510 + err = -ENODEV;
511 + goto out;
512 + }
513 +
514 + /* Check if we are ready */
515 + if (!(chip->avail_substreams & (1 << idx))) {
516 + /* We are not ready yet */
517 + audio_error("substream(%d) device is not ready yet\n", idx);
518 + err = -EAGAIN;
519 + goto out;
520 + }
521 +
522 + alsa_stream = kzalloc(sizeof(bcm2835_alsa_stream_t), GFP_KERNEL);
523 + if (alsa_stream == NULL) {
524 + return -ENOMEM;
525 + }
526 +
527 + /* Initialise alsa_stream */
528 + alsa_stream->chip = chip;
529 + alsa_stream->substream = substream;
530 + alsa_stream->idx = idx;
531 +
532 + sema_init(&alsa_stream->buffers_update_sem, 0);
533 + sema_init(&alsa_stream->control_sem, 0);
534 + spin_lock_init(&alsa_stream->lock);
535 +
536 + /* Enabled in start trigger, called on each "fifo irq" after that */
537 + alsa_stream->enable_fifo_irq = 0;
538 + alsa_stream->fifo_irq_handler = bcm2835_playback_fifo_irq;
539 +
540 + err = bcm2835_audio_open(alsa_stream);
541 + if (err != 0) {
542 + kfree(alsa_stream);
543 + return err;
544 + }
545 + runtime->private_data = alsa_stream;
546 + runtime->private_free = snd_bcm2835_playback_free;
547 + runtime->hw = snd_bcm2835_playback_hw;
548 + /* minimum 16 bytes alignment (for vchiq bulk transfers) */
549 + snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
550 + 16);
551 +
552 + chip->alsa_stream[idx] = alsa_stream;
553 +
554 + alsa_stream->open = 1;
555 + alsa_stream->draining = 1;
556 +
557 +out:
558 + audio_info(" .. OUT =%d\n", err);
559 +
560 + return err;
561 +}
562 +
563 +/* close callback */
564 +static int snd_bcm2835_playback_close(struct snd_pcm_substream *substream)
565 +{
566 + /* the hardware-specific codes will be here */
567 +
568 + struct snd_pcm_runtime *runtime = substream->runtime;
569 + bcm2835_alsa_stream_t *alsa_stream = runtime->private_data;
570 +
571 + audio_info(" .. IN\n");
572 + audio_info("Alsa close\n");
573 +
574 + /*
575 + * Call stop if it's still running. This happens when app
576 + * is force killed and we don't get a stop trigger.
577 + */
578 + if (alsa_stream->running) {
579 + int err;
580 + err = bcm2835_audio_stop(alsa_stream);
581 + alsa_stream->running = 0;
582 + if (err != 0)
583 + audio_error(" Failed to STOP alsa device\n");
584 + }
585 +
586 + alsa_stream->period_size = 0;
587 + alsa_stream->buffer_size = 0;
588 +
589 + if (alsa_stream->open) {
590 + alsa_stream->open = 0;
591 + bcm2835_audio_close(alsa_stream);
592 + }
593 + if (alsa_stream->chip)
594 + alsa_stream->chip->alsa_stream[alsa_stream->idx] = NULL;
595 + /*
596 + * Do not free up alsa_stream here, it will be freed up by
597 + * runtime->private_free callback we registered in *_open above
598 + */
599 +
600 + audio_info(" .. OUT\n");
601 +
602 + return 0;
603 +}
604 +
605 +/* hw_params callback */
606 +static int snd_bcm2835_pcm_hw_params(struct snd_pcm_substream *substream,
607 + struct snd_pcm_hw_params *params)
608 +{
609 + int err;
610 + struct snd_pcm_runtime *runtime = substream->runtime;
611 + bcm2835_alsa_stream_t *alsa_stream =
612 + (bcm2835_alsa_stream_t *) runtime->private_data;
613 +
614 + audio_info(" .. IN\n");
615 +
616 + err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));
617 + if (err < 0) {
618 + audio_error
619 + (" pcm_lib_malloc failed to allocated pages for buffers\n");
620 + return err;
621 + }
622 +
623 + err = bcm2835_audio_set_params(alsa_stream, params_channels(params),
624 + params_rate(params),
625 + snd_pcm_format_width(params_format
626 + (params)));
627 + if (err < 0) {
628 + audio_error(" error setting hw params\n");
629 + }
630 +
631 + bcm2835_audio_setup(alsa_stream);
632 +
633 + /* in preparation of the stream, set the controls (volume level) of the stream */
634 + bcm2835_audio_set_ctls(alsa_stream->chip);
635 +
636 + audio_info(" .. OUT\n");
637 +
638 + return err;
639 +}
640 +
641 +/* hw_free callback */
642 +static int snd_bcm2835_pcm_hw_free(struct snd_pcm_substream *substream)
643 +{
644 + audio_info(" .. IN\n");
645 + return snd_pcm_lib_free_pages(substream);
646 +}
647 +
648 +/* prepare callback */
649 +static int snd_bcm2835_pcm_prepare(struct snd_pcm_substream *substream)
650 +{
651 + struct snd_pcm_runtime *runtime = substream->runtime;
652 + bcm2835_alsa_stream_t *alsa_stream = runtime->private_data;
653 +
654 + audio_info(" .. IN\n");
655 +
656 + alsa_stream->buffer_size = snd_pcm_lib_buffer_bytes(substream);
657 + alsa_stream->period_size = snd_pcm_lib_period_bytes(substream);
658 + alsa_stream->pos = 0;
659 +
660 + audio_debug("buffer_size=%d, period_size=%d pos=%d frame_bits=%d\n",
661 + alsa_stream->buffer_size, alsa_stream->period_size,
662 + alsa_stream->pos, runtime->frame_bits);
663 +
664 + audio_info(" .. OUT\n");
665 + return 0;
666 +}
667 +
668 +/* trigger callback */
669 +static int snd_bcm2835_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
670 +{
671 + struct snd_pcm_runtime *runtime = substream->runtime;
672 + bcm2835_alsa_stream_t *alsa_stream = runtime->private_data;
673 + int err = 0;
674 +
675 + audio_info(" .. IN\n");
676 +
677 + switch (cmd) {
678 + case SNDRV_PCM_TRIGGER_START:
679 + audio_debug("bcm2835_AUDIO_TRIGGER_START running=%d\n",
680 + alsa_stream->running);
681 + if (!alsa_stream->running) {
682 + err = bcm2835_audio_start(alsa_stream);
683 + if (err == 0) {
684 + alsa_stream->running = 1;
685 + alsa_stream->draining = 1;
686 + } else {
687 + audio_error(" Failed to START alsa device (%d)\n", err);
688 + }
689 + }
690 + break;
691 + case SNDRV_PCM_TRIGGER_STOP:
692 + audio_debug
693 + ("bcm2835_AUDIO_TRIGGER_STOP running=%d draining=%d\n",
694 + alsa_stream->running, runtime->status->state == SNDRV_PCM_STATE_DRAINING);
695 + if (runtime->status->state == SNDRV_PCM_STATE_DRAINING) {
696 + audio_info("DRAINING\n");
697 + alsa_stream->draining = 1;
698 + } else {
699 + audio_info("DROPPING\n");
700 + alsa_stream->draining = 0;
701 + }
702 + if (alsa_stream->running) {
703 + err = bcm2835_audio_stop(alsa_stream);
704 + if (err != 0)
705 + audio_error(" Failed to STOP alsa device (%d)\n", err);
706 + alsa_stream->running = 0;
707 + }
708 + break;
709 + default:
710 + err = -EINVAL;
711 + }
712 +
713 + audio_info(" .. OUT\n");
714 + return err;
715 +}
716 +
717 +/* pointer callback */
718 +static snd_pcm_uframes_t
719 +snd_bcm2835_pcm_pointer(struct snd_pcm_substream *substream)
720 +{
721 + struct snd_pcm_runtime *runtime = substream->runtime;
722 + bcm2835_alsa_stream_t *alsa_stream = runtime->private_data;
723 +
724 + audio_info(" .. IN\n");
725 +
726 + audio_debug("pcm_pointer... (%d) hwptr=%d appl=%d pos=%d\n", 0,
727 + frames_to_bytes(runtime, runtime->status->hw_ptr),
728 + frames_to_bytes(runtime, runtime->control->appl_ptr),
729 + alsa_stream->pos);
730 +
731 + audio_info(" .. OUT\n");
732 + return bytes_to_frames(runtime, alsa_stream->pos);
733 +}
734 +
735 +static int snd_bcm2835_pcm_copy(struct snd_pcm_substream *substream,
736 + int channel, snd_pcm_uframes_t pos, void *src,
737 + snd_pcm_uframes_t count)
738 +{
739 + int ret;
740 + struct snd_pcm_runtime *runtime = substream->runtime;
741 + bcm2835_alsa_stream_t *alsa_stream = runtime->private_data;
742 +
743 + audio_info(" .. IN\n");
744 + audio_debug("copy.......... (%d) hwptr=%d appl=%d pos=%d\n",
745 + frames_to_bytes(runtime, count), frames_to_bytes(runtime,
746 + runtime->
747 + status->
748 + hw_ptr),
749 + frames_to_bytes(runtime, runtime->control->appl_ptr),
750 + alsa_stream->pos);
751 + ret =
752 + bcm2835_audio_write(alsa_stream, frames_to_bytes(runtime, count),
753 + src);
754 + audio_info(" .. OUT\n");
755 + return ret;
756 +}
757 +
758 +static int snd_bcm2835_pcm_lib_ioctl(struct snd_pcm_substream *substream,
759 + unsigned int cmd, void *arg)
760 +{
761 + int ret = snd_pcm_lib_ioctl(substream, cmd, arg);
762 + audio_info(" .. substream=%p, cmd=%d, arg=%p (%x) ret=%d\n", substream,
763 + cmd, arg, arg ? *(unsigned *)arg : 0, ret);
764 + return ret;
765 +}
766 +
767 +/* operators */
768 +static struct snd_pcm_ops snd_bcm2835_playback_ops = {
769 + .open = snd_bcm2835_playback_open,
770 + .close = snd_bcm2835_playback_close,
771 + .ioctl = snd_bcm2835_pcm_lib_ioctl,
772 + .hw_params = snd_bcm2835_pcm_hw_params,
773 + .hw_free = snd_bcm2835_pcm_hw_free,
774 + .prepare = snd_bcm2835_pcm_prepare,
775 + .trigger = snd_bcm2835_pcm_trigger,
776 + .pointer = snd_bcm2835_pcm_pointer,
777 + .copy = snd_bcm2835_pcm_copy,
778 +};
779 +
780 +/* create a pcm device */
781 +int snd_bcm2835_new_pcm(bcm2835_chip_t * chip)
782 +{
783 + struct snd_pcm *pcm;
784 + int err;
785 +
786 + audio_info(" .. IN\n");
787 + err =
788 + snd_pcm_new(chip->card, "bcm2835 ALSA", 0, MAX_SUBSTREAMS, 0, &pcm);
789 + if (err < 0)
790 + return err;
791 + pcm->private_data = chip;
792 + strcpy(pcm->name, "bcm2835 ALSA");
793 + chip->pcm = pcm;
794 + chip->dest = AUDIO_DEST_AUTO;
795 + chip->volume = alsa2chip(0);
796 + chip->mute = CTRL_VOL_UNMUTE; /*disable mute on startup */
797 + /* set operators */
798 + snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
799 + &snd_bcm2835_playback_ops);
800 +
801 + /* pre-allocation of buffers */
802 + /* NOTE: this may fail */
803 + snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
804 + snd_dma_continuous_data
805 + (GFP_KERNEL), 64 * 1024,
806 + 64 * 1024);
807 +
808 + audio_info(" .. OUT\n");
809 +
810 + return 0;
811 +}
812 diff --git a/sound/arm/bcm2835-vchiq.c b/sound/arm/bcm2835-vchiq.c
813 new file mode 100755
814 index 0000000..b9b4fe8
815 --- /dev/null
816 +++ b/sound/arm/bcm2835-vchiq.c
817 @@ -0,0 +1,844 @@
818 +/*****************************************************************************
819 +* Copyright 2011 Broadcom Corporation. All rights reserved.
820 +*
821 +* Unless you and Broadcom execute a separate written software license
822 +* agreement governing use of this software, this software is licensed to you
823 +* under the terms of the GNU General Public License version 2, available at
824 +* http://www.broadcom.com/licenses/GPLv2.php (the "GPL").
825 +*
826 +* Notwithstanding the above, under no circumstances may you combine this
827 +* software in any way with any other Broadcom software provided under a
828 +* license other than the GPL, without Broadcom's express prior written
829 +* consent.
830 +*****************************************************************************/
831 +
832 +#include <linux/device.h>
833 +#include <sound/core.h>
834 +#include <sound/initval.h>
835 +#include <sound/pcm.h>
836 +#include <linux/io.h>
837 +#include <linux/interrupt.h>
838 +#include <linux/fs.h>
839 +#include <linux/file.h>
840 +#include <linux/mm.h>
841 +#include <linux/syscalls.h>
842 +#include <asm/uaccess.h>
843 +#include <linux/slab.h>
844 +#include <linux/delay.h>
845 +#include <linux/atomic.h>
846 +#include <linux/module.h>
847 +
848 +#include "bcm2835.h"
849 +
850 +/* ---- Include Files -------------------------------------------------------- */
851 +
852 +#include "interface/vchi/vchi.h"
853 +#include "vc_vchi_audioserv_defs.h"
854 +
855 +/* ---- Private Constants and Types ------------------------------------------ */
856 +
857 +/* Logging macros (for remapping to other logging mechanisms, i.e., printf) */
858 +#ifdef AUDIO_DEBUG_ENABLE
859 + #define LOG_ERR( fmt, arg... ) pr_err( "%s:%d " fmt, __func__, __LINE__, ##arg)
860 + #define LOG_WARN( fmt, arg... ) pr_info( "%s:%d " fmt, __func__, __LINE__, ##arg)
861 + #define LOG_INFO( fmt, arg... ) pr_info( "%s:%d " fmt, __func__, __LINE__, ##arg)
862 + #define LOG_DBG( fmt, arg... ) pr_info( "%s:%d " fmt, __func__, __LINE__, ##arg)
863 +#else
864 + #define LOG_ERR( fmt, arg... ) pr_err( "%s:%d " fmt, __func__, __LINE__, ##arg)
865 + #define LOG_WARN( fmt, arg... )
866 + #define LOG_INFO( fmt, arg... )
867 + #define LOG_DBG( fmt, arg... )
868 +#endif
869 +
870 +typedef struct opaque_AUDIO_INSTANCE_T {
871 + uint32_t num_connections;
872 + VCHI_SERVICE_HANDLE_T vchi_handle[VCHI_MAX_NUM_CONNECTIONS];
873 + struct semaphore msg_avail_event;
874 + struct mutex vchi_mutex;
875 + bcm2835_alsa_stream_t *alsa_stream;
876 + int32_t result;
877 + short peer_version;
878 +} AUDIO_INSTANCE_T;
879 +
880 +bool force_bulk = false;
881 +
882 +/* ---- Private Variables ---------------------------------------------------- */
883 +
884 +/* ---- Private Function Prototypes ------------------------------------------ */
885 +
886 +/* ---- Private Functions ---------------------------------------------------- */
887 +
888 +static int bcm2835_audio_stop_worker(bcm2835_alsa_stream_t * alsa_stream);
889 +static int bcm2835_audio_start_worker(bcm2835_alsa_stream_t * alsa_stream);
890 +
891 +typedef struct {
892 + struct work_struct my_work;
893 + bcm2835_alsa_stream_t *alsa_stream;
894 + int x;
895 +} my_work_t;
896 +
897 +static void my_wq_function(struct work_struct *work)
898 +{
899 + my_work_t *w = (my_work_t *) work;
900 + int ret = -9;
901 + LOG_DBG(" .. IN %p:%d\n", w->alsa_stream, w->x);
902 + switch (w->x) {
903 + case 1:
904 + ret = bcm2835_audio_start_worker(w->alsa_stream);
905 + break;
906 + case 2:
907 + ret = bcm2835_audio_stop_worker(w->alsa_stream);
908 + break;
909 + default:
910 + LOG_ERR(" Unexpected work: %p:%d\n", w->alsa_stream, w->x);
911 + break;
912 + }
913 + kfree((void *)work);
914 + LOG_DBG(" .. OUT %d\n", ret);
915 +}
916 +
917 +int bcm2835_audio_start(bcm2835_alsa_stream_t * alsa_stream)
918 +{
919 + int ret = -1;
920 + LOG_DBG(" .. IN\n");
921 + if (alsa_stream->my_wq) {
922 + my_work_t *work = kmalloc(sizeof(my_work_t), GFP_ATOMIC);
923 + /*--- Queue some work (item 1) ---*/
924 + if (work) {
925 + INIT_WORK((struct work_struct *)work, my_wq_function);
926 + work->alsa_stream = alsa_stream;
927 + work->x = 1;
928 + if (queue_work
929 + (alsa_stream->my_wq, (struct work_struct *)work))
930 + ret = 0;
931 + } else
932 + LOG_ERR(" .. Error: NULL work kmalloc\n");
933 + }
934 + LOG_DBG(" .. OUT %d\n", ret);
935 + return ret;
936 +}
937 +
938 +int bcm2835_audio_stop(bcm2835_alsa_stream_t * alsa_stream)
939 +{
940 + int ret = -1;
941 + LOG_DBG(" .. IN\n");
942 + if (alsa_stream->my_wq) {
943 + my_work_t *work = kmalloc(sizeof(my_work_t), GFP_ATOMIC);
944 + /*--- Queue some work (item 1) ---*/
945 + if (work) {
946 + INIT_WORK((struct work_struct *)work, my_wq_function);
947 + work->alsa_stream = alsa_stream;
948 + work->x = 2;
949 + if (queue_work
950 + (alsa_stream->my_wq, (struct work_struct *)work))
951 + ret = 0;
952 + } else
953 + LOG_ERR(" .. Error: NULL work kmalloc\n");
954 + }
955 + LOG_DBG(" .. OUT %d\n", ret);
956 + return ret;
957 +}
958 +
959 +void my_workqueue_init(bcm2835_alsa_stream_t * alsa_stream)
960 +{
961 + alsa_stream->my_wq = alloc_workqueue("my_queue", WQ_HIGHPRI, 1);
962 + return;
963 +}
964 +
965 +void my_workqueue_quit(bcm2835_alsa_stream_t * alsa_stream)
966 +{
967 + if (alsa_stream->my_wq) {
968 + flush_workqueue(alsa_stream->my_wq);
969 + destroy_workqueue(alsa_stream->my_wq);
970 + alsa_stream->my_wq = NULL;
971 + }
972 + return;
973 +}
974 +
975 +static void audio_vchi_callback(void *param,
976 + const VCHI_CALLBACK_REASON_T reason,
977 + void *msg_handle)
978 +{
979 + AUDIO_INSTANCE_T *instance = (AUDIO_INSTANCE_T *) param;
980 + int32_t status;
981 + int32_t msg_len;
982 + VC_AUDIO_MSG_T m;
983 + bcm2835_alsa_stream_t *alsa_stream = 0;
984 + LOG_DBG(" .. IN instance=%p, param=%p, reason=%d, handle=%p\n",
985 + instance, param, reason, msg_handle);
986 +
987 + if (!instance || reason != VCHI_CALLBACK_MSG_AVAILABLE) {
988 + return;
989 + }
990 + alsa_stream = instance->alsa_stream;
991 + status = vchi_msg_dequeue(instance->vchi_handle[0],
992 + &m, sizeof m, &msg_len, VCHI_FLAGS_NONE);
993 + if (m.type == VC_AUDIO_MSG_TYPE_RESULT) {
994 + LOG_DBG
995 + (" .. instance=%p, m.type=VC_AUDIO_MSG_TYPE_RESULT, success=%d\n",
996 + instance, m.u.result.success);
997 + instance->result = m.u.result.success;
998 + up(&instance->msg_avail_event);
999 + } else if (m.type == VC_AUDIO_MSG_TYPE_COMPLETE) {
1000 + irq_handler_t callback = (irq_handler_t) m.u.complete.callback;
1001 + LOG_DBG
1002 + (" .. instance=%p, m.type=VC_AUDIO_MSG_TYPE_COMPLETE, complete=%d\n",
1003 + instance, m.u.complete.count);
1004 + if (alsa_stream && callback) {
1005 + atomic_add(m.u.complete.count, &alsa_stream->retrieved);
1006 + callback(0, alsa_stream);
1007 + } else {
1008 + LOG_DBG(" .. unexpected alsa_stream=%p, callback=%p\n",
1009 + alsa_stream, callback);
1010 + }
1011 + } else {
1012 + LOG_DBG(" .. unexpected m.type=%d\n", m.type);
1013 + }
1014 + LOG_DBG(" .. OUT\n");
1015 +}
1016 +
1017 +static AUDIO_INSTANCE_T *vc_vchi_audio_init(VCHI_INSTANCE_T vchi_instance,
1018 + VCHI_CONNECTION_T **
1019 + vchi_connections,
1020 + uint32_t num_connections)
1021 +{
1022 + uint32_t i;
1023 + AUDIO_INSTANCE_T *instance;
1024 + int status;
1025 +
1026 + LOG_DBG("%s: start", __func__);
1027 +
1028 + if (num_connections > VCHI_MAX_NUM_CONNECTIONS) {
1029 + LOG_ERR("%s: unsupported number of connections %u (max=%u)\n",
1030 + __func__, num_connections, VCHI_MAX_NUM_CONNECTIONS);
1031 +
1032 + return NULL;
1033 + }
1034 + /* Allocate memory for this instance */
1035 + instance = kmalloc(sizeof(*instance), GFP_KERNEL);
1036 +
1037 + memset(instance, 0, sizeof(*instance));
1038 + instance->num_connections = num_connections;
1039 +
1040 + /* Create a lock for exclusive, serialized VCHI connection access */
1041 + mutex_init(&instance->vchi_mutex);
1042 + /* Open the VCHI service connections */
1043 + for (i = 0; i < num_connections; i++) {
1044 + SERVICE_CREATION_T params = {
1045 + VCHI_VERSION_EX(VC_AUDIOSERV_VER, VC_AUDIOSERV_MIN_VER),
1046 + VC_AUDIO_SERVER_NAME, // 4cc service code
1047 + vchi_connections[i], // passed in fn pointers
1048 + 0, // rx fifo size (unused)
1049 + 0, // tx fifo size (unused)
1050 + audio_vchi_callback, // service callback
1051 + instance, // service callback parameter
1052 + 1, //TODO: remove VCOS_FALSE, // unaligned bulk recieves
1053 + 1, //TODO: remove VCOS_FALSE, // unaligned bulk transmits
1054 + 0 // want crc check on bulk transfers
1055 + };
1056 +
1057 + status = vchi_service_open(vchi_instance, &params,
1058 + &instance->vchi_handle[i]);
1059 + if (status) {
1060 + LOG_ERR
1061 + ("%s: failed to open VCHI service connection (status=%d)\n",
1062 + __func__, status);
1063 +
1064 + goto err_close_services;
1065 + }
1066 + /* Finished with the service for now */
1067 + vchi_service_release(instance->vchi_handle[i]);
1068 + }
1069 +
1070 + return instance;
1071 +
1072 +err_close_services:
1073 + for (i = 0; i < instance->num_connections; i++) {
1074 + vchi_service_close(instance->vchi_handle[i]);
1075 + }
1076 +
1077 + kfree(instance);
1078 +
1079 + return NULL;
1080 +}
1081 +
1082 +static int32_t vc_vchi_audio_deinit(AUDIO_INSTANCE_T * instance)
1083 +{
1084 + uint32_t i;
1085 +
1086 + LOG_DBG(" .. IN\n");
1087 +
1088 + if (instance == NULL) {
1089 + LOG_ERR("%s: invalid handle %p\n", __func__, instance);
1090 +
1091 + return -1;
1092 + }
1093 +
1094 + LOG_DBG(" .. about to lock (%d)\n", instance->num_connections);
1095 + if(mutex_lock_interruptible(&instance->vchi_mutex))
1096 + {
1097 + LOG_DBG("Interrupted whilst waiting for lock on (%d)\n",instance->num_connections);
1098 + return -EINTR;
1099 + }
1100 +
1101 + /* Close all VCHI service connections */
1102 + for (i = 0; i < instance->num_connections; i++) {
1103 + int32_t success;
1104 + LOG_DBG(" .. %i:closing %p\n", i, instance->vchi_handle[i]);
1105 + vchi_service_use(instance->vchi_handle[i]);
1106 +
1107 + success = vchi_service_close(instance->vchi_handle[i]);
1108 + if (success != 0) {
1109 + LOG_ERR
1110 + ("%s: failed to close VCHI service connection (status=%d)\n",
1111 + __func__, success);
1112 + }
1113 + }
1114 +
1115 + mutex_unlock(&instance->vchi_mutex);
1116 +
1117 + kfree(instance);
1118 +
1119 + LOG_DBG(" .. OUT\n");
1120 +
1121 + return 0;
1122 +}
1123 +
1124 +static int bcm2835_audio_open_connection(bcm2835_alsa_stream_t * alsa_stream)
1125 +{
1126 + static VCHI_INSTANCE_T vchi_instance;
1127 + static VCHI_CONNECTION_T *vchi_connection;
1128 + AUDIO_INSTANCE_T *instance = alsa_stream->instance;
1129 + int ret;
1130 + LOG_DBG(" .. IN\n");
1131 +
1132 + LOG_INFO("%s: start", __func__);
1133 + //BUG_ON(instance);
1134 + if (instance) {
1135 + LOG_ERR("%s: VCHI instance already open (%p)\n",
1136 + __func__, instance);
1137 + instance->alsa_stream = alsa_stream;
1138 + alsa_stream->instance = instance;
1139 + ret = 0; // xxx todo -1;
1140 + goto err_free_mem;
1141 + }
1142 +
1143 + /* Initialize and create a VCHI connection */
1144 + ret = vchi_initialise(&vchi_instance);
1145 + if (ret != 0) {
1146 + LOG_ERR("%s: failed to initialise VCHI instance (ret=%d)\n",
1147 + __func__, ret);
1148 +
1149 + ret = -EIO;
1150 + goto err_free_mem;
1151 + }
1152 + ret = vchi_connect(NULL, 0, vchi_instance);
1153 + if (ret != 0) {
1154 + LOG_ERR("%s: failed to connect VCHI instance (ret=%d)\n",
1155 + __func__, ret);
1156 +
1157 + ret = -EIO;
1158 + goto err_free_mem;
1159 + }
1160 +
1161 + /* Initialize an instance of the audio service */
1162 + instance = vc_vchi_audio_init(vchi_instance, &vchi_connection, 1);
1163 +
1164 + if (instance == NULL /*|| audio_handle != instance */ ) {
1165 + LOG_ERR("%s: failed to initialize audio service\n", __func__);
1166 +
1167 + ret = -EPERM;
1168 + goto err_free_mem;
1169 + }
1170 +
1171 + instance->alsa_stream = alsa_stream;
1172 + alsa_stream->instance = instance;
1173 +
1174 + LOG_DBG(" success !\n");
1175 +err_free_mem:
1176 + LOG_DBG(" .. OUT\n");
1177 +
1178 + return ret;
1179 +}
1180 +
1181 +int bcm2835_audio_open(bcm2835_alsa_stream_t * alsa_stream)
1182 +{
1183 + AUDIO_INSTANCE_T *instance;
1184 + VC_AUDIO_MSG_T m;
1185 + int32_t success;
1186 + int ret;
1187 + LOG_DBG(" .. IN\n");
1188 +
1189 + my_workqueue_init(alsa_stream);
1190 +
1191 + ret = bcm2835_audio_open_connection(alsa_stream);
1192 + if (ret != 0) {
1193 + ret = -1;
1194 + goto exit;
1195 + }
1196 + instance = alsa_stream->instance;
1197 +
1198 + if(mutex_lock_interruptible(&instance->vchi_mutex))
1199 + {
1200 + LOG_DBG("Interrupted whilst waiting for lock on (%d)\n",instance->num_connections);
1201 + return -EINTR;
1202 + }
1203 + vchi_service_use(instance->vchi_handle[0]);
1204 +
1205 + m.type = VC_AUDIO_MSG_TYPE_OPEN;
1206 +
1207 + /* Send the message to the videocore */
1208 + success = vchi_msg_queue(instance->vchi_handle[0],
1209 + &m, sizeof m,
1210 + VCHI_FLAGS_BLOCK_UNTIL_QUEUED, NULL);
1211 +
1212 + if (success != 0) {
1213 + LOG_ERR("%s: failed on vchi_msg_queue (status=%d)\n",
1214 + __func__, success);
1215 +
1216 + ret = -1;
1217 + goto unlock;
1218 + }
1219 +
1220 + ret = 0;
1221 +
1222 +unlock:
1223 + vchi_service_release(instance->vchi_handle[0]);
1224 + mutex_unlock(&instance->vchi_mutex);
1225 +exit:
1226 + LOG_DBG(" .. OUT\n");
1227 + return ret;
1228 +}
1229 +
1230 +static int bcm2835_audio_set_ctls_chan(bcm2835_alsa_stream_t * alsa_stream,
1231 + bcm2835_chip_t * chip)
1232 +{
1233 + VC_AUDIO_MSG_T m;
1234 + AUDIO_INSTANCE_T *instance = alsa_stream->instance;
1235 + int32_t success;
1236 + int ret;
1237 + LOG_DBG(" .. IN\n");
1238 +
1239 + LOG_INFO
1240 + (" Setting ALSA dest(%d), volume(%d)\n", chip->dest, chip->volume);
1241 +
1242 + if(mutex_lock_interruptible(&instance->vchi_mutex))
1243 + {
1244 + LOG_DBG("Interrupted whilst waiting for lock on (%d)\n",instance->num_connections);
1245 + return -EINTR;
1246 + }
1247 + vchi_service_use(instance->vchi_handle[0]);
1248 +
1249 + instance->result = -1;
1250 +
1251 + m.type = VC_AUDIO_MSG_TYPE_CONTROL;
1252 + m.u.control.dest = chip->dest;
1253 + m.u.control.volume = chip->volume;
1254 +
1255 + /* Create the message available event */
1256 + sema_init(&instance->msg_avail_event, 0);
1257 +
1258 + /* Send the message to the videocore */
1259 + success = vchi_msg_queue(instance->vchi_handle[0],
1260 + &m, sizeof m,
1261 + VCHI_FLAGS_BLOCK_UNTIL_QUEUED, NULL);
1262 +
1263 + if (success != 0) {
1264 + LOG_ERR("%s: failed on vchi_msg_queue (status=%d)\n",
1265 + __func__, success);
1266 +
1267 + ret = -1;
1268 + goto unlock;
1269 + }
1270 +
1271 + /* We are expecting a reply from the videocore */
1272 + if (down_interruptible(&instance->msg_avail_event)) {
1273 + LOG_ERR("%s: failed on waiting for event (status=%d)\n",
1274 + __func__, success);
1275 +
1276 + ret = -1;
1277 + goto unlock;
1278 + }
1279 +
1280 + if (instance->result != 0) {
1281 + LOG_ERR("%s: result=%d\n", __func__, instance->result);
1282 +
1283 + ret = -1;
1284 + goto unlock;
1285 + }
1286 +
1287 + ret = 0;
1288 +
1289 +unlock:
1290 + vchi_service_release(instance->vchi_handle[0]);
1291 + mutex_unlock(&instance->vchi_mutex);
1292 +
1293 + LOG_DBG(" .. OUT\n");
1294 + return ret;
1295 +}
1296 +
1297 +int bcm2835_audio_set_ctls(bcm2835_chip_t * chip)
1298 +{
1299 + int i;
1300 + int ret = 0;
1301 + LOG_DBG(" .. IN\n");
1302 +
1303 + /* change ctls for all substreams */
1304 + for (i = 0; i < MAX_SUBSTREAMS; i++) {
1305 + if (chip->avail_substreams & (1 << i)) {
1306 + if (!chip->alsa_stream[i])
1307 + {
1308 + LOG_DBG(" No ALSA stream available?! %i:%p (%x)\n", i, chip->alsa_stream[i], chip->avail_substreams);
1309 + ret = 0;
1310 + }
1311 + else if (bcm2835_audio_set_ctls_chan /* returns 0 on success */
1312 + (chip->alsa_stream[i], chip) != 0)
1313 + {
1314 + LOG_DBG("Couldn't set the controls for stream %d\n", i);
1315 + ret = -1;
1316 + }
1317 + else LOG_DBG(" Controls set for stream %d\n", i);
1318 + }
1319 + }
1320 + LOG_DBG(" .. OUT ret=%d\n", ret);
1321 + return ret;
1322 +}
1323 +
1324 +int bcm2835_audio_set_params(bcm2835_alsa_stream_t * alsa_stream,
1325 + uint32_t channels, uint32_t samplerate,
1326 + uint32_t bps)
1327 +{
1328 + VC_AUDIO_MSG_T m;
1329 + AUDIO_INSTANCE_T *instance = alsa_stream->instance;
1330 + int32_t success;
1331 + int ret;
1332 + LOG_DBG(" .. IN\n");
1333 +
1334 + LOG_INFO
1335 + (" Setting ALSA channels(%d), samplerate(%d), bits-per-sample(%d)\n",
1336 + channels, samplerate, bps);
1337 +
1338 + /* resend ctls - alsa_stream may not have been open when first send */
1339 + ret = bcm2835_audio_set_ctls_chan(alsa_stream, alsa_stream->chip);
1340 + if (ret != 0) {
1341 + LOG_ERR(" Alsa controls not supported\n");
1342 + return -EINVAL;
1343 + }
1344 +
1345 + if(mutex_lock_interruptible(&instance->vchi_mutex))
1346 + {
1347 + LOG_DBG("Interrupted whilst waiting for lock on (%d)\n",instance->num_connections);
1348 + return -EINTR;
1349 + }
1350 + vchi_service_use(instance->vchi_handle[0]);
1351 +
1352 + instance->result = -1;
1353 +
1354 + m.type = VC_AUDIO_MSG_TYPE_CONFIG;
1355 + m.u.config.channels = channels;
1356 + m.u.config.samplerate = samplerate;
1357 + m.u.config.bps = bps;
1358 +
1359 + /* Create the message available event */
1360 + sema_init(&instance->msg_avail_event, 0);
1361 +
1362 + /* Send the message to the videocore */
1363 + success = vchi_msg_queue(instance->vchi_handle[0],
1364 + &m, sizeof m,
1365 + VCHI_FLAGS_BLOCK_UNTIL_QUEUED, NULL);
1366 +
1367 + if (success != 0) {
1368 + LOG_ERR("%s: failed on vchi_msg_queue (status=%d)\n",
1369 + __func__, success);
1370 +
1371 + ret = -1;
1372 + goto unlock;
1373 + }
1374 +
1375 + /* We are expecting a reply from the videocore */
1376 + if (down_interruptible(&instance->msg_avail_event)) {
1377 + LOG_ERR("%s: failed on waiting for event (status=%d)\n",
1378 + __func__, success);
1379 +
1380 + ret = -1;
1381 + goto unlock;
1382 + }
1383 +
1384 + if (instance->result != 0) {
1385 + LOG_ERR("%s: result=%d", __func__, instance->result);
1386 +
1387 + ret = -1;
1388 + goto unlock;
1389 + }
1390 +
1391 + ret = 0;
1392 +
1393 +unlock:
1394 + vchi_service_release(instance->vchi_handle[0]);
1395 + mutex_unlock(&instance->vchi_mutex);
1396 +
1397 + LOG_DBG(" .. OUT\n");
1398 + return ret;
1399 +}
1400 +
1401 +int bcm2835_audio_setup(bcm2835_alsa_stream_t * alsa_stream)
1402 +{
1403 + LOG_DBG(" .. IN\n");
1404 +
1405 + LOG_DBG(" .. OUT\n");
1406 +
1407 + return 0;
1408 +}
1409 +
1410 +static int bcm2835_audio_start_worker(bcm2835_alsa_stream_t * alsa_stream)
1411 +{
1412 + VC_AUDIO_MSG_T m;
1413 + AUDIO_INSTANCE_T *instance = alsa_stream->instance;
1414 + int32_t success;
1415 + int ret;
1416 + LOG_DBG(" .. IN\n");
1417 +
1418 + if(mutex_lock_interruptible(&instance->vchi_mutex))
1419 + {
1420 + LOG_DBG("Interrupted whilst waiting for lock on (%d)\n",instance->num_connections);
1421 + return -EINTR;
1422 + }
1423 + vchi_service_use(instance->vchi_handle[0]);
1424 +
1425 + m.type = VC_AUDIO_MSG_TYPE_START;
1426 +
1427 + /* Send the message to the videocore */
1428 + success = vchi_msg_queue(instance->vchi_handle[0],
1429 + &m, sizeof m,
1430 + VCHI_FLAGS_BLOCK_UNTIL_QUEUED, NULL);
1431 +
1432 + if (success != 0) {
1433 + LOG_ERR("%s: failed on vchi_msg_queue (status=%d)",
1434 + __func__, success);
1435 +
1436 + ret = -1;
1437 + goto unlock;
1438 + }
1439 +
1440 + ret = 0;
1441 +
1442 +unlock:
1443 + vchi_service_release(instance->vchi_handle[0]);
1444 + mutex_unlock(&instance->vchi_mutex);
1445 + LOG_DBG(" .. OUT\n");
1446 + return ret;
1447 +}
1448 +
1449 +static int bcm2835_audio_stop_worker(bcm2835_alsa_stream_t * alsa_stream)
1450 +{
1451 + VC_AUDIO_MSG_T m;
1452 + AUDIO_INSTANCE_T *instance = alsa_stream->instance;
1453 + int32_t success;
1454 + int ret;
1455 + LOG_DBG(" .. IN\n");
1456 +
1457 + if(mutex_lock_interruptible(&instance->vchi_mutex))
1458 + {
1459 + LOG_DBG("Interrupted whilst waiting for lock on (%d)\n",instance->num_connections);
1460 + return -EINTR;
1461 + }
1462 + vchi_service_use(instance->vchi_handle[0]);
1463 +
1464 + m.type = VC_AUDIO_MSG_TYPE_STOP;
1465 + m.u.stop.draining = alsa_stream->draining;
1466 +
1467 + /* Send the message to the videocore */
1468 + success = vchi_msg_queue(instance->vchi_handle[0],
1469 + &m, sizeof m,
1470 + VCHI_FLAGS_BLOCK_UNTIL_QUEUED, NULL);
1471 +
1472 + if (success != 0) {
1473 + LOG_ERR("%s: failed on vchi_msg_queue (status=%d)",
1474 + __func__, success);
1475 +
1476 + ret = -1;
1477 + goto unlock;
1478 + }
1479 +
1480 + ret = 0;
1481 +
1482 +unlock:
1483 + vchi_service_release(instance->vchi_handle[0]);
1484 + mutex_unlock(&instance->vchi_mutex);
1485 + LOG_DBG(" .. OUT\n");
1486 + return ret;
1487 +}
1488 +
1489 +int bcm2835_audio_close(bcm2835_alsa_stream_t * alsa_stream)
1490 +{
1491 + VC_AUDIO_MSG_T m;
1492 + AUDIO_INSTANCE_T *instance = alsa_stream->instance;
1493 + int32_t success;
1494 + int ret;
1495 + LOG_DBG(" .. IN\n");
1496 +
1497 + my_workqueue_quit(alsa_stream);
1498 +
1499 + if(mutex_lock_interruptible(&instance->vchi_mutex))
1500 + {
1501 + LOG_DBG("Interrupted whilst waiting for lock on (%d)\n",instance->num_connections);
1502 + return -EINTR;
1503 + }
1504 + vchi_service_use(instance->vchi_handle[0]);
1505 +
1506 + m.type = VC_AUDIO_MSG_TYPE_CLOSE;
1507 +
1508 + /* Create the message available event */
1509 + sema_init(&instance->msg_avail_event, 0);
1510 +
1511 + /* Send the message to the videocore */
1512 + success = vchi_msg_queue(instance->vchi_handle[0],
1513 + &m, sizeof m,
1514 + VCHI_FLAGS_BLOCK_UNTIL_QUEUED, NULL);
1515 +
1516 + if (success != 0) {
1517 + LOG_ERR("%s: failed on vchi_msg_queue (status=%d)",
1518 + __func__, success);
1519 + ret = -1;
1520 + goto unlock;
1521 + }
1522 + if (down_interruptible(&instance->msg_avail_event)) {
1523 + LOG_ERR("%s: failed on waiting for event (status=%d)",
1524 + __func__, success);
1525 +
1526 + ret = -1;
1527 + goto unlock;
1528 + }
1529 + if (instance->result != 0) {
1530 + LOG_ERR("%s: failed result (status=%d)",
1531 + __func__, instance->result);
1532 +
1533 + ret = -1;
1534 + goto unlock;
1535 + }
1536 +
1537 + ret = 0;
1538 +
1539 +unlock:
1540 + vchi_service_release(instance->vchi_handle[0]);
1541 + mutex_unlock(&instance->vchi_mutex);
1542 +
1543 + /* Stop the audio service */
1544 + if (instance) {
1545 + vc_vchi_audio_deinit(instance);
1546 + alsa_stream->instance = NULL;
1547 + }
1548 + LOG_DBG(" .. OUT\n");
1549 + return ret;
1550 +}
1551 +
1552 +int bcm2835_audio_write(bcm2835_alsa_stream_t * alsa_stream, uint32_t count,
1553 + void *src)
1554 +{
1555 + VC_AUDIO_MSG_T m;
1556 + AUDIO_INSTANCE_T *instance = alsa_stream->instance;
1557 + int32_t success;
1558 + int ret;
1559 +
1560 + LOG_DBG(" .. IN\n");
1561 +
1562 + LOG_INFO(" Writing %d bytes from %p\n", count, src);
1563 +
1564 + if(mutex_lock_interruptible(&instance->vchi_mutex))
1565 + {
1566 + LOG_DBG("Interrupted whilst waiting for lock on (%d)\n",instance->num_connections);
1567 + return -EINTR;
1568 + }
1569 + vchi_service_use(instance->vchi_handle[0]);
1570 +
1571 + if ( instance->peer_version==0 && vchi_get_peer_version(instance->vchi_handle[0], &instance->peer_version) == 0 ) {
1572 + LOG_DBG("%s: client version %d connected\n", __func__, instance->peer_version);
1573 + }
1574 + m.type = VC_AUDIO_MSG_TYPE_WRITE;
1575 + m.u.write.count = count;
1576 + // old version uses bulk, new version uses control
1577 + m.u.write.max_packet = instance->peer_version < 2 || force_bulk ? 0:4000;
1578 + m.u.write.callback = alsa_stream->fifo_irq_handler;
1579 + m.u.write.cookie = alsa_stream;
1580 + m.u.write.silence = src == NULL;
1581 +
1582 + /* Send the message to the videocore */
1583 + success = vchi_msg_queue(instance->vchi_handle[0],
1584 + &m, sizeof m,
1585 + VCHI_FLAGS_BLOCK_UNTIL_QUEUED, NULL);
1586 +
1587 + if (success != 0) {
1588 + LOG_ERR("%s: failed on vchi_msg_queue (status=%d)",
1589 + __func__, success);
1590 +
1591 + ret = -1;
1592 + goto unlock;
1593 + }
1594 + if (!m.u.write.silence) {
1595 + if (m.u.write.max_packet == 0) {
1596 + /* Send the message to the videocore */
1597 + success = vchi_bulk_queue_transmit(instance->vchi_handle[0],
1598 + src, count,
1599 + 0 *
1600 + VCHI_FLAGS_BLOCK_UNTIL_QUEUED
1601 + +
1602 + 1 *
1603 + VCHI_FLAGS_BLOCK_UNTIL_DATA_READ,
1604 + NULL);
1605 + } else {
1606 + while (count > 0) {
1607 + int bytes = min((int)m.u.write.max_packet, (int)count);
1608 + success = vchi_msg_queue(instance->vchi_handle[0],
1609 + src, bytes,
1610 + VCHI_FLAGS_BLOCK_UNTIL_QUEUED, NULL);
1611 + src = (char *)src + bytes;
1612 + count -= bytes;
1613 + }
1614 + }
1615 + if (success != 0) {
1616 + LOG_ERR
1617 + ("%s: failed on vchi_bulk_queue_transmit (status=%d)",
1618 + __func__, success);
1619 +
1620 + ret = -1;
1621 + goto unlock;
1622 + }
1623 + }
1624 + ret = 0;
1625 +
1626 +unlock:
1627 + vchi_service_release(instance->vchi_handle[0]);
1628 + mutex_unlock(&instance->vchi_mutex);
1629 + LOG_DBG(" .. OUT\n");
1630 + return ret;
1631 +}
1632 +
1633 +/**
1634 + * Returns all buffers from arm->vc
1635 + */
1636 +void bcm2835_audio_flush_buffers(bcm2835_alsa_stream_t * alsa_stream)
1637 +{
1638 + LOG_DBG(" .. IN\n");
1639 + LOG_DBG(" .. OUT\n");
1640 + return;
1641 +}
1642 +
1643 +/**
1644 + * Forces VC to flush(drop) its filled playback buffers and
1645 + * return them the us. (VC->ARM)
1646 + */
1647 +void bcm2835_audio_flush_playback_buffers(bcm2835_alsa_stream_t * alsa_stream)
1648 +{
1649 + LOG_DBG(" .. IN\n");
1650 + LOG_DBG(" .. OUT\n");
1651 +}
1652 +
1653 +uint32_t bcm2835_audio_retrieve_buffers(bcm2835_alsa_stream_t * alsa_stream)
1654 +{
1655 + uint32_t count = atomic_read(&alsa_stream->retrieved);
1656 + atomic_sub(count, &alsa_stream->retrieved);
1657 + return count;
1658 +}
1659 +
1660 +module_param(force_bulk, bool, 0444);
1661 +MODULE_PARM_DESC(force_bulk, "Force use of vchiq bulk for audio");
1662 diff --git a/sound/arm/bcm2835.c b/sound/arm/bcm2835.c
1663 new file mode 100755
1664 index 0000000..317e7d9
1665 --- /dev/null
1666 +++ b/sound/arm/bcm2835.c
1667 @@ -0,0 +1,413 @@
1668 +/*****************************************************************************
1669 +* Copyright 2011 Broadcom Corporation. All rights reserved.
1670 +*
1671 +* Unless you and Broadcom execute a separate written software license
1672 +* agreement governing use of this software, this software is licensed to you
1673 +* under the terms of the GNU General Public License version 2, available at
1674 +* http://www.broadcom.com/licenses/GPLv2.php (the "GPL").
1675 +*
1676 +* Notwithstanding the above, under no circumstances may you combine this
1677 +* software in any way with any other Broadcom software provided under a
1678 +* license other than the GPL, without Broadcom's express prior written
1679 +* consent.
1680 +*****************************************************************************/
1681 +
1682 +#include <linux/platform_device.h>
1683 +
1684 +#include <linux/init.h>
1685 +#include <linux/slab.h>
1686 +#include <linux/module.h>
1687 +
1688 +#include "bcm2835.h"
1689 +
1690 +/* module parameters (see "Module Parameters") */
1691 +/* SNDRV_CARDS: maximum number of cards supported by this module */
1692 +static int index[MAX_SUBSTREAMS] = {[0 ... (MAX_SUBSTREAMS - 1)] = -1 };
1693 +static char *id[MAX_SUBSTREAMS] = {[0 ... (MAX_SUBSTREAMS - 1)] = NULL };
1694 +static int enable[MAX_SUBSTREAMS] = {[0 ... (MAX_SUBSTREAMS - 1)] = 1 };
1695 +
1696 +/* HACKY global pointers needed for successive probes to work : ssp
1697 + * But compared against the changes we will have to do in VC audio_ipc code
1698 + * to export 8 audio_ipc devices as a single IPC device and then monitor all
1699 + * four devices in a thread, this gets things done quickly and should be easier
1700 + * to debug if we run into issues
1701 + */
1702 +
1703 +static struct snd_card *g_card = NULL;
1704 +static bcm2835_chip_t *g_chip = NULL;
1705 +
1706 +static int snd_bcm2835_free(bcm2835_chip_t * chip)
1707 +{
1708 + kfree(chip);
1709 + return 0;
1710 +}
1711 +
1712 +/* component-destructor
1713 + * (see "Management of Cards and Components")
1714 + */
1715 +static int snd_bcm2835_dev_free(struct snd_device *device)
1716 +{
1717 + return snd_bcm2835_free(device->device_data);
1718 +}
1719 +
1720 +/* chip-specific constructor
1721 + * (see "Management of Cards and Components")
1722 + */
1723 +static int snd_bcm2835_create(struct snd_card *card,
1724 + struct platform_device *pdev,
1725 + bcm2835_chip_t ** rchip)
1726 +{
1727 + bcm2835_chip_t *chip;
1728 + int err;
1729 + static struct snd_device_ops ops = {
1730 + .dev_free = snd_bcm2835_dev_free,
1731 + };
1732 +
1733 + *rchip = NULL;
1734 +
1735 + chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1736 + if (chip == NULL)
1737 + return -ENOMEM;
1738 +
1739 + chip->card = card;
1740 +
1741 + err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
1742 + if (err < 0) {
1743 + snd_bcm2835_free(chip);
1744 + return err;
1745 + }
1746 +
1747 + *rchip = chip;
1748 + return 0;
1749 +}
1750 +
1751 +static int snd_bcm2835_alsa_probe(struct platform_device *pdev)
1752 +{
1753 + static int dev;
1754 + bcm2835_chip_t *chip;
1755 + struct snd_card *card;
1756 + int err;
1757 +
1758 + if (dev >= MAX_SUBSTREAMS)
1759 + return -ENODEV;
1760 +
1761 + if (!enable[dev]) {
1762 + dev++;
1763 + return -ENOENT;
1764 + }
1765 +
1766 + if (dev > 0)
1767 + goto add_register_map;
1768 +
1769 + err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &g_card);
1770 + if (err < 0)
1771 + goto out;
1772 +
1773 + snd_card_set_dev(g_card, &pdev->dev);
1774 + strcpy(g_card->driver, "BRCM bcm2835 ALSA Driver");
1775 + strcpy(g_card->shortname, "bcm2835 ALSA");
1776 + sprintf(g_card->longname, "%s", g_card->shortname);
1777 +
1778 + err = snd_bcm2835_create(g_card, pdev, &chip);
1779 + if (err < 0) {
1780 + printk(KERN_ERR "Failed to create bcm2835 chip\n");
1781 + goto out_bcm2835_create;
1782 + }
1783 +
1784 + g_chip = chip;
1785 + err = snd_bcm2835_new_pcm(chip);
1786 + if (err < 0) {
1787 + printk(KERN_ERR "Failed to create new BCM2835 pcm device\n");
1788 + goto out_bcm2835_new_pcm;
1789 + }
1790 +
1791 + err = snd_bcm2835_new_ctl(chip);
1792 + if (err < 0) {
1793 + printk(KERN_ERR "Failed to create new BCM2835 ctl\n");
1794 + goto out_bcm2835_new_ctl;
1795 + }
1796 +
1797 +add_register_map:
1798 + card = g_card;
1799 + chip = g_chip;
1800 +
1801 + BUG_ON(!(card && chip));
1802 +
1803 + chip->avail_substreams |= (1 << dev);
1804 + chip->pdev[dev] = pdev;
1805 +
1806 + if (dev == 0) {
1807 + err = snd_card_register(card);
1808 + if (err < 0) {
1809 + printk(KERN_ERR
1810 + "Failed to register bcm2835 ALSA card \n");
1811 + goto out_card_register;
1812 + }
1813 + platform_set_drvdata(pdev, card);
1814 + printk(KERN_INFO "bcm2835 ALSA card created!\n");
1815 + } else {
1816 + printk(KERN_INFO "bcm2835 ALSA chip created!\n");
1817 + platform_set_drvdata(pdev, (void *)dev);
1818 + }
1819 +
1820 + dev++;
1821 +
1822 + return 0;
1823 +
1824 +out_card_register:
1825 +out_bcm2835_new_ctl:
1826 +out_bcm2835_new_pcm:
1827 +out_bcm2835_create:
1828 + BUG_ON(!g_card);
1829 + if (snd_card_free(g_card))
1830 + printk(KERN_ERR "Failed to free Registered alsa card\n");
1831 + g_card = NULL;
1832 +out:
1833 + dev = SNDRV_CARDS; /* stop more avail_substreams from being probed */
1834 + printk(KERN_ERR "BCM2835 ALSA Probe failed !!\n");
1835 + return err;
1836 +}
1837 +
1838 +static int snd_bcm2835_alsa_remove(struct platform_device *pdev)
1839 +{
1840 + uint32_t idx;
1841 + void *drv_data;
1842 +
1843 + drv_data = platform_get_drvdata(pdev);
1844 +
1845 + if (drv_data == (void *)g_card) {
1846 + /* This is the card device */
1847 + snd_card_free((struct snd_card *)drv_data);
1848 + g_card = NULL;
1849 + g_chip = NULL;
1850 + } else {
1851 + idx = (uint32_t) drv_data;
1852 + if (g_card != NULL) {
1853 + BUG_ON(!g_chip);
1854 + /* We pass chip device numbers in audio ipc devices
1855 + * other than the one we registered our card with
1856 + */
1857 + idx = (uint32_t) drv_data;
1858 + BUG_ON(!idx || idx > MAX_SUBSTREAMS);
1859 + g_chip->avail_substreams &= ~(1 << idx);
1860 + /* There should be atleast one substream registered
1861 + * after we are done here, as it wil be removed when
1862 + * the *remove* is called for the card device
1863 + */
1864 + BUG_ON(!g_chip->avail_substreams);
1865 + }
1866 + }
1867 +
1868 + platform_set_drvdata(pdev, NULL);
1869 +
1870 + return 0;
1871 +}
1872 +
1873 +#ifdef CONFIG_PM
1874 +static int snd_bcm2835_alsa_suspend(struct platform_device *pdev,
1875 + pm_message_t state)
1876 +{
1877 + return 0;
1878 +}
1879 +
1880 +static int snd_bcm2835_alsa_resume(struct platform_device *pdev)
1881 +{
1882 + return 0;
1883 +}
1884 +
1885 +#endif
1886 +
1887 +static struct platform_driver bcm2835_alsa0_driver = {
1888 + .probe = snd_bcm2835_alsa_probe,
1889 + .remove = snd_bcm2835_alsa_remove,
1890 +#ifdef CONFIG_PM
1891 + .suspend = snd_bcm2835_alsa_suspend,
1892 + .resume = snd_bcm2835_alsa_resume,
1893 +#endif
1894 + .driver = {
1895 + .name = "bcm2835_AUD0",
1896 + .owner = THIS_MODULE,
1897 + },
1898 +};
1899 +
1900 +static struct platform_driver bcm2835_alsa1_driver = {
1901 + .probe = snd_bcm2835_alsa_probe,
1902 + .remove = snd_bcm2835_alsa_remove,
1903 +#ifdef CONFIG_PM
1904 + .suspend = snd_bcm2835_alsa_suspend,
1905 + .resume = snd_bcm2835_alsa_resume,
1906 +#endif
1907 + .driver = {
1908 + .name = "bcm2835_AUD1",
1909 + .owner = THIS_MODULE,
1910 + },
1911 +};
1912 +
1913 +static struct platform_driver bcm2835_alsa2_driver = {
1914 + .probe = snd_bcm2835_alsa_probe,
1915 + .remove = snd_bcm2835_alsa_remove,
1916 +#ifdef CONFIG_PM
1917 + .suspend = snd_bcm2835_alsa_suspend,
1918 + .resume = snd_bcm2835_alsa_resume,
1919 +#endif
1920 + .driver = {
1921 + .name = "bcm2835_AUD2",
1922 + .owner = THIS_MODULE,
1923 + },
1924 +};
1925 +
1926 +static struct platform_driver bcm2835_alsa3_driver = {
1927 + .probe = snd_bcm2835_alsa_probe,
1928 + .remove = snd_bcm2835_alsa_remove,
1929 +#ifdef CONFIG_PM
1930 + .suspend = snd_bcm2835_alsa_suspend,
1931 + .resume = snd_bcm2835_alsa_resume,
1932 +#endif
1933 + .driver = {
1934 + .name = "bcm2835_AUD3",
1935 + .owner = THIS_MODULE,
1936 + },
1937 +};
1938 +
1939 +static struct platform_driver bcm2835_alsa4_driver = {
1940 + .probe = snd_bcm2835_alsa_probe,
1941 + .remove = snd_bcm2835_alsa_remove,
1942 +#ifdef CONFIG_PM
1943 + .suspend = snd_bcm2835_alsa_suspend,
1944 + .resume = snd_bcm2835_alsa_resume,
1945 +#endif
1946 + .driver = {
1947 + .name = "bcm2835_AUD4",
1948 + .owner = THIS_MODULE,
1949 + },
1950 +};
1951 +
1952 +static struct platform_driver bcm2835_alsa5_driver = {
1953 + .probe = snd_bcm2835_alsa_probe,
1954 + .remove = snd_bcm2835_alsa_remove,
1955 +#ifdef CONFIG_PM
1956 + .suspend = snd_bcm2835_alsa_suspend,
1957 + .resume = snd_bcm2835_alsa_resume,
1958 +#endif
1959 + .driver = {
1960 + .name = "bcm2835_AUD5",
1961 + .owner = THIS_MODULE,
1962 + },
1963 +};
1964 +
1965 +static struct platform_driver bcm2835_alsa6_driver = {
1966 + .probe = snd_bcm2835_alsa_probe,
1967 + .remove = snd_bcm2835_alsa_remove,
1968 +#ifdef CONFIG_PM
1969 + .suspend = snd_bcm2835_alsa_suspend,
1970 + .resume = snd_bcm2835_alsa_resume,
1971 +#endif
1972 + .driver = {
1973 + .name = "bcm2835_AUD6",
1974 + .owner = THIS_MODULE,
1975 + },
1976 +};
1977 +
1978 +static struct platform_driver bcm2835_alsa7_driver = {
1979 + .probe = snd_bcm2835_alsa_probe,
1980 + .remove = snd_bcm2835_alsa_remove,
1981 +#ifdef CONFIG_PM
1982 + .suspend = snd_bcm2835_alsa_suspend,
1983 + .resume = snd_bcm2835_alsa_resume,
1984 +#endif
1985 + .driver = {
1986 + .name = "bcm2835_AUD7",
1987 + .owner = THIS_MODULE,
1988 + },
1989 +};
1990 +
1991 +static int bcm2835_alsa_device_init(void)
1992 +{
1993 + int err;
1994 + err = platform_driver_register(&bcm2835_alsa0_driver);
1995 + if (err) {
1996 + printk("Error registering bcm2835_alsa0_driver %d .\n", err);
1997 + goto out;
1998 + }
1999 +
2000 + err = platform_driver_register(&bcm2835_alsa1_driver);
2001 + if (err) {
2002 + printk("Error registering bcm2835_alsa1_driver %d .\n", err);
2003 + goto unregister_0;
2004 + }
2005 +
2006 + err = platform_driver_register(&bcm2835_alsa2_driver);
2007 + if (err) {
2008 + printk("Error registering bcm2835_alsa2_driver %d .\n", err);
2009 + goto unregister_1;
2010 + }
2011 +
2012 + err = platform_driver_register(&bcm2835_alsa3_driver);
2013 + if (err) {
2014 + printk("Error registering bcm2835_alsa3_driver %d .\n", err);
2015 + goto unregister_2;
2016 + }
2017 +
2018 + err = platform_driver_register(&bcm2835_alsa4_driver);
2019 + if (err) {
2020 + printk("Error registering bcm2835_alsa4_driver %d .\n", err);
2021 + goto unregister_3;
2022 + }
2023 +
2024 + err = platform_driver_register(&bcm2835_alsa5_driver);
2025 + if (err) {
2026 + printk("Error registering bcm2835_alsa5_driver %d .\n", err);
2027 + goto unregister_4;
2028 + }
2029 +
2030 + err = platform_driver_register(&bcm2835_alsa6_driver);
2031 + if (err) {
2032 + printk("Error registering bcm2835_alsa6_driver %d .\n", err);
2033 + goto unregister_5;
2034 + }
2035 +
2036 + err = platform_driver_register(&bcm2835_alsa7_driver);
2037 + if (err) {
2038 + printk("Error registering bcm2835_alsa7_driver %d .\n", err);
2039 + goto unregister_6;
2040 + }
2041 +
2042 + return 0;
2043 +
2044 +unregister_6:
2045 + platform_driver_unregister(&bcm2835_alsa6_driver);
2046 +unregister_5:
2047 + platform_driver_unregister(&bcm2835_alsa5_driver);
2048 +unregister_4:
2049 + platform_driver_unregister(&bcm2835_alsa4_driver);
2050 +unregister_3:
2051 + platform_driver_unregister(&bcm2835_alsa3_driver);
2052 +unregister_2:
2053 + platform_driver_unregister(&bcm2835_alsa2_driver);
2054 +unregister_1:
2055 + platform_driver_unregister(&bcm2835_alsa1_driver);
2056 +unregister_0:
2057 + platform_driver_unregister(&bcm2835_alsa0_driver);
2058 +out:
2059 + return err;
2060 +}
2061 +
2062 +static void bcm2835_alsa_device_exit(void)
2063 +{
2064 + platform_driver_unregister(&bcm2835_alsa0_driver);
2065 + platform_driver_unregister(&bcm2835_alsa1_driver);
2066 + platform_driver_unregister(&bcm2835_alsa2_driver);
2067 + platform_driver_unregister(&bcm2835_alsa3_driver);
2068 + platform_driver_unregister(&bcm2835_alsa4_driver);
2069 + platform_driver_unregister(&bcm2835_alsa5_driver);
2070 + platform_driver_unregister(&bcm2835_alsa6_driver);
2071 + platform_driver_unregister(&bcm2835_alsa7_driver);
2072 +}
2073 +
2074 +late_initcall(bcm2835_alsa_device_init);
2075 +module_exit(bcm2835_alsa_device_exit);
2076 +
2077 +MODULE_AUTHOR("Dom Cobley");
2078 +MODULE_DESCRIPTION("Alsa driver for BCM2835 chip");
2079 +MODULE_LICENSE("GPL");
2080 +MODULE_ALIAS("platform:bcm2835_alsa");
2081 diff --git a/sound/arm/bcm2835.h b/sound/arm/bcm2835.h
2082 new file mode 100755
2083 index 0000000..080bd5c
2084 --- /dev/null
2085 +++ b/sound/arm/bcm2835.h
2086 @@ -0,0 +1,155 @@
2087 +/*****************************************************************************
2088 +* Copyright 2011 Broadcom Corporation. All rights reserved.
2089 +*
2090 +* Unless you and Broadcom execute a separate written software license
2091 +* agreement governing use of this software, this software is licensed to you
2092 +* under the terms of the GNU General Public License version 2, available at
2093 +* http://www.broadcom.com/licenses/GPLv2.php (the "GPL").
2094 +*
2095 +* Notwithstanding the above, under no circumstances may you combine this
2096 +* software in any way with any other Broadcom software provided under a
2097 +* license other than the GPL, without Broadcom's express prior written
2098 +* consent.
2099 +*****************************************************************************/
2100 +
2101 +#ifndef __SOUND_ARM_BCM2835_H
2102 +#define __SOUND_ARM_BCM2835_H
2103 +
2104 +#include <linux/device.h>
2105 +#include <linux/list.h>
2106 +#include <linux/interrupt.h>
2107 +#include <linux/wait.h>
2108 +#include <sound/core.h>
2109 +#include <sound/initval.h>
2110 +#include <sound/pcm.h>
2111 +#include <sound/pcm_params.h>
2112 +#include <linux/workqueue.h>
2113 +
2114 +/*
2115 +#define AUDIO_DEBUG_ENABLE
2116 +#define AUDIO_VERBOSE_DEBUG_ENABLE
2117 +*/
2118 +
2119 +/* Debug macros */
2120 +
2121 +#ifdef AUDIO_DEBUG_ENABLE
2122 +#ifdef AUDIO_VERBOSE_DEBUG_ENABLE
2123 +
2124 +#define audio_debug(fmt, arg...) \
2125 + printk(KERN_INFO"%s:%d " fmt, __func__, __LINE__, ##arg)
2126 +
2127 +#define audio_info(fmt, arg...) \
2128 + printk(KERN_INFO"%s:%d " fmt, __func__, __LINE__, ##arg)
2129 +
2130 +#else
2131 +
2132 +#define audio_debug(fmt, arg...)
2133 +
2134 +#define audio_info(fmt, arg...)
2135 +
2136 +#endif /* AUDIO_VERBOSE_DEBUG_ENABLE */
2137 +
2138 +#else
2139 +
2140 +#define audio_debug(fmt, arg...)
2141 +
2142 +#define audio_info(fmt, arg...)
2143 +
2144 +#endif /* AUDIO_DEBUG_ENABLE */
2145 +
2146 +#define audio_error(fmt, arg...) \
2147 + printk(KERN_ERR"%s:%d " fmt, __func__, __LINE__, ##arg)
2148 +
2149 +#define audio_warning(fmt, arg...) \
2150 + printk(KERN_WARNING"%s:%d " fmt, __func__, __LINE__, ##arg)
2151 +
2152 +#define audio_alert(fmt, arg...) \
2153 + printk(KERN_ALERT"%s:%d " fmt, __func__, __LINE__, ##arg)
2154 +
2155 +#define MAX_SUBSTREAMS (8)
2156 +#define AVAIL_SUBSTREAMS_MASK (0xff)
2157 +enum {
2158 + CTRL_VOL_MUTE,
2159 + CTRL_VOL_UNMUTE
2160 +};
2161 +
2162 +/* macros for alsa2chip and chip2alsa, instead of functions */
2163 +
2164 +#define alsa2chip(vol) (uint)(-((vol << 8) / 100)) /* convert alsa to chip volume (defined as macro rather than function call) */
2165 +#define chip2alsa(vol) -((vol * 100) >> 8) /* convert chip to alsa volume */
2166 +
2167 +/* Some constants for values .. */
2168 +typedef enum {
2169 + AUDIO_DEST_AUTO = 0,
2170 + AUDIO_DEST_HEADPHONES = 1,
2171 + AUDIO_DEST_HDMI = 2,
2172 + AUDIO_DEST_MAX,
2173 +} SND_BCM2835_ROUTE_T;
2174 +
2175 +typedef enum {
2176 + PCM_PLAYBACK_VOLUME,
2177 + PCM_PLAYBACK_MUTE,
2178 + PCM_PLAYBACK_DEVICE,
2179 +} SND_BCM2835_CTRL_T;
2180 +
2181 +/* definition of the chip-specific record */
2182 +typedef struct bcm2835_chip {
2183 + struct snd_card *card;
2184 + struct snd_pcm *pcm;
2185 + /* Bitmat for valid reg_base and irq numbers */
2186 + uint32_t avail_substreams;
2187 + struct platform_device *pdev[MAX_SUBSTREAMS];
2188 + struct bcm2835_alsa_stream *alsa_stream[MAX_SUBSTREAMS];
2189 +
2190 + int volume;
2191 + int old_volume; /* stores the volume value whist muted */
2192 + int dest;
2193 + int mute;
2194 +} bcm2835_chip_t;
2195 +
2196 +typedef struct bcm2835_alsa_stream {
2197 + bcm2835_chip_t *chip;
2198 + struct snd_pcm_substream *substream;
2199 +
2200 + struct semaphore buffers_update_sem;
2201 + struct semaphore control_sem;
2202 + spinlock_t lock;
2203 + volatile uint32_t control;
2204 + volatile uint32_t status;
2205 +
2206 + int open;
2207 + int running;
2208 + int draining;
2209 +
2210 + unsigned int pos;
2211 + unsigned int buffer_size;
2212 + unsigned int period_size;
2213 +
2214 + uint32_t enable_fifo_irq;
2215 + irq_handler_t fifo_irq_handler;
2216 +
2217 + atomic_t retrieved;
2218 + struct opaque_AUDIO_INSTANCE_T *instance;
2219 + struct workqueue_struct *my_wq;
2220 + int idx;
2221 +} bcm2835_alsa_stream_t;
2222 +
2223 +int snd_bcm2835_new_ctl(bcm2835_chip_t * chip);
2224 +int snd_bcm2835_new_pcm(bcm2835_chip_t * chip);
2225 +
2226 +int bcm2835_audio_open(bcm2835_alsa_stream_t * alsa_stream);
2227 +int bcm2835_audio_close(bcm2835_alsa_stream_t * alsa_stream);
2228 +int bcm2835_audio_set_params(bcm2835_alsa_stream_t * alsa_stream,
2229 + uint32_t channels, uint32_t samplerate,
2230 + uint32_t bps);
2231 +int bcm2835_audio_setup(bcm2835_alsa_stream_t * alsa_stream);
2232 +int bcm2835_audio_start(bcm2835_alsa_stream_t * alsa_stream);
2233 +int bcm2835_audio_stop(bcm2835_alsa_stream_t * alsa_stream);
2234 +int bcm2835_audio_set_ctls(bcm2835_chip_t * chip);
2235 +int bcm2835_audio_write(bcm2835_alsa_stream_t * alsa_stream, uint32_t count,
2236 + void *src);
2237 +uint32_t bcm2835_audio_retrieve_buffers(bcm2835_alsa_stream_t * alsa_stream);
2238 +void bcm2835_audio_flush_buffers(bcm2835_alsa_stream_t * alsa_stream);
2239 +void bcm2835_audio_flush_playback_buffers(bcm2835_alsa_stream_t * alsa_stream);
2240 +
2241 +#endif /* __SOUND_ARM_BCM2835_H */
2242 diff --git a/sound/arm/vc_vchi_audioserv_defs.h b/sound/arm/vc_vchi_audioserv_defs.h
2243 new file mode 100644
2244 index 0000000..af3e6eb
2245 --- /dev/null
2246 +++ b/sound/arm/vc_vchi_audioserv_defs.h
2247 @@ -0,0 +1,116 @@
2248 +/*****************************************************************************
2249 +* Copyright 2011 Broadcom Corporation. All rights reserved.
2250 +*
2251 +* Unless you and Broadcom execute a separate written software license
2252 +* agreement governing use of this software, this software is licensed to you
2253 +* under the terms of the GNU General Public License version 2, available at
2254 +* http://www.broadcom.com/licenses/GPLv2.php (the "GPL").
2255 +*
2256 +* Notwithstanding the above, under no circumstances may you combine this
2257 +* software in any way with any other Broadcom software provided under a
2258 +* license other than the GPL, without Broadcom's express prior written
2259 +* consent.
2260 +*****************************************************************************/
2261 +
2262 +#ifndef _VC_AUDIO_DEFS_H_
2263 +#define _VC_AUDIO_DEFS_H_
2264 +
2265 +#define VC_AUDIOSERV_MIN_VER 1
2266 +#define VC_AUDIOSERV_VER 2
2267 +
2268 +// FourCC code used for VCHI connection
2269 +#define VC_AUDIO_SERVER_NAME MAKE_FOURCC("AUDS")
2270 +
2271 +// Maximum message length
2272 +#define VC_AUDIO_MAX_MSG_LEN (sizeof( VC_AUDIO_MSG_T ))
2273 +
2274 +// List of screens that are currently supported
2275 +// All message types supported for HOST->VC direction
2276 +typedef enum {
2277 + VC_AUDIO_MSG_TYPE_RESULT, // Generic result
2278 + VC_AUDIO_MSG_TYPE_COMPLETE, // Generic result
2279 + VC_AUDIO_MSG_TYPE_CONFIG, // Configure audio
2280 + VC_AUDIO_MSG_TYPE_CONTROL, // Configure audio
2281 + VC_AUDIO_MSG_TYPE_OPEN, // Configure audio
2282 + VC_AUDIO_MSG_TYPE_CLOSE, // Configure audio
2283 + VC_AUDIO_MSG_TYPE_START, // Configure audio
2284 + VC_AUDIO_MSG_TYPE_STOP, // Configure audio
2285 + VC_AUDIO_MSG_TYPE_WRITE, // Configure audio
2286 + VC_AUDIO_MSG_TYPE_MAX
2287 +} VC_AUDIO_MSG_TYPE;
2288 +
2289 +// configure the audio
2290 +typedef struct {
2291 + uint32_t channels;
2292 + uint32_t samplerate;
2293 + uint32_t bps;
2294 +
2295 +} VC_AUDIO_CONFIG_T;
2296 +
2297 +typedef struct {
2298 + uint32_t volume;
2299 + uint32_t dest;
2300 +
2301 +} VC_AUDIO_CONTROL_T;
2302 +
2303 +// audio
2304 +typedef struct {
2305 + uint32_t dummy;
2306 +
2307 +} VC_AUDIO_OPEN_T;
2308 +
2309 +// audio
2310 +typedef struct {
2311 + uint32_t dummy;
2312 +
2313 +} VC_AUDIO_CLOSE_T;
2314 +// audio
2315 +typedef struct {
2316 + uint32_t dummy;
2317 +
2318 +} VC_AUDIO_START_T;
2319 +// audio
2320 +typedef struct {
2321 + uint32_t draining;
2322 +
2323 +} VC_AUDIO_STOP_T;
2324 +
2325 +// configure the write audio samples
2326 +typedef struct {
2327 + uint32_t count; // in bytes
2328 + void *callback;
2329 + void *cookie;
2330 + uint16_t silence;
2331 + uint16_t max_packet;
2332 +} VC_AUDIO_WRITE_T;
2333 +
2334 +// Generic result for a request (VC->HOST)
2335 +typedef struct {
2336 + int32_t success; // Success value
2337 +
2338 +} VC_AUDIO_RESULT_T;
2339 +
2340 +// Generic result for a request (VC->HOST)
2341 +typedef struct {
2342 + int32_t count; // Success value
2343 + void *callback;
2344 + void *cookie;
2345 +} VC_AUDIO_COMPLETE_T;
2346 +
2347 +// Message header for all messages in HOST->VC direction
2348 +typedef struct {
2349 + int32_t type; // Message type (VC_AUDIO_MSG_TYPE)
2350 + union {
2351 + VC_AUDIO_CONFIG_T config;
2352 + VC_AUDIO_CONTROL_T control;
2353 + VC_AUDIO_OPEN_T open;
2354 + VC_AUDIO_CLOSE_T close;
2355 + VC_AUDIO_START_T start;
2356 + VC_AUDIO_STOP_T stop;
2357 + VC_AUDIO_WRITE_T write;
2358 + VC_AUDIO_RESULT_T result;
2359 + VC_AUDIO_COMPLETE_T complete;
2360 + } u;
2361 +} VC_AUDIO_MSG_T;
2362 +
2363 +#endif // _VC_AUDIO_DEFS_H_
2364 --
2365 1.9.1
2366
OpenWrt Source Repository