Remove msm8909 subdirectory (536daa59) · Commits · e / os / android_hardware_qcom_audio

msm8909/Android.mk

deleted100644 → 0

+0 −25

Original line number	Diff line number	Diff line
		ifneq ($(filter mpq8092 msm8960 msm8226 msm8x26 msm8610 msm8974 msm8x74 apq8084 msm8916 msm8994 msm8909,$(TARGET_BOARD_PLATFORM)),)

		MY_LOCAL_PATH := $(call my-dir)

		ifeq ($(BOARD_USES_LEGACY_ALSA_AUDIO),true)
		include $(MY_LOCAL_PATH)/legacy/Android.mk
		else
		ifneq ($(filter mpq8092,$(TARGET_BOARD_PLATFORM)),)
		include $(MY_LOCAL_PATH)/hal_mpq/Android.mk
		else
		include $(MY_LOCAL_PATH)/hal/Android.mk
		endif
		include $(MY_LOCAL_PATH)/voice_processing/Android.mk
		ifneq ($(TARGET_SUPPORTS_WEARABLES),true)
		include $(MY_LOCAL_PATH)/mm-audio/Android.mk
		endif
		include $(MY_LOCAL_PATH)/policy_hal/Android.mk
		include $(MY_LOCAL_PATH)/visualizer/Android.mk
		include $(MY_LOCAL_PATH)/audiod/Android.mk
		ifneq ($(TARGET_SUPPORTS_ANDROID_WEAR),true)
		include $(MY_LOCAL_PATH)/post_proc/Android.mk
		endif
		endif

		endif

msm8909/audiod/Android.mk

deleted100644 → 0

+0 −21

Original line number	Diff line number	Diff line
		LOCAL_PATH:= $(call my-dir)

		include $(CLEAR_VARS)

		LOCAL_SRC_FILES:= \
		audiod_main.cpp \
		AudioDaemon.cpp \

		LOCAL_CFLAGS += -DGL_GLEXT_PROTOTYPES -DEGL_EGLEXT_PROTOTYPES

		LOCAL_SHARED_LIBRARIES := \
		libcutils \
		libutils \
		libbinder \
		libmedia

		LOCAL_ADDITIONAL_DEPENDENCIES := $(BOARD_KERNEL_HEADER_DEPENDENCIES)

		LOCAL_MODULE:= audiod

		include $(BUILD_EXECUTABLE)

msm8909/audiod/AudioDaemon.cpp

deleted100644 → 0

+0 −460

