#include <asm/io.h>
#include <linux/slab.h>
#include <linux/gpio.h>
#include <linux/delay.h>
#include <linux/jiffies.h>
#include <linux/i2c.h>
#include "io_expander.h"
#include "inv_mux.h"

/* For build single module using (Ex: ONL platform) */
#include <linux/module.h>
//#include <linux/inventec/d5254/io_expander.h>
//#include <linux/inventec/d5254/inv_mux.h>


static struct mux_obj_s *mux_head_p = NULL;

/* ========== MUX object functions ==========
 */
static int
_setup_i2c_value(struct mux_obj_s *self, int offset, int value){

    return i2c_smbus_write_byte_data(self->i2c_client_p, offset, value);
}


static int
_setup_i2c_client(struct mux_obj_s *self, int chan_id, int addr){

    struct i2c_adapter *adap  = NULL;
    char *emsg = "ERR";

    adap = i2c_get_adapter(chan_id);
    if (!adap){
        emsg = "can't get adapter";
        goto err_setup_i2c_client;
    }
    self->i2c_client_p = kzalloc(sizeof(*self->i2c_client_p), GFP_KERNEL);
    if (!self->i2c_client_p){
        emsg = "can't kzalloc client";
        goto err_setup_i2c_client;
    }
    self->i2c_client_p->adapter = adap;
    self->i2c_client_p->addr = addr;
    return 0;

err_setup_i2c_client:
    SWPS_ERR("%s: %s\n", __func__, emsg);
    return ERR_MUX_UNEXCPT;
}


int
_common_force_pull_gpio(int mem_addr,
                        int input,
                        int bit_offset){

    unsigned int val  = 0;
    unsigned int targ = 0;

    /* Get current value */
    val = inl(mem_addr);
    if (val == 0) {
        SWPS_ERR("%s: inl:%d fail!\n", __func__, val);
        return -1;
    }
    /* Count target value */
    switch (input) {
        case 0: /* Pull Low */
            targ = (val & (~(1 << bit_offset)));
            break;
        case 1: /* Pull high */
            targ = (val | (1 << bit_offset));
            break;
        default:
            SWPS_ERR("%s: input state:%d incorrect!\n",
                    __func__, input);
            return -1;
    }
    /* Setup gpio */
    outl(targ, mem_addr);
    if (targ != inl(mem_addr)){
        SWPS_ERR("%s: outl:%d fail!\n", __func__, targ);
        return -1;
    }
    SWPS_DEBUG("%s: done.\n", __func__);
    return 0;
}


int
rangeley_force_pull_high(struct mux_obj_s *self){
    SWPS_ERR("%s: not ready!\n", __func__);
    return -1;
}


int
rangeley_force_pull_low(struct mux_obj_s *self){
    SWPS_ERR("%s: not ready!\n", __func__);
    return -1;
}


int
hedera_force_pull_high(struct mux_obj_s *self){
    return _common_force_pull_gpio(MUX_RST_MEM_ADDR_HEDERA, 1, 5);
}


int
hedera_force_pull_low(struct mux_obj_s *self){
    return _common_force_pull_gpio(MUX_RST_MEM_ADDR_HEDERA, 0, 5);
}


int
normal_gpio_pull_high(struct mux_obj_s *self){
    return gpio_direction_output(self->gpio_num, 1);
}


int
normal_gpio_pull_low(struct mux_obj_s *self){
    return gpio_direction_output(self->gpio_num, 0);
}


int
cpld_rst_all_4_pull_low(struct mux_obj_s *self){

    char *emsg = "ERR";
    int   err  = ERR_MUX_UNEXCPT;

    switch(self->gpio_num) {
        case MUX_RST_CPLD_C0_A77_70_74_RST_ALL:
            goto setlow_cpld_rst_all_4_c0_a77_70_74_rst_all;

        default:
            break;
    }
    emsg = "Undefined case";
    goto err_cpld_rst_all_4_pull_low;

setlow_cpld_rst_all_4_c0_a77_70_74_rst_all:
    err = _setup_i2c_value(self, 0x70, 0x0);
    if (err < 0) {
        emsg = "setup 0x70 fail";
        goto err_cpld_rst_all_4_pull_low;
    }
    err = _setup_i2c_value(self, 0x74, 0x01);
    if (err < 0) {
        emsg = "setup 0x74 fail";
        goto err_cpld_rst_all_4_pull_low;
    }
    return 0;

err_cpld_rst_all_4_pull_low:
    SWPS_INFO("%s: %s <type>:%d <err>:%d\n",
            __func__, emsg, self->gpio_num, err);
    return ERR_MUX_UNEXCPT;
}


