sandy
/
PL286
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1 Commit
1 Branch
0 Tags
18 GiB
Tree: 99da0f2c72
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '99da0f2c72'
${ noResults }
PL286/hardware/libhardware/modules/vehicle/vehicle.c

576 lines
21 KiB
Raw Blame History

/*
* Copyright (C) 2015 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define LOG_TAG "vehicle_hw_default"
#define LOG_NDEBUG 1
#define RADIO_PRESET_NUM 6
#define UNUSED __attribute__((__unused__))
#include <errno.h>
#include <inttypes.h>
#include <malloc.h>
#include <pthread.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <sys/prctl.h>
#include <sys/time.h>
#include <time.h>
#include <log/log.h>
#include <system/radio.h>
#include <hardware/hardware.h>
#include <hardware/vehicle.h>
extern int64_t elapsedRealtimeNano();
static char VEHICLE_MAKE[] = "android_car";
typedef struct vehicle_device_impl {
vehicle_hw_device_t vehicle_device;
uint32_t initialized_;
vehicle_event_callback_fn event_fn_;
vehicle_error_callback_fn error_fn_;
} vehicle_device_impl_t ;
static pthread_mutex_t lock_;
typedef struct subscription {
// Each subscription has it's own thread.
pthread_t thread_id;
int32_t prop;
float sample_rate;
pthread_mutex_t lock;
// This field should be protected by the above mutex.
// TODO change this to something better as flag alone takes long time to finish.
uint32_t stop_thread;
vehicle_device_impl_t* impl;
pthread_t thread;
pthread_cond_t cond;
char name[100];
} subscription_t;
static vehicle_prop_config_t CONFIGS[] = {
{
.prop = VEHICLE_PROPERTY_INFO_MAKE,
.access = VEHICLE_PROP_ACCESS_READ,
.change_mode = VEHICLE_PROP_CHANGE_MODE_STATIC,
.value_type = VEHICLE_VALUE_TYPE_STRING,
.min_sample_rate = 0,
.max_sample_rate = 0,
.hal_data = NULL,
},
{
.prop = VEHICLE_PROPERTY_GEAR_SELECTION,
.access = VEHICLE_PROP_ACCESS_READ,
.change_mode = VEHICLE_PROP_CHANGE_MODE_ON_CHANGE,
.value_type = VEHICLE_VALUE_TYPE_INT32,
.min_sample_rate = 0,
.max_sample_rate = 0,
.hal_data = NULL,
},
{
.prop = VEHICLE_PROPERTY_DRIVING_STATUS,
.access = VEHICLE_PROP_ACCESS_READ,
.change_mode = VEHICLE_PROP_CHANGE_MODE_ON_CHANGE,
.value_type = VEHICLE_VALUE_TYPE_INT32,
.min_sample_rate = 0,
.max_sample_rate = 0,
.hal_data = NULL,
},
{
.prop = VEHICLE_PROPERTY_PARKING_BRAKE_ON,
.access = VEHICLE_PROP_ACCESS_READ,
.change_mode = VEHICLE_PROP_CHANGE_MODE_ON_CHANGE,
.value_type = VEHICLE_VALUE_TYPE_BOOLEAN,
.min_sample_rate = 0,
.max_sample_rate = 0,
.hal_data = NULL,
},
{
.prop = VEHICLE_PROPERTY_PERF_VEHICLE_SPEED,
.access = VEHICLE_PROP_ACCESS_READ,
.change_mode = VEHICLE_PROP_CHANGE_MODE_CONTINUOUS,
.value_type = VEHICLE_VALUE_TYPE_FLOAT,
.min_sample_rate = 0.1,
.max_sample_rate = 10.0,
.hal_data = NULL,
},
{
.prop = VEHICLE_PROPERTY_RADIO_PRESET,
.access = VEHICLE_PROP_ACCESS_READ_WRITE,
.change_mode = VEHICLE_PROP_CHANGE_MODE_ON_CHANGE,
.value_type = VEHICLE_VALUE_TYPE_INT32_VEC4,
.vehicle_radio_num_presets = RADIO_PRESET_NUM,
.min_sample_rate = 0,
.max_sample_rate = 0,
.hal_data = NULL,
},
};
vehicle_prop_config_t* find_config(int prop) {
unsigned int i;
for (i = 0; i < sizeof(CONFIGS) / sizeof(vehicle_prop_config_t); i++) {
if (CONFIGS[i].prop == prop) {
return &CONFIGS[i];
}
}
return NULL;
}
static int alloc_vehicle_str_from_cstr(const char* string, vehicle_str_t* vehicle_str) {
int len = strlen(string);
vehicle_str->data = (uint8_t*) malloc(len);
if (vehicle_str->data == NULL) {
return -ENOMEM;
}
memcpy(vehicle_str->data, string, len);
vehicle_str->len = len;
return 0;
}
static vehicle_prop_config_t const * vdev_list_properties(vehicle_hw_device_t* device UNUSED,
int* num_properties) {
ALOGD("vdev_list_properties.");
*num_properties = sizeof(CONFIGS) / sizeof(vehicle_prop_config_t);
return CONFIGS;
}
static int vdev_init(vehicle_hw_device_t* device,
vehicle_event_callback_fn event_callback_fn,
vehicle_error_callback_fn error_callback_fn) {
ALOGD("vdev_init.");
vehicle_device_impl_t* impl = (vehicle_device_impl_t*)device;
pthread_mutex_lock(&lock_);
if (impl->initialized_) {
ALOGE("vdev_init: Callback and Error functions are already existing.");
pthread_mutex_unlock(&lock_);
return -EEXIST;
}
impl->initialized_ = 1;
impl->event_fn_ = event_callback_fn;
impl->error_fn_ = error_callback_fn;
pthread_mutex_unlock(&lock_);
return 0;
}
static int vdev_release(vehicle_hw_device_t* device) {
vehicle_device_impl_t* impl = (vehicle_device_impl_t*)device;
pthread_mutex_lock(&lock_);
if (!impl->initialized_) {
ALOGD("vdev_release: Already released before, returning early.");
} else {
// unsubscribe_all()
impl->initialized_ = 0;
}
pthread_mutex_unlock(&lock_);
return 0;
}
static int vdev_get(vehicle_hw_device_t* device UNUSED, vehicle_prop_value_t* data) {
ALOGD("vdev_get.");
//TODO all data supporting read should support get
if (!data) {
ALOGE("vdev_get: Data cannot be null.");
return -EINVAL;
}
vehicle_prop_config_t* config = find_config(data->prop);
if (config == NULL) {
ALOGE("vdev_get: cannot find config 0x%x", data->prop);
return -EINVAL;
}
data->value_type = config->value_type;
// for STATIC type, time can be just 0 instead
data->timestamp = elapsedRealtimeNano();
int r;
switch (data->prop) {
case VEHICLE_PROPERTY_INFO_MAKE:
r = alloc_vehicle_str_from_cstr(VEHICLE_MAKE, &(data->value.str_value));
if (r != 0) {
ALOGE("vdev_get: alloc failed");
return r;
}
break;
case VEHICLE_PROPERTY_RADIO_PRESET: {
int radio_preset = data->value.int32_array[0];
if (radio_preset < VEHICLE_RADIO_PRESET_MIN_VALUE ||
radio_preset >= RADIO_PRESET_NUM) {
ALOGE("%s Invalid radio preset: %d\n", __func__, radio_preset);
return -1;
}
ALOGD("%s Radio Preset number: %d", __func__, radio_preset);
int32_t selector = radio_preset % 2 == 0;
// Populate the channel and subchannel to be some variation of the
// preset number for mocking.
// Restore the preset number.
data->value.int32_array[0] = radio_preset;
// Channel type values taken from
// system/core/include/system/radio.h
data->value.int32_array[1] = selector ? RADIO_BAND_FM : RADIO_BAND_AM;
// For FM set a value in Mhz and for AM set a value in Khz range
// (channel).
data->value.int32_array[2] = selector ? 99000000 : 100000;
// For FM we have a sub-channel and we care about it, for AM pass
// a dummy value.
data->value.int32_array[3] = selector ? radio_preset : -1;
break;
}
default:
// actual implementation will be much complex than this. It should track proper last
// state. Here just fill with zero.
memset(&(data->value), 0, sizeof(data->value));
break;
}
ALOGI("vdev_get, type 0x%x, time %" PRId64 ", value_type %d", data->prop, data->timestamp,
data->value_type);
return 0;
}
static void vdev_release_memory_from_get(struct vehicle_hw_device* device UNUSED,
vehicle_prop_value_t *data) {
switch (data->value_type) {
case VEHICLE_VALUE_TYPE_STRING:
case VEHICLE_VALUE_TYPE_BYTES:
free(data->value.str_value.data);
data->value.str_value.data = NULL;
break;
default:
ALOGW("release_memory_from_get for property 0x%x which is not string or bytes type 0x%x"
, data->prop, data->value_type);
break;
}
}
static int vdev_set(vehicle_hw_device_t* device UNUSED, const vehicle_prop_value_t* data) {
ALOGD("vdev_set.");
// Just print what data will be setting here.
ALOGD("Setting property %d with value type %d\n", data->prop, data->value_type);
vehicle_prop_config_t* config = find_config(data->prop);
if (config == NULL) {
ALOGE("vdev_set: cannot find config 0x%x", data->prop);
return -EINVAL;
}
if (config->value_type != data->value_type) {
ALOGE("vdev_set: type mismatch, passed 0x%x expecting 0x%x", data->value_type,
config->value_type);
return -EINVAL;
}
switch (data->value_type) {
case VEHICLE_VALUE_TYPE_FLOAT:
ALOGD("Value type: FLOAT\nValue: %f\n", data->value.float_value);
break;
case VEHICLE_VALUE_TYPE_INT32:
ALOGD("Value type: INT32\nValue: %" PRId32 "\n", data->value.int32_value);
break;
case VEHICLE_VALUE_TYPE_INT64:
ALOGD("Value type: INT64\nValue: %" PRId64 "\n", data->value.int64_value);
break;
case VEHICLE_VALUE_TYPE_BOOLEAN:
ALOGD("Value type: BOOLEAN\nValue: %d\n", data->value.boolean_value);
break;
case VEHICLE_VALUE_TYPE_STRING:
ALOGD("Value type: STRING\n Size: %d\n", data->value.str_value.len);
// NOTE: We only handle ASCII strings here.
// Print the UTF-8 string.
char *ascii_out = (char *) malloc ((data->value.str_value.len + 1) * sizeof (char));
memcpy(ascii_out, data->value.str_value.data, data->value.str_value.len);
ascii_out[data->value.str_value.len] = '\0';
ALOGD("Value: %s\n", ascii_out);
break;
case VEHICLE_VALUE_TYPE_INT32_VEC4:
ALOGD("Value type: INT32_VEC4\nValue[0]: %d Value[1] %d Value[2] %d Value[3] %d",
data->value.int32_array[0], data->value.int32_array[1],
data->value.int32_array[2], data->value.int32_array[3]);
break;
default:
ALOGD("Value type not yet handled: %d.\n", data->value_type);
}
return 0;
}
void print_subscribe_info(vehicle_device_impl_t* impl UNUSED) {
unsigned int i;
for (i = 0; i < sizeof(CONFIGS) / sizeof(vehicle_prop_config_t); i++) {
subscription_t* sub = (subscription_t*)CONFIGS[i].hal_data;
if (sub != NULL) {
ALOGD("prop: %d rate: %f", sub->prop, sub->sample_rate);
}
}
}
// This should be run in a separate thread always.
void fake_event_thread(struct subscription *sub) {
if (!sub) {
ALOGE("oops! subscription object cannot be NULL.");
exit(-1);
}
prctl(PR_SET_NAME, (unsigned long)sub->name, 0, 0, 0);
// Emit values in a loop, every 2 seconds.
while (1) {
// Create a random value depending on the property type.
vehicle_prop_value_t event;
event.prop = sub->prop;
event.timestamp = elapsedRealtimeNano();
switch (sub->prop) {
case VEHICLE_PROPERTY_GEAR_SELECTION:
event.value_type = VEHICLE_VALUE_TYPE_INT32;
switch ((event.timestamp & 0x30000000)>>28) {
case 0:
event.value.gear_selection = VEHICLE_GEAR_PARK;
break;
case 1:
event.value.gear_selection = VEHICLE_GEAR_NEUTRAL;
break;
case 2:
event.value.gear_selection = VEHICLE_GEAR_DRIVE;
break;
case 3:
event.value.gear_selection = VEHICLE_GEAR_REVERSE;
break;
}
break;
case VEHICLE_PROPERTY_PARKING_BRAKE_ON:
event.value_type = VEHICLE_VALUE_TYPE_BOOLEAN;
if (event.timestamp & 0x20000000) {
event.value.parking_brake = VEHICLE_FALSE;
} else {
event.value.parking_brake = VEHICLE_TRUE;
}
break;
case VEHICLE_PROPERTY_PERF_VEHICLE_SPEED:
event.value_type = VEHICLE_VALUE_TYPE_FLOAT;
event.value.vehicle_speed = (float) ((event.timestamp & 0xff000000)>>24);
break;
case VEHICLE_PROPERTY_RADIO_PRESET:
event.value_type = VEHICLE_VALUE_TYPE_INT32_VEC4;
int presetInfo1[4] = {1 /* preset number */, 0 /* AM Band */, 1000, 0};
int presetInfo2[4] = {2 /* preset number */, 1 /* FM Band */, 1000, 0};
if (event.timestamp & 0x20000000) {
memcpy(event.value.int32_array, presetInfo1, sizeof(presetInfo1));
} else {
memcpy(event.value.int32_array, presetInfo2, sizeof(presetInfo2));
}
break;
default: // unsupported
if (sub->impl == NULL) {
ALOGE("subscription impl NULL");
return;
}
if (sub->impl->error_fn_ != NULL) {
sub->impl->error_fn_(-EINVAL, VEHICLE_PROPERTY_INVALID,
VEHICLE_OPERATION_GENERIC);
} else {
ALOGE("Error function is null");
}
ALOGE("Unsupported prop 0x%x, quit", sub->prop);
return;
}
if (sub->impl->event_fn_ != NULL) {
sub->impl->event_fn_(&event);
} else {
ALOGE("Event function is null");
return;
}
pthread_mutex_lock(&sub->lock);
if (sub->stop_thread) {
ALOGD("exiting subscription request here.");
// Do any cleanup here.
pthread_mutex_unlock(&sub->lock);
return;
}
struct timespec now;
clock_gettime(CLOCK_REALTIME, &now);
now.tv_sec += 1; // sleep for one sec
pthread_cond_timedwait(&sub->cond, &sub->lock, &now);
pthread_mutex_unlock(&sub->lock);
}
}
static int vdev_subscribe(vehicle_hw_device_t* device, int32_t prop, float sample_rate,
int32_t zones UNUSED) {
ALOGD("vdev_subscribe 0x%x, %f", prop, sample_rate);
vehicle_device_impl_t* impl = (vehicle_device_impl_t*)device;
// Check that the device is initialized.
pthread_mutex_lock(&lock_);
if (!impl->initialized_) {
pthread_mutex_unlock(&lock_);
ALOGE("vdev_subscribe: have you called init()?");
return -EINVAL;
}
vehicle_prop_config_t* config = find_config(prop);
if (config == NULL) {
pthread_mutex_unlock(&lock_);
ALOGE("vdev_subscribe not supported property 0x%x", prop);
return -EINVAL;
}
if ((config->access != VEHICLE_PROP_ACCESS_READ) &&
(config->access != VEHICLE_PROP_ACCESS_READ_WRITE)) {
pthread_mutex_unlock(&lock_);
ALOGE("vdev_subscribe read not supported on the property 0x%x", prop);
return -EINVAL;
}
if (config->change_mode == VEHICLE_PROP_CHANGE_MODE_STATIC) {
pthread_mutex_unlock(&lock_);
ALOGE("vdev_subscribe cannot subscribe static property 0x%x", prop);
return -EINVAL;
}
if ((config->change_mode == VEHICLE_PROP_CHANGE_MODE_ON_CHANGE) && (sample_rate != 0)) {
pthread_mutex_unlock(&lock_);
ALOGE("vdev_subscribe on change type should have 0 sample rate, property 0x%x, sample rate %f",
prop, sample_rate);
return -EINVAL;
}
if ((config->max_sample_rate < sample_rate) || (config->min_sample_rate > sample_rate)) {
ALOGE("vdev_subscribe property 0x%x, invalid sample rate %f, min:%f, max:%f",
prop, sample_rate, config->min_sample_rate, config->max_sample_rate);
pthread_mutex_unlock(&lock_);
return -EINVAL;
}
subscription_t* sub = (subscription_t*)config->hal_data;
if (sub == NULL) {
sub = calloc(1, sizeof(subscription_t));
sub->prop = prop;
sub->sample_rate = sample_rate;
sub->stop_thread = 0;
sub->impl = impl;
pthread_mutex_init(&sub->lock, NULL);
pthread_cond_init(&sub->cond, NULL);
config->hal_data = sub;
sprintf(sub->name, "vhal0x%x", prop);
} else if (sub->sample_rate != sample_rate){ // sample rate changed
//TODO notify this to fake sensor thread
sub->sample_rate = sample_rate;
pthread_mutex_unlock(&lock_);
return 0;
}
int ret_code = pthread_create(
&sub->thread, NULL, (void *(*)(void*))fake_event_thread, sub);
print_subscribe_info(impl);
pthread_mutex_unlock(&lock_);
return 0;
}
static int vdev_unsubscribe(vehicle_hw_device_t* device, int32_t prop) {
ALOGD("vdev_unsubscribe 0x%x", prop);
vehicle_device_impl_t* impl = (vehicle_device_impl_t*)device;
pthread_mutex_lock(&lock_);
vehicle_prop_config_t* config = find_config(prop);
if (config == NULL) {
pthread_mutex_unlock(&lock_);
return -EINVAL;
}
subscription_t* sub = (subscription_t*)config->hal_data;
if (sub == NULL) {
pthread_mutex_unlock(&lock_);
return -EINVAL;
}
config->hal_data = NULL;
pthread_mutex_unlock(&lock_);
pthread_mutex_lock(&sub->lock);
sub->stop_thread = 1;
pthread_cond_signal(&sub->cond);
pthread_mutex_unlock(&sub->lock);
pthread_join(sub->thread, NULL);
pthread_cond_destroy(&sub->cond);
pthread_mutex_destroy(&sub->lock);
free(sub);
pthread_mutex_lock(&lock_);
print_subscribe_info(impl);
pthread_mutex_unlock(&lock_);
return 0;
}
static int vdev_close(hw_device_t* device) {
vehicle_device_impl_t* impl = (vehicle_device_impl_t*)device;
if (impl) {
free(impl);
return 0;
} else {
return -1;
}
}
static int vdev_dump(struct vehicle_hw_device* device UNUSED, int fd UNUSED) {
//TODO
return 0;
}
/*
* The open function is provided as an interface in harwdare.h which fills in
* all the information about specific implementations and version specific
* informations in hw_device_t structure. After calling open() the client should
* use the hw_device_t to execute any Vehicle HAL device specific functions.
*/
static int vdev_open(const hw_module_t* module, const char* name UNUSED,
hw_device_t** device) {
ALOGD("vdev_open");
// Oops, out of memory!
vehicle_device_impl_t* vdev = calloc(1, sizeof(vehicle_device_impl_t));
if (vdev == NULL) {
return -ENOMEM;
}
// Common functions provided by harware.h to access module and device(s).
vdev->vehicle_device.common.tag = HARDWARE_DEVICE_TAG;
vdev->vehicle_device.common.version = VEHICLE_DEVICE_API_VERSION_1_0;
vdev->vehicle_device.common.module = (hw_module_t *) module;
vdev->vehicle_device.common.close = vdev_close;
// Define the Vehicle HAL device specific functions.
vdev->vehicle_device.list_properties = vdev_list_properties;
vdev->vehicle_device.init = vdev_init;
vdev->vehicle_device.release = vdev_release;
vdev->vehicle_device.get = vdev_get;
vdev->vehicle_device.release_memory_from_get = vdev_release_memory_from_get;
vdev->vehicle_device.set = vdev_set;
vdev->vehicle_device.subscribe = vdev_subscribe;
vdev->vehicle_device.unsubscribe = vdev_unsubscribe;
vdev->vehicle_device.dump = vdev_dump;
*device = (hw_device_t *) vdev;
return 0;
}
static struct hw_module_methods_t hal_module_methods = {
.open = vdev_open,
};
/*
* This structure is mandatory to be implemented by each HAL implementation. It
* exposes the open method (see hw_module_methods_t above) which opens a device.
* The vehicle HAL is supposed to be used as a single device HAL hence all the
* functions should be implemented inside of the vehicle_hw_device_t struct (see
* the vehicle.h in include/ folder.
*/
vehicle_module_t HAL_MODULE_INFO_SYM = {
.common = {
.tag = HARDWARE_MODULE_TAG,
.module_api_version = VEHICLE_MODULE_API_VERSION_1_0,
.hal_api_version = HARDWARE_HAL_API_VERSION,
.id = VEHICLE_HARDWARE_MODULE_ID,
.name = "Default vehicle HW HAL",
.author = "",
.methods = &hal_module_methods,
},
};