Remove building with NOCRYPTO option

[minix3.git] / minix / drivers / bus / i2c / i2c.c

/*
 * i2c - generic driver for Inter-Integrated Circuit bus (I2C).
 */

/* kernel headers */
#include <minix/chardriver.h>
#include <minix/drivers.h>
#include <minix/ds.h>
#include <minix/i2c.h>
#include <minix/log.h>
#include <minix/type.h>
#include <minix/board.h>

/* system headers */
#include <sys/mman.h>

/* usr headers */
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

/* SoC specific headers - 1 for each SoC */
#include "omap_i2c.h"

/* local definitions */

/* i2c slave addresses can be up to 10 bits */
#define NR_I2CDEV (0x3ff)

/* local function prototypes */
static int do_reserve(endpoint_t endpt, int slave_addr);
static int check_reservation(endpoint_t endpt, int slave_addr);
static void update_reservation(endpoint_t endpt, char *key);
static void ds_event(void);

static int validate_ioctl_exec(minix_i2c_ioctl_exec_t * ioctl_exec);
static int do_i2c_ioctl_exec(endpoint_t caller, cp_grant_id_t grant_nr);

static int env_parse_instance(void);

/* libchardriver callbacks */
static int i2c_ioctl(devminor_t minor, unsigned long request, endpoint_t endpt,
        cp_grant_id_t grant, int flags, endpoint_t user_endpt, cdev_id_t id);
static void i2c_other(message * m, int ipc_status);

/* Globals  */

/* the bus that this instance of the driver is responsible for */
uint32_t i2c_bus_id;

/* Table of i2c device reservations. */
static struct i2cdev
{
        uint8_t inuse;
        endpoint_t endpt;
        char key[DS_MAX_KEYLEN];
} i2cdev[NR_I2CDEV];

/* Process a request for an i2c operation.
 * This is the interface that all hardware specific code must implement.
 */
int (*process) (minix_i2c_ioctl_exec_t * ioctl_exec);

/* logging - use with log_warn(), log_info(), log_debug(), log_trace() */
static struct log log = {
        .name = "i2c",
        .log_level = LEVEL_INFO,
        .log_func = default_log
};

/* Entry points to the i2c driver from libchardriver.
 * Only i2c_ioctl() and i2c_other() are implemented. The rest are no-op.
 */
static struct chardriver i2c_tab = {
        .cdr_ioctl      = i2c_ioctl,
        .cdr_other      = i2c_other
};

static int
sef_cb_lu_state_save(int UNUSED(result), int UNUSED(flags))
{
        int r;
        char key[DS_MAX_KEYLEN];

        memset(key, '\0', DS_MAX_KEYLEN);
        snprintf(key, DS_MAX_KEYLEN, "i2c.%d.i2cdev", i2c_bus_id + 1);
        r = ds_publish_mem(key, i2cdev, sizeof(i2cdev), DSF_OVERWRITE);
        if (r != OK) {
                log_warn(&log, "ds_publish_mem(%s) failed (r=%d)\n", key, r);
                return r;
        }

        log_debug(&log, "State Saved\n");

        return OK;
}

/*
 * Claim an unclaimed device for exclusive use by endpt. This function can
 * also be used to update the endpt if the endpt's label matches the label
 * already associated with the slave address. This is useful if a driver
 * shuts down unexpectedly and starts up with a new endpt and wants to reserve
 * the same device it reserved before.
 */
