251 lines
7.0 KiB
C
251 lines
7.0 KiB
C
/*
|
|
* Copyright (C) 2016 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.
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <float.h>
|
|
|
|
#include <eventnums.h>
|
|
#include <gpio.h>
|
|
#include <heap.h>
|
|
#include <hostIntf.h>
|
|
#include <isr.h>
|
|
#include <nanohubPacket.h>
|
|
#include <sensors.h>
|
|
#include <seos.h>
|
|
#include <timer.h>
|
|
#include <plat/gpio.h>
|
|
#include <plat/exti.h>
|
|
#include <plat/syscfg.h>
|
|
#include <variant/variant.h>
|
|
|
|
#define APP_ID APP_ID_MAKE(NANOHUB_VENDOR_GOOGLE, 11)
|
|
#define APP_VERSION 2
|
|
|
|
#define HALL_REPORT_OPENED_VALUE 0
|
|
#define HALL_REPORT_CLOSED_VALUE 1
|
|
#define HALL_DEBOUNCE_TIMER_DELAY 25000000ULL // 25 milliseconds
|
|
|
|
#ifndef HALL_S_PIN
|
|
#error "HALL_S_PIN is not defined; please define in variant.h"
|
|
#endif
|
|
#ifndef HALL_S_IRQ
|
|
#error "HALL_S_IRQ is not defined; please define in variant.h"
|
|
#endif
|
|
#ifndef HALL_N_PIN
|
|
#error "HALL_N_PIN is not defined; please define in variant.h"
|
|
#endif
|
|
#ifndef HALL_N_IRQ
|
|
#error "HALL_N_IRQ is not defined; please define in variant.h"
|
|
#endif
|
|
|
|
#define MAKE_TYPE(sPin,nPin) (sPin ? HALL_REPORT_OPENED_VALUE : HALL_REPORT_CLOSED_VALUE) + \
|
|
((nPin ? HALL_REPORT_OPENED_VALUE : HALL_REPORT_CLOSED_VALUE) << 1)
|
|
|
|
static struct SensorTask
|
|
{
|
|
struct Gpio *sPin;
|
|
struct Gpio *nPin;
|
|
struct ChainedIsr sIsr;
|
|
struct ChainedIsr nIsr;
|
|
|
|
uint32_t id;
|
|
uint32_t sensorHandle;
|
|
uint32_t debounceTimerHandle;
|
|
|
|
int32_t prevReportedState;
|
|
|
|
bool on;
|
|
} mTask;
|
|
|
|
static void hallReportState(int32_t pinState)
|
|
{
|
|
union EmbeddedDataPoint sample;
|
|
if (pinState != mTask.prevReportedState) {
|
|
mTask.prevReportedState = pinState;
|
|
sample.idata = pinState;
|
|
osEnqueueEvt(sensorGetMyEventType(SENS_TYPE_HALL), sample.vptr, NULL);
|
|
}
|
|
}
|
|
|
|
static void debounceTimerCallback(uint32_t timerId, void *cookie)
|
|
{
|
|
int32_t prevPinState = (int32_t)cookie;
|
|
int32_t currPinState = MAKE_TYPE(gpioGet(mTask.sPin), gpioGet(mTask.nPin));
|
|
|
|
if (mTask.on && (currPinState == prevPinState)) {
|
|
hallReportState(currPinState);
|
|
}
|
|
}
|
|
|
|
static void startDebounceTimer(struct SensorTask *data)
|
|
{
|
|
int32_t currPinState = MAKE_TYPE(gpioGet(data->sPin), gpioGet(data->nPin));
|
|
if (data->debounceTimerHandle)
|
|
timTimerCancel(data->debounceTimerHandle);
|
|
|
|
data->debounceTimerHandle = timTimerSet(HALL_DEBOUNCE_TIMER_DELAY, 0, 50, debounceTimerCallback, (void*)currPinState, true /* oneShot */);
|
|
}
|
|
|
|
static bool hallSouthIsr(struct ChainedIsr *localIsr)
|
|
{
|
|
struct SensorTask *data = container_of(localIsr, struct SensorTask, sIsr);
|
|
if (data->on)
|
|
startDebounceTimer(data);
|
|
extiClearPendingGpio(data->sPin);
|
|
return true;
|
|
}
|
|
|
|
static bool hallNorthIsr(struct ChainedIsr *localIsr)
|
|
{
|
|
struct SensorTask *data = container_of(localIsr, struct SensorTask, nIsr);
|
|
if (data->on)
|
|
startDebounceTimer(data);
|
|
extiClearPendingGpio(data->nPin);
|
|
return true;
|
|
}
|
|
|
|
static bool enableInterrupt(struct Gpio *pin, struct ChainedIsr *isr, IRQn_Type irqn)
|
|
{
|
|
gpioConfigInput(pin, GPIO_SPEED_LOW, GPIO_PULL_NONE);
|
|
syscfgSetExtiPort(pin);
|
|
extiEnableIntGpio(pin, EXTI_TRIGGER_BOTH);
|
|
extiChainIsr(irqn, isr);
|
|
return true;
|
|
}
|
|
|
|
static bool disableInterrupt(struct Gpio *pin, struct ChainedIsr *isr, IRQn_Type irqn)
|
|
{
|
|
extiUnchainIsr(irqn, isr);
|
|
extiDisableIntGpio(pin);
|
|
return true;
|
|
}
|
|
|
|
static const uint32_t supportedRates[] =
|
|
{
|
|
SENSOR_RATE_ONCHANGE,
|
|
0
|
|
};
|
|
|
|
static const struct SensorInfo mSensorInfo =
|
|
{
|
|
.sensorName = "Hall",
|
|
.supportedRates = supportedRates,
|
|
.sensorType = SENS_TYPE_HALL,
|
|
.numAxis = NUM_AXIS_EMBEDDED,
|
|
.interrupt = NANOHUB_INT_WAKEUP,
|
|
.minSamples = 20
|
|
};
|
|
|
|
static bool hallPower(bool on, void *cookie)
|
|
{
|
|
if (on) {
|
|
extiClearPendingGpio(mTask.sPin);
|
|
extiClearPendingGpio(mTask.nPin);
|
|
enableInterrupt(mTask.sPin, &mTask.sIsr, HALL_S_IRQ);
|
|
enableInterrupt(mTask.nPin, &mTask.nIsr, HALL_N_IRQ);
|
|
} else {
|
|
disableInterrupt(mTask.sPin, &mTask.sIsr, HALL_S_IRQ);
|
|
disableInterrupt(mTask.nPin, &mTask.nIsr, HALL_N_IRQ);
|
|
extiClearPendingGpio(mTask.sPin);
|
|
extiClearPendingGpio(mTask.nPin);
|
|
}
|
|
|
|
mTask.on = on;
|
|
mTask.prevReportedState = -1;
|
|
|
|
if (mTask.debounceTimerHandle) {
|
|
timTimerCancel(mTask.debounceTimerHandle);
|
|
mTask.debounceTimerHandle = 0;
|
|
}
|
|
|
|
return sensorSignalInternalEvt(mTask.sensorHandle, SENSOR_INTERNAL_EVT_POWER_STATE_CHG, on, 0);
|
|
}
|
|
|
|
static bool hallFirmwareUpload(void *cookie)
|
|
{
|
|
return sensorSignalInternalEvt(mTask.sensorHandle, SENSOR_INTERNAL_EVT_FW_STATE_CHG, 1, 0);
|
|
}
|
|
|
|
static bool hallSetRate(uint32_t rate, uint64_t latency, void *cookie)
|
|
{
|
|
// report initial state of hall interrupt pin
|
|
if (mTask.on)
|
|
hallReportState(MAKE_TYPE(gpioGet(mTask.sPin), gpioGet(mTask.nPin)));
|
|
|
|
return sensorSignalInternalEvt(mTask.sensorHandle, SENSOR_INTERNAL_EVT_RATE_CHG, rate, latency);
|
|
}
|
|
|
|
static bool hallFlush(void *cookie)
|
|
{
|
|
return osEnqueueEvt(sensorGetMyEventType(SENS_TYPE_HALL), SENSOR_DATA_EVENT_FLUSH, NULL);
|
|
}
|
|
|
|
static bool hallSendLastSample(void *cookie, uint32_t tid)
|
|
{
|
|
union EmbeddedDataPoint sample;
|
|
bool result = true;
|
|
|
|
if (mTask.prevReportedState != -1) {
|
|
sample.idata = mTask.prevReportedState;
|
|
result = osEnqueuePrivateEvt(sensorGetMyEventType(SENS_TYPE_HALL), sample.vptr, NULL, tid);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static const struct SensorOps mSensorOps =
|
|
{
|
|
.sensorPower = hallPower,
|
|
.sensorFirmwareUpload = hallFirmwareUpload,
|
|
.sensorSetRate = hallSetRate,
|
|
.sensorFlush = hallFlush,
|
|
.sensorSendOneDirectEvt = hallSendLastSample
|
|
};
|
|
|
|
static void handleEvent(uint32_t evtType, const void* evtData)
|
|
{
|
|
}
|
|
|
|
static bool startTask(uint32_t taskId)
|
|
{
|
|
mTask.id = taskId;
|
|
mTask.sensorHandle = sensorRegister(&mSensorInfo, &mSensorOps, NULL, true);
|
|
mTask.prevReportedState = -1;
|
|
mTask.sPin = gpioRequest(HALL_S_PIN);
|
|
mTask.nPin = gpioRequest(HALL_N_PIN);
|
|
mTask.sIsr.func = hallSouthIsr;
|
|
mTask.nIsr.func = hallNorthIsr;
|
|
|
|
return true;
|
|
}
|
|
|
|
static void endTask(void)
|
|
{
|
|
disableInterrupt(mTask.sPin, &mTask.sIsr, HALL_S_IRQ);
|
|
disableInterrupt(mTask.nPin, &mTask.nIsr, HALL_N_IRQ);
|
|
extiUnchainIsr(HALL_S_IRQ, &mTask.sIsr);
|
|
extiUnchainIsr(HALL_N_IRQ, &mTask.nIsr);
|
|
extiClearPendingGpio(mTask.sPin);
|
|
extiClearPendingGpio(mTask.nPin);
|
|
gpioRelease(mTask.sPin);
|
|
gpioRelease(mTask.nPin);
|
|
sensorUnregister(mTask.sensorHandle);
|
|
memset(&mTask, 0, sizeof(struct SensorTask));
|
|
}
|
|
|
|
INTERNAL_APP_INIT(APP_ID, APP_VERSION, startTask, endTask, handleEvent);
|