static int control__wake(struct sensors_control_context_t *dev)
{
int err = 0;
int acc_fd, ori_fd;
if (open_inputs(O_RDWR, &acc_fd, &ori_fd) < 0 ||
acc_fd < 0 || ori_fd < 0) {
return -1;
}
struct input_event event[1];
event[0].type = EV_SYN;
event[0].code = SYN_CONFIG;
event[0].value = 0;
err = write(acc_fd, event, sizeof(event));
LOGV_IF(err<0, "control__wake(accelerometer), fd=%d (%s)",
acc_fd, strerror(errno));
close(acc_fd);
err = write(ori_fd, event, sizeof(event));
LOGV_IF(err<0, "control__wake(compass), fd=%d (%s)",
ori_fd, strerror(errno));
close(ori_fd);
/*err = write(l_fd, event, sizeof(event));
LOGV_IF(err<0, "control__wake(light), fd=%d (%s)",
l_fd, strerror(errno));
close(l_fd);*/
return err;
}
static int control__wake(struct sensors_control_context_t *dev)
{
int err = 0;
int akm_fd, p_fd, l_fd;
if (open_inputs(O_RDWR, &akm_fd, &p_fd, &l_fd) < 0 ||
akm_fd < 0 || p_fd < 0 || l_fd < 0) {
return -1;
}
struct input_event event[1];
event[0].type = EV_SYN;
event[0].code = SYN_CONFIG;
event[0].value = 0;
err = write(akm_fd, event, sizeof(event));
LOGV_IF(err<0, "control__wake(compass), fd=%d (%s)",
akm_fd, strerror(errno));
close(akm_fd);
err = write(p_fd, event, sizeof(event));
LOGV_IF(err<0, "control__wake(proximity), fd=%d (%s)",
p_fd, strerror(errno));
close(p_fd);
err = write(l_fd, event, sizeof(event));
LOGV_IF(err<0, "control__wake(light), fd=%d (%s)",
l_fd, strerror(errno));
close(l_fd);
return err;
}
/**
* @brief This function will enable/disable sensor.
* @param[in] handle
* which sensor to enable/disable.
* @param[in] en
* en=1, enable;
* en=0, disable
* @return if the operation is successful.
*/
int CompassSensor::enable(int32_t handle, int en)
{
VFUNC_LOG;
mEnable = en;
int tempFd;
int res = 0;
/* reset master enable */
res = masterEnable(0);
if (res < 0) {
return res;
}
if (en) {
LOGV_IF(SYSFS_VERBOSE, "HAL:sysfs:echo %d > %s (%lld)",
en, compassSysFs.compass_x_fifo_enable, getTimestamp());
res = write_sysfs_int(compassSysFs.compass_x_fifo_enable, en);
LOGV_IF(SYSFS_VERBOSE, "HAL:sysfs:echo %d > %s (%lld)",
en, compassSysFs.compass_y_fifo_enable, getTimestamp());
res += write_sysfs_int(compassSysFs.compass_y_fifo_enable, en);
LOGV_IF(SYSFS_VERBOSE, "HAL:sysfs:echo %d > %s (%lld)",
en, compassSysFs.compass_z_fifo_enable, getTimestamp());
res += write_sysfs_int(compassSysFs.compass_z_fifo_enable, en);
res = masterEnable(en);
if (res < en) {
return res;
}
}
return res;
}
/**
* @brief This function will enable/disable sensor.
* @param[in] handle
* which sensor to enable/disable.
* @param[in] en
* en=1, enable;
* en=0, disable
* @return if the operation is successful.
*/
int CompassSensor::enable(int32_t handle, int en)
{
VFUNC_LOG;
mEnable = en;
int tempFd;
int res = 0;
/* reset master enable */
res = masterEnable(0);
if (res < 0) {
return res;
}
if (en) {
LOGV_IF(SYSFS_VERBOSE, "HAL:sysfs:echo %d > %s (%lld)",
en, compassSysFs.compass_x_fifo_enable, getTimestamp());
tempFd = open(compassSysFs.compass_x_fifo_enable, O_RDWR);
res = errno;
if (tempFd > 0) {
res = enable_sysfs_sensor(tempFd, en);
} else {
LOGE("HAL:open of %s failed with '%s' (%d)",
compassSysFs.compass_x_fifo_enable, strerror(res), res);
}
LOGV_IF(SYSFS_VERBOSE, "HAL:sysfs:echo %d > %s (%lld)",
en, compassSysFs.compass_y_fifo_enable, getTimestamp());
tempFd = open(compassSysFs.compass_y_fifo_enable, O_RDWR);
res = errno;
if (tempFd > 0) {
res = enable_sysfs_sensor(tempFd, en);
} else {
LOGE("HAL:open of %s failed with '%s' (%d)",
compassSysFs.compass_y_fifo_enable, strerror(res), res);
}
LOGV_IF(SYSFS_VERBOSE, "HAL:sysfs:echo %d > %s (%lld)",
en, compassSysFs.compass_z_fifo_enable, getTimestamp());
tempFd = open(compassSysFs.compass_z_fifo_enable, O_RDWR);
res = errno;
if (tempFd > 0) {
res = enable_sysfs_sensor(tempFd, en);
} else {
LOGE("HAL:open of %s failed with '%s' (%d)",
compassSysFs.compass_z_fifo_enable, strerror(res), res);
}
res = masterEnable(en);
if (res < en) {
return res;
}
}
return res;
}
CompassSensor::CompassSensor()
: SensorBase(NULL, NULL),
compass_fd(-1),
mCompassTimestamp(0),
mCompassInputReader(8)
{
VFUNC_LOG;
if(!strcmp(COMPASS_NAME, "USE_SYSFS")) {
int result = find_name_by_sensor_type("in_magn_scale", "iio:device",
sensor_name);
if(result) {
LOGE("HAL:Cannot read secondary device name - (%d)", result);
}
dev_name = sensor_name;
}
LOGI_IF(PROCESS_VERBOSE, "HAL:Secondary Chip Id: %s", dev_name);
if(inv_init_sysfs_attributes()) {
LOGE("Error Instantiating Compass\n");
return;
}
memset(mCachedCompassData, 0, sizeof(mCachedCompassData));
LOGV_IF(SYSFS_VERBOSE, "HAL:sysfs:cat %s (%lld)",
compassSysFs.compass_orient, getTimestamp());
FILE *fptr;
fptr = fopen(compassSysFs.compass_orient, "r");
if (fptr != NULL) {
int om[9];
if (fscanf(fptr, "%d,%d,%d,%d,%d,%d,%d,%d,%d",
&om[0], &om[1], &om[2], &om[3], &om[4], &om[5],
&om[6], &om[7], &om[8]) < 0 || fclose(fptr) < 0) {
LOGE("HAL:Could not read compass mounting matrix");
} else {
LOGV_IF(EXTRA_VERBOSE, "HAL:compass mounting matrix: "
"%+d %+d %+d %+d %+d %+d %+d %+d %+d", om[0], om[1], om[2],
om[3], om[4], om[5], om[6], om[7], om[8]);
mCompassOrientation[0] = om[0];
mCompassOrientation[1] = om[1];
mCompassOrientation[2] = om[2];
mCompassOrientation[3] = om[3];
mCompassOrientation[4] = om[4];
mCompassOrientation[5] = om[5];
mCompassOrientation[6] = om[6];
mCompassOrientation[7] = om[7];
mCompassOrientation[8] = om[8];
}
}
if (!isIntegrated()) {
enable(ID_M, 0);
}
}
CompassSensor::CompassSensor()
: SensorBase(NULL, NULL),
compass_fd(-1),
mCompassTimestamp(0),
mCompassInputReader(8)
{
VFUNC_LOG;
if(inv_init_sysfs_attributes()) {
LOGE("Error Instantiating Compass\n");
return;
}
if (!strcmp(COMPASS_NAME, "INV_COMPASS")) {
mI2CBus = COMPASS_BUS_SECONDARY;
} else {
mI2CBus = COMPASS_BUS_PRIMARY;
}
memset(mCachedCompassData, 0, sizeof(mCachedCompassData));
LOGV_IF(SYSFS_VERBOSE, "HAL:sysfs:cat %s (%lld)",
compassSysFs.compass_orient, getTimestamp());
FILE *fptr;
fptr = fopen(compassSysFs.compass_orient, "r");
if (fptr != NULL) {
int om[9];
fscanf(fptr, "%d,%d,%d,%d,%d,%d,%d,%d,%d",
&om[0], &om[1], &om[2], &om[3], &om[4], &om[5],
&om[6], &om[7], &om[8]);
fclose(fptr);
LOGV_IF(EXTRA_VERBOSE,
"HAL:compass mounting matrix: "
"%+d %+d %+d %+d %+d %+d %+d %+d %+d",
om[0], om[1], om[2], om[3], om[4], om[5], om[6], om[7], om[8]);
mCompassOrientation[0] = om[0];
mCompassOrientation[1] = om[1];
mCompassOrientation[2] = om[2];
mCompassOrientation[3] = om[3];
mCompassOrientation[4] = om[4];
mCompassOrientation[5] = om[5];
mCompassOrientation[6] = om[6];
mCompassOrientation[7] = om[7];
mCompassOrientation[8] = om[8];
} else {
LOGE("HAL:Couldn't read compass mounting matrix");
}
if (!isIntegrated()) {
enable(ID_M, 0);
}
}
void TrajectoryAnalyzer::analyze(Trajectory & trajectory,
std::vector<std::shared_ptr<ProteinSegment>> & protein_segments,
const double & temperature,
const int ensemble_size) {
std::vector<ProteinSegmentEnsemble> protein_segment_ensembles;
LOGD << "Fitting protein segments with trajectory frames and computing force constants.";
while (trajectory.has_next()) {
for (std::shared_ptr<ProteinSegment> const & protein_segment : protein_segments) {
protein_segment_ensembles.push_back(ProteinSegmentEnsemble(protein_segment));
}
LOGD << "adding frames to protein segment ensembles";
int frame_nr = 0;
while (trajectory.has_next() && ++frame_nr <= ensemble_size) {
Frame frame = trajectory.get_next_frame();
#pragma omp parallel for
for (size_t i = 0; i < protein_segment_ensembles.size(); i++) {
protein_segment_ensembles[i].add_frame(frame);
}
LOGV_IF(frame_nr % 100 == 0) << "read " << frame_nr << " frames";
}
LOGD << "read total number of " << frame_nr << " frames";
LOGD << "computing force constants for protein segment ensembles.";
#pragma omp parallel for
for (size_t i = 0; i < protein_segment_ensembles.size(); i++) {
protein_segment_ensembles[i].compute_force_constant(temperature);
}
}
LOGD << "Finished analyzing trajectory";
}
int CompassSensor::masterEnable(int en)
{
VFUNC_LOG;
LOGV_IF(SYSFS_VERBOSE, "HAL:sysfs:echo %d > %s (%lld)",
en, compassSysFs.chip_enable, getTimestamp());
return write_sysfs_int(compassSysFs.chip_enable, en);
}
static int out_standby_stream_locked(struct astream_out *out)
{
int ret = 0;
int attempts = MAX_WRITE_COMPLETION_ATTEMPTS;
if (out->standby || !out->data)
return 0;
out->standby = true;
/* wait for write completion if needed */
while (out->write_busy && attempts--) {
ret = pthread_cond_timeout_np(&out->write_cond,
&out->lock,
BUF_WRITE_COMPLETION_TIMEOUT_MS);
LOGE_IF(ret != 0, "out_standby_stream_locked() wait cond error %d", ret);
}
LOGE_IF(attempts == 0, "out_standby_stream_locked() a2dp_write() would not stop!!!");
LOGV_IF(!out->bt_enabled, "Standby skip stop: enabled %d", out->bt_enabled);
if (out->bt_enabled) {
ret = a2dp_stop(out->data);
}
release_wake_lock(A2DP_WAKE_LOCK_NAME);
return ret;
}
/* Read sysfs entry to determine whether overflow had happend
then write to sysfs to reset to zero */
int CompassSensor::checkCoilsReset()
{
int result =- 1;
VFUNC_LOG;
if(mCoilsResetFd != NULL) {
int attr;
rewind(mCoilsResetFd);
fscanf(mCoilsResetFd, "%d", &attr);
if(attr == 0)
return 0;
else {
LOGV_IF(SYSFS_VERBOSE, "HAL:overflow detected");
rewind(mCoilsResetFd);
if( fprintf(mCoilsResetFd, "%d", 0) < 0) {
LOGE("HAL:could not write overunderflow");
}
else
return 1;
}
}
else {
LOGE("HAL:could not read overunderflow");
}
return result;
}
static int pick_sensor(struct sensors_data_context_t *dev,
sensors_data_t* values)
{
uint32_t mask = SUPPORTED_SENSORS;
while (mask) {
uint32_t i = 31 - __builtin_clz(mask);
mask &= ~(1<<i);
if (dev->pendingSensors & (1<<i)) {
dev->pendingSensors &= ~(1<<i);
*values = dev->sensors[i];
values->sensor = id_to_sensor[i];
LOGV_IF(0, "%d [%f, %f, %f]",
values->sensor,
values->vector.x,
values->vector.y,
values->vector.z);
#if 0
LOGE("_______________sensor is:%d [%f, %f, %f],i is:%d",
values->sensor,
values->vector.x,
values->vector.y,
values->vector.z,
i);
#endif
return i;
}
}
LOGE("no sensor to return: pendingSensors = %08x", dev->pendingSensors);
return -1;
}
audio_io_handle_t AudioSystem::getOutput(audio_stream_type_t stream,
uint32_t samplingRate,
uint32_t format,
uint32_t channels,
audio_policy_output_flags_t flags)
{
audio_io_handle_t output = 0;
// Do not use stream to output map cache if the direct output
// flag is set or if we are likely to use a direct output
// (e.g voice call stream @ 8kHz could use BT SCO device and be routed to
// a direct output on some platforms).
// TODO: the output cache and stream to output mapping implementation needs to
// be reworked for proper operation with direct outputs. This code is too specific
// to the first use case we want to cover (Voice Recognition and Voice Dialer over
// Bluetooth SCO
if ((flags & AUDIO_POLICY_OUTPUT_FLAG_DIRECT) == 0 &&
((stream != AUDIO_STREAM_VOICE_CALL && stream != AUDIO_STREAM_BLUETOOTH_SCO) ||
channels != AUDIO_CHANNEL_OUT_MONO ||
(samplingRate != 8000 && samplingRate != 16000))) {
Mutex::Autolock _l(gLock);
output = AudioSystem::gStreamOutputMap.valueFor(stream);
LOGV_IF((output != 0), "getOutput() read %d from cache for stream %d", output, stream);
}
if (output == 0) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return 0;
output = aps->getOutput(stream, samplingRate, format, channels, flags);
if ((flags & AUDIO_POLICY_OUTPUT_FLAG_DIRECT) == 0) {
Mutex::Autolock _l(gLock);
AudioSystem::gStreamOutputMap.add(stream, output);
}
}
return output;
}
AudioTrack::~AudioTrack()
{
LOGV("AudioTrack dtor");
LOGV_IF(mSharedBuffer != 0, "Destructor sharedBuffer: %p", mSharedBuffer->pointer());
if (mStatus == NO_ERROR) {
// Make sure that callback function exits in the case where
// it is looping on buffer full condition in obtainBuffer().
// Otherwise the callback thread will never exit.
stop();
if (mAudioTrackThread != 0) {
mAudioTrackThread->requestExitAndWait();
mAudioTrackThread.clear();
}
if(mAudioTrack != NULL) {
mAudioTrack.clear();
}
if(mAudioSession >= 0) {
const sp<IAudioFlinger>& audioFlinger = AudioSystem::get_audio_flinger();
if (audioFlinger != 0) {
status_t status;
LOGV("Calling AudioFlinger::deleteSession");
audioFlinger->deleteSession();
} else {
LOGE("Could not get audioflinger");
}
AudioSystem::closeSession(mAudioSession);
mAudioSession = -1;
}
IPCThreadState::self()->flushCommands();
}
}
int CompassSensor::turnOnCompassFifo(void)
{
int i, res = 0, tempFd;
LOGV_IF(SYSFS_VERBOSE, "HAL:sysfs:echo %d > %s (%lld)",
1, compassSysFs.compass_fifo_enable, getTimestamp());
res += write_sysfs_int(compassSysFs.compass_fifo_enable, 1);
return res;
}
ssize_t InputEventCircularReader::readEvent(input_event const** events)
{
*events = mCurr;
ssize_t available = (mBufferEnd - mBuffer) - mFreeSpace;
LOGV_IF(INPUT_EVENT_DEBUG, "DEBUG:%s fd:%d, available:%d\n",
__PRETTY_FUNCTION__, mLastFd, (int)available);
return (available ? 1 : 0);
}
inline int64_t now_ns(void)
{
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
LOGV_IF(EXTRA_VERBOSE, "Time %lld", (int64_t)ts.tv_sec * 1000000000 + ts.tv_nsec);
return (int64_t) ts.tv_sec * 1000000000 + ts.tv_nsec;
}
/**
* @brief This function will enable/disable sensor.
* @param[in] handle
* which sensor to enable/disable.
* @param[in] en
* en=1, enable;
* en=0, disable
* @return if the operation is successful.
*/
int CompassSensor::enable(int32_t handle, int en)
{
VFUNC_LOG;
int res = 0;
LOGV_IF(SYSFS_VERBOSE, "HAL:sysfs:echo %d > %s (%lld)",
en, compassSysFs.compass_enable, getTimestamp());
res = write_sysfs_int(compassSysFs.compass_enable, en);
return res;
}
long CompassSensor::getSensitivity()
{
VFUNC_LOG;
long sensitivity;
LOGV_IF(SYSFS_VERBOSE, "HAL:sysfs:cat %s (%lld)",
compassSysFs.compass_scale, getTimestamp());
inv_read_data(compassSysFs.compass_scale, &sensitivity);
return sensitivity;
}
int SensorBase::openInput(const char *inputName)
{
int fd = -1;
const char *dirname = "/dev/input";
char devname[PATH_MAX];
char *filename;
DIR *dir;
struct dirent *de;
dir = opendir(dirname);
if(dir == NULL)
return -1;
strcpy(devname, dirname);
filename = devname + strlen(devname);
*filename++ = '/';
while((de = readdir(dir))) {
if(de->d_name[0] == '.' &&
(de->d_name[1] == '\0' ||
(de->d_name[1] == '.' && de->d_name[2] == '\0')))
continue;
strcpy(filename, de->d_name);
fd = open(devname, O_RDONLY);
LOGV_IF(EXTRA_VERBOSE, "path open %s", devname);
LOGI("path open %s", devname);
if (fd >= 0) {
char name[80];
if (ioctl(fd, EVIOCGNAME(sizeof(name) - 1), &name) < 1) {
name[0] = '\0';
}
LOGV_IF(EXTRA_VERBOSE, "name read %s", name);
if (!strcmp(name, inputName)) {
strcpy(input_name, filename);
break;
} else {
close(fd);
fd = -1;
}
}
}
closedir(dir);
LOGE_IF(fd < 0, "couldn't find '%s' input device", inputName);
return fd;
}
void InputEventCircularReader::next()
{
mCurr++;
mFreeSpace++;
if (mCurr >= mBufferEnd) {
mCurr = mBuffer;
}
ssize_t available = (mBufferEnd - mBuffer) - mFreeSpace;
LOGV_IF(INPUT_EVENT_DEBUG, "DEBUG:%s fd:%d, still available:%d\n",
__PRETTY_FUNCTION__, mLastFd, (int)available);
}
/**
* @brief This function will enable/disable sensor.
* @param[in] handle
* which sensor to enable/disable.
* @param[in] en
* en=1, enable;
* en=0, disable
* @return if the operation is successful.
*/
int PressureSensor::enable(int32_t handle, int en)
{
VFUNC_LOG;
int res = 0;
LOGV_IF(SYSFS_VERBOSE, "HAL:sysfs: echo %d > %s (%lld)",
en, pressureSysFs.pressure_enable, getTimestamp());
res = write_sysfs_int(pressureSysFs.pressure_enable, en);
return res;
}
ssize_t InputEventCircularReader::fill(int fd)
{
size_t numEventsRead = 0;
mLastFd = fd;
LOGV_IF(INPUT_EVENT_DEBUG,
"DEBUG:%s enter, fd=%d\n", __PRETTY_FUNCTION__, fd);
if (mFreeSpace) {
const ssize_t nread = read(fd, mHead, mFreeSpace * sizeof(input_event));
if (nread < 0 || nread % sizeof(input_event)) {
//LOGE("Partial event received nread=%d, required=%d",
// nread, sizeof(input_event));
//LOGE("FD trying to read is: %d");
// we got a partial event!!
if (INPUT_EVENT_DEBUG) {
LOGV_IF(nread < 0, "DEBUG:%s exit nread < 0\n",
__PRETTY_FUNCTION__);
LOGV_IF(nread % sizeof(input_event),
"DEBUG:%s exit nread %% sizeof(input_event)\n",
__PRETTY_FUNCTION__);
}
return (nread < 0 ? -errno : -EINVAL);
}
numEventsRead = nread / sizeof(input_event);
if (numEventsRead) {
mHead += numEventsRead;
mFreeSpace -= numEventsRead;
if (mHead > mBufferEnd) {
size_t s = mHead - mBufferEnd;
memcpy(mBuffer, mBufferEnd, s * sizeof(input_event));
mHead = mBuffer + s;
}
}
}
LOGV_IF(INPUT_EVENT_DEBUG, "DEBUG:%s exit, numEventsRead:%d\n",
__PRETTY_FUNCTION__, numEventsRead);
return numEventsRead;
}
void CompassSensor::processCompassEvent(const input_event *event)
{
VHANDLER_LOG;
switch (event->code) {
case EVENT_TYPE_ICOMPASS_X:
LOGV_IF(COMPASS_EVENT_DEBUG, "EVENT_TYPE_ICOMPASS_X\n");
mCachedCompassData[0] = event->value;
break;
case EVENT_TYPE_ICOMPASS_Y:
LOGV_IF(COMPASS_EVENT_DEBUG, "EVENT_TYPE_ICOMPASS_Y\n");
mCachedCompassData[1] = event->value;
break;
case EVENT_TYPE_ICOMPASS_Z:
LOGV_IF(COMPASS_EVENT_DEBUG, "EVENT_TYPE_ICOMPASS_Z\n");
mCachedCompassData[2] = event->value;
break;
}
mCompassTimestamp =
(int64_t)event->time.tv_sec * 1000000000L + event->time.tv_usec * 1000L;
}
int PressureSensor::setDelay(int32_t handle, int64_t ns)
{
VFUNC_LOG;
int res = 0;
mDelay = int(1000000000.f / ns);
LOGV_IF(SYSFS_VERBOSE, "HAL:sysfs: echo %lld > %s (%lld)",
mDelay, pressureSysFs.pressure_rate, getTimestamp());
res = write_sysfs_int(pressureSysFs.pressure_rate, mDelay);
#ifdef TIMER
int t_poll_time = (int)(ns / 1000000LL);
if (t_poll_time > min_poll_time) {
s_poll_time = t_poll_time;
} else {
s_poll_time = min_poll_time;
}
LOGV_IF(PROCESS_VERBOSE,
"HAL:setDelay : %llu ns, (%.2f Hz)", ns, 1000000000.f/ns);
#endif
return res;
}
int CompassSensor::masterEnable(int en) {
VFUNC_LOG;
int res = 0;
LOGV_IF(SYSFS_VERBOSE, "HAL:sysfs:echo %d > %s (%lld)",
en, compassSysFs.chip_enable, getTimestamp());
int tempFd = open(compassSysFs.chip_enable, O_RDWR);
res = errno;
if(tempFd < 0){
LOGE("HAL:open of %s failed with '%s' (%d)",
compassSysFs.chip_enable, strerror(res), res);
return res;
}
res = enable_sysfs_sensor(tempFd, en);
return res;
}
AudioTrack::~AudioTrack()
{
LOGV_IF(mSharedBuffer != 0, "Destructor sharedBuffer: %p", mSharedBuffer->pointer());
if (mStatus == NO_ERROR) {
// Make sure that callback function exits in the case where
// it is looping on buffer full condition in obtainBuffer().
// Otherwise the callback thread will never exit.
stop();
if (mAudioTrackThread != 0) {
mAudioTrackThread->requestExitAndWait();
mAudioTrackThread.clear();
}
mAudioTrack.clear();
IPCThreadState::self()->flushCommands();
}
}
int CompassSensor::setDelay(int32_t handle, int64_t ns)
{
VFUNC_LOG;
int tempFd;
int res;
LOGV_IF(SYSFS_VERBOSE, "HAL:sysfs:echo %.0f > %s (%lld)",
1000000000.f / ns, compassSysFs.compass_rate, getTimestamp());
mDelay = ns;
if (ns == 0)
return -1;
tempFd = open(compassSysFs.compass_rate, O_RDWR);
res = write_attribute_sensor(tempFd, 1000000000.f / ns);
if(res < 0) {
LOGE("HAL:Compass update delay error");
}
return res;
}
CompassSensor::CompassSensor()
: SensorBase(COMPASS_NAME, NULL),
mCompassTimestamp(0),
mCompassInputReader(8),
mCoilsResetFd(0)
{
FILE *fptr;
VFUNC_LOG;
mYasCompass = false;
if(!strcmp(dev_name, "USE_SYSFS")) {
char sensor_name[20];
find_name_by_sensor_type("in_magn_x_raw", "iio:device", sensor_name);
strncpy(dev_full_name, sensor_name,
sizeof(dev_full_name) / sizeof(dev_full_name[0]));
if(!strncmp(dev_full_name, "yas", 3)) {
mYasCompass = true;
}
} else {
#ifdef COMPASS_YAS53x
/* for YAS53x compasses, dev_name is just a prefix,
we need to find the actual name */
if (fill_dev_full_name_by_prefix(dev_name,
dev_full_name, sizeof(dev_full_name) / sizeof(dev_full_name[0]))) {
LOGE("Cannot find Yamaha device with prefix name '%s' - "
"magnetometer will likely not work.", dev_name);
} else {
mYasCompass = true;
}
#else
strncpy(dev_full_name, dev_name,
sizeof(dev_full_name) / sizeof(dev_full_name[0]));
#endif
}
if (inv_init_sysfs_attributes()) {
LOGE("Error Instantiating Compass\n");
return;
}
if (!strcmp(dev_full_name, "INV_COMPASS")) {
mI2CBus = COMPASS_BUS_SECONDARY;
} else {
mI2CBus = COMPASS_BUS_PRIMARY;
}
memset(mCachedCompassData, 0, sizeof(mCachedCompassData));
if (!isIntegrated()) {
enable(ID_M, 0);
}
LOGV_IF(SYSFS_VERBOSE, "HAL:compass name: %s", dev_full_name);
enable_iio_sysfs();
LOGV_IF(SYSFS_VERBOSE, "HAL:sysfs:cat %s (%lld)",
compassSysFs.compass_orient, getTimestamp());
fptr = fopen(compassSysFs.compass_orient, "r");
if (fptr != NULL) {
int om[9];
if (fscanf(fptr, "%d,%d,%d,%d,%d,%d,%d,%d,%d",
&om[0], &om[1], &om[2], &om[3], &om[4], &om[5],
&om[6], &om[7], &om[8]) < 0 || fclose(fptr)) {
LOGE("HAL:could not read compass mounting matrix");
} else {
LOGV_IF(EXTRA_VERBOSE,
"HAL:compass mounting matrix: "
"%+d %+d %+d %+d %+d %+d %+d %+d %+d",
om[0], om[1], om[2], om[3], om[4], om[5], om[6], om[7], om[8]);
mCompassOrientation[0] = om[0];
mCompassOrientation[1] = om[1];
mCompassOrientation[2] = om[2];
mCompassOrientation[3] = om[3];
mCompassOrientation[4] = om[4];
mCompassOrientation[5] = om[5];
mCompassOrientation[6] = om[6];
mCompassOrientation[7] = om[7];
mCompassOrientation[8] = om[8];
}
}
if(mYasCompass) {
mCoilsResetFd = fopen(compassSysFs.compass_attr_1, "r+");
if (fptr == NULL) {
LOGE("HAL:Could not open compass overunderflow");
}
}
}
void CompassSensor::enable_iio_sysfs()
{
VFUNC_LOG;
int tempFd = 0;
char iio_device_node[MAX_CHIP_ID_LEN];
FILE *tempFp = NULL;
const char* compass = dev_full_name;
LOGV_IF(SYSFS_VERBOSE, "HAL:sysfs:echo %d > %s (%lld)",
1, compassSysFs.in_timestamp_en, getTimestamp());
write_sysfs_int(compassSysFs.in_timestamp_en, 1);
LOGV_IF(SYSFS_VERBOSE, "HAL:sysfs:echo %d > %s (%lld)",
IIO_BUFFER_LENGTH, compassSysFs.buffer_length, getTimestamp());
tempFp = fopen(compassSysFs.buffer_length, "w");
if (tempFp == NULL) {
LOGE("HAL:could not open buffer length");
} else {
if (fprintf(tempFp, "%d", IIO_BUFFER_LENGTH) < 0 || fclose(tempFp) < 0) {
LOGE("HAL:could not write buffer length");
}
}
sprintf(iio_device_node, "%s%d", "/dev/iio:device",
find_type_by_name(compass, "iio:device"));
compass_fd = open(iio_device_node, O_RDONLY);
int res = errno;
if (compass_fd < 0) {
LOGE("HAL:could not open '%s' iio device node in path '%s' - "
"error '%s' (%d)",
compass, iio_device_node, strerror(res), res);
} else {
LOGV_IF(EXTRA_VERBOSE,
"HAL:iio %s, compass_fd opened : %d", compass, compass_fd);
}
/* TODO: need further tests for optimization to reduce context-switch
LOGV_IF(SYSFS_VERBOSE, "HAL:sysfs:echo 1 > %s (%lld)",
compassSysFs.compass_x_fifo_enable, getTimestamp());
tempFd = open(compassSysFs.compass_x_fifo_enable, O_RDWR);
res = errno;
if (tempFd > 0) {
res = enable_sysfs_sensor(tempFd, 1);
} else {
LOGE("HAL:open of %s failed with '%s' (%d)",
compassSysFs.compass_x_fifo_enable, strerror(res), res);
}
LOGV_IF(SYSFS_VERBOSE, "HAL:sysfs:echo 1 > %s (%lld)",
compassSysFs.compass_y_fifo_enable, getTimestamp());
tempFd = open(compassSysFs.compass_y_fifo_enable, O_RDWR);
res = errno;
if (tempFd > 0) {
res = enable_sysfs_sensor(tempFd, 1);
} else {
LOGE("HAL:open of %s failed with '%s' (%d)",
compassSysFs.compass_y_fifo_enable, strerror(res), res);
}
LOGV_IF(SYSFS_VERBOSE, "HAL:sysfs:echo 1 > %s (%lld)",
compassSysFs.compass_z_fifo_enable, getTimestamp());
tempFd = open(compassSysFs.compass_z_fifo_enable, O_RDWR);
res = errno;
if (tempFd > 0) {
res = enable_sysfs_sensor(tempFd, 1);
} else {
LOGE("HAL:open of %s failed with '%s' (%d)",
compassSysFs.compass_z_fifo_enable, strerror(res), res);
}
*/
}
status_t AudioTrack::set(
int streamType,
uint32_t sampleRate,
int format,
int channelMask,
int frameCount,
uint32_t flags,
callback_t cbf,
void* user,
int notificationFrames,
const sp<IMemory>& sharedBuffer,
bool threadCanCallJava,
int sessionId)
{
LOGV_IF(sharedBuffer != 0, "sharedBuffer: %p, size: %d", sharedBuffer->pointer(), sharedBuffer->size());
AutoMutex lock(mLock);
if (mAudioTrack != 0) {
LOGE("Track already in use");
return INVALID_OPERATION;
}
int afSampleRate;
if (AudioSystem::getOutputSamplingRate(&afSampleRate, streamType) != NO_ERROR) {
return NO_INIT;
}
uint32_t afLatency;
if (AudioSystem::getOutputLatency(&afLatency, streamType) != NO_ERROR) {
return NO_INIT;
}
// handle default values first.
if (streamType == AUDIO_STREAM_DEFAULT) {
streamType = AUDIO_STREAM_MUSIC;
}
if (sampleRate == 0) {
sampleRate = afSampleRate;
}
// these below should probably come from the audioFlinger too...
if (format == 0) {
format = AUDIO_FORMAT_PCM_16_BIT;
}
if (channelMask == 0) {
channelMask = AUDIO_CHANNEL_OUT_STEREO;
}
// validate parameters
if (!audio_is_valid_format(format)) {
LOGE("Invalid format");
return BAD_VALUE;
}
// force direct flag if format is not linear PCM
if (!audio_is_linear_pcm(format)) {
flags |= AUDIO_POLICY_OUTPUT_FLAG_DIRECT;
}
if (!audio_is_output_channel(channelMask)) {
LOGE("Invalid channel mask");
return BAD_VALUE;
}
uint32_t channelCount = popcount(channelMask);
audio_io_handle_t output = AudioSystem::getOutput(
(audio_stream_type_t)streamType,
sampleRate,format, channelMask,
(audio_policy_output_flags_t)flags);
if (output == 0) {
LOGE("Could not get audio output for stream type %d", streamType);
return BAD_VALUE;
}
mVolume[LEFT] = 1.0f;
mVolume[RIGHT] = 1.0f;
mSendLevel = 0;
mFrameCount = frameCount;
mNotificationFramesReq = notificationFrames;
mSessionId = sessionId;
mAuxEffectId = 0;
// create the IAudioTrack
status_t status = createTrack_l(streamType,
sampleRate,
(uint32_t)format,
(uint32_t)channelMask,
frameCount,
flags,
sharedBuffer,
output,
true);
if (status != NO_ERROR) {
return status;
}
if (cbf != 0) {
mAudioTrackThread = new AudioTrackThread(*this, threadCanCallJava);
if (mAudioTrackThread == 0) {
LOGE("Could not create callback thread");
return NO_INIT;
}
}
mStatus = NO_ERROR;
mStreamType = streamType;
mFormat = (uint32_t)format;
mChannelMask = (uint32_t)channelMask;
mChannelCount = channelCount;
mSharedBuffer = sharedBuffer;
mMuted = false;
mActive = 0;
mCbf = cbf;
mUserData = user;
mLoopCount = 0;
mMarkerPosition = 0;
mMarkerReached = false;
mNewPosition = 0;
mUpdatePeriod = 0;
mFlushed = false;
mFlags = flags;
AudioSystem::acquireAudioSessionId(mSessionId);
mRestoreStatus = NO_ERROR;
return NO_ERROR;
}