Original line number	Diff line number	Diff line
		/* AudioDaemon.cpp
		Copyright (c) 2012-2015, 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 "AudioDaemon"
		#define LOG_NDEBUG 0
		#define LOG_NDDEBUG 0

		#include <dirent.h>
		#include <media/AudioSystem.h>
		#include <sys/poll.h>

		#include "AudioDaemon.h"

		#define CPE_MAGIC_NUM 0x2000
		#define MAX_CPE_SLEEP_RETRY 2
		#define CPE_SLEEP_WAIT 100

		#define MAX_SLEEP_RETRY 100
		#define AUDIO_INIT_SLEEP_WAIT 100 /* 100 ms */

		int bootup_complete = 0;
		bool cpe_bootup_complete = false;

		namespace android {

		AudioDaemon::AudioDaemon() : Thread(false) {
		}

		AudioDaemon::~AudioDaemon() {
		putStateFDs(mSndCardFd);
		}

		void AudioDaemon::onFirstRef() {
		ALOGV("Start audiod daemon");
		run("AudioDaemon", PRIORITY_URGENT_AUDIO);
		}

		void AudioDaemon::binderDied(const wp<IBinder>& who)
		{
		requestExit();
		}

		bool AudioDaemon::getStateFDs(std::vector<std::pair<int,int> > &sndcardFdPair)
		{
		FILE *fp;
		int fd;
		char ptr, saveptr;
		char buffer[128];
		int line = 0;
		String8 path;
		int sndcard;
		const char* cards = "/proc/asound/cards";

		if ((fp = fopen(cards, "r")) == NULL) {
		ALOGE("Cannot open %s file to get list of sound cars", cards);
		return false;
		}

		sndcardFdPair.clear();
		memset(buffer, 0x0, sizeof(buffer));
		while ((fgets(buffer, sizeof(buffer), fp) != NULL)) {
		if (line % 2)
		continue;
		ptr = strtok_r(buffer, " [", &saveptr);
		if (ptr) {
		path = "/proc/asound/card";
		path += ptr;
		path += "/state";
		ALOGD("Opening sound card state : %s", path.string());
		fd = open(path.string(), O_RDONLY);
		if (fd == -1) {
		ALOGE("Open %s failed : %s", path.string(), strerror(errno));
		} else {
		/* returns vector of pair<sndcard, fd> */
		sndcard = atoi(ptr);
		sndcardFdPair.push_back(std::make_pair(sndcard, fd));
		}
		}
		line++;
		}

		ALOGV("%s: %d sound cards detected", __func__, sndcardFdPair.size());
		fclose(fp);

		return sndcardFdPair.size() > 0 ? true : false;
		}

		void AudioDaemon::putStateFDs(std::vector<std::pair<int,int> > &sndcardFdPair)
		{
		unsigned int i;
		for (i = 0; i < sndcardFdPair.size(); i++)
		close(sndcardFdPair[i].second);
		sndcardFdPair.clear();
		}

		bool AudioDaemon::getDeviceEventFDs()
		{
		const char* events_dir = "/sys/class/switch/";
		DIR *dp;
		struct dirent* in_file;
		int fd;
		String8 path;
		String8 d_name;

		if ((dp = opendir(events_dir)) == NULL) {
		ALOGE("Cannot open switch directory to get list of audio events %s", events_dir);
		return false;
		}

		mAudioEvents.clear();
		mAudioEventsStatus.clear();

		while ((in_file = readdir(dp)) != NULL) {

		if (!strstr(in_file->d_name, "qc_"))
		continue;
		ALOGD(" Found event file = %s", in_file->d_name);
		path = "/sys/class/switch/";
		path += in_file->d_name;
		path += "/state";

		ALOGE("Opening audio event state : %s ", path.string());
		fd = open(path.string(), O_RDONLY);
		if (fd == -1) {
		ALOGE("Open %s failed : %s", path.string(), strerror(errno));
		} else {
		d_name = in_file->d_name;
		mAudioEvents.push_back(std::make_pair(d_name, fd));
		mAudioEventsStatus.push_back(std::make_pair(d_name, 0));
		ALOGD("event status mAudioEventsStatus= %s",
		mAudioEventsStatus[0].first.string());
		}
		}

		ALOGV("%s: %d audio device event detected",
		__func__,
		mAudioEvents.size());

		closedir(dp);
		return mAudioEvents.size() > 0 ? true : false;

		}

		void AudioDaemon::putDeviceEventFDs()
		{
		unsigned int i;
		for (i = 0; i < mAudioEvents.size(); i++) {
		close(mAudioEvents[i].second);
		delete(mAudioEvents[i].first);
		}
		mAudioEvents.clear();
		mAudioEventsStatus.clear();
		}

		void AudioDaemon::checkEventState(int fd, int index)
		{
		char state_buf[2];
		audio_event_status event_cur_state = audio_event_off;

		if (!read(fd, (void *)state_buf, 1)) {
		ALOGE("Error receiving device state event (%s)", strerror(errno));
		} else {
		state_buf[1] = '\0';
		if (atoi(state_buf) != mAudioEventsStatus[index].second) {
		ALOGD("notify audio HAL %s",
		mAudioEvents[index].first.string());
		mAudioEventsStatus[index].second = atoi(state_buf);

		if (mAudioEventsStatus[index].second == 1)
		event_cur_state = audio_event_on;
		else
		event_cur_state = audio_event_off;
		notifyAudioSystemEventStatus(
		mAudioEventsStatus[index].first.string(),
		event_cur_state);
		}
		}
		lseek(fd, 0, SEEK_SET);
		}

		status_t AudioDaemon::readyToRun() {

		ALOGV("readyToRun: open snd card state node files");
		return NO_ERROR;
		}

		bool AudioDaemon::threadLoop()
		{
		int max = -1;
		unsigned int i;
		bool ret = true;
		notify_status cur_state = snd_card_offline;
		struct pollfd *pfd = NULL;
		char rd_buf[9];
		unsigned int sleepRetry = 0;
		bool audioInitDone = false;
		int fd = 0;
		char path[50];
		notify_status cur_cpe_state = cpe_offline;
		notify_status prev_cpe_state = cpe_offline;
		unsigned int cpe_cnt = CPE_MAGIC_NUM;
		unsigned int num_snd_cards = 0;

		ALOGV("Start threadLoop()");
		while (audioInitDone == false && sleepRetry < MAX_SLEEP_RETRY) {
		if (mSndCardFd.empty() && !getStateFDs(mSndCardFd)) {
		ALOGE("Sleeping for 100 ms");
		usleep(AUDIO_INIT_SLEEP_WAIT*1000);
		sleepRetry++;
		} else {
		audioInitDone = true;
		}
		}

		if (!getDeviceEventFDs()) {
		ALOGE("No audio device events detected");
		}

		if (audioInitDone == false) {
		ALOGE("Sound Card is empty!!!");
		goto thread_exit;
		}

		/* soundcards are opened, now get the cpe state nodes */
		num_snd_cards = mSndCardFd.size();
		for (i = 0; i < num_snd_cards; i++) {
		snprintf(path, sizeof(path), "/proc/asound/card%d/cpe0_state", mSndCardFd[i].first);
		ALOGD("Opening cpe0_state : %s", path);
		sleepRetry = 0;
		do {
		fd = open(path, O_RDONLY);
		if (fd == -1) {
		sleepRetry++;
		ALOGE("CPE state open %s failed %s, Retrying %d",
		path, strerror(errno), sleepRetry);
		usleep(CPE_SLEEP_WAIT*1000);
		} else {
		ALOGD("cpe state opened: %s", path);
		mSndCardFd.push_back(std::make_pair(cpe_cnt++, fd));
		}
		}while ((fd == -1) && sleepRetry < MAX_CPE_SLEEP_RETRY);
		}
		ALOGD("number of sndcards %d CPEs %d", i, cpe_cnt - CPE_MAGIC_NUM);

		pfd = new pollfd[mSndCardFd.size() + mAudioEvents.size()];
		bzero(pfd, (sizeof(pfd) mSndCardFd.size() +
		sizeof(pfd) mAudioEvents.size()));
		for (i = 0; i < mSndCardFd.size(); i++) {
		pfd[i].fd = mSndCardFd[i].second;
		pfd[i].events = POLLPRI;
		}

		/insert all audio events/
		for(i = 0; i < mAudioEvents.size(); i++) {
		pfd[i+mSndCardFd.size()].fd = mAudioEvents[i].second;
		pfd[i+mSndCardFd.size()].events = POLLPRI;
		}

		ALOGD("read for sound card state change before while");
		for (i = 0; i < mSndCardFd.size(); i++) {
		if (!read(pfd[i].fd, (void *)rd_buf, 8)) {
		ALOGE("Error receiving sound card state event (%s)", strerror(errno));
		ret = false;
		} else {
		rd_buf[8] = '\0';
		lseek(pfd[i].fd, 0, SEEK_SET);

		if(mSndCardFd[i].first >= CPE_MAGIC_NUM) {
		ALOGD("CPE %d state file content: %s before while",
		mSndCardFd[i].first - CPE_MAGIC_NUM, rd_buf);
		if (strstr(rd_buf, "OFFLINE")) {
		ALOGD("CPE state offline");
		cur_cpe_state = cpe_offline;
		} else if (strstr(rd_buf, "ONLINE")){
		ALOGD("CPE state online");
		cur_cpe_state = cpe_online;
		} else {
		ALOGE("ERROR CPE rd_buf %s", rd_buf);
		}
		if (cur_cpe_state == cpe_online && !cpe_bootup_complete) {
		cpe_bootup_complete = true;
		ALOGD("CPE boot up completed before polling");
		}
		prev_cpe_state = cur_cpe_state;
		}
		else {
		ALOGD("sound card state file content: %s before while",rd_buf);
		if (strstr(rd_buf, "OFFLINE")) {
		ALOGE("put cur_state to offline");
		cur_state = snd_card_offline;
		} else if (strstr(rd_buf, "ONLINE")){
		ALOGE("put cur_state to online");
		cur_state = snd_card_online;
		} else {
		ALOGE("ERROR rd_buf %s", rd_buf);
		}

		ALOGD("cur_state=%d, bootup_complete=%d", cur_state, cur_state );
		if (cur_state == snd_card_online && !bootup_complete) {
		bootup_complete = 1;
		ALOGE("sound card up is deteced before while");
		ALOGE("bootup_complete set to 1");
		}
		}
		}
		}

		ALOGE("read for event state change before while");
		for (i = 0; i < mAudioEvents.size(); i++){
		checkEventState(pfd[i+mSndCardFd.size()].fd, i);
		}

		while (1) {
		ALOGD("poll() for sound card state change ");
		if (poll(pfd, (mSndCardFd.size() + mAudioEvents.size()), -1) < 0) {
		ALOGE("poll() failed (%s)", strerror(errno));
		ret = false;
		break;
		}

		ALOGD("out of poll() for sound card state change, SNDCARD size=%d", mSndCardFd.size());
		for (i = 0; i < mSndCardFd.size(); i++) {
		if (pfd[i].revents & POLLPRI) {
		if (!read(pfd[i].fd, (void *)rd_buf, 8)) {
		ALOGE("Error receiving sound card %d state event (%s)",
		mSndCardFd[i].first, strerror(errno));
		ret = false;
		} else {
		rd_buf[8] = '\0';
		lseek(pfd[i].fd, 0, SEEK_SET);

		if(mSndCardFd[i].first >= CPE_MAGIC_NUM) {
		if (strstr(rd_buf, "OFFLINE"))
		cur_cpe_state = cpe_offline;
		else if (strstr(rd_buf, "ONLINE"))
		cur_cpe_state = cpe_online;
		else
		ALOGE("ERROR CPE rd_buf %s", rd_buf);

		if (cpe_bootup_complete && (prev_cpe_state != cur_cpe_state)) {
		ALOGD("CPE state is %d, nofity AudioSystem", cur_cpe_state);
		notifyAudioSystem(mSndCardFd[i].first, cur_cpe_state, CPE_STATE);
		}
		if (!cpe_bootup_complete && (cur_cpe_state == cpe_online)) {
		cpe_bootup_complete = true;
		ALOGD("CPE boot up completed");
		}
		prev_cpe_state = cur_cpe_state;
		}
		else {
		ALOGV("sound card state file content: %s, bootup_complete=%d",rd_buf, bootup_complete);
		if (strstr(rd_buf, "OFFLINE")) {
		cur_state = snd_card_offline;
		} else if (strstr(rd_buf, "ONLINE")){
		cur_state = snd_card_online;
		}

		if (bootup_complete) {
		ALOGV("bootup_complete, so NofityAudioSystem");
		notifyAudioSystem(mSndCardFd[i].first, cur_state, SND_CARD_STATE);
		}

		if (cur_state == snd_card_online && !bootup_complete) {
		bootup_complete = 1;
		}
		}
		}
		}
		}
		for (i = 0; i < mAudioEvents.size(); i++) {
		if (pfd[i + mSndCardFd.size()].revents & POLLPRI) {
		ALOGE("EVENT recieved pfd[i].revents= 0x%x %d",
		pfd[i + mSndCardFd.size()].revents,
		mAudioEvents[i].second);

		checkEventState(pfd[i + mSndCardFd.size()].fd, i);
		}
		}
		}

		putStateFDs(mSndCardFd);
		putDeviceEventFDs();
		delete [] pfd;

		thread_exit:
		ALOGV("Exiting Poll ThreadLoop");
		return ret;
		}

		void AudioDaemon::notifyAudioSystem(int snd_card,
		notify_status status,
		notify_status_type type)
		{

		String8 str;
		char buf[4] = {0,};

		if (type == CPE_STATE) {
		str = "CPE_STATUS=";
		snprintf(buf, sizeof(buf), "%d", snd_card - CPE_MAGIC_NUM);
		str += buf;
		if (status == cpe_online)
		str += ",ONLINE";
		else
		str += ",OFFLINE";
		}
		else {
		str = "SND_CARD_STATUS=";
		snprintf(buf, sizeof(buf), "%d", snd_card);
		str += buf;
		if (status == snd_card_online)
		str += ",ONLINE";
		else
		str += ",OFFLINE";
		}
		ALOGV("%s: notifyAudioSystem : %s", __func__, str.string());
		AudioSystem::setParameters(0, str);
		}

		void AudioDaemon::notifyAudioSystemEventStatus(const char* event,
		audio_event_status status) {

		String8 str;
		str += AUDIO_PARAMETER_KEY_EXT_AUDIO_DEVICE;
		str += "=";
		str += event;

		if (status == audio_event_on)
		str += ",ON";
		else
		str += ",OFF";
		ALOGD("%s: notifyAudioSystemEventStatus : %s", __func__, str.string());
		AudioSystem::setParameters(0, str);
		}
		}