int
cpld_rst_all_4_pull_high(struct mux_obj_s *self){

    char *emsg = "ERR";
    int   err  = ERR_MUX_UNEXCPT;

    switch(self->gpio_num) {
        case MUX_RST_CPLD_C0_A77_70_74_RST_ALL:
            goto sethigh_cpld_rst_all_4_c0_a77_70_74_rst_all;

        default:
            break;
    }
    emsg = "Undefined case";
    goto err_cpld_rst_all_4_pull_high;

sethigh_cpld_rst_all_4_c0_a77_70_74_rst_all:
    err = _setup_i2c_value(self, 0x70, 0xfe);
    if (err < 0) {
        emsg = "setup 0x70 fail";
        goto err_cpld_rst_all_4_pull_high;
    }
    err = _setup_i2c_value(self, 0x74, 0x03);
    if (err < 0) {
        emsg = "setup 0x74 fail";
        goto err_cpld_rst_all_4_pull_high;
    }
    return 0;

err_cpld_rst_all_4_pull_high:
    SWPS_INFO("%s: %s <type>:%d <err>:%d\n",
            __func__, emsg, self->gpio_num, err);
    return ERR_MUX_UNEXCPT;
}


int
pca9548_reset_mux_all(struct mux_obj_s *self){
    /* [Note] Power-on reset (PCA9548A-NXP)
     *     When power is applied to VDD, an internal Power-On Reset (POR)
     *     holds the PCA9548A in a reset condition until VDD has reached
     *     VPOR. At this point, the reset condition is released and the
     *     PCA9548A register and I2C-bus state machine are initialized to
     *     their default states (all zeroes) causing all the channels to
     *     be deselected. Thereafter, VDD must be lowered below 0.2 V for
     *     at least 5 us in order to reset the device.
     */
    if (self->_pull_low(self) < 0) {
        SWPS_ERR("%s: _pull_low fail!\n", __func__);
        return -1;
    }
    mdelay(MUX_RST_WAIT_MS_PCA9548);
    if (self->_pull_high(self) < 0) {
        SWPS_ERR("%s: _pull_high fail!\n", __func__);
        return -1;
    }
    mdelay(MUX_RST_WAIT_MS_PCA9548);
    return 0;
}


int
cpld_reset_mux_all(struct mux_obj_s *self){

    char *emsg = "ERR";
    int   err  = ERR_MUX_UNEXCPT;

    switch(self->gpio_num) {
        case MUX_RST_CPLD_C0_A77_70_74_RST_ALL:
            goto reset_cpld_rst_all_4_c0_a77_70_74_rst_all;

        default:
            break;
    }
    emsg = "Undefined case";
    goto err_cpld_reset_mux_all;
    
reset_cpld_rst_all_4_c0_a77_70_74_rst_all:
    if (self->_pull_low(self) < 0) {
        emsg = "_pull_low fail";
        goto err_cpld_reset_mux_all;
    }
    mdelay(MUX_RST_WAIT_MS_CPLD);
    return 0;
    
err_cpld_reset_mux_all:
    SWPS_INFO("%s: %s <type>:%d <err>:%d\n",
            __func__, emsg, self->gpio_num, err);
    return ERR_MUX_UNEXCPT;
}


int
common_reset_mux_all(struct mux_obj_s *self){
    SWPS_ERR("%s: not ready!\n", __func__);
    return -1;
}


int
init_gpio_4_force(struct mux_obj_s *self){

    if (self->_pull_high(self) < 0) {
        SWPS_ERR("%s: setup default fail!\n", __func__);
        return -1;
    }
    return 0;
}


