--- /dev/null
+/* Driver for the TSL2550 Ambient Light Sensor */
+
+#include <minix/ds.h>
+#include <minix/drivers.h>
+#include <minix/i2c.h>
+#include <minix/i2cdriver.h>
+#include <minix/chardriver.h>
+#include <minix/log.h>
+#include <minix/type.h>
+#include <minix/spin.h>
+
+/*
+ * Device Commands
+ */
+#define CMD_PWR_DOWN 0x00
+#define CMD_PWR_UP 0x03
+#define CMD_EXT_RANGE 0x1d
+#define CMD_NORM_RANGE 0x18
+#define CMD_READ_ADC0 0x43
+#define CMD_READ_ADC1 0x83
+
+/* When powered up and communicating, the register should have this value */
+#define EXPECTED_PWR_UP_TEST_VAL 0x03
+
+/* Maximum Lux value in Standard Mode */
+#define MAX_LUX_STD_MODE 1846
+
+/* Bit Masks for ADC Data */
+#define ADC_VALID_MASK (1<<7)
+#define ADC_CHORD_MASK ((1<<6)|(1<<5)|(1<<4))
+#define ADC_STEP_MASK ((1<<3)|(1<<2)|(1<<1)|(1<<0))
+
+#define ADC_VAL_IS_VALID(x) ((x & ADC_VALID_MASK) == ADC_VALID_MASK)
+#define ADC_VAL_TO_CHORD_BITS(x) ((x & ADC_CHORD_MASK) >> 4)
+#define ADC_VAL_TO_STEP_BITS(x) (x & ADC_STEP_MASK)
+
+/* logging - use with log_warn(), log_info(), log_debug(), log_trace(), etc */
+static struct log log = {
+ .name = "tsl2550",
+ .log_level = LEVEL_INFO,
+ .log_func = default_log
+};
+
+/* The slave address is hardwired to 0x39 and cannot be changed. */
+static i2c_addr_t valid_addrs[2] = {
+ 0x39, 0x00
+};
+
+/* Buffer to store output string returned when reading from device file. */
+#define BUFFER_LEN 32
+char buffer[BUFFER_LEN + 1];
+
+/* the bus that this device is on (counting starting at 1) */
+static uint32_t bus;
+
+/* slave address of the device */
+static i2c_addr_t address;
+
+/* endpoint for the driver for the bus itself. */
+static endpoint_t bus_endpoint;
+
+/* register access functions */
+static int reg_read(uint8_t * val);
+static int reg_write(uint8_t val);
+
+/* main driver functions */
+static int tsl2550_init(void);
+static int adc_read(int adc, uint8_t * val);
+static int measure_lux(uint32_t * lux);
+
+/* libchardriver callbacks */
+static struct device *tsl2550_prepare(dev_t UNUSED(dev));
+static int tsl2550_transfer(endpoint_t endpt, int opcode, u64_t position,
+ iovec_t * iov, unsigned nr_req, endpoint_t UNUSED(user_endpt),
+ unsigned int UNUSED(flags));
+static int tsl2550_other(message * m);
+
+/* SEF functions */
+static int sef_cb_lu_state_save(int);
+static int lu_state_restore(void);
+static int sef_cb_init(int type, sef_init_info_t * info);
+static void sef_local_startup(void);
+
+/* Entry points to this driver from libchardriver. */
+static struct chardriver tsl2550_tab = {
+ .cdr_open = do_nop,
+ .cdr_close = do_nop,
+ .cdr_ioctl = nop_ioctl,
+ .cdr_prepare = tsl2550_prepare,
+ .cdr_transfer = tsl2550_transfer,
+ .cdr_cleanup = nop_cleanup,
+ .cdr_alarm = nop_alarm,
+ .cdr_cancel = nop_cancel,
+ .cdr_select = nop_select,
+ .cdr_other = tsl2550_other
+};
+
+static struct device tsl2550_device = {
+ .dv_base = 0,
+ .dv_size = 0
+};
+
+/*
+ * These two lookup tables and the formulas used in measure_lux() are from
+ * 'TAOS INTELLIGENT OPTO SENSOR DESIGNER'S NOTEBOOK' Number 9
+ * 'Simplified TSL2550 Lux Calculation for Embedded and Micro Controllers'.
+ *
+ * The tables and formulas eliminate the need for floating point math and
+ * functions from libm. It also speeds up the calculations.
+ */
+
+/* Look up table for converting ADC values to ADC counts */
+static const uint32_t adc_counts_lut[128] = {
+ 0, 1, 2, 3, 4, 5, 6, 7,
+ 8, 9, 10, 11, 12, 13, 14, 15,
+ 16, 18, 20, 22, 24, 26, 28, 30,
+ 32, 34, 36, 38, 40, 42, 44, 46,
+ 49, 53, 57, 61, 65, 69, 73, 77,
+ 81, 85, 89, 93, 97, 101, 105, 109,
+ 115, 123, 131, 139, 147, 155, 163, 171,
+ 179, 187, 195, 203, 211, 219, 227, 235,
+ 247, 263, 279, 295, 311, 327, 343, 359,
+ 375, 391, 407, 423, 439, 455, 471, 487,
+ 511, 543, 575, 607, 639, 671, 703, 735,
+ 767, 799, 831, 863, 895, 927, 959, 991,
+ 1039, 1103, 1167, 1231, 1295, 1359, 1423, 1487,
+ 1551, 1615, 1679, 1743, 1807, 1871, 1935, 1999,
+ 2095, 2223, 2351, 2479, 2607, 2735, 2863, 2991,
+ 3119, 3247, 3375, 3503, 3631, 3759, 3887, 4015
+};
+
+/* Look up table of scaling factors */
+static const uint32_t ratio_lut[129] = {
+ 100, 100, 100, 100, 100, 100, 100, 100,
+ 100, 100, 100, 100, 100, 100, 99, 99,
+ 99, 99, 99, 99, 99, 99, 99, 99,
+ 99, 99, 99, 98, 98, 98, 98, 98,
+ 98, 98, 97, 97, 97, 97, 97, 96,
+ 96, 96, 96, 95, 95, 95, 94, 94,
+ 93, 93, 93, 92, 92, 91, 91, 90,
+ 89, 89, 88, 87, 87, 86, 85, 84,
+ 83, 82, 81, 80, 79, 78, 77, 75,
+ 74, 73, 71, 69, 68, 66, 64, 62,
+ 60, 58, 56, 54, 52, 49, 47, 44,
+ 42, 41, 40, 40, 39, 39, 38, 38,
+ 37, 37, 37, 36, 36, 36, 35, 35,
+ 35, 35, 34, 34, 34, 34, 33, 33,
+ 33, 33, 32, 32, 32, 32, 32, 31,
+ 31, 31, 31, 31, 30, 30, 30, 30,
+ 30
+};
+
+static int
+measure_lux(uint32_t * lux)
+{
+ int r;
+ uint8_t adc0_val, adc1_val;
+ uint32_t adc0_cnt, adc1_cnt;
+ uint32_t ratio;
+
+ r = adc_read(0, &adc0_val);
+ if (r != OK) {
+ return -1;
+ }
+
+ r = adc_read(1, &adc1_val);
+ if (r != OK) {
+ return -1;
+ }
+
+ /* Look up the adc count, drop the MSB to put in range 0-127. */
+ adc0_cnt = adc_counts_lut[adc0_val & ~ADC_VALID_MASK];
+ adc1_cnt = adc_counts_lut[adc1_val & ~ADC_VALID_MASK];
+
+ /* default scaling factor */
+ ratio = 128;
+
+ /* calculate ratio - avoid div by 0, ensure cnt1 <= cnt0 */
+ if ((adc0_cnt != 0) && (adc1_cnt <= adc0_cnt)) {
+ ratio = (adc1_cnt * 128 / adc0_cnt);
+ }
+
+ /* ensure ratio isn't outside ratio_lut[] */
+ if (ratio > 128) {
+ ratio = 128;
+ }
+
+ /* calculate lux */
+ *lux = ((adc0_cnt - adc1_cnt) * ratio_lut[ratio]) / 256;
+
+ /* range check */
+ if (*lux > MAX_LUX_STD_MODE) {
+ *lux = MAX_LUX_STD_MODE;
+ }
+
+ return OK;
+}
+
+static int
+adc_read(int adc, uint8_t * val)
+{
+ int r;
+ spin_t spin;
+
+ if (adc != 0 && adc != 1) {
+ log_warn(&log, "Invalid ADC number %d, expected 0 or 1.\n",
+ adc);
+ return EINVAL;
+ }
+
+ if (val == NULL) {
+ log_warn(&log, "Read called with a NULL pointer.\n");
+ return EINVAL;
+ }
+
+ *val = (adc == 0) ? CMD_READ_ADC0 : CMD_READ_ADC1;
+
+ /* Select the ADC to read from */
+ r = reg_write(*val);
+ if (r != OK) {
+ log_warn(&log, "Failed to write ADC read command.\n");
+ return -1;
+ }
+
+ *val = 0;
+
+ /* Repeatedly read until the value is valid (i.e. the conversion
+ * finishes). Depending on the timing, the data sheet says this
+ * could take up to 400ms.
+ */
+ spin_init(&spin, 400000);
+ do {
+ r = reg_read(val);
+ if (r != OK) {
+ log_warn(&log, "Failed to read ADC%d value.\n", adc);
+ return -1;
+ }
+
+ if (ADC_VAL_IS_VALID(*val)) {
+ return OK;
+ }
+ } while (spin_check(&spin));
+
+ /* Final read attempt. If the bus was really busy with other requests
+ * and the timing of things happened in the worst possible case,
+ * there is a chance that the loop above only did 1 read (slightly
+ * before 400 ms) and left the loop. To ensure there is a final read
+ * at or after the 400 ms mark, we try one last time here.
+ */
+ r = reg_read(val);
+ if (r != OK) {
+ log_warn(&log, "Failed to read ADC%d value.\n", adc);
+ return -1;
+ }
+
+ if (ADC_VAL_IS_VALID(*val)) {
+ return OK;
+ } else {
+ log_warn(&log, "ADC%d never returned a valid result.\n", adc);
+ return EIO;
+ }
+}
+
+static int
+reg_read(uint8_t * val)
+{
+ int r;
+ minix_i2c_ioctl_exec_t ioctl_exec;
+
+ if (val == NULL) {
+ log_warn(&log, "Read called with a NULL pointer.\n");
+ return EINVAL;
+ }
+
+ memset(&ioctl_exec, '\0', sizeof(minix_i2c_ioctl_exec_t));
+
+ /* Read from chip */
+ ioctl_exec.iie_op = I2C_OP_READ_WITH_STOP;
+ ioctl_exec.iie_addr = address;
+
+ /* No register address to write */
+ ioctl_exec.iie_cmdlen = 0;
+
+ /* Read one byte */
+ ioctl_exec.iie_buflen = 1;
+
+ r = i2cdriver_exec(bus_endpoint, &ioctl_exec);
+ if (r != OK) {
+ log_warn(&log, "reg_read() failed (r=%d)\n", r);
+ return -1;
+ }
+
+ *val = ioctl_exec.iie_buf[0];
+
+ log_trace(&log, "Read 0x%x from reg\n", *val);
+
+ return OK;
+}
+
+static int
+reg_write(uint8_t val)
+{
+ int r;
+ minix_i2c_ioctl_exec_t ioctl_exec;
+
+ switch (val) {
+ case CMD_PWR_DOWN:
+ case CMD_PWR_UP:
+ case CMD_EXT_RANGE:
+ case CMD_NORM_RANGE:
+ case CMD_READ_ADC0:
+ case CMD_READ_ADC1:
+ /* Command is valid */
+ break;
+ default:
+ log_warn(&log,
+ "reg_write() called with invalid command 0x%x\n", val);
+ return EINVAL;
+ }
+
+ memset(&ioctl_exec, '\0', sizeof(minix_i2c_ioctl_exec_t));
+
+ /* Write to chip */
+ ioctl_exec.iie_op = I2C_OP_WRITE_WITH_STOP;
+ ioctl_exec.iie_addr = address;
+
+ /* No command bytes for writing to this chip */
+ ioctl_exec.iie_cmdlen = 0;
+
+ /* Set the byte to write */
+ ioctl_exec.iie_buf[0] = val;
+ ioctl_exec.iie_buflen = 1;
+
+ r = i2cdriver_exec(bus_endpoint, &ioctl_exec);
+ if (r != OK) {
+ log_warn(&log, "reg_write() failed (r=%d)\n", r);
+ return -1;
+ }
+
+ log_trace(&log, "Wrote 0x%x to reg\n", val);
+
+ return OK;
+}
+
+static int
+tsl2550_init(void)
+{
+ int r;
+ uint8_t val;
+
+ /* Power on the device */
+ r = reg_write(CMD_PWR_UP);
+ if (r != OK) {
+ log_warn(&log, "Power-up command failed.\n");
+ return -1;
+ }
+
+ /* Read power on test value */
+ r = reg_read(&val);
+ if (r != OK) {
+ log_warn(&log, "Failed to read power on test value.\n");
+ return -1;
+ }
+
+ /* Check power on test value */
+ if (val != EXPECTED_PWR_UP_TEST_VAL) {
+ log_warn(&log, "Bad test value. Got 0x%x, expected 0x%x\n",
+ val, EXPECTED_PWR_UP_TEST_VAL);
+ return -1;
+ }
+
+ /* Set range to normal */
+ r = reg_write(CMD_NORM_RANGE);
+ if (r != OK) {
+ log_warn(&log, "Normal range command failed.\n");
+ return -1;
+ }
+
+ return OK;
+}
+
+static struct device *
+tsl2550_prepare(dev_t UNUSED(dev))
+{
+ return &tsl2550_device;
+}
+
+static int
+tsl2550_transfer(endpoint_t endpt, int opcode, u64_t position,
+ iovec_t * iov, unsigned nr_req, endpoint_t UNUSED(user_endpt),
+ unsigned int UNUSED(flags))
+{
+ int bytes, r;
+ uint32_t lux;
+
+ r = measure_lux(&lux);
+ if (r != OK) {
+ return EIO;
+ }
+
+ memset(buffer, '\0', BUFFER_LEN + 1);
+ snprintf(buffer, BUFFER_LEN, "%-16s: %d\n", "ILLUMINANCE", lux);
+
+ bytes = strlen(buffer) - position < iov->iov_size ?
+ strlen(buffer) - position : iov->iov_size;
+
+ if (bytes <= 0) {
+ return OK;
+ }
+
+ switch (opcode) {
+ case DEV_GATHER_S:
+ r = sys_safecopyto(endpt, (cp_grant_id_t) iov->iov_addr, 0,
+ (vir_bytes) (buffer + position), bytes);
+ iov->iov_size -= bytes;
+ break;
+ default:
+ return EINVAL;
+ }
+
+ return r;
+}
+
+static int
+tsl2550_other(message * m)
+{
+ int r;
+
+ switch (m->m_type) {
+ case NOTIFY_MESSAGE:
+ if (m->m_source == DS_PROC_NR) {
+ log_debug(&log,
+ "bus driver changed state, update endpoint\n");
+ i2cdriver_handle_bus_update(&bus_endpoint, bus,
+ address);
+ }
+ r = OK;
+ break;
+ default:
+ log_warn(&log, "Invalid message type (0x%x)\n", m->m_type);
+ r = EINVAL;
+ break;
+ }
+
+ return r;
+}
+
+static int
+sef_cb_lu_state_save(int UNUSED(state))
+{
+ ds_publish_u32("bus", bus, DSF_OVERWRITE);
+ ds_publish_u32("address", address, DSF_OVERWRITE);
+ return OK;
+}
+
+static int
+lu_state_restore(void)
+{
+ /* Restore the state. */
+ u32_t value;
+
+ ds_retrieve_u32("bus", &value);
+ ds_delete_u32("bus");
+ bus = (int) value;
+
+ ds_retrieve_u32("address", &value);
+ ds_delete_u32("address");
+ address = (int) value;
+
+ return OK;
+}
+
+static int
+sef_cb_init(int type, sef_init_info_t * UNUSED(info))
+{
+ int r;
+
+ if (type == SEF_INIT_LU) {
+ /* Restore the state. */
+ lu_state_restore();
+ }
+
+ /* look-up the endpoint for the bus driver */
+ bus_endpoint = i2cdriver_bus_endpoint(bus);
+ if (bus_endpoint == 0) {
+ log_warn(&log, "Couldn't find bus driver.\n");
+ return EXIT_FAILURE;
+ }
+
+ /* claim the device */
+ r = i2cdriver_reserve_device(bus_endpoint, address);
+ if (r != OK) {
+ log_warn(&log, "Couldn't reserve device 0x%x (r=%d)\n",
+ address, r);
+ return EXIT_FAILURE;
+ }
+
+ r = tsl2550_init();
+ if (r != OK) {
+ log_warn(&log, "Device Init Failed\n");
+ return EXIT_FAILURE;
+ }
+
+ if (type != SEF_INIT_LU) {
+
+ /* sign up for updates about the i2c bus going down/up */
+ r = i2cdriver_subscribe_bus_updates(bus);
+ if (r != OK) {
+ log_warn(&log, "Couldn't subscribe to bus updates\n");
+ return EXIT_FAILURE;
+ }
+
+ i2cdriver_announce(bus);
+ log_debug(&log, "announced\n");
+ }
+
+ return OK;
+}
+
+static void
+sef_local_startup(void)
+{
+ /*
+ * Register init callbacks. Use the same function for all event types
+ */
+ sef_setcb_init_fresh(sef_cb_init);
+ sef_setcb_init_lu(sef_cb_init);
+ sef_setcb_init_restart(sef_cb_init);
+
+ /*
+ * Register live update callbacks.
+ */
+ /* Agree to update immediately when LU is requested in a valid state. */
+ sef_setcb_lu_prepare(sef_cb_lu_prepare_always_ready);
+ /* Support live update starting from any standard state. */
+ sef_setcb_lu_state_isvalid(sef_cb_lu_state_isvalid_standard);
+ /* Register a custom routine to save the state. */
+ sef_setcb_lu_state_save(sef_cb_lu_state_save);
+
+ /* Let SEF perform startup. */
+ sef_startup();
+}
+
+int
+main(int argc, char *argv[])
+{
+ int r;
+
+ env_setargs(argc, argv);
+
+ r = i2cdriver_env_parse(&bus, &address, valid_addrs);
+ if (r < 0) {
+ log_warn(&log, "Expecting -args 'bus=X address=0xYY'\n");
+ log_warn(&log, "Example -args 'bus=1 address=0x39'\n");
+ return EXIT_FAILURE;
+ } else if (r > 0) {
+ log_warn(&log,
+ "Invalid slave address for device, expecting 0x39\n");
+ return EXIT_FAILURE;
+ }
+
+ sef_local_startup();
+
+ chardriver_task(&tsl2550_tab, CHARDRIVER_SYNC);
+
+ return 0;
+}
