path: root/tools/mako/csd-daemon.c

/* csd-daemon.c
**
** Copyright 2013, Mozilla Corporation
**
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are met:
**     * Redistributions of source code must retain the above copyright
**       notice, this list of conditions and the following disclaimer.
**     * Redistributions in binary form must reproduce the above copyright
**       notice, this list of conditions and the following disclaimer in the
**       documentation and/or other materials provided with the distribution.
**     * Neither the name of The Android Open Source Project nor the names of
**       its contributors may be used to endorse or promote products derived
**       from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY Mozilla Corporation ``AS IS'' AND
** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
** ARE DISCLAIMED. IN NO EVENT SHALL The Android Open Source Project BE LIABLE
** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
** SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
** CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
** DAMAGE.
*/

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <dlfcn.h>
#include <errno.h>
#include <unistd.h>
#include <poll.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <sys/un.h>

#include <asoundlib.h>

#define DEBUG 1
#include "common.h"

/* FIXME: we're always setting dmic + tty-off, is that always correct? */
#define ACDB_SETTINGS 0x12

struct state {
    int sockfd;
    int rx_dev, tx_dev;

    int start_voice, started_voice;
    int enabled_device;

    snd_pcm_t *play, *rec;
    snd_ctl_t *ctl;

    snd_ctl_elem_id_t *play_id, *rec_id;

    int volume;
    int mic_mute;

    struct pollfd *pollfds;
    int nfds;
};

static struct state state;

/* Based on prototypes in hardware/qcom/audio/hal/audio_hw.h */

int  (*acdb_loader_init_ACDB)();
void (*acdb_loader_deallocate_ACDB)();
void (*acdb_loader_send_audio_cal)(int, int);
void (*acdb_loader_send_voice_cal)(int, int);

int (*csd_client_init)(void);
int (*csd_client_deinit)(void);
int (*csd_client_disable_device)(void);
int (*csd_client_enable_device)(int, int, uint32_t);
int (*csd_client_volume)(int);
int (*csd_client_mic_mute)(int);
int (*csd_client_start_voice)(void);
int (*csd_client_stop_voice)(void);

static int init_lib(void)
{
    void *handle;

    handle = dlopen("/system/lib/libacdbloader.so", RTLD_NOW);

    acdb_loader_init_ACDB = dlsym(handle, "acdb_loader_init_ACDB");
    acdb_loader_deallocate_ACDB = dlsym(handle, "acdb_loader_deallocate_ACDB");
    acdb_loader_send_audio_cal = dlsym(handle, "acdb_loader_send_audio_cal");
    acdb_loader_send_voice_cal = dlsym(handle, "acdb_loader_send_voice_cal");

    if (!acdb_loader_init_ACDB || !acdb_loader_deallocate_ACDB ||
        !acdb_loader_send_audio_cal || !acdb_loader_send_voice_cal) {
        ERR("Could not find all acdb_loader_* functions\n");
        return -1;
    }

    handle = dlopen("/system/lib/libcsd-client.so", RTLD_NOW);

    csd_client_init = dlsym(handle, "csd_client_init");
    csd_client_deinit = dlsym(handle, "csd_client_deinit");
    csd_client_disable_device = dlsym(handle, "csd_client_disable_device");
    csd_client_enable_device = dlsym(handle, "csd_client_enable_device");
    csd_client_volume = dlsym(handle, "csd_client_volume");
    csd_client_mic_mute = dlsym(handle, "csd_client_mic_mute");
    csd_client_start_voice = dlsym(handle, "csd_client_start_voice");
    csd_client_stop_voice = dlsym(handle, "csd_client_stop_voice");

    if (!csd_client_init || !csd_client_deinit || !csd_client_disable_device ||
        !csd_client_enable_device || !csd_client_volume ||
        !csd_client_mic_mute || !csd_client_start_voice ||
        !csd_client_stop_voice) {
        ERR("Could not find all csd_client_* functions\n");
        return -1;
    }

    return 0;
}