msm8909/audiod/AudioDaemon.h

deleted100644 → 0

+0 −92

Original line number	Diff line number	Diff line
		/* AudioDaemon.h

		Copyright (c) 2012-2014, 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.*/

		#include <stdio.h>
		#include <stdlib.h>
		#include <unistd.h>
		#include <string.h>
		#include <fcntl.h>
		#include <vector>

		#include <utils/threads.h>
		#include <utils/String8.h>


		namespace android {

		enum notify_status {
		snd_card_online,
		snd_card_offline,
		cpe_online,
		cpe_offline
		};

		enum notify_status_type {
		SND_CARD_STATE,
		CPE_STATE
		};

		enum audio_event_status {audio_event_on, audio_event_off};

		#define AUDIO_PARAMETER_KEY_EXT_AUDIO_DEVICE "ext_audio_device"

		class AudioDaemon:public Thread, public IBinder :: DeathRecipient
		{
		/Overrides/
		virtual bool threadLoop();
		virtual status_t readyToRun();
		virtual void onFirstRef();
		virtual void binderDied(const wp < IBinder > &who);

		bool processUeventMessage();
		void notifyAudioSystem(int snd_card,
		notify_status status,
		notify_status_type type);
		void notifyAudioSystemEventStatus(const char* event, audio_event_status status);
		int mUeventSock;
		bool getStateFDs(std::vector<std::pair<int,int> > &sndcardFdPair);
		void putStateFDs(std::vector<std::pair<int,int> > &sndcardFdPair);
		bool getDeviceEventFDs();
		void putDeviceEventFDs();
		void checkEventState(int fd, int index);

		public:
		AudioDaemon();
		virtual ~AudioDaemon();

		private:
		std::vector<std::pair<int,int> > mSndCardFd;

		//file descriptors for audio device events and their statuses
		std::vector<std::pair<String8, int> > mAudioEvents;
		std::vector<std::pair<String8, int> > mAudioEventsStatus;

		};

		}

