firmware/os/drivers/intersil_isl29034/isl29034.c - device/google/contexthub - Git at Google

 /*
  * Copyright (C) 2017 STMicroelectronics
  * Copyright (C) 2017 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 <seos.h>
 #include <i2c.h>
 #include <timer.h>
 #include <sensors.h>
 #include <heap.h>
 #include <hostIntf.h>
 #include <nanohubPacket.h>
 #include <eventnums.h>
 #include <util.h>
 #include <variant/variant.h>

 #ifdef DEBUG
 #undef ISL29034_DBG_ENABLED
 #define ISL29034_DBG_ENABLED                    1
 #endif

 #ifndef ISL29034_DBG_ENABLED
 #define ISL29034_DBG_ENABLED                    0
 #endif /* ISL29034_DBG_ENABLED */

 #define ISL29034_APP_VERSION                    1

 #define ISL29034_REG_CMD_1                      0x00
 #define ISL29034_REG_CMD_2                      0x01
 #define ISL29034_REG_DATA_L                     0x02
 #define ISL29034_REG_DATA_H                     0x03
 #define ISL29034_REG_ID                         0x0f

 #define ISL29034_CMD1_POWERDOWN                 (0 << 5)
 #define ISL29034_CMD1_MEASURE                   (5 << 5)

 #define ISL29034_CMD2_RANGE_1KLUX               0
 #define ISL29034_CMD2_RANGE_4KLUX               1
 #define ISL29034_CMD2_RANGE_16KLUX              2
 #define ISL29034_CMD2_RANGE_64KLUX              3
 #define ISL29034_CMD2_RES_16BIT                 (0 << 2)
 #define ISL29034_CMD2_RES_12BIT                 (1 << 2)
 #define ISL29034_CMD2_RES_8BIT                  (2 << 2)
 #define ISL29034_CMD2_RES_4BIT                  (3 << 2)

 #define ISL29034_ID                             (5 << 3)
 #define ISL29034_ID_MASK                        (7 << 3)
 #define ISL29034_ID_BOUT                        (1 << 7)

 #define ISL29034_ALS_INVALID                    UINT32_MAX
 #define ISL29034_MAX_PENDING_I2C_REQUESTS       4
 #define ISL29034_MAX_I2C_TRANSFER_SIZE          3

 /* Used when SENSOR_RATE_ONCHANGE is requested */
 #define ISL29034_DEFAULT_RATE                   SENSOR_HZ(10)

 #ifndef ISL29034_I2C_BUS_ID
 #error "ISL29034_I2C_BUS_ID is not defined; please define in variant.h"
 #endif

 #ifndef ISL29034_I2C_SPEED
 #error "ISL29034_I2C_SPEED is not defined; please define in variant.h"
 #endif

 #ifndef ISL29034_I2C_ADDR
 #define ISL29034_I2C_ADDR                       0x44
 #endif

 #define INFO_PRINT(fmt, ...) \
     do { \
         osLog(LOG_INFO, "%s " fmt, "[ISL29034]", ##__VA_ARGS__); \
     } while (0);

 #define DEBUG_PRINT(fmt, ...) \
     do { \
         if (ISL29034_DBG_ENABLED) { \
             osLog(LOG_DEBUG, "%s " fmt, "[ISL29034]", ##__VA_ARGS__); \
         } \
     } while (0);

 #define ERROR_PRINT(fmt, ...) \
     do { \
         osLog(LOG_ERROR, "%s " fmt, "[ISL29034]", ##__VA_ARGS__); \
     } while (0);


 /* Private driver events */
 enum SensorEvents
 {
     EVT_SENSOR_I2C = EVT_APP_START + 1,
     EVT_SENSOR_ALS_TIMER,
 };

 /* I2C state machine */
 enum SensorState
 {
     SENSOR_STATE_VERIFY_ID,
     SENSOR_STATE_CLEAR_BOUT,

     SENSOR_STATE_ENABLING_ALS,
     SENSOR_STATE_DISABLING_ALS,

     SENSOR_STATE_IDLE,
     SENSOR_STATE_SAMPLING,
 };

 struct I2cTransfer
 {
     size_t tx;
     size_t rx;
     int err;

     uint8_t txrxBuf[ISL29034_MAX_I2C_TRANSFER_SIZE];

     uint8_t state;
     bool inUse;
 };

 struct SensorData
 {
     uint32_t tid;

     uint32_t alsHandle;
     uint32_t alsTimerHandle;

     struct I2cTransfer transfers[ISL29034_MAX_PENDING_I2C_REQUESTS];

     union EmbeddedDataPoint lastAlsSample;

     bool alsOn;
     bool alsReading;
 };

 static struct SensorData mData;

 static const uint32_t supportedRates[] =
 {
     SENSOR_HZ(10),
     SENSOR_RATE_ONCHANGE,
     0
 };

 // should match "supported rates in length" and be the timer length for that rate in nanosecs
 static const uint64_t rateTimerVals[] =
 {
     1000000000ULL / 10,
 };

 /*
  * Helper functions
  */

 static void i2cCallback(void *cookie, size_t tx, size_t rx, int err)
 {
     struct I2cTransfer *xfer = cookie;

     xfer->tx = tx;
     xfer->rx = rx;
     xfer->err = err;

     osEnqueuePrivateEvt(EVT_SENSOR_I2C, cookie, NULL, mData.tid);
     if (err != 0)
         INFO_PRINT("i2c error (tx: %d, rx: %d, err: %d)\n", tx, rx, err);
 }

 // Allocate a buffer and mark it as in use with the given state, or return NULL
 // if no buffers available. Must *not* be called from interrupt context.
 static struct I2cTransfer *allocXfer(uint8_t state)
 {
     size_t i;

     for (i = 0; i < ARRAY_SIZE(mData.transfers); i++) {
         if (!mData.transfers[i].inUse) {
             mData.transfers[i].inUse = true;
             mData.transfers[i].state = state;
             return &mData.transfers[i];
         }
     }

     ERROR_PRINT("Ran out of i2c buffers!");
     return NULL;
 }

 // Helper function to write a one byte register. Returns true if we got a
 // successful return value from i2cMasterTx().
 static bool writeRegister(uint8_t reg, uint8_t value, uint8_t state)
 {
     struct I2cTransfer *xfer = allocXfer(state);
     int ret = -1;

     if (xfer != NULL) {
         xfer->txrxBuf[0] = reg;
         xfer->txrxBuf[1] = value;
         ret = i2cMasterTx(ISL29034_I2C_BUS_ID, ISL29034_I2C_ADDR, xfer->txrxBuf, 2, i2cCallback, xfer);
     }

     return (ret == 0);
 }

 static void alsTimerCallback(uint32_t timerId, void *cookie)
 {
     osEnqueuePrivateEvt(EVT_SENSOR_ALS_TIMER, cookie, NULL, mData.tid);
 }

 static inline float getLuxFromAlsData(uint16_t als)
 {
     float range = 64000.0;
     float resolution = 65536.0;

     return range * als / resolution;
 }

 static bool sensorPowerAls(bool on, void *cookie)
 {
     INFO_PRINT("sensorPowerAls: %d\n", on);

     if (mData.alsTimerHandle) {
         timTimerCancel(mData.alsTimerHandle);
         mData.alsTimerHandle = 0;
         mData.alsReading = false;
     }

     mData.lastAlsSample.idata = ISL29034_ALS_INVALID;
     mData.alsOn = on;

     writeRegister(ISL29034_REG_CMD_1,
                   on ? ISL29034_CMD1_MEASURE : ISL29034_CMD1_POWERDOWN,
                   on ? SENSOR_STATE_ENABLING_ALS : SENSOR_STATE_DISABLING_ALS);

     return true;
 }

 static bool sensorFirmwareAls(void *cookie)
 {
     sensorSignalInternalEvt(mData.alsHandle, SENSOR_INTERNAL_EVT_FW_STATE_CHG, 1, 0);
     return true;
 }

 static bool sensorRateAls(uint32_t rate, uint64_t latency, void *cookie)
 {
     if (rate == SENSOR_RATE_ONCHANGE)
         rate = ISL29034_DEFAULT_RATE;

     INFO_PRINT("sensorRateAls: %ld/%lld\n", rate, latency);

     if (mData.alsTimerHandle)
         timTimerCancel(mData.alsTimerHandle);
     mData.alsTimerHandle = timTimerSet(sensorTimerLookupCommon(supportedRates, rateTimerVals, rate), 0, 50, alsTimerCallback, NULL, false);
     osEnqueuePrivateEvt(EVT_SENSOR_ALS_TIMER, NULL, NULL, mData.tid);
     sensorSignalInternalEvt(mData.alsHandle, SENSOR_INTERNAL_EVT_RATE_CHG, rate, latency);

     return true;
 }

 static bool sensorFlushAls(void *cookie)
 {
     return osEnqueueEvt(sensorGetMyEventType(SENS_TYPE_ALS), SENSOR_DATA_EVENT_FLUSH, NULL);
 }

 static bool sendLastSampleAls(void *cookie, uint32_t tid)
 {
     bool result = true;

     // If we don't end up doing anything here, the expectation is that we are powering up/haven't got the
     // first sample yet, so a broadcast event will go out soon with the first sample
     if (mData.lastAlsSample.idata != ISL29034_ALS_INVALID)
         result = osEnqueuePrivateEvt(sensorGetMyEventType(SENS_TYPE_ALS), mData.lastAlsSample.vptr, NULL, tid);

     return result;
 }

 static const struct SensorInfo sensorInfoAls =
 {
     .sensorName = "ALS",
     .supportedRates = supportedRates,
     .sensorType = SENS_TYPE_ALS,
     .numAxis = NUM_AXIS_EMBEDDED,
     .interrupt = NANOHUB_INT_NONWAKEUP,
     .minSamples = 20
 };

 static const struct SensorOps sensorOpsAls =
 {
     .sensorPower = sensorPowerAls,
     .sensorFirmwareUpload = sensorFirmwareAls,
     .sensorSetRate = sensorRateAls,
     .sensorFlush = sensorFlushAls,
     .sensorTriggerOndemand = NULL,
     .sensorCalibrate = NULL,
     .sensorSendOneDirectEvt = sendLastSampleAls
 };

 /*
  * Sensor i2c state machine
  */

 static void handle_i2c_event(struct I2cTransfer *xfer)
 {
     union EmbeddedDataPoint sample;
     struct I2cTransfer *nextXfer;

     switch (xfer->state) {
     case SENSOR_STATE_VERIFY_ID:
         /* Check the sensor ID */
         if (xfer->err != 0 ||
             (xfer->txrxBuf[0] & ISL29034_ID_MASK) != ISL29034_ID) {
             INFO_PRINT("not detected\n");
             sensorUnregister(mData.alsHandle);
             break;
         }
         INFO_PRINT("detected\n")

         if (xfer->txrxBuf[0] & ISL29034_ID_BOUT) {
             INFO_PRINT("Brownout Condition\n");
             writeRegister(ISL29034_REG_ID,
                           xfer->txrxBuf[0] ^ ISL29034_ID_BOUT,
                           SENSOR_STATE_CLEAR_BOUT);
             break;
         }
         /* fallthrough */

     case SENSOR_STATE_CLEAR_BOUT:
         nextXfer = allocXfer(SENSOR_STATE_IDLE);
         if (nextXfer != NULL) {
             nextXfer->txrxBuf[0] = ISL29034_REG_CMD_1;
             nextXfer->txrxBuf[1] = ISL29034_CMD1_POWERDOWN;
             nextXfer->txrxBuf[2] = ISL29034_CMD2_RANGE_64KLUX | ISL29034_CMD2_RES_16BIT;
             i2cMasterTx(ISL29034_I2C_BUS_ID, ISL29034_I2C_ADDR, nextXfer->txrxBuf, 3, i2cCallback, nextXfer);
         }
         break;

     case SENSOR_STATE_IDLE:
         sensorRegisterInitComplete(mData.alsHandle);
         break;

     case SENSOR_STATE_ENABLING_ALS:
         sensorSignalInternalEvt(mData.alsHandle, SENSOR_INTERNAL_EVT_POWER_STATE_CHG, true, 0);
         break;

     case SENSOR_STATE_DISABLING_ALS:
         sensorSignalInternalEvt(mData.alsHandle, SENSOR_INTERNAL_EVT_POWER_STATE_CHG, false, 0);
         break;

     case SENSOR_STATE_SAMPLING:
         DEBUG_PRINT("sample ready: als0=%u als1=%u\n", xfer->txrxBuf[0], xfer->txrxBuf[1]);

         if (mData.alsOn && mData.alsReading) {
             /* Create event */
             sample.fdata = getLuxFromAlsData(xfer->txrxBuf[0] | (xfer->txrxBuf[1] << 8));
             if (mData.lastAlsSample.idata != sample.idata) {
                 osEnqueueEvt(sensorGetMyEventType(SENS_TYPE_ALS), sample.vptr, NULL);
                 mData.lastAlsSample.fdata = sample.fdata;
             }
         }

         mData.alsReading = false;
         break;
     }

     xfer->inUse = false;
 }

 /*
  * Main driver entry points
  */

 static bool init_app(uint32_t myTid)
 {
     INFO_PRINT("started\n");

     /* Set up driver private data */
     mData.tid = myTid;
     mData.alsOn = false;
     mData.alsReading = false;
     mData.lastAlsSample.idata = ISL29034_ALS_INVALID;

     i2cMasterRequest(ISL29034_I2C_BUS_ID, ISL29034_I2C_SPEED);

     /* Register sensors */
     mData.alsHandle = sensorRegister(&sensorInfoAls, &sensorOpsAls, NULL, false);

     osEventSubscribe(myTid, EVT_APP_START);

     return true;
 }

 static void end_app(void)
 {
     INFO_PRINT("ended\n");

     sensorUnregister(mData.alsHandle);

     i2cMasterRelease(ISL29034_I2C_BUS_ID);
 }

 static void handle_event(uint32_t evtType, const void* evtData)
 {
     struct I2cTransfer *xfer;

     switch (evtType) {
     case EVT_APP_START:
         osEventUnsubscribe(mData.tid, EVT_APP_START);

         xfer = allocXfer(SENSOR_STATE_VERIFY_ID);
         if (xfer != NULL) {
             xfer->txrxBuf[0] = ISL29034_REG_ID;
             i2cMasterTxRx(ISL29034_I2C_BUS_ID, ISL29034_I2C_ADDR, xfer->txrxBuf, 1, xfer->txrxBuf, 1, i2cCallback, xfer);
         }
         break;

     case EVT_SENSOR_I2C:
         handle_i2c_event((struct I2cTransfer *)evtData);
         break;

     case EVT_SENSOR_ALS_TIMER:
         /* Start sampling for a value */
         if (!mData.alsReading) {
             xfer = allocXfer(SENSOR_STATE_SAMPLING);
             if (xfer != NULL) {
                 xfer->txrxBuf[0] = ISL29034_REG_DATA_L;
                 i2cMasterTxRx(ISL29034_I2C_BUS_ID, ISL29034_I2C_ADDR, xfer->txrxBuf, 1, xfer->txrxBuf, 2, i2cCallback, xfer);
             }
         }

         mData.alsReading = true;
         break;
     }
 }

 INTERNAL_APP_INIT(APP_ID_MAKE(NANOHUB_VENDOR_STMICRO, 4), ISL29034_APP_VERSION, init_app, end_app, handle_event);
	/*
	* Copyright (C) 2017 STMicroelectronics
	* Copyright (C) 2017 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 <seos.h>
	#include <i2c.h>
	#include <timer.h>
	#include <sensors.h>
	#include <heap.h>
	#include <hostIntf.h>
	#include <nanohubPacket.h>
	#include <eventnums.h>
	#include <util.h>
	#include <variant/variant.h>

	#ifdef DEBUG
	#undef ISL29034_DBG_ENABLED
	#define ISL29034_DBG_ENABLED 1
	#endif

	#ifndef ISL29034_DBG_ENABLED
	#define ISL29034_DBG_ENABLED 0
	#endif /* ISL29034_DBG_ENABLED */

	#define ISL29034_APP_VERSION 1

	#define ISL29034_REG_CMD_1 0x00
	#define ISL29034_REG_CMD_2 0x01
	#define ISL29034_REG_DATA_L 0x02
	#define ISL29034_REG_DATA_H 0x03
	#define ISL29034_REG_ID 0x0f

	#define ISL29034_CMD1_POWERDOWN (0 << 5)
	#define ISL29034_CMD1_MEASURE (5 << 5)

	#define ISL29034_CMD2_RANGE_1KLUX 0
	#define ISL29034_CMD2_RANGE_4KLUX 1
	#define ISL29034_CMD2_RANGE_16KLUX 2
	#define ISL29034_CMD2_RANGE_64KLUX 3
	#define ISL29034_CMD2_RES_16BIT (0 << 2)
	#define ISL29034_CMD2_RES_12BIT (1 << 2)
	#define ISL29034_CMD2_RES_8BIT (2 << 2)
	#define ISL29034_CMD2_RES_4BIT (3 << 2)

	#define ISL29034_ID (5 << 3)
	#define ISL29034_ID_MASK (7 << 3)
	#define ISL29034_ID_BOUT (1 << 7)

	#define ISL29034_ALS_INVALID UINT32_MAX
	#define ISL29034_MAX_PENDING_I2C_REQUESTS 4
	#define ISL29034_MAX_I2C_TRANSFER_SIZE 3

	/* Used when SENSOR_RATE_ONCHANGE is requested */
	#define ISL29034_DEFAULT_RATE SENSOR_HZ(10)

	#ifndef ISL29034_I2C_BUS_ID
	#error "ISL29034_I2C_BUS_ID is not defined; please define in variant.h"
	#endif

	#ifndef ISL29034_I2C_SPEED
	#error "ISL29034_I2C_SPEED is not defined; please define in variant.h"
	#endif

	#ifndef ISL29034_I2C_ADDR
	#define ISL29034_I2C_ADDR 0x44
	#endif

	#define INFO_PRINT(fmt, ...) \
	do { \
	osLog(LOG_INFO, "%s " fmt, "[ISL29034]", ##__VA_ARGS__); \
	} while (0);

	#define DEBUG_PRINT(fmt, ...) \
	do { \
	if (ISL29034_DBG_ENABLED) { \
	osLog(LOG_DEBUG, "%s " fmt, "[ISL29034]", ##__VA_ARGS__); \
	} \
	} while (0);

	#define ERROR_PRINT(fmt, ...) \
	do { \
	osLog(LOG_ERROR, "%s " fmt, "[ISL29034]", ##__VA_ARGS__); \
	} while (0);


	/* Private driver events */
	enum SensorEvents
	{
	EVT_SENSOR_I2C = EVT_APP_START + 1,
	EVT_SENSOR_ALS_TIMER,
	};

	/* I2C state machine */
	enum SensorState
	{
	SENSOR_STATE_VERIFY_ID,
	SENSOR_STATE_CLEAR_BOUT,

	SENSOR_STATE_ENABLING_ALS,
	SENSOR_STATE_DISABLING_ALS,

	SENSOR_STATE_IDLE,
	SENSOR_STATE_SAMPLING,
	};

	struct I2cTransfer
	{
	size_t tx;
	size_t rx;
	int err;

	uint8_t txrxBuf[ISL29034_MAX_I2C_TRANSFER_SIZE];

	uint8_t state;
	bool inUse;
	};

	struct SensorData
	{
	uint32_t tid;

	uint32_t alsHandle;
	uint32_t alsTimerHandle;

	struct I2cTransfer transfers[ISL29034_MAX_PENDING_I2C_REQUESTS];

	union EmbeddedDataPoint lastAlsSample;

	bool alsOn;
	bool alsReading;
	};

	static struct SensorData mData;

	static const uint32_t supportedRates[] =
	{
	SENSOR_HZ(10),
	SENSOR_RATE_ONCHANGE,
	0
	};

	// should match "supported rates in length" and be the timer length for that rate in nanosecs
	static const uint64_t rateTimerVals[] =
	{
	1000000000ULL / 10,
	};

	/*
	* Helper functions
	*/

	static void i2cCallback(void *cookie, size_t tx, size_t rx, int err)
	{
	struct I2cTransfer *xfer = cookie;

	xfer->tx = tx;
	xfer->rx = rx;
	xfer->err = err;

	osEnqueuePrivateEvt(EVT_SENSOR_I2C, cookie, NULL, mData.tid);
	if (err != 0)
	INFO_PRINT("i2c error (tx: %d, rx: %d, err: %d)\n", tx, rx, err);
	}

	// Allocate a buffer and mark it as in use with the given state, or return NULL
	// if no buffers available. Must not be called from interrupt context.
	static struct I2cTransfer *allocXfer(uint8_t state)
	{
	size_t i;

	for (i = 0; i < ARRAY_SIZE(mData.transfers); i++) {
	if (!mData.transfers[i].inUse) {
	mData.transfers[i].inUse = true;
	mData.transfers[i].state = state;
	return &mData.transfers[i];
	}
	}

	ERROR_PRINT("Ran out of i2c buffers!");
	return NULL;
	}

	// Helper function to write a one byte register. Returns true if we got a
	// successful return value from i2cMasterTx().
	static bool writeRegister(uint8_t reg, uint8_t value, uint8_t state)
	{
	struct I2cTransfer *xfer = allocXfer(state);
	int ret = -1;

	if (xfer != NULL) {
	xfer->txrxBuf[0] = reg;
	xfer->txrxBuf[1] = value;
	ret = i2cMasterTx(ISL29034_I2C_BUS_ID, ISL29034_I2C_ADDR, xfer->txrxBuf, 2, i2cCallback, xfer);
	}

	return (ret == 0);
	}

	static void alsTimerCallback(uint32_t timerId, void *cookie)
	{
	osEnqueuePrivateEvt(EVT_SENSOR_ALS_TIMER, cookie, NULL, mData.tid);
	}

	static inline float getLuxFromAlsData(uint16_t als)
	{
	float range = 64000.0;
	float resolution = 65536.0;

	return range * als / resolution;
	}

	static bool sensorPowerAls(bool on, void *cookie)
	{
	INFO_PRINT("sensorPowerAls: %d\n", on);

	if (mData.alsTimerHandle) {
	timTimerCancel(mData.alsTimerHandle);
	mData.alsTimerHandle = 0;
	mData.alsReading = false;
	}

	mData.lastAlsSample.idata = ISL29034_ALS_INVALID;
	mData.alsOn = on;

	writeRegister(ISL29034_REG_CMD_1,
	on ? ISL29034_CMD1_MEASURE : ISL29034_CMD1_POWERDOWN,
	on ? SENSOR_STATE_ENABLING_ALS : SENSOR_STATE_DISABLING_ALS);

	return true;
	}

	static bool sensorFirmwareAls(void *cookie)
	{
	sensorSignalInternalEvt(mData.alsHandle, SENSOR_INTERNAL_EVT_FW_STATE_CHG, 1, 0);
	return true;
	}

	static bool sensorRateAls(uint32_t rate, uint64_t latency, void *cookie)
	{
	if (rate == SENSOR_RATE_ONCHANGE)
	rate = ISL29034_DEFAULT_RATE;

	INFO_PRINT("sensorRateAls: %ld/%lld\n", rate, latency);

	if (mData.alsTimerHandle)
	timTimerCancel(mData.alsTimerHandle);
	mData.alsTimerHandle = timTimerSet(sensorTimerLookupCommon(supportedRates, rateTimerVals, rate), 0, 50, alsTimerCallback, NULL, false);
	osEnqueuePrivateEvt(EVT_SENSOR_ALS_TIMER, NULL, NULL, mData.tid);
	sensorSignalInternalEvt(mData.alsHandle, SENSOR_INTERNAL_EVT_RATE_CHG, rate, latency);

	return true;
	}

	static bool sensorFlushAls(void *cookie)
	{
	return osEnqueueEvt(sensorGetMyEventType(SENS_TYPE_ALS), SENSOR_DATA_EVENT_FLUSH, NULL);
	}

	static bool sendLastSampleAls(void *cookie, uint32_t tid)
	{
	bool result = true;

	// If we don't end up doing anything here, the expectation is that we are powering up/haven't got the
	// first sample yet, so a broadcast event will go out soon with the first sample
	if (mData.lastAlsSample.idata != ISL29034_ALS_INVALID)
	result = osEnqueuePrivateEvt(sensorGetMyEventType(SENS_TYPE_ALS), mData.lastAlsSample.vptr, NULL, tid);

	return result;
	}

	static const struct SensorInfo sensorInfoAls =
	{
	.sensorName = "ALS",
	.supportedRates = supportedRates,
	.sensorType = SENS_TYPE_ALS,
	.numAxis = NUM_AXIS_EMBEDDED,
	.interrupt = NANOHUB_INT_NONWAKEUP,
	.minSamples = 20
	};

	static const struct SensorOps sensorOpsAls =
	{
	.sensorPower = sensorPowerAls,
	.sensorFirmwareUpload = sensorFirmwareAls,
	.sensorSetRate = sensorRateAls,
	.sensorFlush = sensorFlushAls,
	.sensorTriggerOndemand = NULL,
	.sensorCalibrate = NULL,
	.sensorSendOneDirectEvt = sendLastSampleAls
	};

	/*
	* Sensor i2c state machine
	*/

	static void handle_i2c_event(struct I2cTransfer *xfer)
	{
	union EmbeddedDataPoint sample;
	struct I2cTransfer *nextXfer;

	switch (xfer->state) {
	case SENSOR_STATE_VERIFY_ID:
	/* Check the sensor ID */
	if (xfer->err != 0 \|\|
	(xfer->txrxBuf[0] & ISL29034_ID_MASK) != ISL29034_ID) {
	INFO_PRINT("not detected\n");
	sensorUnregister(mData.alsHandle);
	break;
	}
	INFO_PRINT("detected\n")

	if (xfer->txrxBuf[0] & ISL29034_ID_BOUT) {
	INFO_PRINT("Brownout Condition\n");
	writeRegister(ISL29034_REG_ID,
	xfer->txrxBuf[0] ^ ISL29034_ID_BOUT,
	SENSOR_STATE_CLEAR_BOUT);
	break;
	}
	/* fallthrough */

	case SENSOR_STATE_CLEAR_BOUT:
	nextXfer = allocXfer(SENSOR_STATE_IDLE);
	if (nextXfer != NULL) {
	nextXfer->txrxBuf[0] = ISL29034_REG_CMD_1;
	nextXfer->txrxBuf[1] = ISL29034_CMD1_POWERDOWN;
	nextXfer->txrxBuf[2] = ISL29034_CMD2_RANGE_64KLUX \| ISL29034_CMD2_RES_16BIT;
	i2cMasterTx(ISL29034_I2C_BUS_ID, ISL29034_I2C_ADDR, nextXfer->txrxBuf, 3, i2cCallback, nextXfer);
	}
	break;

	case SENSOR_STATE_IDLE:
	sensorRegisterInitComplete(mData.alsHandle);
	break;

	case SENSOR_STATE_ENABLING_ALS:
	sensorSignalInternalEvt(mData.alsHandle, SENSOR_INTERNAL_EVT_POWER_STATE_CHG, true, 0);
	break;

	case SENSOR_STATE_DISABLING_ALS:
	sensorSignalInternalEvt(mData.alsHandle, SENSOR_INTERNAL_EVT_POWER_STATE_CHG, false, 0);
	break;

	case SENSOR_STATE_SAMPLING:
	DEBUG_PRINT("sample ready: als0=%u als1=%u\n", xfer->txrxBuf[0], xfer->txrxBuf[1]);

	if (mData.alsOn && mData.alsReading) {
	/* Create event */
	sample.fdata = getLuxFromAlsData(xfer->txrxBuf[0] \| (xfer->txrxBuf[1] << 8));
	if (mData.lastAlsSample.idata != sample.idata) {
	osEnqueueEvt(sensorGetMyEventType(SENS_TYPE_ALS), sample.vptr, NULL);
	mData.lastAlsSample.fdata = sample.fdata;
	}
	}

	mData.alsReading = false;
	break;
	}

	xfer->inUse = false;
	}

	/*
	* Main driver entry points
	*/

	static bool init_app(uint32_t myTid)
	{
	INFO_PRINT("started\n");

	/* Set up driver private data */
	mData.tid = myTid;
	mData.alsOn = false;
	mData.alsReading = false;
	mData.lastAlsSample.idata = ISL29034_ALS_INVALID;

	i2cMasterRequest(ISL29034_I2C_BUS_ID, ISL29034_I2C_SPEED);

	/* Register sensors */
	mData.alsHandle = sensorRegister(&sensorInfoAls, &sensorOpsAls, NULL, false);

	osEventSubscribe(myTid, EVT_APP_START);

	return true;
	}

	static void end_app(void)
	{
	INFO_PRINT("ended\n");

	sensorUnregister(mData.alsHandle);

	i2cMasterRelease(ISL29034_I2C_BUS_ID);
	}

	static void handle_event(uint32_t evtType, const void* evtData)
	{
	struct I2cTransfer *xfer;

	switch (evtType) {
	case EVT_APP_START:
	osEventUnsubscribe(mData.tid, EVT_APP_START);

	xfer = allocXfer(SENSOR_STATE_VERIFY_ID);
	if (xfer != NULL) {
	xfer->txrxBuf[0] = ISL29034_REG_ID;
	i2cMasterTxRx(ISL29034_I2C_BUS_ID, ISL29034_I2C_ADDR, xfer->txrxBuf, 1, xfer->txrxBuf, 1, i2cCallback, xfer);
	}
	break;

	case EVT_SENSOR_I2C:
	handle_i2c_event((struct I2cTransfer *)evtData);
	break;

	case EVT_SENSOR_ALS_TIMER:
	/* Start sampling for a value */
	if (!mData.alsReading) {
	xfer = allocXfer(SENSOR_STATE_SAMPLING);
	if (xfer != NULL) {
	xfer->txrxBuf[0] = ISL29034_REG_DATA_L;
	i2cMasterTxRx(ISL29034_I2C_BUS_ID, ISL29034_I2C_ADDR, xfer->txrxBuf, 1, xfer->txrxBuf, 2, i2cCallback, xfer);
	}
	}

	mData.alsReading = true;
	break;
	}
	}

	INTERNAL_APP_INIT(APP_ID_MAKE(NANOHUB_VENDOR_STMICRO, 4), ISL29034_APP_VERSION, init_app, end_app, handle_event);