static int
do_reserve(endpoint_t endpt, int slave_addr)
{
        int r;
        char key[DS_MAX_KEYLEN];
        char label[DS_MAX_KEYLEN];

        /* find the label for the endpoint */
        r = ds_retrieve_label_name(label, endpt);
        if (r != OK) {
                log_warn(&log, "Couldn't find label for endpt='0x%x'\n",
                    endpt);
                return r;
        }

        /* construct the key i2cdriver_announce published (saves an IPC call) */
        snprintf(key, DS_MAX_KEYLEN, "drv.i2c.%d.%s", i2c_bus_id + 1, label);

        if (slave_addr < 0 || slave_addr >= NR_I2CDEV) {
                log_debug(&log,
                    "slave address must be positive & no more than 10 bits\n");
                return EINVAL;
        }

        /* check if device is in use by another driver */
        if (i2cdev[slave_addr].inuse != 0
            && strncmp(i2cdev[slave_addr].key, key, DS_MAX_KEYLEN) != 0) {
                log_debug(&log, "address in use by '%s'/0x%x\n",
                    i2cdev[slave_addr].key, i2cdev[slave_addr].endpt);
                return EBUSY;
        }

        /* device is free or already owned by us, claim it */
        i2cdev[slave_addr].inuse = 1;
        i2cdev[slave_addr].endpt = endpt;
        memcpy(i2cdev[slave_addr].key, key, DS_MAX_KEYLEN);

        sef_cb_lu_state_save(0, 0);     /* save reservations */

        log_debug(&log, "Device 0x%x claimed by 0x%x key='%s'\n",
            slave_addr, endpt, key);

        return OK;
}

/*
 * All drivers must reserve their device(s) before doing operations on them
 * (read/write, etc). ioctl()'s from VFS (i.e. user programs) can only use
 * devices that haven't been reserved. A driver isn't allowed to access a
 * device that another driver has reserved (not even other instances of the
 * same driver).
 */
static int
check_reservation(endpoint_t endpt, int slave_addr)
{
        if (slave_addr < 0 || slave_addr >= NR_I2CDEV) {
                log_debug(&log,
                    "slave address must be positive & no more than 10 bits\n");
                return EINVAL;
        }

        if (endpt == VFS_PROC_NR && i2cdev[slave_addr].inuse == 0) {
                log_debug(&log,
                    "allowing ioctl() from VFS to access unclaimed device\n");
                return OK;
        }

        if (i2cdev[slave_addr].inuse && i2cdev[slave_addr].endpt != endpt) {
                log_debug(&log, "device reserved by another endpoint\n");
                return EBUSY;
        } else if (i2cdev[slave_addr].inuse == 0) {
                log_debug(&log,
                    "all drivers sending messages directly to this driver must reserve\n");
                return EPERM;
        } else {
                log_debug(&log, "allowing access to registered device\n");
                return OK;
        }
}

/*
 * i2c listens to updates from ds about i2c device drivers starting up.
 * When a driver comes back up with the same label, the endpt associated
 * with the reservation needs to be updated. This function does the updating.
 */
static void
update_reservation(endpoint_t endpt, char *key)
{
        int i;

        log_debug(&log, "Updating reservation for '%s' endpt=0x%x\n", key,
            endpt);

        for (i = 0; i < NR_I2CDEV; i++) {

                /* find devices in use that the driver owns */
                if (i2cdev[i].inuse != 0
                    && strncmp(i2cdev[i].key, key, DS_MAX_KEYLEN) == 0) {
                        /* update reservation with new endpoint */
                        do_reserve(endpt, i);
                        log_debug(&log, "Found device to update 0x%x\n", i);
                }
        }
}

/*
 * Checks a minix_i2c_ioctl_exec_t to see if the fields make sense.
 */
static int
validate_ioctl_exec(minix_i2c_ioctl_exec_t * ioctl_exec)
{
        i2c_op_t op;
        i2c_addr_t addr;
        size_t len;

        op = ioctl_exec->iie_op;
        if (op != I2C_OP_READ &&
            op != I2C_OP_READ_WITH_STOP &&
            op != I2C_OP_WRITE &&
            op != I2C_OP_WRITE_WITH_STOP &&
            op != I2C_OP_READ_BLOCK && op != I2C_OP_WRITE_BLOCK) {
                log_warn(&log, "iie_op value not valid\n");
                return EINVAL;
        }

        addr = ioctl_exec->iie_addr;
        if (addr < 0 || addr >= NR_I2CDEV) {
                log_warn(&log, "iie_addr out of range 0x0-0x%x\n", NR_I2CDEV);
                return EINVAL;
        }

        len = ioctl_exec->iie_cmdlen;
        if (len > I2C_EXEC_MAX_CMDLEN) {
                log_warn(&log,
                    "iie_cmdlen out of range 0-I2C_EXEC_MAX_CMDLEN\n");
                return EINVAL;
        }

        len = ioctl_exec->iie_buflen;
        if (len > I2C_EXEC_MAX_BUFLEN) {
                log_warn(&log,
                    "iie_buflen out of range 0-I2C_EXEC_MAX_BUFLEN\n");
                return EINVAL;
        }

        return OK;
}

