/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <sys/types.h>
#include <sys/conf.h>
#include <sys/kmem.h>
#include <sys/open.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/file.h>
#include <sys/modctl.h>
#include <sys/i2c/misc/i2c_svc.h>
#include <sys/i2c/misc/i2c_svc_impl.h>

kmutex_t i2c_svc_mutex;

static struct modldrv i2c_modldrv = {
        &mod_miscops,           /* type of module - misc */
        "I2C module",
        NULL,
};

static struct modlinkage i2c_modlinkage = {
        MODREV_1,
        &i2c_modldrv,
        0
};

i2c_nexus_reg_list_t *nexus_reg_list_head = NULL;

int i2csvcdebug = 0;

int
_init(void)
{
        int error;

        if ((error = mod_install(&i2c_modlinkage)) == 0) {
                mutex_init(&i2c_svc_mutex, NULL, MUTEX_DRIVER, NULL);
        }

        return (error);
}

int
_fini(void)
{
        int error;

        if ((error = mod_remove(&i2c_modlinkage)) == 0) {
                mutex_destroy(&i2c_svc_mutex);
        }

        return (error);
}

int
_info(struct modinfo *modinfop)
{
        return (mod_info(&i2c_modlinkage, modinfop));
}

/*
 * i2c_client_register is called by I2C client drivers,
 * typically in attach, but before starting any bus transfers.
 *
 * dip     - the client device's dip.
 * i2c_hdl - pointer to a handle returned on success.
 *
 */
int
i2c_client_register(dev_info_t *dip, i2c_client_hdl_t *i2c_hdl)
{
        dev_info_t *pdip;
        i2c_client_hdl_t hdl;
        i2c_nexus_reg_list_t *reg_list;

        pdip = ddi_get_parent(dip);

        mutex_enter(&i2c_svc_mutex);

        reg_list = nexus_reg_list_head;
        /*
         * search parent reg list to find dip's parent.
         */
        for (; reg_list != NULL; reg_list = reg_list->next) {
                if (reg_list->dip == pdip) {
                        break;
                }
        }

        mutex_exit(&i2c_svc_mutex);

        if (reg_list == NULL) {

                return (I2C_FAILURE);
        }

        hdl = kmem_alloc(sizeof (struct i2c_client_hdl_impl), KM_SLEEP);

        CHDL(hdl)->chdl_dip = dip;
        CHDL(hdl)->chdl_nexus_reg = &reg_list->nexus_reg;
        *i2c_hdl = hdl;

        return (I2C_SUCCESS);
}

/*
 * i2c_client_unregister() is called by the I2C client driver
 * when it no longer wishes to transmit on the I2C bus, typically
 * during its detach routine.
 *
 * hdl - handle previously returned by i2c_client_register().
 *
 */
void
i2c_client_unregister(i2c_client_hdl_t hdl)
{
        kmem_free(hdl, sizeof (struct i2c_client_hdl_impl));
}

/*
 * i2c_transfer() is called by client drivers to handle
 * I2C data transfers.  It performs some basic sanity checking of
 * flags vs. i2c_len and i2c_wlen values, and then calls the
 * parent's i2c_transfer() function to handle the actual transfer.
 */
int
i2c_transfer(i2c_client_hdl_t hdl, i2c_transfer_t *i2c_tran)
{
        switch (i2c_tran->i2c_flags) {
        case I2C_WR:
                if (i2c_tran->i2c_wlen == 0) {

                        return (EINVAL);
                }
                break;
        case I2C_RD:
                if (i2c_tran->i2c_rlen == 0) {

                        return (EINVAL);
                }
                break;
        case I2C_WR_RD:
                if (i2c_tran->i2c_wlen == 0 || i2c_tran->i2c_rlen == 0) {

                        return (EINVAL);
                }
                break;
        default:

                return (EINVAL);
        }

        if (CHDL(hdl)->chdl_nexus_reg->i2c_nexus_transfer != NULL) {
                (*CHDL(hdl)->chdl_nexus_reg->i2c_nexus_transfer)
                                (CHDL(hdl)->chdl_dip, i2c_tran);

                return (i2c_tran->i2c_result);
        } else {

                return (ENOTSUP);
        }
}

/*
 * i2c_transfer_alloc() allocates a i2c_transfer structure along
 * with read and write buffers of size rlen and wlen respectively.
 *
 * i2c_hdl - handle returned previously by i2c_client_register()
 * i2c - address of pointer to allocated buffer returned on success.
 * wlen - write size buffer to allocate.  May be 0.
 * rlen - read size buffer to allocate.  May be 0.
 * flags - I2C_SLEEP or I2C_NOSLEEP
 */
