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