681 lines
25 KiB
C
681 lines
25 KiB
C
/*
|
|
* Copyright (c) 2013, The Linux Foundation. All rights reserved.
|
|
*
|
|
* 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 Linux Foundation 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 "AS IS" AND ANY EXPRESS OR IMPLIED
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
|
|
* 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.
|
|
*/
|
|
|
|
#define LOG_TAG "audio_hw_spkr_prot"
|
|
/*#define LOG_NDEBUG 0*/
|
|
#define LOG_NDDEBUG 0
|
|
|
|
#include <errno.h>
|
|
#include <math.h>
|
|
#include <cutils/log.h>
|
|
#include <fcntl.h>
|
|
#include "audio_hw.h"
|
|
#include "platform.h"
|
|
#include "platform_api.h"
|
|
#include <sys/stat.h>
|
|
#include <stdlib.h>
|
|
#include <dlfcn.h>
|
|
#include <math.h>
|
|
#include <cutils/properties.h>
|
|
#include "audio_extn.h"
|
|
#include <linux/msm_audio_acdb.h>
|
|
|
|
#ifdef SPKR_PROT_ENABLED
|
|
|
|
/*Range of spkr temparatures -30C to 80C*/
|
|
#define MIN_SPKR_TEMP_Q6 (-30 * (1 << 6))
|
|
#define MAX_SPKR_TEMP_Q6 (80 * (1 << 6))
|
|
|
|
/*Set safe temp value to 40C*/
|
|
#define SAFE_SPKR_TEMP 40
|
|
#define SAFE_SPKR_TEMP_Q6 (SAFE_SPKR_TEMP * (1 << 6))
|
|
|
|
/*Range of resistance values 2ohms to 40 ohms*/
|
|
#define MIN_RESISTANCE_SPKR_Q24 (2 * (1 << 24))
|
|
#define MAX_RESISTANCE_SPKR_Q24 (40 * (1 << 24))
|
|
|
|
/*Path where the calibration file will be stored*/
|
|
#define CALIB_FILE "/data/misc/audio/audio.cal"
|
|
|
|
/*Time between retries for calibartion or intial wait time
|
|
after boot up*/
|
|
#define WAIT_TIME_SPKR_CALIB (60 * 1000 * 1000)
|
|
|
|
#define MIN_SPKR_IDLE_SEC (60 * 30)
|
|
|
|
/*Once calibration is started sleep for 1 sec to allow
|
|
the calibration to kick off*/
|
|
#define SLEEP_AFTER_CALIB_START (3000)
|
|
|
|
/*If calibration is in progress wait for 200 msec before querying
|
|
for status again*/
|
|
#define WAIT_FOR_GET_CALIB_STATUS (200 * 1000)
|
|
|
|
/*Speaker states*/
|
|
#define SPKR_NOT_CALIBRATED -1
|
|
#define SPKR_CALIBRATED 1
|
|
|
|
/*Speaker processing state*/
|
|
#define SPKR_PROCESSING_IN_PROGRESS 1
|
|
#define SPKR_PROCESSING_IN_IDLE 0
|
|
|
|
/*Modes of Speaker Protection*/
|
|
enum speaker_protection_mode {
|
|
SPKR_PROTECTION_DISABLED = -1,
|
|
SPKR_PROTECTION_MODE_PROCESSING = 0,
|
|
SPKR_PROTECTION_MODE_CALIBRATE = 1,
|
|
};
|
|
|
|
struct speaker_prot_session {
|
|
int spkr_prot_mode;
|
|
int spkr_processing_state;
|
|
int thermal_client_handle;
|
|
pthread_mutex_t mutex_spkr_prot;
|
|
pthread_t spkr_calibration_thread;
|
|
pthread_mutex_t spkr_prot_thermalsync_mutex;
|
|
pthread_cond_t spkr_prot_thermalsync;
|
|
int cancel_spkr_calib;
|
|
pthread_cond_t spkr_calib_cancel;
|
|
pthread_mutex_t spkr_calib_cancelack_mutex;
|
|
pthread_cond_t spkr_calibcancel_ack;
|
|
pthread_t speaker_prot_threadid;
|
|
void *thermal_handle;
|
|
void *adev_handle;
|
|
int spkr_prot_t0;
|
|
struct pcm *pcm_rx;
|
|
struct pcm *pcm_tx;
|
|
int (*client_register_callback)
|
|
(char *client_name, int (*callback)(int, void *, void *), void *data);
|
|
void (*thermal_client_unregister_callback)(int handle);
|
|
int (*thermal_client_request)(char *client_name, int req_data);
|
|
bool spkr_prot_enable;
|
|
bool spkr_in_use;
|
|
struct timespec spkr_last_time_used;
|
|
};
|
|
|
|
static struct pcm_config pcm_config_skr_prot = {
|
|
.channels = 2,
|
|
.rate = 48000,
|
|
.period_size = 256,
|
|
.period_count = 4,
|
|
.format = PCM_FORMAT_S16_LE,
|
|
.start_threshold = 0,
|
|
.stop_threshold = INT_MAX,
|
|
.avail_min = 0,
|
|
};
|
|
|
|
static struct speaker_prot_session handle;
|
|
|
|
static void spkr_prot_set_spkrstatus(bool enable)
|
|
{
|
|
struct timespec ts;
|
|
if (enable)
|
|
handle.spkr_in_use = true;
|
|
else {
|
|
handle.spkr_in_use = false;
|
|
clock_gettime(CLOCK_MONOTONIC, &handle.spkr_last_time_used);
|
|
}
|
|
}
|
|
|
|
static void spkr_prot_calib_cancel(void *adev)
|
|
{
|
|
pthread_t threadid;
|
|
struct audio_usecase *uc_info;
|
|
int count = 0;
|
|
threadid = pthread_self();
|
|
ALOGV("%s: Entry", __func__);
|
|
if (pthread_equal(handle.speaker_prot_threadid, threadid) || !adev) {
|
|
ALOGE("%s: Invalid params", __func__);
|
|
return;
|
|
}
|
|
uc_info = get_usecase_from_list(adev, USECASE_AUDIO_SPKR_CALIB_RX);
|
|
if (uc_info) {
|
|
pthread_mutex_lock(&handle.mutex_spkr_prot);
|
|
pthread_mutex_lock(&handle.spkr_calib_cancelack_mutex);
|
|
handle.cancel_spkr_calib = 1;
|
|
pthread_cond_signal(&handle.spkr_calib_cancel);
|
|
pthread_mutex_unlock(&handle.mutex_spkr_prot);
|
|
pthread_cond_wait(&handle.spkr_calibcancel_ack,
|
|
&handle.spkr_calib_cancelack_mutex);
|
|
pthread_mutex_unlock(&handle.spkr_calib_cancelack_mutex);
|
|
pthread_mutex_unlock(&handle.mutex_spkr_prot);
|
|
}
|
|
ALOGV("%s: Exit", __func__);
|
|
}
|
|
|
|
static bool is_speaker_in_use(unsigned long *sec)
|
|
{
|
|
struct timespec temp;
|
|
if (!sec) {
|
|
ALOGE("%s: Invalid params", __func__);
|
|
return true;
|
|
}
|
|
if (handle.spkr_in_use) {
|
|
*sec = 0;
|
|
return true;
|
|
} else {
|
|
clock_gettime(CLOCK_MONOTONIC, &temp);
|
|
*sec = temp.tv_sec - handle.spkr_last_time_used.tv_sec;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
static int spkr_calibrate(int t0)
|
|
{
|
|
struct audio_device *adev = handle.adev_handle;
|
|
struct msm_spk_prot_cfg protCfg;
|
|
struct msm_spk_prot_status status;
|
|
bool cleanup = false, disable_rx = false, disable_tx = false;
|
|
int acdb_fd = -1;
|
|
struct audio_usecase *uc_info_rx = NULL, *uc_info_tx = NULL;
|
|
int32_t pcm_dev_rx_id = -1, pcm_dev_tx_id = -1;
|
|
struct timespec ts;
|
|
|
|
if (!adev) {
|
|
ALOGE("%s: Invalid params", __func__);
|
|
return -EINVAL;
|
|
}
|
|
if (!list_empty(&adev->usecase_list)) {
|
|
ALOGD("%s: Usecase present retry speaker protection", __func__);
|
|
return -EAGAIN;
|
|
}
|
|
acdb_fd = open("/dev/msm_acdb",O_RDWR | O_NONBLOCK);
|
|
if (acdb_fd < 0) {
|
|
ALOGE("%s: spkr_prot_thread open msm_acdb failed", __func__);
|
|
return -ENODEV;
|
|
} else {
|
|
protCfg.mode = MSM_SPKR_PROT_CALIBRATION_IN_PROGRESS;
|
|
protCfg.t0 = t0;
|
|
if (ioctl(acdb_fd, AUDIO_SET_SPEAKER_PROT, &protCfg)) {
|
|
ALOGE("%s: spkr_prot_thread set failed AUDIO_SET_SPEAKER_PROT",
|
|
__func__);
|
|
status.status = -ENODEV;
|
|
goto exit;
|
|
}
|
|
}
|
|
uc_info_rx = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase));
|
|
uc_info_rx->id = USECASE_AUDIO_SPKR_CALIB_RX;
|
|
uc_info_rx->type = PCM_PLAYBACK;
|
|
uc_info_rx->in_snd_device = SND_DEVICE_NONE;
|
|
uc_info_rx->out_snd_device = SND_DEVICE_OUT_SPEAKER_PROTECTED;
|
|
pthread_mutex_lock(&adev->lock);
|
|
disable_rx = true;
|
|
enable_snd_device(adev, SND_DEVICE_OUT_SPEAKER_PROTECTED, true);
|
|
enable_audio_route(adev, uc_info_rx, true);
|
|
pthread_mutex_unlock(&adev->lock);
|
|
|
|
pcm_dev_rx_id = platform_get_pcm_device_id(uc_info_rx->id, PCM_PLAYBACK);
|
|
ALOGV("%s: pcm device id %d", __func__, pcm_dev_rx_id);
|
|
if (pcm_dev_rx_id < 0) {
|
|
ALOGE("%s: Invalid pcm device for usecase (%d)",
|
|
__func__, uc_info_rx->id);
|
|
status.status = -ENODEV;
|
|
goto exit;
|
|
}
|
|
handle.pcm_rx = handle.pcm_tx = NULL;
|
|
handle.pcm_rx = pcm_open(adev->snd_card,
|
|
pcm_dev_rx_id,
|
|
PCM_OUT, &pcm_config_skr_prot);
|
|
if (handle.pcm_rx && !pcm_is_ready(handle.pcm_rx)) {
|
|
ALOGE("%s: %s", __func__, pcm_get_error(handle.pcm_rx));
|
|
status.status = -EIO;
|
|
goto exit;
|
|
}
|
|
uc_info_tx = (struct audio_usecase *)
|
|
calloc(1, sizeof(struct audio_usecase));
|
|
uc_info_tx->id = USECASE_AUDIO_SPKR_CALIB_TX;
|
|
uc_info_tx->type = PCM_CAPTURE;
|
|
uc_info_tx->in_snd_device = SND_DEVICE_NONE;
|
|
uc_info_tx->out_snd_device = SND_DEVICE_NONE;
|
|
|
|
pthread_mutex_lock(&adev->lock);
|
|
disable_tx = true;
|
|
enable_snd_device(adev, SND_DEVICE_IN_CAPTURE_VI_FEEDBACK, true);
|
|
enable_audio_route(adev, uc_info_tx, true);
|
|
pthread_mutex_unlock(&adev->lock);
|
|
|
|
pcm_dev_tx_id = platform_get_pcm_device_id(uc_info_tx->id, PCM_CAPTURE);
|
|
if (pcm_dev_tx_id < 0) {
|
|
ALOGE("%s: Invalid pcm device for usecase (%d)",
|
|
__func__, uc_info_tx->id);
|
|
status.status = -ENODEV;
|
|
goto exit;
|
|
}
|
|
handle.pcm_tx = pcm_open(adev->snd_card,
|
|
pcm_dev_tx_id,
|
|
PCM_IN, &pcm_config_skr_prot);
|
|
if (handle.pcm_tx && !pcm_is_ready(handle.pcm_tx)) {
|
|
ALOGE("%s: %s", __func__, pcm_get_error(handle.pcm_tx));
|
|
status.status = -EIO;
|
|
goto exit;
|
|
}
|
|
if (pcm_start(handle.pcm_rx) < 0) {
|
|
ALOGE("%s: pcm start for RX failed", __func__);
|
|
status.status = -EINVAL;
|
|
goto exit;
|
|
}
|
|
if (pcm_start(handle.pcm_tx) < 0) {
|
|
ALOGE("%s: pcm start for TX failed", __func__);
|
|
status.status = -EINVAL;
|
|
goto exit;
|
|
}
|
|
cleanup = true;
|
|
clock_gettime(CLOCK_REALTIME, &ts);
|
|
ts.tv_sec += (SLEEP_AFTER_CALIB_START/1000);
|
|
ts.tv_nsec = 0;
|
|
(void)pthread_cond_timedwait(&handle.spkr_calib_cancel,
|
|
&handle.mutex_spkr_prot, &ts);
|
|
ALOGD("%s: Speaker calibration done", __func__);
|
|
cleanup = true;
|
|
pthread_mutex_lock(&handle.spkr_calib_cancelack_mutex);
|
|
if (handle.cancel_spkr_calib) {
|
|
status.status = -EAGAIN;
|
|
goto exit;
|
|
}
|
|
if (acdb_fd > 0) {
|
|
status.status = -EINVAL;
|
|
while (!ioctl(acdb_fd, AUDIO_GET_SPEAKER_PROT,&status)) {
|
|
/*sleep for 200 ms to check for status check*/
|
|
if (!status.status) {
|
|
ALOGD("%s: spkr_prot_thread calib Success R0 %d",
|
|
__func__, status.r0);
|
|
FILE *fp;
|
|
fp = fopen(CALIB_FILE,"wb");
|
|
if (!fp) {
|
|
ALOGE("%s: spkr_prot_thread File open failed %s",
|
|
__func__, strerror(errno));
|
|
status.status = -ENODEV;
|
|
} else {
|
|
fwrite(&status.r0, sizeof(status.r0),1,fp);
|
|
fwrite(&protCfg.t0, sizeof(protCfg.t0),1,fp);
|
|
fclose(fp);
|
|
}
|
|
break;
|
|
} else if (status.status == -EAGAIN) {
|
|
ALOGD("%s: spkr_prot_thread try again", __func__);
|
|
usleep(WAIT_FOR_GET_CALIB_STATUS);
|
|
} else {
|
|
ALOGE("%s: spkr_prot_thread get failed status %d",
|
|
__func__, status.status);
|
|
break;
|
|
}
|
|
}
|
|
exit:
|
|
if (handle.pcm_rx)
|
|
pcm_close(handle.pcm_rx);
|
|
handle.pcm_rx = NULL;
|
|
if (handle.pcm_tx)
|
|
pcm_close(handle.pcm_tx);
|
|
handle.pcm_tx = NULL;
|
|
pthread_mutex_lock(&adev->lock);
|
|
if (disable_rx) {
|
|
disable_snd_device(adev, SND_DEVICE_OUT_SPEAKER_PROTECTED, true);
|
|
disable_audio_route(adev, uc_info_rx, true);
|
|
}
|
|
if (disable_tx) {
|
|
disable_snd_device(adev, SND_DEVICE_IN_CAPTURE_VI_FEEDBACK, true);
|
|
disable_audio_route(adev, uc_info_tx, true);
|
|
}
|
|
pthread_mutex_unlock(&adev->lock);
|
|
|
|
if (!status.status) {
|
|
protCfg.mode = MSM_SPKR_PROT_CALIBRATED;
|
|
protCfg.r0 = status.r0;
|
|
if (ioctl(acdb_fd, AUDIO_SET_SPEAKER_PROT, &protCfg))
|
|
ALOGE("%s: spkr_prot_thread disable calib mode", __func__);
|
|
else
|
|
handle.spkr_prot_mode = MSM_SPKR_PROT_CALIBRATED;
|
|
} else {
|
|
protCfg.mode = MSM_SPKR_PROT_NOT_CALIBRATED;
|
|
handle.spkr_prot_mode = MSM_SPKR_PROT_NOT_CALIBRATED;
|
|
if (ioctl(acdb_fd, AUDIO_SET_SPEAKER_PROT, &protCfg))
|
|
ALOGE("%s: spkr_prot_thread disable calib mode failed", __func__);
|
|
}
|
|
if (acdb_fd > 0)
|
|
close(acdb_fd);
|
|
if (uc_info_rx) free(uc_info_rx);
|
|
if (uc_info_tx) free(uc_info_tx);
|
|
if (cleanup) {
|
|
if (handle.cancel_spkr_calib)
|
|
pthread_cond_signal(&handle.spkr_calibcancel_ack);
|
|
handle.cancel_spkr_calib = 0;
|
|
pthread_mutex_unlock(&handle.spkr_calib_cancelack_mutex);
|
|
}
|
|
}
|
|
return status.status;
|
|
}
|
|
|
|
static void* spkr_calibration_thread(void *context)
|
|
{
|
|
unsigned long sec = 0;
|
|
int t0;
|
|
bool goahead = false;
|
|
struct msm_spk_prot_cfg protCfg;
|
|
FILE *fp;
|
|
int acdb_fd;
|
|
struct audio_device *adev = handle.adev_handle;
|
|
|
|
handle.speaker_prot_threadid = pthread_self();
|
|
ALOGD("spkr_prot_thread enable prot Entry");
|
|
acdb_fd = open("/dev/msm_acdb",O_RDWR | O_NONBLOCK);
|
|
if (acdb_fd > 0) {
|
|
/*Set processing mode with t0/r0*/
|
|
protCfg.mode = MSM_SPKR_PROT_NOT_CALIBRATED;
|
|
if (ioctl(acdb_fd, AUDIO_SET_SPEAKER_PROT, &protCfg)) {
|
|
ALOGE("%s: spkr_prot_thread enable prot failed", __func__);
|
|
handle.spkr_prot_mode = MSM_SPKR_PROT_DISABLED;
|
|
close(acdb_fd);
|
|
} else
|
|
handle.spkr_prot_mode = MSM_SPKR_PROT_NOT_CALIBRATED;
|
|
} else {
|
|
handle.spkr_prot_mode = MSM_SPKR_PROT_DISABLED;
|
|
ALOGE("%s: Failed to open acdb node", __func__);
|
|
}
|
|
if (handle.spkr_prot_mode == MSM_SPKR_PROT_DISABLED) {
|
|
ALOGD("%s: Speaker protection disabled", __func__);
|
|
pthread_exit(0);
|
|
return NULL;
|
|
}
|
|
|
|
fp = fopen(CALIB_FILE,"rb");
|
|
if (fp) {
|
|
fread(&protCfg.r0,sizeof(protCfg.r0),1,fp);
|
|
ALOGD("%s: spkr_prot_thread r0 value %d", __func__, protCfg.r0);
|
|
fread(&protCfg.t0, sizeof(protCfg.t0), 1, fp);
|
|
ALOGD("%s: spkr_prot_thread t0 value %d", __func__, protCfg.t0);
|
|
fclose(fp);
|
|
/*Valid tempature range: -30C to 80C(in q6 format)
|
|
Valid Resistance range: 2 ohms to 40 ohms(in q24 format)*/
|
|
if (protCfg.t0 > MIN_SPKR_TEMP_Q6 &&
|
|
protCfg.t0 < MAX_SPKR_TEMP_Q6 &&
|
|
protCfg.r0 >= MIN_RESISTANCE_SPKR_Q24
|
|
&& protCfg.r0 < MAX_RESISTANCE_SPKR_Q24) {
|
|
ALOGD("%s: Spkr calibrated", __func__);
|
|
protCfg.mode = MSM_SPKR_PROT_CALIBRATED;
|
|
if (ioctl(acdb_fd, AUDIO_SET_SPEAKER_PROT, &protCfg)) {
|
|
ALOGE("%s: enable prot failed", __func__);
|
|
handle.spkr_prot_mode = MSM_SPKR_PROT_DISABLED;
|
|
} else
|
|
handle.spkr_prot_mode = MSM_SPKR_PROT_CALIBRATED;
|
|
close(acdb_fd);
|
|
pthread_exit(0);
|
|
return NULL;
|
|
}
|
|
close(acdb_fd);
|
|
}
|
|
|
|
while (1) {
|
|
ALOGV("%s: start calibration", __func__);
|
|
if (!handle.thermal_client_request("spkr",1)) {
|
|
ALOGD("%s: wait for callback from thermal daemon", __func__);
|
|
pthread_mutex_lock(&handle.spkr_prot_thermalsync_mutex);
|
|
pthread_cond_wait(&handle.spkr_prot_thermalsync,
|
|
&handle.spkr_prot_thermalsync_mutex);
|
|
/*Convert temp into q6 format*/
|
|
t0 = (handle.spkr_prot_t0 * (1 << 6));
|
|
pthread_mutex_unlock(&handle.spkr_prot_thermalsync_mutex);
|
|
if (t0 < MIN_SPKR_TEMP_Q6 || t0 > MAX_SPKR_TEMP_Q6) {
|
|
ALOGE("%s: Calibration temparature error %d", __func__,
|
|
handle.spkr_prot_t0);
|
|
continue;
|
|
}
|
|
ALOGD("%s: Request t0 success value %d", __func__,
|
|
handle.spkr_prot_t0);
|
|
} else {
|
|
ALOGE("%s: Request t0 failed", __func__);
|
|
/*Assume safe value for temparature*/
|
|
t0 = SAFE_SPKR_TEMP_Q6;
|
|
}
|
|
goahead = false;
|
|
pthread_mutex_lock(&handle.mutex_spkr_prot);
|
|
if (is_speaker_in_use(&sec)) {
|
|
ALOGD("%s: Speaker in use retry calibration", __func__);
|
|
pthread_mutex_unlock(&handle.mutex_spkr_prot);
|
|
continue;
|
|
} else {
|
|
ALOGD("%s: speaker idle %ld", __func__, sec);
|
|
if (sec < MIN_SPKR_IDLE_SEC) {
|
|
ALOGD("%s: speaker idle is less retry", __func__);
|
|
pthread_mutex_unlock(&handle.mutex_spkr_prot);
|
|
continue;
|
|
}
|
|
goahead = true;
|
|
}
|
|
if (!list_empty(&adev->usecase_list))
|
|
goahead = false;
|
|
if (goahead) {
|
|
int status;
|
|
status = spkr_calibrate(t0);
|
|
if (status == -EAGAIN) {
|
|
ALOGE("%s: failed to calibrate try again %s",
|
|
__func__, strerror(status));
|
|
pthread_mutex_unlock(&handle.mutex_spkr_prot);
|
|
continue;
|
|
} else {
|
|
ALOGE("%s: calibrate status %s", __func__, strerror(status));
|
|
}
|
|
ALOGD("%s: spkr_prot_thread end calibration", __func__);
|
|
pthread_mutex_unlock(&handle.mutex_spkr_prot);
|
|
break;
|
|
}
|
|
}
|
|
if (handle.thermal_client_handle)
|
|
handle.thermal_client_unregister_callback(handle.thermal_client_handle);
|
|
handle.thermal_client_handle = 0;
|
|
if (handle.thermal_handle)
|
|
dlclose(handle.thermal_handle);
|
|
handle.thermal_handle = NULL;
|
|
pthread_exit(0);
|
|
return NULL;
|
|
}
|
|
|
|
static int thermal_client_callback(int temp, void *user_data, void *reserved)
|
|
{
|
|
pthread_mutex_lock(&handle.spkr_prot_thermalsync_mutex);
|
|
ALOGD("%s: spkr_prot set t0 %d and signal", __func__, temp);
|
|
if (handle.spkr_prot_mode == MSM_SPKR_PROT_NOT_CALIBRATED)
|
|
handle.spkr_prot_t0 = temp;
|
|
pthread_cond_signal(&handle.spkr_prot_thermalsync);
|
|
pthread_mutex_unlock(&handle.spkr_prot_thermalsync_mutex);
|
|
return 0;
|
|
}
|
|
|
|
void audio_extn_spkr_prot_init(void *adev)
|
|
{
|
|
char value[PROPERTY_VALUE_MAX];
|
|
ALOGD("%s: Initialize speaker protection module", __func__);
|
|
memset(&handle, 0, sizeof(handle));
|
|
if (!adev) {
|
|
ALOGE("%s: Invalid params", __func__);
|
|
return;
|
|
}
|
|
property_get("persist.speaker.prot.enable", value, "");
|
|
handle.spkr_prot_enable = false;
|
|
if (!strncmp("true", value, 4))
|
|
handle.spkr_prot_enable = true;
|
|
if (!handle.spkr_prot_enable) {
|
|
ALOGD("%s: Speaker protection disabled", __func__);
|
|
return;
|
|
}
|
|
handle.adev_handle = adev;
|
|
handle.spkr_prot_mode = MSM_SPKR_PROT_DISABLED;
|
|
handle.spkr_processing_state = SPKR_PROCESSING_IN_IDLE;
|
|
handle.spkr_prot_t0 = -1;
|
|
pthread_cond_init(&handle.spkr_prot_thermalsync, NULL);
|
|
pthread_cond_init(&handle.spkr_calib_cancel, NULL);
|
|
pthread_cond_init(&handle.spkr_calibcancel_ack, NULL);
|
|
pthread_mutex_init(&handle.mutex_spkr_prot, NULL);
|
|
pthread_mutex_init(&handle.spkr_calib_cancelack_mutex, NULL);
|
|
pthread_mutex_init(&handle.spkr_prot_thermalsync_mutex, NULL);
|
|
handle.thermal_handle = dlopen("/vendor/lib/libthermalclient.so",
|
|
RTLD_NOW);
|
|
if (!handle.thermal_handle) {
|
|
ALOGE("%s: DLOPEN for thermal client failed", __func__);
|
|
} else {
|
|
/*Query callback function symbol*/
|
|
handle.client_register_callback =
|
|
(int (*)(char *, int (*)(int, void *, void *),void *))
|
|
dlsym(handle.thermal_handle, "thermal_client_register_callback");
|
|
handle.thermal_client_unregister_callback =
|
|
(void (*)(int) )
|
|
dlsym(handle.thermal_handle, "thermal_client_unregister_callback");
|
|
if (!handle.client_register_callback ||
|
|
!handle.thermal_client_unregister_callback) {
|
|
ALOGE("%s: DLSYM thermal_client_register_callback failed", __func__);
|
|
} else {
|
|
/*Register callback function*/
|
|
handle.thermal_client_handle =
|
|
handle.client_register_callback("spkr", thermal_client_callback, NULL);
|
|
if (!handle.thermal_client_handle) {
|
|
ALOGE("%s: client_register_callback failed", __func__);
|
|
} else {
|
|
ALOGD("%s: spkr_prot client_register_callback success", __func__);
|
|
handle.thermal_client_request = (int (*)(char *, int))
|
|
dlsym(handle.thermal_handle, "thermal_client_request");
|
|
}
|
|
}
|
|
}
|
|
if (handle.thermal_client_request) {
|
|
ALOGD("%s: Create calibration thread", __func__);
|
|
(void)pthread_create(&handle.spkr_calibration_thread,
|
|
(const pthread_attr_t *) NULL, spkr_calibration_thread, &handle);
|
|
} else {
|
|
ALOGE("%s: thermal_client_request failed", __func__);
|
|
if (handle.thermal_client_handle)
|
|
handle.thermal_client_unregister_callback(handle.thermal_client_handle);
|
|
if (handle.thermal_handle)
|
|
dlclose(handle.thermal_handle);
|
|
handle.thermal_handle = NULL;
|
|
handle.spkr_prot_enable = false;
|
|
}
|
|
}
|
|
|
|
int audio_extn_spkr_prot_start_processing(snd_device_t snd_device)
|
|
{
|
|
struct audio_usecase uc_info_tx;
|
|
struct audio_device *adev = handle.adev_handle;
|
|
int32_t pcm_dev_tx_id = -1, ret = 0;
|
|
|
|
ALOGV("%s: Entry", __func__);
|
|
/* cancel speaker calibration */
|
|
if (!adev) {
|
|
ALOGE("%s: Invalid params", __func__);
|
|
return -EINVAL;
|
|
}
|
|
spkr_prot_calib_cancel(adev);
|
|
spkr_prot_set_spkrstatus(true);
|
|
if (platform_send_audio_calibration(adev->platform,
|
|
SND_DEVICE_OUT_SPEAKER_PROTECTED) < 0) {
|
|
adev->snd_dev_ref_cnt[snd_device]--;
|
|
return -EINVAL;
|
|
}
|
|
ALOGV("%s: snd_device(%d: %s)", __func__, snd_device,
|
|
platform_get_snd_device_name(SND_DEVICE_OUT_SPEAKER_PROTECTED));
|
|
audio_route_apply_path(adev->audio_route,
|
|
platform_get_snd_device_name(SND_DEVICE_OUT_SPEAKER_PROTECTED));
|
|
|
|
pthread_mutex_lock(&handle.mutex_spkr_prot);
|
|
if (handle.spkr_processing_state == SPKR_PROCESSING_IN_IDLE) {
|
|
memset(&uc_info_tx, 0 , sizeof(uc_info_tx));
|
|
uc_info_tx.id = USECASE_AUDIO_SPKR_CALIB_TX;
|
|
uc_info_tx.type = PCM_CAPTURE;
|
|
uc_info_tx.in_snd_device = SND_DEVICE_NONE;
|
|
uc_info_tx.out_snd_device = SND_DEVICE_NONE;
|
|
handle.pcm_tx = NULL;
|
|
|
|
enable_snd_device(adev, SND_DEVICE_IN_CAPTURE_VI_FEEDBACK, true);
|
|
enable_audio_route(adev, &uc_info_tx, true);
|
|
|
|
pcm_dev_tx_id = platform_get_pcm_device_id(uc_info_tx.id, PCM_CAPTURE);
|
|
if (pcm_dev_tx_id < 0) {
|
|
ALOGE("%s: Invalid pcm device for usecase (%d)",
|
|
__func__, uc_info_tx.id);
|
|
ret = -ENODEV;
|
|
goto exit;
|
|
}
|
|
handle.pcm_tx = pcm_open(adev->snd_card,
|
|
pcm_dev_tx_id,
|
|
PCM_IN, &pcm_config_skr_prot);
|
|
if (handle.pcm_tx && !pcm_is_ready(handle.pcm_tx)) {
|
|
ALOGE("%s: %s", __func__, pcm_get_error(handle.pcm_tx));
|
|
ret = -EIO;
|
|
goto exit;
|
|
}
|
|
if (pcm_start(handle.pcm_tx) < 0) {
|
|
ALOGE("%s: pcm start for TX failed", __func__);
|
|
ret = -EINVAL;
|
|
}
|
|
}
|
|
exit:
|
|
if (ret) {
|
|
if (handle.pcm_tx)
|
|
pcm_close(handle.pcm_tx);
|
|
handle.pcm_tx = NULL;
|
|
disable_snd_device(adev, SND_DEVICE_IN_CAPTURE_VI_FEEDBACK, true);
|
|
disable_audio_route(adev, &uc_info_tx, true);
|
|
} else
|
|
handle.spkr_processing_state = SPKR_PROCESSING_IN_PROGRESS;
|
|
pthread_mutex_unlock(&handle.mutex_spkr_prot);
|
|
ALOGV("%s: Exit", __func__);
|
|
return ret;
|
|
}
|
|
|
|
void audio_extn_spkr_prot_stop_processing()
|
|
{
|
|
struct audio_usecase uc_info_tx;
|
|
struct audio_device *adev = handle.adev_handle;
|
|
ALOGV("%s: Entry", __func__);
|
|
spkr_prot_set_spkrstatus(false);
|
|
pthread_mutex_lock(&handle.mutex_spkr_prot);
|
|
if (adev && handle.spkr_processing_state == SPKR_PROCESSING_IN_PROGRESS) {
|
|
memset(&uc_info_tx, 0 , sizeof(uc_info_tx));
|
|
uc_info_tx.id = USECASE_AUDIO_SPKR_CALIB_TX;
|
|
uc_info_tx.type = PCM_CAPTURE;
|
|
uc_info_tx.in_snd_device = SND_DEVICE_NONE;
|
|
uc_info_tx.out_snd_device = SND_DEVICE_NONE;
|
|
if (handle.pcm_tx)
|
|
pcm_close(handle.pcm_tx);
|
|
handle.pcm_tx = NULL;
|
|
disable_snd_device(adev, SND_DEVICE_IN_CAPTURE_VI_FEEDBACK, true);
|
|
disable_audio_route(adev, &uc_info_tx, true);
|
|
}
|
|
handle.spkr_processing_state = SPKR_PROCESSING_IN_IDLE;
|
|
pthread_mutex_unlock(&handle.mutex_spkr_prot);
|
|
audio_route_reset_path(adev->audio_route,
|
|
platform_get_snd_device_name(SND_DEVICE_OUT_SPEAKER_PROTECTED));
|
|
ALOGV("%s: Exit", __func__);
|
|
}
|
|
|
|
bool audio_extn_spkr_prot_is_enabled()
|
|
{
|
|
return handle.spkr_prot_enable;
|
|
}
|
|
#endif /*SPKR_PROT_ENABLED*/
|