psmattas/device_motorola_sanders
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

sanders: bye shims

Browse Source
This commit is contained in:
Vachounet
2018-06-01 16:52:37 +02:00
committed by therootlord
parent 23ad650025
commit 84b87de13c
9 changed files with 2 additions and 861 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
BoardConfig.mk
View File

@@ -210,14 +210,6 @@ TARGET_RELEASETOOLS_EXTENSIONS := $(DEVICE_PATH)/releasetools
#include device/qcom/sepolicy/sepolicy.mk
#BOARD_SEPOLICY_DIRS += $(DEVICE_PATH)/sepolicy
# Shim
TARGET_LD_SHIM_LIBS := \
/vendor/bin/adspd|libshim_adsp.so \
/system/lib/lib_motsensorlistener.so|libsensor.so \
/system/lib/libjustshoot.so|libshims_camera.so \
/system/vendor/lib/libguy.so|libshim_camera_hal.so \
/vendor/lib64/libmdmcutback.so|libqsap_shim.so
# Wifi
BOARD_HAS_QCOM_WLAN := true
BOARD_HAS_QCOM_WLAN_SDK := true

13
device.mk
View File

@@ -71,7 +71,6 @@ PRODUCT_PACKAGES += \
audio.usb.default \
audio.r_submix.default \
libaudio-resampler \
libshim_adsp \
libtinycompress \
audiod
@@ -114,9 +113,7 @@ PRODUCT_PACKAGES += \
android.hardware.camera.provider@2.4-impl \
android.hardware.camera.provider@2.4-service \
vendor.qti.hardware.camera.device@1.0 \
vendor.qti.hardware.camera.device@1.0_vendor \
libshim_camera_hal \
libshims_camera
vendor.qti.hardware.camera.device@1.0_vendor
PRODUCT_COPY_FILES += \
$(LOCAL_PATH)/configs/camera/imx219_chromatix.xml:$(TARGET_COPY_OUT_VENDOR)/etc/camera/imx219_chromatix.xml \
@@ -206,9 +203,7 @@ PRODUCT_PACKAGES += \
libgnsspps \
android.hardware.gnss@1.0-impl-qti \
android.hardware.gnss@1.0-impl \
android.hardware.gnss@1.0-service-qti \
libqsap_sdk \
libqsap_shim
android.hardware.gnss@1.0-service-qti
# health
PRODUCT_PACKAGES += \
@@ -369,10 +364,6 @@ PRODUCT_PACKAGES += \
android.hardware.sensors@1.0-service_32 \
sensorservice_32
# Shims
PRODUCT_PACKAGES += \
libqsap_shim
# Thermal
PRODUCT_COPY_FILES += \
$(LOCAL_PATH)/configs/thermal-engine-sanders.conf:$(TARGET_COPY_OUT_VENDOR)/etc/thermal-engine.conf

53
libshims/Android.mk
View File

@@ -1,53 +0,0 @@
#
# Copyright (C) 2016 The CyanogenMod Project
# Copyright (C) 2017 The LineageOS 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)
# ADSP
include $(CLEAR_VARS)
LOCAL_C_INCLUDES := external/tinyalsa/include
LOCAL_SRC_FILES := mixer.c
LOCAL_MODULE := libshim_adsp
LOCAL_MODULE_TAGS := optional
include $(BUILD_SHARED_LIBRARY)
include $(CLEAR_VARS)
LOCAL_SRC_FILES := camera_hal.cpp
LOCAL_MODULE := libshim_camera_hal
LOCAL_MODULE_TAGS := optional
LOCAL_SHARED_LIBRARIES := libgui
include $(BUILD_SHARED_LIBRARY)
include $(CLEAR_VARS)
LOCAL_SRC_FILES := MediaCodec.cpp
LOCAL_SHARED_LIBRARIES := libstagefright libmedia
LOCAL_MODULE := libshims_camera
LOCAL_MODULE_TAGS := optional
include $(BUILD_SHARED_LIBRARY)
include $(CLEAR_VARS)
LOCAL_SRC_FILES := libqsap_shim.c
LOCAL_SHARED_LIBRARIES := libqsap_sdk liblog
LOCAL_C_INCLUDES := $(TOP)/system/qcom/softap/sdk
LOCAL_MODULE := libqsap_shim
LOCAL_MODULE_TAGS := optional
LOCAL_PROPRIETARY_MODULE := true
include $(BUILD_SHARED_LIBRARY)