int
init_gpio_4_normal(struct mux_obj_s *self){

    int   err  = 0;
    char *emsg = "ERR";

    if (!gpio_is_valid(self->gpio_num)) {
        emsg = "GPIO invalid";
        goto err_init_gpio_4_normal;
    }
    err = gpio_request(self->gpio_num, MUX_GPIO_LABEL);
    if (err < 0) {
        emsg = "gpio_request fail";
        goto err_init_gpio_4_normal;
    }
    err = self->_pull_high(self);
    if (err < 0) {
        emsg = "setup default fail";
        goto err_init_gpio_4_normal;
    }
    SWPS_DEBUG("%s: gpio_request:%d ok.\n", __func__, self->gpio_num);
    return 0;

err_init_gpio_4_normal:
    SWPS_ERR("%s: %s <gpio>:%d <err>:%d\n",
             __func__, emsg, self->gpio_num, err);
    return -1;
}


int
init_cpld_4_rst_all(struct mux_obj_s *self){

    char *emsg = "ERR";
    int err  = ERR_MUX_UNEXCPT;
    int chan = ERR_MUX_UNEXCPT;
    int addr = ERR_MUX_UNEXCPT;

    switch(self->gpio_num) {
        case MUX_RST_CPLD_C0_A77_70_74_RST_ALL:
            goto init_cpld_i2c_c0_a77_70_74_rst_all;

        default:
            break;
    }
    emsg = "Undefined case";
    goto err_init_cpld_4_rst_all;

init_cpld_i2c_c0_a77_70_74_rst_all:
    chan = 0;
    addr = 0x77;
    err = _setup_i2c_client(self, chan, addr);
    if (err < 0) {
        emsg = "_setup_i2c_client fail";
        goto err_init_cpld_4_rst_all;
    }
    err = self->_pull_high(self);
    if (err < 0) {
        emsg = "setup default value fail";
        goto err_init_cpld_4_rst_all;
    }
    SWPS_DEBUG("%s: init_cpld_i2c_c0_a77_70_74_rst_all ok", __func__);
    return 0;

err_init_cpld_4_rst_all:
    SWPS_INFO("%s: %s <type>:%d <err>:%d\n",
             __func__, emsg, self->gpio_num, err);
    return ERR_MUX_UNEXCPT;
}


int
clean_gpio_4_common(struct mux_obj_s *self){

    if (!self) return 0;
    if (!gpio_is_valid(self->gpio_num)) return 0;
    self->_pull_high(self);
    gpio_free(mux_head_p->gpio_num);
    return 0;
}


int
clean_cpld_4_rst_all(struct mux_obj_s *self){

    if (!self) return 0;
    self->_pull_high(self);
    if (self->i2c_client_p) {
        i2c_put_adapter(self->i2c_client_p->adapter);
        kfree(self->i2c_client_p);
    }
    return 0;
}


static int
_setup_muxctl_cb(struct mux_obj_s *self,
                 unsigned gpio){

    char mod_dsc[32] = "ERR";

    switch (gpio) {
        case MUX_RST_GPIO_FORCE_RANGELEY:
            self->gpio_num   = gpio;
            self->_pull_low  = rangeley_force_pull_low;
            self->_pull_high = rangeley_force_pull_high;
            self->_init      = init_gpio_4_force;
            self->_clean     = clean_gpio_4_common;
            self->reset      = pca9548_reset_mux_all;
            memset(mod_dsc, 0, 32);
            snprintf(mod_dsc, 31, "Rangeley force mode");
            goto ok_setup_muxctl_cb;

        case MUX_RST_GPIO_FORCE_HEDERA:
            self->gpio_num   = gpio;
            self->_pull_low  = hedera_force_pull_low;
            self->_pull_high = hedera_force_pull_high;
            self->_init      = init_gpio_4_force;
            self->_clean     = clean_gpio_4_common;
            self->reset      = pca9548_reset_mux_all;
            memset(mod_dsc, 0, 32);
            snprintf(mod_dsc, 31, "Hedera force mode");
            goto ok_setup_muxctl_cb;

        case MUX_RST_GPIO_48_PCA9548:
        case MUX_RST_GPIO_69_PCA9548:
        case MUX_RST_GPIO_249_PCA9548:
        case MUX_RST_GPIO_500_PCA9548:
        case MUX_RST_GPIO_505_PCA9548:
            self->gpio_num   = gpio;
            self->_pull_low  = normal_gpio_pull_low;
            self->_pull_high = normal_gpio_pull_high;
            self->_init      = init_gpio_4_normal;
            self->_clean     = clean_gpio_4_common;
            self->reset      = pca9548_reset_mux_all;
            memset(mod_dsc, 0, 32);
            snprintf(mod_dsc, 31, "Normal mode <gpio>:%d", (int)gpio);
            goto ok_setup_muxctl_cb;

        case MUX_RST_CPLD_C0_A77_70_74_RST_ALL:
            self->gpio_num   = gpio;
            self->_pull_low  = cpld_rst_all_4_pull_low;
            self->_pull_high = cpld_rst_all_4_pull_high;
            self->_init      = init_cpld_4_rst_all;
            self->_clean     = clean_cpld_4_rst_all;
            self->reset      = cpld_reset_mux_all;
            memset(mod_dsc, 0, 32);
            snprintf(mod_dsc, 31, "CPLD mode <type>:%d", (int)gpio);
            goto ok_setup_muxctl_cb;

        default:
            break;
    }
    SWPS_ERR("%s: Unexpected GPIO:%d\n", __func__, gpio);
    return -1;

ok_setup_muxctl_cb:
    SWPS_INFO("muxctl: %s.\n", mod_dsc);
    return 0;
}