/*
 * Performs the action in minix_i2c_ioctl_exec_t.
 */
static int
do_i2c_ioctl_exec(endpoint_t caller, cp_grant_id_t grant_nr)
{
        int r;
        minix_i2c_ioctl_exec_t ioctl_exec;

        /* Copy the requested exection into the driver */
        r = sys_safecopyfrom(caller, grant_nr, (vir_bytes) 0,
            (vir_bytes) & ioctl_exec, sizeof(ioctl_exec));
        if (r != OK) {
                log_warn(&log, "sys_safecopyfrom() failed\n");
                return r;
        }

        /* input validation */
        r = validate_ioctl_exec(&ioctl_exec);
        if (r != OK) {
                log_debug(&log, "Message validation failed\n");
                return r;
        }

        /* permission check */
        r = check_reservation(caller, ioctl_exec.iie_addr);
        if (r != OK) {
                log_debug(&log, "check_reservation() denied the request\n");
                return r;
        }

        /* Call the device specific code to execute the action */
        r = process(&ioctl_exec);
        if (r != OK) {
                log_debug(&log, "process() failed\n");
                return r;
        }

        /* Copy the results of the execution back to the calling process */
        r = sys_safecopyto(caller, grant_nr, (vir_bytes) 0,
            (vir_bytes) & ioctl_exec, sizeof(ioctl_exec));
        if (r != OK) {
                log_warn(&log, "sys_safecopyto() failed\n");
                return r;
        }

        return OK;
}

static int
i2c_ioctl(devminor_t UNUSED(minor), unsigned long request, endpoint_t endpt,
        cp_grant_id_t grant, int UNUSED(flags), endpoint_t UNUSED(user_endpt),
        cdev_id_t UNUSED(id))
{
        int r;

        switch (request) {
        case MINIX_I2C_IOCTL_EXEC:
                r = do_i2c_ioctl_exec(endpt, grant);
                break;
        default:
                log_warn(&log, "Invalid ioctl() 0x%x\n", request);
                r = ENOTTY;
                break;
        }

        return r;
}

static void
i2c_other(message * m, int ipc_status)
{
        message m_reply;
        int r;

        if (is_ipc_notify(ipc_status)) {
                /* handle notifications about drivers changing state */
                if (m->m_source == DS_PROC_NR) {
                        ds_event();
                }
                return;
        }

        switch (m->m_type) {
        case BUSC_I2C_RESERVE:
                /* reserve a device on the bus for exclusive access */
                r = do_reserve(m->m_source, m->m_li2cdriver_i2c_busc_i2c_reserve.addr);
                break;
        case BUSC_I2C_EXEC:
                /* handle request from another driver */
                r = do_i2c_ioctl_exec(m->m_source, m->m_li2cdriver_i2c_busc_i2c_exec.grant);
                break;
        default:
                log_warn(&log, "Invalid message type (0x%x)\n", m->m_type);
                r = EINVAL;
                break;
        }

        log_trace(&log, "i2c_other() returning r=%d\n", r);

        /* Send a reply. */
        memset(&m_reply, 0, sizeof(m_reply));
        m_reply.m_type = r;

        if ((r = ipc_send(m->m_source, &m_reply)) != OK)
                log_warn(&log, "ipc_send() to %d failed: %d\n", m->m_source, r);
}