/*ARGSUSED*/
int
i2c_transfer_alloc(i2c_client_hdl_t hdl,
                        i2c_transfer_t **i2c,
                        ushort_t wlen,
                        ushort_t rlen,
                        uint_t flags)
{
        i2c_transfer_alloc_t *i2cw;
        int sleep;
        int size;

        /*
         * set i2c to NULL in case the caller just checks i2c
         * to determine failures.
         */
        *i2c = NULL;

        if (flags & I2C_SLEEP) {
                sleep = KM_SLEEP;
        } else if (flags & I2C_NOSLEEP) {
                sleep = KM_NOSLEEP;
        } else {
                sleep = KM_NOSLEEP;
        }

        size = sizeof (i2c_transfer_alloc_t) + rlen + wlen;

        if ((i2cw = kmem_zalloc(size, sleep)) == NULL) {

                return (I2C_FAILURE);
        }

        i2cw->i2cw_size = size;
        i2cw->i2cw_i2ct.i2c_wlen = wlen;
        i2cw->i2cw_i2ct.i2c_rlen = rlen;
        if (wlen != 0) {
                i2cw->i2cw_i2ct.i2c_wbuf = (uchar_t *)i2cw +
                        sizeof (i2c_transfer_alloc_t);
        }
        if (rlen != 0) {
                i2cw->i2cw_i2ct.i2c_rbuf = (uchar_t *)i2cw +
                        sizeof (i2c_transfer_alloc_t) + wlen;
        }
        *i2c = (i2c_transfer_t *)i2cw;

        return (I2C_SUCCESS);
}

/*
 * i2c_transfer_free() is called to free a buffer previously
 * allocated by i2c_transfer_allocate().
 *
 * i2c_hdl - handle returned previously by i2c_client_register()
 * i2c - buffer previously allocated by i2c_transfer_allocate()
 */
/*ARGSUSED*/
void
i2c_transfer_free(i2c_client_hdl_t hdl, i2c_transfer_t *i2c_tran)
{
        i2c_transfer_alloc_t *i2cw = (i2c_transfer_alloc_t *)i2c_tran;

        kmem_free(i2cw, i2cw->i2cw_size);
}

/*
 * i2c_nexus_register() is called by the nexus driver to inform
 * I2C services that it is ready to accept transactions, and
 * give the I2C services a vector of functions.
 *
 * dip - dip of the bus controller
 * nexus_reg - pointer to reg structure of vector functions
 */
void
i2c_nexus_register(dev_info_t *dip, i2c_nexus_reg_t *nexus_reg)
{
        i2c_nexus_reg_list_t *nexus_reglist;

        nexus_reglist = kmem_alloc(sizeof (struct i2c_nexus_reg_list),
                KM_SLEEP);

        mutex_enter(&i2c_svc_mutex);
        nexus_reglist->next = nexus_reg_list_head;
        nexus_reg_list_head = nexus_reglist;
        mutex_exit(&i2c_svc_mutex);

        nexus_reglist->nexus_reg = *nexus_reg;
        nexus_reglist->dip = dip;
}

/*
 * i2c_nexus_unregister() is called by the nexus driver when
 * it is no longer able to accept transactions for its I2C
 * children.
 *
 * dip - dev_info pointer passed to i2c_nexus_register().
 */
void
i2c_nexus_unregister(dev_info_t *dip)
{
        i2c_nexus_reg_list_t **reg_list;
        i2c_nexus_reg_list_t *save = NULL;

        mutex_enter(&i2c_svc_mutex);

        reg_list = &nexus_reg_list_head;

        /*
         * reg_list is the address of the pointer to an element on
         * the reg list.  It starts out being the address of the
         * list head, but then is changed to the address of the
         * next pointer in a list element.  Once the element to
         * delete is found, then we change the pointer to the
         * address found in the next pointer of the element to
         * be deleted.
         */
        for (; *reg_list != NULL; reg_list = &(*reg_list)->next) {
                if ((*reg_list)->dip == dip) {
                        save = *reg_list;
                        /* prev next pointer adjusted to point */
                        *reg_list = (*reg_list)->next;
                        break;
                }
        }
        mutex_exit(&i2c_svc_mutex);
        if (save != NULL) {
                kmem_free(save, sizeof (i2c_nexus_reg_list_t));
        } else {
                cmn_err(CE_WARN, "could not find nexus reg to free");
        }
}