19
libshims/MediaBuffer.c
View File

@@ -1,19 +0,0 @@
/*
* Copyright (C) 2016 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.
*/
/* TODO: Actually provide implementations for these function! */
void _ZNK7android11MediaBuffer8refcountEv() {}

26
libshims/MediaCodec.cpp
View File

@@ -1,26 +0,0 @@
#include <media/MediaCodecBuffer.h>
#include <media/stagefright/foundation/AHandler.h>
#include <utils/Vector.h>
namespace android {
extern "C" void _ZN7android10MediaCodec12CreateByTypeERKNS_2spINS_7ALooperEEERKNS_7AStringEbPiij(
const sp<ALooper> &looper, const AString &mime, bool encoder, status_t *err, pid_t pid, uid_t uid);
extern "C" void _ZNK7android10MediaCodec15getInputBuffersEPNS_6VectorINS_2spINS_16MediaCodecBufferEEEEE(Vector<sp<ABuffer> > *buffers);
extern "C" void _ZNK7android10MediaCodec16getOutputBuffersEPNS_6VectorINS_2spINS_16MediaCodecBufferEEEEE(Vector<sp<ABuffer> > *buffers);
extern "C" void _ZN7android10MediaCodec12CreateByTypeERKNS_2spINS_7ALooperEEERKNS_7AStringEbPii(
const sp<ALooper> &looper, const AString &mime, bool encoder, status_t *err, pid_t pid) {
_ZN7android10MediaCodec12CreateByTypeERKNS_2spINS_7ALooperEEERKNS_7AStringEbPiij(
looper, mime, encoder, err, pid, 0);
}
extern "C" void _ZNK7android10MediaCodec15getInputBuffersEPNS_6VectorINS_2spINS_7ABufferEEEEE(Vector<sp<ABuffer> > *buffers) {
_ZNK7android10MediaCodec15getInputBuffersEPNS_6VectorINS_2spINS_16MediaCodecBufferEEEEE(buffers);
}
extern "C" void _ZNK7android10MediaCodec16getOutputBuffersEPNS_6VectorINS_2spINS_7ABufferEEEEE(Vector<sp<ABuffer> > *buffers) {
_ZNK7android10MediaCodec16getOutputBuffersEPNS_6VectorINS_2spINS_16MediaCodecBufferEEEEE(buffers);
}
}

28
libshims/camera_hal.cpp
View File

@@ -1,28 +0,0 @@
/*
* Copyright (C) 2016 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.
*/
#include <EGL/egl.h>
#include <EGL/eglext.h>
/* TODO: Actually provide implementations for these function! */
extern "C" void _ZN7android20DisplayEventReceiverC1Ev() {}
EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name);
extern "C" void _Z35eglQueryStringImplementationANDROIDPvi(EGLDisplay dpy, EGLint name){
eglQueryStringImplementationANDROID(dpy, name);
}

74
libshims/libqsap_shim.c
View File