/*
 * The bus drivers are subscribed to DS events about device drivers on their
 * bus. When the device drivers restart, DS sends a notification and this
 * function updates the reservation table with the device driver's new
 * endpoint.
 */
static void
ds_event(void)
{
        char key[DS_MAX_KEYLEN];
        u32_t value;
        int type;
        endpoint_t owner_endpoint;
        int r;

        /* check for pending events */
        while ((r = ds_check(key, &type, &owner_endpoint)) == OK) {

                r = ds_retrieve_u32(key, &value);
                if (r != OK) {
                        log_warn(&log, "ds_retrieve_u32() failed r=%d\n", r);
                        return;
                }

                log_debug(&log, "key='%s' owner_endpoint=0x%x\n", key,
                    owner_endpoint);

                if (value == DS_DRIVER_UP) {
                        /* clean up any old reservations the driver had */
                        log_debug(&log, "DS_DRIVER_UP\n");
                        update_reservation(owner_endpoint, key);
                }
        }
}

static int
lu_state_restore(void)
{
        int r;
        char key[DS_MAX_KEYLEN];
        size_t size;

        env_parse_instance();

        size = sizeof(i2cdev);

        memset(key, '\0', DS_MAX_KEYLEN);
        snprintf(key, DS_MAX_KEYLEN, "i2c.%d.i2cdev", i2c_bus_id + 1);

        r = ds_retrieve_mem(key, (char *) i2cdev, &size);
        if (r != OK) {
                log_warn(&log, "ds_retrieve_mem(%s) failed (r=%d)\n", key, r);
                return r;
        }

        log_debug(&log, "State Restored\n");

        return OK;
}

static int
sef_cb_init(int type, sef_init_info_t * UNUSED(info))
{
        int r;
        char regex[DS_MAX_KEYLEN];
        struct machine machine;
        sys_getmachine(&machine);

        if (type != SEF_INIT_FRESH) {
                /* Restore a prior state. */
                lu_state_restore();
        }
        
        if (BOARD_IS_BBXM(machine.board_id) || BOARD_IS_BB(machine.board_id)){
                /* Set callback and initialize the bus */
                r = omap_interface_setup(&process, i2c_bus_id);
                if (r != OK) {
                        return r;
                }
        } else {
                return ENODEV;
        }

        /* Announce we are up when necessary. */
        if (type != SEF_INIT_LU) {

                /* only capture events for this particular bus */
                snprintf(regex, DS_MAX_KEYLEN, "drv\\.i2c\\.%d\\..*",
                    i2c_bus_id + 1);

                /* Subscribe to driver events for i2c drivers */
                r = ds_subscribe(regex, DSF_INITIAL | DSF_OVERWRITE);
                if (r != OK) {
                        log_warn(&log, "ds_subscribe() failed\n");
                        return r;
                }

                chardriver_announce();
        }

        /* Save state */
        sef_cb_lu_state_save(0, 0);

        /* Initialization completed successfully. */
        return OK;
}

static void
sef_local_startup()
{
        /* Register init callbacks. */
        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 */
        sef_setcb_lu_state_save(sef_cb_lu_state_save);

        /* Let SEF perform startup. */
        sef_startup();
}

static int
env_parse_instance(void)
{
        int r;
        long instance;

        /* Parse the instance number passed to service */
        instance = 0;
        r = env_parse("instance", "d", 0, &instance, 1, 3);
        if (r == -1) {
                log_warn(&log,
                    "Expecting '-arg instance=N' argument (N=1..3)\n");
                return EXIT_FAILURE;
        }

        /* Device files count from 1, hardware starts counting from 0 */
        i2c_bus_id = instance - 1;

        return OK;
}

int
main(int argc, char *argv[])
{
        int r;

        env_setargs(argc, argv);

        r = env_parse_instance();
        if (r != OK) {
                return r;
        }

        memset(i2cdev, '\0', sizeof(i2cdev));
        sef_local_startup();
        chardriver_task(&i2c_tab);

        return OK;
}