static int init_daemon(void)
{
    struct stat st;
    struct sockaddr_un sa;

    state.rx_dev = state.tx_dev = -1;

    if (stat(DEFAULT_RUNTIME_DIR, &st) < 0) {
        if (errno != -ENOENT) {
            /* First run, try to create the directory */
            if (mkdir(DEFAULT_RUNTIME_DIR, 0700) < 0) {
                ERR("Could not create runtime directory\n");
                return -1;
            }
        } else {
            ERR("Could not access runtime directory\n");
            return -1;
        }
    }

    if ((state.sockfd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
        ERR("Could not create socket\n");
        return -1;
    }

    sa.sun_family = AF_UNIX;
    snprintf(sa.sun_path, sizeof(sa.sun_path), DEFAULT_SOCKET_PATH);

    if (stat(DEFAULT_SOCKET_PATH, &st) == 0) {
        /* Either a daemon is already running or this is a stale socket */
        if (connect(state.sockfd, (struct sockaddr *) &sa, sizeof(sa)) < 0 &&
            errno == ECONNREFUSED) {
            DBG("Removing stale socket\n");
            unlink(DEFAULT_SOCKET_PATH);
        } else {
            ERR("Found existing socket, daemon already running?\n");
            close(state.sockfd);
            return -1;
        }
    }

    if (bind(state.sockfd, (struct sockaddr *) &sa, sizeof(sa)) < 0) {
        ERR("Could not bind address\n");
        return -1;
    }

    if (listen(state.sockfd, 1) < 0) {
        ERR("Could not start listening for connections\n");
        return -1;
    }

    return 0;
}

#define MODEM_PCM "hw:apq8064tablasnd,12"

static int open_pcms(void)
{
    if (snd_pcm_open(&state.play, MODEM_PCM, SND_PCM_STREAM_PLAYBACK, 0) < 0) {
        ERR("Could not open playback device\n");
        return -1;
    }

    if (snd_pcm_open(&state.rec, MODEM_PCM, SND_PCM_STREAM_CAPTURE, 0) < 0) {
        ERR("Could not open capture device\n");
        return -1;
    }

    if (snd_pcm_set_params(state.play,
                           SND_PCM_FORMAT_S16_LE,
                           SND_PCM_ACCESS_RW_INTERLEAVED,
                           1,
                           8000,
                           0,
                           0) < 0) {
        ERR("Could not set playback params\n");
        return -1;
    }

    if (snd_pcm_set_params(state.rec,
                           SND_PCM_FORMAT_S16_LE,
                           SND_PCM_ACCESS_RW_INTERLEAVED,
                           1,
                           8000,
                           0,
                           0) < 0) {
        ERR("Could not set capture params\n");
        return -1;
    }

    if (snd_pcm_start(state.play) < 0) {
        ERR("Could not start playback PCM\n");
        return -1;
    }

    if (snd_pcm_start(state.rec) < 0) {
        ERR("Could not start capture PCM\n");
        return -1;
    }

    return 0;
}

static void close_pcms(void)
{
    if (state.play) {
        snd_pcm_close(state.play);
        state.play = NULL;
    }

    if (state.rec) {
        snd_pcm_close(state.rec);
        state.rec = NULL;
    }
}

static void remove_user_ctls(void)
{
    snd_ctl_subscribe_events(state.ctl, 0);

    if (state.play_id) {
        snd_ctl_elem_remove(state.ctl, state.play_id);
        state.play_id = NULL;
    }

    if (state.rec_id) {
        snd_ctl_elem_remove(state.ctl, state.rec_id);
        state.rec_id = NULL;
    }

    if (state.ctl) {
        snd_ctl_close(state.ctl);
        state.ctl = NULL;
    }
}

static void set_volume(int volume)
{
    if (state.volume == volume)
        return;

    if (csd_client_volume(100 - volume) < 0)
        ERR("Could not set volume");
    else
        state.volume = volume;
}

static void set_mic_mute(int mic_mute)
{
    if (state.mic_mute == mic_mute)
        return;

    if (csd_client_mic_mute(mic_mute) < 0)
        ERR("Could not set mic_mute");
    else
        state.mic_mute = mic_mute;
}

static void handle_play_volume()
{
    snd_ctl_elem_value_t *elem;

    snd_ctl_elem_value_alloca(&elem);
    snd_ctl_elem_value_set_id(elem, state.play_id);

    if (snd_ctl_elem_read(state.ctl, elem) < 0) {
        ERR("Error reading volume value\n");
        return;
    }

    set_volume(snd_ctl_elem_value_get_integer(elem, 0));
    DBG("Volume set to: %d\n", state.volume);
}

static void handle_mic_switch()
{
    snd_ctl_elem_value_t *elem;

    snd_ctl_elem_value_alloca(&elem);
    snd_ctl_elem_value_set_id(elem, state.rec_id);

    if (snd_ctl_elem_read(state.ctl, elem) < 0) {
        ERR("Error reading mic mute value\n");
        return;
    }

    set_mic_mute(1 - snd_ctl_elem_value_get_boolean(elem, 0));
    DBG("Mic mute set to: %d\n", state.mic_mute);
}

#define CTL_DEVICE "hw:0"

static int create_user_ctls(void)
{
    snd_ctl_elem_value_t *elem;
    int err;

    if (snd_ctl_open(&state.ctl, CTL_DEVICE, SND_CTL_NONBLOCK) < 0) {
        ERR("Could not open playback ctl device\n");
        goto error;
    }

    snd_ctl_elem_id_malloc(&state.play_id);
    snd_ctl_elem_id_set_interface(state.play_id, SND_CTL_ELEM_IFACE_MIXER);
    snd_ctl_elem_id_set_name(state.play_id, "Voice Call Playback Volume");
    snd_ctl_elem_id_set_device(state.play_id, 0);
    snd_ctl_elem_id_set_subdevice(state.play_id, 0);

    /* We ignore -EEXIST to make things more robust if a previous instance of
     * csd-daemon didn't clean up properly */
    err = snd_ctl_elem_add_integer(state.ctl, state.play_id, 1, 0, 100, 1);
    if (err < 0 && err != -EEXIST) {
        ERR("Could not add voice call playback volume control (%d)\n", err);
        goto error;
    }

    snd_ctl_elem_id_malloc(&state.rec_id);
    snd_ctl_elem_id_set_interface(state.rec_id, SND_CTL_ELEM_IFACE_MIXER);
    snd_ctl_elem_id_set_name(state.rec_id, "Voice Call Capture Switch");
    snd_ctl_elem_id_set_device(state.rec_id, 0);
    snd_ctl_elem_id_set_subdevice(state.rec_id, 0);

    err = snd_ctl_elem_add_boolean(state.ctl, state.rec_id, 1);
    if (err < 0 && err != -EEXIST) {
        ERR("Could not add voice call capture switch (%d)\n", err);
        goto error;
    }

    snd_ctl_elem_unlock(state.ctl, state.play_id);
    snd_ctl_elem_unlock(state.ctl, state.rec_id);

    if (snd_ctl_subscribe_events(state.ctl, 1) < 0) {
        ERR("Could not subscribe to mixer events");
        goto error;
    }

    snd_ctl_elem_value_alloca(&elem);

    snd_ctl_elem_value_set_id(elem, state.play_id);
    snd_ctl_elem_value_set_integer(elem, 0, 100);
    if ((err = snd_ctl_elem_write(state.ctl, elem)) < 0)
        ERR("Could not set volume: %d", err);

    snd_ctl_elem_value_set_id(elem, state.rec_id);
    snd_ctl_elem_value_set_boolean(elem, 0, 1);
    if ((err = snd_ctl_elem_write(state.ctl, elem)) < 0)
        ERR("Could not set mic mute: %d", err);

    return 0;

error:
    remove_user_ctls();
    return -1;
}

static int prepare_poll(void)
{
    int i;

    state.nfds = 1 /* socket */ + snd_ctl_poll_descriptors_count(state.ctl);
    state.pollfds = (struct pollfd *) calloc(state.nfds, sizeof(struct pollfd));

    state.pollfds[0].fd = state.sockfd;
    state.pollfds[0].events = POLLIN;

    i = snd_ctl_poll_descriptors(state.ctl, &state.pollfds[1], state.nfds - 1);
    if (i != state.nfds - 1) {
        ERR("Got a wrong number of pollfds\n");
        return -1;
    }

    for (i = 1; i < state.nfds; i++)
        state.pollfds[i].events = POLLIN;

    return 0;
}

static int start_voice(void)
{
    int ret;

    state.start_voice = 0;
    ret = csd_client_start_voice();

    if (ret == 0) {
        state.started_voice = 1;

        DBG("Opening PCMs\n");
        ret = open_pcms();
    }

    return ret;
}

static int enable_device(void)
{
    int ret = 0;

    if (ret == 0) {
        ret = csd_client_enable_device(state.rx_dev, state.tx_dev,
                                       ACDB_SETTINGS);

        if (ret == 0) {
            state.enabled_device = 1;

            if (state.start_voice)
                ret = start_voice();
        }
    }

    return ret;
}

/* Return negative value to signal death (currently only returns 0 */
static int process(const char *command)
{
    int32_t ret = 0;

    if (strncmp(command, "enable-rx-device", 16) == 0) {
        if (sscanf(command, "%*s %d", &state.rx_dev) != 1) {
            ERR("Bad argument to enable-rx-device\n");
            goto out;
        }

        DBG("enable rx device: %d\n", state.rx_dev);

        /* Only enable device after we get both rx and tx device */
        if (state.rx_dev != -1 && state.tx_dev != -1)
            ret = enable_device();

    } else if (strncmp(command, "enable-tx-device", 16) == 0) {
        if (sscanf(command, "%*s %d", &state.tx_dev) != 1) {
            ERR("Bad argument to enable-tx-device\n");
            goto out;
        }

        DBG("enable tx device: %d\n", state.tx_dev);

        /* Only enable device after we get both rx and tx device */
        if (state.rx_dev != -1 && state.tx_dev != -1)
            ret = enable_device();

    } else if (strcmp(command, "disable-device") == 0) {
        /* We need to disable the device before an enable-device and ignore for
         * stop-voice. Since we don't know what's coming next, we wait for
         * these to happen before actually executing the command. */
        ret = csd_client_disable_device();
        state.enabled_device = 0;

    } else if (strncmp(command, "volume", 6) == 0) {
        int volume;

        if (sscanf(command, "%*s %d", &volume) != 1) {
            ERR("Bad volume\n");
            goto out;
        }

        ret = csd_client_volume(volume);

    } else if (strncmp(command, "mic-mute", 8) == 0) {
        int state;

        if (sscanf(command, "%*s %d", &state) != 1 || (state != 0 && state != 1)) {
            ERR("Bad volume\n");
            goto out;
        }

        ret = csd_client_mic_mute(state);

    } else if (strcmp(command, "start-voice") == 0) {
        if (state.rx_dev != -1 && state.tx_dev != -1)
            ret = start_voice();
        else {
            DBG("Deferring start voice till devices are enabled\n");
            state.start_voice = 1;
            ret = 0;
        }

    } else if (strcmp(command, "stop-voice") == 0) {
        if (state.started_voice) {
            if (!state.enabled_device) {
                /* Run a fake enable device because the firmware can't deal
                 * with a stop-voice after disable-device */
                if (csd_client_enable_device(7, 6, ACDB_SETTINGS) < 0)
                    ERR("Error enabling device before shutdown\n");
            }

            ret = csd_client_stop_voice();

            DBG("Closing PCMs\n");
            close_pcms();

        } else
            DBG("Ignoring stop-voice before start-voice was executed\n");

        /* Reset all the things */
        state.start_voice = state.started_voice = 0;
        state.enabled_device = 0;
        state.rx_dev = state.tx_dev = -1;

    } else {
        ERR("Bad command: %s\n", command);
    }

    if (ret < 0)
        ERR("Error running command\n");

    /* For now, there are no fatal errors */

out:
    return 0;
}

int main(int argc, char **argv)
{
    char command[COMMAND_MAX];
    int child, fd, done = 0, ret = 0;
    unsigned int i;
    unsigned short revents;

    if (argc > 1) {
        ERR("Bad arguments\n");
        return -1;
    }

    /* Make our socket readable by only us and the parent */
    umask(0077);

    if (init_lib() < 0)
        return -1;

    if (init_daemon() < 0)
        return -1;

    if (create_user_ctls() < 0)
        return -1;

    /* Basic setup was successful, so clients try to connect. Daemonize before
     * making any actual library init, else nothing will work. */
    if ((child = fork()) < 0) {
        ERR("Could not daemonize");
        return -1;
    }

    if (child > 0) {
        /* This is the parent, exit */
        return 0;
    }

    /* Child process, don't need to double-fork since in most cases we're not
     * actually being run from a terminal. */

    if ((ret = acdb_loader_init_ACDB()) < 0) {
        ERR("Could not initialise acdb loader\n");
        return ret;
    }

    if ((ret = csd_client_init()) < 0) {
        ERR("Could not initialise csd client\n");
        return ret;
    }

    if ((ret = prepare_poll()) < 0) {
        ERR("Could not set up poll()\n");
        return ret;
    }

    while (!done) {
        ret = poll(state.pollfds, state.nfds, -1);
        if (ret < 0) {
            ERR("Error in poll()\n");
            break;
        }

        if ((ret = snd_ctl_poll_descriptors_revents(state.ctl,
                                                    &state.pollfds[1],
                                                    state.nfds - 1,
                                                    &revents)) < 0) {
            ERR("Could not get ALSA revents\n");
        } else {
            if (revents) {
                snd_ctl_event_t *event;

                /* Just force update */
                handle_play_volume();
                handle_mic_switch();

                /* Now consume all pending events */
                snd_ctl_event_alloca(&event);
                do {
                    ret = snd_ctl_read(state.ctl, event);
                } while (ret != 0 && ret != -EAGAIN);
            }
        }

        if (state.pollfds[0].revents == 0)
            continue;

        /* Got a connection */

        fd = accept(state.sockfd, NULL, NULL);

        if (fd < 0) {
            ERR("Could not accept incoming connection\n");
            continue;
        }

        /* We now read one "command" which is a string terminated with a NULL */
        for (i = 0; i < sizeof(command); i++) {
            if (read(fd, &command[i], 1) != 1) {
                ERR("Error reading command. Ignoring.\n");
                goto next;
            }

            if (command[i] == '\0') {
                DBG("Got command: %s\n", command);
                break;
            }
        }

        if (strcmp(command, "quit") == 0) {
            DBG("Got quit message. Exiting.\n");
            done = 1;
        } else if (process(command) < 0) {
            ERR("Fatal error while processing commands. Exiting.\n");
            ret = -1;
            done = 1;
        }

        /* Send back return code */
        if (write(fd, &ret, 4) < 4)
            ERR("Error sending return code");

next:
        close(fd);
    }

out:
    close(state.sockfd);

    if (state.pollfds)
        free(state.pollfds);

    remove_user_ctls();

    /* Clearly deinitialisation is for the weak - this breaks the radio
     * firmware until reboot! */
#if 0
    csd_client_deinit();
    acdb_loader_deallocate_ACDB();
#endif

    return ret;
}