@@ -1,74 +0,0 @@
#include "qsap_api.h"
#include <sys/socket.h>
#include <linux/wireless.h>
#include "cutils/log.h"
// Keep in sync with system/qcom/softap/sdk/qsap_api.c
struct Command qsap_str[eSTR_LAST] = {
{ "wpa", NULL },
{ "accept_mac_file", NULL },
{ "deny_mac_file", NULL },
{ "gAPMacAddr", "00deadbeef04" },/** AP MAC address */
{ "gEnableApProt", "1" },/** protection flag in ini file */
{ "gFixedRate", "0" },/** Fixed rate in ini */
{ "gTxPowerCap", "27" },/** Tx power in ini */
{ "gFragmentationThreshold", "2346" },/** Fragmentation threshold in ini */
{ "RTSThreshold", "2347" },/** RTS threshold in ini */
{ "gAPCntryCode", "USI" },/** Country code in ini */
{ "gDisableIntraBssFwd", "0" },/** Intra-bss forward in ini */
{ "WmmIsEnabled", "0" },/** WMM */
{ "g11dSupportEnabled", "1" },/** 802.11d support */
{ "ieee80211n", NULL },
{ "ctrl_interface", NULL },
{ "interface", NULL },
{ "eap_server", NULL },
{ "gAPAutoShutOff", "0" },
{ "gEnablePhyAgcListenMode", "128" },
};
// system/qcom/softap/sdk/qsap_api.h
#define eERR_SET_TX_POWER (eERR_GET_AUTO_CHAN + 1)
s32 wifi_qsap_set_tx_power(s32 tx_power)
{
#define QCSAP_IOCTL_SET_MAX_TX_POWER (SIOCIWFIRSTPRIV + 22)
s32 sock;
s32 ret = eERR_SET_TX_POWER;
s8 interface[128];
s8 *iface;
s32 len = 128;
struct iwreq wrq;
if(NULL == (iface = qsap_get_config_value(CONFIG_FILE, &qsap_str[STR_INTERFACE], interface, (u32*)&len))) {
ALOGE("%s :interface error \n", __func__);
return ret;
}
/* Issue QCSAP_IOCTL_SET_MAX_TX_POWER ioctl */
sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock < 0) {
ALOGE("%s :socket error \n", __func__);
return eERR_SET_TX_POWER;
}
strlcpy(wrq.ifr_name, iface, sizeof(wrq.ifr_name));
wrq.u.data.length = sizeof(s32);
wrq.u.data.pointer = &tx_power;
wrq.u.data.flags = 0;
ret = ioctl(sock, QCSAP_IOCTL_SET_MAX_TX_POWER, &wrq);
close(sock);
if (ret) {
ALOGE("%s :IOCTL set tx power failed: %ld\n", __func__, ret);
ret = eERR_SET_TX_POWER;
} else {
ALOGD("%s :IOCTL set tx power issued\n", __func__);
ret = eSUCCESS;
}
return ret;
}

620
libshims/mixer.c
View File