msm8909/audiod/audiod_main.cpp

deleted100644 → 0

+0 −60

Original line number	Diff line number	Diff line
		/* Copyright (C) 2007 The Android Open Source Project

		Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.

		Not a Contribution, Apache license notifications and license are retained
		for attribution purposes only.

		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#define LOG_TAG "AudioDaemonMain"
		#define LOG_NDEBUG 0
		#define LOG_NDDEBUG 0

		#include <cutils/properties.h>

		#include <binder/IPCThreadState.h>
		#include <binder/ProcessState.h>
		#include <binder/IServiceManager.h>

		#include <utils/Log.h>
		#include <utils/threads.h>

		#if defined(HAVE_PTHREADS)
		# include <pthread.h>
		# include <sys/resource.h>
		#endif

		#include "AudioDaemon.h"

		using namespace android;

		// ---------------------------------------------------------------------------

		int main(int argc, char** argv)
		{
		#if defined(HAVE_PTHREADS)
		setpriority(PRIO_PROCESS, 0, ANDROID_PRIORITY_AUDIO);
		#endif


		ALOGV("Audio daemon starting sequence..");
		sp<ProcessState> proc(ProcessState::self());
		ProcessState::self()->startThreadPool();

		sp<AudioDaemon> audioService = new AudioDaemon();
		IPCThreadState::self()->joinThreadPool();

		return 0;
		}