| /* Copyright (c) 2012 The Chromium OS Authors. All rights reserved. |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include <syslog.h> |
| |
| #include "audio_thread.h" |
| #include "cras_empty_iodev.h" |
| #include "cras_iodev.h" |
| #include "cras_iodev_info.h" |
| #include "cras_iodev_list.h" |
| #include "cras_loopback_iodev.h" |
| #include "cras_main_thread_log.h" |
| #include "cras_observer.h" |
| #include "cras_rstream.h" |
| #include "cras_server.h" |
| #include "cras_tm.h" |
| #include "cras_types.h" |
| #include "cras_system_state.h" |
| #include "server_stream.h" |
| #include "softvol_curve.h" |
| #include "stream_list.h" |
| #include "test_iodev.h" |
| #include "utlist.h" |
| |
| const struct timespec idle_timeout_interval = { .tv_sec = 10, .tv_nsec = 0 }; |
| |
| /* Linked list of available devices. */ |
| struct iodev_list { |
| struct cras_iodev *iodevs; |
| size_t size; |
| }; |
| |
| /* List of enabled input/output devices. |
| * dev - The device. |
| * init_timer - Timer for a delayed call to init this iodev. |
| */ |
| struct enabled_dev { |
| struct cras_iodev *dev; |
| struct enabled_dev *prev, *next; |
| }; |
| |
| struct dev_init_retry { |
| int dev_idx; |
| struct cras_timer *init_timer; |
| struct dev_init_retry *next, *prev; |
| }; |
| |
| struct device_enabled_cb { |
| device_enabled_callback_t enabled_cb; |
| device_disabled_callback_t disabled_cb; |
| void *cb_data; |
| struct device_enabled_cb *next, *prev; |
| }; |
| |
| struct main_thread_event_log *main_log; |
| |
| /* Lists for devs[CRAS_STREAM_INPUT] and devs[CRAS_STREAM_OUTPUT]. */ |
| static struct iodev_list devs[CRAS_NUM_DIRECTIONS]; |
| /* The observer client iodev_list used to listen on various events. */ |
| static struct cras_observer_client *list_observer; |
| /* Keep a list of enabled inputs and outputs. */ |
| static struct enabled_dev *enabled_devs[CRAS_NUM_DIRECTIONS]; |
| /* Keep an empty device per direction. */ |
| static struct cras_iodev *fallback_devs[CRAS_NUM_DIRECTIONS]; |
| /* Special empty device for hotword streams. */ |
| static struct cras_iodev *empty_hotword_dev; |
| /* Loopback devices. */ |
| static struct cras_iodev *loopdev_post_mix; |
| static struct cras_iodev *loopdev_post_dsp; |
| /* List of pending device init retries. */ |
| static struct dev_init_retry *init_retries; |
| |
| /* Keep a constantly increasing index for iodevs. Index 0 is reserved |
| * to mean "no device". */ |
| static uint32_t next_iodev_idx = MAX_SPECIAL_DEVICE_IDX; |
| |
| /* Call when a device is enabled or disabled. */ |
| struct device_enabled_cb *device_enable_cbs; |
| |
| /* Thread that handles audio input and output. */ |
| static struct audio_thread *audio_thread; |
| /* List of all streams. */ |
| static struct stream_list *stream_list; |
| /* Idle device timer. */ |
| static struct cras_timer *idle_timer; |
| /* Flag to indicate that the stream list is disconnected from audio thread. */ |
| static int stream_list_suspended = 0; |
| /* If init device failed, retry after 1 second. */ |
| static const unsigned int INIT_DEV_DELAY_MS = 1000; |
| /* Flag to indicate that hotword streams are suspended. */ |
| static int hotword_suspended = 0; |
| /* Flag to indicate that suspended hotword streams should be auto-resumed at |
| * system resume. */ |
| static int hotword_auto_resume = 0; |
| |
| static void idle_dev_check(struct cras_timer *timer, void *data); |
| |
| static struct cras_iodev *find_dev(size_t dev_index) |
| { |
| struct cras_iodev *dev; |
| |
| DL_FOREACH (devs[CRAS_STREAM_OUTPUT].iodevs, dev) |
| if (dev->info.idx == dev_index) |
| return dev; |
| |
| DL_FOREACH (devs[CRAS_STREAM_INPUT].iodevs, dev) |
| if (dev->info.idx == dev_index) |
| return dev; |
| |
| return NULL; |
| } |
| |
| static struct cras_ionode *find_node(struct cras_iodev *iodev, |
| unsigned int node_idx) |
| { |
| struct cras_ionode *node; |
| DL_SEARCH_SCALAR(iodev->nodes, node, idx, node_idx); |
| return node; |
| } |
| |
| /* Adds a device to the list. Used from add_input and add_output. */ |
| static int add_dev_to_list(struct cras_iodev *dev) |
| { |
| struct cras_iodev *tmp; |
| uint32_t new_idx; |
| struct iodev_list *list = &devs[dev->direction]; |
| |
| DL_FOREACH (list->iodevs, tmp) |
| if (tmp == dev) |
| return -EEXIST; |
| |
| dev->format = NULL; |
| dev->format = NULL; |
| dev->prev = dev->next = NULL; |
| |
| /* Move to the next index and make sure it isn't taken. */ |
| new_idx = next_iodev_idx; |
| while (1) { |
| if (new_idx < MAX_SPECIAL_DEVICE_IDX) |
| new_idx = MAX_SPECIAL_DEVICE_IDX; |
| DL_SEARCH_SCALAR(list->iodevs, tmp, info.idx, new_idx); |
| if (tmp == NULL) |
| break; |
| new_idx++; |
| } |
| dev->info.idx = new_idx; |
| next_iodev_idx = new_idx + 1; |
| list->size++; |
| |
| syslog(LOG_INFO, "Adding %s dev at index %u.", |
| dev->direction == CRAS_STREAM_OUTPUT ? "output" : "input", |
| dev->info.idx); |
| DL_PREPEND(list->iodevs, dev); |
| |
| cras_iodev_list_update_device_list(); |
| return 0; |
| } |
| |
| /* Removes a device to the list. Used from rm_input and rm_output. */ |
| static int rm_dev_from_list(struct cras_iodev *dev) |
| { |
| struct cras_iodev *tmp; |
| |
| DL_FOREACH (devs[dev->direction].iodevs, tmp) |
| if (tmp == dev) { |
| if (cras_iodev_is_open(dev)) |
| return -EBUSY; |
| DL_DELETE(devs[dev->direction].iodevs, dev); |
| devs[dev->direction].size--; |
| return 0; |
| } |
| |
| /* Device not found. */ |
| return -EINVAL; |
| } |
| |
| /* Fills a dev_info array from the iodev_list. */ |
| static void fill_dev_list(struct iodev_list *list, |
| struct cras_iodev_info *dev_info, size_t out_size) |
| { |
| int i = 0; |
| struct cras_iodev *tmp; |
| DL_FOREACH (list->iodevs, tmp) { |
| memcpy(&dev_info[i], &tmp->info, sizeof(dev_info[0])); |
| i++; |
| if (i == out_size) |
| return; |
| } |
| } |
| |
| static const char *node_type_to_str(struct cras_ionode *node) |
| { |
| switch (node->type) { |
| case CRAS_NODE_TYPE_INTERNAL_SPEAKER: |
| return "INTERNAL_SPEAKER"; |
| case CRAS_NODE_TYPE_HEADPHONE: |
| return "HEADPHONE"; |
| case CRAS_NODE_TYPE_HDMI: |
| return "HDMI"; |
| case CRAS_NODE_TYPE_HAPTIC: |
| return "HAPTIC"; |
| case CRAS_NODE_TYPE_MIC: |
| switch (node->position) { |
| case NODE_POSITION_INTERNAL: |
| return "INTERNAL_MIC"; |
| case NODE_POSITION_FRONT: |
| return "FRONT_MIC"; |
| case NODE_POSITION_REAR: |
| return "REAR_MIC"; |
| case NODE_POSITION_KEYBOARD: |
| return "KEYBOARD_MIC"; |
| case NODE_POSITION_EXTERNAL: |
| default: |
| return "MIC"; |
| } |
| case CRAS_NODE_TYPE_HOTWORD: |
| return "HOTWORD"; |
| case CRAS_NODE_TYPE_LINEOUT: |
| return "LINEOUT"; |
| case CRAS_NODE_TYPE_POST_MIX_PRE_DSP: |
| return "POST_MIX_LOOPBACK"; |
| case CRAS_NODE_TYPE_POST_DSP: |
| return "POST_DSP_LOOPBACK"; |
| case CRAS_NODE_TYPE_USB: |
| return "USB"; |
| case CRAS_NODE_TYPE_BLUETOOTH: |
| return "BLUETOOTH"; |
| case CRAS_NODE_TYPE_BLUETOOTH_NB_MIC: |
| return "BLUETOOTH_NB_MIC"; |
| case CRAS_NODE_TYPE_FALLBACK_NORMAL: |
| return "FALLBACK_NORMAL"; |
| case CRAS_NODE_TYPE_FALLBACK_ABNORMAL: |
| return "FALLBACK_ABNORMAL"; |
| case CRAS_NODE_TYPE_ECHO_REFERENCE: |
| return "ECHO_REFERENCE"; |
| case CRAS_NODE_TYPE_ALSA_LOOPBACK: |
| return "ALSA_LOOPBACK"; |
| case CRAS_NODE_TYPE_UNKNOWN: |
| default: |
| return "UNKNOWN"; |
| } |
| } |
| |
| /* Fills an ionode_info array from the iodev_list. */ |
| static int fill_node_list(struct iodev_list *list, |
| struct cras_ionode_info *node_info, size_t out_size) |
| { |
| int i = 0; |
| struct cras_iodev *dev; |
| struct cras_ionode *node; |
| DL_FOREACH (list->iodevs, dev) { |
| DL_FOREACH (dev->nodes, node) { |
| node_info->iodev_idx = dev->info.idx; |
| node_info->ionode_idx = node->idx; |
| node_info->plugged = node->plugged; |
| node_info->plugged_time.tv_sec = |
| node->plugged_time.tv_sec; |
| node_info->plugged_time.tv_usec = |
| node->plugged_time.tv_usec; |
| node_info->active = |
| dev->is_enabled && (dev->active_node == node); |
| node_info->volume = node->volume; |
| node_info->capture_gain = node->capture_gain; |
| node_info->ui_gain_scaler = node->ui_gain_scaler; |
| node_info->left_right_swapped = |
| node->left_right_swapped; |
| node_info->stable_id = node->stable_id; |
| strcpy(node_info->name, node->name); |
| strcpy(node_info->active_hotword_model, |
| node->active_hotword_model); |
| snprintf(node_info->type, sizeof(node_info->type), "%s", |
| node_type_to_str(node)); |
| node_info->type_enum = node->type; |
| node_info++; |
| i++; |
| if (i == out_size) |
| return i; |
| } |
| } |
| return i; |
| } |
| |
| /* Copies the info for each device in the list to "list_out". */ |
| static int get_dev_list(struct iodev_list *list, |
| struct cras_iodev_info **list_out) |
| { |
| struct cras_iodev_info *dev_info; |
| |
| if (!list_out) |
| return list->size; |
| |
| *list_out = NULL; |
| if (list->size == 0) |
| return 0; |
| |
| dev_info = malloc(sizeof(*list_out[0]) * list->size); |
| if (dev_info == NULL) |
| return -ENOMEM; |
| |
| fill_dev_list(list, dev_info, list->size); |
| |
| *list_out = dev_info; |
| return list->size; |
| } |
| |
| /* Called when the system volume changes. Pass the current volume setting to |
| * the default output if it is active. */ |
| static void sys_vol_change(void *context, int32_t volume) |
| { |
| struct cras_iodev *dev; |
| |
| DL_FOREACH (devs[CRAS_STREAM_OUTPUT].iodevs, dev) { |
| if (dev->set_volume && cras_iodev_is_open(dev)) |
| dev->set_volume(dev); |
| } |
| } |
| |
| /* Called when the system mute state changes. Pass the current mute setting |
| * to the default output if it is active. */ |
| static void sys_mute_change(void *context, int muted, int user_muted, |
| int mute_locked) |
| { |
| struct cras_iodev *dev; |
| int should_mute = muted || user_muted; |
| |
| DL_FOREACH (devs[CRAS_STREAM_OUTPUT].iodevs, dev) { |
| if (!cras_iodev_is_open(dev)) { |
| /* For closed devices, just set its mute state. */ |
| cras_iodev_set_mute(dev); |
| } else { |
| audio_thread_dev_start_ramp( |
| audio_thread, dev->info.idx, |
| (should_mute ? |
| CRAS_IODEV_RAMP_REQUEST_DOWN_MUTE : |
| CRAS_IODEV_RAMP_REQUEST_UP_UNMUTE)); |
| } |
| } |
| } |
| |
| static void remove_all_streams_from_dev(struct cras_iodev *dev) |
| { |
| struct cras_rstream *rstream; |
| |
| audio_thread_rm_open_dev(audio_thread, dev->direction, dev->info.idx); |
| |
| DL_FOREACH (stream_list_get(stream_list), rstream) { |
| if (rstream->apm_list == NULL) |
| continue; |
| cras_apm_list_remove_apm(rstream->apm_list, dev); |
| } |
| } |
| |
| /* |
| * If output dev has an echo reference dev associated, add a server |
| * stream to read audio data from it so APM can analyze. |
| */ |
| static void possibly_enable_echo_reference(struct cras_iodev *dev) |
| { |
| if (dev->direction != CRAS_STREAM_OUTPUT) |
| return; |
| |
| if (dev->echo_reference_dev == NULL) |
| return; |
| |
| server_stream_create(stream_list, dev->echo_reference_dev->info.idx, |
| dev->format); |
| } |
| |
| /* |
| * If output dev has an echo reference dev associated, check if there |
| * is server stream opened for it and remove it. |
| */ |
| static void possibly_disable_echo_reference(struct cras_iodev *dev) |
| { |
| if (dev->echo_reference_dev == NULL) |
| return; |
| |
| server_stream_destroy(stream_list, dev->echo_reference_dev->info.idx); |
| } |
| |
| /* |
| * Removes all attached streams and close dev if it's opened. |
| */ |
| static void close_dev(struct cras_iodev *dev) |
| { |
| if (!cras_iodev_is_open(dev)) |
| return; |
| |
| MAINLOG(main_log, MAIN_THREAD_DEV_CLOSE, dev->info.idx, 0, 0); |
| remove_all_streams_from_dev(dev); |
| dev->idle_timeout.tv_sec = 0; |
| /* close echo ref first to avoid underrun in hardware */ |
| possibly_disable_echo_reference(dev); |
| cras_iodev_close(dev); |
| } |
| |
| static void idle_dev_check(struct cras_timer *timer, void *data) |
| { |
| struct enabled_dev *edev; |
| struct timespec now; |
| struct timespec min_idle_expiration; |
| unsigned int num_idle_devs = 0; |
| unsigned int min_idle_timeout_ms; |
| |
| clock_gettime(CLOCK_MONOTONIC_RAW, &now); |
| min_idle_expiration.tv_sec = 0; |
| min_idle_expiration.tv_nsec = 0; |
| |
| DL_FOREACH (enabled_devs[CRAS_STREAM_OUTPUT], edev) { |
| if (edev->dev->idle_timeout.tv_sec == 0) |
| continue; |
| if (timespec_after(&now, &edev->dev->idle_timeout)) { |
| close_dev(edev->dev); |
| continue; |
| } |
| num_idle_devs++; |
| if (min_idle_expiration.tv_sec == 0 || |
| timespec_after(&min_idle_expiration, |
| &edev->dev->idle_timeout)) |
| min_idle_expiration = edev->dev->idle_timeout; |
| } |
| |
| idle_timer = NULL; |
| if (!num_idle_devs) |
| return; |
| if (timespec_after(&now, &min_idle_expiration)) { |
| min_idle_timeout_ms = 0; |
| } else { |
| struct timespec timeout; |
| subtract_timespecs(&min_idle_expiration, &now, &timeout); |
| min_idle_timeout_ms = timespec_to_ms(&timeout); |
| } |
| /* Wake up when it is time to close the next idle device. Sleep for a |
| * minimum of 10 milliseconds. */ |
| idle_timer = cras_tm_create_timer(cras_system_state_get_tm(), |
| MAX(min_idle_timeout_ms, 10), |
| idle_dev_check, NULL); |
| } |
| |
| /* |
| * Cancel pending init tries. Called at device initialization or when device |
| * is disabled. |
| */ |
| static void cancel_pending_init_retries(unsigned int dev_idx) |
| { |
| struct dev_init_retry *retry; |
| |
| DL_FOREACH (init_retries, retry) { |
| if (retry->dev_idx != dev_idx) |
| continue; |
| cras_tm_cancel_timer(cras_system_state_get_tm(), |
| retry->init_timer); |
| DL_DELETE(init_retries, retry); |
| free(retry); |
| } |
| } |
| |
| /* Open the device potentially filling the output with a pre buffer. */ |
| static int init_device(struct cras_iodev *dev, struct cras_rstream *rstream) |
| { |
| int rc; |
| |
| cras_iodev_exit_idle(dev); |
| |
| if (cras_iodev_is_open(dev)) |
| return 0; |
| cancel_pending_init_retries(dev->info.idx); |
| MAINLOG(main_log, MAIN_THREAD_DEV_INIT, dev->info.idx, |
| rstream->format.num_channels, rstream->format.frame_rate); |
| |
| rc = cras_iodev_open(dev, rstream->cb_threshold, &rstream->format); |
| if (rc) |
| return rc; |
| |
| rc = audio_thread_add_open_dev(audio_thread, dev); |
| if (rc) |
| cras_iodev_close(dev); |
| |
| possibly_enable_echo_reference(dev); |
| |
| return rc; |
| } |
| |
| static void suspend_devs() |
| { |
| struct enabled_dev *edev; |
| struct cras_rstream *rstream; |
| |
| MAINLOG(main_log, MAIN_THREAD_SUSPEND_DEVS, 0, 0, 0); |
| |
| DL_FOREACH (stream_list_get(stream_list), rstream) { |
| if (rstream->is_pinned) { |
| struct cras_iodev *dev; |
| |
| /* Skip closing hotword stream in the first pass. |
| * Closing an input device may resume hotword stream |
| * with its post_close_iodev_hook so we should deal |
| * with hotword stream in the second pass. |
| */ |
| if ((rstream->flags & HOTWORD_STREAM) == HOTWORD_STREAM) |
| continue; |
| |
| dev = find_dev(rstream->pinned_dev_idx); |
| if (dev) { |
| audio_thread_disconnect_stream(audio_thread, |
| rstream, dev); |
| if (!cras_iodev_list_dev_is_enabled(dev)) |
| close_dev(dev); |
| } |
| } else { |
| audio_thread_disconnect_stream(audio_thread, rstream, |
| NULL); |
| } |
| } |
| stream_list_suspended = 1; |
| |
| DL_FOREACH (enabled_devs[CRAS_STREAM_OUTPUT], edev) { |
| close_dev(edev->dev); |
| } |
| DL_FOREACH (enabled_devs[CRAS_STREAM_INPUT], edev) { |
| close_dev(edev->dev); |
| } |
| |
| /* Doing this check after all the other enabled iodevs are closed to |
| * ensure preempted hotword streams obey the pause_at_suspend flag. |
| */ |
| if (cras_system_get_hotword_pause_at_suspend()) { |
| cras_iodev_list_suspend_hotword_streams(); |
| hotword_auto_resume = 1; |
| } |
| } |
| |
| static int stream_added_cb(struct cras_rstream *rstream); |
| |
| static void resume_devs() |
| { |
| struct enabled_dev *edev; |
| struct cras_rstream *rstream; |
| |
| int has_output_stream = 0; |
| stream_list_suspended = 0; |
| |
| MAINLOG(main_log, MAIN_THREAD_RESUME_DEVS, 0, 0, 0); |
| |
| /* Auto-resume based on the local flag in case the system state flag has |
| * changed. |
| */ |
| if (hotword_auto_resume) { |
| cras_iodev_list_resume_hotword_stream(); |
| hotword_auto_resume = 0; |
| } |
| |
| /* |
| * To remove the short popped noise caused by applications that can not |
| * stop playback "right away" after resume, we mute all output devices |
| * for a short time if there is any output stream. |
| */ |
| DL_FOREACH (stream_list_get(stream_list), rstream) { |
| if (rstream->direction == CRAS_STREAM_OUTPUT) |
| has_output_stream++; |
| } |
| if (has_output_stream) { |
| DL_FOREACH (enabled_devs[CRAS_STREAM_OUTPUT], edev) { |
| edev->dev->initial_ramp_request = |
| CRAS_IODEV_RAMP_REQUEST_RESUME_MUTE; |
| } |
| } |
| |
| DL_FOREACH (stream_list_get(stream_list), rstream) { |
| if ((rstream->flags & HOTWORD_STREAM) == HOTWORD_STREAM) |
| continue; |
| stream_added_cb(rstream); |
| } |
| } |
| |
| /* Called when the system audio is suspended or resumed. */ |
| void sys_suspend_change(void *arg, int suspended) |
| { |
| if (suspended) |
| suspend_devs(); |
| else |
| resume_devs(); |
| } |
| |
| /* Called when the system capture mute state changes. Pass the current capture |
| * mute setting to the default input if it is active. */ |
| static void sys_cap_mute_change(void *context, int muted, int mute_locked) |
| { |
| struct cras_iodev *dev; |
| |
| DL_FOREACH (devs[CRAS_STREAM_INPUT].iodevs, dev) { |
| if (dev->set_capture_mute && cras_iodev_is_open(dev)) |
| dev->set_capture_mute(dev); |
| } |
| } |
| |
| static int disable_device(struct enabled_dev *edev, bool force); |
| static int enable_device(struct cras_iodev *dev); |
| |
| static void possibly_disable_fallback(enum CRAS_STREAM_DIRECTION dir) |
| { |
| struct enabled_dev *edev; |
| |
| DL_FOREACH (enabled_devs[dir], edev) { |
| if (edev->dev == fallback_devs[dir]) |
| disable_device(edev, false); |
| } |
| } |
| |
| /* |
| * Possibly enables fallback device to handle streams. |
| * dir - output or input. |
| * error - true if enable fallback device because no other iodevs can be |
| * initialized successfully. |
| */ |
| static void possibly_enable_fallback(enum CRAS_STREAM_DIRECTION dir, bool error) |
| { |
| if (fallback_devs[dir] == NULL) |
| return; |
| |
| /* |
| * The fallback device is a special device. It doesn't have a real |
| * device to get a correct node type. Therefore, we need to set it by |
| * ourselves, which indicates the reason to use this device. |
| * NORMAL - Use it because of nodes changed. |
| * ABNORMAL - Use it because there are no other usable devices. |
| */ |
| if (error) |
| syslog(LOG_ERR, |
| "Enable fallback device because there are no other usable devices."); |
| |
| fallback_devs[dir]->active_node->type = |
| error ? CRAS_NODE_TYPE_FALLBACK_ABNORMAL : |
| CRAS_NODE_TYPE_FALLBACK_NORMAL; |
| if (!cras_iodev_list_dev_is_enabled(fallback_devs[dir])) |
| enable_device(fallback_devs[dir]); |
| } |
| |
| /* |
| * Adds stream to one or more open iodevs. If the stream has processing effect |
| * turned on, create new APM instance and add to the list. This makes sure the |
| * time consuming APM creation happens in main thread. |
| */ |
| static int add_stream_to_open_devs(struct cras_rstream *stream, |
| struct cras_iodev **iodevs, |
| unsigned int num_iodevs) |
| { |
| int i; |
| if (stream->apm_list) { |
| for (i = 0; i < num_iodevs; i++) |
| cras_apm_list_add_apm(stream->apm_list, iodevs[i], |
| iodevs[i]->format, |
| cras_iodev_is_aec_use_case( |
| iodevs[i]->active_node)); |
| } |
| return audio_thread_add_stream(audio_thread, stream, iodevs, |
| num_iodevs); |
| } |
| |
| static int init_and_attach_streams(struct cras_iodev *dev) |
| { |
| int rc; |
| enum CRAS_STREAM_DIRECTION dir = dev->direction; |
| struct cras_rstream *stream; |
| int dev_enabled = cras_iodev_list_dev_is_enabled(dev); |
| |
| /* If called after suspend, for example bluetooth |
| * profile switching, don't add back the stream list. */ |
| if (stream_list_suspended) |
| return 0; |
| |
| /* If there are active streams to attach to this device, |
| * open it. */ |
| DL_FOREACH (stream_list_get(stream_list), stream) { |
| bool can_attach = 0; |
| |
| if (stream->direction != dir) |
| continue; |
| /* |
| * For normal stream, if device is enabled by UI then it can |
| * attach to this dev. |
| */ |
| if (!stream->is_pinned) { |
| can_attach = dev_enabled; |
| } |
| /* |
| * If this is a pinned stream, attach it if its pinned dev id |
| * matches this device or any fallback dev. Note that attaching |
| * a pinned stream to fallback device is temporary. When the |
| * fallback dev gets disabled in possibly_disable_fallback() |
| * the check stream_list_has_pinned_stream() is key to allow |
| * all streams to be removed from fallback and close it. |
| */ |
| else if ((stream->pinned_dev_idx == dev->info.idx) || |
| (SILENT_PLAYBACK_DEVICE == dev->info.idx) || |
| (SILENT_RECORD_DEVICE == dev->info.idx)) { |
| can_attach = 1; |
| } |
| |
| if (!can_attach) |
| continue; |
| |
| /* |
| * Note that the stream list is descending ordered by channel |
| * count, which guarantees the first attachable stream will have |
| * the highest channel count. |
| */ |
| rc = init_device(dev, stream); |
| if (rc) { |
| syslog(LOG_ERR, "Enable %s failed, rc = %d", |
| dev->info.name, rc); |
| return rc; |
| } |
| add_stream_to_open_devs(stream, &dev, 1); |
| } |
| return 0; |
| } |
| |
| static void init_device_cb(struct cras_timer *timer, void *arg) |
| { |
| int rc; |
| struct dev_init_retry *retry = (struct dev_init_retry *)arg; |
| struct cras_iodev *dev = find_dev(retry->dev_idx); |
| |
| /* |
| * First of all, remove retry record to avoid confusion to the |
| * actual device init work. |
| */ |
| DL_DELETE(init_retries, retry); |
| free(retry); |
| |
| if (!dev || cras_iodev_is_open(dev)) |
| return; |
| |
| rc = init_and_attach_streams(dev); |
| if (rc < 0) |
| syslog(LOG_ERR, "Init device retry failed"); |
| else |
| possibly_disable_fallback(dev->direction); |
| } |
| |
| static int schedule_init_device_retry(struct cras_iodev *dev) |
| { |
| struct dev_init_retry *retry; |
| struct cras_tm *tm = cras_system_state_get_tm(); |
| |
| retry = (struct dev_init_retry *)calloc(1, sizeof(*retry)); |
| if (!retry) |
| return -ENOMEM; |
| |
| retry->dev_idx = dev->info.idx; |
| retry->init_timer = cras_tm_create_timer(tm, INIT_DEV_DELAY_MS, |
| init_device_cb, retry); |
| DL_APPEND(init_retries, retry); |
| return 0; |
| } |
| |
| static int init_pinned_device(struct cras_iodev *dev, |
| struct cras_rstream *rstream) |
| { |
| int rc; |
| |
| cras_iodev_exit_idle(dev); |
| |
| if (audio_thread_is_dev_open(audio_thread, dev)) |
| return 0; |
| |
| /* Make sure the active node is configured properly, it could be |
| * disabled when last normal stream removed. */ |
| dev->update_active_node(dev, dev->active_node->idx, 1); |
| |
| /* Negative EAGAIN code indicates dev will be opened later. */ |
| rc = init_device(dev, rstream); |
| if (rc) |
| return rc; |
| return 0; |
| } |
| |
| /* |
| * Close device enabled by pinned stream. Since it's NOT in the enabled |
| * dev list, make sure update_active_node() is called to correctly |
| * configure the ALSA UCM or BT profile state. |
| */ |
| static int close_pinned_device(struct cras_iodev *dev) |
| { |
| close_dev(dev); |
| dev->update_active_node(dev, dev->active_node->idx, 0); |
| return 0; |
| } |
| |
| static struct cras_iodev *find_pinned_device(struct cras_rstream *rstream) |
| { |
| struct cras_iodev *dev; |
| if (!rstream->is_pinned) |
| return NULL; |
| |
| dev = find_dev(rstream->pinned_dev_idx); |
| |
| if ((rstream->flags & HOTWORD_STREAM) != HOTWORD_STREAM) |
| return dev; |
| |
| /* Double check node type for hotword stream */ |
| if (dev && dev->active_node->type != CRAS_NODE_TYPE_HOTWORD) { |
| syslog(LOG_ERR, "Hotword stream pinned to invalid dev %u", |
| dev->info.idx); |
| return NULL; |
| } |
| |
| return hotword_suspended ? empty_hotword_dev : dev; |
| } |
| |
| static int pinned_stream_added(struct cras_rstream *rstream) |
| { |
| struct cras_iodev *dev; |
| int rc; |
| |
| /* Check that the target device is valid for pinned streams. */ |
| dev = find_pinned_device(rstream); |
| if (!dev) |
| return -EINVAL; |
| |
| rc = init_pinned_device(dev, rstream); |
| if (rc) { |
| syslog(LOG_INFO, "init_pinned_device failed, rc %d", rc); |
| return schedule_init_device_retry(dev); |
| } |
| |
| return add_stream_to_open_devs(rstream, &dev, 1); |
| } |
| |
| static int stream_added_cb(struct cras_rstream *rstream) |
| { |
| struct enabled_dev *edev; |
| struct cras_iodev *iodevs[10]; |
| unsigned int num_iodevs; |
| int rc; |
| bool iodev_reopened; |
| |
| if (stream_list_suspended) |
| return 0; |
| |
| MAINLOG(main_log, MAIN_THREAD_STREAM_ADDED, rstream->stream_id, |
| rstream->direction, rstream->buffer_frames); |
| |
| if (rstream->is_pinned) |
| return pinned_stream_added(rstream); |
| |
| /* Add the new stream to all enabled iodevs at once to avoid offset |
| * in shm level between different ouput iodevs. */ |
| num_iodevs = 0; |
| iodev_reopened = false; |
| DL_FOREACH (enabled_devs[rstream->direction], edev) { |
| if (num_iodevs >= ARRAY_SIZE(iodevs)) { |
| syslog(LOG_ERR, "too many enabled devices"); |
| break; |
| } |
| |
| if (cras_iodev_is_open(edev->dev) && |
| (rstream->format.num_channels > |
| edev->dev->format->num_channels) && |
| (rstream->format.num_channels <= |
| edev->dev->info.max_supported_channels)) { |
| /* Re-open the device with the format of the attached |
| * stream if it has higher channel count than the |
| * current format of the device, and doesn't exceed the |
| * max_supported_channels of the device. |
| * Fallback device will be transciently enabled during |
| * the device re-opening. |
| */ |
| MAINLOG(main_log, MAIN_THREAD_DEV_REOPEN, |
| rstream->format.num_channels, |
| edev->dev->format->num_channels, |
| edev->dev->format->frame_rate); |
| syslog(LOG_INFO, "re-open %s for higher channel count", |
| edev->dev->info.name); |
| possibly_enable_fallback(rstream->direction, false); |
| cras_iodev_list_suspend_dev(edev->dev->info.idx); |
| cras_iodev_list_resume_dev(edev->dev->info.idx); |
| possibly_disable_fallback(rstream->direction); |
| iodev_reopened = true; |
| } else { |
| rc = init_device(edev->dev, rstream); |
| if (rc) { |
| /* Error log but don't return error here, because |
| * stopping audio could block video playback. |
| */ |
| syslog(LOG_ERR, "Init %s failed, rc = %d", |
| edev->dev->info.name, rc); |
| schedule_init_device_retry(edev->dev); |
| continue; |
| } |
| |
| iodevs[num_iodevs++] = edev->dev; |
| } |
| } |
| if (num_iodevs) { |
| rc = add_stream_to_open_devs(rstream, iodevs, num_iodevs); |
| if (rc) { |
| syslog(LOG_ERR, "adding stream to thread fail"); |
| return rc; |
| } |
| } else if (!iodev_reopened) { |
| /* Enable fallback device if no other iodevs can be initialized |
| * or re-opened successfully. |
| * For error codes like EAGAIN and ENOENT, a new iodev will be |
| * enabled soon so streams are going to route there. As for the |
| * rest of the error cases, silence will be played or recorded |
| * so client won't be blocked. |
| * The enabled fallback device will be disabled when |
| * cras_iodev_list_select_node() is called to re-select the |
| * active node. |
| */ |
| possibly_enable_fallback(rstream->direction, true); |
| } |
| return 0; |
| } |
| |
| static int possibly_close_enabled_devs(enum CRAS_STREAM_DIRECTION dir) |
| { |
| struct enabled_dev *edev; |
| const struct cras_rstream *s; |
| |
| /* Check if there are still default streams attached. */ |
| DL_FOREACH (stream_list_get(stream_list), s) { |
| if (s->direction == dir && !s->is_pinned) |
| return 0; |
| } |
| |
| /* No more default streams, close any device that doesn't have a stream |
| * pinned to it. */ |
| DL_FOREACH (enabled_devs[dir], edev) { |
| if (stream_list_has_pinned_stream(stream_list, |
| edev->dev->info.idx)) |
| continue; |
| if (dir == CRAS_STREAM_INPUT) { |
| close_dev(edev->dev); |
| continue; |
| } |
| /* Allow output devs to drain before closing. */ |
| clock_gettime(CLOCK_MONOTONIC_RAW, &edev->dev->idle_timeout); |
| add_timespecs(&edev->dev->idle_timeout, &idle_timeout_interval); |
| idle_dev_check(NULL, NULL); |
| } |
| |
| return 0; |
| } |
| |
| static void pinned_stream_removed(struct cras_rstream *rstream) |
| { |
| struct cras_iodev *dev; |
| |
| dev = find_pinned_device(rstream); |
| if (!dev) |
| return; |
| if (!cras_iodev_list_dev_is_enabled(dev) && |
| !stream_list_has_pinned_stream(stream_list, dev->info.idx)) |
| close_pinned_device(dev); |
| } |
| |
| /* Returns the number of milliseconds left to drain this stream. This is passed |
| * directly from the audio thread. */ |
| static int stream_removed_cb(struct cras_rstream *rstream) |
| { |
| enum CRAS_STREAM_DIRECTION direction = rstream->direction; |
| int rc; |
| |
| rc = audio_thread_drain_stream(audio_thread, rstream); |
| if (rc) |
| return rc; |
| |
| MAINLOG(main_log, MAIN_THREAD_STREAM_REMOVED, rstream->stream_id, 0, 0); |
| |
| if (rstream->is_pinned) |
| pinned_stream_removed(rstream); |
| |
| possibly_close_enabled_devs(direction); |
| |
| return 0; |
| } |
| |
| static int enable_device(struct cras_iodev *dev) |
| { |
| int rc; |
| struct enabled_dev *edev; |
| enum CRAS_STREAM_DIRECTION dir = dev->direction; |
| struct device_enabled_cb *callback; |
| |
| DL_FOREACH (enabled_devs[dir], edev) { |
| if (edev->dev == dev) |
| return -EEXIST; |
| } |
| |
| edev = calloc(1, sizeof(*edev)); |
| edev->dev = dev; |
| DL_APPEND(enabled_devs[dir], edev); |
| dev->is_enabled = 1; |
| |
| rc = init_and_attach_streams(dev); |
| if (rc < 0) { |
| syslog(LOG_INFO, "Enable device fail, rc %d", rc); |
| schedule_init_device_retry(dev); |
| return rc; |
| } |
| |
| DL_FOREACH (device_enable_cbs, callback) |
| callback->enabled_cb(dev, callback->cb_data); |
| |
| return 0; |
| } |
| |
| /* Set `force to true to flush any pinned streams before closing the device. */ |
| static int disable_device(struct enabled_dev *edev, bool force) |
| { |
| struct cras_iodev *dev = edev->dev; |
| enum CRAS_STREAM_DIRECTION dir = dev->direction; |
| struct cras_rstream *stream; |
| struct device_enabled_cb *callback; |
| |
| MAINLOG(main_log, MAIN_THREAD_DEV_DISABLE, dev->info.idx, force, 0); |
| /* |
| * Remove from enabled dev list. However this dev could have a stream |
| * pinned to it, only cancel pending init timers when force flag is set. |
| */ |
| DL_DELETE(enabled_devs[dir], edev); |
| free(edev); |
| dev->is_enabled = 0; |
| if (force) { |
| cancel_pending_init_retries(dev->info.idx); |
| } |
| /* If there's a pinned stream exists, simply disconnect all the normal |
| * streams off this device and return. */ |
| else if (stream_list_has_pinned_stream(stream_list, dev->info.idx)) { |
| DL_FOREACH (stream_list_get(stream_list), stream) { |
| if (stream->direction != dev->direction) |
| continue; |
| if (stream->is_pinned) |
| continue; |
| audio_thread_disconnect_stream(audio_thread, stream, |
| dev); |
| } |
| return 0; |
| } |
| |
| DL_FOREACH (device_enable_cbs, callback) |
| callback->disabled_cb(dev, callback->cb_data); |
| close_dev(dev); |
| dev->update_active_node(dev, dev->active_node->idx, 0); |
| |
| return 0; |
| } |
| |
| /* |
| * Exported Interface. |
| */ |
| |
| void cras_iodev_list_init() |
| { |
| struct cras_observer_ops observer_ops; |
| |
| memset(&observer_ops, 0, sizeof(observer_ops)); |
| observer_ops.output_volume_changed = sys_vol_change; |
| observer_ops.output_mute_changed = sys_mute_change; |
| observer_ops.capture_mute_changed = sys_cap_mute_change; |
| observer_ops.suspend_changed = sys_suspend_change; |
| list_observer = cras_observer_add(&observer_ops, NULL); |
| idle_timer = NULL; |
| |
| main_log = main_thread_event_log_init(); |
| |
| /* Create the audio stream list for the system. */ |
| stream_list = |
| stream_list_create(stream_added_cb, stream_removed_cb, |
| cras_rstream_create, cras_rstream_destroy, |
| cras_system_state_get_tm()); |
| |
| /* Add an empty device so there is always something to play to or |
| * capture from. */ |
| fallback_devs[CRAS_STREAM_OUTPUT] = empty_iodev_create( |
| CRAS_STREAM_OUTPUT, CRAS_NODE_TYPE_FALLBACK_NORMAL); |
| fallback_devs[CRAS_STREAM_INPUT] = empty_iodev_create( |
| CRAS_STREAM_INPUT, CRAS_NODE_TYPE_FALLBACK_NORMAL); |
| enable_device(fallback_devs[CRAS_STREAM_OUTPUT]); |
| enable_device(fallback_devs[CRAS_STREAM_INPUT]); |
| |
| empty_hotword_dev = |
| empty_iodev_create(CRAS_STREAM_INPUT, CRAS_NODE_TYPE_HOTWORD); |
| |
| /* Create loopback devices. */ |
| loopdev_post_mix = loopback_iodev_create(LOOPBACK_POST_MIX_PRE_DSP); |
| loopdev_post_dsp = loopback_iodev_create(LOOPBACK_POST_DSP); |
| |
| audio_thread = audio_thread_create(); |
| if (!audio_thread) { |
| syslog(LOG_ERR, "Fatal: audio thread init"); |
| exit(-ENOMEM); |
| } |
| audio_thread_start(audio_thread); |
| |
| cras_iodev_list_update_device_list(); |
| } |
| |
| void cras_iodev_list_deinit() |
| { |
| audio_thread_destroy(audio_thread); |
| loopback_iodev_destroy(loopdev_post_dsp); |
| loopback_iodev_destroy(loopdev_post_mix); |
| empty_iodev_destroy(empty_hotword_dev); |
| empty_iodev_destroy(fallback_devs[CRAS_STREAM_INPUT]); |
| empty_iodev_destroy(fallback_devs[CRAS_STREAM_OUTPUT]); |
| stream_list_destroy(stream_list); |
| main_thread_event_log_deinit(main_log); |
| if (list_observer) { |
| cras_observer_remove(list_observer); |
| list_observer = NULL; |
| } |
| } |
| |
| int cras_iodev_list_dev_is_enabled(const struct cras_iodev *dev) |
| { |
| struct enabled_dev *edev; |
| |
| DL_FOREACH (enabled_devs[dev->direction], edev) { |
| if (edev->dev == dev) |
| return 1; |
| } |
| |
| return 0; |
| } |
| |
| void cras_iodev_list_enable_dev(struct cras_iodev *dev) |
| { |
| possibly_disable_fallback(dev->direction); |
| /* Enable ucm setting of active node. */ |
| dev->update_active_node(dev, dev->active_node->idx, 1); |
| enable_device(dev); |
| cras_iodev_list_notify_active_node_changed(dev->direction); |
| } |
| |
| void cras_iodev_list_add_active_node(enum CRAS_STREAM_DIRECTION dir, |
| cras_node_id_t node_id) |
| { |
| struct cras_iodev *new_dev; |
| new_dev = find_dev(dev_index_of(node_id)); |
| if (!new_dev || new_dev->direction != dir) |
| return; |
| |
| MAINLOG(main_log, MAIN_THREAD_ADD_ACTIVE_NODE, new_dev->info.idx, 0, 0); |
| |
| /* If the new dev is already enabled but its active node needs to be |
| * changed. Disable new dev first, update active node, and then |
| * re-enable it again. |
| */ |
| if (cras_iodev_list_dev_is_enabled(new_dev)) { |
| if (node_index_of(node_id) == new_dev->active_node->idx) |
| return; |
| else |
| cras_iodev_list_disable_dev(new_dev, true); |
| } |
| |
| new_dev->update_active_node(new_dev, node_index_of(node_id), 1); |
| cras_iodev_list_enable_dev(new_dev); |
| } |
| |
| /* |
| * Disables device which may or may not be in enabled_devs list. |
| */ |
| void cras_iodev_list_disable_dev(struct cras_iodev *dev, bool force_close) |
| { |
| struct enabled_dev *edev, *edev_to_disable = NULL; |
| |
| int is_the_only_enabled_device = 1; |
| |
| DL_FOREACH (enabled_devs[dev->direction], edev) { |
| if (edev->dev == dev) |
| edev_to_disable = edev; |
| else |
| is_the_only_enabled_device = 0; |
| } |
| |
| /* |
| * Disables the device for these two cases: |
| * 1. Disable a device in the enabled_devs list. |
| * 2. Force close a device that is not in the enabled_devs list, |
| * but it is running a pinned stream. |
| */ |
| if (!edev_to_disable) { |
| if (force_close) |
| close_pinned_device(dev); |
| return; |
| } |
| |
| /* If the device to be closed is the only enabled device, we should |
| * enable the fallback device first then disable the target |
| * device. */ |
| if (is_the_only_enabled_device && fallback_devs[dev->direction]) |
| enable_device(fallback_devs[dev->direction]); |
| |
| disable_device(edev_to_disable, force_close); |
| |
| cras_iodev_list_notify_active_node_changed(dev->direction); |
| return; |
| } |
| |
| void cras_iodev_list_suspend_dev(unsigned int dev_idx) |
| { |
| struct cras_iodev *dev = find_dev(dev_idx); |
| |
| if (!dev) |
| return; |
| |
| /* Remove all streams including the pinned streams, and close |
| * this iodev. */ |
| close_dev(dev); |
| dev->update_active_node(dev, dev->active_node->idx, 0); |
| } |
| |
| void cras_iodev_list_resume_dev(unsigned int dev_idx) |
| { |
| struct cras_iodev *dev = find_dev(dev_idx); |
| int rc; |
| |
| if (!dev) |
| return; |
| |
| dev->update_active_node(dev, dev->active_node->idx, 1); |
| rc = init_and_attach_streams(dev); |
| if (rc == 0) { |
| /* If dev initialize succeeded and this is not a pinned device, |
| * disable the silent fallback device because it's just |
| * unnecessary. */ |
| if (!stream_list_has_pinned_stream(stream_list, dev_idx)) |
| possibly_disable_fallback(dev->direction); |
| } else { |
| syslog(LOG_INFO, "Enable dev fail at resume, rc %d", rc); |
| schedule_init_device_retry(dev); |
| } |
| } |
| |
| void cras_iodev_list_set_dev_mute(unsigned int dev_idx) |
| { |
| struct cras_iodev *dev; |
| |
| dev = find_dev(dev_idx); |
| if (!dev) |
| return; |
| |
| cras_iodev_set_mute(dev); |
| } |
| |
| void cras_iodev_list_rm_active_node(enum CRAS_STREAM_DIRECTION dir, |
| cras_node_id_t node_id) |
| { |
| struct cras_iodev *dev; |
| |
| dev = find_dev(dev_index_of(node_id)); |
| if (!dev) |
| return; |
| |
| cras_iodev_list_disable_dev(dev, false); |
| } |
| |
| int cras_iodev_list_add_output(struct cras_iodev *output) |
| { |
| int rc; |
| |
| if (output->direction != CRAS_STREAM_OUTPUT) |
| return -EINVAL; |
| |
| rc = add_dev_to_list(output); |
| if (rc) |
| return rc; |
| |
| MAINLOG(main_log, MAIN_THREAD_ADD_TO_DEV_LIST, output->info.idx, |
| CRAS_STREAM_OUTPUT, 0); |
| return 0; |
| } |
| |
| int cras_iodev_list_add_input(struct cras_iodev *input) |
| { |
| int rc; |
| |
| if (input->direction != CRAS_STREAM_INPUT) |
| return -EINVAL; |
| |
| rc = add_dev_to_list(input); |
| if (rc) |
| return rc; |
| |
| MAINLOG(main_log, MAIN_THREAD_ADD_TO_DEV_LIST, input->info.idx, |
| CRAS_STREAM_INPUT, 0); |
| return 0; |
| } |
| |
| int cras_iodev_list_rm_output(struct cras_iodev *dev) |
| { |
| int res; |
| |
| /* Retire the current active output device before removing it from |
| * list, otherwise it could be busy and remain in the list. |
| */ |
| cras_iodev_list_disable_dev(dev, true); |
| res = rm_dev_from_list(dev); |
| if (res == 0) |
| cras_iodev_list_update_device_list(); |
| return res; |
| } |
| |
| int cras_iodev_list_rm_input(struct cras_iodev *dev) |
| { |
| int res; |
| |
| /* Retire the current active input device before removing it from |
| * list, otherwise it could be busy and remain in the list. |
| */ |
| cras_iodev_list_disable_dev(dev, true); |
| res = rm_dev_from_list(dev); |
| if (res == 0) |
| cras_iodev_list_update_device_list(); |
| return res; |
| } |
| |
| int cras_iodev_list_get_outputs(struct cras_iodev_info **list_out) |
| { |
| return get_dev_list(&devs[CRAS_STREAM_OUTPUT], list_out); |
| } |
| |
| int cras_iodev_list_get_inputs(struct cras_iodev_info **list_out) |
| { |
| return get_dev_list(&devs[CRAS_STREAM_INPUT], list_out); |
| } |
| |
| struct cras_iodev * |
| cras_iodev_list_get_first_enabled_iodev(enum CRAS_STREAM_DIRECTION direction) |
| { |
| struct enabled_dev *edev = enabled_devs[direction]; |
| |
| return edev ? edev->dev : NULL; |
| } |
| |
| struct cras_iodev * |
| cras_iodev_list_get_sco_pcm_iodev(enum CRAS_STREAM_DIRECTION direction) |
| { |
| struct cras_iodev *dev; |
| struct cras_ionode *node; |
| |
| DL_FOREACH (devs[direction].iodevs, dev) { |
| DL_FOREACH (dev->nodes, node) { |
| if (node->is_sco_pcm) |
| return dev; |
| } |
| } |
| |
| return NULL; |
| } |
| |
| cras_node_id_t |
| cras_iodev_list_get_active_node_id(enum CRAS_STREAM_DIRECTION direction) |
| { |
| struct enabled_dev *edev = enabled_devs[direction]; |
| |
| if (!edev || !edev->dev || !edev->dev->active_node) |
| return 0; |
| |
| return cras_make_node_id(edev->dev->info.idx, |
| edev->dev->active_node->idx); |
| } |
| |
| void cras_iodev_list_update_device_list() |
| { |
| struct cras_server_state *state; |
| |
| state = cras_system_state_update_begin(); |
| if (!state) |
| return; |
| |
| state->num_output_devs = devs[CRAS_STREAM_OUTPUT].size; |
| state->num_input_devs = devs[CRAS_STREAM_INPUT].size; |
| fill_dev_list(&devs[CRAS_STREAM_OUTPUT], &state->output_devs[0], |
| CRAS_MAX_IODEVS); |
| fill_dev_list(&devs[CRAS_STREAM_INPUT], &state->input_devs[0], |
| CRAS_MAX_IODEVS); |
| |
| state->num_output_nodes = |
| fill_node_list(&devs[CRAS_STREAM_OUTPUT], |
| &state->output_nodes[0], CRAS_MAX_IONODES); |
| state->num_input_nodes = |
| fill_node_list(&devs[CRAS_STREAM_INPUT], &state->input_nodes[0], |
| CRAS_MAX_IONODES); |
| |
| cras_system_state_update_complete(); |
| } |
| |
| /* Look up the first hotword stream and the device it pins to. */ |
| int find_hotword_stream_dev(struct cras_iodev **dev, |
| struct cras_rstream **stream) |
| { |
| DL_FOREACH (stream_list_get(stream_list), *stream) { |
| if (((*stream)->flags & HOTWORD_STREAM) != HOTWORD_STREAM) |
| continue; |
| |
| *dev = find_dev((*stream)->pinned_dev_idx); |
| if (*dev == NULL) |
| return -ENOENT; |
| break; |
| } |
| return 0; |
| } |
| |
| /* Suspend/resume hotword streams functions are used to provide seamless |
| * experience to cras clients when there's hardware limitation about concurrent |
| * DSP and normal recording. The empty hotword iodev is used to hold all |
| * hotword streams during suspend, so client side will not know about the |
| * transition, and can still remove or add streams. At resume, the real hotword |
| * device will be initialized and opened again to re-arm the DSP. |
| */ |
| int cras_iodev_list_suspend_hotword_streams() |
| { |
| struct cras_iodev *hotword_dev; |
| struct cras_rstream *stream = NULL; |
| int rc; |
| |
| rc = find_hotword_stream_dev(&hotword_dev, &stream); |
| if (rc) |
| return rc; |
| |
| if (stream == NULL) { |
| hotword_suspended = 1; |
| return 0; |
| } |
| /* Move all existing hotword streams to the empty hotword iodev. */ |
| init_pinned_device(empty_hotword_dev, stream); |
| DL_FOREACH (stream_list_get(stream_list), stream) { |
| if ((stream->flags & HOTWORD_STREAM) != HOTWORD_STREAM) |
| continue; |
| if (stream->pinned_dev_idx != hotword_dev->info.idx) { |
| syslog(LOG_ERR, |
| "Failed to suspend hotword stream on dev %u", |
| stream->pinned_dev_idx); |
| continue; |
| } |
| |
| audio_thread_disconnect_stream(audio_thread, stream, |
| hotword_dev); |
| audio_thread_add_stream(audio_thread, stream, |
| &empty_hotword_dev, 1); |
| } |
| close_pinned_device(hotword_dev); |
| hotword_suspended = 1; |
| return 0; |
| } |
| |
| int cras_iodev_list_resume_hotword_stream() |
| { |
| struct cras_iodev *hotword_dev; |
| struct cras_rstream *stream = NULL; |
| int rc; |
| |
| rc = find_hotword_stream_dev(&hotword_dev, &stream); |
| if (rc) |
| return rc; |
| |
| if (stream == NULL) { |
| hotword_suspended = 0; |
| return 0; |
| } |
| /* Move all existing hotword streams to the real hotword iodev. */ |
| init_pinned_device(hotword_dev, stream); |
| DL_FOREACH (stream_list_get(stream_list), stream) { |
| if ((stream->flags & HOTWORD_STREAM) != HOTWORD_STREAM) |
| continue; |
| if (stream->pinned_dev_idx != hotword_dev->info.idx) { |
| syslog(LOG_ERR, |
| "Fail to resume hotword stream on dev %u", |
| stream->pinned_dev_idx); |
| continue; |
| } |
| |
| audio_thread_disconnect_stream(audio_thread, stream, |
| empty_hotword_dev); |
| audio_thread_add_stream(audio_thread, stream, &hotword_dev, 1); |
| } |
| close_pinned_device(empty_hotword_dev); |
| hotword_suspended = 0; |
| return 0; |
| } |
| |
| char *cras_iodev_list_get_hotword_models(cras_node_id_t node_id) |
| { |
| struct cras_iodev *dev = NULL; |
| |
| dev = find_dev(dev_index_of(node_id)); |
| if (!dev || !dev->get_hotword_models || |
| (dev->active_node->type != CRAS_NODE_TYPE_HOTWORD)) |
| return NULL; |
| |
| return dev->get_hotword_models(dev); |
| } |
| |
| int cras_iodev_list_set_hotword_model(cras_node_id_t node_id, |
| const char *model_name) |
| { |
| int ret; |
| struct cras_iodev *dev = find_dev(dev_index_of(node_id)); |
| if (!dev || !dev->get_hotword_models || |
| (dev->active_node->type != CRAS_NODE_TYPE_HOTWORD)) |
| return -EINVAL; |
| |
| ret = dev->set_hotword_model(dev, model_name); |
| if (!ret) |
| strncpy(dev->active_node->active_hotword_model, model_name, |
| sizeof(dev->active_node->active_hotword_model) - 1); |
| return ret; |
| } |
| |
| void cras_iodev_list_notify_nodes_changed() |
| { |
| cras_observer_notify_nodes(); |
| } |
| |
| void cras_iodev_list_notify_active_node_changed( |
| enum CRAS_STREAM_DIRECTION direction) |
| { |
| cras_observer_notify_active_node( |
| direction, cras_iodev_list_get_active_node_id(direction)); |
| } |
| |
| void cras_iodev_list_select_node(enum CRAS_STREAM_DIRECTION direction, |
| cras_node_id_t node_id) |
| { |
| struct cras_iodev *new_dev = NULL; |
| struct enabled_dev *edev; |
| int new_node_already_enabled = 0; |
| struct cras_rstream *rstream; |
| int has_output_stream = 0; |
| int rc; |
| |
| /* find the devices for the id. */ |
| new_dev = find_dev(dev_index_of(node_id)); |
| |
| MAINLOG(main_log, MAIN_THREAD_SELECT_NODE, dev_index_of(node_id), 0, 0); |
| |
| /* Do nothing if the direction is mismatched. The new_dev == NULL case |
| could happen if node_id is 0 (no selection), or the client tries |
| to select a non-existing node (maybe it's unplugged just before |
| the client selects it). We will just behave like there is no selected |
| node. */ |
| if (new_dev && new_dev->direction != direction) |
| return; |
| |
| /* Determine whether the new device and node are already enabled - if |
| * they are, the selection algorithm should avoid disabling the new |
| * device. */ |
| DL_FOREACH (enabled_devs[direction], edev) { |
| if (edev->dev == new_dev && |
| edev->dev->active_node->idx == node_index_of(node_id)) { |
| new_node_already_enabled = 1; |
| break; |
| } |
| } |
| |
| /* Enable fallback device during the transition so client will not be |
| * blocked in this duration, which is as long as 300 ms on some boards |
| * before new device is opened. |
| * Note that the fallback node is not needed if the new node is already |
| * enabled - the new node will remain enabled. */ |
| if (!new_node_already_enabled) |
| possibly_enable_fallback(direction, false); |
| |
| DL_FOREACH (enabled_devs[direction], edev) { |
| /* Don't disable fallback devices. */ |
| if (edev->dev == fallback_devs[direction]) |
| continue; |
| /* |
| * Disable enabled device if it's not the new one, use non-force |
| * disable call so we don't interrupt existing pinned streams on |
| * it. |
| */ |
| if (edev->dev != new_dev) { |
| disable_device(edev, false); |
| } |
| /* |
| * Otherwise if this happens to be the new device but about to |
| * select to a different node (on the same dev). Force disable |
| * this device to avoid any pinned stream occupies it in audio |
| * thread and cause problem in later update_active_node call. |
| */ |
| else if (!new_node_already_enabled) { |
| disable_device(edev, true); |
| } |
| } |
| |
| if (new_dev && !new_node_already_enabled) { |
| new_dev->update_active_node(new_dev, node_index_of(node_id), 1); |
| |
| /* To reduce the popped noise of active device change, mute |
| * new_dev's for RAMP_SWITCH_MUTE_DURATION_SECS s. |
| */ |
| DL_FOREACH (stream_list_get(stream_list), rstream) { |
| if (rstream->direction == CRAS_STREAM_OUTPUT) |
| has_output_stream++; |
| } |
| if (direction == CRAS_STREAM_OUTPUT && has_output_stream) { |
| new_dev->initial_ramp_request = |
| CRAS_IODEV_RAMP_REQUEST_SWITCH_MUTE; |
| } |
| |
| rc = enable_device(new_dev); |
| if (rc == 0) { |
| /* Disable fallback device after new device is enabled. |
| * Leave the fallback device enabled if new_dev failed |
| * to open, or the new_dev == NULL case. */ |
| possibly_disable_fallback(direction); |
| } |
| } |
| |
| cras_iodev_list_notify_active_node_changed(direction); |
| } |
| |
| static int set_node_plugged(struct cras_iodev *iodev, unsigned int node_idx, |
| int plugged) |
| { |
| struct cras_ionode *node; |
| |
| node = find_node(iodev, node_idx); |
| if (!node) |
| return -EINVAL; |
| cras_iodev_set_node_plugged(node, plugged); |
| return 0; |
| } |
| |
| static int set_node_volume(struct cras_iodev *iodev, unsigned int node_idx, |
| int volume) |
| { |
| struct cras_ionode *node; |
| |
| node = find_node(iodev, node_idx); |
| if (!node) |
| return -EINVAL; |
| |
| if (iodev->ramp && cras_iodev_software_volume_needed(iodev) && |
| !cras_system_get_mute()) |
| cras_iodev_start_volume_ramp(iodev, node->volume, volume); |
| |
| node->volume = volume; |
| if (iodev->set_volume) |
| iodev->set_volume(iodev); |
| cras_iodev_list_notify_node_volume(node); |
| MAINLOG(main_log, MAIN_THREAD_OUTPUT_NODE_VOLUME, iodev->info.idx, |
| volume, 0); |
| return 0; |
| } |
| |
| static int set_node_capture_gain(struct cras_iodev *iodev, |
| unsigned int node_idx, int value) |
| { |
| struct cras_ionode *node; |
| int db_scale; |
| |
| node = find_node(iodev, node_idx); |
| if (!node) |
| return -EINVAL; |
| |
| /* Assert value in range 0 - 100. */ |
| if (value < 0) |
| value = 0; |
| if (value > 100) |
| value = 100; |
| |
| /* Linear maps (0, 50) to (-4000, 0) and (50, 100) to (0, 2000) dBFS. |
| * Calculate and store corresponding scaler in ui_gain_scaler. */ |
| db_scale = (value > 50) ? 40 : 80; |
| node->ui_gain_scaler = |
| convert_softvol_scaler_from_dB((value - 50) * db_scale); |
| |
| if (iodev->set_capture_gain) |
| iodev->set_capture_gain(iodev); |
| cras_iodev_list_notify_node_capture_gain(node); |
| MAINLOG(main_log, MAIN_THREAD_INPUT_NODE_GAIN, iodev->info.idx, value, |
| 0); |
| return 0; |
| } |
| |
| static int set_node_left_right_swapped(struct cras_iodev *iodev, |
| unsigned int node_idx, |
| int left_right_swapped) |
| { |
| struct cras_ionode *node; |
| int rc; |
| |
| if (!iodev->set_swap_mode_for_node) |
| return -EINVAL; |
| node = find_node(iodev, node_idx); |
| if (!node) |
| return -EINVAL; |
| |
| rc = iodev->set_swap_mode_for_node(iodev, node, left_right_swapped); |
| if (rc) { |
| syslog(LOG_ERR, "Failed to set swap mode on node %s to %d", |
| node->name, left_right_swapped); |
| return rc; |
| } |
| node->left_right_swapped = left_right_swapped; |
| cras_iodev_list_notify_node_left_right_swapped(node); |
| return 0; |
| } |
| |
| int cras_iodev_list_set_node_attr(cras_node_id_t node_id, enum ionode_attr attr, |
| int value) |
| { |
| struct cras_iodev *iodev; |
| int rc = 0; |
| |
| iodev = find_dev(dev_index_of(node_id)); |
| if (!iodev) |
| return -EINVAL; |
| |
| switch (attr) { |
| case IONODE_ATTR_PLUGGED: |
| rc = set_node_plugged(iodev, node_index_of(node_id), value); |
| break; |
| case IONODE_ATTR_VOLUME: |
| rc = set_node_volume(iodev, node_index_of(node_id), value); |
| break; |
| case IONODE_ATTR_CAPTURE_GAIN: |
| rc = set_node_capture_gain(iodev, node_index_of(node_id), |
| value); |
| break; |
| case IONODE_ATTR_SWAP_LEFT_RIGHT: |
| rc = set_node_left_right_swapped(iodev, node_index_of(node_id), |
| value); |
| break; |
| default: |
| return -EINVAL; |
| } |
| |
| return rc; |
| } |
| |
| void cras_iodev_list_notify_node_volume(struct cras_ionode *node) |
| { |
| cras_node_id_t id = cras_make_node_id(node->dev->info.idx, node->idx); |
| cras_iodev_list_update_device_list(); |
| cras_observer_notify_output_node_volume(id, node->volume); |
| } |
| |
| void cras_iodev_list_notify_node_left_right_swapped(struct cras_ionode *node) |
| { |
| cras_node_id_t id = cras_make_node_id(node->dev->info.idx, node->idx); |
| cras_iodev_list_update_device_list(); |
| cras_observer_notify_node_left_right_swapped(id, |
| node->left_right_swapped); |
| } |
| |
| void cras_iodev_list_notify_node_capture_gain(struct cras_ionode *node) |
| { |
| cras_node_id_t id = cras_make_node_id(node->dev->info.idx, node->idx); |
| cras_iodev_list_update_device_list(); |
| cras_observer_notify_input_node_gain(id, node->capture_gain); |
| } |
| |
| void cras_iodev_list_add_test_dev(enum TEST_IODEV_TYPE type) |
| { |
| if (type != TEST_IODEV_HOTWORD) |
| return; |
| test_iodev_create(CRAS_STREAM_INPUT, type); |
| } |
| |
| void cras_iodev_list_test_dev_command(unsigned int iodev_idx, |
| enum CRAS_TEST_IODEV_CMD command, |
| unsigned int data_len, |
| const uint8_t *data) |
| { |
| struct cras_iodev *dev = find_dev(iodev_idx); |
| |
| if (!dev) |
| return; |
| |
| test_iodev_command(dev, command, data_len, data); |
| } |
| |
| struct audio_thread *cras_iodev_list_get_audio_thread() |
| { |
| return audio_thread; |
| } |
| |
| struct stream_list *cras_iodev_list_get_stream_list() |
| { |
| return stream_list; |
| } |
| |
| int cras_iodev_list_set_device_enabled_callback( |
| device_enabled_callback_t enabled_cb, |
| device_disabled_callback_t disabled_cb, void *cb_data) |
| { |
| struct device_enabled_cb *callback; |
| |
| DL_FOREACH (device_enable_cbs, callback) { |
| if (callback->cb_data != cb_data) |
| continue; |
| |
| DL_DELETE(device_enable_cbs, callback); |
| free(callback); |
| } |
| |
| if (enabled_cb && disabled_cb) { |
| callback = (struct device_enabled_cb *)calloc( |
| 1, sizeof(*callback)); |
| callback->enabled_cb = enabled_cb; |
| callback->disabled_cb = disabled_cb; |
| callback->cb_data = cb_data; |
| DL_APPEND(device_enable_cbs, callback); |
| } |
| |
| return 0; |
| } |
| |
| void cras_iodev_list_register_loopback(enum CRAS_LOOPBACK_TYPE loopback_type, |
| unsigned int output_dev_idx, |
| loopback_hook_data_t hook_data, |
| loopback_hook_control_t hook_control, |
| unsigned int loopback_dev_idx) |
| { |
| struct cras_iodev *iodev = find_dev(output_dev_idx); |
| struct cras_iodev *loopback_dev; |
| struct cras_loopback *loopback; |
| bool dev_open; |
| |
| if (iodev == NULL) { |
| syslog(LOG_ERR, "Output dev %u not found for loopback", |
| output_dev_idx); |
| return; |
| } |
| |
| loopback_dev = find_dev(loopback_dev_idx); |
| if (loopback_dev == NULL) { |
| syslog(LOG_ERR, "Loopback dev %u not found", loopback_dev_idx); |
| return; |
| } |
| |
| dev_open = cras_iodev_is_open(iodev); |
| |
| loopback = (struct cras_loopback *)calloc(1, sizeof(*loopback)); |
| if (NULL == loopback) { |
| syslog(LOG_ERR, "Not enough memory for loopback"); |
| return; |
| } |
| |
| loopback->type = loopback_type; |
| loopback->hook_data = hook_data; |
| loopback->hook_control = hook_control; |
| loopback->cb_data = loopback_dev; |
| if (loopback->hook_control && dev_open) |
| loopback->hook_control(true, loopback->cb_data); |
| |
| DL_APPEND(iodev->loopbacks, loopback); |
| } |
| |
| void cras_iodev_list_unregister_loopback(enum CRAS_LOOPBACK_TYPE type, |
| unsigned int output_dev_idx, |
| unsigned int loopback_dev_idx) |
| { |
| struct cras_iodev *iodev = find_dev(output_dev_idx); |
| struct cras_iodev *loopback_dev; |
| struct cras_loopback *loopback; |
| |
| if (iodev == NULL) |
| return; |
| |
| loopback_dev = find_dev(loopback_dev_idx); |
| if (loopback_dev == NULL) |
| return; |
| |
| DL_FOREACH (iodev->loopbacks, loopback) { |
| if ((loopback->cb_data == loopback_dev) && |
| (loopback->type == type)) { |
| DL_DELETE(iodev->loopbacks, loopback); |
| free(loopback); |
| } |
| } |
| } |
| |
| void cras_iodev_list_reset_for_noise_cancellation() |
| { |
| struct cras_iodev *dev; |
| bool enabled = cras_system_get_noise_cancellation_enabled(); |
| |
| DL_FOREACH (devs[CRAS_STREAM_INPUT].iodevs, dev) { |
| if (!cras_iodev_is_open(dev) || |
| !cras_iodev_support_noise_cancellation(dev)) |
| continue; |
| syslog(LOG_INFO, "Re-open %s for %s noise cancellation", |
| dev->info.name, enabled ? "enabling" : "disabling"); |
| possibly_enable_fallback(CRAS_STREAM_INPUT, false); |
| cras_iodev_list_suspend_dev(dev->info.idx); |
| cras_iodev_list_resume_dev(dev->info.idx); |
| possibly_disable_fallback(CRAS_STREAM_INPUT); |
| } |
| } |
| |
| void cras_iodev_list_reset() |
| { |
| struct enabled_dev *edev; |
| |
| DL_FOREACH (enabled_devs[CRAS_STREAM_OUTPUT], edev) { |
| DL_DELETE(enabled_devs[CRAS_STREAM_OUTPUT], edev); |
| free(edev); |
| } |
| enabled_devs[CRAS_STREAM_OUTPUT] = NULL; |
| DL_FOREACH (enabled_devs[CRAS_STREAM_INPUT], edev) { |
| DL_DELETE(enabled_devs[CRAS_STREAM_INPUT], edev); |
| free(edev); |
| } |
| enabled_devs[CRAS_STREAM_INPUT] = NULL; |
| devs[CRAS_STREAM_OUTPUT].iodevs = NULL; |
| devs[CRAS_STREAM_INPUT].iodevs = NULL; |
| devs[CRAS_STREAM_OUTPUT].size = 0; |
| devs[CRAS_STREAM_INPUT].size = 0; |
| } |