@@ -1,620 +0,0 @@
/* mixer.c
**
** Copyright 2011, The Android Open Source Project
**
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are met:
** * Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** * Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in the
** documentation and/or other materials provided with the distribution.
** * Neither the name of The Android Open Source Project nor the names of
** its contributors may be used to endorse or promote products derived
** from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY The Android Open Source Project ``AS IS'' AND
** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
** ARE DISCLAIMED. IN NO EVENT SHALL The Android Open Source Project BE LIABLE
** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
** SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
** CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
** DAMAGE.
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <ctype.h>
#include <sys/ioctl.h>
#include <linux/ioctl.h>
#define __force
#define __bitwise
#define __user
#include <sound/asound.h>
#include <tinyalsa/asoundlib.h>
struct mixer_ctl {
struct mixer *mixer;
struct snd_ctl_elem_info info;
char **ename;
};
struct mixer {
int fd;
struct snd_ctl_card_info card_info;
struct mixer_ctl *ctl;
unsigned int count;
};
static void mixer_cleanup_control(struct mixer_ctl *ctl)
{
unsigned int m;
if (ctl->ename) {
unsigned int max = ctl->info.value.enumerated.items;
for (m = 0; m < max; m++)
free(ctl->ename[m]);
free(ctl->ename);
}
}
void mixer_close(struct mixer *mixer)
{
unsigned int n;
if (!mixer)
return;
if (mixer->fd >= 0)
close(mixer->fd);
if (mixer->ctl) {
for (n = 0; n < mixer->count; n++)
mixer_cleanup_control(&mixer->ctl[n]);
free(mixer->ctl);
}
free(mixer);
/* TODO: verify frees */
}
static void *mixer_realloc_z(void *ptr, size_t curnum, size_t newnum, size_t size)
{
int8_t *newp;
newp = realloc(ptr, size * newnum);
if (!newp)
return NULL;
memset(newp + (curnum * size), 0, (newnum-curnum) * size);
return newp;
}
static int add_controls(struct mixer *mixer)
{
struct snd_ctl_elem_list elist;
struct snd_ctl_elem_info tmp;
struct snd_ctl_elem_id *eid = NULL;
struct snd_ctl_elem_info *info;
struct mixer_ctl *ctl;
int fd = mixer->fd;
const unsigned int old_count = mixer->count;
unsigned int extra_count;
unsigned int n, m;
memset(&elist, 0, sizeof(elist));
if (ioctl(fd, SNDRV_CTL_IOCTL_ELEM_LIST, &elist) < 0)
goto fail;
if (old_count == elist.count)
return 0; /* no new controls return unchanged */
ctl = mixer_realloc_z(mixer->ctl, old_count, elist.count,
sizeof(struct mixer_ctl));
if (!ctl)
goto fail;
mixer->ctl = ctl;
extra_count = elist.count - old_count; /* controls we haven't seen before */
eid = calloc(extra_count, sizeof(struct snd_ctl_elem_id));
if (!eid)
goto fail;
/* Add all controls we haven't seen before
* ALSA drivers are not allowed to remove or re-order controls that
* have already been created so we know that any new controls must
* be after the ones we have already collected
*/
elist.offset = old_count; /* first control we haven't seen yet */
elist.space = extra_count;
elist.pids = eid;
if (ioctl(fd, SNDRV_CTL_IOCTL_ELEM_LIST, &elist) < 0)
goto fail;
for (n = old_count; n < old_count + extra_count; n++) {
struct snd_ctl_elem_info *ei = &mixer->ctl[n].info;
ei->id.numid = eid[n - old_count].numid;
if (ioctl(fd, SNDRV_CTL_IOCTL_ELEM_INFO, ei) < 0)
goto fail_extend;
ctl[n].mixer = mixer;
if (ei->type == SNDRV_CTL_ELEM_TYPE_ENUMERATED) {
char **enames = calloc(ei->value.enumerated.items, sizeof(char*));
if (!enames)
goto fail_extend;
ctl[n].ename = enames;
for (m = 0; m < ei->value.enumerated.items; m++) {
memset(&tmp, 0, sizeof(tmp));
tmp.id.numid = ei->id.numid;
tmp.value.enumerated.item = m;
if (ioctl(fd, SNDRV_CTL_IOCTL_ELEM_INFO, &tmp) < 0)
goto fail_extend;
enames[m] = strdup(tmp.value.enumerated.name);
if (!enames[m])
goto fail_extend;
}
}
}
mixer->count = old_count + extra_count;
free(eid);
return 0;
fail_extend:
/* cleanup the control we failed on but leave the ones that were already
* added. Also no advantage to shrinking the resized memory block, we
* might want to extend the controls again later
*/
mixer_cleanup_control(&ctl[n]);
mixer->count = n; /* keep controls we successfully added */
/* fall through... */
fail:
free(eid);
return -1;
}
struct mixer *mixer_open(unsigned int card)
{
struct mixer *mixer = NULL;
int fd;
char fn[256];
snprintf(fn, sizeof(fn), "/dev/snd/controlC%u", card);
fd = open(fn, O_RDWR);
if (fd < 0)
return 0;
mixer = calloc(1, sizeof(*mixer));
if (!mixer)
goto fail;
if (ioctl(fd, SNDRV_CTL_IOCTL_CARD_INFO, &mixer->card_info) < 0)
goto fail;
mixer->fd = fd;
if (add_controls(mixer) != 0)
goto fail;
return mixer;
fail:
if (mixer)
mixer_close(mixer);
else if (fd >= 0)
close(fd);
return NULL;
}
int mixer_update_ctls(struct mixer *mixer)
{
if (!mixer)
return 0;
return add_controls(mixer);
}
const char *mixer_get_name(struct mixer *mixer)
{
return (const char *)mixer->card_info.name;
}
unsigned int mixer_get_num_ctls(struct mixer *mixer)
{
if (!mixer)
return 0;
return mixer->count;
}
struct mixer_ctl *mixer_get_ctl(struct mixer *mixer, unsigned int id)
{
if (mixer && (id < mixer->count))
return mixer->ctl + id;
return NULL;
}
struct mixer_ctl *mixer_get_ctl_by_name(struct mixer *mixer, const char *name)
{
unsigned int n;
struct mixer_ctl *ctl = mixer->ctl;
if (!mixer)
return NULL;
for (n = 0; n < mixer->count; n++)
if (!strcmp(name, (char*) ctl[n].info.id.name))
return &ctl[n];
return NULL;
}
void mixer_ctl_update(struct mixer_ctl *ctl)
{
ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_INFO, ctl->info);
}
const char *mixer_ctl_get_name(struct mixer_ctl *ctl)
{
if (!ctl)
return NULL;
return (const char *)ctl->info.id.name;
}
enum mixer_ctl_type mixer_ctl_get_type(struct mixer_ctl *ctl)
{
if (!ctl)
return MIXER_CTL_TYPE_UNKNOWN;
switch (ctl->info.type) {
case SNDRV_CTL_ELEM_TYPE_BOOLEAN: return MIXER_CTL_TYPE_BOOL;
case SNDRV_CTL_ELEM_TYPE_INTEGER: return MIXER_CTL_TYPE_INT;
case SNDRV_CTL_ELEM_TYPE_ENUMERATED: return MIXER_CTL_TYPE_ENUM;
case SNDRV_CTL_ELEM_TYPE_BYTES: return MIXER_CTL_TYPE_BYTE;
case SNDRV_CTL_ELEM_TYPE_IEC958: return MIXER_CTL_TYPE_IEC958;
case SNDRV_CTL_ELEM_TYPE_INTEGER64: return MIXER_CTL_TYPE_INT64;
default: return MIXER_CTL_TYPE_UNKNOWN;
};
}
const char *mixer_ctl_get_type_string(struct mixer_ctl *ctl)
{
if (!ctl)
return "";
switch (ctl->info.type) {
case SNDRV_CTL_ELEM_TYPE_BOOLEAN: return "BOOL";
case SNDRV_CTL_ELEM_TYPE_INTEGER: return "INT";
case SNDRV_CTL_ELEM_TYPE_ENUMERATED: return "ENUM";
case SNDRV_CTL_ELEM_TYPE_BYTES: return "BYTE";
case SNDRV_CTL_ELEM_TYPE_IEC958: return "IEC958";
case SNDRV_CTL_ELEM_TYPE_INTEGER64: return "INT64";
default: return "Unknown";
};
}
unsigned int mixer_ctl_get_num_values(struct mixer_ctl *ctl)
{
if (!ctl)
return 0;
return ctl->info.count;
}
static int percent_to_int(struct snd_ctl_elem_info *ei, int percent)
{
int range;
if (percent > 100)
percent = 100;
else if (percent < 0)
percent = 0;
range = (ei->value.integer.max - ei->value.integer.min);
return ei->value.integer.min + (range * percent) / 100;
}
static int int_to_percent(struct snd_ctl_elem_info *ei, int value)
{
int range = (ei->value.integer.max - ei->value.integer.min);
if (range == 0)
return 0;
return ((value - ei->value.integer.min) / range) * 100;
}
int mixer_ctl_get_percent(struct mixer_ctl *ctl, unsigned int id)
{
if (!ctl || (ctl->info.type != SNDRV_CTL_ELEM_TYPE_INTEGER))
return -EINVAL;
return int_to_percent(&ctl->info, mixer_ctl_get_value(ctl, id));
}
int mixer_ctl_set_percent(struct mixer_ctl *ctl, unsigned int id, int percent)
{
if (!ctl || (ctl->info.type != SNDRV_CTL_ELEM_TYPE_INTEGER))
return -EINVAL;
return mixer_ctl_set_value(ctl, id, percent_to_int(&ctl->info, percent));
}
int mixer_ctl_get_value(struct mixer_ctl *ctl, unsigned int id)
{
struct snd_ctl_elem_value ev;
int ret;
if (!ctl || (id >= ctl->info.count))
return -EINVAL;
memset(&ev, 0, sizeof(ev));
ev.id.numid = ctl->info.id.numid;
ret = ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_READ, &ev);
if (ret < 0)
return ret;
switch (ctl->info.type) {
case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
return !!ev.value.integer.value[id];
case SNDRV_CTL_ELEM_TYPE_INTEGER:
return ev.value.integer.value[id];
case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
return ev.value.enumerated.item[id];
case SNDRV_CTL_ELEM_TYPE_BYTES:
return ev.value.bytes.data[id];
default:
return -EINVAL;
}
return 0;
}
int mixer_ctl_get_array(struct mixer_ctl *ctl, void *array, size_t count)
{
struct snd_ctl_elem_value ev;
int ret = 0;
size_t size;
void *source;
if (!ctl || (count > ctl->info.count) || !count || !array)
return -EINVAL;
memset(&ev, 0, sizeof(ev));
ev.id.numid = ctl->info.id.numid;
switch (ctl->info.type) {
case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
case SNDRV_CTL_ELEM_TYPE_INTEGER:
ret = ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_READ, &ev);
if (ret < 0)
return ret;
size = sizeof(ev.value.integer.value[0]);
source = ev.value.integer.value;
break;
case SNDRV_CTL_ELEM_TYPE_BYTES:
/* check if this is new bytes TLV */
if (ctl->info.access & SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE) {
struct snd_ctl_tlv *tlv;
int ret;
if (count > SIZE_MAX - sizeof(*tlv))
return -EINVAL;
tlv = calloc(1, sizeof(*tlv) + count);
if (!tlv)
return -ENOMEM;
tlv->numid = ctl->info.id.numid;
tlv->length = count;
ret = ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_TLV_READ, tlv);
source = tlv->tlv;
memcpy(array, source, count);
free(tlv);
return ret;
} else {
ret = ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_READ, &ev);
if (ret < 0)
return ret;
size = sizeof(ev.value.bytes.data[0]);
source = ev.value.bytes.data;
break;
}
case SNDRV_CTL_ELEM_TYPE_IEC958:
size = sizeof(ev.value.iec958);
source = &ev.value.iec958;
break;
default:
return -EINVAL;
}
memcpy(array, source, size * count);
return 0;
}
int mixer_ctl_set_value(struct mixer_ctl *ctl, unsigned int id, int value)
{
struct snd_ctl_elem_value ev;
int ret;
if (!ctl || (id >= ctl->info.count))
return -EINVAL;
memset(&ev, 0, sizeof(ev));
ev.id.numid = ctl->info.id.numid;
ret = ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_READ, &ev);
if (ret < 0)
return ret;
switch (ctl->info.type) {
case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
ev.value.integer.value[id] = !!value;
break;
case SNDRV_CTL_ELEM_TYPE_INTEGER: {
int min = mixer_ctl_get_range_min(ctl);
int max = mixer_ctl_get_range_max(ctl);
if (min < max && (value < min || value > max))
return -EINVAL;
ev.value.integer.value[id] = value;
break;
}
case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
if (value < 0 || (value >= 0 && (unsigned int)value >= mixer_ctl_get_num_enums(ctl)))
return -EINVAL;
ev.value.enumerated.item[id] = value;
break;
case SNDRV_CTL_ELEM_TYPE_BYTES:
ev.value.bytes.data[id] = value;
break;
default:
return -EINVAL;
}
return ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_WRITE, &ev);
}
int mixer_ctl_set_array(struct mixer_ctl *ctl, const void *array, size_t count)
{
struct snd_ctl_elem_value ev;
size_t size;
void *dest;
if (!ctl || (count > ctl->info.count) || !count || !array)
return -EINVAL;
memset(&ev, 0, sizeof(ev));
ev.id.numid = ctl->info.id.numid;
switch (ctl->info.type) {
case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
case SNDRV_CTL_ELEM_TYPE_INTEGER:
size = sizeof(ev.value.integer.value[0]);
dest = ev.value.integer.value;
break;
case SNDRV_CTL_ELEM_TYPE_BYTES:
/* check if this is new bytes TLV */
if (ctl->info.access & SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE) {
struct snd_ctl_tlv *tlv;
int ret = 0;
if (count > SIZE_MAX - sizeof(*tlv))
return -EINVAL;
tlv = calloc(1, sizeof(*tlv) + count);
if (!tlv)
return -ENOMEM;
tlv->numid = ctl->info.id.numid;
tlv->length = count;
memcpy(tlv->tlv, array, count);
ret = ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_TLV_WRITE, tlv);
free(tlv);
return ret;
} else {
size = sizeof(ev.value.bytes.data[0]);
dest = ev.value.bytes.data;
}
break;
case SNDRV_CTL_ELEM_TYPE_IEC958:
size = sizeof(ev.value.iec958);
dest = &ev.value.iec958;
break;
default:
return -EINVAL;
}
memcpy(dest, array, size * count);
return ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_WRITE, &ev);
}
int mixer_ctl_get_range_min(struct mixer_ctl *ctl)
{
if (!ctl || (ctl->info.type != SNDRV_CTL_ELEM_TYPE_INTEGER))
return -EINVAL;
return ctl->info.value.integer.min;
}
int mixer_ctl_get_range_max(struct mixer_ctl *ctl)
{
if (!ctl || (ctl->info.type != SNDRV_CTL_ELEM_TYPE_INTEGER))
return -EINVAL;
return ctl->info.value.integer.max;
}
unsigned int mixer_ctl_get_num_enums(struct mixer_ctl *ctl)
{
if (!ctl)
return 0;
return ctl->info.value.enumerated.items;
}
const char *mixer_ctl_get_enum_string(struct mixer_ctl *ctl,
unsigned int enum_id)
{
if (!ctl || (ctl->info.type != SNDRV_CTL_ELEM_TYPE_ENUMERATED) ||
(enum_id >= ctl->info.value.enumerated.items))
return NULL;
return (const char *)ctl->ename[enum_id];
}
int mixer_ctl_set_enum_by_string(struct mixer_ctl *ctl, const char *string)
{
unsigned int i, num_enums;
struct snd_ctl_elem_value ev;
int ret;
if (!ctl || (ctl->info.type != SNDRV_CTL_ELEM_TYPE_ENUMERATED))
return -EINVAL;
num_enums = ctl->info.value.enumerated.items;
for (i = 0; i < num_enums; i++) {
if (!strcmp(string, ctl->ename[i])) {
memset(&ev, 0, sizeof(ev));
ev.value.enumerated.item[0] = i;
ev.id.numid = ctl->info.id.numid;
ret = ioctl(ctl->mixer->fd, SNDRV_CTL_IOCTL_ELEM_WRITE, &ev);
if (ret < 0)
return ret;
return 0;
}
}
return -EINVAL;
}

22
libshims/sensor.cpp
View File

@@ -1,22 +0,0 @@
/*
* Copyright (C) 2017 The LineageOS 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.
*/
#include <sensor/Sensor.h>
extern "C" int ASensor_getHandle(ASensor const* sensor)
{
return static_cast<android::Sensor const*>(sensor)->getHandle();
}