/* * 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 <slab.h> #include <timer.h> #include <plat/inc/gpio.h> #include <plat/inc/exti.h> #include <plat/inc/syscfg.h> #include <variant/inc/variant.h> #define VSYNC_APP_ID APP_ID_MAKE(APP_ID_VENDOR_GOOGLE, 7) #define VSYNC_APP_VERSION 2 // This defines how many vsync events we could handle being backed up in the // queue. Use this to size our slab #define MAX_VSYNC_EVENTS 4 #define MAX_VSYNC_INT_LATENCY 1000 /* in ns */ #ifndef VSYNC_PIN #error "VSYNC_PIN is not defined; please define in variant.h" #endif #ifndef VSYNC_IRQ #error "VSYNC_IRQ is not defined; please define in variant.h" #endif #define INFO_PRINT(fmt, ...) do { \ osLog(LOG_INFO, "%s " fmt, "[VSYNC]", ##__VA_ARGS__); \ } while (0); #define ERROR_PRINT(fmt, ...) INFO_PRINT("%s" fmt, "ERROR: ", ##__VA_ARGS__); \ #define DEBUG_PRINT(fmt, ...) do { \ if (enable_debug) { \ INFO_PRINT(fmt, ##__VA_ARGS__); \ } \ } while (0); static const bool enable_debug = 0; static struct SensorTask { struct Gpio *pin; struct ChainedIsr isr; struct SlabAllocator *evtSlab; uint32_t id; uint32_t sensorHandle; bool on; } mTask; static bool vsyncAllocateEvt(struct SingleAxisDataEvent **evPtr, uint64_t time) { struct SingleAxisDataEvent *ev; *evPtr = slabAllocatorAlloc(mTask.evtSlab); ev = *evPtr; if (!ev) { ERROR_PRINT("slabAllocatorAlloc() failed\n"); return false; } memset(&ev->samples[0].firstSample, 0x00, sizeof(struct SensorFirstSample)); ev->referenceTime = time; ev->samples[0].firstSample.numSamples = 1; ev->samples[0].idata = 1; return true; } static void vsyncFreeEvt(void *ptr) { slabAllocatorFree(mTask.evtSlab, ptr); } static bool vsyncIsr(struct ChainedIsr *localIsr) { struct SensorTask *data = container_of(localIsr, struct SensorTask, isr); struct SingleAxisDataEvent *ev; if (!extiIsPendingGpio(data->pin)) { return false; } if (data->on) { if (vsyncAllocateEvt(&ev, sensorGetTime())) { if (!osEnqueueEvtOrFree(sensorGetMyEventType(SENS_TYPE_VSYNC), ev, vsyncFreeEvt)) { ERROR_PRINT("osEnqueueEvtOrFree() failed\n"); } } } extiClearPendingGpio(data->pin); return true; } static bool enableInterrupt(struct Gpio *pin, struct ChainedIsr *isr) { gpioConfigInput(pin, GPIO_SPEED_LOW, GPIO_PULL_NONE); syscfgSetExtiPort(pin); extiEnableIntGpio(pin, EXTI_TRIGGER_FALLING); extiChainIsr(VSYNC_IRQ, isr); return true; } static bool disableInterrupt(struct Gpio *pin, struct ChainedIsr *isr) { extiUnchainIsr(VSYNC_IRQ, isr); extiDisableIntGpio(pin); return true; } static const struct SensorInfo mSensorInfo = { .sensorName = "Camera Vsync", .sensorType = SENS_TYPE_VSYNC, .numAxis = NUM_AXIS_ONE, .interrupt = NANOHUB_INT_NONWAKEUP, .minSamples = 20, }; static bool vsyncPower(bool on, void *cookie) { INFO_PRINT("power %d\n", on); if (on) { extiClearPendingGpio(mTask.pin); enableInterrupt(mTask.pin, &mTask.isr); } else { disableInterrupt(mTask.pin, &mTask.isr); extiClearPendingGpio(mTask.pin); } mTask.on = on; sensorSignalInternalEvt(mTask.sensorHandle, SENSOR_INTERNAL_EVT_POWER_STATE_CHG, on, 0); return true; } static bool vsyncFirmwareUpload(void *cookie) { return sensorSignalInternalEvt(mTask.sensorHandle, SENSOR_INTERNAL_EVT_FW_STATE_CHG, 1, 0); } static bool vsyncSetRate(uint32_t rate, uint64_t latency, void *cookie) { INFO_PRINT("setRate\n"); return sensorSignalInternalEvt(mTask.sensorHandle, SENSOR_INTERNAL_EVT_RATE_CHG, rate, latency); } static bool vsyncFlush(void *cookie) { INFO_PRINT("flush\n"); return osEnqueueEvt(sensorGetMyEventType(SENS_TYPE_VSYNC), SENSOR_DATA_EVENT_FLUSH, NULL); } static const struct SensorOps mSensorOps = { .sensorPower = vsyncPower, .sensorFirmwareUpload = vsyncFirmwareUpload, .sensorSetRate = vsyncSetRate, .sensorFlush = vsyncFlush, }; 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.pin = gpioRequest(VSYNC_PIN); mTask.isr.func = vsyncIsr; mTask.isr.maxLatencyNs = MAX_VSYNC_INT_LATENCY; mTask.evtSlab = slabAllocatorNew(sizeof(struct SingleAxisDataEvent) + sizeof(struct SingleAxisDataPoint), 4, MAX_VSYNC_EVENTS); if (!mTask.evtSlab) { ERROR_PRINT("slabAllocatorNew() failed\n"); return false; } return true; } static void endTask(void) { disableInterrupt(mTask.pin, &mTask.isr); extiUnchainIsr(VSYNC_IRQ, &mTask.isr); extiClearPendingGpio(mTask.pin); gpioRelease(mTask.pin); sensorUnregister(mTask.sensorHandle); } INTERNAL_APP_INIT(VSYNC_APP_ID, VSYNC_APP_VERSION, startTask, endTask, handleEvent);