From 5c27960bc1122f9235f5395b8f7bcc5382389ea8 Mon Sep 17 00:00:00 2001 From: codeworkx Date: Mon, 4 Feb 2013 17:01:15 +0000 Subject: initial commit --- Android.mk | 23 + AndroidProducts.mk | 18 + BoardConfig.mk | 41 + DeviceSettings/Android.mk | 15 + DeviceSettings/AndroidManifest.xml | 31 + .../res/drawable/ic_launcher_cmdevicesettings.png | Bin 0 -> 8207 bytes DeviceSettings/res/layout/top.xml | 5 + DeviceSettings/res/values-de/arrays.xml | 56 + DeviceSettings/res/values-de/strings.xml | 34 + DeviceSettings/res/values-es/arrays.xml | 48 + DeviceSettings/res/values-es/strings.xml | 28 + DeviceSettings/res/values-hu/arrays.xml | 56 + DeviceSettings/res/values-hu/strings.xml | 34 + DeviceSettings/res/values-pt-rBR/arrays.xml | 55 + DeviceSettings/res/values-pt-rBR/strings.xml | 28 + DeviceSettings/res/values-ru/arrays.xml | 54 + DeviceSettings/res/values-ru/strings.xml | 34 + DeviceSettings/res/values-zh-rCN/arrays.xml | 56 + DeviceSettings/res/values-zh-rCN/strings.xml | 33 + DeviceSettings/res/values/arrays.xml | 109 + DeviceSettings/res/values/strings.xml | 34 + DeviceSettings/res/xml/haptic_preferences.xml | 13 + DeviceSettings/res/xml/radio_preferences.xml | 12 + DeviceSettings/res/xml/screen_preferences.xml | 65 + .../settings/device/DeviceSettings.java | 166 + .../settings/device/HapticFragmentActivity.java | 66 + .../src/com/cyanogenmod/settings/device/Hspa.java | 67 + .../com/cyanogenmod/settings/device/LedFade.java | 59 + .../settings/device/RadioFragmentActivity.java | 66 + .../settings/device/ScreenFragmentActivity.java | 102 + .../com/cyanogenmod/settings/device/Startup.java | 38 + .../settings/device/TouchkeyTimeout.java | 59 + .../src/com/cyanogenmod/settings/device/Utils.java | 143 + .../settings/device/VibratorIntensity.java | 59 + .../com/cyanogenmod/settings/device/mDNIeMode.java | 59 + .../cyanogenmod/settings/device/mDNIeNegative.java | 59 + .../cyanogenmod/settings/device/mDNIeScenario.java | 59 + README | 4 + audio/Android.mk | 33 + audio/audio_hw.c | 3234 ++++++++++++++++++++ audio/audio_hw.h | 302 ++ bluetooth/bdroid_buildcfg.h | 23 + cm.dependencies | 14 + cm.mk | 25 + configs/80cfw | 10 + configs/gps.conf | 102 + configs/nfcee_access.xml | 11 + configs/nfcee_access_debug.xml | 17 + configs/tiny_hw.xml | 353 +++ extract-files.sh | 105 + full_i9305.mk | 35 + i9305.mk | 96 + .../frameworks/base/core/res/res/values/config.xml | 118 + .../base/core/res/res/xml/power_profile.xml | 69 + .../base/core/res/res/xml/storage_list.xml | 52 + .../base/packages/SystemUI/res/values/config.xml | 26 + overlay/packages/apps/Phone/res/values/config.xml | 30 + overlay/packages/apps/Torch/res/values/config.xml | 36 + proprietary-files.txt | 49 + recovery.fstab | 12 + rootdir/fstab.smdk4x12 | 11 + rootdir/init.smdk4x12.rc | 609 ++++ rootdir/lpm.rc | 77 + rootdir/ueventd.smdk4x12.rc | 109 + system.prop | 17 + 65 files changed, 7463 insertions(+) create mode 100644 Android.mk create mode 100644 AndroidProducts.mk create mode 100644 BoardConfig.mk create mode 100644 DeviceSettings/Android.mk create mode 100644 DeviceSettings/AndroidManifest.xml create mode 100755 DeviceSettings/res/drawable/ic_launcher_cmdevicesettings.png create mode 100755 DeviceSettings/res/layout/top.xml create mode 100644 DeviceSettings/res/values-de/arrays.xml create mode 100644 DeviceSettings/res/values-de/strings.xml create mode 100644 DeviceSettings/res/values-es/arrays.xml create mode 100644 DeviceSettings/res/values-es/strings.xml create mode 100644 DeviceSettings/res/values-hu/arrays.xml create mode 100644 DeviceSettings/res/values-hu/strings.xml create mode 100755 DeviceSettings/res/values-pt-rBR/arrays.xml create mode 100755 DeviceSettings/res/values-pt-rBR/strings.xml create mode 100644 DeviceSettings/res/values-ru/arrays.xml create mode 100644 DeviceSettings/res/values-ru/strings.xml create mode 100644 DeviceSettings/res/values-zh-rCN/arrays.xml create mode 100644 DeviceSettings/res/values-zh-rCN/strings.xml create mode 100644 DeviceSettings/res/values/arrays.xml create mode 100644 DeviceSettings/res/values/strings.xml create mode 100644 DeviceSettings/res/xml/haptic_preferences.xml create mode 100644 DeviceSettings/res/xml/radio_preferences.xml create mode 100644 DeviceSettings/res/xml/screen_preferences.xml create mode 100644 DeviceSettings/src/com/cyanogenmod/settings/device/DeviceSettings.java create mode 100644 DeviceSettings/src/com/cyanogenmod/settings/device/HapticFragmentActivity.java create mode 100644 DeviceSettings/src/com/cyanogenmod/settings/device/Hspa.java create mode 100644 DeviceSettings/src/com/cyanogenmod/settings/device/LedFade.java create mode 100644 DeviceSettings/src/com/cyanogenmod/settings/device/RadioFragmentActivity.java create mode 100644 DeviceSettings/src/com/cyanogenmod/settings/device/ScreenFragmentActivity.java create mode 100644 DeviceSettings/src/com/cyanogenmod/settings/device/Startup.java create mode 100644 DeviceSettings/src/com/cyanogenmod/settings/device/TouchkeyTimeout.java create mode 100644 DeviceSettings/src/com/cyanogenmod/settings/device/Utils.java create mode 100644 DeviceSettings/src/com/cyanogenmod/settings/device/VibratorIntensity.java create mode 100644 DeviceSettings/src/com/cyanogenmod/settings/device/mDNIeMode.java create mode 100644 DeviceSettings/src/com/cyanogenmod/settings/device/mDNIeNegative.java create mode 100644 DeviceSettings/src/com/cyanogenmod/settings/device/mDNIeScenario.java create mode 100644 README create mode 100644 audio/Android.mk create mode 100644 audio/audio_hw.c create mode 100644 audio/audio_hw.h create mode 100644 bluetooth/bdroid_buildcfg.h create mode 100644 cm.dependencies create mode 100644 cm.mk create mode 100644 configs/80cfw create mode 100644 configs/gps.conf create mode 100644 configs/nfcee_access.xml create mode 100644 configs/nfcee_access_debug.xml create mode 100644 configs/tiny_hw.xml create mode 100755 extract-files.sh create mode 100644 full_i9305.mk create mode 100644 i9305.mk 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/frameworks/base/packages/SystemUI/res/values/config.xml create mode 100644 overlay/packages/apps/Phone/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 rootdir/fstab.smdk4x12 create mode 100755 rootdir/init.smdk4x12.rc create mode 100644 rootdir/lpm.rc create mode 100644 rootdir/ueventd.smdk4x12.rc create mode 100644 system.prop diff --git a/Android.mk b/Android.mk new file mode 100644 index 0000000..e187cd5 --- /dev/null +++ b/Android.mk @@ -0,0 +1,23 @@ +# +# 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 := $(call my-dir) + +ifeq ($(TARGET_DEVICE),i9305) + +include $(call all-makefiles-under,$(LOCAL_PATH)) + +endif diff --git a/AndroidProducts.mk b/AndroidProducts.mk new file mode 100644 index 0000000..549de4c --- /dev/null +++ b/AndroidProducts.mk @@ -0,0 +1,18 @@ +# +# 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. +# + +PRODUCT_MAKEFILES := \ + $(LOCAL_DIR)/full_i9305.mk diff --git a/BoardConfig.mk b/BoardConfig.mk new file mode 100644 index 0000000..c405919 --- /dev/null +++ b/BoardConfig.mk @@ -0,0 +1,41 @@ +# +# 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 variable is set first, so it can be overridden +# by BoardConfigVendor.mk + +-include device/samsung/smdk4412-common/BoardCommonConfig.mk + +LOCAL_PATH := device/samsung/i9305 + +# Bluetooth +BOARD_BLUETOOTH_BDROID_BUILDCFG_INCLUDE_DIR := $(LOCAL_PATH)/bluetooth + +# RIL +COMMON_GLOBAL_CFLAGS += -DPROPERTY_PERMS_APPEND='{ "ril.ks.status", AID_SYSTEM, 0 },' + +# Camera +COMMON_GLOBAL_CFLAGS += -DCAMERA_WITH_CITYID_PARAM + +# Kernel +TARGET_KERNEL_SOURCE := kernel/samsung/smdk4412 +TARGET_KERNEL_CONFIG := cyanogenmod_i9305_defconfig + +# assert +TARGET_OTA_ASSERT_DEVICE := m3,m3xx,i9305,GT-I9305 + +# inherit from the proprietary version +-include vendor/samsung/i9305/BoardConfigVendor.mk diff --git a/DeviceSettings/Android.mk b/DeviceSettings/Android.mk new file mode 100644 index 0000000..12c8de5 --- /dev/null +++ b/DeviceSettings/Android.mk @@ -0,0 +1,15 @@ +LOCAL_PATH:= $(call my-dir) +include $(CLEAR_VARS) + +LOCAL_MODULE_TAGS := optional + +LOCAL_STATIC_JAVA_LIBRARIES := android-support-v13 + +LOCAL_SRC_FILES := $(call all-java-files-under, src) + +LOCAL_PACKAGE_NAME := GalaxyS3Settings +LOCAL_CERTIFICATE := platform + +include $(BUILD_PACKAGE) + +include $(call all-makefiles-under,$(LOCAL_PATH)) diff --git a/DeviceSettings/AndroidManifest.xml b/DeviceSettings/AndroidManifest.xml new file mode 100644 index 0000000..d373ded --- /dev/null +++ b/DeviceSettings/AndroidManifest.xml @@ -0,0 +1,31 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/DeviceSettings/res/drawable/ic_launcher_cmdevicesettings.png b/DeviceSettings/res/drawable/ic_launcher_cmdevicesettings.png new file mode 100755 index 0000000..66de9c3 Binary files /dev/null and b/DeviceSettings/res/drawable/ic_launcher_cmdevicesettings.png differ diff --git a/DeviceSettings/res/layout/top.xml b/DeviceSettings/res/layout/top.xml new file mode 100755 index 0000000..744b568 --- /dev/null +++ b/DeviceSettings/res/layout/top.xml @@ -0,0 +1,5 @@ + + diff --git a/DeviceSettings/res/values-de/arrays.xml b/DeviceSettings/res/values-de/arrays.xml new file mode 100644 index 0000000..9edf346 --- /dev/null +++ b/DeviceSettings/res/values-de/arrays.xml @@ -0,0 +1,56 @@ + + + + 0% + 25% + 50% (Standard) + 75% + 100% + + + + Nur UMTS + Nur HSDPA + HSDPA + HSUPA + + + + CyanogenMod (Standard) + UI + Video + Video warm + Video kalt + Kamera + Navigation + Gallerie + VT + + + + Dynamisch (Standard) + Standard + Natürlich + Film + + + + Normal + Invertiert + + + + Blinken + Verblassen + + + + Niemals + 1 Sekunde + 2 Sekunden + 3 Sekunden (Standard) + 4 Sekunden + 5 Sekunden + 6 Sekunden + + + diff --git a/DeviceSettings/res/values-de/strings.xml b/DeviceSettings/res/values-de/strings.xml new file mode 100644 index 0000000..50c66a6 --- /dev/null +++ b/DeviceSettings/res/values-de/strings.xml @@ -0,0 +1,34 @@ + + + Galaxy S III Einstellungen + + Haptik + Vibrator + Vibrator Intensität + Wähle Vibrator Intensität + + Mobilfunk + HSPA + Aktiviere HSDPA/HSUPA + + Display + Farben + Szenario + Wähle das mDNIe Szenario + Modus + Wähle den mDNIe Modus + Negativ Modus + Invertiere Farben + + Benachrichtigungslicht + Modus + Wähle zwischen sanftem Verblassen und Blinken + + Touchkeys + Beleuchtung + Aktiviere Beleuchtung + Deaktiviere Beleuchtung + Zeitabschaltung der Beleuchtung + Setze Zeit für automatische Abschaltung + + diff --git a/DeviceSettings/res/values-es/arrays.xml b/DeviceSettings/res/values-es/arrays.xml new file mode 100644 index 0000000..fd55bc4 --- /dev/null +++ b/DeviceSettings/res/values-es/arrays.xml @@ -0,0 +1,48 @@ + + + 0% + 25% + 50% (por defecto) + 75% + 100% + + + Solo UMTS + Solo HSDPA + HSDPA + HSUPA + + + CyanogenMod (por defecto) + UI + Vídeo + Vídeo cálido + Vídeo frío + Camara + Navegación + Galería + VT + + + Estándar (por defecto) + Dinámico + Natural + Película + + + Normal + Invertido + + + Parpadeo + Fundido + + + Nunca + 1 segundo + 2 segundos + 3 segundos (por defecto) + 4 segundos + 5 segundos + 6 segundos + + diff --git a/DeviceSettings/res/values-es/strings.xml b/DeviceSettings/res/values-es/strings.xml new file mode 100644 index 0000000..50674d3 --- /dev/null +++ b/DeviceSettings/res/values-es/strings.xml @@ -0,0 +1,28 @@ + + + "Ajustes Galaxy S III" + "Háptica" + "Vibración" + "Intensidad de vibración" + "Establecer la intensidad de vibración" + "Radio" + "HSPA" + "Habilitar HSDPA/HSUPA" + "Pantalla" + "Colores" + "Escenario" + "Establecer escenario mDNIe" + "Modo" + "Establecer modo mDNIe" + "Modo negativo" + "Habilitar/deshabilitar colores invertidos" + "Notificación LED" + "Fundido LED" + "Habilitar fundido suave en vez de parpadeo intenso" + "Teclas táctiles" + "Retroiluminación" + "Habilitar retroiluminación" + "Deshabilitar retroiluminación" + "Tiempo de espera de retroiluminación" + "Tiempo tras pulsar una tecla antes de apagar la retroiluminación" + diff --git a/DeviceSettings/res/values-hu/arrays.xml b/DeviceSettings/res/values-hu/arrays.xml new file mode 100644 index 0000000..824296d --- /dev/null +++ b/DeviceSettings/res/values-hu/arrays.xml @@ -0,0 +1,56 @@ + + + + 0% + 25% + 50% (Alapbeállítás) + 75% + 100% + + + + UMTS + HSDPA + HSDPA + HSUPA + + + + CyanogenMod (Alapbeállítás) + Felhasználói felület + Videó + Videó (Meleg árnyalat) + Videó (Hideg árnyalat) + Kamera + Navigáció + Galéria + VT + + + + Dinamikus (Alapbeállítás) + Hagyományos + Természetes + Film + + + + Normál + Fordított + + + + Villogás + Elhalványulás + + + + Soha + 1 másodperc + 2 másodperc + 3 másodperc (Alapbeállítás) + 4 másodperc + 5 másodperc + 6 másodperc + + + diff --git a/DeviceSettings/res/values-hu/strings.xml b/DeviceSettings/res/values-hu/strings.xml new file mode 100644 index 0000000..aecbf59 --- /dev/null +++ b/DeviceSettings/res/values-hu/strings.xml @@ -0,0 +1,34 @@ + + + Galaxy S III Beállítások + + Érintési visszajelzés + Rezgés + Rezgés erőssége + Rezgés erősségének beállítása + + GSM Rádió + HSPA + HSDPA/HSUPA engedélyezése + + Kijelző + Színek + Megjelenítés + mDNIe megjelenítési beállítások + Üzemmód + mDNIe üzemmódok + Negatív üzemmód + Fordított színek ki/be + + LED értesítés + LED halványítás + LED elhalványítása villogtatás helyett + + Érintőgombok + Háttérvilágítás + Háttérvilágítás engedélyezése + Háttérvilágítás tiltása + Háttérvilágítás időkorlátja + Háttérvilágítás késleltetése + + diff --git a/DeviceSettings/res/values-pt-rBR/arrays.xml b/DeviceSettings/res/values-pt-rBR/arrays.xml new file mode 100755 index 0000000..7ade7ea --- /dev/null +++ b/DeviceSettings/res/values-pt-rBR/arrays.xml @@ -0,0 +1,55 @@ + + + + 0% + 25% + 50% (Padrão) + 75% + 100% + + + + Somente UMTS + Somente HSDPA + HSDPA + HSUPA + + + + CyanogenMod (Padrão) + IU + Vídeo + Vídeo Quente + Vídeo Frio + Câmera + Navegação + Galeria + VT + + + + Padrão + Dinâmico + Natural + Filme + + + + Normal + Invertido + + + + Piscando + Desvanecimento + + + + Nunca + 1 segundo + 2 segundos + 3 segundos (Padrão) + 4 segundos + 5 segundos + 6 segundos + + diff --git a/DeviceSettings/res/values-pt-rBR/strings.xml b/DeviceSettings/res/values-pt-rBR/strings.xml new file mode 100755 index 0000000..668c59c --- /dev/null +++ b/DeviceSettings/res/values-pt-rBR/strings.xml @@ -0,0 +1,28 @@ + + + Config. Galaxy S III + Resposta Tátil + Vibração + Intensidade da Vibração + Define a intensidade da vibração + Rádio + Ativar HSDPA/HSUPA + Tela + Cores + Cenário + Define o Cenário mDNIe + Modo + Define o Modo mDNIe + Modo Negativo + Ativar/Desativar cores invertidas + Notificação com LED + Desvanecimento LED + Ativar desvanecimento suave do LED em vez de piscar. + Teclas sensíveis ao toque + Luz de fundo + Ativar luz de fundo + Desativar luz de fundo + Tempo limite da luz de fundo + Define o tempo limite para a luz de fundo + HSPA + \ No newline at end of file diff --git a/DeviceSettings/res/values-ru/arrays.xml b/DeviceSettings/res/values-ru/arrays.xml new file mode 100644 index 0000000..ed61b6e --- /dev/null +++ b/DeviceSettings/res/values-ru/arrays.xml @@ -0,0 +1,54 @@ + + + + 0% + 25% + 50% (По умолч.) + 75% + 100% + + + + Только UMTS + Только HSDPA + HSDPA + HSUPA + + + + CyanogenMod (По умолч.) + Видео + Видео (тёпл.) + Видео (хол.) + Камера + Навигация + Галерея + VT + + + + Динамический (По умолч.) + Стандартный + Натуральный + Кино + + + + Нормально + Инверсия + + + + Мигание + Затухание + + + + Никогда + 1 секунда + 2 секунды + 3 секунды (По умолч.) + 4 секунды + 5 секунд + 6 секунд + + diff --git a/DeviceSettings/res/values-ru/strings.xml b/DeviceSettings/res/values-ru/strings.xml new file mode 100644 index 0000000..d6d44b8 --- /dev/null +++ b/DeviceSettings/res/values-ru/strings.xml @@ -0,0 +1,34 @@ + + + Настройки Galaxy S III + + Отклик + Вибрация + Интенсивность вибрации + Установка интенсивности вибрации + + Модем + HSPA + Включить HSDPA/HSUPA + + Экран + Цвета + Сценарий + Установка сценария mDNIe + Режим + Установка режима mDNIe + Негатив + Вкл./выкл. инверсии цветов + + Индикатор событий + Режим + Плавное затухание или резкое мигание + + Сенсорные клавиши + Подсветка + Подсветка включена + Подсветка выключена + Тайм-аут подсветки + Установка тайм-аута подсветки + + diff --git a/DeviceSettings/res/values-zh-rCN/arrays.xml b/DeviceSettings/res/values-zh-rCN/arrays.xml new file mode 100644 index 0000000..3fe1780 --- /dev/null +++ b/DeviceSettings/res/values-zh-rCN/arrays.xml @@ -0,0 +1,56 @@ + + + + 0% + 25% + 50% (默认) + 75% + 100% + + + + 仅使用 UMTS + 仅使用 HSDPA + 使用 HSDPA + HSUPA + + + + CyanogenMod (默认) + 界面 + 影片 + 影片 (温) + 影片 (冷) + 相机 + 导航 + 图库 + VT + + + + 动态 (默认) + 标准 + 自然 + 电影 + + + + 正常 + 反色 + + + + 闪烁 + 淡出 + + + + 从不 + 1 秒 + 2 秒 + 3 秒 (默认) + 4 秒 + 5 秒 + 6 秒 + + + diff --git a/DeviceSettings/res/values-zh-rCN/strings.xml b/DeviceSettings/res/values-zh-rCN/strings.xml new file mode 100644 index 0000000..17451bd --- /dev/null +++ b/DeviceSettings/res/values-zh-rCN/strings.xml @@ -0,0 +1,33 @@ + + + Galaxy S III 设置 + + 振动 + 振动器 + 振动器强度 + 设置振动器强度 + + 无线电 + HSPA + 启用 HSDPA/HSUPA + + 屏幕 + 颜色 + 场景 + 设置 mDNIe 场景 + 模式 + 设置 mDNIe 模式 + 负极模式 + 启用/禁用反色 + + LED 指示灯 + LED 淡出 + 启用后 LED 指示灯将会产生淡出效果而替代闪烁效果. + + 触摸键 + 背光灯 + 启用背光灯 + 禁用背光灯 + 背光灯超时 + 设置背光灯超时时间 + diff --git a/DeviceSettings/res/values/arrays.xml b/DeviceSettings/res/values/arrays.xml new file mode 100644 index 0000000..d82ffbc --- /dev/null +++ b/DeviceSettings/res/values/arrays.xml @@ -0,0 +1,109 @@ + + + + 0% + 25% + 50% (Default) + 75% + 100% + + + + 0 + 25 + 50 + 75 + 100 + + + + UMTS Only + HSDPA Only + HSDPA + HSUPA + + + + 21 + 22 + 23 + + + + CyanogenMod (Default) + UI + Video + Video Warm + Video Cold + Camera + Navigation + Gallery + VT + + + + 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + + + + Dynamic (Default) + Standard + Natural + Movie + + + + 0 + 1 + 2 + 3 + + + + Normal + Inverted + + + + 0 + 1 + + + + Blinking + Fading + + + + 0 + 1 + + + + Never + 1 second + 2 seconds + 3 seconds (Default) + 4 seconds + 5 seconds + 6 seconds + + + + 0 + 1 + 2 + 3 + 4 + 5 + 6 + + + diff --git a/DeviceSettings/res/values/strings.xml b/DeviceSettings/res/values/strings.xml new file mode 100644 index 0000000..e842ae4 --- /dev/null +++ b/DeviceSettings/res/values/strings.xml @@ -0,0 +1,34 @@ + + + Galaxy S III Settings + + Haptic + Vibrator + Vibrator Intensity + Set vibrator intensity + + Radio + HSPA + Enable HSDPA/HSUPA + + Screen + Colors + Scenario + Set the mDNIe Scenario + Mode + Set the mDNIe Mode + Negative Mode + Enable/Disable inverted colors + + Notification LED + LED Fading + Enable LED smooth fading instead of sharp blinking. + + Touchkeys + Backlight + Enable backlight + Disable backlight + Backlight timeout + Set timeout for the backlight + + diff --git a/DeviceSettings/res/xml/haptic_preferences.xml b/DeviceSettings/res/xml/haptic_preferences.xml new file mode 100644 index 0000000..31c0e21 --- /dev/null +++ b/DeviceSettings/res/xml/haptic_preferences.xml @@ -0,0 +1,13 @@ + + + + + + diff --git a/DeviceSettings/res/xml/radio_preferences.xml b/DeviceSettings/res/xml/radio_preferences.xml new file mode 100644 index 0000000..c173db7 --- /dev/null +++ b/DeviceSettings/res/xml/radio_preferences.xml @@ -0,0 +1,12 @@ + + + + + + diff --git a/DeviceSettings/res/xml/screen_preferences.xml b/DeviceSettings/res/xml/screen_preferences.xml new file mode 100644 index 0000000..aff39c0 --- /dev/null +++ b/DeviceSettings/res/xml/screen_preferences.xml @@ -0,0 +1,65 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/DeviceSettings/src/com/cyanogenmod/settings/device/DeviceSettings.java b/DeviceSettings/src/com/cyanogenmod/settings/device/DeviceSettings.java new file mode 100644 index 0000000..152e361 --- /dev/null +++ b/DeviceSettings/src/com/cyanogenmod/settings/device/DeviceSettings.java @@ -0,0 +1,166 @@ +/* + * 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. + */ + +package com.cyanogenmod.settings.device; + +import android.app.ActionBar; +import android.app.ActionBar.Tab; +import android.app.Activity; +import android.app.Fragment; +import android.app.FragmentTransaction; +import android.content.Context; +import android.os.Bundle; +import android.support.v4.app.FragmentActivity; +import android.support.v13.app.FragmentPagerAdapter; +import android.support.v4.view.ViewPager; +import android.view.MenuItem; + +import com.cyanogenmod.settings.device.R; + +import java.util.ArrayList; + +public class DeviceSettings extends FragmentActivity { + + public static final String SHARED_PREFERENCES_BASENAME = "com.cyanogenmod.settings.device"; + public static final String ACTION_UPDATE_PREFERENCES = "com.cyanogenmod.settings.device.UPDATE"; + public static final String KEY_HSPA = "hspa"; + public static final String KEY_VIBRATOR_INTENSITY = "vibrator_intensity"; + public static final String KEY_MDNIE_SCENARIO = "mdnie_scenario"; + public static final String KEY_MDNIE_MODE = "mdnie_mode"; + public static final String KEY_MDNIE_NEGATIVE = "mdnie_negative"; + public static final String KEY_LED_FADE = "led_fade"; + public static final String KEY_TOUCHKEY_LIGHT = "touchkey_light"; + public static final String KEY_TOUCHKEY_TIMEOUT = "touchkey_timeout"; + + ViewPager mViewPager; + TabsAdapter mTabsAdapter; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + + mViewPager = new ViewPager(this); + mViewPager.setId(R.id.viewPager); + setContentView(mViewPager); + + final ActionBar bar = getActionBar(); + bar.setNavigationMode(ActionBar.NAVIGATION_MODE_TABS); + bar.setDisplayOptions(ActionBar.DISPLAY_SHOW_TITLE, ActionBar.DISPLAY_SHOW_TITLE); + bar.setTitle(R.string.app_name); + bar.setDisplayHomeAsUpEnabled(true); + + mTabsAdapter = new TabsAdapter(this, mViewPager); + mTabsAdapter.addTab(bar.newTab().setText(R.string.category_radio_title), + RadioFragmentActivity.class, null); + mTabsAdapter.addTab(bar.newTab().setText(R.string.category_screen_title), + ScreenFragmentActivity.class, null); + mTabsAdapter.addTab(bar.newTab().setText(R.string.category_haptic_title), + HapticFragmentActivity.class, null); + + + if (savedInstanceState != null) { + bar.setSelectedNavigationItem(savedInstanceState.getInt("tab", 0)); + } + } + + @Override + protected void onSaveInstanceState(Bundle outState) { + super.onSaveInstanceState(outState); + outState.putInt("tab", getActionBar().getSelectedNavigationIndex()); + } + + public static class TabsAdapter extends FragmentPagerAdapter + implements ActionBar.TabListener, ViewPager.OnPageChangeListener { + private final Context mContext; + private final ActionBar mActionBar; + private final ViewPager mViewPager; + private final ArrayList mTabs = new ArrayList(); + + static final class TabInfo { + private final Class clss; + private final Bundle args; + + TabInfo(Class _class, Bundle _args) { + clss = _class; + args = _args; + } + } + + public TabsAdapter(Activity activity, ViewPager pager) { + super(activity.getFragmentManager()); + mContext = activity; + mActionBar = activity.getActionBar(); + mViewPager = pager; + mViewPager.setAdapter(this); + mViewPager.setOnPageChangeListener(this); + } + + public void addTab(ActionBar.Tab tab, Class clss, Bundle args) { + TabInfo info = new TabInfo(clss, args); + tab.setTag(info); + tab.setTabListener(this); + mTabs.add(info); + mActionBar.addTab(tab); + notifyDataSetChanged(); + } + + @Override + public int getCount() { + return mTabs.size(); + } + + @Override + public Fragment getItem(int position) { + TabInfo info = mTabs.get(position); + return Fragment.instantiate(mContext, info.clss.getName(), info.args); + } + + public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) { + } + + public void onPageSelected(int position) { + mActionBar.setSelectedNavigationItem(position); + } + + public void onPageScrollStateChanged(int state) { + } + + public void onTabSelected(Tab tab, FragmentTransaction ft) { + Object tag = tab.getTag(); + for (int i=0; i + * 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 + +#include "audio_hw.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_WB_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; + struct pcm *pcm_bt_dl; + struct pcm *pcm_bt_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; + bool screen_off; +}; + +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; +}; + +/* QCOM CSD-Client */ +#define CSD_CLIENT_LIBPATH "/system/lib/libcsd-client.so" + +void *mCsdHandle; +int rx_dev_id, tx_dev_id; + +static int (*csd_client_init)(); +static int (*csd_client_deinit)(); +static int (*csd_start_playback)(); +static int (*csd_stop_playback)(); +static int (*csd_disable_device)(); +static int (*csd_enable_device)(int, int, uint32_t); +static int (*csd_switch_device)(int,int); +static int (*csd_volume)(int); +static int (*csd_mic_mute)(int); +static int (*csd_wide_voice)(uint8_t); +static int (*csd_slow_talk)(uint8_t); +static int (*csd_fens)(uint8_t); +static int (*csd_volume_index)(int); +static int (*csd_start_voice)(int,int,int); +static int (*csd_stop_voice)(int); +static int (*csd_client_volume)(int); +static int (*csd_client_mic_mute)(int); +static int (*csd_client_pcm_loopback_start)(int,int); +static int (*csd_client_pcm_loopback_stop)(int); + +void setCsdHandle(void* handle) +{ + void *mcsd_handle; + mcsd_handle = (void*)handle; + ALOGD("%s csd_handle: %p", __func__, mcsd_handle); + + csd_start_voice = (int (*)(int,int,int)) dlsym(mcsd_handle,"csd_client_start_voice"); + csd_enable_device = (int (*)(int,int,uint32_t)) dlsym(mcsd_handle,"csd_client_enable_device"); + csd_disable_device = (int (*)()) dlsym(mcsd_handle,"csd_client_disable_device"); + //csd_client_start_record + //csd_client_stop_record + csd_start_playback = (int (*)()) dlsym(mcsd_handle,"csd_client_start_playback"); + csd_stop_playback = (int (*)()) dlsym(mcsd_handle,"csd_client_stop_playback"); + csd_volume = (int (*)(int)) dlsym(mcsd_handle,"csd_client_volume"); + csd_mic_mute = (int (*)(int)) dlsym(mcsd_handle,"csd_client_mic_mute"); + csd_wide_voice = (int (*)(uint8_t)) dlsym(mcsd_handle,"csd_client_wide_voice"); + csd_slow_talk = (int (*)(uint8_t)) dlsym(mcsd_handle,"csd_client_slow_talk"); + csd_fens = (int (*)(uint8_t)) dlsym(mcsd_handle,"csd_client_fens"); + csd_volume_index = (int (*)(int)) dlsym(mcsd_handle,"csd_client_volume_index"); + csd_switch_device = (int (*)(int,int)) dlsym(mcsd_handle,"csd_client_switch_device"); + //csd_client_stream_mute + csd_client_pcm_loopback_start = (int (*)(int,int)) dlsym(mcsd_handle,"csd_client_pcm_loopback_start"); + csd_client_pcm_loopback_stop = (int (*)(int)) dlsym(mcsd_handle,"csd_client_pcm_loopback_stop"); + //csd_client_tty + csd_client_init = (int (*)()) dlsym(mcsd_handle,"csd_client_init_lb"); + csd_client_deinit = (int (*)()) dlsym(mcsd_handle,"csd_client_deinit_lb"); + csd_stop_voice = (int (*)(int)) dlsym(mcsd_handle,"csd_client_stop_voice"); +} + +/** + * 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) +{ + ALOGV("Opening modem PCMs"); + int bt_on; + + bt_on = adev->out_device & AUDIO_DEVICE_OUT_ALL_SCO; + + /* use amr-wb by default */ + pcm_config_vx.rate = VX_WB_SAMPLING_RATE; + + /* Open modem PCM channels */ + if (adev->pcm_modem_dl == NULL) { + ALOGD("Opening PCM modem DL stream"); + 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) { + ALOGD("Opening PCM modem UL stream"); + 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; + } + } + + ALOGD("Starting PCM modem streams"); + pcm_start(adev->pcm_modem_dl); + pcm_start(adev->pcm_modem_ul); + + /* Open bluetooth PCM channels */ + if (bt_on) { + ALOGV("Opening bluetooth PCMs"); + /* use amr-nb for bluetooth */ + pcm_config_vx.rate = VX_NB_SAMPLING_RATE; + + if (adev->pcm_bt_dl == NULL) { + ALOGD("Opening PCM bluetooth DL stream"); + adev->pcm_bt_dl = pcm_open(CARD_DEFAULT, PORT_BT, PCM_OUT, &pcm_config_vx); + if (!pcm_is_ready(adev->pcm_bt_dl)) { + ALOGE("cannot open PCM bluetooth DL stream: %s", pcm_get_error(adev->pcm_bt_dl)); + goto err_open_dl; + } + } + + if (adev->pcm_bt_ul == NULL) { + ALOGD("Opening PCM bluetooth UL stream"); + adev->pcm_bt_ul = pcm_open(CARD_DEFAULT, PORT_BT, PCM_IN, &pcm_config_vx); + if (!pcm_is_ready(adev->pcm_bt_ul)) { + ALOGE("cannot open PCM bluetooth UL stream: %s", pcm_get_error(adev->pcm_bt_ul)); + goto err_open_ul; + } + } + ALOGD("Starting PCM bluetooth streams"); + pcm_start(adev->pcm_bt_dl); + pcm_start(adev->pcm_bt_ul); + } + + return 0; + +err_open_ul: + pcm_close(adev->pcm_modem_ul); + adev->pcm_modem_ul = NULL; + pcm_close(adev->pcm_bt_ul); + adev->pcm_bt_ul = NULL; +err_open_dl: + pcm_close(adev->pcm_modem_dl); + adev->pcm_modem_dl = NULL; + pcm_close(adev->pcm_bt_dl); + adev->pcm_bt_dl = NULL; + + return -ENOMEM; +} + +static void end_call(struct m0_audio_device *adev) +{ + int bt_on; + bt_on = adev->out_device & AUDIO_DEVICE_OUT_ALL_SCO; + + if (adev->pcm_modem_dl != NULL) { + ALOGD("Stopping modem DL PCM"); + pcm_stop(adev->pcm_modem_dl); + ALOGV("Closing modem DL PCM"); + pcm_close(adev->pcm_modem_dl); + } + if (adev->pcm_modem_ul != NULL) { + ALOGD("Stopping modem UL PCM"); + pcm_stop(adev->pcm_modem_ul); + ALOGV("Closing modem UL PCM"); + pcm_close(adev->pcm_modem_ul); + } + adev->pcm_modem_dl = NULL; + adev->pcm_modem_ul = NULL; + + if (bt_on) { + if (adev->pcm_bt_dl != NULL) { + ALOGD("Stopping bluetooth DL PCM"); + pcm_stop(adev->pcm_bt_dl); + ALOGV("Closing bluetooth DL PCM"); + pcm_close(adev->pcm_bt_dl); + } + if (adev->pcm_bt_ul != NULL) { + ALOGD("Stopping bluetooth UL PCM"); + pcm_stop(adev->pcm_bt_ul); + ALOGV("Closing bluetooth UL PCM"); + pcm_close(adev->pcm_bt_ul); + } + } + adev->pcm_bt_dl = NULL; + adev->pcm_bt_ul = NULL; +} + +static void set_eq_filter(struct m0_audio_device *adev) +{ +} + +static void set_incall_device(struct m0_audio_device *adev) +{ + int err; + uint32_t mDevSettingsFlag = TTY_OFF; + + switch(adev->out_device) { + case AUDIO_DEVICE_OUT_EARPIECE: + rx_dev_id = DEVICE_HANDSET_RX_ACDB_ID; + tx_dev_id = DEVICE_HANDSET_TX_ACDB_ID; + break; + case AUDIO_DEVICE_OUT_SPEAKER: + case AUDIO_DEVICE_OUT_AUX_DIGITAL: + case AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET: + rx_dev_id = DEVICE_SPEAKER_MONO_RX_ACDB_ID; + tx_dev_id = DEVICE_HANDSET_TX_ACDB_ID; + break; + case AUDIO_DEVICE_OUT_WIRED_HEADSET: + case AUDIO_DEVICE_OUT_WIRED_HEADPHONE: + rx_dev_id = DEVICE_HEADSET_RX_ACDB_ID; + tx_dev_id = DEVICE_HEADSET_TX_ACDB_ID; + 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) { + rx_dev_id = DEVICE_BT_SCO_RX_ACDB_ID; + tx_dev_id = DEVICE_BT_SCO_TX_ACDB_ID; + } else { + rx_dev_id = DEVICE_BT_SCO_RX_ACDB_ID; + tx_dev_id = DEVICE_BT_SCO_TX_ACDB_ID; + } + break; + default: + rx_dev_id = DEVICE_HANDSET_RX_ACDB_ID; + tx_dev_id = DEVICE_HANDSET_TX_ACDB_ID; + break; + } + + ALOGV("rx_dev_id=%d, tx_dev_id=%d\n", rx_dev_id, tx_dev_id); + + /* QCOM CSD-CLIENT */ + if (!adev->in_call) { + if (csd_start_voice == NULL) { + ALOGE("dlsym:Error:%s Loading csd_client_start_voice", dlerror()); + } else { + ALOGD("%s: calling csd_start_voice", __func__); + err = csd_start_voice(rx_dev_id, tx_dev_id, 1); + if (err < 0) { + ALOGE("%s: csd_start_voice error %d\n", __func__, err); + } + } + } + + if (csd_switch_device == NULL) { + ALOGE("dlsym:Error:%s Loading csd_client_switch_device", dlerror()); + } else { + ALOGD("%s: calling csd_switch_device", __func__); + err = csd_switch_device(rx_dev_id, tx_dev_id); + if (err < 0) { + ALOGE("%s: csd_switch_device failed, error %d", __func__, err); + } + } +} + +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) +{ + int err; + + 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); + 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); + + /* QCOM CSD-Client */ + if (csd_stop_voice == NULL) { + ALOGE("dlsym:Error:%s Loading csd_client_disable_device", dlerror()); + } else { + ALOGD("%s: calling csd_stop_voice", __func__); + err = csd_stop_voice(1); + if (err < 0) { + ALOGE("%s: csd_stop_voice error %d\n", __func__, err); + } + } + + 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; + } + + // Wideband AMR + ret = str_parms_get_str(parms, "wb_amr", value, sizeof(value)); + if (ret >= 0) { + if (csd_wide_voice == NULL) { + ALOGE("dlsym: Error:%s Loading csd_wide_voice", dlerror()); + } else { + if (strcmp(value, "on") == 0) { + ALOGE("%s: enabling csd_wide_voice", __func__); + csd_wide_voice(VX_WB_SAMPLING_RATE); + } else { + ALOGE("%s: disabling csd_wide_voice", __func__); + csd_wide_voice(VX_NB_SAMPLING_RATE); + } + } + } + + // FIXME + ret = str_parms_get_str(parms, "noise_suppression", value, sizeof(value)); + if (ret >= 0) { + if (strcmp(value, "true") == 0) { + ALOGE("%s: enabling two mic control", __func__); + /* sub mic */ + set_bigroute_by_array(adev->mixer, noise_suppression, 1); + } else { + ALOGE("%s: disabling two mic control", __func__); + /* sub mic */ + set_bigroute_by_array(adev->mixer, noise_suppression_disable, 1); + } + } + + 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) { + if (csd_volume_index == NULL) { + ALOGE("dlsym: Error:%s Loading csd_volume_index", dlerror()); + } else { + volume = volume * 5; + ALOGD("%s: calling csd_volume_index(%f)", __func__, volume); + csd_volume_index(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; + + if (adev->mode == AUDIO_MODE_IN_CALL) { + if (csd_mic_mute == NULL) { + ALOGE("dlsym: Error:%s Loading csd_mic_mute", dlerror()); + } else { + ALOGD("%s: calling csd_mic_mute, state=%d", __func__, adev->mic_mute); + csd_mic_mute(adev->mic_mute); + } + } + + 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; + + /* Respond with a request for stereo if a different format is given. */ + if (config->channel_mask != AUDIO_CHANNEL_IN_STEREO) { + config->channel_mask = AUDIO_CHANNEL_IN_STEREO; + return -EINVAL; + } + + 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; + + /* QCOM CSD-Client */ + if (mCsdHandle) { + if (csd_client_deinit == NULL) { + ALOGE("dlsym: Error:%s Loading csd_client_deinit", dlerror()); + } else { + ALOGD("%s: calling csd_client_deinit", __func__); + csd_client_deinit(); + } + dlclose(mCsdHandle); + mCsdHandle = NULL; + } + + 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; + char property[PROPERTY_VALUE_MAX]; + char file[80]; + int ret = 0; + bool eof = false; + int len; + + property_get("ro.product.device", property, "tiny_hw"); + snprintf(file, sizeof(file), "/system/etc/sound/%s", property); + + ALOGV("Reading configuration from %s\n", file); + f = fopen(file, "r"); + if (!f) { + ALOGE("Failed to open %s\n", 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(file, 1, sizeof(file), f); + if (ferror(f)) { + ALOGE("I/O error reading config\n"); + ret = -EIO; + goto out_parser; + } + eof = feof(f); + + if (XML_Parse(p, file, 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->pcm_bt_dl = NULL; + adev->pcm_bt_ul = NULL; + adev->voice_volume = 1.0f; + adev->tty_mode = TTY_MODE_OFF; + adev->bluetooth_nrec = true; + + /* QCOM CSD-Client */ + mCsdHandle = dlopen(CSD_CLIENT_LIBPATH, RTLD_NOW); + if (mCsdHandle == NULL) { + ALOGE("DLOPEN not successful for CSD CLIENT"); + } else { + ALOGD("DLOPEN successful for CSD CLIENT"); + setCsdHandle(mCsdHandle); + + if (csd_client_init == NULL) { + ALOGE("dlsym: Error:%s Loading csd_client_init", dlerror()); + } else { + ALOGD("%s: calling csd_client_init", __func__); + csd_client_init(); + } + } + + pthread_mutex_unlock(&adev->lock); + + *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 = "T0LTE 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..30bdf01 --- /dev/null +++ b/audio/audio_hw.h @@ -0,0 +1,302 @@ +/* + * 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. + */ + +/* 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 1056 +#define CAPTURE_PERIOD_COUNT 2 + +#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 + +/* product-specific defines */ +#define PRODUCT_DEVICE_PROPERTY "ro.product.device" +#define PRODUCT_NAME_PROPERTY "ro.product.name" + +#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 +}; + +/* ACDB Device ID macros */ +#define DEVICE_HANDSET_RX_ACDB_ID 7 // HANDSET_SPKR +#define DEVICE_HANDSET_TX_ACDB_ID 4 // HANDSET_MIC +#define DEVICE_SPEAKER_RX_ACDB_ID 15// SPKR_PHONE_SPKR_STEREO +#define DEVICE_SPEAKER_MONO_RX_ACDB_ID 14// SPKR_PHONE_SPKR_MONO +#define DEVICE_SPEAKER_STEREO_RX_ACDB_ID 15// SPKR_PHONE_SPKR_STEREO +#define DEVICE_SPEAKER_TX_ACDB_ID 11// SPKR_PHONE_MIC +#define DEVICE_HEADSET_RX_ACDB_ID 10// HEADSET_SPKR_STEREO +#define DEVICE_HEADSET_TX_ACDB_ID 8 // HEADSET_MIC +#define DEVICE_DUALMIC_HANDSET_TX_BROADSIDE_ACDB_ID 5 // HANDSET_MIC_BROADSIDE +#define DEVICE_DUALMIC_HANDSET_TX_ENDFIRE_ACDB_ID 6 // HANDSET_MIC_ENDFIRE +#define DEVICE_DUALMIC_SPEAKER_TX_BROADSIDE_ACDB_ID 12// SPKR_PHONE_MIC_BROADSIDE +#define DEVICE_DUALMIC_SPEAKER_TX_ENDFIRE_ACDB_ID 13// SPKR_PHONE_MIC_ENDFIRE +#define DEVICE_DUALMIC_HANDSET_STEREO_ACDB_ID 34 +#define DEVICE_DUALMIC_SPEAKER_PHONE_STEREO_ACDB_ID 35 +#define DEVICE_TTY_HEADSET_MONO_RX_ACDB_ID 17// TTY_HEADSET_SPKR +#define DEVICE_TTY_HEADSET_MONO_TX_ACDB_ID 16// TTY_HEADSET_MIC +#define DEVICE_BT_SCO_RX_ACDB_ID 22// BT_SCO_SPKR +#define DEVICE_BT_SCO_TX_ACDB_ID 21// BT_SCO_SPKR +#define DEVICE_BT_SCO_RX_WB_ACDB_ID 39// BT_SCO_WB_SPKR +#define DEVICE_BT_SCO_TX_WB_ACDB_ID 38// BT_SCO_WB_MIC +#define DEVICE_SPEAKER_HEADSET_RX_ACDB_ID DEVICE_HEADSET_RX_ACDB_ID // Use headset calibration +#define DEVICE_HDMI_STEREO_RX_ACDB_ID 18// HDMI_SPKR +#define DEVICE_ANC_HEADSET_STEREO_RX_ACDB_ID 26// ANC RX, same as regular headset +#define DEVICE_QUADMIC_ACDB_ID 19// QUADMIC_SKPR +#define DEVICE_PROXY_RX_ACDB_ID DEVICE_HDMI_STEREO_RX_ACDB_ID +#define DEVICE_TTY_VCO_HANDSET_TX_ACDB_ID 36// TTY_VCO_HANDSET_MIC +#define DEVICE_TTY_HCO_HANDSET_RX_ACDB_ID 37// TTY_HCO_HANDSET_SPRK +#define DEVICE_HANDSET_TX_FV5_ACDB_ID 40 +#define DEVICE_DUALMIC_HANDSET_TX_ENDFIRE_FV5_ACDB_ID 41 +#define DEVICE_SPEAKER_TX_FV5_ACDB_ID 42 +#define DEVICE_DUALMIC_SPEAKER_TX_ENDFIRE_FV5_ACDB_ID 43 +#define DEVICE_INCALL_VOICE_RECORD_STEREO_ACDB_ID 45 +#define DEVICE_INCALL_MUSIC_DELIVERY_MONO_ACDB_ID 46 +#define DEVICE_INCALL_VOICE_RECORD_MONO_ACDB_ID 47 +#define DEVICE_CAMCORDER_TX_ACDB_ID 61// CAMCORDER_TX +#define DEVICE_VOICE_RECOGNITION_ACDB_ID 62// VOICE_RECOGNITION + +#define ANC_FLAG 0x00000001 +#define DMIC_FLAG 0x00000002 +#define QMIC_FLAG 0x00000004 +#define TTY_OFF 0x00000010 +#define TTY_FULL 0x00000020 +#define TTY_VCO 0x00000040 +#define TTY_HCO 0x00000080 +#define TTY_CLEAR 0xFFFFFF0F + +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 = "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 = "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 IN2L 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 = "MainMicBias Mode", .intval = 1, }, + { .ctl_name = "IN2L Volume", .intval = 28, }, + { .ctl_name = "MIXINL IN2L Switch", .intval = 1, }, + { .ctl_name = "MIXINL IN2L 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 = "IN2L Volume", .intval = 4, }, + { .ctl_name = "MIXINL IN2L Switch", .intval = 0, }, + { .ctl_name = "AIF1ADC1 HPF Switch", .intval = 0, }, + { .ctl_name = NULL, }, +}; + +struct route_setting noise_suppression[] = { + { .ctl_name = "Sub Mic Switch", .intval = 1, }, + { .ctl_name = "IN1R Volume", .intval = 25, }, + { .ctl_name = "MIXINR IN1R Switch", .intval = 1, }, + { .ctl_name = "MIXINR IN1R Volume", .intval = 0, }, + { .ctl_name = "AIF1ADCR Source", .intval = 1, }, + { .ctl_name = NULL, }, +}; + +struct route_setting noise_suppression_disable[] = { + { .ctl_name = "Sub Mic Switch", .intval = 0, }, + { .ctl_name = "IN1R Volume", .intval = 7, }, + { .ctl_name = "MIXINR IN1R Switch", .intval = 0, }, + { .ctl_name = "MIXINR IN1R Volume", .intval = 0, }, + { .ctl_name = NULL, }, +}; + +struct route_setting headset_input[] = { + { .ctl_name = "MIXINL IN2L Switch", .intval = 0, }, + { .ctl_name = "MIXINR IN1R Switch", .intval = 0, }, + { .ctl_name = "Headset Mic Switch", .intval = 1, }, + { .ctl_name = "IN1L Volume", .intval = 18, }, + { .ctl_name = "MIXINL IN1L Switch", .intval = 1, }, + { .ctl_name = "MIXINL IN1L 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 = NULL, }, +}; + +struct route_setting headset_input_disable[] = { + { .ctl_name = "Headset Mic Switch", .intval = 0, }, + { .ctl_name = "MIXINL IN1L 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 = "AIF1DAC1 Volume", .intval = 96, }, + { .ctl_name = "AIF1 Boost Volume", .intval = 0, }, + { .ctl_name = "DAC2 Volume", .intval = 96, }, + { .ctl_name = "AIF2ADC Volume", .intval = 96, }, + { .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 = "MIXINL IN1L Volume", .intval = 1, }, + { .ctl_name = "IN2L Volume", .intval = 25, }, + { .ctl_name = "IN1R Volume", .intval = 25, }, + { .ctl_name = "LINEOUT1N Switch", .intval = 0, }, + { .ctl_name = "LINEOUT1P Switch", .intval = 0, }, + { .ctl_name = "AIF1ADC1 HPF Switch", .intval = 0, }, + { .ctl_name = "AIF2ADC HPF Mode", .intval = 3, }, + { .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 = "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 = "AIF1DAC1 Volume", .intval = 96, }, + { .ctl_name = "AIF1 Boost Volume", .intval = 0, }, + { .ctl_name = "DAC2 Volume", .intval = 96, }, + { .ctl_name = "AIF2ADC Volume", .intval = 96, }, + { .ctl_name = "AIF2ADC Mux", .intval = 0, }, + { .ctl_name = "MIXINL IN1L 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/bluetooth/bdroid_buildcfg.h b/bluetooth/bdroid_buildcfg.h new file mode 100644 index 0000000..6aa5a1b --- /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 S III LTE" + +#endif diff --git a/cm.dependencies b/cm.dependencies new file mode 100644 index 0000000..a1ab9d7 --- /dev/null +++ b/cm.dependencies @@ -0,0 +1,14 @@ +[ + { + "repository": "android_device_samsung_smdk4412-common", + "target_path": "device/samsung/smdk4412-common" + }, + { + "repository": "android_kernel_samsung_smdk4412", + "target_path": "kernel/samsung/smdk4412" + }, + { + "repository": "android_hardware_samsung", + "target_path": "hardware/samsung" + } +] diff --git a/cm.mk b/cm.mk new file mode 100644 index 0000000..4fc3092 --- /dev/null +++ b/cm.mk @@ -0,0 +1,25 @@ +# Specify phone tech before including full_phone +$(call inherit-product, vendor/cm/config/gsm.mk) + +# Release name +PRODUCT_RELEASE_NAME := i9305 + +# Boot animation +TARGET_SCREEN_HEIGHT := 1280 +TARGET_SCREEN_WIDTH := 720 + +# Inherit some common CM stuff. +$(call inherit-product, vendor/cm/config/common_full_phone.mk) + +# Inherit device configuration +$(call inherit-product, device/samsung/i9305/full_i9305.mk) + +# Device identifier. This must come after all inclusions +PRODUCT_DEVICE := i9305 +PRODUCT_NAME := cm_i9305 +PRODUCT_BRAND := samsung +PRODUCT_MODEL := GT-I9305 +PRODUCT_MANUFACTURER := samsung + +# Set build fingerprint / ID / Product Name ect. +PRODUCT_BUILD_PROP_OVERRIDES += PRODUCT_NAME=m3xx TARGET_DEVICE=m3 BUILD_FINGERPRINT="samsung/m3xx/m3:4.1.2/JZO54K/I9305XXBMA6:user/release-keys" PRIVATE_BUILD_DESC="m3xx-user 4.1.2 JZO54K I9305XXBMA6 release-keys" diff --git a/configs/80cfw b/configs/80cfw new file mode 100644 index 0000000..ba04436 --- /dev/null +++ b/configs/80cfw @@ -0,0 +1,10 @@ +#!/system/bin/sh +# +# Copy camera firmware to /data/cfw +# + +busybox cp /system/vendor/firmware/SlimISP_GD.bin /data/cfw/SlimISP_GD.bin +busybox cp /system/vendor/firmware/SlimISP_ZD.bin /data/cfw/SlimISP_ZD.bin +busybox chown system /data/cfw/* +busybox chgrp media /data/cfw/* +busybox chmod 0775 /data/cfw/* diff --git a/configs/gps.conf b/configs/gps.conf new file mode 100644 index 0000000..6576285 --- /dev/null +++ b/configs/gps.conf @@ -0,0 +1,102 @@ +#Test +NTP_SERVER=time.gpsonextra.net +#Asia +# NTP_SERVER=asia.pool.ntp.org +#Europe +# NTP_SERVER=europe.pool.ntp.org +#North America +# NTP_SERVER=north-america.pool.ntp.org + +XTRA_SERVER_1=http://xtra1.gpsonextra.net/xtra2.bin +XTRA_SERVER_2=http://xtra2.gpsonextra.net/xtra2.bin +XTRA_SERVER_3=http://xtra3.gpsonextra.net/xtra2.bin + +# DEBUG LEVELS: 0 - none, 1 - Error, 2 - Warning, 3 - Info +# 4 - Debug, 5 - Verbose +DEBUG_LEVEL = 4 + +# Intermediate position report, 1=enable, 0=disable +INTERMEDIATE_POS=0 + +# supl version 1.0 +SUPL_VER=0x10000 + +# Error Estimate +# _SET = 1 +# _CLEAR = 0 +ERR_ESTIMATE=0 + +# GPS Capabilities bit mask +# SCHEDULING = 1 +# MSB = 2 +# MSA = 4 +# ULP = 0x20 +# ON_DEMAND_TIME = 0x10 // yunu.lee +# default = MSA | MSB | SCHEDULING | ULP +CAPABILITIES=0x16 + +# Accuracy threshold for intermediate positions +# less accurate positions are ignored, 0 for passing all positions +# ACCURACY_THRES=5000 + +################################ +##### AGPS server settings ##### +################################ + +# FOR SUPL SUPPORT, set the following +# SUPL_HOST=supl.host.com or IP +# SUPL_PORT=1234 + +# FOR C2K PDE SUPPORT, set the following +# C2K_HOST=c2k.pde.com or IP +# C2K_PORT=1234 + +################################ +# Sensor Settings +################################ + +# Needs to be set explicitly based on sensor +# There is no default value. +GYRO_BIAS_RANDOM_WALK=0.00001 + +# Sensor Sampling Rate Parameters for Low-Data Rate Filter (should be greater than 0) +SENSOR_ACCEL_BATCHES_PER_SEC=3 +SENSOR_ACCEL_SAMPLES_PER_BATCH=5 +SENSOR_GYRO_BATCHES_PER_SEC=3 +SENSOR_GYRO_SAMPLES_PER_BATCH=5 +# Sensor Sampling Rate Parameters for High-Data Rate Filter (should be greater than 0) +SENSOR_ACCEL_BATCHES_PER_SEC_HIGH=4 +SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH=25 +SENSOR_GYRO_BATCHES_PER_SEC_HIGH=4 +SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH=25 + +# INS Filter Mode (0=Enable, 1=Disable) +SENSOR_ALGORITHM_CONFIG_MASK=1 + +# Sensor Control Mode (0=AUTO, 1=FORCE_ON) +SENSOR_CONTROL_MODE=0 + +# Enable or Disable Sensors for GPS use (0=Enable, 1=Disable) +SENSOR_USAGE=0 + +# Choose GSIFF sensor provider (1=DSPS, 2=Android NDK) +SENSOR_PROVIDER=2 + +################################ +# Indoor Positioning Settings +################################ +# 0: QUIPC disabled, 1: QUIPC enabled, 2: forced QUIPC only +QUIPC_ENABLED = 0 + +################################ +# EXTRA SETTINGS +################################ +# Enable or Disable Wiper (1=Enable, 0=Disable) +ENABLE_WIPER=0 + +#################################### +# LTE Positioning Profile Settings +#################################### +# 0: Enable RRLP on LTE(Default) 1: Enable LPP_User_Plane on LTE +LPP_PROFILE = 0 + diff --git a/configs/nfcee_access.xml b/configs/nfcee_access.xml new file mode 100644 index 0000000..02e12fd --- /dev/null +++ b/configs/nfcee_access.xml @@ -0,0 +1,11 @@ + + + + + + + + diff --git a/configs/nfcee_access_debug.xml b/configs/nfcee_access_debug.xml new file mode 100644 index 0000000..a96a2d1 --- /dev/null +++ b/configs/nfcee_access_debug.xml @@ -0,0 +1,17 @@ + + + + + + + + + + + + + + diff --git a/configs/tiny_hw.xml b/configs/tiny_hw.xml new file mode 100644 index 0000000..365f5d1 --- /dev/null +++ b/configs/tiny_hw.xml @@ -0,0 +1,353 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/extract-files.sh b/extract-files.sh new file mode 100755 index 0000000..b65c3dd --- /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=i9305 + +mkdir -p ../../../vendor/$VENDOR/$DEVICE/proprietary + +adb root +adb wait-for-device + +echo "Pulling proprietary files..." +for FILE in `cat 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/smdk4412-common/extract-files.sh diff --git a/full_i9305.mk b/full_i9305.mk new file mode 100644 index 0000000..9e02ef2 --- /dev/null +++ b/full_i9305.mk @@ -0,0 +1,35 @@ +# 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 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_telephony.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/i9305/i9305.mk) + +# Discard inherited values and use our own instead. +PRODUCT_NAME := full_i9305 +PRODUCT_DEVICE := i9305 +PRODUCT_BRAND := samsung +PRODUCT_MANUFACTURER := samsung +PRODUCT_MODEL := GT-I9305 diff --git a/i9305.mk b/i9305.mk new file mode 100644 index 0000000..81bf693 --- /dev/null +++ b/i9305.mk @@ -0,0 +1,96 @@ +# +# 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 := device/samsung/i9305 + +# Overlay +DEVICE_PACKAGE_OVERLAYS += $(LOCAL_PATH)/overlay + +# This device is xhdpi. However the platform doesn't +# currently contain all of the bitmaps at xhdpi density so +# we do this little trick to fall back to the hdpi version +# if the xhdpi doesn't exist. +PRODUCT_AAPT_CONFIG := normal hdpi xhdpi +PRODUCT_AAPT_PREF_CONFIG := xhdpi + +# Init files +PRODUCT_COPY_FILES += \ + $(LOCAL_PATH)/rootdir/fstab.smdk4x12:root/fstab.smdk4x12 \ + $(LOCAL_PATH)/rootdir/init.smdk4x12.rc:root/init.smdk4x12.rc \ + $(LOCAL_PATH)/rootdir/lpm.rc:root/lpm.rc \ + $(LOCAL_PATH)/rootdir/ueventd.smdk4x12.rc:root/ueventd.smdk4x12.rc + +# Audio +PRODUCT_COPY_FILES += \ + $(LOCAL_PATH)/configs/tiny_hw.xml:system/etc/sound/m3 + +# Gps +PRODUCT_COPY_FILES += \ + $(LOCAL_PATH)/configs/gps.conf:system/etc/gps.conf + +# Camera FW +PRODUCT_COPY_FILES += \ + $(LOCAL_PATH)/configs/80cfw:system/etc/init.d/80cfw + +# Product specific Packages +PRODUCT_PACKAGES += \ + GalaxyS3Settings + +# NFC +PRODUCT_PACKAGES += \ + nfc.exynos4 \ + libnfc \ + libnfc_jni \ + Nfc \ + Tag + +PRODUCT_COPY_FILES += \ + packages/apps/Nfc/migrate_nfc.txt:system/etc/updatecmds/migrate_nfc.txt \ + frameworks/base/nfc-extras/com.android.nfc_extras.xml:system/etc/permissions/com.android.nfc_extras.xml \ + frameworks/native/data/etc/android.hardware.nfc.xml:system/etc/permissions/android.hardware.nfc.xml + +# NFCEE access control +ifeq ($(TARGET_BUILD_VARIANT),user) + NFCEE_ACCESS_PATH := $(LOCAL_PATH)/configs/nfcee_access.xml +else + NFCEE_ACCESS_PATH := $(LOCAL_PATH)/configs/nfcee_access_debug.xml +endif + +PRODUCT_COPY_FILES += \ + $(NFCEE_ACCESS_PATH):system/etc/nfcee_access.xml + +PRODUCT_PACKAGES += \ + com.android.nfc_extras + +$(call inherit-product, vendor/cm/config/nfc_enhanced.mk) + +# RIL +PRODUCT_PROPERTY_OVERRIDES += \ + ro.telephony.ril_class=SamsungQualcommD2RIL \ + telephony.lteOnGsmDevice=1 \ + mobiledata.interfaces=pdp0,wlan0,gprs,ppp0 \ + ro.ril.hsxpa=1 \ + ro.ril.gprsclass=10 + +# These are the hardware-specific features +PRODUCT_COPY_FILES += \ + frameworks/native/data/etc/handheld_core_hardware.xml:system/etc/permissions/handheld_core_hardware.xml \ + frameworks/native/data/etc/android.hardware.telephony.gsm.xml:system/etc/permissions/android.hardware.telephony.gsm.xml + +# Include common makefile +$(call inherit-product, device/samsung/smdk4412-common/common.mk) + +$(call inherit-product-if-exists, vendor/samsung/i9305/i9305-vendor.mk) 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..7ac03e4 --- /dev/null +++ b/overlay/frameworks/base/core/res/res/values/config.xml @@ -0,0 +1,118 @@ + + + + + + + + false + + + + + + + + "wifi,1,1,1,-1,true" + "mobile,0,0,0,-1,true" + "mobile_mms,2,0,2,60000,true" + "mobile_supl,3,0,2,60000,true" + "mobile_dun,4,0,3,60000,true" + "mobile_hipri,5,0,3,60000,true" + "mobile_bluetooth,7,7,1,-1,true" + "wifi_p2p,13,1,0,-1,true" + + + + + "1,1" + "0,1" + "7,1" + + + + + "rndis0" + + + + + + 0 + 1 + 5 + 7 + + + + pdp0 + + + true + + + true + + + true + + + #ffffffff + + + 1000 + + + 9000 + + + true + + + false + + + true + + + 7 + + + true + + 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..3501baa --- /dev/null +++ b/overlay/frameworks/base/core/res/res/xml/power_profile.xml @@ -0,0 +1,69 @@ + + + + + + 0 + 71 + 17 + 0.3 + 35690 + 380 + 0.3 + 96 + 70 + 44 + 280 + 250 + + 82 + 50 + + + 3.4 + 3.4 + + + + 200000 + 500000 + 800000 + 1000000 + 1200000 + 1400000 + 1600000 + + + 4 + + 44 + + + 55.4 + 82.1 + 113.7 + 140.0 + 170.0 + 200.0 + 230.0 + + + 3100 + 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..d9247c5 --- /dev/null +++ b/overlay/frameworks/base/core/res/res/xml/storage_list.xml @@ -0,0 +1,52 @@ + + + + + + + + + + + + diff --git a/overlay/frameworks/base/packages/SystemUI/res/values/config.xml b/overlay/frameworks/base/packages/SystemUI/res/values/config.xml new file mode 100644 index 0000000..88851f7 --- /dev/null +++ b/overlay/frameworks/base/packages/SystemUI/res/values/config.xml @@ -0,0 +1,26 @@ + + + + + + + true + + diff --git a/overlay/packages/apps/Phone/res/values/config.xml b/overlay/packages/apps/Phone/res/values/config.xml new file mode 100644 index 0000000..35eae87 --- /dev/null +++ b/overlay/packages/apps/Phone/res/values/config.xml @@ -0,0 +1,30 @@ + + + + + + + true + + + noise_suppression=true=false + + + 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..d4611e2 --- /dev/null +++ b/overlay/packages/apps/Torch/res/values/config.xml @@ -0,0 +1,36 @@ + + + + + + + false + + + /sys/class/camera/flash/rear_flash + + + 1 + + 10 + + 15 + + diff --git a/proprietary-files.txt b/proprietary-files.txt new file mode 100644 index 0000000..ce78ef5 --- /dev/null +++ b/proprietary-files.txt @@ -0,0 +1,49 @@ +system/bin/at_distributor +system/bin/efsks +system/bin/gsiff_daemon +system/bin/ks +system/bin/netmgrd +system/bin/qcks +system/bin/qmiproxy +system/bin/qmuxd +system/bin/rild +system/bin/sec-ril +system/bin/smdexe +system/etc/Diag.cfg +system/etc/Diag_zero.cfg +system/lib/libakm.so +system/lib/libatparser.so +system/lib/libcsd-client.so +system/lib/libdiag.so +system/lib/libdsi_netctrl.so +system/lib/libdsutils.so +system/lib/libfactoryutil.so +system/lib/libgps.so +system/lib/libgps.utils.so +system/lib/libidl.so +system/lib/libloc_adapter.so +system/lib/libloc_api_v02.so +system/lib/libloc_eng.so +system/lib/libnetmgr.so +system/lib/libomission_avoidance.so +system/lib/libqcci_legacy.so +system/lib/libqdi.so +system/lib/libqdp.so +system/lib/libqmi.so +system/lib/libqmi_cci.so +system/lib/libqmi_client_qmux.so +system/lib/libqmi_common_so.so +system/lib/libqmi_csi.so +system/lib/libqmi_encdec.so +system/lib/libqmiservices.so +system/lib/libril.so +system/lib/libril-qc-qmi-1.so +system/lib/libril-qcril-hook-oem.so +system/lib/libsecnativefeature.so +system/lib/libsecril-client.so +system/lib/hw/vendor-camera.exynos4.so +system/lib/hw/gps.default.so +system/lib/hw/sensors.smdk4x12.so +system/usr/keylayout/sec_touchkey.kl +system/vendor/firmware/SlimISP_GD.bin +system/vendor/firmware/SlimISP_ZD.bin diff --git a/recovery.fstab b/recovery.fstab new file mode 100644 index 0000000..14e7e67 --- /dev/null +++ b/recovery.fstab @@ -0,0 +1,12 @@ +# mount point fstype device device2 +/efs ext4 /dev/block/mmcblk0p3 +/boot emmc /dev/block/mmcblk0p8 +/recovery emmc /dev/block/mmcblk0p9 +/cache ext4 /dev/block/mmcblk0p12 +/system ext4 /dev/block/mmcblk0p13 +/data ext4 /dev/block/mmcblk0p16 length=-16384 +/preload ext4 /dev/block/mmcblk0p14 +/modem emmc /dev/block/mmcblk0p10 + +/sdcard datamedia /dev/null +/external_sd vfat /dev/block/mmcblk1p1 diff --git a/rootdir/fstab.smdk4x12 b/rootdir/fstab.smdk4x12 new file mode 100644 index 0000000..d4c03f3 --- /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/mmcblk0p13 /system ext4 ro wait +/dev/block/mmcblk0p3 /efs ext4 noatime,nosuid,nodev,journal_async_commit,errors=panic wait,check +/dev/block/mmcblk0p12 /cache ext4 noatime,nosuid,nodev,journal_async_commit,errors=panic wait,check +/dev/block/mmcblk0p16 /data ext4 noatime,nosuid,nodev,discard,noauto_da_alloc,journal_async_commit,errors=panic wait,check,encryptable=footer +/dev/block/mmcblk0p11 /tombstones ext4 noatime,nosuid,nodev,journal_async_commit,errors=panic wait,check diff --git a/rootdir/init.smdk4x12.rc b/rootdir/init.smdk4x12.rc new file mode 100755 index 0000000..936e87a --- /dev/null +++ b/rootdir/init.smdk4x12.rc @@ -0,0 +1,609 @@ +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 + # WFD CES Demo + chmod 0666 /dev/graphics/fb5 + + # 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 + +#MDM requirement + mkdir /firmware 0771 system system + mount vfat /dev/block/mmcblk0p10 /firmware ro shortname=lower fmask=0133,dmask=0022 + chown system system /tombstones + chmod 0775 /tombstones + mkdir /tombstones/modem 0775 system system + mkdir /tombstones/lpass 0775 system system + mkdir /tombstones/wcnss 0775 system system + mkdir /tombstones/dsps 0775 system system + rmdir /tombstones/qcks + mkdir /tombstones/qcks 771 system system + rmdir /tombstones/efs + mkdir /tombstones/efs 771 system system + + chown system radio /dev/block/platform/dw_mmc/by-name + chmod 0775 /dev/block/platform/dw_mmc/by-name + +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 + +#QCRIL + + #Create QMUX deamon socket area + mkdir /dev/socket/qmux_radio 0770 radio radio + chmod 2770 /dev/socket/qmux_radio + mkdir /dev/socket/qmux_audio 0770 media audio + chmod 2770 /dev/socket/qmux_audio + mkdir /dev/socket/qmux_gps 0770 gps gps + chmod 2770 /dev/socket/qmux_gps + + # Allow QMUX daemon to assign port open wait time + chown radio radio /sys/devices/virtual/hsicctl/hsicctl0/modem_wait + + # To prevent out of order acknowledgements from making + # connection tracking to treat them as not belonging to + # the connection they belong to. + # Otherwise, a weird issue happens in which some long + # connections on high-throughput links get dropped when + # an ack packet comes out of order + write /proc/sys/net/netfilter/nf_conntrack_tcp_be_liberal 1 + +# for AT distributor + chown system radio /sys/module/cpuidle_exynos4/parameters/enable_mask + chmod 0664 /sys/module/cpuidle_exynos4/parameters/enable_mask + +# Waketime fot fast dormancy + chown system radio /sys/devices/platform/mdm_hsic_pm0/waketime + chmod 0660 /sys/devices/platform/mdm_hsic_pm0/waketime + +# 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 + +# 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_GD.bin + chmod 0775 /data/cfw/SlimISP_GD.bin + chown system media /data/cfw/SlimISP_ZD.bin + chmod 0775 /data/cfw/SlimISP_ZD.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 + write /data/ISP_CV 1 + + symlink /dev/block/mmcblk0p7 /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 + +# NFC + setprop ro.nfc.port "I2C" + chmod 0600 /dev/pn544 + chown nfc nfc /dev/pn544 + +# Vibrator + chmod 0660 /dev/tspdrv + chown root shell /dev/tspdrv + chmod 0660 /sys/vibrator/pwm_val + chown system system /sys/vibrator/pwm_val + +# LED + chmod 0660 /sys/class/sec/led/led_fade + chown system system /sys/class/sec/led/led_fade + +# Touchkey + chmod 0660 /sys/class/sec/sec_touchkey/timeout + chown system system /sys/class/sec/sec_touchkey/timeout + chmod 0660 /sys/class/sec/sec_touchkey/force_disable + chown system system /sys/class/sec/sec_touchkey/force_disable + +# Permissions for LCD + chown system radio /sys/class/lcd/panel/lcd_power + chown system radio /sys/class/lcd/panel/lcd_type + chown system radio /sys/class/lcd/panel/device/hs_toggle + chown system media_rw /sys/class/lcd/panel/power_reduce + chown system system /sys/class/backlight/panel/auto_brightness + chown system system /sys/class/backlight/panel/brightness + chown system system /sys/class/graphics/fb0/lcdfreq/level + +# 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 + write /sys/class/mdnie/mdnie/scenario 0 + write /sys/class/mdnie/mdnie/mode 0 + +# 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_reset_soc + chown system radio /sys/class/power_supply/battery/batt_read_raw_soc + chown system radio /sys/class/power_supply/battery/batt_read_adj_soc + chown system radio /sys/class/power_supply/battery/batt_type + chown system radio /sys/class/power_supply/battery/batt_temp_adc + chown system radio /sys/class/power_supply/battery/batt_temp_aver + chown system radio /sys/class/power_supply/battery/batt_temp_adc_aver + chown system radio /sys/class/power_supply/battery/batt_vfocv + chown system radio /sys/class/power_supply/battery/batt_lp_charging + chown system radio /sys/class/power_supply/battery/batt_charging_source + chown system radio /sys/class/power_supply/battery/test_mode + chown system radio /sys/class/power_supply/battery/wc_status + chown system radio /sys/class/power_supply/battery/wpc_pin_state + +# 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 + +# 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 + +# SVC LED + chown system system /sys/class/sec/led/led_r + chown system system /sys/class/sec/led/led_g + chown system system /sys/class/sec/led/led_b + + chown system system /sys/class/leds/led_r/brightness + chown system system /sys/class/leds/led_g/brightness + chown system system /sys/class/leds/led_b/brightness + chown system system /sys/class/leds/led_r/delay_on + chown system system /sys/class/leds/led_g/delay_on + chown system system /sys/class/leds/led_b/delay_on + chown system system /sys/class/leds/led_r/delay_off + chown system system /sys/class/leds/led_g/delay_off + chown system system /sys/class/leds/led_b/delay_off + chown system system /sys/class/leds/led_r/blink + chown system system /sys/class/leds/led_g/blink + chown system system /sys/class/leds/led_b/blink + + chown system system /sys/class/sec/led/led_pattern + chown system system /sys/class/sec/led/led_blink + chown system system /sys/class/sec/led/led_br_lev + +# +# Input Events + chown system radio /sys/class/input/input2/enable + chown system radio /sys/class/input/input2/poll_delay + chown system radio /sys/class/input/input3/enable + chown system radio /sys/class/input/input3/poll_delay + chown system radio /sys/class/input/input4/enable + chown system radio /sys/class/input/input4/poll_delay + chown system radio /sys/class/input/input5/enable + chown system radio /sys/class/input/input5/poll_delay + chown system radio /sys/class/input/input6/enable + chown system radio /sys/class/input/input6/poll_delay + chown system radio /sys/class/input/input7/enable + chown system radio /sys/class/input/input7/poll_delay + chown system radio /sys/class/input/input8/enable + chown system radio /sys/class/input/input8/poll_delay + chown system radio /sys/class/input/input9/enable + chown system radio /sys/class/input/input9/poll_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/input/input7/enable + chown system radio /sys/class/input/input7/poll_delay + 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 +# Gyro_sensor + chown system radio /dev/lsm330dlc_gyro_misc + chown system radio /sys/class/sensors/gyro_sensor/power_on + chown system radio /sys/class/sensors/gyro_sensor/power_off + chown system radio /sys/class/sensors/gyro_sensor/temperature + chown system radio /sys/class/sensors/gyro_sensor/selftest + chown system radio /sys/class/sensors/gyro_sensor/selftest_dps + chown system radio /sys/class/sensors/gyro_sensor/vendor + chown system radio /sys/class/sensors/gyro_sensor/name +# Barometer_sensor + chown system radio /sys/class/input/input5/pressure_reference_level + chown system radio /sys/class/input/input5/temperature_reference_level + chown system radio /sys/class/input/input5/enable_autozero + chown system radio /sys/class/input/input5/compensation_param + chown system radio /sys/class/input/input5/reg_value + chown system radio /sys/class/input/input5/reg_addr + chown system radio /sys/class/sensors/barometer_sensor/sea_level_pressure + chown system radio /sys/class/sensors/barometer_sensor/vendor + chown system radio /sys/class/sensors/barometer_sensor/name + chown system radio /sys/class/sensors/barometer_sensor/calibration +# Magnetic_sensor + chown system radio /dev/akm8975 + 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 + +# 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 + +# 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 + +# serial keyboard port + chown root system /dev/ttySAC2 + chmod 0660 /dev/ttySAC2 + +# 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 + +# 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/ttySAC2 + 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 +# write /proc/sys/net/ipv6/conf/rmnet_usb0/accept_ra 2 +# write /proc/sys/net/ipv6/conf/rmnet_usb1/accept_ra 2 +# write /proc/sys/net/ipv6/conf/rmnet_usb2/accept_ra 2 +# write /proc/sys/net/ipv6/conf/rmnet_usb3/accept_ra 2 +# SISO-ANDR_PERF :: END + +on property:ro.uart_debug=0 + start sec_keyboard + +# 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 + +# AT Distributor for factory test +service at_distributor /system/bin/at_distributor + class main + user root + group radio log + +# diag app for cp uart +service diag_uart_log /system/bin/diag_uart_log + class main + user root + group radio + +#service cpboot-daemon /sbin/cbd -d -p 10 +# class main +# user root +# group radio cache inet misc audio sdcard_rw log + +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 + +#service secstarter /system/bin/secstarter +#NOT NEEDED +# class main +# user system +# group system + +service macloader /system/bin/macloader + class main + oneshot + +service netmgrd /system/bin/netmgrd + class late_start + +service SMD-daemon /system/bin/smdexe + class main + user root + group system radio inet net_raw + +service qc_kickstart /system/bin/qcks s + class core + user root + group radio cache inet misc audio sdcard_rw log + +service secril-daemon /system/bin/sec-ril + class main + user root + group radio cache inet misc audio sdcard_rw qcom_diag log + +#For EncryptionMode - remove disabled, Modify class main +service qmiproxy /system/bin/qmiproxy + class main + user radio + group radio gps + +service qmuxd /system/bin/qmuxd + class main + user root + group radio log audio bluetooth gps log + +#start GNSS/Sensor interface daemon +service gsiff_daemon /system/bin/gsiff_daemon + class late_start + user system + group qcom_oncrpc gps + +# TVout +service TvoutService_C /system/bin/bintvoutservice + class main + user system + group graphics + +on property:ro.tvout.enable=false + stop TvoutService_C diff --git a/rootdir/lpm.rc b/rootdir/lpm.rc new file mode 100644 index 0000000..c21c887 --- /dev/null +++ b/rootdir/lpm.rc @@ -0,0 +1,77 @@ +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 + mount ext4 /dev/block/mmcblk0p13 /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 /system/bin/sh + console + +service playlpm /system/bin/playlpm + user root + +service immvibed /system/bin/immvibed + oneshot + +service lpmkey /system/bin/lpmkey + 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..39089e3 --- /dev/null +++ b/rootdir/ueventd.smdk4x12.rc @@ -0,0 +1,109 @@ +/dev/mali 0666 system system +/dev/ump 0666 system graphics +/dev/ion 0666 system system +/dev/exynos-mem 0660 system camera + +/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 0666 system system +/dev/video1 0666 system camera +/dev/video2 0666 system system +/dev/video3 0666 system system +/dev/video4 0666 system system +/dev/video11 0666 system system +/dev/video12 0666 system system +/dev/video16 0666 system system +/dev/video20 0666 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 camera +/dev/video29 0666 media camera +/dev/video32 0660 media camera + +/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/i2c-6 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 0666 system graphics +/dev/s5p-mfc 0666 system graphics + +/dev/block/mmcblk0p7 0660 system root +/dev/block/mmcblk0p10 0660 system radio +/dev/block/mmcblk0p4 0660 system radio +/dev/block/mmcblk0p5 0660 system radio +/dev/block/mmcblk0p6 0660 system radio +/dev/block/mmcblk0p11 0660 system radio +/dev/mdm 0660 system system +#CPRM +/dev/block/mmcblk1 0660 root system +/dev/ttyUSB0 0666 system system +/dev/ttyUSB1 0666 system system +/dev/ttyUSB2 0666 system system +/dev/hsic* 0660 system radio +/dev/usb/lp* 0660 system usb + +/dev/ttySAC* 0660 root system +/dev/umts* 0660 system radio +/dev/lte* 0660 system radio +/dev/cdma* 0660 system radio +/dev/link_pm 0660 system radio + +# for felica +/dev/felica 0666 root root +/dev/felica_pon 0666 root root +/dev/felica_cen 0666 root root +/dev/felica_rfs 0444 root root +/dev/felica_rws 0666 root root +/dev/felica_ant 0666 root root +/dev/felica_int_poll 0400 root root +/dev/felica_uid 0222 root root +# for felica end diff --git a/system.prop b/system.prop new file mode 100644 index 0000000..fbfaa1f --- /dev/null +++ b/system.prop @@ -0,0 +1,17 @@ +# +# system.prop for i9305 +# + +rild.libpath=/system/lib/libril-qc-qmi-1.so +rild.libargs=-d /dev/ttyS0 +ro.sf.lcd_density=320 +ro.lcd_min_brightness=20 + +# System property ril adb log on +persist.radio.adb_log_on=1 + +# For sys info indication +persist.radio.add_power_save=1 + +# System property for SIM +persist.radio.apm_sim_not_pwdn=1 -- cgit v1.1