summaryrefslogtreecommitdiffstats
path: root/HAL-afb
diff options
context:
space:
mode:
Diffstat (limited to 'HAL-afb')
-rw-r--r--HAL-afb/HAL-interface/hal-interface.c54
-rw-r--r--HAL-afb/HAL-plugin/CMakeLists.txt41
-rw-r--r--HAL-afb/HAL-plugin/HalPlugCtl.c267
-rw-r--r--HAL-afb/HAL-plugin/HalPlugPcm.c430
-rw-r--r--HAL-afb/Scarlett-Focusrite/ScarlettUsbHAL.c12
5 files changed, 774 insertions, 30 deletions
diff --git a/HAL-afb/HAL-interface/hal-interface.c b/HAL-afb/HAL-interface/hal-interface.c
index 29c5e88..035278b 100644
--- a/HAL-afb/HAL-interface/hal-interface.c
+++ b/HAL-afb/HAL-interface/hal-interface.c
@@ -222,13 +222,13 @@ OnExit:
// This receive all event this binding subscribe to
PUBLIC void halServiceEvent(const char *evtname, struct json_object *object) {
- AFB_NOTICE("afbBindingV1ServiceEvent evtname=%s [msg=%s]", evtname, json_object_to_json_string(object));
+ AFB_NOTICE("afbBindingV1ServiceEvent evtname=%s [msg=%s]", evtname, json_object_get_string(object));
}
// this is call when after all bindings are loaded
PUBLIC int halServiceInit (const char *apiPrefix, alsaHalSndCardT *alsaHalSndCard) {
int ok, err;
- struct json_object *queryurl, *responseJ, *devidJ, *tmpJ;
+ struct json_object *queryurl, *responseJ, *devidJ, *ctlsJ, *tmpJ;
halCtls = alsaHalSndCard->ctls; // Get sndcard specific HAL control mapping
err= afb_daemon_require_api("alsacore", 1);
@@ -245,38 +245,44 @@ PUBLIC int halServiceInit (const char *apiPrefix, alsaHalSndCardT *alsaHalSndCar
ok= afb_service_call_sync ("alsacore", "registerHal", queryurl, &responseJ);
json_object_put(queryurl);
if (!ok) {
- NOTICE ("Fail to register HAL to ALSA lowlevel binding Response=[%s]", json_object_to_json_string(responseJ));
+ NOTICE ("Fail to register HAL to ALSA lowlevel binding Response=[%s]", json_object_get_string(responseJ));
goto OnErrorExit;
}
// extract sound devid from HAL registration
if (!json_object_object_get_ex(responseJ, "response", &tmpJ) || !json_object_object_get_ex(tmpJ, "devid", &devidJ)) {
- AFB_ERROR ("Ooops: Internal error no devid return from HAL registration Response=[%s]", json_object_to_json_string(responseJ));
+ AFB_ERROR ("Ooops: Internal error no devid return from HAL registration Response=[%s]", json_object_get_string(responseJ));
goto OnErrorExit;
}
+
+
// for each Non Alsa Control callback create a custom control
+ ctlsJ= json_object_new_array();
for (int idx = 0; halCtls[idx].alsa.numid != 0; idx++) {
- if (halCtls[idx].cb.callback != NULL) {
- queryurl = json_object_new_object();
- json_object_object_add(queryurl, "devid",devidJ);
- tmpJ = json_object_new_object();
- if (halCtls[idx].alsa.name) json_object_object_add(tmpJ, "name" , json_object_new_string(halCtls[idx].alsa.name));
- if (halCtls[idx].alsa.numid) json_object_object_add(tmpJ, "numid" , json_object_new_int(halCtls[idx].alsa.numid));
- if (halCtls[idx].alsa.minval) json_object_object_add(tmpJ, "minval", json_object_new_int(halCtls[idx].alsa.minval));
- if (halCtls[idx].alsa.maxval) json_object_object_add(tmpJ, "maxval", json_object_new_int(halCtls[idx].alsa.maxval));
- if (halCtls[idx].alsa.step) json_object_object_add(tmpJ, "step" , json_object_new_int(halCtls[idx].alsa.step));
- if (halCtls[idx].alsa.type) json_object_object_add(tmpJ, "type" , json_object_new_int(halCtls[idx].alsa.type));
- json_object_object_add(queryurl, "ctls",tmpJ);
-
- AFB_NOTICE("QUERY=%s", json_object_to_json_string(queryurl));
-
- ok= afb_service_call_sync ("alsacore", "addcustomctl", queryurl, &responseJ);
- if (!ok) {
- AFB_ERROR ("Fail to add Customer Sound Control for ctrl=[%s] Response=[%s]", halCtls[idx].alsa.name, json_object_to_json_string(responseJ));
- goto OnErrorExit;
- }
- }
+ struct json_object *ctlJ;
+ if (halCtls[idx].alsa.numid != 0 || halCtls[idx].cb.callback != NULL) {
+ ctlJ = json_object_new_object();
+ if (halCtls[idx].alsa.name) json_object_object_add(ctlJ, "name" , json_object_new_string(halCtls[idx].alsa.name));
+ if (halCtls[idx].alsa.numid) json_object_object_add(ctlJ, "numid" , json_object_new_int(halCtls[idx].alsa.numid));
+ if (halCtls[idx].alsa.minval) json_object_object_add(ctlJ, "minval", json_object_new_int(halCtls[idx].alsa.minval));
+ if (halCtls[idx].alsa.maxval) json_object_object_add(ctlJ, "maxval", json_object_new_int(halCtls[idx].alsa.maxval));
+ if (halCtls[idx].alsa.step) json_object_object_add(ctlJ, "step" , json_object_new_int(halCtls[idx].alsa.step));
+ if (halCtls[idx].alsa.type) json_object_object_add(ctlJ, "type" , json_object_new_int(halCtls[idx].alsa.type));
+ json_object_array_add(ctlsJ, ctlJ);
+ }
+ }
+
+ // Build new queryJ to add HAL custom control if any
+ if (json_object_array_length (ctlsJ) > 0) {
+ queryurl = json_object_new_object();
+ json_object_object_add(queryurl, "devid",devidJ);
+ json_object_object_add(queryurl, "ctls",ctlsJ);
+ ok= afb_service_call_sync ("alsacore", "addcustomctl", queryurl, &responseJ);
+ if (!ok) {
+ AFB_ERROR ("Fail creating HAL Custom ALSA ctls Response=[%s]", json_object_get_string(responseJ));
+ goto OnErrorExit;
+ }
}
// finally register for alsa lowlevel event
diff --git a/HAL-afb/HAL-plugin/CMakeLists.txt b/HAL-afb/HAL-plugin/CMakeLists.txt
new file mode 100644
index 0000000..73390b8
--- /dev/null
+++ b/HAL-afb/HAL-plugin/CMakeLists.txt
@@ -0,0 +1,41 @@
+###########################################################################
+# Copyright 2015, 2016, 2017 IoT.bzh
+#
+# author: Fulup Ar Foll <fulup@iot.bzh>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+###########################################################################
+
+
+# Add target to project dependency list
+PROJECT_TARGET_ADD(hal-ctl-plugin)
+
+ # Define targets
+ ADD_LIBRARY(hal-ctl-plugin MODULE HalPlugCtl.c)
+
+ # Alsa Plugin properties
+ SET_TARGET_PROPERTIES(hal-ctl-plugin PROPERTIES
+ PREFIX "alsa-"
+ OUTPUT_NAME ${TARGET_NAME}
+ )
+
+PROJECT_TARGET_ADD(hal-pcm-plugin)
+
+ # Define targets
+ ADD_LIBRARY(hal-pcm-plugin MODULE HalPlugPcm.c)
+
+ # Alsa Plugin properties
+ SET_TARGET_PROPERTIES(hal-pcm-plugin PROPERTIES
+ PREFIX "alsa-"
+ OUTPUT_NAME ${TARGET_NAME}
+ )
diff --git a/HAL-afb/HAL-plugin/HalPlugCtl.c b/HAL-afb/HAL-plugin/HalPlugCtl.c
new file mode 100644
index 0000000..21e7cfc
--- /dev/null
+++ b/HAL-afb/HAL-plugin/HalPlugCtl.c
@@ -0,0 +1,267 @@
+/*
+ * Copyright (C) 2016 "IoT.bzh"
+ * Author Fulup Ar Foll <fulup@iot.bzh>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+#include <stdio.h>
+#include <sys/ioctl.h>
+#include <alsa/asoundlib.h>
+#include <alsa/control_external.h>
+#include <linux/soundcard.h>
+
+typedef struct afbHalPlug {
+ snd_ctl_ext_t ext;
+ char *device;
+ unsigned int num_vol_ctls;
+ unsigned int num_rec_items;
+ unsigned int vol_ctl[SOUND_MIXER_NRDEVICES];
+ unsigned int rec_item[SOUND_MIXER_NRDEVICES];
+} afbHalPlug_t;
+
+static const char *const vol_devices[SOUND_MIXER_NRDEVICES] = {
+ [SOUND_MIXER_VOLUME] = "Master Playback Volume",
+ [SOUND_MIXER_BASS] = "Tone Control - Bass",
+ [SOUND_MIXER_TREBLE] = "Tone Control - Treble",
+ [SOUND_MIXER_SYNTH] = "Synth Playback Volume",
+ [SOUND_MIXER_PCM] = "PCM Playback Volume",
+ [SOUND_MIXER_SPEAKER] = "PC Speaker Playback Volume",
+ [SOUND_MIXER_LINE] = "Line Playback Volume",
+ [SOUND_MIXER_MIC] = "Mic Playback Volume",
+ [SOUND_MIXER_CD] = "CD Playback Volume",
+ [SOUND_MIXER_IMIX] = "Monitor Mix Playback Volume",
+ [SOUND_MIXER_ALTPCM] = "Headphone Playback Volume",
+ [SOUND_MIXER_RECLEV] = "Capture Volume",
+ [SOUND_MIXER_IGAIN] = "Capture Volume",
+ [SOUND_MIXER_OGAIN] = "Playback Volume",
+ [SOUND_MIXER_LINE1] = "Aux Playback Volume",
+ [SOUND_MIXER_LINE2] = "Aux1 Playback Volume",
+ [SOUND_MIXER_LINE3] = "Line1 Playback Volume",
+ [SOUND_MIXER_DIGITAL1] = "IEC958 Playback Volume",
+ [SOUND_MIXER_DIGITAL2] = "Digital Playback Volume",
+ [SOUND_MIXER_DIGITAL3] = "Digital1 Playback Volume",
+ [SOUND_MIXER_PHONEIN] = "Phone Playback Volume",
+ [SOUND_MIXER_PHONEOUT] = "Master Mono Playback Volume",
+ [SOUND_MIXER_VIDEO] = "Video Playback Volume",
+ [SOUND_MIXER_RADIO] = "Radio Playback Volume",
+ [SOUND_MIXER_MONITOR] = "Monitor Playback Volume",
+};
+
+static const char *const rec_devices[SOUND_MIXER_NRDEVICES] = {
+ [SOUND_MIXER_VOLUME] = "Mix Capture Switch",
+ [SOUND_MIXER_SYNTH] = "Synth Capture Switch",
+ [SOUND_MIXER_PCM] = "PCM Capture Switch",
+ [SOUND_MIXER_LINE] = "Line Capture Switch",
+ [SOUND_MIXER_MIC] = "Mic Capture Switch",
+ [SOUND_MIXER_CD] = "CD Capture Switch",
+ [SOUND_MIXER_LINE1] = "Aux Capture Switch",
+ [SOUND_MIXER_LINE2] = "Aux1 Capture Switch",
+ [SOUND_MIXER_LINE3] = "Line1 Capture Switch",
+ [SOUND_MIXER_DIGITAL1] = "IEC958 Capture Switch",
+ [SOUND_MIXER_DIGITAL2] = "Digital Capture Switch",
+ [SOUND_MIXER_DIGITAL3] = "Digital1 Capture Switch",
+ [SOUND_MIXER_PHONEIN] = "Phone Capture Switch",
+ [SOUND_MIXER_VIDEO] = "Video Capture Switch",
+ [SOUND_MIXER_RADIO] = "Radio Capture Switch",
+};
+
+static const char *const rec_items[SOUND_MIXER_NRDEVICES] = {
+ [SOUND_MIXER_VOLUME] = "Mix",
+ [SOUND_MIXER_SYNTH] = "Synth",
+ [SOUND_MIXER_PCM] = "PCM",
+ [SOUND_MIXER_LINE] = "Line",
+ [SOUND_MIXER_MIC] = "Mic",
+ [SOUND_MIXER_CD] = "CD",
+ [SOUND_MIXER_LINE1] = "Aux",
+ [SOUND_MIXER_LINE2] = "Aux1",
+ [SOUND_MIXER_LINE3] = "Line1",
+ [SOUND_MIXER_DIGITAL1] = "IEC958",
+ [SOUND_MIXER_DIGITAL2] = "Digital",
+ [SOUND_MIXER_DIGITAL3] = "Digital1",
+ [SOUND_MIXER_PHONEIN] = "Phone",
+ [SOUND_MIXER_VIDEO] = "Video",
+ [SOUND_MIXER_RADIO] = "Radio",
+};
+
+
+
+
+static snd_ctl_ext_key_t AfbHalElemFind(snd_ctl_ext_t *ext,
+ const snd_ctl_elem_id_t *id) {
+
+ snd_ctl_hal_t *ctlHal = ext->private_data;
+ const char *name;
+ unsigned int i, key, numid;
+
+ numid = snd_ctl_elem_id_get_numid(id);
+ if (numid > 0) {
+ numid--;
+ if (numid < afbHalPlug->num_vol_ctls)
+ return afbHalPlug->vol_ctl[numid];
+ numid -= afbHalPlug->num_vol_ctls;
+ if (afbHalPlug->exclusive_input) {
+ if (!numid)
+ return OSS_KEY_CAPTURE_MUX;
+ } else if (numid < afbHalPlug->num_rec_items)
+ return afbHalPlug->rec_item[numid] |
+ OSS_KEY_CAPTURE_FLAG;
+ }
+
+ name = snd_ctl_elem_id_get_name(id);
+ if (! strcmp(name, "Capture Source")) {
+ if (afbHalPlug->exclusive_input)
+ return OSS_KEY_CAPTURE_MUX;
+ else
+ return SND_CTL_EXT_KEY_NOT_FOUND;
+ }
+ for (i = 0; i < afbHalPlug->num_vol_ctls; i++) {
+ key = afbHalPlug->vol_ctl[i];
+ if (! strcmp(name, vol_devices[key]))
+ return key;
+ }
+ for (i = 0; i < afbHalPlug->num_rec_items; i++) {
+ key = afbHalPlug->rec_item[i];
+ if (! strcmp(name, rec_devices[key]))
+ return key | OSS_KEY_CAPTURE_FLAG;
+ }
+ return SND_CTL_EXT_KEY_NOT_FOUND;
+}
+
+static int AfbHalGetAttrib(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key,
+ int *type, unsigned int *acc, unsigned int *count) {
+ return 0;
+}
+
+static int AfbHalGetInfo(snd_ctl_ext_t *ext ATTRIBUTE_UNUSED,
+ snd_ctl_ext_key_t key ATTRIBUTE_UNUSED,
+ long *imin, long *imax, long *istep) {
+
+ return 0;
+}
+
+static int AfbHalGetEnumInfo(snd_ctl_ext_t *ext,
+ snd_ctl_ext_key_t key ATTRIBUTE_UNUSED,
+ unsigned int *items) {
+
+ return 0;
+}
+
+static int AfbHalGetEnumName(snd_ctl_ext_t *ext,
+ snd_ctl_ext_key_t key ATTRIBUTE_UNUSED,
+ unsigned int item, char *name,
+ size_t name_max_len) {
+
+ return 0;
+}
+
+static int AfbHalReadInt(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key, long *value) {
+
+ return 0;
+}
+
+static int AfbHalReadEnumerate(snd_ctl_ext_t *ext,
+ snd_ctl_ext_key_t key ATTRIBUTE_UNUSED,
+ unsigned int *items) {
+
+ return 0;
+}
+
+static int AfbHalWriteInt(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key, long *value) {
+
+ return 0;
+}
+
+static int AfbHalWriteEnum(snd_ctl_ext_t *ext,
+ snd_ctl_ext_key_t key ATTRIBUTE_UNUSED,
+ unsigned int *items) {
+
+ return 0;
+}
+
+static int AfbHalEventRead(snd_ctl_ext_t *ext ATTRIBUTE_UNUSED,
+ snd_ctl_elem_id_t *id ATTRIBUTE_UNUSED,
+ unsigned int *event_mask ATTRIBUTE_UNUSED)
+{
+ return -EAGAIN;
+}
+
+static snd_ctl_ext_callback_t afbHalCBs = {
+ .close = AfbHalClose,
+ .elem_count = AfbHalElemCount,
+ .elem_list = AfbHalElemList,
+ .find_elem = AfbHalElemFind,
+ .get_attribute = AfbHalGetAttrib,
+ .get_integer_info = AfbHalGetInfo,
+ .get_enumerated_info = AfbHalGetEnumInfo,
+ .get_enumerated_name = AfbHalGetEnumName,
+ .read_integer = AfbHalReadInt,
+ .read_enumerated = AfbHalReadEnumerate,
+ .write_integer = AfbHalWriteInt,
+ .write_enumerated = AfbHalWriteEnum,
+ .read_event = AfbHalEventRead,
+};
+
+
+SND_CTL_PLUGIN_DEFINE_FUNC(afb_hal) {
+
+ snd_config_iterator_t it, next;
+ afbHalPlug_t *afbHalPlug;
+ int err;
+
+ snd_config_for_each(it, next, conf) {
+ snd_config_t *n = snd_config_iterator_entry(it);
+ const char *id;
+ if (snd_config_get_id(n, &id) < 0)
+ continue;
+ if (strcmp(id, "comment") == 0 || strcmp(id, "type") == 0 || strcmp(id, "hint") == 0)
+ continue;
+ if (strcmp(id, "slave") == 0) {
+ if (snd_config_get_string(n, &device) < 0) {
+ SNDERR("Invalid type for %s", id);
+ return -EINVAL;
+ }
+ continue;
+ }
+ SNDERR("Unknown field %s", id);
+ return -EINVAL;
+ }
+
+ // Create ALSA control plugin structure
+ afbHalPlug->ext.version = SND_CTL_EXT_VERSION;
+ afbHalPlug->ext.card_idx = 0; /* FIXME */
+ strcpy(afbHalPlug->ext.id, "AFB-HAL-CTL");
+ strcpy(afbHalPlug->ext.driver, "AFB-HAL");
+ strcpy(afbHalPlug->ext.name, "AFB-HAL Control Plugin");
+ strcpy(afbHalPlug->ext.mixername, "AFB-HAL Mixer Plugin");
+ strcpy(afbHalPlug->ext.longname, "Automotive-Linux Sound Abstraction Control Plugin");
+ afbHalPlug->ext.poll_fd = -1;
+ afbHalPlug->ext.callback = &afbHalCBs;
+ afbHalPlug->ext.private_data = afbHalPlug;
+
+
+ err = snd_ctl_ext_create(&afbHalPlug->ext, name, mode);
+ if (err < 0) goto OnErrorExit;
+
+ // Plugin register controls update handlep before exiting
+ *handlep = afbHalPlug->ext.handle;
+ return 0;
+
+OnErrorExit:
+ free(afbHalPlug);
+ return -1;
+}
+
+SND_CTL_PLUGIN_SYMBOL(afb_hal);
diff --git a/HAL-afb/HAL-plugin/HalPlugPcm.c b/HAL-afb/HAL-plugin/HalPlugPcm.c
new file mode 100644
index 0000000..d43b44c
--- /dev/null
+++ b/HAL-afb/HAL-plugin/HalPlugPcm.c
@@ -0,0 +1,430 @@
+/*
+ * ALSA <-> OSS PCM I/O plugin
+ *
+ * Copyright (c) 2005 by Takashi Iwai <tiwai@suse.de>
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include <stdio.h>
+#include <sys/ioctl.h>
+#include <alsa/asoundlib.h>
+#include <alsa/pcm_external.h>
+#include <linux/soundcard.h>
+
+typedef struct snd_pcm_oss {
+ snd_pcm_ioplug_t io;
+ char *device;
+ int fd;
+ int fragment_set;
+ int caps;
+ int format;
+ unsigned int period_shift;
+ unsigned int periods;
+ unsigned int frame_bytes;
+} snd_pcm_oss_t;
+
+static snd_pcm_sframes_t oss_write(snd_pcm_ioplug_t *io,
+ const snd_pcm_channel_area_t *areas,
+ snd_pcm_uframes_t offset,
+ snd_pcm_uframes_t size)
+{
+ snd_pcm_oss_t *oss = io->private_data;
+ const char *buf;
+ ssize_t result;
+
+ /* we handle only an interleaved buffer */
+ buf = (char *)areas->addr + (areas->first + areas->step * offset) / 8;
+ size *= oss->frame_bytes;
+ result = write(oss->fd, buf, size);
+ if (result <= 0)
+ return result;
+ return result / oss->frame_bytes;
+}
+
+static snd_pcm_sframes_t oss_read(snd_pcm_ioplug_t *io,
+ const snd_pcm_channel_area_t *areas,
+ snd_pcm_uframes_t offset,
+ snd_pcm_uframes_t size)
+{
+ snd_pcm_oss_t *oss = io->private_data;
+ char *buf;
+ ssize_t result;
+
+ /* we handle only an interleaved buffer */
+ buf = (char *)areas->addr + (areas->first + areas->step * offset) / 8;
+ size *= oss->frame_bytes;
+ result = read(oss->fd, buf, size);
+ if (result <= 0)
+ return result;
+ return result / oss->frame_bytes;
+}
+
+static snd_pcm_sframes_t oss_pointer(snd_pcm_ioplug_t *io)
+{
+ snd_pcm_oss_t *oss = io->private_data;
+ struct count_info info;
+ int ptr;
+
+ if (ioctl(oss->fd, io->stream == SND_PCM_STREAM_PLAYBACK ?
+ SNDCTL_DSP_GETOPTR : SNDCTL_DSP_GETIPTR, &info) < 0) {
+ fprintf(stderr, "*** OSS: oss_pointer error\n");
+ return 0;
+ }
+ ptr = snd_pcm_bytes_to_frames(io->pcm, info.ptr);
+ return ptr;
+}
+
+static int oss_start(snd_pcm_ioplug_t *io)
+{
+ snd_pcm_oss_t *oss = io->private_data;
+ int tmp = io->stream == SND_PCM_STREAM_PLAYBACK ?
+ PCM_ENABLE_OUTPUT : PCM_ENABLE_INPUT;
+
+ if (ioctl(oss->fd, SNDCTL_DSP_SETTRIGGER, &tmp) < 0) {
+ fprintf(stderr, "*** OSS: trigger failed\n");
+ if (io->stream == SND_PCM_STREAM_CAPTURE)
+ /* fake read to trigger */
+ read(oss->fd, &tmp, 0);
+ }
+ return 0;
+}
+
+static int oss_stop(snd_pcm_ioplug_t *io)
+{
+ snd_pcm_oss_t *oss = io->private_data;
+ int tmp = 0;
+
+ ioctl(oss->fd, SNDCTL_DSP_SETTRIGGER, &tmp);
+ return 0;
+}
+
+static int oss_drain(snd_pcm_ioplug_t *io)
+{
+ snd_pcm_oss_t *oss = io->private_data;
+
+ if (io->stream == SND_PCM_STREAM_PLAYBACK)
+ ioctl(oss->fd, SNDCTL_DSP_SYNC);
+ return 0;
+}
+
+static int oss_prepare(snd_pcm_ioplug_t *io)
+{
+ snd_pcm_oss_t *oss = io->private_data;
+ int tmp;
+
+ ioctl(oss->fd, SNDCTL_DSP_RESET);
+
+ tmp = io->channels;
+ if (ioctl(oss->fd, SNDCTL_DSP_CHANNELS, &tmp) < 0) {
+ perror("SNDCTL_DSP_CHANNELS");
+ return -EINVAL;
+ }
+ tmp = oss->format;
+ if (ioctl(oss->fd, SNDCTL_DSP_SETFMT, &tmp) < 0) {
+ perror("SNDCTL_DSP_SETFMT");
+ return -EINVAL;
+ }
+ tmp = io->rate;
+ if (ioctl(oss->fd, SNDCTL_DSP_SPEED, &tmp) < 0 ||
+ tmp > io->rate * 1.01 || tmp < io->rate * 0.99) {
+ perror("SNDCTL_DSP_SPEED");
+ return -EINVAL;
+ }
+ return 0;
+}
+
+static int oss_hw_params(snd_pcm_ioplug_t *io,
+ snd_pcm_hw_params_t *params ATTRIBUTE_UNUSED)
+{
+ snd_pcm_oss_t *oss = io->private_data;
+ int i, tmp, err;
+ unsigned int period_bytes;
+ long oflags, flags;
+
+ oss->frame_bytes = (snd_pcm_format_physical_width(io->format) * io->channels) / 8;
+ switch (io->format) {
+ case SND_PCM_FORMAT_U8:
+ oss->format = AFMT_U8;
+ break;
+ case SND_PCM_FORMAT_S16_LE:
+ oss->format = AFMT_S16_LE;
+ break;
+ case SND_PCM_FORMAT_S16_BE:
+ oss->format = AFMT_S16_BE;
+ break;
+ default:
+ fprintf(stderr, "*** OSS: unsupported format %s\n", snd_pcm_format_name(io->format));
+ return -EINVAL;
+ }
+ period_bytes = io->period_size * oss->frame_bytes;
+ oss->period_shift = 0;
+ for (i = 31; i >= 4; i--) {
+ if (period_bytes & (1U << i)) {
+ oss->period_shift = i;
+ break;
+ }
+ }
+ if (! oss->period_shift) {
+ fprintf(stderr, "*** OSS: invalid period size %d\n", (int)io->period_size);
+ return -EINVAL;
+ }
+ oss->periods = io->buffer_size / io->period_size;
+
+ _retry:
+ tmp = oss->period_shift | (oss->periods << 16);
+ if (ioctl(oss->fd, SNDCTL_DSP_SETFRAGMENT, &tmp) < 0) {
+ if (! oss->fragment_set) {
+ perror("SNDCTL_DSP_SETFRAGMENT");
+ fprintf(stderr, "*** period shift = %d, periods = %d\n", oss->period_shift, oss->periods);
+ return -EINVAL;
+ }
+ /* OSS has no proper way to reinitialize the fragments */
+ /* try to reopen the device */
+ close(oss->fd);
+ oss->fd = open(oss->device, io->stream == SND_PCM_STREAM_PLAYBACK ?
+ O_WRONLY : O_RDONLY);
+ if (oss->fd < 0) {
+ err = -errno;
+ SNDERR("Cannot reopen the device %s", oss->device);
+ return err;
+ }
+ io->poll_fd = oss->fd;
+ io->poll_events = io->stream == SND_PCM_STREAM_PLAYBACK ?
+ POLLOUT : POLLIN;
+ snd_pcm_ioplug_reinit_status(io);
+ oss->fragment_set = 0;
+ goto _retry;
+ }
+ oss->fragment_set = 1;
+
+ if ((flags = fcntl(oss->fd, F_GETFL)) < 0) {
+ err = -errno;
+ perror("F_GETFL");
+ } else {
+ oflags = flags;
+ if (io->nonblock)
+ flags |= O_NONBLOCK;
+ else
+ flags &= ~O_NONBLOCK;
+ if (flags != oflags &&
+ fcntl(oss->fd, F_SETFL, flags) < 0) {
+ err = -errno;
+ perror("F_SETFL");
+ }
+ }
+
+ return 0;
+}
+
+#define ARRAY_SIZE(ary) (sizeof(ary)/sizeof(ary[0]))
+
+static int oss_hw_constraint(snd_pcm_oss_t *oss)
+{
+ snd_pcm_ioplug_t *io = &oss->io;
+ static const snd_pcm_access_t access_list[] = {
+ SND_PCM_ACCESS_RW_INTERLEAVED,
+ SND_PCM_ACCESS_MMAP_INTERLEAVED
+ };
+ unsigned int nformats;
+ unsigned int format[5];
+ unsigned int nchannels;
+ unsigned int channel[6];
+ /* period and buffer bytes must be power of two */
+ static const unsigned int bytes_list[] = {
+ 1U<<8, 1U<<9, 1U<<10, 1U<<11, 1U<<12, 1U<<13, 1U<<14, 1U<<15,
+ 1U<<16, 1U<<17, 1U<<18, 1U<<19, 1U<<20, 1U<<21, 1U<<22, 1U<<23
+ };
+ int i, err, tmp;
+
+ /* check trigger */
+ oss->caps = 0;
+ if (ioctl(oss->fd, SNDCTL_DSP_GETCAPS, &oss->caps) >= 0) {
+ if (! (oss->caps & DSP_CAP_TRIGGER))
+ fprintf(stderr, "*** OSS: trigger is not supported!\n");
+ }
+
+ /* access type - interleaved only */
+ if ((err = snd_pcm_ioplug_set_param_list(io, SND_PCM_IOPLUG_HW_ACCESS,
+ ARRAY_SIZE(access_list), access_list)) < 0)
+ return err;
+
+ /* supported formats */
+ tmp = 0;
+ ioctl(oss->fd, SNDCTL_DSP_GETFMTS, &tmp);
+ nformats = 0;
+ if (tmp & AFMT_U8)
+ format[nformats++] = SND_PCM_FORMAT_U8;
+ if (tmp & AFMT_S16_LE)
+ format[nformats++] = SND_PCM_FORMAT_S16_LE;
+ if (tmp & AFMT_S16_BE)
+ format[nformats++] = SND_PCM_FORMAT_S16_BE;
+ if (tmp & AFMT_MU_LAW)
+ format[nformats++] = SND_PCM_FORMAT_MU_LAW;
+ if (! nformats)
+ format[nformats++] = SND_PCM_FORMAT_S16;
+ if ((err = snd_pcm_ioplug_set_param_list(io, SND_PCM_IOPLUG_HW_FORMAT,
+ nformats, format)) < 0)
+ return err;
+
+ /* supported channels */
+ nchannels = 0;
+ for (i = 0; i < 6; i++) {
+ tmp = i + 1;
+ if (ioctl(oss->fd, SNDCTL_DSP_CHANNELS, &tmp) >= 0)
+ channel[nchannels++] = tmp;
+ }
+ if (! nchannels) /* assume 2ch stereo */
+ err = snd_pcm_ioplug_set_param_minmax(io, SND_PCM_IOPLUG_HW_CHANNELS,
+ 2, 2);
+ else
+ err = snd_pcm_ioplug_set_param_list(io, SND_PCM_IOPLUG_HW_CHANNELS,
+ nchannels, channel);
+ if (err < 0)
+ return err;
+
+ /* supported rates */
+ /* FIXME: should query? */
+ err = snd_pcm_ioplug_set_param_minmax(io, SND_PCM_IOPLUG_HW_RATE, 8000, 480000);
+ if (err < 0)
+ return err;
+
+ /* period size (in power of two) */
+ err = snd_pcm_ioplug_set_param_list(io, SND_PCM_IOPLUG_HW_PERIOD_BYTES,
+ ARRAY_SIZE(bytes_list), bytes_list);
+ if (err < 0)
+ return err;
+ /* periods */
+ err = snd_pcm_ioplug_set_param_minmax(io, SND_PCM_IOPLUG_HW_PERIODS, 2, 1024);
+ if (err < 0)
+ return err;
+ /* buffer size (in power of two) */
+ err = snd_pcm_ioplug_set_param_list(io, SND_PCM_IOPLUG_HW_BUFFER_BYTES,
+ ARRAY_SIZE(bytes_list), bytes_list);
+ if (err < 0)
+ return err;
+
+ return 0;
+}
+
+
+static int oss_close(snd_pcm_ioplug_t *io)
+{
+ snd_pcm_oss_t *oss = io->private_data;
+
+ close(oss->fd);
+ free(oss->device);
+ free(oss);
+ return 0;
+}
+
+static const snd_pcm_ioplug_callback_t oss_playback_callback = {
+ .start = oss_start,
+ .stop = oss_stop,
+ .transfer = oss_write,
+ .pointer = oss_pointer,
+ .close = oss_close,
+ .hw_params = oss_hw_params,
+ .prepare = oss_prepare,
+ .drain = oss_drain,
+};
+
+static const snd_pcm_ioplug_callback_t oss_capture_callback = {
+ .start = oss_start,
+ .stop = oss_stop,
+ .transfer = oss_read,
+ .pointer = oss_pointer,
+ .close = oss_close,
+ .hw_params = oss_hw_params,
+ .prepare = oss_prepare,
+ .drain = oss_drain,
+};
+
+
+SND_PCM_PLUGIN_DEFINE_FUNC(oss)
+{
+ snd_config_iterator_t i, next;
+ const char *device = "/dev/dsp";
+ int err;
+ snd_pcm_oss_t *oss;
+
+ snd_config_for_each(i, next, conf) {
+ snd_config_t *n = snd_config_iterator_entry(i);
+ const char *id;
+ if (snd_config_get_id(n, &id) < 0)
+ continue;
+ if (strcmp(id, "comment") == 0 || strcmp(id, "type") == 0 || strcmp(id, "hint") == 0)
+ continue;
+ if (strcmp(id, "device") == 0) {
+ if (snd_config_get_string(n, &device) < 0) {
+ SNDERR("Invalid type for %s", id);
+ return -EINVAL;
+ }
+ continue;
+ }
+ SNDERR("Unknown field %s", id);
+ return -EINVAL;
+ }
+
+ oss = calloc(1, sizeof(*oss));
+ if (! oss) {
+ SNDERR("cannot allocate");
+ return -ENOMEM;
+ }
+
+ oss->device = strdup(device);
+ if (oss->device == NULL) {
+ SNDERR("cannot allocate");
+ free(oss);
+ return -ENOMEM;
+ }
+ oss->fd = open(device, stream == SND_PCM_STREAM_PLAYBACK ?
+ O_WRONLY : O_RDONLY);
+ if (oss->fd < 0) {
+ err = -errno;
+ SNDERR("Cannot open device %s", device);
+ goto error;
+ }
+
+ oss->io.version = SND_PCM_IOPLUG_VERSION;
+ oss->io.name = "ALSA <-> OSS PCM I/O Plugin";
+ oss->io.poll_fd = oss->fd;
+ oss->io.poll_events = stream == SND_PCM_STREAM_PLAYBACK ? POLLOUT : POLLIN;
+ oss->io.mmap_rw = 0;
+ oss->io.callback = stream == SND_PCM_STREAM_PLAYBACK ?
+ &oss_playback_callback : &oss_capture_callback;
+ oss->io.private_data = oss;
+
+ err = snd_pcm_ioplug_create(&oss->io, name, stream, mode);
+ if (err < 0)
+ goto error;
+
+ if ((err = oss_hw_constraint(oss)) < 0) {
+ snd_pcm_ioplug_delete(&oss->io);
+ return err;
+ }
+
+ *pcmp = oss->io.pcm;
+ return 0;
+
+ error:
+ if (oss->fd >= 0)
+ close(oss->fd);
+ free(oss->device);
+ free(oss);
+ return err;
+}
+
+SND_PCM_PLUGIN_SYMBOL(oss);
diff --git a/HAL-afb/Scarlett-Focusrite/ScarlettUsbHAL.c b/HAL-afb/Scarlett-Focusrite/ScarlettUsbHAL.c
index 1ff5320..3b9ee4c 100644
--- a/HAL-afb/Scarlett-Focusrite/ScarlettUsbHAL.c
+++ b/HAL-afb/Scarlett-Focusrite/ScarlettUsbHAL.c
@@ -18,7 +18,7 @@
* To find out which control your sound card uses
* aplay -l # Check sndcard name name in between []
* amixer -D hw:xx controls # get supported controls
- * amixer -D "hw:3" cget numid=xx # get control settings
+ * amixer -D "hw:4" cget numid=xx # get control settings
*
*/
#define _GNU_SOURCE
@@ -41,11 +41,11 @@ STATIC struct json_object* MasterOnOff (alsaHalCtlMapT *control, void* handle) {
// Map HAL hight sndctl with Alsa numid and optionally with a custom callback for non Alsa supported functionalities.
STATIC alsaHalMapT alsaHalMap[]= {
- { .alsa={.control=Master_Playback_Volume,.numid=16, .name="Master-Vol" , .values=1,.minval=0,.maxval= 87 ,.step=0}, .info= "Master Playback Volume" },
- { .alsa={.control=PCM_Playback_Volume ,.numid=27, .name="Play-Vol" , .values=2,.minval=0,.maxval= 255,.step=0}, .info= "PCM Playback Volume" },
- { .alsa={.control=PCM_Playback_Switch ,.numid=17, .name="Play-Switch" , .values=1,.minval=0,.maxval= 1 ,.step=0}, .info= "Master Playback Switch" },
- { .alsa={.control=Capture_Volume ,.numid=12, .name="Capt-vol" , .values=2,.minval=0,.maxval= 31 ,.step=0}, .info= "Capture Volume" },
- { .alsa={.control=Master_OnOff_Switch ,.numid=99, .name="Power-Switch"}, .cb={.callback=MasterOnOff, .handle=NULL}, .info= "OnOff Global Switch"},
+ { .alsa={.control=Master_Playback_Volume,.numid=04, .name="Matrix 03 Mix A Playback Volume" , .values=1,.minval=0,.maxval= 87 ,.step=0}, .info= "Master Playback Volume" },
+ { .alsa={.control=PCM_Playback_Volume ,.numid=06, .name="play-vol" , .values=2,.minval=0,.maxval= 255,.step=0}, .info= "PCM Playback Volume" },
+ { .alsa={.control=PCM_Playback_Switch ,.numid=05, .name="play-switch" , .values=1,.minval=0,.maxval= 1 ,.step=0}, .info= "Master Playback Switch" },
+ { .alsa={.control=Capture_Volume ,.numid=12, .name="capt-vol" , .values=2,.minval=0,.maxval= 31 ,.step=0}, .info= "Capture Volume" },
+ { .alsa={.control=Master_OnOff_Switch, .name="Power-Switch"}, .cb={.callback=MasterOnOff, .handle=NULL}, .info= "OnOff Global Switch"},
{ .alsa={.numid=0}, .cb={.callback=NULL, .handle=NULL}} /* marker for end of the array */
} ;