/* ========== MUX public functions ==========
 */
void
clean_mux_objs(void){

    struct mux_obj_s *curr_p = mux_head_p;
    struct mux_obj_s *next_p = NULL;

    if (!curr_p) {
        SWPS_DEBUG("%s: mux_head_p is NULL\n", __func__);
        return;
    }
    while (curr_p) {
        next_p = curr_p->next;
        curr_p->_clean(curr_p);
        kfree(curr_p);
        curr_p = next_p;
    }
    SWPS_DEBUG("%s: done.\n", __func__);
}
EXPORT_SYMBOL(clean_mux_objs);


int
reset_mux_objs(void){

    if (!mux_head_p) {
        SWPS_ERR("%s: MUX ctl object doesn't exist!\n", __func__);
        return -1;
    }
    if (mux_head_p->reset(mux_head_p) < 0){
        SWPS_ERR("%s: reset fail!\n", __func__);
        return -1;
    }
    return 0;
}
EXPORT_SYMBOL(reset_mux_objs);


struct mux_obj_s *
_create_mux_obj(unsigned gpio){

    char *emsg = "ERR";
    struct mux_obj_s *obj_p = NULL;

    obj_p = kzalloc(sizeof(struct mux_obj_s), GFP_KERNEL);
    if (!obj_p) {
        emsg = "kzalloc fail!";
        goto err_create_mux_obj_1;
    }
    if (_setup_muxctl_cb(obj_p, gpio) < 0){
        emsg = "_setup_muxctl_cb fail!";
        goto err_create_mux_obj_2;
    }
    if (obj_p->_init(obj_p) < 0) {
        emsg = "_init() fail!";
        goto err_create_mux_obj_2;
    }
    SWPS_DEBUG("%s: created MUX object <id>:%d\n", __func__, gpio);
    return obj_p;

err_create_mux_obj_2:
    kfree(obj_p);
err_create_mux_obj_1:
    SWPS_ERR("%s: %s <type>:%d\n", __func__, emsg, gpio);
    return NULL;
}


int
init_mux_objs(unsigned gpio){

    struct mux_obj_s *curr_p = NULL;
    char  *emsg = "ERR";

    /* Create MUX control object */
    if (mux_head_p) {
        SWPS_DEBUG("%s: mux_head_p is not NULL!\n", __func__);
        clean_mux_objs();
    }
    /* Currently, it is using single muxctl architecture.
     * In the future, it may use the multi-muxctl.
     * (Ex: Gulmohar's advance I2C control / Peony's reset single mux)
     */
    curr_p = _create_mux_obj(gpio);
    if (!curr_p) {
        emsg = "_create_mux_obj fail";
        goto err_init_mux_objs;
    }
    curr_p->next = NULL;
    mux_head_p = curr_p;
    SWPS_DEBUG("%s: all done. <type>:%d\n", __func__, gpio);
    return 0;

err_init_mux_objs:
    clean_mux_objs();
    SWPS_ERR("%s: %s\n", __func__, emsg);
    return -1;
}
EXPORT_SYMBOL(init_mux_objs);


/* For single ko module
 * => You need to declare MODULE_LICENSE If you want to build single module along.
 * => Ex: For ONL platform
 */
MODULE_LICENSE("GPL");