From 6c796b0257e8e9cf37d784d33fe101a9b6f5c89b Mon Sep 17 00:00:00 2001 From: sbrissen Date: Tue, 16 Jul 2013 16:11:37 -0400 Subject: n5110: initial commit --- Android.mk | 23 + AndroidProducts.mk | 18 + BoardConfig.mk | 44 + README | 10 + audio/Android.mk | 33 + audio/audio_hw.c | 3027 ++++++++++++++++++++ audio/audio_hw.h | 239 ++ audio/ril_interface.c | 183 ++ audio/ril_interface.h | 72 + bluetooth/bdroid_buildcfg.h | 23 + bluetooth/vnd_n5110.txt | 14 + cm.dependencies | 18 + cm.mk | 21 + configs/Android.mk | 12 + configs/audio_policy.conf | 82 + configs/gps.xml | 72 + configs/nvram_mfg.txt | 146 + configs/nvram_mfg.txt_murata | 145 + configs/nvram_net.txt | 152 + configs/nvram_net.txt_murata | 156 + configs/tiny_hw.xml | 316 ++ extract-files.sh | 105 + full_n5110.mk | 35 + n5110.mk | 70 + .../DeviceSettings/res/values/config.xml | 28 + .../frameworks/base/core/res/res/values/config.xml | 92 + .../base/core/res/res/xml/power_profile.xml | 61 + .../base/core/res/res/xml/storage_list.xml | 51 + overlay/packages/apps/Browser/res/values/bools.xml | 16 + overlay/packages/apps/Camera/res/values/config.xml | 23 + .../packages/apps/Launcher2/res/values/config.xml | 18 + .../packages/apps/Settings/res/values/arrays.xml | 46 + .../packages/apps/Settings/res/values/bools.xml | 23 + .../packages/apps/Settings/res/values/config.xml | 20 + overlay/packages/apps/Torch/res/values/config.xml | 36 + proprietary-files.txt | 3 + recovery.fstab | 12 + res/charger/battery_0.png | Bin 0 -> 5515 bytes res/charger/battery_1.png | Bin 0 -> 5549 bytes res/charger/battery_2.png | Bin 0 -> 5548 bytes res/charger/battery_3.png | Bin 0 -> 5548 bytes res/charger/battery_4.png | Bin 0 -> 5548 bytes res/charger/battery_5.png | Bin 0 -> 5522 bytes res/charger/battery_charge.png | Bin 0 -> 7126 bytes res/charger/battery_fail.png | Bin 0 -> 7051 bytes rootdir/fstab.smdk4x12 | 11 + rootdir/init.smdk4x12.rc | 584 ++++ rootdir/init.smdk4x12.usb.rc | 134 + rootdir/lpm.rc | 80 + rootdir/ueventd.smdk4x12.rc | 83 + system.prop | 12 + 51 files changed, 6349 insertions(+) create mode 100644 Android.mk create mode 100644 AndroidProducts.mk create mode 100644 BoardConfig.mk create mode 100644 README create mode 100644 audio/Android.mk create mode 100755 audio/audio_hw.c create mode 100644 audio/audio_hw.h create mode 100755 audio/ril_interface.c create mode 100755 audio/ril_interface.h create mode 100755 bluetooth/bdroid_buildcfg.h create mode 100755 bluetooth/vnd_n5110.txt create mode 100644 cm.dependencies create mode 100644 cm.mk create mode 100644 configs/Android.mk create mode 100644 configs/audio_policy.conf create mode 100644 configs/gps.xml create mode 100644 configs/nvram_mfg.txt create mode 100644 configs/nvram_mfg.txt_murata create mode 100644 configs/nvram_net.txt create mode 100644 configs/nvram_net.txt_murata create mode 100644 configs/tiny_hw.xml create mode 100755 extract-files.sh create mode 100644 full_n5110.mk create mode 100644 n5110.mk create mode 100644 overlay/device/samsung/smdk4412-common/DeviceSettings/res/values/config.xml create mode 100644 overlay/frameworks/base/core/res/res/values/config.xml create mode 100644 overlay/frameworks/base/core/res/res/xml/power_profile.xml create mode 100644 overlay/frameworks/base/core/res/res/xml/storage_list.xml create mode 100644 overlay/packages/apps/Browser/res/values/bools.xml create mode 100644 overlay/packages/apps/Camera/res/values/config.xml create mode 100644 overlay/packages/apps/Launcher2/res/values/config.xml create mode 100644 overlay/packages/apps/Settings/res/values/arrays.xml create mode 100644 overlay/packages/apps/Settings/res/values/bools.xml create mode 100644 overlay/packages/apps/Settings/res/values/config.xml create mode 100644 overlay/packages/apps/Torch/res/values/config.xml create mode 100644 proprietary-files.txt create mode 100644 recovery.fstab create mode 100644 res/charger/battery_0.png create mode 100644 res/charger/battery_1.png create mode 100644 res/charger/battery_2.png create mode 100644 res/charger/battery_3.png create mode 100644 res/charger/battery_4.png create mode 100644 res/charger/battery_5.png create mode 100644 res/charger/battery_charge.png create mode 100644 res/charger/battery_fail.png create mode 100644 rootdir/fstab.smdk4x12 create mode 100644 rootdir/init.smdk4x12.rc create mode 100755 rootdir/init.smdk4x12.usb.rc create mode 100644 rootdir/lpm.rc create mode 100644 rootdir/ueventd.smdk4x12.rc create mode 100755 system.prop diff --git a/Android.mk b/Android.mk new file mode 100644 index 0000000..23ce42c --- /dev/null +++ b/Android.mk @@ -0,0 +1,23 @@ +# +# Copyright (C) 2012 The CyanogenMod Project +# +# 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. +# + +LOCAL_PATH := $(call my-dir) + +ifeq ($(TARGET_DEVICE),n5110) + +include $(call all-makefiles-under,$(LOCAL_PATH)) + +endif diff --git a/AndroidProducts.mk b/AndroidProducts.mk new file mode 100644 index 0000000..7143952 --- /dev/null +++ b/AndroidProducts.mk @@ -0,0 +1,18 @@ +# +# Copyright (C) 2012 The CyanogenMod Project +# +# 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. +# + +PRODUCT_MAKEFILES := \ + $(LOCAL_DIR)/full_n5110.mk diff --git a/BoardConfig.mk b/BoardConfig.mk new file mode 100644 index 0000000..75a3671 --- /dev/null +++ b/BoardConfig.mk @@ -0,0 +1,44 @@ +# +# Copyright (C) 2012 The CyanogenMod Project +# +# 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. +# + +# This variable is set first, so it can be overridden +# by BoardConfigVendor.mk +-include device/samsung/smdk4412-common/BoardCommonConfig.mk + +LOCAL_PATH := device/samsung/n5110 + +# Bluetooth +BOARD_BLUETOOTH_BDROID_BUILDCFG_INCLUDE_DIR := $(LOCAL_PATH)/bluetooth +BOARD_BLUEDROID_VENDOR_CONF := $(LOCAL_PATH)/bluetooth/vnd_n5110.txt + +# Inline kernel building +TARGET_KERNEL_SOURCE := kernel/samsung/smdk4412 +TARGET_KERNEL_CONFIG := cyanogenmod_n5110_defconfig + +# Camera +COMMON_GLOBAL_CFLAGS += -DCAMERA_WITH_CITYID_PARAM + +# Charging mode +BOARD_CHARGING_MODE_BOOTING_LPM := /sys/class/power_supply/battery/batt_lp_charging +BOARD_BATTERY_DEVICE_NAME := "battery" +BOARD_CHARGER_RES := device/samsung/n5110/res/charger + +# Recovery +# inherit from the proprietary version +-include vendor/samsung/n5110/BoardConfigVendor.mk + +# assert +TARGET_OTA_ASSERT_DEVICE := konawifixx,n5110,GT-N5110,konawifi diff --git a/README b/README new file mode 100644 index 0000000..0a398a0 --- /dev/null +++ b/README @@ -0,0 +1,10 @@ +Device configuration for the Samsung Galaxy Note 8.0 WiFi +GT-N5110 + +Copyright (C) 2013 The CyanogenMod Project + + 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 diff --git a/audio/Android.mk b/audio/Android.mk new file mode 100644 index 0000000..4655db0 --- /dev/null +++ b/audio/Android.mk @@ -0,0 +1,33 @@ +# Copyright (C) 2011 The Android Open Source Project +# +# 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. + +LOCAL_PATH := $(call my-dir) + +include $(CLEAR_VARS) + +LOCAL_MODULE := audio.primary.$(TARGET_BOOTLOADER_BOARD_NAME) +LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw +LOCAL_MODULE_TAGS := optional + +LOCAL_SRC_FILES := audio_hw.c ril_interface.c + +LOCAL_C_INCLUDES += \ + external/tinyalsa/include \ + external/expat/lib \ + $(call include-path-for, audio-utils) \ + $(call include-path-for, audio-effects) + +LOCAL_SHARED_LIBRARIES := liblog libcutils libtinyalsa libaudioutils libdl libexpat + +include $(BUILD_SHARED_LIBRARY) diff --git a/audio/audio_hw.c b/audio/audio_hw.c new file mode 100755 index 0000000..e4f5edf --- /dev/null +++ b/audio/audio_hw.c @@ -0,0 +1,3027 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * Copyright (C) 2012 Wolfson Microelectronics plc + * Copyright (C) 2012 The CyanogenMod Project + * Daniel Hillenbrand + * Guillaume "XpLoDWilD" Lesniak + * + * 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 "audio_hw_primary" +#define LOG_NDEBUG 0 + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "audio_hw.h" +#include "ril_interface.h" + +struct pcm_config pcm_config_mm = { + .channels = 2, + .rate = MM_FULL_POWER_SAMPLING_RATE, + .period_size = DEEP_BUFFER_LONG_PERIOD_SIZE, + .period_count = PLAYBACK_DEEP_BUFFER_LONG_PERIOD_COUNT, + .format = PCM_FORMAT_S16_LE, +}; + +struct pcm_config pcm_config_tones = { + .channels = 2, + .rate = MM_FULL_POWER_SAMPLING_RATE, + .period_size = SHORT_PERIOD_SIZE, + .period_count = PLAYBACK_SHORT_PERIOD_COUNT, + .format = PCM_FORMAT_S16_LE, + .start_threshold = 0, + .avail_min = 0, +}; + +struct pcm_config pcm_config_capture = { + .channels = 2, + .rate = DEFAULT_IN_SAMPLING_RATE, + .period_size = CAPTURE_PERIOD_SIZE, + .period_count = CAPTURE_PERIOD_COUNT, + .format = PCM_FORMAT_S16_LE, +}; + +struct pcm_config pcm_config_vx = { + .channels = 2, + .rate = VX_NB_SAMPLING_RATE, + .period_size = 160, + .period_count = 2, + .format = PCM_FORMAT_S16_LE, +}; + +#define MIN(x, y) ((x) > (y) ? (y) : (x)) + +struct m0_audio_device { + struct audio_hw_device hw_device; + + pthread_mutex_t lock; /* see note below on mutex acquisition order */ + struct m0_dev_cfg *dev_cfgs; + int num_dev_cfgs; + struct mixer *mixer; + struct mixer_ctls mixer_ctls; + audio_mode_t mode; + int active_out_device; + int out_device; + int active_in_device; + int in_device; + struct pcm *pcm_modem_dl; + struct pcm *pcm_modem_ul; + int in_call; + float voice_volume; + struct m0_stream_in *active_input; + struct m0_stream_out *outputs[OUTPUT_TOTAL]; + bool mic_mute; + int tty_mode; + struct echo_reference_itfe *echo_reference; + bool bluetooth_nrec; + int wb_amr; + bool screen_off; + + /* RIL */ + struct ril_handle ril; +}; + +struct m0_stream_out { + struct audio_stream_out stream; + + pthread_mutex_t lock; /* see note below on mutex acquisition order */ + struct pcm_config config[PCM_TOTAL]; + struct pcm *pcm[PCM_TOTAL]; + struct resampler_itfe *resampler; + char *buffer; + size_t buffer_frames; + int standby; + struct echo_reference_itfe *echo_reference; + int write_threshold; + bool use_long_periods; + audio_channel_mask_t channel_mask; + audio_channel_mask_t sup_channel_masks[3]; + + struct m0_audio_device *dev; +}; + +#define MAX_PREPROCESSORS 3 /* maximum one AGC + one NS + one AEC per input stream */ + +struct effect_info_s { + effect_handle_t effect_itfe; + size_t num_channel_configs; + channel_config_t* channel_configs; +}; + +#define NUM_IN_AUX_CNL_CONFIGS 2 +channel_config_t in_aux_cnl_configs[NUM_IN_AUX_CNL_CONFIGS] = { + { AUDIO_CHANNEL_IN_FRONT , AUDIO_CHANNEL_IN_BACK}, + { AUDIO_CHANNEL_IN_STEREO , AUDIO_CHANNEL_IN_RIGHT} +}; + +struct m0_stream_in { + struct audio_stream_in stream; + + pthread_mutex_t lock; /* see note below on mutex acquisition order */ + struct pcm_config config; + struct pcm *pcm; + int device; + struct resampler_itfe *resampler; + struct resampler_buffer_provider buf_provider; + unsigned int requested_rate; + int standby; + int source; + struct echo_reference_itfe *echo_reference; + bool need_echo_reference; + + int16_t *read_buf; + size_t read_buf_size; + size_t read_buf_frames; + + int16_t *proc_buf_in; + int16_t *proc_buf_out; + size_t proc_buf_size; + size_t proc_buf_frames; + + int16_t *ref_buf; + size_t ref_buf_size; + size_t ref_buf_frames; + + int read_status; + + int num_preprocessors; + struct effect_info_s preprocessors[MAX_PREPROCESSORS]; + + bool aux_channels_changed; + uint32_t main_channels; + uint32_t aux_channels; + struct m0_audio_device *dev; +}; + +struct m0_dev_cfg { + int mask; + + struct route_setting *on; + unsigned int on_len; + + struct route_setting *off; + unsigned int off_len; +}; + +/** + * NOTE: when multiple mutexes have to be acquired, always respect the following order: + * hw device > in stream > out stream + */ + +static void select_output_device(struct m0_audio_device *adev); +static void select_input_device(struct m0_audio_device *adev); +static int adev_set_voice_volume(struct audio_hw_device *dev, float volume); +static int do_input_standby(struct m0_stream_in *in); +static int do_output_standby(struct m0_stream_out *out); +static void in_update_aux_channels(struct m0_stream_in *in, effect_handle_t effect); + +/* The enable flag when 0 makes the assumption that enums are disabled by + * "Off" and integers/booleans by 0 */ +static int set_bigroute_by_array(struct mixer *mixer, struct route_setting *route, + int enable) +{ + struct mixer_ctl *ctl; + unsigned int i, j, ret; + + /* Go through the route array and set each value */ + i = 0; + while (route[i].ctl_name) { + ctl = mixer_get_ctl_by_name(mixer, route[i].ctl_name); + if (!ctl) { + ALOGE("Unknown control '%s'\n", route[i].ctl_name); + return -EINVAL; + } + + if (route[i].strval) { + if (enable) { + ret = mixer_ctl_set_enum_by_string(ctl, route[i].strval); + if (ret != 0) { + ALOGE("Failed to set '%s' to '%s'\n", route[i].ctl_name, route[i].strval); + } else { + ALOGV("Set '%s' to '%s'\n", route[i].ctl_name, route[i].strval); + } + } else { + ret = mixer_ctl_set_enum_by_string(ctl, "Off"); + if (ret != 0) { + ALOGE("Failed to set '%s' to '%s'\n", route[i].ctl_name, route[i].strval); + } else { + ALOGV("Set '%s' to '%s'\n", route[i].ctl_name, "Off"); + } + } + } else { + /* This ensures multiple (i.e. stereo) values are set jointly */ + for (j = 0; j < mixer_ctl_get_num_values(ctl); j++) { + if (enable) { + ret = mixer_ctl_set_value(ctl, j, route[i].intval); + if (ret != 0) { + ALOGE("Failed to set '%s' to '%d'\n", route[i].ctl_name, route[i].intval); + } else { + ALOGV("Set '%s' to '%d'\n", route[i].ctl_name, route[i].intval); + } + } else { + ret = mixer_ctl_set_value(ctl, j, 0); + if (ret != 0) { + ALOGE("Failed to set '%s' to '%d'\n", route[i].ctl_name, route[i].intval); + } else { + ALOGV("Set '%s' to '%d'\n", route[i].ctl_name, 0); + } + } + } + } + i++; + } + + return 0; +} + +/* The enable flag when 0 makes the assumption that enums are disabled by + * "Off" and integers/booleans by 0 */ +static int set_route_by_array(struct mixer *mixer, struct route_setting *route, + unsigned int len) +{ + struct mixer_ctl *ctl; + unsigned int i, j, ret; + + /* Go through the route array and set each value */ + for (i = 0; i < len; i++) { + ctl = mixer_get_ctl_by_name(mixer, route[i].ctl_name); + if (!ctl) { + ALOGE("Unknown control '%s'\n", route[i].ctl_name); + return -EINVAL; + } + + if (route[i].strval) { + ret = mixer_ctl_set_enum_by_string(ctl, route[i].strval); + if (ret != 0) { + ALOGE("Failed to set '%s' to '%s'\n", + route[i].ctl_name, route[i].strval); + } else { + ALOGV("Set '%s' to '%s'\n", + route[i].ctl_name, route[i].strval); + } + + } else { + /* This ensures multiple (i.e. stereo) values are set jointly */ + for (j = 0; j < mixer_ctl_get_num_values(ctl); j++) { + ret = mixer_ctl_set_value(ctl, j, route[i].intval); + if (ret != 0) { + ALOGE("Failed to set '%s'.%d to %d\n", + route[i].ctl_name, j, route[i].intval); + } else { + ALOGV("Set '%s'.%d to %d\n", + route[i].ctl_name, j, route[i].intval); + } + } + } + } + + return 0; +} + +/* Must be called with lock */ +void select_devices(struct m0_audio_device *adev) +{ + int i; + + if (adev->active_out_device == adev->out_device && adev->active_in_device == adev->in_device) + return; + + ALOGV("Changing output device %x => %x\n", adev->active_out_device, adev->out_device); + ALOGV("Changing input device %x => %x\n", adev->active_in_device, adev->in_device); + + /* Turn on new devices first so we don't glitch due to powerdown... */ + for (i = 0; i < adev->num_dev_cfgs; i++) + if ((adev->out_device & adev->dev_cfgs[i].mask) && + !(adev->active_out_device & adev->dev_cfgs[i].mask)) + set_route_by_array(adev->mixer, adev->dev_cfgs[i].on, + adev->dev_cfgs[i].on_len); + + for (i = 0; i < adev->num_dev_cfgs; i++) + if ((adev->in_device & adev->dev_cfgs[i].mask) && + !(adev->active_in_device & adev->dev_cfgs[i].mask)) + set_route_by_array(adev->mixer, adev->dev_cfgs[i].on, + adev->dev_cfgs[i].on_len); + + /* ...then disable old ones. */ + for (i = 0; i < adev->num_dev_cfgs; i++) + if (!(adev->out_device & adev->dev_cfgs[i].mask) && + (adev->active_out_device & adev->dev_cfgs[i].mask)) + set_route_by_array(adev->mixer, adev->dev_cfgs[i].off, + adev->dev_cfgs[i].off_len); + + for (i = 0; i < adev->num_dev_cfgs; i++) + if (!(adev->in_device & adev->dev_cfgs[i].mask) && + (adev->active_in_device & adev->dev_cfgs[i].mask)) + set_route_by_array(adev->mixer, adev->dev_cfgs[i].off, + adev->dev_cfgs[i].off_len); + + adev->active_out_device = adev->out_device; + adev->active_in_device = adev->in_device; +} + +static int start_call(struct m0_audio_device *adev) +{ + ALOGE("Opening modem PCMs"); + int bt_on; + + bt_on = adev->out_device & AUDIO_DEVICE_OUT_ALL_SCO; + pcm_config_vx.rate = adev->wb_amr ? VX_WB_SAMPLING_RATE : VX_NB_SAMPLING_RATE; + + /* Open modem PCM channels */ + if (adev->pcm_modem_dl == NULL) { + if (bt_on) + adev->pcm_modem_dl = pcm_open(CARD_DEFAULT, PORT_BT, PCM_OUT, &pcm_config_vx); + else + adev->pcm_modem_dl = pcm_open(CARD_DEFAULT, PORT_MODEM, PCM_OUT, &pcm_config_vx); + if (!pcm_is_ready(adev->pcm_modem_dl)) { + ALOGE("cannot open PCM modem DL stream: %s", pcm_get_error(adev->pcm_modem_dl)); + goto err_open_dl; + } + } + + if (adev->pcm_modem_ul == NULL) { + adev->pcm_modem_ul = pcm_open(CARD_DEFAULT, PORT_MODEM, PCM_IN, &pcm_config_vx); + if (!pcm_is_ready(adev->pcm_modem_ul)) { + ALOGE("cannot open PCM modem UL stream: %s", pcm_get_error(adev->pcm_modem_ul)); + goto err_open_ul; + } + } + + pcm_start(adev->pcm_modem_dl); + pcm_start(adev->pcm_modem_ul); + + return 0; + +err_open_ul: + pcm_close(adev->pcm_modem_ul); + adev->pcm_modem_ul = NULL; +err_open_dl: + pcm_close(adev->pcm_modem_dl); + adev->pcm_modem_dl = NULL; + + return -ENOMEM; +} + +static void end_call(struct m0_audio_device *adev) +{ + ALOGE("Closing modem PCMs"); + pcm_stop(adev->pcm_modem_dl); + pcm_stop(adev->pcm_modem_ul); + pcm_close(adev->pcm_modem_dl); + pcm_close(adev->pcm_modem_ul); + adev->pcm_modem_dl = NULL; + adev->pcm_modem_ul = NULL; + + /* re-enable +30db boost on mics */ + mixer_ctl_set_value(adev->mixer_ctls.mixinl_in1l_volume, 0, 1); + mixer_ctl_set_value(adev->mixer_ctls.mixinl_in2l_volume, 0, 1); +} + +static void set_eq_filter(struct m0_audio_device *adev) +{ +} + +void audio_set_wb_amr_callback(void *data, int enable) +{ + struct m0_audio_device *adev = (struct m0_audio_device *)data; + + pthread_mutex_lock(&adev->lock); + if (adev->wb_amr != enable) { + adev->wb_amr = enable; + + /* reopen the modem PCMs at the new rate */ + if (adev->in_call) { + end_call(adev); + select_output_device(adev); + start_call(adev); + } + } + pthread_mutex_unlock(&adev->lock); +} + +static void set_incall_device(struct m0_audio_device *adev) +{ + int device_type; + + switch(adev->out_device) { + case AUDIO_DEVICE_OUT_EARPIECE: + device_type = SOUND_AUDIO_PATH_HANDSET; + break; + case AUDIO_DEVICE_OUT_SPEAKER: + case AUDIO_DEVICE_OUT_AUX_DIGITAL: + case AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET: + device_type = SOUND_AUDIO_PATH_SPEAKER; + break; + case AUDIO_DEVICE_OUT_WIRED_HEADSET: + device_type = SOUND_AUDIO_PATH_HEADSET; + break; + case AUDIO_DEVICE_OUT_WIRED_HEADPHONE: + device_type = SOUND_AUDIO_PATH_HEADPHONE; + break; + case AUDIO_DEVICE_OUT_BLUETOOTH_SCO: + case AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET: + case AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT: + if (adev->bluetooth_nrec) { + device_type = SOUND_AUDIO_PATH_BLUETOOTH; + } else { + device_type = SOUND_AUDIO_PATH_BLUETOOTH_NO_NR; + } + break; + default: + device_type = SOUND_AUDIO_PATH_HANDSET; + break; + } + + /* if output device isn't supported, open modem side to handset by default */ + ALOGE("%s: ril_set_call_audio_path(%d)", __func__, device_type); + ril_set_call_audio_path(&adev->ril, device_type); +} + +static void set_input_volumes(struct m0_audio_device *adev, int main_mic_on, + int headset_mic_on, int sub_mic_on) +{ +} + +static void set_output_volumes(struct m0_audio_device *adev, bool tty_volume) +{ +} + +static void force_all_standby(struct m0_audio_device *adev) +{ + struct m0_stream_in *in; + struct m0_stream_out *out; + + /* only needed for low latency output streams as other streams are not used + * for voice use cases */ + if (adev->outputs[OUTPUT_LOW_LATENCY] != NULL && + !adev->outputs[OUTPUT_LOW_LATENCY]->standby) { + out = adev->outputs[OUTPUT_LOW_LATENCY]; + pthread_mutex_lock(&out->lock); + do_output_standby(out); + pthread_mutex_unlock(&out->lock); + } + + if (adev->active_input) { + in = adev->active_input; + pthread_mutex_lock(&in->lock); + do_input_standby(in); + pthread_mutex_unlock(&in->lock); + } +} + +static void select_mode(struct m0_audio_device *adev) +{ + if (adev->mode == AUDIO_MODE_IN_CALL) { + ALOGE("Entering IN_CALL state, in_call=%d", adev->in_call); + if (!adev->in_call) { + force_all_standby(adev); + /* force earpiece route for in call state if speaker is the + only currently selected route. This prevents having to tear + down the modem PCMs to change route from speaker to earpiece + after the ringtone is played, but doesn't cause a route + change if a headset or bt device is already connected. If + speaker is not the only thing active, just remove it from + the route. We'll assume it'll never be used initally during + a call. This works because we're sure that the audio policy + manager will update the output device after the audio mode + change, even if the device selection did not change. */ + if (adev->out_device == AUDIO_DEVICE_OUT_SPEAKER) { + adev->out_device = AUDIO_DEVICE_OUT_EARPIECE; + adev->in_device = AUDIO_DEVICE_IN_BUILTIN_MIC & ~AUDIO_DEVICE_BIT_IN; + } else + adev->out_device &= ~AUDIO_DEVICE_OUT_SPEAKER; + select_output_device(adev); + start_call(adev); + ril_set_call_clock_sync(&adev->ril, SOUND_CLOCK_START); + adev_set_voice_volume(&adev->hw_device, adev->voice_volume); + adev->in_call = 1; + } + } else { + ALOGE("Leaving IN_CALL state, in_call=%d, mode=%d", + adev->in_call, adev->mode); + if (adev->in_call) { + adev->in_call = 0; + end_call(adev); + force_all_standby(adev); + select_output_device(adev); + select_input_device(adev); + } + } +} + +static void select_output_device(struct m0_audio_device *adev) +{ + int headset_on; + int headphone_on; + int speaker_on; + int earpiece_on; + int bt_on; + bool tty_volume = false; + unsigned int channel; + + headset_on = adev->out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET; + headphone_on = adev->out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE; + speaker_on = adev->out_device & AUDIO_DEVICE_OUT_SPEAKER; + earpiece_on = adev->out_device & AUDIO_DEVICE_OUT_EARPIECE; + bt_on = adev->out_device & AUDIO_DEVICE_OUT_ALL_SCO; + + switch(adev->out_device) { + case AUDIO_DEVICE_OUT_SPEAKER: + ALOGD("%s: AUDIO_DEVICE_OUT_SPEAKER", __func__); + break; + case AUDIO_DEVICE_OUT_WIRED_HEADSET: + ALOGD("%s: AUDIO_DEVICE_OUT_WIRED_HEADSET", __func__); + break; + case AUDIO_DEVICE_OUT_WIRED_HEADPHONE: + ALOGD("%s: AUDIO_DEVICE_OUT_WIRED_HEADPHONE", __func__); + break; + case AUDIO_DEVICE_OUT_EARPIECE: + ALOGD("%s: AUDIO_DEVICE_OUT_EARPIECE", __func__); + break; + case AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET: + ALOGD("%s: AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET", __func__); + break; + case AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET: + ALOGD("%s: AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET", __func__); + break; + case AUDIO_DEVICE_OUT_ALL_SCO: + ALOGD("%s: AUDIO_DEVICE_OUT_ALL_SCO", __func__); + break; + default: + ALOGD("%s: AUDIO_DEVICE_OUT_ALL", __func__); + break; + } + + select_devices(adev); + + set_eq_filter(adev); + + if (adev->mode == AUDIO_MODE_IN_CALL) { + if (!bt_on) { + /* force tx path according to TTY mode when in call */ + switch(adev->tty_mode) { + case TTY_MODE_FULL: + case TTY_MODE_HCO: + /* tx path from headset mic */ + headphone_on = 0; + headset_on = 1; + speaker_on = 0; + earpiece_on = 0; + break; + case TTY_MODE_VCO: + /* tx path from device sub mic */ + headphone_on = 0; + headset_on = 0; + speaker_on = 1; + earpiece_on = 0; + break; + case TTY_MODE_OFF: + default: + break; + } + } + + if (headset_on || headphone_on || speaker_on || earpiece_on) { + ALOGD("%s: set voicecall route: voicecall_default", __func__); + set_bigroute_by_array(adev->mixer, voicecall_default, 1); + } else { + ALOGD("%s: set voicecall route: voicecall_default_disable", __func__); + set_bigroute_by_array(adev->mixer, voicecall_default_disable, 1); + } + + if (speaker_on || earpiece_on || headphone_on) { + ALOGD("%s: set voicecall route: default_input", __func__); + set_bigroute_by_array(adev->mixer, default_input, 1); + } else { + ALOGD("%s: set voicecall route: default_input_disable", __func__); + set_bigroute_by_array(adev->mixer, default_input_disable, 1); + } + + if (headset_on) { + ALOGD("%s: set voicecall route: headset_input", __func__); + set_bigroute_by_array(adev->mixer, headset_input, 1); + } else { + ALOGD("%s: set voicecall route: headset_input_disable", __func__); + set_bigroute_by_array(adev->mixer, headset_input_disable, 1); + } + + if (bt_on) { + // bt uses a different port (PORT_BT) for playback, reopen the pcms + end_call(adev); + start_call(adev); + ALOGD("%s: set voicecall route: bt_input", __func__); + set_bigroute_by_array(adev->mixer, bt_input, 1); + ALOGD("%s: set voicecall route: bt_output", __func__); + set_bigroute_by_array(adev->mixer, bt_output, 1); + } else { + ALOGD("%s: set voicecall route: bt_disable", __func__); + set_bigroute_by_array(adev->mixer, bt_disable, 1); + } + + set_incall_device(adev); + } +} + +static void select_input_device(struct m0_audio_device *adev) +{ + switch(adev->in_device) { + case AUDIO_DEVICE_IN_BUILTIN_MIC: + ALOGD("%s: AUDIO_DEVICE_IN_BUILTIN_MIC", __func__); + break; + case AUDIO_DEVICE_IN_BACK_MIC: + ALOGD("%s: AUDIO_DEVICE_IN_BACK_MIC", __func__); + break; + case AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET: + ALOGD("%s: AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET", __func__); + break; + case AUDIO_DEVICE_IN_WIRED_HEADSET: + ALOGD("%s: AUDIO_DEVICE_IN_WIRED_HEADSET", __func__); + break; + default: + break; + } + + select_devices(adev); +} + +/* must be called with hw device and output stream mutexes locked */ +static int start_output_stream_low_latency(struct m0_stream_out *out) +{ + struct m0_audio_device *adev = out->dev; + unsigned int flags = PCM_OUT; + int i; + bool success = true; + + if (adev->mode != AUDIO_MODE_IN_CALL) { + select_output_device(adev); + } + + /* default to low power: will be corrected in out_write if necessary before first write to + * tinyalsa. + */ + + if (adev->out_device & ~(AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET | AUDIO_DEVICE_OUT_AUX_DIGITAL)) { + /* Something not a dock in use */ + out->config[PCM_NORMAL] = pcm_config_tones; + out->config[PCM_NORMAL].rate = MM_FULL_POWER_SAMPLING_RATE; + out->pcm[PCM_NORMAL] = pcm_open(CARD_DEFAULT, PORT_PLAYBACK, + flags, &out->config[PCM_NORMAL]); + } + + if (adev->out_device & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) { + /* SPDIF output in use */ + out->config[PCM_SPDIF] = pcm_config_tones; + out->config[PCM_SPDIF].rate = MM_FULL_POWER_SAMPLING_RATE; + out->pcm[PCM_SPDIF] = pcm_open(CARD_DEFAULT, PORT_PLAYBACK, + flags, &out->config[PCM_SPDIF]); + } + + /* Close any PCMs that could not be opened properly and return an error */ + for (i = 0; i < PCM_TOTAL; i++) { + if (out->pcm[i] && !pcm_is_ready(out->pcm[i])) { + ALOGE("%s: cannot open pcm_out driver %d: %s", __func__ , i, pcm_get_error(out->pcm[i])); + pcm_close(out->pcm[i]); + out->pcm[i] = NULL; + success = false; + } + } + + if (success) { + out->buffer_frames = pcm_config_tones.period_size * 2; + if (out->buffer == NULL) + out->buffer = malloc(out->buffer_frames * audio_stream_frame_size(&out->stream.common)); + + if (adev->echo_reference != NULL) + out->echo_reference = adev->echo_reference; + out->resampler->reset(out->resampler); + + return 0; + } + + return -ENOMEM; +} + +/* must be called with hw device and output stream mutexes locked */ +static int start_output_stream_deep_buffer(struct m0_stream_out *out) +{ + struct m0_audio_device *adev = out->dev; + + if (adev->mode != AUDIO_MODE_IN_CALL) { + select_output_device(adev); + } + + out->write_threshold = PLAYBACK_DEEP_BUFFER_LONG_PERIOD_COUNT * DEEP_BUFFER_LONG_PERIOD_SIZE; + out->use_long_periods = true; + + out->config[PCM_NORMAL] = pcm_config_mm; + out->config[PCM_NORMAL].rate = MM_FULL_POWER_SAMPLING_RATE; + out->pcm[PCM_NORMAL] = pcm_open(CARD_DEFAULT, PORT_PLAYBACK, + PCM_OUT | PCM_MMAP | PCM_NOIRQ, &out->config[PCM_NORMAL]); + if (out->pcm[PCM_NORMAL] && !pcm_is_ready(out->pcm[PCM_NORMAL])) { + ALOGE("%s: cannot open pcm_out driver: %s", __func__, pcm_get_error(out->pcm[PCM_NORMAL])); + pcm_close(out->pcm[PCM_NORMAL]); + out->pcm[PCM_NORMAL] = NULL; + return -ENOMEM; + } + out->buffer_frames = DEEP_BUFFER_SHORT_PERIOD_SIZE * 2; + if (out->buffer == NULL) + out->buffer = malloc(PLAYBACK_DEEP_BUFFER_LONG_PERIOD_COUNT * DEEP_BUFFER_LONG_PERIOD_SIZE); + + return 0; +} + +static int check_input_parameters(uint32_t sample_rate, audio_format_t format, int channel_count) +{ + if (format != AUDIO_FORMAT_PCM_16_BIT) + return -EINVAL; + + if ((channel_count < 1) || (channel_count > 2)) + return -EINVAL; + + switch(sample_rate) { + case 8000: + case 11025: + case 16000: + case 22050: + case 24000: + case 32000: + case 44100: + case 48000: + break; + default: + return -EINVAL; + } + + return 0; +} + +static size_t get_input_buffer_size(uint32_t sample_rate, audio_format_t format, int channel_count) +{ + size_t size; + size_t device_rate; + + if (check_input_parameters(sample_rate, format, channel_count) != 0) + return 0; + + /* take resampling into account and return the closest majoring + multiple of 16 frames, as audioflinger expects audio buffers to + be a multiple of 16 frames */ + size = (pcm_config_capture.period_size * sample_rate) / pcm_config_capture.rate; + size = ((size + 15) / 16) * 16; + + return size * channel_count * sizeof(short); +} + +static void add_echo_reference(struct m0_stream_out *out, + struct echo_reference_itfe *reference) +{ + pthread_mutex_lock(&out->lock); + out->echo_reference = reference; + pthread_mutex_unlock(&out->lock); +} + +static void remove_echo_reference(struct m0_stream_out *out, + struct echo_reference_itfe *reference) +{ + pthread_mutex_lock(&out->lock); + if (out->echo_reference == reference) { + /* stop writing to echo reference */ + reference->write(reference, NULL); + out->echo_reference = NULL; + } + pthread_mutex_unlock(&out->lock); +} + +static void put_echo_reference(struct m0_audio_device *adev, + struct echo_reference_itfe *reference) +{ + if (adev->echo_reference != NULL && + reference == adev->echo_reference) { + /* echo reference is taken from the low latency output stream used + * for voice use cases */ + if (adev->outputs[OUTPUT_LOW_LATENCY] != NULL && + !adev->outputs[OUTPUT_LOW_LATENCY]->standby) + remove_echo_reference(adev->outputs[OUTPUT_LOW_LATENCY], reference); + release_echo_reference(reference); + adev->echo_reference = NULL; + } +} + +static struct echo_reference_itfe *get_echo_reference(struct m0_audio_device *adev, + audio_format_t format, + uint32_t channel_count, + uint32_t sampling_rate) +{ + put_echo_reference(adev, adev->echo_reference); + /* echo reference is taken from the low latency output stream used + * for voice use cases */ + if (adev->outputs[OUTPUT_LOW_LATENCY] != NULL && + !adev->outputs[OUTPUT_LOW_LATENCY]->standby) { + struct audio_stream *stream = + &adev->outputs[OUTPUT_LOW_LATENCY]->stream.common; + uint32_t wr_channel_count = popcount(stream->get_channels(stream)); + uint32_t wr_sampling_rate = stream->get_sample_rate(stream); + + int status = create_echo_reference(AUDIO_FORMAT_PCM_16_BIT, + channel_count, + sampling_rate, + AUDIO_FORMAT_PCM_16_BIT, + wr_channel_count, + wr_sampling_rate, + &adev->echo_reference); + if (status == 0) + add_echo_reference(adev->outputs[OUTPUT_LOW_LATENCY], + adev->echo_reference); + } + return adev->echo_reference; +} + +static int get_playback_delay(struct m0_stream_out *out, + size_t frames, + struct echo_reference_buffer *buffer) +{ + size_t kernel_frames; + int status; + int primary_pcm = 0; + + /* Find the first active PCM to act as primary */ + while ((primary_pcm < PCM_TOTAL) && !out->pcm[primary_pcm]) + primary_pcm++; + + status = pcm_get_htimestamp(out->pcm[primary_pcm], &kernel_frames, &buffer->time_stamp); + if (status < 0) { + buffer->time_stamp.tv_sec = 0; + buffer->time_stamp.tv_nsec = 0; + buffer->delay_ns = 0; + ALOGV("%s: pcm_get_htimestamp error," + "setting playbackTimestamp to 0", __func__); + return status; + } + + kernel_frames = pcm_get_buffer_size(out->pcm[primary_pcm]) - kernel_frames; + + /* adjust render time stamp with delay added by current driver buffer. + * Add the duration of current frame as we want the render time of the last + * sample being written. */ + buffer->delay_ns = (long)(((int64_t)(kernel_frames + frames)* 1000000000)/ + MM_FULL_POWER_SAMPLING_RATE); + + return 0; +} + +static uint32_t out_get_sample_rate(const struct audio_stream *stream) +{ + return DEFAULT_OUT_SAMPLING_RATE; +} + +static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate) +{ + return 0; +} + +static size_t out_get_buffer_size_low_latency(const struct audio_stream *stream) +{ + struct m0_stream_out *out = (struct m0_stream_out *)stream; + + /* take resampling into account and return the closest majoring + multiple of 16 frames, as audioflinger expects audio buffers to + be a multiple of 16 frames. Note: we use the default rate here + from pcm_config_tones.rate. */ + size_t size = (SHORT_PERIOD_SIZE * DEFAULT_OUT_SAMPLING_RATE) / pcm_config_tones.rate; + size = ((size + 15) / 16) * 16; + return size * audio_stream_frame_size((struct audio_stream *)stream); +} + +static size_t out_get_buffer_size_deep_buffer(const struct audio_stream *stream) +{ + struct m0_stream_out *out = (struct m0_stream_out *)stream; + + /* take resampling into account and return the closest majoring + multiple of 16 frames, as audioflinger expects audio buffers to + be a multiple of 16 frames. Note: we use the default rate here + from pcm_config_mm.rate. */ + size_t size = (DEEP_BUFFER_SHORT_PERIOD_SIZE * DEFAULT_OUT_SAMPLING_RATE) / + pcm_config_mm.rate; + size = ((size + 15) / 16) * 16; + return size * audio_stream_frame_size((struct audio_stream *)stream); +} + +static audio_channel_mask_t out_get_channels(const struct audio_stream *stream) +{ + struct m0_stream_out *out = (struct m0_stream_out *)stream; + + return out->channel_mask; +} + +static audio_format_t out_get_format(const struct audio_stream *stream) +{ + return AUDIO_FORMAT_PCM_16_BIT; +} + +static int out_set_format(struct audio_stream *stream, audio_format_t format) +{ + return 0; +} + +/* must be called with hw device and output stream mutexes locked */ +static int do_output_standby(struct m0_stream_out *out) +{ + struct m0_audio_device *adev = out->dev; + int i; + bool all_outputs_in_standby = true; + + if (!out->standby) { + out->standby = 1; + + for (i = 0; i < PCM_TOTAL; i++) { + if (out->pcm[i]) { + pcm_close(out->pcm[i]); + out->pcm[i] = NULL; + } + } + + for (i = 0; i < OUTPUT_TOTAL; i++) { + if (adev->outputs[i] != NULL && !adev->outputs[i]->standby) { + all_outputs_in_standby = false; + break; + } + } + + /* force standby on low latency output stream so that it can reuse HDMI driver if + * necessary when restarted */ + if (out == adev->outputs[OUTPUT_HDMI]) { + if (adev->outputs[OUTPUT_LOW_LATENCY] != NULL && + !adev->outputs[OUTPUT_LOW_LATENCY]->standby) { + struct m0_stream_out *ll_out = adev->outputs[OUTPUT_LOW_LATENCY]; + pthread_mutex_lock(&ll_out->lock); + do_output_standby(ll_out); + pthread_mutex_unlock(&ll_out->lock); + } + } + + /* stop writing to echo reference */ + if (out->echo_reference != NULL) { + out->echo_reference->write(out->echo_reference, NULL); + out->echo_reference = NULL; + } + } + return 0; +} + +static int out_standby(struct audio_stream *stream) +{ + struct m0_stream_out *out = (struct m0_stream_out *)stream; + int status; + + pthread_mutex_lock(&out->dev->lock); + pthread_mutex_lock(&out->lock); + status = do_output_standby(out); + pthread_mutex_unlock(&out->lock); + pthread_mutex_unlock(&out->dev->lock); + return status; +} + +static int out_dump(const struct audio_stream *stream, int fd) +{ + return 0; +} + +static int out_set_parameters(struct audio_stream *stream, const char *kvpairs) +{ + struct m0_stream_out *out = (struct m0_stream_out *)stream; + struct m0_audio_device *adev = out->dev; + struct m0_stream_in *in; + struct str_parms *parms; + char *str; + char value[32]; + int ret, val = 0; + bool force_input_standby = false; + + parms = str_parms_create_str(kvpairs); + + ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value)); + if (ret >= 0) { + val = atoi(value); + pthread_mutex_lock(&adev->lock); + pthread_mutex_lock(&out->lock); + if (((adev->out_device) != val) && (val != 0)) { + /* this is needed only when changing device on low latency output + * as other output streams are not used for voice use cases nor + * handle duplication to HDMI or SPDIF */ + if (out == adev->outputs[OUTPUT_LOW_LATENCY] && !out->standby) { + /* a change in output device may change the microphone selection */ + if (adev->active_input && + adev->active_input->source == AUDIO_SOURCE_VOICE_COMMUNICATION) { + force_input_standby = true; + } + /* force standby if moving to/from HDMI/SPDIF or if the output + * device changes when in HDMI/SPDIF mode */ + /* FIXME also force standby when in call as some audio path switches do not work + * while in call and an output stream is active (e.g BT SCO => earpiece) */ + + /* FIXME workaround for audio being dropped when switching path without forcing standby + * (several hundred ms of audio can be lost: e.g beginning of a ringtone. We must understand + * the root cause in audio HAL, driver or ABE. + if (((val & AUDIO_DEVICE_OUT_AUX_DIGITAL) ^ + (adev->out_device & AUDIO_DEVICE_OUT_AUX_DIGITAL)) || + ((val & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) ^ + (adev->out_device & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET)) || + (adev->out_device & (AUDIO_DEVICE_OUT_AUX_DIGITAL | + AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET))) + */ + if (((val & AUDIO_DEVICE_OUT_AUX_DIGITAL) ^ + (adev->out_device & AUDIO_DEVICE_OUT_AUX_DIGITAL)) || + ((val & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET) ^ + (adev->out_device & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET)) || + (adev->out_device & (AUDIO_DEVICE_OUT_AUX_DIGITAL | + AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET)) || + ((val & AUDIO_DEVICE_OUT_SPEAKER) ^ + (adev->out_device & AUDIO_DEVICE_OUT_SPEAKER)) || + (adev->mode == AUDIO_MODE_IN_CALL)) + do_output_standby(out); + } + if (out != adev->outputs[OUTPUT_HDMI]) { + adev->out_device = val; + select_output_device(adev); + } + } + pthread_mutex_unlock(&out->lock); + if (force_input_standby) { + in = adev->active_input; + pthread_mutex_lock(&in->lock); + do_input_standby(in); + pthread_mutex_unlock(&in->lock); + } + pthread_mutex_unlock(&adev->lock); + } + + str_parms_destroy(parms); + return ret; +} + +static char * out_get_parameters(const struct audio_stream *stream, const char *keys) +{ + struct m0_stream_out *out = (struct m0_stream_out *)stream; + + struct str_parms *query = str_parms_create_str(keys); + char *str; + char value[256]; + struct str_parms *reply = str_parms_create(); + size_t i, j; + int ret; + bool first = true; + + ret = str_parms_get_str(query, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value, sizeof(value)); + if (ret >= 0) { + value[0] = '\0'; + i = 0; + while (out->sup_channel_masks[i] != 0) { + for (j = 0; j < ARRAY_SIZE(out_channels_name_to_enum_table); j++) { + if (out_channels_name_to_enum_table[j].value == out->sup_channel_masks[i]) { + if (!first) { + strcat(value, "|"); + } + strcat(value, out_channels_name_to_enum_table[j].name); + first = false; + break; + } + } + i++; + } + str_parms_add_str(reply, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value); + str = strdup(str_parms_to_str(reply)); + } else { + str = strdup(keys); + } + str_parms_destroy(query); + str_parms_destroy(reply); + return str; +} + +static uint32_t out_get_latency_low_latency(const struct audio_stream_out *stream) +{ + struct m0_stream_out *out = (struct m0_stream_out *)stream; + + /* Note: we use the default rate here from pcm_config_mm.rate */ + return (SHORT_PERIOD_SIZE * PLAYBACK_SHORT_PERIOD_COUNT * 1000) / pcm_config_tones.rate; +} + +static uint32_t out_get_latency_deep_buffer(const struct audio_stream_out *stream) +{ + struct m0_stream_out *out = (struct m0_stream_out *)stream; + + /* Note: we use the default rate here from pcm_config_mm.rate */ + return (DEEP_BUFFER_LONG_PERIOD_SIZE * PLAYBACK_DEEP_BUFFER_LONG_PERIOD_COUNT * 1000) / + pcm_config_mm.rate; +} + +static int out_set_volume(struct audio_stream_out *stream, float left, + float right) +{ + return -ENOSYS; +} + +static ssize_t out_write_low_latency(struct audio_stream_out *stream, const void* buffer, + size_t bytes) +{ + int ret; + struct m0_stream_out *out = (struct m0_stream_out *)stream; + struct m0_audio_device *adev = out->dev; + size_t frame_size = audio_stream_frame_size(&out->stream.common); + size_t in_frames = bytes / frame_size; + size_t out_frames = in_frames; + bool force_input_standby = false; + struct m0_stream_in *in; + int i; + + /* acquiring hw device mutex systematically is useful if a low priority thread is waiting + * on the output stream mutex - e.g. executing select_mode() while holding the hw device + * mutex + */ + pthread_mutex_lock(&adev->lock); + pthread_mutex_lock(&out->lock); + if (out->standby) { + ret = start_output_stream_low_latency(out); + if (ret != 0) { + pthread_mutex_unlock(&adev->lock); + goto exit; + } + out->standby = 0; + /* a change in output device may change the microphone selection */ + if (adev->active_input && + adev->active_input->source == AUDIO_SOURCE_VOICE_COMMUNICATION) + force_input_standby = true; + } + pthread_mutex_unlock(&adev->lock); + + for (i = 0; i < PCM_TOTAL; i++) { + /* only use resampler if required */ + if (out->pcm[i] && (out->config[i].rate != DEFAULT_OUT_SAMPLING_RATE)) { + out_frames = out->buffer_frames; + out->resampler->resample_from_input(out->resampler, + (int16_t *)buffer, + &in_frames, + (int16_t *)out->buffer, + &out_frames); + break; + } + } + + if (out->echo_reference != NULL) { + struct echo_reference_buffer b; + b.raw = (void *)buffer; + b.frame_count = in_frames; + + get_playback_delay(out, out_frames, &b); + out->echo_reference->write(out->echo_reference, &b); + } + + /* Write to all active PCMs */ + for (i = 0; i < PCM_TOTAL; i++) { + if (out->pcm[i]) { + if (out->config[i].rate == DEFAULT_OUT_SAMPLING_RATE) { + /* PCM uses native sample rate */ + ret = PCM_WRITE(out->pcm[i], (void *)buffer, bytes); + } else { + /* PCM needs resampler */ + ret = PCM_WRITE(out->pcm[i], (void *)out->buffer, out_frames * frame_size); + } + if (ret) + break; + } + } + +exit: + pthread_mutex_unlock(&out->lock); + + if (ret != 0) { + usleep(bytes * 1000000 / audio_stream_frame_size(&stream->common) / + out_get_sample_rate(&stream->common)); + } + + if (force_input_standby) { + pthread_mutex_lock(&adev->lock); + if (adev->active_input) { + in = adev->active_input; + pthread_mutex_lock(&in->lock); + do_input_standby(in); + pthread_mutex_unlock(&in->lock); + } + pthread_mutex_unlock(&adev->lock); + } + + return bytes; +} + +static ssize_t out_write_deep_buffer(struct audio_stream_out *stream, const void* buffer, + size_t bytes) +{ + int ret; + struct m0_stream_out *out = (struct m0_stream_out *)stream; + struct m0_audio_device *adev = out->dev; + size_t frame_size = audio_stream_frame_size(&out->stream.common); + size_t in_frames = bytes / frame_size; + size_t out_frames; + bool use_long_periods; + int kernel_frames; + void *buf; + + /* acquiring hw device mutex systematically is useful if a low priority thread is waiting + * on the output stream mutex - e.g. executing select_mode() while holding the hw device + * mutex + */ + pthread_mutex_lock(&adev->lock); + pthread_mutex_lock(&out->lock); + if (out->standby) { + ret = start_output_stream_deep_buffer(out); + if (ret != 0) { + pthread_mutex_unlock(&adev->lock); + goto exit; + } + out->standby = 0; + } + use_long_periods = adev->screen_off && !adev->active_input; + pthread_mutex_unlock(&adev->lock); + + if (use_long_periods != out->use_long_periods) { + size_t period_size; + size_t period_count; + + if (use_long_periods) { + period_size = DEEP_BUFFER_LONG_PERIOD_SIZE; + period_count = PLAYBACK_DEEP_BUFFER_LONG_PERIOD_COUNT; + } else { + period_size = DEEP_BUFFER_SHORT_PERIOD_SIZE; + period_count = PLAYBACK_DEEP_BUFFER_SHORT_PERIOD_COUNT; + } + out->write_threshold = period_size * period_count; + pcm_set_avail_min(out->pcm[PCM_NORMAL], period_size); + out->use_long_periods = use_long_periods; + } + + /* only use resampler if required */ + if (out->config[PCM_NORMAL].rate != DEFAULT_OUT_SAMPLING_RATE) { + out_frames = out->buffer_frames; + out->resampler->resample_from_input(out->resampler, + (int16_t *)buffer, + &in_frames, + (int16_t *)out->buffer, + &out_frames); + buf = (void *)out->buffer; + } else { + out_frames = in_frames; + buf = (void *)buffer; + } + + /* do not allow more than out->write_threshold frames in kernel pcm driver buffer */ + do { + struct timespec time_stamp; + + if (pcm_get_htimestamp(out->pcm[PCM_NORMAL], + (unsigned int *)&kernel_frames, &time_stamp) < 0) + break; + kernel_frames = pcm_get_buffer_size(out->pcm[PCM_NORMAL]) - kernel_frames; + + if (kernel_frames > out->write_threshold) { + unsigned long time = (unsigned long) + (((int64_t)(kernel_frames - out->write_threshold) * 1000000) / + MM_FULL_POWER_SAMPLING_RATE); + if (time < MIN_WRITE_SLEEP_US) + time = MIN_WRITE_SLEEP_US; + usleep(time); + } + } while (kernel_frames > out->write_threshold); + + ret = pcm_mmap_write(out->pcm[PCM_NORMAL], buf, out_frames * frame_size); + +exit: + pthread_mutex_unlock(&out->lock); + + if (ret != 0) { + usleep(bytes * 1000000 / audio_stream_frame_size(&stream->common) / + out_get_sample_rate(&stream->common)); + } + + return bytes; +} + +static int out_get_render_position(const struct audio_stream_out *stream, + uint32_t *dsp_frames) +{ + return -EINVAL; +} + +static int out_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect) +{ + return 0; +} + +static int out_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect) +{ + return 0; +} + +/** audio_stream_in implementation **/ + +/* must be called with hw device and input stream mutexes locked */ +static int start_input_stream(struct m0_stream_in *in) +{ + int ret = 0; + struct m0_audio_device *adev = in->dev; + + adev->active_input = in; + + if (adev->mode != AUDIO_MODE_IN_CALL) { + adev->in_device = in->device; + select_input_device(adev); + } + + if (in->aux_channels_changed) + { + in->aux_channels_changed = false; + in->config.channels = popcount(in->main_channels | in->aux_channels); + + if (in->resampler) { + /* release and recreate the resampler with the new number of channel of the input */ + release_resampler(in->resampler); + in->resampler = NULL; + ret = create_resampler(in->config.rate, + in->requested_rate, + in->config.channels, + RESAMPLER_QUALITY_DEFAULT, + &in->buf_provider, + &in->resampler); + } + ALOGV("%s: New channel configuration, " + "main_channels = [%04x], aux_channels = [%04x], config.channels = %d", + __func__, in->main_channels, in->aux_channels, in->config.channels); + } + + if (in->need_echo_reference && in->echo_reference == NULL) + in->echo_reference = get_echo_reference(adev, + AUDIO_FORMAT_PCM_16_BIT, + popcount(in->main_channels), + in->requested_rate); + + /* this assumes routing is done previously */ + in->pcm = pcm_open(CARD_DEFAULT, PORT_CAPTURE, PCM_IN, &in->config); + if (!pcm_is_ready(in->pcm)) { + ALOGE("cannot open pcm_in driver: %s", pcm_get_error(in->pcm)); + pcm_close(in->pcm); + adev->active_input = NULL; + return -ENOMEM; + } + + /* force read and proc buf reallocation case of frame size or channel count change */ + in->read_buf_frames = 0; + in->read_buf_size = 0; + in->proc_buf_frames = 0; + in->proc_buf_size = 0; + /* if no supported sample rate is available, use the resampler */ + if (in->resampler) { + in->resampler->reset(in->resampler); + } + return 0; +} + +static uint32_t in_get_sample_rate(const struct audio_stream *stream) +{ + struct m0_stream_in *in = (struct m0_stream_in *)stream; + + return in->requested_rate; +} + +static int in_set_sample_rate(struct audio_stream *stream, uint32_t rate) +{ + return 0; +} + +static size_t in_get_buffer_size(const struct audio_stream *stream) +{ + struct m0_stream_in *in = (struct m0_stream_in *)stream; + + return get_input_buffer_size(in->requested_rate, + AUDIO_FORMAT_PCM_16_BIT, + popcount(in->main_channels)); +} + +static audio_channel_mask_t in_get_channels(const struct audio_stream *stream) +{ + struct m0_stream_in *in = (struct m0_stream_in *)stream; + + return in->main_channels; +} + +static audio_format_t in_get_format(const struct audio_stream *stream) +{ + return AUDIO_FORMAT_PCM_16_BIT; +} + +static int in_set_format(struct audio_stream *stream, audio_format_t format) +{ + return 0; +} + +/* must be called with hw device and input stream mutexes locked */ +static int do_input_standby(struct m0_stream_in *in) +{ + struct m0_audio_device *adev = in->dev; + + if (!in->standby) { + pcm_close(in->pcm); + in->pcm = NULL; + + adev->active_input = 0; + if (adev->mode != AUDIO_MODE_IN_CALL) { + adev->in_device = AUDIO_DEVICE_NONE; + select_input_device(adev); + } + + if (in->echo_reference != NULL) { + /* stop reading from echo reference */ + in->echo_reference->read(in->echo_reference, NULL); + put_echo_reference(adev, in->echo_reference); + in->echo_reference = NULL; + } + + in->standby = 1; + } + return 0; +} + +static int in_standby(struct audio_stream *stream) +{ + struct m0_stream_in *in = (struct m0_stream_in *)stream; + int status; + + pthread_mutex_lock(&in->dev->lock); + pthread_mutex_lock(&in->lock); + status = do_input_standby(in); + pthread_mutex_unlock(&in->lock); + pthread_mutex_unlock(&in->dev->lock); + return status; +} + +static int in_dump(const struct audio_stream *stream, int fd) +{ + return 0; +} + +static int in_set_parameters(struct audio_stream *stream, const char *kvpairs) +{ + struct m0_stream_in *in = (struct m0_stream_in *)stream; + struct m0_audio_device *adev = in->dev; + struct str_parms *parms; + char *str; + char value[32]; + int ret, val = 0; + bool do_standby = false; + + parms = str_parms_create_str(kvpairs); + + ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_INPUT_SOURCE, value, sizeof(value)); + + pthread_mutex_lock(&adev->lock); + pthread_mutex_lock(&in->lock); + if (ret >= 0) { + val = atoi(value); + /* no audio source uses val == 0 */ + if ((in->source != val) && (val != 0)) { + in->source = val; + do_standby = true; + } + } + + ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value)); + if (ret >= 0) { + val = atoi(value) & ~AUDIO_DEVICE_BIT_IN; + if ((in->device != val) && (val != 0)) { + in->device = val; + do_standby = true; + /* make sure new device selection is incompatible with multi-mic pre processing + * configuration */ + in_update_aux_channels(in, NULL); + } + } + + if (do_standby) + do_input_standby(in); + pthread_mutex_unlock(&in->lock); + pthread_mutex_unlock(&adev->lock); + + str_parms_destroy(parms); + return ret; +} + +static char * in_get_parameters(const struct audio_stream *stream, + const char *keys) +{ + return strdup(""); +} + +static int in_set_gain(struct audio_stream_in *stream, float gain) +{ + return 0; +} + +static void get_capture_delay(struct m0_stream_in *in, + size_t frames, + struct echo_reference_buffer *buffer) +{ + + /* read frames available in kernel driver buffer */ + size_t kernel_frames; + struct timespec tstamp; + long buf_delay; + long rsmp_delay; + long kernel_delay; + long delay_ns; + + if (pcm_get_htimestamp(in->pcm, &kernel_frames, &tstamp) < 0) { + buffer->time_stamp.tv_sec = 0; + buffer->time_stamp.tv_nsec = 0; + buffer->delay_ns = 0; + ALOGW("%s: pcm_htimestamp error", __func__); + return; + } + + /* read frames available in audio HAL input buffer + * add number of frames being read as we want the capture time of first sample + * in current buffer */ + /* frames in in->buffer are at driver sampling rate while frames in in->proc_buf are + * at requested sampling rate */ + buf_delay = (long)(((int64_t)(in->read_buf_frames) * 1000000000) / in->config.rate + + ((int64_t)(in->proc_buf_frames) * 1000000000) / + in->requested_rate); + + /* add delay introduced by resampler */ + rsmp_delay = 0; + if (in->resampler) { + rsmp_delay = in->resampler->delay_ns(in->resampler); + } + + kernel_delay = (long)(((int64_t)kernel_frames * 1000000000) / in->config.rate); + + delay_ns = kernel_delay + buf_delay + rsmp_delay; + + buffer->time_stamp = tstamp; + buffer->delay_ns = delay_ns; + ALOGV("%s: time_stamp = [%ld].[%ld], delay_ns: [%d]," + " kernel_delay:[%ld], buf_delay:[%ld], rsmp_delay:[%ld], kernel_frames:[%d], " + "in->read_buf_frames:[%d], in->proc_buf_frames:[%d], frames:[%d]", + __func__, buffer->time_stamp.tv_sec , buffer->time_stamp.tv_nsec, buffer->delay_ns, + kernel_delay, buf_delay, rsmp_delay, kernel_frames, + in->read_buf_frames, in->proc_buf_frames, frames); + +} + +static int32_t update_echo_reference(struct m0_stream_in *in, size_t frames) +{ + struct echo_reference_buffer b; + b.delay_ns = 0; + + ALOGV("%s: frames = [%d], in->ref_frames_in = [%d], " + "b.frame_count = [%d]", + __func__, frames, in->ref_buf_frames, frames - in->ref_buf_frames); + if (in->ref_buf_frames < frames) { + if (in->ref_buf_size < frames) { + in->ref_buf_size = frames; + in->ref_buf = (int16_t *)realloc(in->ref_buf, pcm_frames_to_bytes(in->pcm, frames)); + ALOG_ASSERT((in->ref_buf != NULL), + "%s failed to reallocate ref_buf", __func__); + ALOGV("%s: ref_buf %p extended to %d bytes", + __func__, in->ref_buf, pcm_frames_to_bytes(in->pcm, frames)); + } + b.frame_count = frames - in->ref_buf_frames; + b.raw = (void *)(in->ref_buf + in->ref_buf_frames * in->config.channels); + + get_capture_delay(in, frames, &b); + + if (in->echo_reference->read(in->echo_reference, &b) == 0) + { + in->ref_buf_frames += b.frame_count; + ALOGD("%s: in->ref_buf_frames:[%d], " + "in->ref_buf_size:[%d], frames:[%d], b.frame_count:[%d]", + __func__, in->ref_buf_frames, in->ref_buf_size, frames, b.frame_count); + } + } else + ALOGW("%s: NOT enough frames to read ref buffer", __func__); + return b.delay_ns; +} + +static int set_preprocessor_param(effect_handle_t handle, + effect_param_t *param) +{ + uint32_t size = sizeof(int); + uint32_t psize = ((param->psize - 1) / sizeof(int) + 1) * sizeof(int) + + param->vsize; + + int status = (*handle)->command(handle, + EFFECT_CMD_SET_PARAM, + sizeof (effect_param_t) + psize, + param, + &size, + ¶m->status); + if (status == 0) + status = param->status; + + return status; +} + +static int set_preprocessor_echo_delay(effect_handle_t handle, + int32_t delay_us) +{ + uint32_t buf[sizeof(effect_param_t) / sizeof(uint32_t) + 2]; + effect_param_t *param = (effect_param_t *)buf; + + param->psize = sizeof(uint32_t); + param->vsize = sizeof(uint32_t); + *(uint32_t *)param->data = AEC_PARAM_ECHO_DELAY; + *((int32_t *)param->data + 1) = delay_us; + + return set_preprocessor_param(handle, param); +} + +static void push_echo_reference(struct m0_stream_in *in, size_t frames) +{ + /* read frames from echo reference buffer and update echo delay + * in->ref_buf_frames is updated with frames available in in->ref_buf */ + int32_t delay_us = update_echo_reference(in, frames)/1000; + int i; + audio_buffer_t buf; + + if (in->ref_buf_frames < frames) + frames = in->ref_buf_frames; + + buf.frameCount = frames; + buf.raw = in->ref_buf; + + for (i = 0; i < in->num_preprocessors; i++) { + if ((*in->preprocessors[i].effect_itfe)->process_reverse == NULL) + continue; + + (*in->preprocessors[i].effect_itfe)->process_reverse(in->preprocessors[i].effect_itfe, + &buf, + NULL); + set_preprocessor_echo_delay(in->preprocessors[i].effect_itfe, delay_us); + } + + in->ref_buf_frames -= buf.frameCount; + if (in->ref_buf_frames) { + memcpy(in->ref_buf, + in->ref_buf + buf.frameCount * in->config.channels, + in->ref_buf_frames * in->config.channels * sizeof(int16_t)); + } +} + +static int get_next_buffer(struct resampler_buffer_provider *buffer_provider, + struct resampler_buffer* buffer) +{ + struct m0_stream_in *in; + + if (buffer_provider == NULL || buffer == NULL) + return -EINVAL; + + in = (struct m0_stream_in *)((char *)buffer_provider - + offsetof(struct m0_stream_in, buf_provider)); + + if (in->pcm == NULL) { + buffer->raw = NULL; + buffer->frame_count = 0; + in->read_status = -ENODEV; + return -ENODEV; + } + + if (in->read_buf_frames == 0) { + size_t size_in_bytes = pcm_frames_to_bytes(in->pcm, in->config.period_size); + if (in->read_buf_size < in->config.period_size) { + in->read_buf_size = in->config.period_size; + in->read_buf = (int16_t *) realloc(in->read_buf, size_in_bytes); + ALOG_ASSERT((in->read_buf != NULL), + "%s failed to reallocate read_buf", __func__); + ALOGV("%s: read_buf %p extended to %d bytes", + __func__, in->read_buf, size_in_bytes); + } + + in->read_status = pcm_read(in->pcm, (void*)in->read_buf, size_in_bytes); + + if (in->read_status != 0) { + ALOGE("%s: pcm_read error %d", __func__, in->read_status); + buffer->raw = NULL; + buffer->frame_count = 0; + return in->read_status; + } + in->read_buf_frames = in->config.period_size; + } + + buffer->frame_count = (buffer->frame_count > in->read_buf_frames) ? + in->read_buf_frames : buffer->frame_count; + buffer->i16 = in->read_buf + (in->config.period_size - in->read_buf_frames) * + in->config.channels; + + return in->read_status; + +} + +static void release_buffer(struct resampler_buffer_provider *buffer_provider, + struct resampler_buffer* buffer) +{ + struct m0_stream_in *in; + + if (buffer_provider == NULL || buffer == NULL) + return; + + in = (struct m0_stream_in *)((char *)buffer_provider - + offsetof(struct m0_stream_in, buf_provider)); + + in->read_buf_frames -= buffer->frame_count; +} + +/* read_frames() reads frames from kernel driver, down samples to capture rate + * if necessary and output the number of frames requested to the buffer specified */ +static ssize_t read_frames(struct m0_stream_in *in, void *buffer, ssize_t frames) +{ + ssize_t frames_wr = 0; + + while (frames_wr < frames) { + size_t frames_rd = frames - frames_wr; + if (in->resampler != NULL) { + in->resampler->resample_from_provider(in->resampler, + (int16_t *)((char *)buffer + + pcm_frames_to_bytes(in->pcm ,frames_wr)), + &frames_rd); + + } else { + struct resampler_buffer buf = { + { raw : NULL, }, + frame_count : frames_rd, + }; + get_next_buffer(&in->buf_provider, &buf); + if (buf.raw != NULL) { + memcpy((char *)buffer + + pcm_frames_to_bytes(in->pcm, frames_wr), + buf.raw, + pcm_frames_to_bytes(in->pcm, buf.frame_count)); + frames_rd = buf.frame_count; + } + release_buffer(&in->buf_provider, &buf); + } + /* in->read_status is updated by getNextBuffer() also called by + * in->resampler->resample_from_provider() */ + if (in->read_status != 0) + return in->read_status; + + frames_wr += frames_rd; + } + return frames_wr; +} + +/* process_frames() reads frames from kernel driver (via read_frames()), + * calls the active audio pre processings and output the number of frames requested + * to the buffer specified */ +static ssize_t process_frames(struct m0_stream_in *in, void* buffer, ssize_t frames) +{ + ssize_t frames_wr = 0; + audio_buffer_t in_buf; + audio_buffer_t out_buf; + int i; + bool has_aux_channels = (~in->main_channels & in->aux_channels); + void *proc_buf_out; + + if (has_aux_channels) + proc_buf_out = in->proc_buf_out; + else + proc_buf_out = buffer; + + /* since all the processing below is done in frames and using the config.channels + * as the number of channels, no changes is required in case aux_channels are present */ + while (frames_wr < frames) { + /* first reload enough frames at the end of process input buffer */ + if (in->proc_buf_frames < (size_t)frames) { + ssize_t frames_rd; + + if (in->proc_buf_size < (size_t)frames) { + size_t size_in_bytes = pcm_frames_to_bytes(in->pcm, frames); + + in->proc_buf_size = (size_t)frames; + in->proc_buf_in = (int16_t *)realloc(in->proc_buf_in, size_in_bytes); + ALOG_ASSERT((in->proc_buf_in != NULL), + "%s failed to reallocate proc_buf_in", __func__); + if (has_aux_channels) { + in->proc_buf_out = (int16_t *)realloc(in->proc_buf_out, size_in_bytes); + ALOG_ASSERT((in->proc_buf_out != NULL), + "%s failed to reallocate proc_buf_out", __func__); + proc_buf_out = in->proc_buf_out; + } + ALOGV("process_frames(): proc_buf_in %p extended to %d bytes", + in->proc_buf_in, size_in_bytes); + } + frames_rd = read_frames(in, + in->proc_buf_in + + in->proc_buf_frames * in->config.channels, + frames - in->proc_buf_frames); + if (frames_rd < 0) { + frames_wr = frames_rd; + break; + } + in->proc_buf_frames += frames_rd; + } + + if (in->echo_reference != NULL) + push_echo_reference(in, in->proc_buf_frames); + + /* in_buf.frameCount and out_buf.frameCount indicate respectively + * the maximum number of frames to be consumed and produced by process() */ + in_buf.frameCount = in->proc_buf_frames; + in_buf.s16 = in->proc_buf_in; + out_buf.frameCount = frames - frames_wr; + out_buf.s16 = (int16_t *)proc_buf_out + frames_wr * in->config.channels; + + /* FIXME: this works because of current pre processing library implementation that + * does the actual process only when the last enabled effect process is called. + * The generic solution is to have an output buffer for each effect and pass it as + * input to the next. + */ + for (i = 0; i < in->num_preprocessors; i++) { + (*in->preprocessors[i].effect_itfe)->process(in->preprocessors[i].effect_itfe, + &in_buf, + &out_buf); + } + + /* process() has updated the number of frames consumed and produced in + * in_buf.frameCount and out_buf.frameCount respectively + * move remaining frames to the beginning of in->proc_buf_in */ + in->proc_buf_frames -= in_buf.frameCount; + + if (in->proc_buf_frames) { + memcpy(in->proc_buf_in, + in->proc_buf_in + in_buf.frameCount * in->config.channels, + in->proc_buf_frames * in->config.channels * sizeof(int16_t)); + } + + /* if not enough frames were passed to process(), read more and retry. */ + if (out_buf.frameCount == 0) { + ALOGW("No frames produced by preproc"); + continue; + } + + if ((frames_wr + (ssize_t)out_buf.frameCount) <= frames) { + frames_wr += out_buf.frameCount; + } else { + /* The effect does not comply to the API. In theory, we should never end up here! */ + ALOGE("%s: preprocessing produced too many frames: %d + %d > %d !", __func__, + (unsigned int)frames_wr, out_buf.frameCount, (unsigned int)frames); + frames_wr = frames; + } + } + + /* Remove aux_channels that have been added on top of main_channels + * Assumption is made that the channels are interleaved and that the main + * channels are first. */ + if (has_aux_channels) + { + size_t src_channels = in->config.channels; + size_t dst_channels = popcount(in->main_channels); + int16_t* src_buffer = (int16_t *)proc_buf_out; + int16_t* dst_buffer = (int16_t *)buffer; + + if (dst_channels == 1) { + for (i = frames_wr; i > 0; i--) + { + *dst_buffer++ = *src_buffer; + src_buffer += src_channels; + } + } else { + for (i = frames_wr; i > 0; i--) + { + memcpy(dst_buffer, src_buffer, dst_channels*sizeof(int16_t)); + dst_buffer += dst_channels; + src_buffer += src_channels; + } + } + } + + return frames_wr; +} + +static ssize_t in_read(struct audio_stream_in *stream, void* buffer, + size_t bytes) +{ + int ret = 0; + struct m0_stream_in *in = (struct m0_stream_in *)stream; + struct m0_audio_device *adev = in->dev; + size_t frames_rq = bytes / audio_stream_frame_size(&stream->common); + + /* acquiring hw device mutex systematically is useful if a low priority thread is waiting + * on the input stream mutex - e.g. executing select_mode() while holding the hw device + * mutex + */ + pthread_mutex_lock(&adev->lock); + pthread_mutex_lock(&in->lock); + if (in->standby) { + ret = start_input_stream(in); + if (ret == 0) + in->standby = 0; + } + pthread_mutex_unlock(&adev->lock); + + if (ret < 0) + goto exit; + + if (in->num_preprocessors != 0) + ret = process_frames(in, buffer, frames_rq); + else if (in->resampler != NULL) + ret = read_frames(in, buffer, frames_rq); + else + ret = pcm_read(in->pcm, buffer, bytes); + + if (ret > 0) + ret = 0; + + if (ret == 0 && adev->mic_mute) + memset(buffer, 0, bytes); + +exit: + if (ret < 0) + usleep(bytes * 1000000 / audio_stream_frame_size(&stream->common) / + in_get_sample_rate(&stream->common)); + + pthread_mutex_unlock(&in->lock); + return bytes; +} + +static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream) +{ + return 0; +} + +#define GET_COMMAND_STATUS(status, fct_status, cmd_status) \ + do { \ + if (fct_status != 0) \ + status = fct_status; \ + else if (cmd_status != 0) \ + status = cmd_status; \ + } while(0) + +static int in_configure_reverse(struct m0_stream_in *in) +{ + int32_t cmd_status; + uint32_t size = sizeof(int); + effect_config_t config; + int32_t status = 0; + int32_t fct_status = 0; + int i; + + if (in->num_preprocessors > 0) { + config.inputCfg.channels = in->main_channels; + config.outputCfg.channels = in->main_channels; + config.inputCfg.format = AUDIO_FORMAT_PCM_16_BIT; + config.outputCfg.format = AUDIO_FORMAT_PCM_16_BIT; + config.inputCfg.samplingRate = in->requested_rate; + config.outputCfg.samplingRate = in->requested_rate; + config.inputCfg.mask = + ( EFFECT_CONFIG_SMP_RATE | EFFECT_CONFIG_CHANNELS | EFFECT_CONFIG_FORMAT ); + config.outputCfg.mask = + ( EFFECT_CONFIG_SMP_RATE | EFFECT_CONFIG_CHANNELS | EFFECT_CONFIG_FORMAT ); + + for (i = 0; i < in->num_preprocessors; i++) + { + if ((*in->preprocessors[i].effect_itfe)->process_reverse == NULL) + continue; + fct_status = (*(in->preprocessors[i].effect_itfe))->command( + in->preprocessors[i].effect_itfe, + EFFECT_CMD_SET_CONFIG_REVERSE, + sizeof(effect_config_t), + &config, + &size, + &cmd_status); + GET_COMMAND_STATUS(status, fct_status, cmd_status); + } + } + return status; +} + +#define MAX_NUM_CHANNEL_CONFIGS 10 + +static void in_read_audio_effect_channel_configs(struct m0_stream_in *in, + struct effect_info_s *effect_info) +{ + /* size and format of the cmd are defined in hardware/audio_effect.h */ + effect_handle_t effect = effect_info->effect_itfe; + uint32_t cmd_size = 2 * sizeof(uint32_t); + uint32_t cmd[] = { EFFECT_FEATURE_AUX_CHANNELS, MAX_NUM_CHANNEL_CONFIGS }; + /* reply = status + number of configs (n) + n x channel_config_t */ + uint32_t reply_size = + 2 * sizeof(uint32_t) + (MAX_NUM_CHANNEL_CONFIGS * sizeof(channel_config_t)); + int32_t reply[reply_size]; + int32_t cmd_status; + + ALOG_ASSERT((effect_info->num_channel_configs == 0), + "in_read_audio_effect_channel_configs() num_channel_configs not cleared"); + ALOG_ASSERT((effect_info->channel_configs == NULL), + "in_read_audio_effect_channel_configs() channel_configs not cleared"); + + /* if this command is not supported, then the effect is supposed to return -EINVAL. + * This error will be interpreted as if the effect supports the main_channels but does not + * support any aux_channels */ + cmd_status = (*effect)->command(effect, + EFFECT_CMD_GET_FEATURE_SUPPORTED_CONFIGS, + cmd_size, + (void*)&cmd, + &reply_size, + (void*)&reply); + + if (cmd_status != 0) { + ALOGI("%s: fx->command returned %d", __func__, cmd_status); + return; + } + + if (reply[0] != 0) { + ALOGW("%s: " + "command EFFECT_CMD_GET_FEATURE_SUPPORTED_CONFIGS error %d num configs %d", + __func__, reply[0], (reply[0] == -ENOMEM) ? reply[1] : MAX_NUM_CHANNEL_CONFIGS); + return; + } + + /* the feature is not supported */ + ALOGI("in_read_audio_effect_channel_configs()(): " + "Feature supported and adding %d channel configs to the list", reply[1]); + effect_info->num_channel_configs = reply[1]; + effect_info->channel_configs = + (channel_config_t *) malloc(sizeof(channel_config_t) * reply[1]); /* n x configs */ + memcpy(effect_info->channel_configs, (reply + 2), sizeof(channel_config_t) * reply[1]); +} + + +static uint32_t in_get_aux_channels(struct m0_stream_in *in) +{ + int i; + channel_config_t new_chcfg = {0, 0}; + + if (in->num_preprocessors == 0) + return 0; + + /* do not enable dual mic configurations when capturing from other microphones than + * main or sub */ + if (!(in->device & (AUDIO_DEVICE_IN_BUILTIN_MIC | AUDIO_DEVICE_IN_BACK_MIC))) + return 0; + + /* retain most complex aux channels configuration compatible with requested main channels and + * supported by audio driver and all pre processors */ + for (i = 0; i < NUM_IN_AUX_CNL_CONFIGS; i++) { + channel_config_t *cur_chcfg = &in_aux_cnl_configs[i]; + if (cur_chcfg->main_channels == in->main_channels) { + size_t match_cnt; + size_t idx_preproc; + for (idx_preproc = 0, match_cnt = 0; + /* no need to continue if at least one preprocessor doesn't match */ + idx_preproc < (size_t)in->num_preprocessors && match_cnt == idx_preproc; + idx_preproc++) { + struct effect_info_s *effect_info = &in->preprocessors[idx_preproc]; + size_t idx_chcfg; + + for (idx_chcfg = 0; idx_chcfg < effect_info->num_channel_configs; idx_chcfg++) { + if (memcmp(effect_info->channel_configs + idx_chcfg, + cur_chcfg, + sizeof(channel_config_t)) == 0) { + match_cnt++; + break; + } + } + } + /* if all preprocessors match, we have a candidate */ + if (match_cnt == (size_t)in->num_preprocessors) { + /* retain most complex aux channels configuration */ + if (popcount(cur_chcfg->aux_channels) > popcount(new_chcfg.aux_channels)) { + new_chcfg = *cur_chcfg; + } + } + } + } + + ALOGI("in_get_aux_channels(): return %04x", new_chcfg.aux_channels); + + return new_chcfg.aux_channels; +} + +static int in_configure_effect_channels(effect_handle_t effect, + channel_config_t *channel_config) +{ + int status = 0; + int fct_status; + int32_t cmd_status; + uint32_t reply_size; + effect_config_t config; + uint32_t cmd[(sizeof(uint32_t) + sizeof(channel_config_t) - 1) / sizeof(uint32_t) + 1]; + + ALOGI("in_configure_effect_channels(): configure effect with channels: [%04x][%04x]", + channel_config->main_channels, + channel_config->aux_channels); + + config.inputCfg.mask = EFFECT_CONFIG_CHANNELS; + config.outputCfg.mask = EFFECT_CONFIG_CHANNELS; + reply_size = sizeof(effect_config_t); + fct_status = (*effect)->command(effect, + EFFECT_CMD_GET_CONFIG, + 0, + NULL, + &reply_size, + &config); + if (fct_status != 0) { + ALOGE("in_configure_effect_channels(): EFFECT_CMD_GET_CONFIG failed"); + return fct_status; + } + + config.inputCfg.channels = channel_config->main_channels | channel_config->aux_channels; + config.outputCfg.channels = config.inputCfg.channels; + reply_size = sizeof(uint32_t); + fct_status = (*effect)->command(effect, + EFFECT_CMD_SET_CONFIG, + sizeof(effect_config_t), + &config, + &reply_size, + &cmd_status); + GET_COMMAND_STATUS(status, fct_status, cmd_status); + + cmd[0] = EFFECT_FEATURE_AUX_CHANNELS; + memcpy(cmd + 1, channel_config, sizeof(channel_config_t)); + reply_size = sizeof(uint32_t); + fct_status = (*effect)->command(effect, + EFFECT_CMD_SET_FEATURE_CONFIG, + sizeof(cmd), //sizeof(uint32_t) + sizeof(channel_config_t), + cmd, + &reply_size, + &cmd_status); + GET_COMMAND_STATUS(status, fct_status, cmd_status); + + /* some implementations need to be re-enabled after a config change */ + reply_size = sizeof(uint32_t); + fct_status = (*effect)->command(effect, + EFFECT_CMD_ENABLE, + 0, + NULL, + &reply_size, + &cmd_status); + GET_COMMAND_STATUS(status, fct_status, cmd_status); + + return status; +} + +static int in_reconfigure_channels(struct m0_stream_in *in, + effect_handle_t effect, + channel_config_t *channel_config, + bool config_changed) { + + int status = 0; + + ALOGI("%s: config_changed %d effect %p", + __func__, config_changed, effect); + + /* if config changed, reconfigure all previously added effects */ + if (config_changed) { + int i; + for (i = 0; i < in->num_preprocessors; i++) + { + int cur_status = in_configure_effect_channels(in->preprocessors[i].effect_itfe, + channel_config); + if (cur_status != 0) { + ALOGI("%s: error %d configuring effect " + "%d with channels: [%04x][%04x]", + __func__, + cur_status, + i, + channel_config->main_channels, + channel_config->aux_channels); + status = cur_status; + } + } + } else if (effect != NULL && channel_config->aux_channels) { + /* if aux channels config did not change but aux channels are present, + * we still need to configure the effect being added */ + status = in_configure_effect_channels(effect, channel_config); + } + return status; +} + +static void in_update_aux_channels(struct m0_stream_in *in, + effect_handle_t effect) +{ + uint32_t aux_channels; + channel_config_t channel_config; + int status; + + aux_channels = in_get_aux_channels(in); + + channel_config.main_channels = in->main_channels; + channel_config.aux_channels = aux_channels; + status = in_reconfigure_channels(in, + effect, + &channel_config, + (aux_channels != in->aux_channels)); + + if (status != 0) { + ALOGI("%s: in_reconfigure_channels error %d", __func__, status); + /* resetting aux channels configuration */ + aux_channels = 0; + channel_config.aux_channels = 0; + in_reconfigure_channels(in, effect, &channel_config, true); + } + if (in->aux_channels != aux_channels) { + in->aux_channels_changed = true; + in->aux_channels = aux_channels; + do_input_standby(in); + } +} + +static int in_add_audio_effect(const struct audio_stream *stream, + effect_handle_t effect) +{ + struct m0_stream_in *in = (struct m0_stream_in *)stream; + int status; + effect_descriptor_t desc; + + pthread_mutex_lock(&in->dev->lock); + pthread_mutex_lock(&in->lock); + if (in->num_preprocessors >= MAX_PREPROCESSORS) { + status = -ENOSYS; + goto exit; + } + + status = (*effect)->get_descriptor(effect, &desc); + if (status != 0) + goto exit; + + in->preprocessors[in->num_preprocessors].effect_itfe = effect; + /* add the supported channel of the effect in the channel_configs */ + in_read_audio_effect_channel_configs(in, &in->preprocessors[in->num_preprocessors]); + + in->num_preprocessors++; + + /* check compatibility between main channel supported and possible auxiliary channels */ + in_update_aux_channels(in, effect); + + ALOGV("%s: effect type: %08x", __func__, desc.type.timeLow); + + if (memcmp(&desc.type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0) { + in->need_echo_reference = true; + do_input_standby(in); + in_configure_reverse(in); + } + +exit: + + ALOGW_IF(status != 0, "%s: error %d", __func__, status); + pthread_mutex_unlock(&in->lock); + pthread_mutex_unlock(&in->dev->lock); + return status; +} + +static int in_remove_audio_effect(const struct audio_stream *stream, + effect_handle_t effect) +{ + struct m0_stream_in *in = (struct m0_stream_in *)stream; + int i; + int status = -EINVAL; + effect_descriptor_t desc; + + pthread_mutex_lock(&in->dev->lock); + pthread_mutex_lock(&in->lock); + if (in->num_preprocessors <= 0) { + status = -ENOSYS; + goto exit; + } + + for (i = 0; i < in->num_preprocessors; i++) { + if (status == 0) { /* status == 0 means an effect was removed from a previous slot */ + in->preprocessors[i - 1].effect_itfe = in->preprocessors[i].effect_itfe; + in->preprocessors[i - 1].channel_configs = in->preprocessors[i].channel_configs; + in->preprocessors[i - 1].num_channel_configs = in->preprocessors[i].num_channel_configs; + ALOGI("in_remove_audio_effect moving fx from %d to %d", i, i - 1); + continue; + } + if (in->preprocessors[i].effect_itfe == effect) { + ALOGI("in_remove_audio_effect found fx at index %d", i); + free(in->preprocessors[i].channel_configs); + status = 0; + } + } + + if (status != 0) + goto exit; + + in->num_preprocessors--; + /* if we remove one effect, at least the last preproc should be reset */ + in->preprocessors[in->num_preprocessors].num_channel_configs = 0; + in->preprocessors[in->num_preprocessors].effect_itfe = NULL; + in->preprocessors[in->num_preprocessors].channel_configs = NULL; + + + /* check compatibility between main channel supported and possible auxiliary channels */ + in_update_aux_channels(in, NULL); + + status = (*effect)->get_descriptor(effect, &desc); + if (status != 0) + goto exit; + + ALOGI("%s: effect type: %08x", __func__, desc.type.timeLow); + + if (memcmp(&desc.type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0) { + in->need_echo_reference = false; + do_input_standby(in); + } + +exit: + + ALOGW_IF(status != 0, "%s: error %d", __func__, status); + pthread_mutex_unlock(&in->lock); + pthread_mutex_unlock(&in->dev->lock); + return status; +} + +static int adev_open_output_stream(struct audio_hw_device *dev, + audio_io_handle_t handle, + audio_devices_t devices, + audio_output_flags_t flags, + struct audio_config *config, + struct audio_stream_out **stream_out) +{ + struct m0_audio_device *ladev = (struct m0_audio_device *)dev; + struct m0_stream_out *out; + int ret; + int output_type; + *stream_out = NULL; + + out = (struct m0_stream_out *)calloc(1, sizeof(struct m0_stream_out)); + if (!out) + return -ENOMEM; + + out->sup_channel_masks[0] = AUDIO_CHANNEL_OUT_STEREO; + out->channel_mask = AUDIO_CHANNEL_OUT_STEREO; + + if (ladev->outputs[OUTPUT_DEEP_BUF] != NULL) { + ret = -ENOSYS; + goto err_open; + } + output_type = OUTPUT_DEEP_BUF; + out->channel_mask = AUDIO_CHANNEL_OUT_STEREO; + out->stream.common.get_buffer_size = out_get_buffer_size_deep_buffer; + out->stream.common.get_sample_rate = out_get_sample_rate; + out->stream.get_latency = out_get_latency_deep_buffer; + out->stream.write = out_write_deep_buffer; + + ret = create_resampler(DEFAULT_OUT_SAMPLING_RATE, + MM_FULL_POWER_SAMPLING_RATE, + 2, + RESAMPLER_QUALITY_DEFAULT, + NULL, + &out->resampler); + if (ret != 0) + goto err_open; + + out->stream.common.set_sample_rate = out_set_sample_rate; + out->stream.common.get_channels = out_get_channels; + out->stream.common.get_format = out_get_format; + out->stream.common.set_format = out_set_format; + out->stream.common.standby = out_standby; + out->stream.common.dump = out_dump; + out->stream.common.set_parameters = out_set_parameters; + out->stream.common.get_parameters = out_get_parameters; + out->stream.common.add_audio_effect = out_add_audio_effect; + out->stream.common.remove_audio_effect = out_remove_audio_effect; + out->stream.set_volume = out_set_volume; + out->stream.get_render_position = out_get_render_position; + + out->dev = ladev; + out->standby = 1; + + /* FIXME: when we support multiple output devices, we will want to + * do the following: + * adev->out_device = out->device; + * select_output_device(adev); + * This is because out_set_parameters() with a route is not + * guaranteed to be called after an output stream is opened. */ + + config->format = out->stream.common.get_format(&out->stream.common); + config->channel_mask = out->stream.common.get_channels(&out->stream.common); + config->sample_rate = out->stream.common.get_sample_rate(&out->stream.common); + + *stream_out = &out->stream; + ladev->outputs[output_type] = out; + + return 0; + +err_open: + free(out); + return ret; +} + +static void adev_close_output_stream(struct audio_hw_device *dev, + struct audio_stream_out *stream) +{ + struct m0_audio_device *ladev = (struct m0_audio_device *)dev; + struct m0_stream_out *out = (struct m0_stream_out *)stream; + int i; + + out_standby(&stream->common); + for (i = 0; i < OUTPUT_TOTAL; i++) { + if (ladev->outputs[i] == out) { + ladev->outputs[i] = NULL; + break; + } + } + + if (out->buffer) + free(out->buffer); + if (out->resampler) + release_resampler(out->resampler); + free(stream); +} + +static int adev_set_parameters(struct audio_hw_device *dev, const char *kvpairs) +{ + struct m0_audio_device *adev = (struct m0_audio_device *)dev; + struct str_parms *parms; + char *str; + char value[32]; + int ret; + + parms = str_parms_create_str(kvpairs); + ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_TTY_MODE, value, sizeof(value)); + if (ret >= 0) { + int tty_mode; + + if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_OFF) == 0) + tty_mode = TTY_MODE_OFF; + else if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_VCO) == 0) + tty_mode = TTY_MODE_VCO; + else if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_HCO) == 0) + tty_mode = TTY_MODE_HCO; + else if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_FULL) == 0) + tty_mode = TTY_MODE_FULL; + else + return -EINVAL; + + pthread_mutex_lock(&adev->lock); + if (tty_mode != adev->tty_mode) { + adev->tty_mode = tty_mode; + if (adev->mode == AUDIO_MODE_IN_CALL) + select_output_device(adev); + } + pthread_mutex_unlock(&adev->lock); + } + + ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_BT_NREC, value, sizeof(value)); + if (ret >= 0) { + if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0) + adev->bluetooth_nrec = true; + else + adev->bluetooth_nrec = false; + } + + ret = str_parms_get_str(parms, "screen_off", value, sizeof(value)); + if (ret >= 0) { + if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0) + adev->screen_off = false; + else + adev->screen_off = true; + } + + str_parms_destroy(parms); + return ret; +} + +static char * adev_get_parameters(const struct audio_hw_device *dev, + const char *keys) +{ + return strdup(""); +} + +static int adev_init_check(const struct audio_hw_device *dev) +{ + return 0; +} + +static int adev_set_voice_volume(struct audio_hw_device *dev, float volume) +{ + struct m0_audio_device *adev = (struct m0_audio_device *)dev; + + adev->voice_volume = volume; + + if (adev->mode == AUDIO_MODE_IN_CALL) + ril_set_call_volume(&adev->ril, SOUND_TYPE_VOICE, volume); + + return 0; +} + +static int adev_set_master_volume(struct audio_hw_device *dev, float volume) +{ + return -ENOSYS; +} + +static int adev_set_mode(struct audio_hw_device *dev, audio_mode_t mode) +{ + struct m0_audio_device *adev = (struct m0_audio_device *)dev; + + pthread_mutex_lock(&adev->lock); + if (adev->mode != mode) { + adev->mode = mode; + select_mode(adev); + } + pthread_mutex_unlock(&adev->lock); + + return 0; +} + +static int adev_set_mic_mute(struct audio_hw_device *dev, bool state) +{ + struct m0_audio_device *adev = (struct m0_audio_device *)dev; + + adev->mic_mute = state; + + return 0; +} + +static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state) +{ + struct m0_audio_device *adev = (struct m0_audio_device *)dev; + + *state = adev->mic_mute; + + return 0; +} + +static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev, + const struct audio_config *config) +{ + size_t size; + int channel_count = popcount(config->channel_mask); + if (check_input_parameters(config->sample_rate, config->format, channel_count) != 0) + return 0; + + return get_input_buffer_size(config->sample_rate, config->format, channel_count); +} + +static int adev_open_input_stream(struct audio_hw_device *dev, + audio_io_handle_t handle, + audio_devices_t devices, + struct audio_config *config, + struct audio_stream_in **stream_in) +{ + struct m0_audio_device *ladev = (struct m0_audio_device *)dev; + struct m0_stream_in *in; + int ret; + int channel_count = popcount(config->channel_mask); + + *stream_in = NULL; + + if (check_input_parameters(config->sample_rate, config->format, channel_count) != 0) + return -EINVAL; + + in = (struct m0_stream_in *)calloc(1, sizeof(struct m0_stream_in)); + if (!in) + return -ENOMEM; + + in->stream.common.get_sample_rate = in_get_sample_rate; + in->stream.common.set_sample_rate = in_set_sample_rate; + in->stream.common.get_buffer_size = in_get_buffer_size; + in->stream.common.get_channels = in_get_channels; + in->stream.common.get_format = in_get_format; + in->stream.common.set_format = in_set_format; + in->stream.common.standby = in_standby; + in->stream.common.dump = in_dump; + in->stream.common.set_parameters = in_set_parameters; + in->stream.common.get_parameters = in_get_parameters; + in->stream.common.add_audio_effect = in_add_audio_effect; + in->stream.common.remove_audio_effect = in_remove_audio_effect; + in->stream.set_gain = in_set_gain; + in->stream.read = in_read; + in->stream.get_input_frames_lost = in_get_input_frames_lost; + + in->requested_rate = config->sample_rate; + + memcpy(&in->config, &pcm_config_capture, sizeof(pcm_config_capture)); + in->config.channels = channel_count; + + in->main_channels = config->channel_mask; + + /* initialisation of preprocessor structure array is implicit with the calloc. + * same for in->aux_channels and in->aux_channels_changed */ + + if (in->requested_rate != in->config.rate) { + in->buf_provider.get_next_buffer = get_next_buffer; + in->buf_provider.release_buffer = release_buffer; + + ret = create_resampler(in->config.rate, + in->requested_rate, + in->config.channels, + RESAMPLER_QUALITY_DEFAULT, + &in->buf_provider, + &in->resampler); + if (ret != 0) { + ret = -EINVAL; + goto err; + } + } + + in->dev = ladev; + in->standby = 1; + in->device = devices & ~AUDIO_DEVICE_BIT_IN; + + *stream_in = &in->stream; + return 0; + +err: + if (in->resampler) + release_resampler(in->resampler); + + free(in); + return ret; +} + +static void adev_close_input_stream(struct audio_hw_device *dev, + struct audio_stream_in *stream) +{ + struct m0_stream_in *in = (struct m0_stream_in *)stream; + int i; + + in_standby(&stream->common); + + for (i = 0; i < in->num_preprocessors; i++) { + free(in->preprocessors[i].channel_configs); + } + + free(in->read_buf); + if (in->resampler) { + release_resampler(in->resampler); + } + if (in->proc_buf_in) + free(in->proc_buf_in); + if (in->proc_buf_out) + free(in->proc_buf_out); + if (in->ref_buf) + free(in->ref_buf); + + free(stream); + return; +} + +static int adev_dump(const audio_hw_device_t *device, int fd) +{ + return 0; +} + +static int adev_close(hw_device_t *device) +{ + struct m0_audio_device *adev = (struct m0_audio_device *)device; + + /* RIL */ + ril_close(&adev->ril); + + mixer_close(adev->mixer); + free(device); + return 0; +} + +struct config_parse_state { + struct m0_audio_device *adev; + struct m0_dev_cfg *dev; + bool on; + + struct route_setting *path; + unsigned int path_len; +}; + +static const struct { + int mask; + const char *name; +} dev_names[] = { + { AUDIO_DEVICE_OUT_SPEAKER, "speaker" }, + { AUDIO_DEVICE_OUT_WIRED_HEADSET | AUDIO_DEVICE_OUT_WIRED_HEADPHONE, "headphone" }, + { AUDIO_DEVICE_OUT_EARPIECE, "earpiece" }, + { AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET, "analog-dock" }, + { AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET, "digital-dock" }, + { AUDIO_DEVICE_OUT_ALL_SCO, "sco-out" }, + + { AUDIO_DEVICE_IN_BUILTIN_MIC, "builtin-mic" }, + { AUDIO_DEVICE_IN_BACK_MIC, "back-mic" }, + { AUDIO_DEVICE_IN_WIRED_HEADSET, "headset-in" }, + { AUDIO_DEVICE_IN_ALL_SCO, "sco-in" }, +}; + +static void adev_config_start(void *data, const XML_Char *elem, + const XML_Char **attr) +{ + struct config_parse_state *s = data; + struct m0_dev_cfg *dev_cfg; + const XML_Char *name = NULL; + const XML_Char *val = NULL; + unsigned int i, j; + + for (i = 0; attr[i]; i += 2) { + if (strcmp(attr[i], "name") == 0) + name = attr[i + 1]; + + if (strcmp(attr[i], "val") == 0) + val = attr[i + 1]; + } + + if (strcmp(elem, "device") == 0) { + if (!name) { + ALOGE("Unnamed device\n"); + return; + } + + for (i = 0; i < sizeof(dev_names) / sizeof(dev_names[0]); i++) { + if (strcmp(dev_names[i].name, name) == 0) { + ALOGI("Allocating device %s\n", name); + dev_cfg = realloc(s->adev->dev_cfgs, + (s->adev->num_dev_cfgs + 1) + * sizeof(*dev_cfg)); + if (!dev_cfg) { + ALOGE("Unable to allocate dev_cfg\n"); + return; + } + + s->dev = &dev_cfg[s->adev->num_dev_cfgs]; + memset(s->dev, 0, sizeof(*s->dev)); + s->dev->mask = dev_names[i].mask; + + s->adev->dev_cfgs = dev_cfg; + s->adev->num_dev_cfgs++; + } + } + + } else if (strcmp(elem, "path") == 0) { + if (s->path_len) + ALOGW("Nested paths\n"); + + /* If this a path for a device it must have a role */ + if (s->dev) { + /* Need to refactor a bit... */ + if (strcmp(name, "on") == 0) { + s->on = true; + } else if (strcmp(name, "off") == 0) { + s->on = false; + } else { + ALOGW("Unknown path name %s\n", name); + } + } + + } else if (strcmp(elem, "ctl") == 0) { + struct route_setting *r; + + if (!name) { + ALOGE("Unnamed control\n"); + return; + } + + if (!val) { + ALOGE("No value specified for %s\n", name); + return; + } + + ALOGV("Parsing control %s => %s\n", name, val); + + r = realloc(s->path, sizeof(*r) * (s->path_len + 1)); + if (!r) { + ALOGE("Out of memory handling %s => %s\n", name, val); + return; + } + + r[s->path_len].ctl_name = strdup(name); + r[s->path_len].strval = NULL; + + /* This can be fooled but it'll do */ + r[s->path_len].intval = atoi(val); + if (!r[s->path_len].intval && strcmp(val, "0") != 0) + r[s->path_len].strval = strdup(val); + + s->path = r; + s->path_len++; + } +} + +static void adev_config_end(void *data, const XML_Char *name) +{ + struct config_parse_state *s = data; + unsigned int i; + + if (strcmp(name, "path") == 0) { + if (!s->path_len) + ALOGW("Empty path\n"); + + if (!s->dev) { + ALOGV("Applying %d element default route\n", s->path_len); + + set_route_by_array(s->adev->mixer, s->path, s->path_len); + + for (i = 0; i < s->path_len; i++) { + free(s->path[i].ctl_name); + free(s->path[i].strval); + } + + free(s->path); + + /* Refactor! */ + } else if (s->on) { + ALOGV("%d element on sequence\n", s->path_len); + s->dev->on = s->path; + s->dev->on_len = s->path_len; + + } else { + ALOGV("%d element off sequence\n", s->path_len); + + /* Apply it, we'll reenable anything that's wanted later */ + set_route_by_array(s->adev->mixer, s->path, s->path_len); + + s->dev->off = s->path; + s->dev->off_len = s->path_len; + } + + s->path_len = 0; + s->path = NULL; + + } else if (strcmp(name, "device") == 0) { + s->dev = NULL; + } +} + +static int adev_config_parse(struct m0_audio_device *adev) +{ + struct config_parse_state s; + FILE *f; + XML_Parser p; + int ret = 0; + bool eof = false; + int len; + char buf[1024]; + + ALOGV("Reading configuration from %s\n", CONFIG_FILE); + f = fopen(CONFIG_FILE, "r"); + if (!f) { + ALOGE("Failed to open %s\n", CONFIG_FILE); + return -ENODEV; + } + + p = XML_ParserCreate(NULL); + if (!p) { + ALOGE("Failed to create XML parser\n"); + ret = -ENOMEM; + goto out; + } + + memset(&s, 0, sizeof(s)); + s.adev = adev; + XML_SetUserData(p, &s); + + XML_SetElementHandler(p, adev_config_start, adev_config_end); + + while (!eof) { + len = fread(buf, 1, sizeof(buf), f); + if (ferror(f)) { + ALOGE("I/O error reading config\n"); + ret = -EIO; + goto out_parser; + } + eof = feof(f); + + if (XML_Parse(p, buf, len, eof) == XML_STATUS_ERROR) { + ALOGE("Parse error at line %u:\n%s\n", + (unsigned int)XML_GetCurrentLineNumber(p), + XML_ErrorString(XML_GetErrorCode(p))); + ret = -EINVAL; + goto out_parser; + } + } + + out_parser: + XML_ParserFree(p); + out: + fclose(f); + + return ret; +} + +static int adev_open(const hw_module_t* module, const char* name, + hw_device_t** device) +{ + struct m0_audio_device *adev; + int ret; + + if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0) + return -EINVAL; + + adev = calloc(1, sizeof(struct m0_audio_device)); + if (!adev) + return -ENOMEM; + + adev->hw_device.common.tag = HARDWARE_DEVICE_TAG; + adev->hw_device.common.version = AUDIO_DEVICE_API_VERSION_2_0; + adev->hw_device.common.module = (struct hw_module_t *) module; + adev->hw_device.common.close = adev_close; + + adev->hw_device.init_check = adev_init_check; + adev->hw_device.set_voice_volume = adev_set_voice_volume; + adev->hw_device.set_master_volume = adev_set_master_volume; + adev->hw_device.set_mode = adev_set_mode; + adev->hw_device.set_mic_mute = adev_set_mic_mute; + adev->hw_device.get_mic_mute = adev_get_mic_mute; + adev->hw_device.set_parameters = adev_set_parameters; + adev->hw_device.get_parameters = adev_get_parameters; + adev->hw_device.get_input_buffer_size = adev_get_input_buffer_size; + adev->hw_device.open_output_stream = adev_open_output_stream; + adev->hw_device.close_output_stream = adev_close_output_stream; + adev->hw_device.open_input_stream = adev_open_input_stream; + adev->hw_device.close_input_stream = adev_close_input_stream; + adev->hw_device.dump = adev_dump; + + adev->mixer = mixer_open(CARD_DEFAULT); + if (!adev->mixer) { + free(adev); + ALOGE("Unable to open the mixer, aborting."); + return -EINVAL; + } + + /* +30db boost for mics */ + adev->mixer_ctls.mixinl_in1l_volume = mixer_get_ctl_by_name(adev->mixer, "MIXINL IN1L Volume"); + adev->mixer_ctls.mixinl_in2l_volume = mixer_get_ctl_by_name(adev->mixer, "MIXINL IN2L Volume"); + + ret = adev_config_parse(adev); + if (ret != 0) + goto err_mixer; + + /* Set the default route before the PCM stream is opened */ + pthread_mutex_lock(&adev->lock); + adev->mode = AUDIO_MODE_NORMAL; + adev->out_device = AUDIO_DEVICE_OUT_SPEAKER; + adev->in_device = AUDIO_DEVICE_IN_BUILTIN_MIC & ~AUDIO_DEVICE_BIT_IN; + select_devices(adev); + + adev->pcm_modem_dl = NULL; + adev->pcm_modem_ul = NULL; + adev->voice_volume = 1.0f; + adev->tty_mode = TTY_MODE_OFF; + adev->bluetooth_nrec = true; + adev->wb_amr = 0; + + /* RIL */ + ril_open(&adev->ril); + pthread_mutex_unlock(&adev->lock); + /* register callback for wideband AMR setting */ + ril_register_set_wb_amr_callback(audio_set_wb_amr_callback, (void *)adev); + + *device = &adev->hw_device.common; + + return 0; + +err_mixer: + mixer_close(adev->mixer); +err: + return -EINVAL; +} + +static struct hw_module_methods_t hal_module_methods = { + .open = adev_open, +}; + +struct audio_module HAL_MODULE_INFO_SYM = { + .common = { + .tag = HARDWARE_MODULE_TAG, + .module_api_version = AUDIO_MODULE_API_VERSION_0_1, + .hal_api_version = HARDWARE_HAL_API_VERSION, + .id = AUDIO_HARDWARE_MODULE_ID, + .name = "M0 audio HW HAL", + .author = "The CyanogenMod Project", + .methods = &hal_module_methods, + }, +}; diff --git a/audio/audio_hw.h b/audio/audio_hw.h new file mode 100644 index 0000000..246cba8 --- /dev/null +++ b/audio/audio_hw.h @@ -0,0 +1,239 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * Copyright (C) 2012 Wolfson Microelectronics plc + * Copyright (C) 2012 The CyanogenMod Project + * Daniel Hillenbrand + * Guillaume "XpLoDWilD" Lesniak + * + * 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 CONFIG_FILE "/system/etc/sound/tiny_hw.xml" + +/* ALSA cards for WM1811 */ +#define CARD_DEFAULT 0 + +#define PORT_PLAYBACK 0 +#define PORT_MODEM 1 +#define PORT_BT 2 +#define PORT_CAPTURE 3 + +#define PCM_WRITE pcm_write + +#define PLAYBACK_PERIOD_SIZE 880 +#define PLAYBACK_PERIOD_COUNT 8 +#define PLAYBACK_SHORT_PERIOD_COUNT 2 + +#define CAPTURE_PERIOD_SIZE 1024 +#define CAPTURE_PERIOD_COUNT 4 + +#define SHORT_PERIOD_SIZE 192 + +// +// deep buffer +// +/* screen on */ +#define DEEP_BUFFER_SHORT_PERIOD_SIZE 1056 +#define PLAYBACK_DEEP_BUFFER_SHORT_PERIOD_COUNT 4 +/* screen off */ +#define DEEP_BUFFER_LONG_PERIOD_SIZE 880 +#define PLAYBACK_DEEP_BUFFER_LONG_PERIOD_COUNT 8 + + +/* minimum sleep time in out_write() when write threshold is not reached */ +#define MIN_WRITE_SLEEP_US 5000 + +#define RESAMPLER_BUFFER_FRAMES (PLAYBACK_PERIOD_SIZE * 2) +#define RESAMPLER_BUFFER_SIZE (4 * RESAMPLER_BUFFER_FRAMES) + +#define DEFAULT_OUT_SAMPLING_RATE 44100 +#define MM_LOW_POWER_SAMPLING_RATE 44100 +#define MM_FULL_POWER_SAMPLING_RATE 44100 +#define DEFAULT_IN_SAMPLING_RATE 44100 + +/* sampling rate when using VX port for narrow band */ +#define VX_NB_SAMPLING_RATE 8000 +/* sampling rate when using VX port for wide band */ +#define VX_WB_SAMPLING_RATE 16000 + +#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0])) + +#define STRING_TO_ENUM(string) { #string, string } + +struct string_to_enum { + const char *name; + uint32_t value; +}; + +const struct string_to_enum out_channels_name_to_enum_table[] = { + STRING_TO_ENUM(AUDIO_CHANNEL_OUT_STEREO), + STRING_TO_ENUM(AUDIO_CHANNEL_OUT_5POINT1), + STRING_TO_ENUM(AUDIO_CHANNEL_OUT_7POINT1), +}; + +enum pcm_type { + PCM_NORMAL = 0, + PCM_SPDIF, + PCM_HDMI, + PCM_TOTAL, +}; + +enum output_type { + OUTPUT_DEEP_BUF, // deep PCM buffers output stream + OUTPUT_LOW_LATENCY, // low latency output stream + OUTPUT_HDMI, + OUTPUT_TOTAL +}; + +enum tty_modes { + TTY_MODE_OFF, + TTY_MODE_VCO, + TTY_MODE_HCO, + TTY_MODE_FULL +}; + +struct mixer_ctls +{ + struct mixer_ctl *mixinl_in1l_volume; + struct mixer_ctl *mixinl_in2l_volume; +}; + +struct route_setting +{ + char *ctl_name; + int intval; + char *strval; +}; + +struct route_setting voicecall_default[] = { + { .ctl_name = "AIF2DACL Source", .intval = 0, }, + { .ctl_name = "AIF2DACR Source", .intval = 0, }, + { .ctl_name = "AIF2 Mode", .intval = 0, }, + { .ctl_name = "DAC1L Mixer AIF1.1 Switch", .intval = 1, }, + { .ctl_name = "DAC1R Mixer AIF1.1 Switch", .intval = 1, }, + { .ctl_name = "DAC1L Mixer AIF2 Switch", .intval = 1, }, + { .ctl_name = "DAC1R Mixer AIF2 Switch", .intval = 1, }, + { .ctl_name = "AIF2DAC Mux", .strval = "AIF2DACDAT", }, + { .ctl_name = NULL, }, +}; + +struct route_setting voicecall_default_disable[] = { + { .ctl_name = "AIF2DACL Source", .intval = 0, }, + { .ctl_name = "AIF2DACR Source", .intval = 1, }, + { .ctl_name = "AIF2 Mode", .intval = 0, }, + { .ctl_name = "DAC1L Mixer AIF2 Switch", .intval = 0, }, + { .ctl_name = "DAC1R Mixer AIF2 Switch", .intval = 0, }, + { .ctl_name = "AIF2DAC Mux", .strval = "AIF3DACDAT", }, + { .ctl_name = "Main Mic Switch", .intval = 0, }, + { .ctl_name = "MIXINL IN1L Switch", .intval = 0, }, + { .ctl_name = "Sub Mic Switch", .intval = 0, }, + { .ctl_name = "MIXINR IN1R Switch", .intval = 0, }, + { .ctl_name = NULL, }, +}; + +struct route_setting default_input[] = { + { .ctl_name = "Main Mic Switch", .intval = 1, }, + { .ctl_name = "IN1L Volume", .intval = 30, }, + { .ctl_name = "MIXINL IN1L Switch", .intval = 1, }, + { .ctl_name = "MIXINL IN1L Volume", .intval = 0, }, + { .ctl_name = "AIF1ADC1 HPF Mode", .intval = 0, }, + { .ctl_name = "AIF1ADC1 HPF Switch", .intval = 1, }, + { .ctl_name = NULL, }, +}; + +struct route_setting default_input_disable[] = { + { .ctl_name = "Main Mic Switch", .intval = 0, }, + { .ctl_name = "IN1L Volume", .intval = 22, }, + { .ctl_name = "MIXINL IN1L Switch", .intval = 0, }, + { .ctl_name = "AIF1ADC1 HPF Switch", .intval = 0, }, + { .ctl_name = NULL, }, +}; + +struct route_setting headset_input[] = { + { .ctl_name = "MIXINL IN1L Switch", .intval = 0, }, + { .ctl_name = "MIXINR IN1R Switch", .intval = 0, }, + { .ctl_name = "Headset Mic Switch", .intval = 1, }, + { .ctl_name = "IN2L Volume", .intval = 18, }, + { .ctl_name = "MIXINL IN2L Switch", .intval = 1, }, + { .ctl_name = "MIXINL IN2L Volume", .intval = 0, }, + { .ctl_name = "AIF1ADC1 HPF Mode", .intval = 1, }, + { .ctl_name = "AIF1ADC1 HPF Switch", .intval = 1, }, + { .ctl_name = "AIF1ADC1 Volume", .intval = 96, }, + { .ctl_name = "AIF1ADCL Source", .intval = 0, }, + { .ctl_name = "AIF1ADCR Source", .intval = 0, }, + { .ctl_name = "AIF2ADCL Source", .intval = 0, }, + { .ctl_name = NULL, }, +}; + +struct route_setting headset_input_disable[] = { + { .ctl_name = "Headset Mic Switch", .intval = 0, }, + { .ctl_name = "MIXINL IN2L Switch", .intval = 0, }, + { .ctl_name = "AIF1ADC1 HPF Mode", .intval = 0, }, + { .ctl_name = "AIF1ADC1 HPF Switch", .intval = 0, }, + { .ctl_name = NULL, }, +}; + +struct route_setting bt_output[] = { + { .ctl_name = "DAC1L Mixer AIF1.1 Switch", .intval = 1, }, + { .ctl_name = "DAC1R Mixer AIF1.1 Switch", .intval = 1, }, + { .ctl_name = "AIF3ADC Mux", .intval = 1, }, + { .ctl_name = "AIF2DAC2L Mixer AIF1.1 Switch", .intval = 1, }, + { .ctl_name = "AIF2DAC2R Mixer AIF1.1 Switch", .intval = 1, }, + { .ctl_name = "AIF2DAC Volume", .intval = 96, }, + { .ctl_name = "DAC2 Volume", .intval = 96, }, + { .ctl_name = "AIF2ADC Volume", .intval = 96, }, + { .ctl_name = "Speaker Mixer Volume", .intval = 1, }, + { .ctl_name = "MIXINL IN2L Volume", .intval = 1, }, + { .ctl_name = "IN1L Volume", .intval = 25, }, + { .ctl_name = "IN1R Volume", .intval = 25, }, + { .ctl_name = "Speaker Boost Volume", .intval = 4, }, + { .ctl_name = "LINEOUT1N Switch", .intval = 0, }, + { .ctl_name = "LINEOUT1P Switch", .intval = 0, }, + { .ctl_name = "AIF2DACR Source", .intval = 0, }, + { .ctl_name = "AIF1ADC1 HPF Switch", .intval = 0, }, + { .ctl_name = "AIF2ADC HPF Mode", .intval = 1, }, + { .ctl_name = "AIF2ADC HPF Switch", .intval = 1, }, + { .ctl_name = "AIF2DAC Mux", .strval = "AIF2DACDAT", }, + { .ctl_name = "AIF2DAC2R Mixer AIF2 Switch", .intval = 1, }, + { .ctl_name = "AIF2DAC2L Mixer AIF2 Switch", .intval = 1, }, + { .ctl_name = NULL, }, +}; + +struct route_setting bt_input[] = { + { .ctl_name = "AIF2ADC Mux", .intval = 1, }, + { .ctl_name = "AIF1ADCL Source", .intval = 0, }, + { .ctl_name = "AIF1ADCR Source", .intval = 1, }, + { .ctl_name = "AIF2ADCL Source", .intval = 0, }, + { .ctl_name = "AIF2ADCR Source", .intval = 1, }, + { .ctl_name = "DAC1L Mixer AIF2 Switch", .intval = 1, }, + { .ctl_name = "DAC1R Mixer AIF2 Switch", .intval = 1, }, + { .ctl_name = "AIF1ADC1R Mixer AIF2 Switch", .intval = 1, }, + { .ctl_name = "AIF1ADC1L Mixer AIF2 Switch", .intval = 1, }, + { .ctl_name = "AIF1ADC1 Volume", .intval = 96, }, + { .ctl_name = "AIF2DAC Volume", .intval = 96, }, + { .ctl_name = NULL, }, +}; + +struct route_setting bt_disable[] = { + { .ctl_name = "AIF2ADC Mux", .intval = 0, }, + { .ctl_name = "MIXINL IN2L Volume", .intval = 0, }, + { .ctl_name = "LINEOUT1N Switch", .intval = 1, }, + { .ctl_name = "LINEOUT1P Switch", .intval = 1, }, + { .ctl_name = "AIF2ADC HPF Mode", .intval = 0, }, + { .ctl_name = "AIF2ADC HPF Switch", .intval = 0, }, + { .ctl_name = "AIF2DAC2R Mixer AIF2 Switch", .intval = 0, }, + { .ctl_name = "AIF2DAC2L Mixer AIF2 Switch", .intval = 0, }, + { .ctl_name = "AIF1ADC1R Mixer AIF2 Switch", .intval = 0, }, + { .ctl_name = "AIF1ADC1L Mixer AIF2 Switch", .intval = 0, }, + { .ctl_name = NULL, }, +}; diff --git a/audio/ril_interface.c b/audio/ril_interface.c new file mode 100755 index 0000000..89a0aef --- /dev/null +++ b/audio/ril_interface.c @@ -0,0 +1,183 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * 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 ALOG_TAG "audio_hw_primary" +/*#define ALOG_NDEBUG 0*/ + +#include +#include + +#include +#include + +#include "ril_interface.h" + +#define VOLUME_STEPS_DEFAULT "5" +#define VOLUME_STEPS_PROPERTY "ro.config.vc_call_vol_steps" + +/* Function pointers */ +void *(*_ril_open_client)(void); +int (*_ril_close_client)(void *); +int (*_ril_connect)(void *); +int (*_ril_is_connected)(void *); +int (*_ril_disconnect)(void *); +int (*_ril_set_call_volume)(void *, enum ril_sound_type, int); +int (*_ril_set_call_audio_path)(void *, enum ril_audio_path); +int (*_ril_set_call_clock_sync)(void *, enum ril_clock_state); +int (*_ril_register_unsolicited_handler)(void *, int, void *); +int (*_ril_get_wb_amr)(void *, void *); + +/* Audio WB AMR callback */ +void (*_audio_set_wb_amr_callback)(void *, int); +void *callback_data = NULL; + +void ril_register_set_wb_amr_callback(void *function, void *data) +{ + _audio_set_wb_amr_callback = function; + callback_data = data; +} + +/* This is the callback function that the RIL uses to +set the wideband AMR state */ +static int ril_set_wb_amr_callback(void *ril_client, + const void *data, + size_t datalen) +{ + int enable = ((int *)data)[0]; + + if (!callback_data || !_audio_set_wb_amr_callback) + return -1; + + _audio_set_wb_amr_callback(callback_data, enable); + + return 0; +} + +static int ril_connect_if_required(struct ril_handle *ril) +{ + if (_ril_is_connected(ril->client)) + return 0; + + if (_ril_connect(ril->client) != RIL_CLIENT_ERR_SUCCESS) { + ALOGE("ril_connect() failed"); + return -1; + } + + /* get wb amr status to set pcm samplerate depending on + wb amr status when ril is connected. */ + if(_ril_get_wb_amr) + _ril_get_wb_amr(ril->client, ril_set_wb_amr_callback); + + return 0; +} + +int ril_open(struct ril_handle *ril) +{ + char property[PROPERTY_VALUE_MAX]; + + if (!ril) + return -1; + + ril->handle = dlopen(RIL_CLIENT_LIBPATH, RTLD_NOW); + + if (!ril->handle) { + ALOGE("Cannot open '%s'", RIL_CLIENT_LIBPATH); + return -1; + } + + _ril_open_client = dlsym(ril->handle, "OpenClient_RILD"); + _ril_close_client = dlsym(ril->handle, "CloseClient_RILD"); + _ril_connect = dlsym(ril->handle, "Connect_RILD"); + _ril_is_connected = dlsym(ril->handle, "isConnected_RILD"); + _ril_disconnect = dlsym(ril->handle, "Disconnect_RILD"); + _ril_set_call_volume = dlsym(ril->handle, "SetCallVolume"); + _ril_set_call_audio_path = dlsym(ril->handle, "SetCallAudioPath"); + _ril_set_call_clock_sync = dlsym(ril->handle, "SetCallClockSync"); + _ril_register_unsolicited_handler = dlsym(ril->handle, + "RegisterUnsolicitedHandler"); + /* since this function is not supported in all RILs, don't require it */ + _ril_get_wb_amr = dlsym(ril->handle, "GetWB_AMR"); + + if (!_ril_open_client || !_ril_close_client || !_ril_connect || + !_ril_is_connected || !_ril_disconnect || !_ril_set_call_volume || + !_ril_set_call_audio_path || !_ril_set_call_clock_sync || + !_ril_register_unsolicited_handler) { + ALOGE("Cannot get symbols from '%s'", RIL_CLIENT_LIBPATH); + dlclose(ril->handle); + return -1; + } + + ril->client = _ril_open_client(); + if (!ril->client) { + ALOGE("ril_open_client() failed"); + dlclose(ril->handle); + return -1; + } + + /* register the wideband AMR callback */ + _ril_register_unsolicited_handler(ril->client, RIL_UNSOL_WB_AMR_STATE, + ril_set_wb_amr_callback); + + property_get(VOLUME_STEPS_PROPERTY, property, VOLUME_STEPS_DEFAULT); + ril->volume_steps_max = atoi(property); + /* this catches the case where VOLUME_STEPS_PROPERTY does not contain + an integer */ + if (ril->volume_steps_max == 0) + ril->volume_steps_max = atoi(VOLUME_STEPS_DEFAULT); + + return 0; +} + +int ril_close(struct ril_handle *ril) +{ + if (!ril || !ril->handle || !ril->client) + return -1; + + if ((_ril_disconnect(ril->client) != RIL_CLIENT_ERR_SUCCESS) || + (_ril_close_client(ril->client) != RIL_CLIENT_ERR_SUCCESS)) { + ALOGE("ril_disconnect() or ril_close_client() failed"); + return -1; + } + + dlclose(ril->handle); + return 0; +} + +int ril_set_call_volume(struct ril_handle *ril, enum ril_sound_type sound_type, + float volume) +{ + if (ril_connect_if_required(ril)) + return 0; + + return _ril_set_call_volume(ril->client, sound_type, + (int)(volume * ril->volume_steps_max)); +} + +int ril_set_call_audio_path(struct ril_handle *ril, enum ril_audio_path path) +{ + if (ril_connect_if_required(ril)) + return 0; + + return _ril_set_call_audio_path(ril->client, path); +} + +int ril_set_call_clock_sync(struct ril_handle *ril, enum ril_clock_state state) +{ + if (ril_connect_if_required(ril)) + return 0; + + return _ril_set_call_clock_sync(ril->client, state); +} diff --git a/audio/ril_interface.h b/audio/ril_interface.h new file mode 100755 index 0000000..676772c --- /dev/null +++ b/audio/ril_interface.h @@ -0,0 +1,72 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * 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. + */ + +#ifndef RIL_INTERFACE_H +#define RIL_INTERFACE_H + +#define RIL_CLIENT_LIBPATH "libsecril-client.so" + +#define RIL_CLIENT_ERR_SUCCESS 0 +#define RIL_CLIENT_ERR_AGAIN 1 +#define RIL_CLIENT_ERR_INIT 2 // Client is not initialized +#define RIL_CLIENT_ERR_INVAL 3 // Invalid value +#define RIL_CLIENT_ERR_CONNECT 4 // Connection error +#define RIL_CLIENT_ERR_IO 5 // IO error +#define RIL_CLIENT_ERR_RESOURCE 6 // Resource not available +#define RIL_CLIENT_ERR_UNKNOWN 7 + +#define RIL_OEM_UNSOL_RESPONSE_BASE 11000 // RIL response base index +#define RIL_UNSOL_WB_AMR_STATE \ + (RIL_OEM_UNSOL_RESPONSE_BASE + 17) // RIL AMR state index + +struct ril_handle +{ + void *handle; + void *client; + int volume_steps_max; +}; + +enum ril_sound_type { + SOUND_TYPE_VOICE, + SOUND_TYPE_SPEAKER, + SOUND_TYPE_HEADSET, + SOUND_TYPE_BTVOICE +}; + +enum ril_audio_path { + SOUND_AUDIO_PATH_HANDSET, + SOUND_AUDIO_PATH_HEADSET, + SOUND_AUDIO_PATH_SPEAKER, + SOUND_AUDIO_PATH_BLUETOOTH, + SOUND_AUDIO_PATH_BLUETOOTH_NO_NR, + SOUND_AUDIO_PATH_HEADPHONE +}; + +enum ril_clock_state { + SOUND_CLOCK_STOP, + SOUND_CLOCK_START +}; + +/* Function prototypes */ +int ril_open(struct ril_handle *ril); +int ril_close(struct ril_handle *ril); +int ril_set_call_volume(struct ril_handle *ril, enum ril_sound_type sound_type, + float volume); +int ril_set_call_audio_path(struct ril_handle *ril, enum ril_audio_path path); +int ril_set_call_clock_sync(struct ril_handle *ril, enum ril_clock_state state); +void ril_register_set_wb_amr_callback(void *function, void *data); +#endif + diff --git a/bluetooth/bdroid_buildcfg.h b/bluetooth/bdroid_buildcfg.h new file mode 100755 index 0000000..41d14f3 --- /dev/null +++ b/bluetooth/bdroid_buildcfg.h @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * Copyright (C) 2012 The CyanogenMod Project + * + * 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. + */ + +#ifndef _BDROID_BUILDCFG_H +#define _BDROID_BUILDCFG_H + +#define BTM_DEF_LOCAL_NAME "Galaxy Note 8.0" + +#endif diff --git a/bluetooth/vnd_n5110.txt b/bluetooth/vnd_n5110.txt new file mode 100755 index 0000000..670fbc7 --- /dev/null +++ b/bluetooth/vnd_n5110.txt @@ -0,0 +1,14 @@ +BLUETOOTH_UART_DEVICE_PORT = "/dev/ttySAC0" +FW_PATCHFILE_LOCATION = "/system/bin" +LPM_IDLE_TIMEOUT_MULTIPLE = 5 +BTVND_DBG = FALSE +BTHW_DBG = TRUE +VNDUSERIAL_DBG = FALSE +UPIO_DBG = FALSE +UART_TARGET_BAUD_RATE = 3000000 +FW_PATCH_SETTLEMENT_DELAY_MS = 50 +SCO_USE_I2S_INTERFACE = TRUE +SCO_I2SPCM_IF_MODE = 1 +SCO_I2SPCM_IF_ROLE = 0 +SCO_I2SPCM_IF_SAMPLE_RATE = 0 +SCO_I2SPCM_IF_CLOCK_RATE = 1 diff --git a/cm.dependencies b/cm.dependencies new file mode 100644 index 0000000..a78a94f --- /dev/null +++ b/cm.dependencies @@ -0,0 +1,18 @@ +[ + { + "repository": "android_device_samsung_smdk4412-common", + "target_path": "device/samsung/smdk4412-common" + }, + { + "repository": "android_kernel_samsung_smdk4412", + "target_path": "kernel/samsung/smdk4412" + }, + { + "repository": "android_packages_apps_SamsungServiceMode", + "target_path": "packages/apps/SamsungServiceMode" + }, + { + "repository": "android_hardware_samsung", + "target_path": "hardware/samsung" + } +] diff --git a/cm.mk b/cm.mk new file mode 100644 index 0000000..572b0e1 --- /dev/null +++ b/cm.mk @@ -0,0 +1,21 @@ +# Specify phone tech before including full_phone +$(call inherit-product, vendor/cm/config/cdma.mk) + +# Release name +PRODUCT_RELEASE_NAME := n5110 + +# Inherit some common CM stuff. +$(call inherit-product, vendor/cm/config/common_full_tablet_wifionly.mk) + +# Inherit device configuration +$(call inherit-product, device/samsung/n5110/full_n5110.mk) + +# Device identifier. This must come after all inclusions +PRODUCT_DEVICE := n5110 +PRODUCT_NAME := cm_n5110 +PRODUCT_BRAND := samsung +PRODUCT_MODEL := GT-N5110 +PRODUCT_MANUFACTURER := samsung + +# Set build fingerprint / ID / Product Name ect. +PRODUCT_BUILD_PROP_OVERRIDES += PRODUCT_NAME=konawifixx TARGET_DEVICE=konawifi BUILD_FINGERPRINT="samsung/konawifixx/konawifi:4.1.2/JZO54K/N5110XXBMF2:user/release-keys" PRIVATE_BUILD_DESC="konawifixx-user 4.1.2 JZO54K N5110XXBMF2 release-keys" diff --git a/configs/Android.mk b/configs/Android.mk new file mode 100644 index 0000000..c0d0384 --- /dev/null +++ b/configs/Android.mk @@ -0,0 +1,12 @@ +LOCAL_PATH := $(call my-dir) + +include $(CLEAR_VARS) +LOCAL_MODULE := tiny_hw +LOCAL_MODULE_OWNER := samsung +LOCAL_SRC_FILES := tiny_hw.xml +LOCAL_MODULE_TAGS := optional +LOCAL_MODULE_CLASS := ETC +LOCAL_MODULE_SUFFIX := .xml +LOCAL_MODULE_PATH := $(TARGET_OUT)/etc/sound +include $(BUILD_PREBUILT) + diff --git a/configs/audio_policy.conf b/configs/audio_policy.conf new file mode 100644 index 0000000..3a0a14c --- /dev/null +++ b/configs/audio_policy.conf @@ -0,0 +1,82 @@ +# Global configuration section: lists input and output devices always present on the device +# as well as the output device selected by default. +# Devices are designated by a string that corresponds to the enum in audio.h + +global_configuration { + attached_output_devices AUDIO_DEVICE_OUT_SPEAKER + default_output_device AUDIO_DEVICE_OUT_SPEAKER + attached_input_devices AUDIO_DEVICE_IN_BUILTIN_MIC +} + +# audio hardware module section: contains descriptors for all audio hw modules present on the +# device. Each hw module node is named after the corresponding hw module library base name. +# For instance, "primary" corresponds to audio.primary..so. +# The "primary" module is mandatory and must include at least one output with +# AUDIO_OUTPUT_FLAG_PRIMARY flag. +# Each module descriptor contains one or more output profile descriptors and zero or more +# input profile descriptors. Each profile lists all the parameters supported by a given output +# or input stream category. +# The "channel_masks", "formats", "devices" and "flags" are specified using strings corresponding +# to enums in audio.h and audio_policy.h. They are concatenated by use of "|" without space or "\n". + +audio_hw_modules { + primary { + outputs { + primary { + sampling_rates 44100|48000 + channel_masks AUDIO_CHANNEL_OUT_STEREO + formats AUDIO_FORMAT_PCM_16_BIT + devices AUDIO_DEVICE_OUT_SPEAKER|AUDIO_DEVICE_OUT_WIRED_HEADSET|AUDIO_DEVICE_OUT_WIRED_HEADPHONE|AUDIO_DEVICE_OUT_ALL_SCO|AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET + flags AUDIO_OUTPUT_FLAG_PRIMARY + } + deep_buffer { + sampling_rates 44100 + channel_masks AUDIO_CHANNEL_OUT_STEREO + formats AUDIO_FORMAT_PCM_16_BIT + devices AUDIO_DEVICE_OUT_SPEAKER|AUDIO_DEVICE_OUT_WIRED_HEADSET|AUDIO_DEVICE_OUT_WIRED_HEADPHONE + flags AUDIO_OUTPUT_FLAG_DEEP_BUFFER + } + hdmi { + sampling_rates 44100|48000 + channel_masks dynamic + formats AUDIO_FORMAT_PCM_16_BIT + devices AUDIO_DEVICE_OUT_AUX_DIGITAL + flags AUDIO_OUTPUT_FLAG_DIRECT + } + } + inputs { + primary { + sampling_rates 8000|11025|16000|22050|24000|32000|44100|48000 + channel_masks AUDIO_CHANNEL_IN_MONO|AUDIO_CHANNEL_IN_STEREO + formats AUDIO_FORMAT_PCM_16_BIT + devices AUDIO_DEVICE_IN_BUILTIN_MIC|AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET|AUDIO_DEVICE_IN_WIRED_HEADSET + } + } + } + a2dp { + outputs { + a2dp { + sampling_rates 44100 + channel_masks AUDIO_CHANNEL_OUT_STEREO + formats AUDIO_FORMAT_PCM_16_BIT + devices AUDIO_DEVICE_OUT_ALL_A2DP + } + } + } + usb { + outputs { + usb_accessory { + sampling_rates 44100 + channel_masks AUDIO_CHANNEL_OUT_STEREO + formats AUDIO_FORMAT_PCM_16_BIT + devices AUDIO_DEVICE_OUT_USB_ACCESSORY + } + usb_device { + sampling_rates 44100 + channel_masks AUDIO_CHANNEL_OUT_STEREO + formats AUDIO_FORMAT_PCM_16_BIT + devices AUDIO_DEVICE_OUT_USB_DEVICE + } + } + } +} diff --git a/configs/gps.xml b/configs/gps.xml new file mode 100644 index 0000000..38f16ad --- /dev/null +++ b/configs/gps.xml @@ -0,0 +1,72 @@ + + + + + + + + + + + diff --git a/configs/nvram_mfg.txt b/configs/nvram_mfg.txt new file mode 100644 index 0000000..efb5cad --- /dev/null +++ b/configs/nvram_mfg.txt @@ -0,0 +1,146 @@ +# Kona Rev0.1 2012.10.29-TSSI + +manfid=0x2d0 +prodid=0x05de +vendid=0x14e4 +devid=0x4380 +boardtype=0x05de +boardrev=0x1205 +boardnum=22 +macaddr=00:90:4c:c5:12:38 +sromrev=3 +#boardflags: 5GHz FEM: has ext 5GHz PA + LNA +# 2.4GHz FEM: has ext 2.4GHz PA + SP3T +# 2.4GHz FEM: SP3T switch share with BT +# keep original 0x200 +boardflags=0x10081a01 +xtalfreq=37400 +nocrc=1 +ag0=0 +aa2g=1 +ccode=ALL +pa0itssit=0x20 +#PA parameters for 2.4GHz-10/29 R01 TSSI +pa0b0=0x141E +pa0b1=0xFD89 +pa0b2=0xFF57 + +tssifloor2g=30 +extpagain2g=2 +extpagain5g=2 + +# rssi params for 2.4GHz +rssismf2g=0xf +rssismc2g=0x8 +rssisav2g=0x1 +# rssi params(RFMD) for 2.4GHz +#rssismf2g=0x3 +#rssismc2g=0xa +#rssisav2g=0x1 + +cckPwrOffset=3 +cckdigfilttype=24 +#PwrOffset40mhz2g=-10 +# rssi params for 5GHz +rssismf5g=0xf +rssismc5g=0x7 +rssisav5g=0x1 +#PA parameters for lower a-band-10/29 R01 TSSI +pa1lob0=0x1A12 +pa1lob1=0xFCE0 +pa1lob2=0xFF53 +tssifloor5gl=30 +#PA parameters for midband-10/29 R01 TSSI +pa1b0=0x1B2F +pa1b1=0xFCBB +pa1b2=0xFF4E +tssifloor5gm=30 +#PA paramasdeters for high band-10/29 R01 TSSI +pa1hib0=0x1BDC +pa1hib1=0xFCA3 +pa1hib2=0xFF4B +tssifloor5gh=30 +rxpo5g=0 +maxp2ga0=72 +# 2GTxPwr Backoff +ofdm2gpo=0x66666666 +mcs2gpo0=0x8888 +mcs2gpo1=0x8888 +maxp5ga0=62 +maxp5gla0=58 +maxp5gha0=54 +# 5GTxPwr Backoff +ofdm5gpo=0x33333333 +ofdm5glpo=0x33333333 +ofdm5ghpo=0x33333333 +mcs5gpo0=0x4444 +mcs5gpo1=0x4444 +mcs5glpo0=0x4444 +mcs5glpo1=0x4444 +mcs5ghpo0=0x4444 +mcs5ghpo1=0x4444 +# 5GTxPwr HT40 Backoff +mcs5gpo2=0x6666 +mcs5gpo3=0x6666 +mcs5glpo2=0x6666 +mcs5glpo3=0x6666 +mcs5ghpo2=0x6666 +mcs5ghpo3=0x6666 +# 4334B1FCBGA -16, 4334B2FCBGA 4, 4334B2WLBGA -7 +PwrOffset40mhz5g=-1 + +#ofdmdigfilttype=3 +ofdmdigfilttype2g=3 +ofdmdigfilttype5g=3 +#ofdm40digfilttype=5 -8/21-comment out + +il0macaddr=00:90:4c:c5:12:38 +wl0id=0x431b +pagc2g=0x10 + +# Parameters for DAC2x mode and ALPF bypass +dacrate2xen=1 +txalpfbyp=1 +txalpfpu=1 + +#Murata 2G & 5G FEM switch control table +swctrlmap_2g=0x00400040,0x06060606,0x02020202,0x10302,0x1ff +swctrlmap_5g=0x08080808,0x30303030,0x10101010,0x10302,0x2f8 + +#elna_off_gain_idx_2g=32 +#elna_off_gain_idx_5g=TBD +gain=32 +triso2g=8 +triso5g=7 + +muxenab=0x10 +dacpu.fab.4=1 + +aci_detect_en_2g=1 + +#EPA_or_PAD_lpbck5g=1 +lpbckmode5g=1 +txiqlopapu5g=0 +iqcalidx5g=50 +txiqlopapu2g=0 +dlorange_lowlimit=5 +loflag=1 + +###iqlocalidx5g=50 +###iqlocalidx5g=70 75 80 +iqlocalidx5g=45 + +### dlocalidx5g should be greater than iqlocalidx5g by at least 20 index steps +###dlocalidx5g=90 +dlocalidx5g=65 + +#gain_settle_dly_2g=4 +gain_settle_dly_5g=4 +#noise_cal_po_2g=-1 +#noise_cal_po_40_2g=-1 +#noise_cal_high_gain_2g=73 +#noise_cal_nf_substract_val_2g=346 +noise_cal_po_5g=-1 +noise_cal_po_40_5g=-1 +noise_cal_high_gain_5g=73 +noise_cal_nf_substract_val_5g=346 diff --git a/configs/nvram_mfg.txt_murata b/configs/nvram_mfg.txt_murata new file mode 100644 index 0000000..a5e7448 --- /dev/null +++ b/configs/nvram_mfg.txt_murata @@ -0,0 +1,145 @@ +# Kona Emual Rev0.3 2012.08.21-TSSI + +manfid=0x2d0 +prodid=0x05de +vendid=0x14e4 +devid=0x4380 +boardtype=0x05de +boardrev=0x1205 +boardnum=22 +macaddr=00:90:4c:c5:12:38 +sromrev=3 +#boardflags: 5GHz FEM: has ext 5GHz PA + LNA +# 2.4GHz FEM: has ext 2.4GHz PA + SP3T +# 2.4GHz FEM: SP3T switch share with BT +# keep original 0x200 +boardflags=0x10081a01 +xtalfreq=37400 +nocrc=1 +ag0=0 +aa2g=1 +ccode=ALL +pa0itssit=0x20 +#PA parameters for 2.4GHz-8/21 TSSI +pa0b0=0x14B6 +pa0b1=0xFD8C +pa0b2=0xFF5E + +tssifloor2g=30 +extpagain2g=2 +extpagain5g=2 + +# rssi params for 2.4GHz +rssismf2g=0xf +rssismc2g=0x8 +rssisav2g=0x1 +# rssi params(RFMD) for 2.4GHz +#rssismf2g=0x3 +#rssismc2g=0xa +#rssisav2g=0x1 + +cckPwrOffset=3 +cckdigfilttype=24 +#PwrOffset40mhz2g=-10 +# rssi params for 5GHz +rssismf5g=0xf +rssismc5g=0x7 +rssisav5g=0x1 +#PA parameters for lower a-band-8/21 TSSI +pa1lob0=0x1AF2 +pa1lob1=0xFCC8 +pa1lob2=0xFF52 +tssifloor5gl=30 +#PA parameters for midband-8/21 TSSI +pa1b0=0x1AA0 +pa1b1=0xFCC9 +pa1b2=0xFF45 +tssifloor5gm=30 +#PA paramasdeters for high band-8/21 TSSI +pa1hib0=0x1D27 +pa1hib1=0xFC8E +pa1hib2=0xFF59 +tssifloor5gh=30 +rxpo5g=0 +maxp2ga0=72 +# 2GTxPwr Backoff +ofdm2gpo=0x66666666 +mcs2gpo0=0x8888 +mcs2gpo1=0x8888 +maxp5ga0=66 +maxp5gla0=66 +maxp5gha0=66 +# 5GTxPwr Backoff +ofdm5gpo=0x33333333 +ofdm5glpo=0x33333333 +ofdm5ghpo=0x33333333 +mcs5gpo0=0x4444 +mcs5gpo1=0x4444 +mcs5glpo0=0x4444 +mcs5glpo1=0x4444 +mcs5ghpo0=0x4444 +mcs5ghpo1=0x4444 +# 5GTxPwr HT40 Backoff +mcs5gpo2=0x6666 +mcs5gpo3=0x6666 +mcs5glpo2=0x6666 +mcs5glpo3=0x6666 +mcs5ghpo2=0x6666 +mcs5ghpo3=0x6666 +# 4334B1FCBGA -16, 4334B2FCBGA 4, 4334B2WLBGA -7 +PwrOffset40mhz5g=-7 + +#ofdmdigfilttype=3 +ofdmdigfilttype2g=3 +ofdmdigfilttype5g=3 +#ofdm40digfilttype=5 -8/21-comment out + +il0macaddr=00:90:4c:c5:12:38 +wl0id=0x431b +pagc2g=0x10 + +# Parameters for DAC2x mode and ALPF bypass +dacrate2xen=1 +txalpfbyp=1 +txalpfpu=1 + +#Murata 2G & 5G FEM switch control table +swctrlmap_2g=0x00400040,0x06060606,0x02020202,0x10302,0x1ff +swctrlmap_5g=0x08080808,0x30303030,0x10101010,0x10302,0x2f8 + +elna_off_gain_idx_2g=32 +#elna_off_gain_idx_5g=TBD +triso2g=8 +triso5g=7 + +muxenab=0x10 +dacpu.fab.4=1 + +aci_detect_en_2g=1 + +#EPA_or_PAD_lpbck5g=1 +lpbckmode5g=1 +txiqlopapu5g=0 +iqcalidx5g=50 +txiqlopapu2g=0 +dlorange_lowlimit=5 +loflag=1 + +###iqlocalidx5g=50 +###iqlocalidx5g=70 75 80 +iqlocalidx5g=45 + +### dlocalidx5g should be greater than iqlocalidx5g by at least 20 index steps +###dlocalidx5g=90 +dlocalidx5g=65 + +gain_settle_dly_2g=4 +gain_settle_dly_5g=4 +noise_cal_po_2g=-1 +noise_cal_po_40_2g=-1 +noise_cal_high_gain_2g=73 +noise_cal_nf_substract_val_2g=346 +noise_cal_po_5g=-1 +noise_cal_po_40_5g=-1 +noise_cal_high_gain_5g=73 +noise_cal_nf_substract_val_5g=346 diff --git a/configs/nvram_net.txt b/configs/nvram_net.txt new file mode 100644 index 0000000..e35db20 --- /dev/null +++ b/configs/nvram_net.txt @@ -0,0 +1,152 @@ +# Kona Rev0.1 2012.10.29-TSSI + +manfid=0x2d0 +prodid=0x05de +vendid=0x14e4 +devid=0x4380 +boardtype=0x05de +boardrev=0x1205 +boardnum=22 +macaddr=00:90:4c:c5:12:38 +sromrev=3 +#boardflags: 5GHz FEM: has ext 5GHz PA + LNA +# 2.4GHz FEM: has ext 2.4GHz PA + SP3T +# 2.4GHz FEM: SP3T switch share with BT +# keep original 0x200 +boardflags=0x10081a01 +xtalfreq=37400 +nocrc=1 +ag0=0 +aa2g=1 +ccode=GB +pa0itssit=0x20 +#PA parameters for 2.4GHz-10/29 R01 TSSI +pa0b0=0x141E +pa0b1=0xFD89 +pa0b2=0xFF57 + +tssifloor2g=30 +extpagain2g=2 +extpagain5g=2 + +# rssi params for 2.4GHz +rssismf2g=0xf +rssismc2g=0x8 +rssisav2g=0x1 +# rssi params(RFMD) for 2.4GHz +#rssismf2g=0x3 +#rssismc2g=0xa +#rssisav2g=0x1 + +cckPwrOffset=3 +cckdigfilttype=24 +#PwrOffset40mhz2g=-10 +# rssi params for 5GHz +rssismf5g=0xf +rssismc5g=0x7 +rssisav5g=0x1 +#PA parameters for lower a-band-10/29 R01 TSSI +pa1lob0=0x1A12 +pa1lob1=0xFCE0 +pa1lob2=0xFF53 +tssifloor5gl=30 +#PA parameters for midband-10/29 R01 TSSI +pa1b0=0x1B2F +pa1b1=0xFCBB +pa1b2=0xFF4E +tssifloor5gm=30 +#PA paramasdeters for high band-10/29 R01 TSSI +pa1hib0=0x1BDC +pa1hib1=0xFCA3 +pa1hib2=0xFF4B +tssifloor5gh=30 +rxpo5g=0 +maxp2ga0=72 +# 2GTxPwr Backoff +ofdm2gpo=0x66666666 +mcs2gpo0=0x8888 +mcs2gpo1=0x8888 +maxp5ga0=62 +maxp5gla0=58 +maxp5gha0=54 +# 5GTxPwr Backoff +ofdm5gpo=0x33333333 +ofdm5glpo=0x33333333 +ofdm5ghpo=0x33333333 +mcs5gpo0=0x4444 +mcs5gpo1=0x4444 +mcs5glpo0=0x4444 +mcs5glpo1=0x4444 +mcs5ghpo0=0x4444 +mcs5ghpo1=0x4444 +# 5GTxPwr HT40 Backoff +mcs5gpo2=0x6666 +mcs5gpo3=0x6666 +mcs5glpo2=0x6666 +mcs5glpo3=0x6666 +mcs5ghpo2=0x6666 +mcs5ghpo3=0x6666 +# 4334B1FCBGA -16, 4334B2FCBGA 4, 4334B2WLBGA -7 +PwrOffset40mhz5g=-1 + +#ofdmdigfilttype=3 +ofdmdigfilttype2g=3 +ofdmdigfilttype5g=3 +#ofdm40digfilttype=5 -8/21-comment out + +il0macaddr=00:90:4c:c5:12:38 +wl0id=0x431b +pagc2g=0x10 + +# Parameters for DAC2x mode and ALPF bypass +dacrate2xen=1 +txalpfbyp=1 +txalpfpu=1 + +#Murata 2G & 5G FEM switch control table +swctrlmap_2g=0x00400040,0x06060606,0x02020202,0x10302,0x1ff +swctrlmap_5g=0x08080808,0x30303030,0x10101010,0x10302,0x2f8 + +#elna_off_gain_idx_2g=32 +#elna_off_gain_idx_5g=TBD +gain=32 +triso2g=8 +triso5g=7 + +muxenab=0x10 +dacpu.fab.4=1 + +aci_detect_en_2g=1 + +#EPA_or_PAD_lpbck5g=1 +lpbckmode5g=1 +txiqlopapu5g=0 +iqcalidx5g=50 +txiqlopapu2g=0 +dlorange_lowlimit=5 +loflag=1 + +###iqlocalidx5g=50 +###iqlocalidx5g=70 75 80 +iqlocalidx5g=45 + +### dlocalidx5g should be greater than iqlocalidx5g by at least 20 index steps +###dlocalidx5g=90 +dlocalidx5g=65 + +#gain_settle_dly_2g=4 +gain_settle_dly_5g=4 +#noise_cal_po_2g=-1 +#noise_cal_po_40_2g=-1 +#noise_cal_high_gain_2g=73 +#noise_cal_nf_substract_val_2g=346 +noise_cal_po_5g=-1 +noise_cal_po_40_5g=-1 +noise_cal_high_gain_5g=73 +noise_cal_nf_substract_val_5g=346 + +# BT / WIFI coex parameter + +btc_params80=0 +btc_params6=10 +btc_params95=53 \ No newline at end of file diff --git a/configs/nvram_net.txt_murata b/configs/nvram_net.txt_murata new file mode 100644 index 0000000..e8ecdad --- /dev/null +++ b/configs/nvram_net.txt_murata @@ -0,0 +1,156 @@ +# Kona Emual Rev0.3 2012.08.21-TSSI + +manfid=0x2d0 +prodid=0x05de +vendid=0x14e4 +devid=0x4380 +boardtype=0x05de +boardrev=0x1205 +boardnum=22 +macaddr=00:90:4c:c5:12:38 +sromrev=3 +#boardflags: 5GHz FEM: has ext 5GHz PA + LNA +# 2.4GHz FEM: has ext 2.4GHz PA + SP3T +# 2.4GHz FEM: SP3T switch share with BT +# keep original 0x200 +boardflags=0x10081a01 +xtalfreq=37400 +nocrc=1 +ag0=0 +aa2g=1 +ccode=XZ +regrev=11 +pa0itssit=0x20 +#PA parameters for 2.4GHz-8/21 TSSI +pa0b0=0x14B6 +pa0b1=0xFD8C +pa0b2=0xFF5E + +tssifloor2g=30 +extpagain2g=2 +extpagain5g=2 + +# rssi params for 2.4GHz +rssismf2g=0xf +rssismc2g=0x8 +rssisav2g=0x1 +# rssi params(RFMD) for 2.4GHz +#rssismf2g=0x3 +#rssismc2g=0xa +#rssisav2g=0x1 + +cckPwrOffset=3 +cckdigfilttype=24 +#PwrOffset40mhz2g=-10 +# rssi params for 5GHz +rssismf5g=0xf +rssismc5g=0x7 +rssisav5g=0x1 +#PA parameters for lower a-band-8/21 TSSI +pa1lob0=0x1AF2 +pa1lob1=0xFCC8 +pa1lob2=0xFF52 +tssifloor5gl=30 +#PA parameters for midband-8/21 TSSI +pa1b0=0x1AA0 +pa1b1=0xFCC9 +pa1b2=0xFF45 +tssifloor5gm=30 +#PA paramasdeters for high band-8/21 TSSI +pa1hib0=0x1D27 +pa1hib1=0xFC8E +pa1hib2=0xFF59 +tssifloor5gh=30 +rxpo5g=0 +maxp2ga0=72 +# 2GTxPwr Backoff +ofdm2gpo=0x66666666 +mcs2gpo0=0x8888 +mcs2gpo1=0x8888 +maxp5ga0=66 +maxp5gla0=66 +maxp5gha0=66 +# 5GTxPwr Backoff +ofdm5gpo=0x33333333 +ofdm5glpo=0x33333333 +ofdm5ghpo=0x33333333 +mcs5gpo0=0x4444 +mcs5gpo1=0x4444 +mcs5glpo0=0x4444 +mcs5glpo1=0x4444 +mcs5ghpo0=0x4444 +mcs5ghpo1=0x4444 +# 5GTxPwr HT40 Backoff +mcs5gpo2=0x6666 +mcs5gpo3=0x6666 +mcs5glpo2=0x6666 +mcs5glpo3=0x6666 +mcs5ghpo2=0x6666 +mcs5ghpo3=0x6666 +# 4334B1FCBGA -16, 4334B2FCBGA 4, 4334B2WLBGA -7 +PwrOffset40mhz5g=-7 + +#ofdmdigfilttype=3 +ofdmdigfilttype2g=3 +ofdmdigfilttype5g=3 +#ofdm40digfilttype=5 -8/21-comment out + +il0macaddr=00:90:4c:c5:12:38 +wl0id=0x431b +pagc2g=0x10 + +# Parameters for DAC2x mode and ALPF bypass +dacrate2xen=1 +txalpfbyp=1 +txalpfpu=1 + +#Murata 2G & 5G FEM switch control table +swctrlmap_2g=0x00400040,0x06060606,0x02020202,0x10302,0x1ff +swctrlmap_5g=0x08080808,0x30303030,0x10101010,0x10302,0x2f8 + +elna_off_gain_idx_2g=32 +#elna_off_gain_idx_5g=TBD +triso2g=8 +triso5g=7 + +muxenab=0x10 +dacpu.fab.4=1 + +aci_detect_en_2g=1 + +#EPA_or_PAD_lpbck5g=1 +lpbckmode5g=1 +txiqlopapu5g=0 +iqcalidx5g=50 +txiqlopapu2g=0 +dlorange_lowlimit=5 +loflag=1 + +###iqlocalidx5g=50 +###iqlocalidx5g=70 75 80 +iqlocalidx5g=45 + +### dlocalidx5g should be greater than iqlocalidx5g by at least 20 index steps +###dlocalidx5g=90 +dlocalidx5g=65 + +gain_settle_dly_2g=4 +gain_settle_dly_5g=4 +noise_cal_po_2g=-1 +noise_cal_po_40_2g=-1 +noise_cal_high_gain_2g=73 +noise_cal_nf_substract_val_2g=346 +noise_cal_po_5g=-1 +noise_cal_po_40_5g=-1 +noise_cal_high_gain_5g=73 +noise_cal_nf_substract_val_5g=346 + +# BT / WIFI coex parameter + +btc_params80=0 + +btc_params6=10 + +btc_params95=53 + + diff --git a/configs/tiny_hw.xml b/configs/tiny_hw.xml new file mode 100644 index 0000000..0fe8edf --- /dev/null +++ b/configs/tiny_hw.xml @@ -0,0 +1,316 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/extract-files.sh b/extract-files.sh new file mode 100755 index 0000000..768f8d8 --- /dev/null +++ b/extract-files.sh @@ -0,0 +1,105 @@ +#!/bin/sh + +# Copyright (C) 2013 The CyanogenMod Project +# +# 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. + +# This file is generated by device/common/generate-blob-scripts.sh - DO NOT EDIT + +VENDOR=samsung +DEVICE=i925 + +mkdir -p ../../../vendor/$VENDOR/$DEVICE/proprietary + +adb root +adb wait-for-device + +echo "Pulling proprietary files..." +for FILE in `cat ../$DEVICE/proprietary-files.txt | grep -v ^# | grep -v ^$`; do + DIR=`dirname $FILE` + if [ ! -d ../../../vendor/$VENDOR/$DEVICE/proprietary/$DIR ]; then + mkdir -p ../../../vendor/$VENDOR/$DEVICE/proprietary/$DIR + fi + adb pull /$FILE ../../../vendor/$VENDOR/$DEVICE/proprietary/$FILE +done + + +(cat << EOF) | sed s/__DEVICE__/$DEVICE/g | sed s/__VENDOR__/$VENDOR/g > ../../../vendor/$VENDOR/$DEVICE/$DEVICE-vendor-blobs.mk +# Copyright (C) 2013 The CyanogenMod Project +# +# 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. + +LOCAL_PATH := vendor/__VENDOR__/__DEVICE__ + +PRODUCT_COPY_FILES += \\ +EOF + +LINEEND=" \\" +COUNT=`cat proprietary-files.txt | grep -v ^# | grep -v ^$ | wc -l | awk {'print $1'}` +for FILE in `cat proprietary-files.txt | grep -v ^# | grep -v ^$`; do + COUNT=`expr $COUNT - 1` + if [ $COUNT = "0" ]; then + LINEEND="" + fi + echo " \$(LOCAL_PATH)/proprietary/$FILE:$FILE$LINEEND" >> ../../../vendor/$VENDOR/$DEVICE/$DEVICE-vendor-blobs.mk +done + +(cat << EOF) | sed s/__DEVICE__/$DEVICE/g | sed s/__VENDOR__/$VENDOR/g > ../../../vendor/$VENDOR/$DEVICE/$DEVICE-vendor.mk +# Copyright (C) 2013 The CyanogenMod Project +# +# 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. + +# Pick up overlay for features that depend on non-open-source files +DEVICE_PACKAGE_OVERLAYS += vendor/__VENDOR__/__DEVICE__/overlay + +\$(call inherit-product, vendor/__VENDOR__/__DEVICE__/__DEVICE__-vendor-blobs.mk) +EOF + +(cat << EOF) | sed s/__DEVICE__/$DEVICE/g | sed s/__VENDOR__/$VENDOR/g > ../../../vendor/$VENDOR/$DEVICE/BoardConfigVendor.mk +# Copyright (C) 2013 The CyanogenMod Project +# +# 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. + +EOF + +./../../../device/samsung/p4notelte-common/extract-files.sh diff --git a/full_n5110.mk b/full_n5110.mk new file mode 100644 index 0000000..d3fbc49 --- /dev/null +++ b/full_n5110.mk @@ -0,0 +1,35 @@ +# Copyright (C) 2012 The CyanogenMod Project +# +# 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. + +# +# This file is the build configuration for a full Android +# build for toro hardware. This cleanly combines a set of +# device-specific aspects (drivers) with a device-agnostic +# product configuration (apps). Except for a few implementation +# details, it only fundamentally contains two inherit-product +# lines, full and toro, hence its name. +# + +# Inherit from those products. Most specific first. +$(call inherit-product, $(SRC_TARGET_DIR)/product/full_base.mk) +# This is where we'd set a backup provider if we had one +#$(call inherit-product, device/sample/products/backup_overlay.mk) +$(call inherit-product, device/samsung/n5110/n5110.mk) + +# Discard inherited values and use our own instead. +PRODUCT_NAME := full_n5110 +PRODUCT_DEVICE := n5110 +PRODUCT_BRAND := samsung +PRODUCT_MANUFACTURER := samsung +PRODUCT_MODEL := GT-N5110 diff --git a/n5110.mk b/n5110.mk new file mode 100644 index 0000000..68ca0b1 --- /dev/null +++ b/n5110.mk @@ -0,0 +1,70 @@ +# +# Copyright (C) 2012 The CyanogenMod Project +# +# 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. +# + +LOCAL_PATH := device/samsung/n5110 + +DEVICE_PACKAGE_OVERLAYS += $(LOCAL_PATH)/overlay + +PRODUCT_AAPT_CONFIG := xlarge mdpi +PRODUCT_AAPT_PREF_CONFIG := mdpi + +TARGET_SCREEN_HEIGHT := 1280 +TARGET_SCREEN_WIDTH := 800 + +# Init files +PRODUCT_COPY_FILES += \ + $(LOCAL_PATH)/rootdir/init.smdk4x12.rc:root/init.smdk4x12.rc \ + $(LOCAL_PATH)/rootdir/init.smdk4x12.usb.rc:root/init.smdk4x12.usb.rc \ + $(LOCAL_PATH)/rootdir/ueventd.smdk4x12.rc:root/ueventd.smdk4x12.rc \ + $(LOCAL_PATH)/rootdir/ueventd.smdk4x12.rc:recovery/root/ueventd.smdk4x12.rc \ + $(LOCAL_PATH)/rootdir/lpm.rc:root/lpm.rc \ + $(LOCAL_PATH)/rootdir/fstab.smdk4x12:root/fstab.smdk4x12 + +# Packages +PRODUCT_PACKAGES += \ + tiny_hw \ + libsecril-client \ + DeviceSettings \ + SamsungServiceMode + +PRODUCT_COPY_FILES += \ + $(LOCAL_PATH)/configs/gps.xml:system/etc/gps.xml \ + $(LOCAL_PATH)/configs/nvram_mfg.txt:system/etc/wifi/nvram_mfg.txt \ + $(LOCAL_PATH)/configs/nvram_mfg.txt_murata:system/etc/wifi/nvram_mfg.txt_murata \ + $(LOCAL_PATH)/configs/nvram_net.txt:system/etc/wifi/nvram_net.txt \ + $(LOCAL_PATH)/configs/nvram_net.txt_murata:system/etc/wifi/nvram_net.txt_murata + +# RIL +PRODUCT_PROPERTY_OVERRIDES += \ + mobiledata.interfaces=wlan0 + +# Charger +PRODUCT_PACKAGES += \ + charger \ + charger_res_images + +# These are the hardware-specific features +PRODUCT_COPY_FILES += \ + frameworks/native/data/etc/tablet_core_hardware.xml:system/etc/permissions/tablet_core_hardware.xml + +# Set product characteristic to tablet, needed for some ui elements +PRODUCT_CHARACTERISTICS := tablet + +$(call inherit-product, frameworks/native/build/tablet-10in-xhdpi-2048-dalvik-heap.mk) + +$(call inherit-product, device/samsung/smdk4412-common/common.mk) + +$(call inherit-product-if-exists, vendor/samsung/n5110/n5110-vendor.mk) \ No newline at end of file diff --git a/overlay/device/samsung/smdk4412-common/DeviceSettings/res/values/config.xml b/overlay/device/samsung/smdk4412-common/DeviceSettings/res/values/config.xml new file mode 100644 index 0000000..1da977a --- /dev/null +++ b/overlay/device/samsung/smdk4412-common/DeviceSettings/res/values/config.xml @@ -0,0 +1,28 @@ + + + + + + + + false + + + false + true + + diff --git a/overlay/frameworks/base/core/res/res/values/config.xml b/overlay/frameworks/base/core/res/res/values/config.xml new file mode 100644 index 0000000..76d54b9 --- /dev/null +++ b/overlay/frameworks/base/core/res/res/values/config.xml @@ -0,0 +1,92 @@ + + + + + + + true + + + true + + + true + + true + -1 + 0 + 1 + + + + false + + + false + + + wlan0 + + + + + + wifi,1,1,1,-1,true + bluetooth,7,7,2,-1,true + wifi_p2p,13,1,0,-1,true + + + + + 1,1 + 0,1 + 7,1 + + + + + "rndis0" + + + + 0 + 2 + 3 + 4 + 5 + 10 + 11 + 12 + + + + + + 1 + 7 + + diff --git a/overlay/frameworks/base/core/res/res/xml/power_profile.xml b/overlay/frameworks/base/core/res/res/xml/power_profile.xml new file mode 100644 index 0000000..ad5f292 --- /dev/null +++ b/overlay/frameworks/base/core/res/res/xml/power_profile.xml @@ -0,0 +1,61 @@ + + + + + 0 + 302 + 445.8 + 107.6 + 0.6 + 0.4 + 31.0 + 6.5 + 33.5 + 624.5 + 0.2 + 140.9 + 18.5 + + 4.3 + 4.3 + + + 216000 + 312000 + 456000 + 608000 + 760000 + 816000 + 912000 + 1000000 + + 2.2 + 54.6 + + 100 + 107 + 116 + 123 + 135 + 138 + 142 + 148 + + 4600 + diff --git a/overlay/frameworks/base/core/res/res/xml/storage_list.xml b/overlay/frameworks/base/core/res/res/xml/storage_list.xml new file mode 100644 index 0000000..30c5bd6 --- /dev/null +++ b/overlay/frameworks/base/core/res/res/xml/storage_list.xml @@ -0,0 +1,51 @@ + + + + + + + + + + + + diff --git a/overlay/packages/apps/Browser/res/values/bools.xml b/overlay/packages/apps/Browser/res/values/bools.xml new file mode 100644 index 0000000..3218656 --- /dev/null +++ b/overlay/packages/apps/Browser/res/values/bools.xml @@ -0,0 +1,16 @@ + + + + true + diff --git a/overlay/packages/apps/Camera/res/values/config.xml b/overlay/packages/apps/Camera/res/values/config.xml new file mode 100644 index 0000000..122b4d2 --- /dev/null +++ b/overlay/packages/apps/Camera/res/values/config.xml @@ -0,0 +1,23 @@ + + + + + + false + diff --git a/overlay/packages/apps/Launcher2/res/values/config.xml b/overlay/packages/apps/Launcher2/res/values/config.xml new file mode 100644 index 0000000..22a4ed5 --- /dev/null +++ b/overlay/packages/apps/Launcher2/res/values/config.xml @@ -0,0 +1,18 @@ + + + + true + diff --git a/overlay/packages/apps/Settings/res/values/arrays.xml b/overlay/packages/apps/Settings/res/values/arrays.xml new file mode 100644 index 0000000..3b47031 --- /dev/null +++ b/overlay/packages/apps/Settings/res/values/arrays.xml @@ -0,0 +1,46 @@ + + + + + + 15 seconds + 30 seconds + 1 minute + 2 minutes + 5 minutes + 10 minutes + + + + + + 15000 + + 30000 + + 60000 + + 120000 + + 300000 + + 600000 + + diff --git a/overlay/packages/apps/Settings/res/values/bools.xml b/overlay/packages/apps/Settings/res/values/bools.xml new file mode 100644 index 0000000..2ebd9dd --- /dev/null +++ b/overlay/packages/apps/Settings/res/values/bools.xml @@ -0,0 +1,23 @@ + + + + + + true + + + true + diff --git a/overlay/packages/apps/Settings/res/values/config.xml b/overlay/packages/apps/Settings/res/values/config.xml new file mode 100644 index 0000000..a4a7315 --- /dev/null +++ b/overlay/packages/apps/Settings/res/values/config.xml @@ -0,0 +1,20 @@ + + + + + true + diff --git a/overlay/packages/apps/Torch/res/values/config.xml b/overlay/packages/apps/Torch/res/values/config.xml new file mode 100644 index 0000000..d13de94 --- /dev/null +++ b/overlay/packages/apps/Torch/res/values/config.xml @@ -0,0 +1,36 @@ + + + + + + + false + + + /sys/class/camera/rear/rear_flash + + + 1 + + -1 + + -1 + + diff --git a/proprietary-files.txt b/proprietary-files.txt new file mode 100644 index 0000000..25c0d21 --- /dev/null +++ b/proprietary-files.txt @@ -0,0 +1,3 @@ +system/lib/libril-qc-qmi-1.so +system/lib/libril-qcril-hook-oem.so +system/lib/libril.so diff --git a/recovery.fstab b/recovery.fstab new file mode 100644 index 0000000..d1e7503 --- /dev/null +++ b/recovery.fstab @@ -0,0 +1,12 @@ +# mount point fstype device device2 +/efs ext4 /dev/block/mmcblk0p3 +/boot emmc /dev/block/mmcblk0p5 +/recovery emmc /dev/block/mmcblk0p6 +/cache ext4 /dev/block/mmcblk0p8 +/system ext4 /dev/block/mmcblk0p9 +/data ext4 /dev/block/mmcblk0p12 length=-16384 +/preload ext4 /dev/block/mmcblk0p10 +/modem emmc /dev/block/mmcblk0p7 + +/sdcard datamedia /dev/null +/external_sd vfat /dev/block/mmcblk1p1 fstype2=ext4 diff --git a/res/charger/battery_0.png b/res/charger/battery_0.png new file mode 100644 index 0000000..38b888c Binary files /dev/null and b/res/charger/battery_0.png differ diff --git a/res/charger/battery_1.png b/res/charger/battery_1.png new file mode 100644 index 0000000..03f4226 Binary files /dev/null and b/res/charger/battery_1.png differ diff --git a/res/charger/battery_2.png b/res/charger/battery_2.png new file mode 100644 index 0000000..296959e Binary files /dev/null and b/res/charger/battery_2.png differ diff --git a/res/charger/battery_3.png b/res/charger/battery_3.png new file mode 100644 index 0000000..97a5dfd Binary files /dev/null and b/res/charger/battery_3.png differ diff --git a/res/charger/battery_4.png b/res/charger/battery_4.png new file mode 100644 index 0000000..63865c2 Binary files /dev/null and b/res/charger/battery_4.png differ diff --git a/res/charger/battery_5.png b/res/charger/battery_5.png new file mode 100644 index 0000000..eec62b0 Binary files /dev/null and b/res/charger/battery_5.png differ diff --git a/res/charger/battery_charge.png b/res/charger/battery_charge.png new file mode 100644 index 0000000..c1d2856 Binary files /dev/null and b/res/charger/battery_charge.png differ diff --git a/res/charger/battery_fail.png b/res/charger/battery_fail.png new file mode 100644 index 0000000..9099d02 Binary files /dev/null and b/res/charger/battery_fail.png differ diff --git a/rootdir/fstab.smdk4x12 b/rootdir/fstab.smdk4x12 new file mode 100644 index 0000000..62f53ac --- /dev/null +++ b/rootdir/fstab.smdk4x12 @@ -0,0 +1,11 @@ +# Android fstab file. +# +# The filesystem that contains the filesystem checker binary (typically /system) cannot +# specify MF_CHECK, and must come before any filesystems that do specify MF_CHECK +# data partition must be located at the bottom for supporting device encryption + +/dev/block/mmcblk0p9 /system ext4 ro,errors=panic wait +/dev/block/mmcblk0p3 /efs ext4 nosuid,nodev,noatime,noauto_da_alloc,discard,journal_async_commit,errors=panic wait,check +/dev/block/mmcblk0p8 /cache ext4 nosuid,nodev,noatime,noauto_da_alloc,discard,journal_async_commit,errors=panic wait,check +/dev/block/mmcblk0p12 /data ext4 nosuid,nodev,noatime,noauto_da_alloc,discard,journal_async_commit,errors=panic wait,check,encryptable=footer + diff --git a/rootdir/init.smdk4x12.rc b/rootdir/init.smdk4x12.rc new file mode 100644 index 0000000..f549179 --- /dev/null +++ b/rootdir/init.smdk4x12.rc @@ -0,0 +1,584 @@ +import init.smdk4x12.usb.rc +import init.bt.rc + +on init + mkdir /mnt/shell/emulated 0700 shell shell + mkdir /storage 0550 system sdcard_r + mkdir /storage/emulated 0555 root root + mkdir /storage/sdcard1 0775 system system + mkdir /storage/usbdisk0 0775 system system + + export EXTERNAL_STORAGE /storage/emulated/legacy + export SECONDARY_STORAGE /storage/sdcard1 + export EMULATED_STORAGE_SOURCE /mnt/shell/emulated + export EMULATED_STORAGE_TARGET /storage/emulated + + # for backwards compatibility + symlink /storage/emulated/legacy /sdcard + symlink /storage/emulated/legacy /mnt/sdcard + symlink /storage/emulated/legacy /storage/sdcard0 + symlink /mnt/shell/emulated/0 /storage/emulated/legacy + symlink /storage/sdcard1 /extSdCard + symlink /storage/sdcard1 /mnt/extSdCard + symlink /storage/usbdisk0 /usbdisk0 + symlink /storage/usbdisk0 /mnt/usbdisk0 + + mkdir /efs 0771 radio system + mkdir /tombstones + symlink /efs /factory + + +# ko files for FM Radio + #insmod /system/lib/modules/Si4709_driver.ko + +on init + + # Vibetonz + export VIBE_PIPE_PATH /dev/pipes + mkdir /dev/pipes 0771 shell shell + +on fs + mount_all /fstab.smdk4x12 + + setprop ro.crypto.fuse_sdcard true + + chown radio system /efs + chmod 0771 /efs + +on post-fs-data + # we will remap this as /mnt/sdcard with the sdcard fuse tool + mkdir /data/media 0775 media_rw media_rw + chown media_rw media_rw /data/media + +# for AT distributor + chown system radio /sys/module/cpuidle_exynos4/parameters/enable_mask + chmod 0664 /sys/module/cpuidle_exynos4/parameters/enable_mask + +# data/log + mkdir /data/log 0775 system log + chown system log /data/log + chmod 0775 /data/log + chmod 0775 /data/anr + + # create data/gps for GPS demon + chown root system /dev/ttySAC1 + chmod 0660 /dev/ttySAC1 + chown root system /sys/class/sec/gps/GPS_PWR_EN/value + chmod 0664 /sys/class/sec/gps/GPS_PWR_EN/value + chown root system /sys/class/sec/gps/GPS_nRST/value + chmod 0664 /sys/class/sec/gps/GPS_nRST/value + mkdir /data/gps 771 system system + chown system system /data/gps + + mkdir /data/misc/radio 0775 radio system + chmod 0775 /data/misc/radio + mkdir /efs/imei 0775 radio system + + mkdir /data/local/audio 0775 media audio + chown media audio /data/local/audio + +# HDCP 2.x + mkdir /data/system/hdcp2 0775 system system + +# h2k permission + chmod 0644 /efs/redata.bin + chmod 0644 /efs/h2k.dat + +# Camera firmware + mkdir /data/cfw 0775 system system + chown system media /data/cfw/SlimISP_GK.bin + chmod 0775 /data/cfw/SlimISP_GK.bin + chown system media /data/cfw/SlimISP_ZK.bin + chmod 0775 /data/cfw/SlimISP_ZK.bin + +# Camera + chown system radio /sys/class/camera/rear/rear_camfw + chown system radio /sys/class/camera/rear/rear_camtype + chown system radio /sys/class/camera/rear/rear_flash + chmod 0666 /sys/class/camera/flash/rear_flash + chown system radio /sys/class/camera/rear/isp_core + chown system radio /sys/class/camera/front/front_camfw + chown system radio /sys/class/camera/front/front_camtype + chown system radio /sys/class/camera/flash/rear_flash + chown radio system /sys/devices/platform/samsung-pd.5/s3c-fimc.2/range_mode + chmod 0660 /sys/devices/platform/samsung-pd.5/s3c-fimc.2/range_mode + + symlink /dev/block/mmcblk0p4 /dev/block/param + +# Permissions for bluetooth + setprop ro.bt.bdaddr_path "/efs/bluetooth/bt_addr" + chown bluetooth bluetooth ro.bt.bdaddr_path + chown bluetooth bluetooth /dev/ttySAC0 + chmod 0600 /dev/ttySAC0 + chmod 0660 /sys/class/rfkill/rfkill0/state + chown bluetooth bluetooth /sys/class/rfkill/rfkill0/state + chown bluetooth bluetooth /sys/class/rfkill/rfkill0/type + +# Vibrator + chmod 0660 /dev/tspdrv + chown root shell /dev/tspdrv + chmod 0660 /sys/vibrator/pwm_val + chown system system /sys/vibrator/pwm_val + +# serial keyboard port + chown root system /dev/ttySAC3 + chmod 0660 /dev/ttySAC3 + +# for datarouter + chown system system /dev/dun + chown system system /dev/ttyGS0 + chown system system /dev/ttyGS1 + chown system system /dev/ttyGS2 + chown system system /dev/ttyGS3 + +# NFC + setprop ro.nfc.port "I2C" + chmod 0600 /dev/pn544 + chown nfc nfc /dev/pn544 + +# Permissions for LCD + chown system radio /sys/class/lcd/panel/lcd_type + chown system system /sys/class/backlight/panel/auto_brightness + +# Permissions for mDNIe + chown system media_rw /sys/class/mdnie/mdnie/mode + chown system media_rw /sys/class/mdnie/mdnie/outdoor + chown system media_rw /sys/class/mdnie/mdnie/scenario + chown system system /sys/class/mdnie/mdnie/negative + chown system system /sys/class/mdnie/mdnie/ebook + chown system system /sys/class/mdnie/mdnie/accessibility + write /sys/class/mdnie/mdnie/scenario 0 + write /sys/class/mdnie/mdnie/mode 0 + +# Permissions for Touchkey + chown system radio /sys/class/sec/sec_touchkey/touchkey_dummy_btn1 + chown system radio /sys/class/sec/sec_touchkey/touchkey_dummy_btn3 + chown system radio /sys/class/sec/sec_touchkey/touchkey_dummy_btn5 + chown system radio /sys/class/sec/sec_touchkey/extra_button_event + chown system radio /sys/class/sec/sec_touchkey/touchkey_button_all + chown system radio /sys/class/sec/sec_touchkey/touchkey_threshold + chmod 0660 /sys/class/sec/sec_touchkey/extra_button_event + +# Permissions for Hall IC + chown system radio /sys/class/sec/sec_key/hall_detect + +# Permissions for System Server and daemons. + chown radio system /sys/android_power/state + chown radio system /sys/android_power/request_state + chown radio system /sys/android_power/acquire_full_wake_lock + chown radio system /sys/android_power/acquire_partial_wake_lock + chown radio system /sys/android_power/release_wake_lock + chown radio system /sys/power/state + chown radio system /sys/power/wake_lock + chown radio system /sys/power/wake_unlock + chown radio system /sys/power/cpufreq_table + chown radio system /sys/power/cpufreq_max_limit + chown radio system /sys/power/cpufreq_min_limit + chown radio system /sys/power/mali_lock + chown radio system /sys/class/power_supply/battery/siop_activated + chown radio system /sys/devices/system/cpu/cpufreq/pegasusq/max_cpu_lock + chown radio system /sys/devices/system/cpu/cpufreq/pegasusq/hotplug_lock + chown radio system /sys/devices/system/cpu/busfreq/curr_freq + chown radio system /sys/module/mali/parameters/mali_dvfs_control + chown system radio /sys/bus/platform/devices/s5p-tmu/lot_id + chmod 0660 /sys/power/state + chmod 0660 /sys/power/wake_lock + chmod 0660 /sys/power/wake_unlock + chmod 0660 /sys/power/cpufreq_table + chmod 0660 /sys/power/cpufreq_max_limit + chmod 0660 /sys/power/cpufreq_min_limit + chmod 0660 /sys/power/mali_lock + chmod 0660 /sys/class/power_supply/battery/siop_activated + chmod 0660 /sys/devices/system/cpu/cpufreq/pegasusq/max_cpu_lock + chmod 0660 /sys/devices/system/cpu/cpufreq/pegasusq/hotplug_lock + chmod 0660 /sys/devices/system/cpu/busfreq/curr_freq + chmod 0660 /sys/module/mali/parameters/mali_dvfs_control + chmod 0664 /sys/bus/platform/devices/s5p-tmu/lot_id + chown system system /sys/class/timed_output/vibrator/enable + chown system system /sys/class/leds/keyboard-backlight/brightness + chown system system /sys/class/leds/lcd-backlight/brightness + chown system system /sys/class/backlight/panel/brightness + chown system system /sys/class/leds/button-backlight/brightness + chown system system /sys/class/sec/sec_touchkey/brightness + chown system system /sys/class/leds/jogball-backlight/brightness + chown system system /sys/class/leds/red/brightness + chown system system /sys/class/leds/green/brightness + chown system system /sys/class/leds/blue/brightness + chown system system /sys/class/leds/red/device/grpfreq + chown system system /sys/class/leds/red/device/grppwm + chown system system /sys/class/leds/red/device/blink + chown system system /sys/class/leds/red/brightness + chown system system /sys/class/leds/green/brightness + chown system system /sys/class/leds/blue/brightness + chown system system /sys/class/leds/red/device/grpfreq + chown system system /sys/class/leds/red/device/grppwm + chown system system /sys/class/leds/red/device/blink + chown system system /sys/class/timed_output/vibrator/enable + chown system system /sys/module/sco/parameters/disable_esco + chown system system /sys/kernel/ipv4/tcp_wmem_min + chown system system /sys/kernel/ipv4/tcp_wmem_def + chown system system /sys/kernel/ipv4/tcp_wmem_max + chown system system /sys/kernel/ipv4/tcp_rmem_min + chown system system /sys/kernel/ipv4/tcp_rmem_def + chown system system /sys/kernel/ipv4/tcp_rmem_max + chown root radio /proc/cmdline + +# Audio (Earjack) + chown system radio /sys/class/audio/earjack/select_jack + chown system radio /sys/class/audio/earjack/key_state + chown system radio /sys/class/audio/earjack/state + chown media system /sys/class/audio/earjack/reselect_jack + +# Battery node + chown system radio /sys/class/power_supply/battery/batt_charging_source + chown system radio /sys/class/power_supply/battery/batt_error_test + chown system radio /sys/class/power_supply/battery/batt_lp_charging + chown system radio /sys/class/power_supply/battery/batt_read_adj_soc + chown system radio /sys/class/power_supply/battery/batt_read_raw_soc + chown system radio /sys/class/power_supply/battery/batt_reset_soc + chown system radio /sys/class/power_supply/battery/batt_slate_mode + chown system radio /sys/class/power_supply/battery/batt_temp_adc + chown system radio /sys/class/power_supply/battery/batt_temp_adc_aver + chown system radio /sys/class/power_supply/battery/batt_temp_adc_cal + chown system radio /sys/class/power_supply/battery/batt_temp_aver + chown system radio /sys/class/power_supply/battery/batt_type + chown system radio /sys/class/power_supply/battery/batt_vf_adc + chown system radio /sys/class/power_supply/battery/batt_vfocv + chown system radio /sys/class/power_supply/battery/batt_vol_adc + chown system radio /sys/class/power_supply/battery/batt_vol_adc_aver + chown system radio /sys/class/power_supply/battery/batt_vol_adc_cal + chown system radio /sys/class/power_supply/battery/batt_vol_aver + chown system radio /sys/class/power_supply/battery/factory_mode + chown system radio /sys/class/power_supply/battery/siop_activated + chown system radio /sys/class/power_supply/battery/siop_level + chown system radio /sys/class/power_supply/battery/update + chown system radio /sys/class/power_supply/battery/wc_status + chown system radio /sys/class/power_supply/battery/wpc_pin_state + +# CTIA event + chown sdcard_rw sdcard_rw /sys/class/power_supply/battery/call + chown sdcard_rw sdcard_rw /sys/class/power_supply/battery/video + chown sdcard_rw sdcard_rw /sys/class/power_supply/battery/music + chown sdcard_rw sdcard_rw /sys/class/power_supply/battery/browser + chown sdcard_rw sdcard_rw /sys/class/power_supply/battery/hotspot + chown sdcard_rw sdcard_rw /sys/class/power_supply/battery/camera + chown system radio /sys/class/power_supply/battery/talk_wcdma + chown system radio /sys/class/power_supply/battery/talk_gsm + chown system radio /sys/class/power_supply/battery/call + chown system radio /sys/class/power_supply/battery/data_call + chown gps radio /sys/class/power_supply/battery/gps + chown system radio /sys/class/power_supply/battery/wifi + chown system radio /sys/class/power_supply/battery/lte + +# Thermistor node + chown radio system /sys/devices/platform/sec-thermistor/temp_adc + chown radio system /sys/devices/platform/sec-thermistor/temperature + +# Permissions for touch + chown system radio /sys/class/sec/tsp/cmd + +# Permissions for Touchkey + chown system radio /sys/class/sec/sec_touchkey/enable_disable + chown system radio /sys/class/sec/sec_touchkey/touchkey_brightness + chown system radio /sys/class/sec/sec_touchkey/touchkey_menu + chown system radio /sys/class/sec/sec_touchkey/touchkey_back + chown system radio /sys/class/sec/sec_touchkey/touch_update + chown system radio /sys/class/sec/sec_touchkey/touch_version + chown system radio /sys/class/sec/sec_touchkey/touchkey_firm_version_panel + chown system radio /sys/class/sec/sec_touchkey/touchkey_firm_version_phone + chown system radio /sys/class/sec/sec_touchkey/touchkey_firm_update_status + chown system radio /sys/class/sec/sec_touchkey/touchkey_firm_update + chown system radio /sys/class/sec/sec_touchkey/touch_sensitivity + chown system radio /sys/class/sec/sec_touchkey/touchkey_threshold + chown system system /sys/devices/virtual/sec/sec_touchkey/brightness + +# Permissions for gpio_keys + chown radio system /sys/class/sec/sec_key/wakeup_keys + write /sys/class/sec/sec_key/wakeup_keys 116,172,544 + +# Switch Device + chown system system /sys/class/sec/switch/uart_sel + chown system system /sys/class/sec/switch/usb_sel + chown system system /sys/class/sec/switch/otg_test + chown system radio /sys/class/sec/switch/adc + +# IPC sysfs + chown radio radio /sys/devices/virtual/misc/multipdp/waketime + symlink /dev/block/mmcblk0p7 /dev/mbin0 + +# +# Input Events + chown system input /sys/class/input/input2/enable + chown system input /sys/class/input/input2/poll_delay + chown system input /sys/class/input/input3/enable + chown system input /sys/class/input/input3/poll_delay + chown system input /sys/class/input/input4/enable + chown system input /sys/class/input/input4/poll_delay + chown system input /sys/class/input/input5/enable + chown system input /sys/class/input/input5/poll_delay + chown system input /sys/class/input/input6/enable + chown system input /sys/class/input/input6/poll_delay + chown system input /sys/class/input/input7/enable + chown system input /sys/class/input/input7/poll_delay + chown system input /sys/class/input/input8/enable + chown system input /sys/class/input/input8/poll_delay + chown system input /sys/class/input/input9/enable + chown system input /sys/class/input/input9/poll_delay + chown system input /sys/class/input/input2/delay + chown system input /sys/class/input/input3/delay + chown system input /sys/class/input/input4/delay + chown system input /sys/class/input/input5/delay + chown system input /sys/class/input/input6/delay + chown system input /sys/class/input/input6/delay + chown system input /sys/class/input/input7/delay + chown system input /sys/class/input/input8/delay + chown system input /sys/class/input/input9/delay +# Accelerometer_sensor + chown system radio /dev/accelerometer + chown system radio /sys/class/sensors/accelerometer_sensor + chown system radio /sys/class/sensors/accelerometer_sensor/raw_data + chown system radio /sys/class/sensors/accelerometer_sensor/calibration + chown system radio /sys/class/sensors/accelerometer_sensor/reactive_alert + chown system radio /sys/class/sensors/accelerometer_sensor/vendor + chown system radio /sys/class/sensors/accelerometer_sensor/name +# Proximity_sensor + chown system radio /sys/class/sensors/proximity_sensor/state + chown system radio /sys/class/sensors/proximity_sensor/prox_avg + chown system radio /sys/class/sensors/proximity_sensor/prox_cal + chown system radio /sys/class/sensors/proximity_sensor/vendor + chown system radio /sys/class/sensors/proximity_sensor/name + chown system radio /sys/class/sensors/proximity_sensor/prox_thresh +# Light_sensor + chown system radio /sys/class/sensors/light_sensor/lux + chown system radio /sys/class/sensors/light_sensor/raw_data + chown system radio /sys/class/sensors/light_sensor/vendor + chown system radio /sys/class/sensors/light_sensor/name +# Magnetic_sensor + chmod 0777 /dev/i2c-10 + chown system radio /sys/class/sensors/magnetic_sensor/raw_data + chown system radio /sys/class/sensors/magnetic_sensor/vendor + chown system radio /sys/class/sensors/magnetic_sensor/name + chown compass input /sys/class/input/input6/offsets + chown compass input /sys/class/input/input6/dynamic_matrix + chown system input /sys/class/input/input6/threshold + chown system input /sys/class/input/input6/distortion + chown system input /sys/class/input/input6/shape + write /sys/class/input/input6/distortion "350 50 15" + write /sys/class/input/input6/static_matrix "10602 -980 25 -830 10470 -188 2753 1005 9019" + write /sys/class/input/input6/ellipsoid_mode "1" + + chown system input /sys/class/input/input6/filter_enable + chown system input /sys/class/input/input6/filter_len + chown system input /sys/class/input/input6/data + chown system input /sys/class/input/input6/status + chown system input /sys/class/input/input6/wake + chown system input /sys/class/input/input6/position +# Magnetic_sensor + chown compass input /sys/class/input/input5/offsets + chown compass input /sys/class/input/input5/dynamic_matrix + chown system input /sys/class/input/input5/threshold + chown system input /sys/class/input/input5/distortion + chown system input /sys/class/input/input5/shape + write /sys/class/input/input5/distortion "350 50 15" + write /sys/class/input/input5/static_matrix "10602 -980 25 -830 10470 -188 2753 1005 9019" + write /sys/class/input/input5/ellipsoid_mode "1" + + chown system input /sys/class/input/input5/filter_enable + chown system input /sys/class/input/input5/filter_len + chown system input /sys/class/input/input5/data + chown system input /sys/class/input/input5/status + chown system input /sys/class/input/input5/wake + chown system input /sys/class/input/input5/position + +# NFC + setprop ro.nfc.port "I2C" + chmod 0600 /dev/pn544 + chown nfc nfc /dev/pn544 + +# Vibetonz + chmod 0660 /dev/tspdrv + chown root shell /dev/tspdrv + +# IR_LED + chown system system /sys/class/sec/sec_ir/ir_send + chown system system /sys/class/sec/sec_ir/ir_send_result + +# Permissions for backlight + chown system system /sys/class/backlight/panel/brightness + +# for wifi + mkdir /data/misc/wifi/sockets 0770 wifi wifi + mkdir /data/misc/dhcp 0775 dhcp dhcp + chown dhcp dhcp /data/misc/dhcp + +# for TRP/TIS + write /data/.psm.info 1 + chown system root /data/.psm.info + chmod 0660 /data/.psm.info + + # Set indication (checked by vold) that we have finished this action + setprop vold.post_fs_data_done 1 + +on boot + mount debugfs /sys/kernel/debug /sys/kernel/debug + + setprop ro.build.product smdk4x12 + setprop ro.product.device smdk4x12 + setprop ro.radio.noril yes + setprop wifi.interface wlan0 + +# fake some battery state + setprop status.battery.state Slow + setprop status.battery.level 5 + setprop status.battery.level_raw 50 + setprop status.battery.level_scale 9 + +# wifi display + write /proc/sys/net/core/wmem_max 262144 + + # Set permission for Widevine DRM temporarily + chmod 0777 /dev/s5p-smem + rm /data/app/tlcd_sock + + # make param block device link for SysScope + symlink /dev/block/mmcblk0p7 /dev/block/param + +# touchscreen + chown radio system /sys/class/sec/tsp/cmd + chown media_rw media_rw /sys/class/sec/tsp/set_jitter + +# epen + chown radio system /sys/class/sec/sec_epen/epen_firm_update + chown radio system /sys/class/sec/sec_epen/epen_checksum + chown radio system /sys/class/sec/sec_epen/epen_checksum_result + chown radio system /sys/class/sec/sec_epen/epen_reset + chown system system /sys/class/sec/sec_epen/epen_saving_mode + chmod 660 /sys/class/sec/sec_epen/epen_saving_mode + +# wakeup keys + chown radio system /sys/class/sec/sec_key/wakeup_keys + write /sys/class/sec/sec_key/wakeup_keys 116,172 + +# serial keyboard daemon +service sec_keyboard /system/bin/sec_keyboard /dev/ttySAC3 + class late_start + disabled + group system + +# SISO-ANDR_PERF :: START Changing scheduler to cfq and reseting cpu min freq to -1 after boot complete +on property:sys.boot_completed=1 + write /sys/block/mmcblk0/queue/scheduler cfq + write /sys/power/cpufreq_min_limit -1 +# SISO-ANDR_PERF :: END + +on property:ro.uart_debug=0 + start sec_keyboard + +# create filesystem if necessary +#service setup_fs /system/bin/setup_fs \ +# /dev/block/mmcblk0p3 \ +# /dev/block/mmcblk0p4 +# class core +# user root +# group root +# oneshot + +service at_distributor /system/bin/at_distributor + class main + user root + group radio lo + +# create virtual SD card at /mnt/sdcard, based on the /data/media directory +# daemon will drop to user/group system/media_rw after initializing +# underlying files in /data/media wil be created with user and group media_rw (1023) +service sdcard /system/bin/sdcard /data/media /mnt/shell/emulated 1023 1023 + class late_start + +service p2p_supplicant /system/bin/wpa_supplicant \ + -iwlan0 -Dnl80211 -c/data/misc/wifi/wpa_supplicant.conf -N \ + -ip2p0 -Dnl80211 -c/data/misc/wifi/p2p_supplicant.conf -e/data/misc/wifi/entropy.bin \ + -puse_p2p_group_interface=1 + # we will start as root and wpa_supplicant will switch to user wifi + # after setting up the capabilities required for WEXT + # user wifi + # group wifi inet keystore + class main + socket wpa_wlan0 dgram 660 wifi wifi + disabled + oneshot + +service wpa_supplicant /system/bin/wpa_supplicant \ + -Dnl80211 -iwlan0 -e/data/misc/wifi/entropy.bin \ + -c/data/misc/wifi/wpa_supplicant.conf + # we will start as root and wpa_supplicant will switch to user wifi + # after setting up the capabilities required for WEXT + # user wifi + # group wifi inet keystore + class main + socket wpa_wlan0 dgram 660 wifi wifi + disabled + oneshot + +service dhcpcd_wlan0 /system/bin/dhcpcd -ABKL + class main + disabled + oneshot + +service dhcpcd_p2p /system/bin/dhcpcd -aABKL + class main + disabled + oneshot + +service dhcpcd_bnep0 /system/bin/dhcpcd -ABKL + class main + disabled + oneshot + +service iprenew_wlan0 /system/bin/dhcpcd -n + class main + disabled + oneshot + +service iprenew_p2p /system/bin/dhcpcd -n + class main + disabled + oneshot + +service iprenew_bnep0 /system/bin/dhcpcd -n + class main + disabled + oneshot + +# GPS +service gpsd /system/bin/gpsd -c /system/etc/gps.xml + class main + socket gps seqpacket 0660 gps system + user gps + group system inet sdcard_rw + ioprio be 0 + +service macloader /system/bin/macloader + class main + oneshot + +service orientationd /system/bin/orientationd + class main + user compass + group input + +service geomagneticd /system/bin/geomagneticd + class main + user compass + group system input + +on property:init.svc.macloader=stopped + chown system root /data/.cid.info + chmod 0664 /data/.cid.info + chown system root /data/.rev + chmod 0660 /data/.rev +# end of wifi + +service SMD-daemon /system/bin/smdexe + class main + user root + group system radio inet net_raw diff --git a/rootdir/init.smdk4x12.usb.rc b/rootdir/init.smdk4x12.usb.rc new file mode 100755 index 0000000..6c4bca2 --- /dev/null +++ b/rootdir/init.smdk4x12.usb.rc @@ -0,0 +1,134 @@ +on init + write /sys/class/android_usb/android0/iSerial $ro.serialno + write /sys/class/android_usb/android0/f_rndis/manufacturer Samsung + write /sys/class/android_usb/android0/f_rndis/vendorID 04e8 + write /sys/class/android_usb/android0/f_rndis/wceis 1 + +on boot + write /sys/class/android_usb/android0/iManufacturer $ro.product.manufacturer + write /sys/class/android_usb/android0/iProduct $ro.product.model + write /sys/class/android_usb/android0/iSerial $ro.serialno + write /sys/class/android_usb/f_mass_storage/inquiry_string "Samsung" + +on property:sys.usb.config=mtp + write /sys/class/android_usb/android0/enable 0 + write /sys/class/android_usb/android0/idVendor 04e8 + write /sys/class/android_usb/android0/idProduct 6860 + write /sys/class/android_usb/android0/functions ${sys.usb.config} + write /sys/class/android_usb/android0/enable 1 + setprop sys.usb.state ${sys.usb.config} + + +on property:sys.usb.config=mtp,adb + write /sys/class/android_usb/android0/enable 0 + write /sys/class/android_usb/android0/idVendor 04e8 + write /sys/class/android_usb/android0/idProduct 6860 + write /sys/class/android_usb/android0/functions ${sys.usb.config} + write /sys/class/android_usb/android0/enable 1 + start adbd + setprop sys.usb.state ${sys.usb.config} + +on property:sys.usb.config=rndis + write /sys/class/android_usb/android0/enable 0 + write /sys/class/android_usb/android0/idVendor 04e8 + write /sys/class/android_usb/android0/idProduct 6863 + write /sys/class/android_usb/android0/functions ${sys.usb.config} + write /sys/class/android_usb/android0/bDeviceClass 224 + write /sys/class/android_usb/android0/enable 1 + setprop sys.usb.state ${sys.usb.config} + +on property:sys.usb.config=rndis,adb + write /sys/class/android_usb/android0/enable 0 + write /sys/class/android_usb/android0/idVendor 04e8 + write /sys/class/android_usb/android0/idProduct 6864 + write /sys/class/android_usb/android0/functions ${sys.usb.config} + write /sys/class/android_usb/android0/bDeviceClass 224 + write /sys/class/android_usb/android0/enable 1 + start adbd + setprop sys.usb.state ${sys.usb.config} +on property:sys.usb.config=ptp + write /sys/class/android_usb/android0/enable 0 + write /sys/class/android_usb/android0/idVendor 04e8 + write /sys/class/android_usb/android0/idProduct 6865 + write /sys/class/android_usb/android0/functions ${sys.usb.config} + write /sys/class/android_usb/android0/enable 1 + setprop sys.usb.state ${sys.usb.config} + +on property:sys.usb.config=ptp,adb + write /sys/class/android_usb/android0/enable 0 + write /sys/class/android_usb/android0/idVendor 04e8 + write /sys/class/android_usb/android0/idProduct 6866 + write /sys/class/android_usb/android0/functions ${sys.usb.config} + write /sys/class/android_usb/android0/enable 1 + start adbd + setprop sys.usb.state ${sys.usb.config} + +on property:sys.usb.config=rndis,dm + write /sys/class/android_usb/android0/enable 0 + write /sys/class/android_usb/android0/idVendor 04e8 + write /sys/class/android_usb/android0/idProduct 6862 + write /sys/class/android_usb/android0/functions ${sys.usb.config} + write /sys/class/android_usb/android0/enable 1 + setprop sys.usb.state ${sys.usb.config} + +on property:sys.usb.config=rndis,acm,dm + write /sys/class/android_usb/android0/enable 0 + write /sys/class/android_usb/android0/idVendor 04e8 + write /sys/class/android_usb/android0/idProduct 6862 + write /sys/class/android_usb/android0/functions ${sys.usb.config} + write /sys/class/android_usb/android0/enable 1 + setprop sys.usb.state ${sys.usb.config} + +on property:sys.usb.config=mass_storage + write /sys/class/android_usb/android0/enable 0 + write /sys/class/android_usb/android0/idVendor 04e8 + write /sys/class/android_usb/android0/idProduct 685B + write /sys/class/android_usb/android0/functions ${sys.usb.config} + write /sys/class/android_usb/android0/enable 1 + setprop sys.usb.state ${sys.usb.config} + +on property:sys.usb.config=mass_storage,adb + write /sys/class/android_usb/android0/enable 0 + write /sys/class/android_usb/android0/idVendor 04e8 + write /sys/class/android_usb/android0/idProduct 685e + write /sys/class/android_usb/android0/functions ${sys.usb.config} + write /sys/class/android_usb/android0/enable 1 + start adbd + setprop sys.usb.state ${sys.usb.config} + +on property:sys.usb.config=mass_storage,acm + write /sys/class/android_usb/android0/enable 0 + write /sys/class/android_usb/android0/idVendor 04e8 + write /sys/class/android_usb/android0/idProduct 685e + write /sys/class/android_usb/android0/functions ${sys.usb.config} + write /sys/class/android_usb/android0/enable 1 + setprop sys.usb.state ${sys.usb.config} +# rndis,acm,diag and diag,acm,adb used for Hidden Menu + +on property:sys.usb.config=rndis,diag + write /sys/class/android_usb/android0/enable 0 + write /sys/class/android_usb/android0/idVendor 04e8 + write /sys/class/android_usb/android0/idProduct 6862 + write /sys/class/android_usb/android0/f_diag/clients diag_mdm + write /sys/class/android_usb/android0/functions ${sys.usb.config} + write /sys/class/android_usb/android0/enable 1 + setprop sys.usb.state ${sys.usb.config} + +on property:sys.usb.config=diag,acm,adb + write /sys/class/android_usb/android0/enable 0 + write /sys/class/android_usb/android0/idVendor 04E8 + write /sys/class/android_usb/android0/idProduct 6860 + write /sys/class/android_usb/android0/f_diag/clients diag_mdm + write /sys/class/android_usb/android0/functions ${sys.usb.config} + write /sys/class/android_usb/android0/enable 1 + start adbd + setprop sys.usb.state ${sys.usb.config} + +on property:sys.usb.config=rndis,acm,diag + write /sys/class/android_usb/android0/enable 0 + write /sys/class/android_usb/android0/idVendor 04E8 + write /sys/class/android_usb/android0/idProduct 6864 + write /sys/class/android_usb/android0/f_diag/clients diag_mdm + write /sys/class/android_usb/android0/functions ${sys.usb.config} + write /sys/class/android_usb/android0/enable 1 + setprop sys.usb.state ${sys.usb.config} diff --git a/rootdir/lpm.rc b/rootdir/lpm.rc new file mode 100644 index 0000000..7e5d382 --- /dev/null +++ b/rootdir/lpm.rc @@ -0,0 +1,80 @@ +on early-init + start ueventd + +on init + + export PATH /sbin:/vendor/bin:/system/sbin:/system/bin:/system/xbin + export LD_LIBRARY_PATH /vendor/lib:/system/lib + export ANDROID_ROOT /system + export ANDROID_DATA /data + export EXTERNAL_STORAGE /sdcard + + symlink /system/etc /etc + + mkdir /sdcard + mkdir /preload + mkdir /system + mkdir /data + mkdir /cache + mkdir /efs + mkdir /tmp + mkdir /dbdata + mkdir /mnt 0775 root root + #mount /tmp /tmp tmpfs + +on early-fs + insmod /lib/modules/vibrator.ko + + mount ext4 /dev/block/mmcblk0p9 /system ro wait noatime + + mkdir /data/log 0777 + + chmod 0666 /dev/log/radio + chmod 0666 /dev/log/main + chmod 0666 /dev/log/event + +on boot +# write /sys/class/sec/switch/usb_sel PDA + +# CPU Frequency Governor + write /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor pegasusq + +# EHCI runtime enable for LPA + write /sys/devices/platform/s5p-ehci/power/control auto + + ifup lo + hostname localhost + domainname localdomain + + class_start default + +service debuggerd /system/bin/debuggerd + + service ueventd /sbin/ueventd + critical + +#service console /bin/sh +service console /system/bin/sh + console + +service immvibed /system/bin/immvibed + oneshot + +service charger /charger + class default + user root + +# adbd is controlled by the persist.service.adb.enable system property +service adbd /sbin/adbd + disabled + +# adbd on at boot in emulator +on property:ro.kernel.qemu=1 + start adbd + +on property:persist.service.adb.enable=1 + start adbd + +on property:persist.service.adb.enable=0 + stop adbd + diff --git a/rootdir/ueventd.smdk4x12.rc b/rootdir/ueventd.smdk4x12.rc new file mode 100644 index 0000000..3129961 --- /dev/null +++ b/rootdir/ueventd.smdk4x12.rc @@ -0,0 +1,83 @@ +/dev/mali 0666 system system +/dev/ump 0666 system graphics +/dev/ion 0666 system system +/dev/exynos-mem 0666 system graphics + +/dev/media0 0660 system system +/dev/media1 0660 system camera +/dev/media2 0660 system camera +/dev/v4l-subdev0 0660 system system +/dev/v4l-subdev1 0660 system system +/dev/v4l-subdev3 0660 system system +/dev/v4l-subdev4 0660 system system +/dev/v4l-subdev5 0660 system system +/dev/v4l-subdev6 0660 system system +/dev/v4l-subdev7 0660 system system +/dev/v4l-subdev8 0660 system system +/dev/v4l-subdev9 0660 system system +/dev/v4l-subdev10 0660 system system +/dev/v4l-subdev11 0660 system system +/dev/v4l-subdev12 0660 system system +/dev/v4l-subdev13 0660 system system +/dev/v4l-subdev14 0660 system system +/dev/v4l-subdev15 0660 system system +/dev/v4l-subdev16 0660 system system +/dev/v4l-subdev17 0660 system system + +/dev/video0 0660 system camera +/dev/video1 0660 system camera +/dev/video2 0660 system camera +/dev/video3 0660 system camera +/dev/video4 0666 system m2m +/dev/video11 0666 system system +/dev/video12 0666 system system +/dev/video20 0660 system system +/dev/video6 0660 media graphics +/dev/video7 0660 media graphics + +/dev/video11 0666 system graphics +/dev/video12 0660 system camera + +/dev/video16 0660 system system +/dev/video17 0660 system system +/dev/video18 0660 system system +/dev/video19 0660 system system + +# Rotator +/dev/video21 0660 system system + +/dev/video23 0660 system system +/dev/video24 0660 system system +/dev/video25 0660 system camera +/dev/video26 0666 media m2m +/dev/video29 0666 media m2m +/dev/video32 0660 media m2m + +/dev/video33 0660 system system +/dev/video34 0660 system system + +/dev/video40 0660 system camera +/dev/video41 0660 system camera +/dev/video42 0660 system camera +/dev/video43 0660 system camera + +/dev/i2c-2 0660 system system +/dev/i2c-5 0660 system system +/dev/CEC 0660 system system +/dev/HPD 0660 system system +/dev/fimg2d 0666 system graphics +/dev/fmradio 0660 system audio + +#ALP Audio +/dev/srp 0660 system audio + +/dev/s3c-mfc 0660 system graphics +/dev/s5p-mfc 0666 system graphics + +/dev/umts* 0660 system radio +/dev/ttyUSB0 0666 system system +/dev/ttyUSB1 0666 system system +/dev/ttyUSB2 0666 system system +/dev/usb/lp* 0660 system usb +/dev/block/mmcblk0p4 0660 system system +/dev/block/mmcblk0p7 0660 system radio diff --git a/system.prop b/system.prop new file mode 100755 index 0000000..b2928cb --- /dev/null +++ b/system.prop @@ -0,0 +1,12 @@ +# +# system.prop for smdk4x12 +# +dalvik.vm.dexopt-data-only=1 +rild.libpath=/system/lib/libsec-ril.so +rild.libargs=-d /dev/ttyS0 +ro.sf.hwrotation=270 +ro.sf.lcd_density=213 +ro.lcd_min_brightness=20 +ro.hdcp2.rx=tz + + -- cgit v1.1