/*
 * Copyright 2019 Broadcom.
 * The term “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 *
 * PDDF generic kernle module to create the I2C client for pca955x type of GPIO module
 */

#define __STDC_WANT_LIB_EXT1__ 1
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/jiffies.h>
#include <linux/i2c.h>
#include <linux/hwmon.h>
#include <linux/hwmon-sysfs.h>
#include <linux/err.h>
#include <linux/mutex.h>
#include <linux/sysfs.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/dmi.h>
#include <linux/kobject.h>
#include "pddf_client_defs.h"
#include "pddf_gpio_defs.h"


static ssize_t do_device_operation(struct device *dev, struct device_attribute *da, const char *buf, size_t count);
extern void* get_device_table(char *name);
extern void delete_device_table(char *name);

static int base_gpio_num = 0xf0;
GPIO_DATA gpio_data = {0};

/* GPIO CLIENT DATA */
PDDF_DATA_ATTR(gpio_base, S_IWUSR|S_IRUGO, show_pddf_data, store_pddf_data, PDDF_INT_HEX, sizeof(int), (void*)&gpio_data.gpio_base, NULL);
PDDF_DATA_ATTR(dev_ops, S_IWUSR, NULL, do_device_operation, PDDF_CHAR, 8, (void*)&gpio_data, (void*)&pddf_data);



static struct attribute *gpio_attributes[] = {
    &attr_gpio_base.dev_attr.attr,
    &attr_dev_ops.dev_attr.attr,
    NULL
};

static const struct attribute_group pddf_gpio_client_data_group = {
    .attrs = gpio_attributes,
};


struct i2c_board_info *i2c_get_gpio_board_info(GPIO_DATA* mdata, NEW_DEV_ATTR *device_data)
{
    static struct i2c_board_info board_info;
    struct pca953x_platform_data *gpio_platform_data=NULL;
    int def_num_gpios, base;

    gpio_platform_data = (struct pca953x_platform_data *)kzalloc(sizeof (struct pca953x_platform_data), GFP_KERNEL);

    if (strncmp(device_data->dev_type, "pca9554", strlen("pca9554")) == 0 ||
            strncmp(device_data->dev_type, "pca9534", strlen("pca9534")) == 0 ||
            strncmp(device_data->dev_type, "pca9538", strlen("pca9538")) == 0 ||
            strncmp(device_data->dev_type, "tca6408", strlen("tca6408")) == 0 ||
            strncmp(device_data->dev_type, "tca9554", strlen("tca9554")) == 0)
        def_num_gpios = 0x8;
    else if (strncmp(device_data->dev_type, "pca9555", strlen("pca9555")) == 0 ||
            strncmp(device_data->dev_type, "pca9535", strlen("pca9535")) == 0 ||
            strncmp(device_data->dev_type, "pca9539", strlen("pca9539")) == 0 ||
            strncmp(device_data->dev_type, "pca9575", strlen("pca9575")) == 0 ||
            strncmp(device_data->dev_type, "tca6416", strlen("tca6416")) == 0 ||
            strncmp(device_data->dev_type, "tca9539", strlen("tca9539")) == 0)
        def_num_gpios = 0x10;
    else if (strncmp(device_data->dev_type, "tca6424", strlen("tca6424")) == 0)
        def_num_gpios = 0x18;
    else if (strncmp(device_data->dev_type, "pca9698", strlen("pca9698")) == 0 ||
            strncmp(device_data->dev_type, "pca9505", strlen("pca9505")) == 0)
        def_num_gpios = 0x28;
    else
    {
        printk(KERN_ERR "%s: Unknown type of gpio device\n", __FUNCTION__);
        return NULL;
    }

    if(mdata->gpio_base == 0) {
        base = base_gpio_num;
        base_gpio_num += def_num_gpios;
    }
    else {
        base = mdata->gpio_base;
    }

    gpio_platform_data->gpio_base = base;

    board_info = (struct i2c_board_info) {
        .platform_data = gpio_platform_data,
    };

    board_info.addr = device_data->dev_addr;
    strcpy(board_info.type, device_data->dev_type);

    return &board_info;
}


static ssize_t do_device_operation(struct device *dev, struct device_attribute *da, const char *buf, size_t count)
{
    PDDF_ATTR *ptr = (PDDF_ATTR *)da;
    GPIO_DATA *gpio_ptr = (GPIO_DATA *)(ptr->addr);
    NEW_DEV_ATTR *device_ptr = (NEW_DEV_ATTR *)(ptr->data);
    struct i2c_adapter *adapter;
    struct i2c_board_info *board_info;
    struct i2c_client *client_ptr;

    if (strncmp(buf, "add", strlen(buf)-1)==0)
    {
        adapter = i2c_get_adapter(device_ptr->parent_bus);
        board_info = i2c_get_gpio_board_info(gpio_ptr, device_ptr);

        /*pddf_dbg(KERN_ERR "Creating a client %s on 0x%x, platform_data 0x%x\n", board_info->type, board_info->addr, board_info->platform_data);*/
        client_ptr = i2c_new_client_device(adapter, board_info);

        i2c_put_adapter(adapter);
        if (!IS_ERR(client_ptr))
        {
            pddf_dbg(GPIO, KERN_ERR "Created %s client: 0x%p\n", device_ptr->i2c_name, (void *)client_ptr);
            add_device_table(device_ptr->i2c_name, (void*)client_ptr);
        }
        else
        {
            kfree(board_info);
            goto free_data;
        }
    }
    else if (strncmp(buf, "delete", strlen(buf)-1)==0)
    {
        /*Get the i2c_client handle for the created client*/
        client_ptr = (struct i2c_client *)get_device_table(device_ptr->i2c_name);
        if (client_ptr)
        {
            struct pca953x_platform_data *gpio_platform_data = (struct pca953x_platform_data *)client_ptr->dev.platform_data;
            pddf_dbg(GPIO, KERN_ERR "Removing %s client: 0x%p\n", device_ptr->i2c_name, (void *)client_ptr);
            i2c_unregister_device(client_ptr);
            /*TODO: Nullyfy the platform data*/
            if (gpio_platform_data)
                kfree(gpio_platform_data);
            delete_device_table(device_ptr->i2c_name);
        }
        else
        {
            printk(KERN_ERR "Unable to get the client handle for %s\n", device_ptr->i2c_name);
        }
    }
    else
    {
        printk(KERN_ERR "PDDF_ERROR: %s: Invalid value for dev_ops %s", __FUNCTION__, buf);
    }

free_data:

#ifdef __STDC_LIB_EXT1__
    memset_s(gpio_ptr, sizeof(GPIO_DATA), 0, sizeof(GPIO_DATA));
#else
    memset(gpio_ptr, 0, sizeof(GPIO_DATA));
#endif
    /*TODO: free the device_ptr->data is dynamically allocated*/
#ifdef __STDC_LIB_EXT1__
    memset_s(device_ptr, sizeof(NEW_DEV_ATTR), 0 , sizeof(NEW_DEV_ATTR));
#else
    memset(device_ptr, 0 , sizeof(NEW_DEV_ATTR));
#endif

    return count;
}


static struct kobject *gpio_kobj;

int __init gpio_data_init(void)
{
    struct kobject *device_kobj;
    int ret = 0;


    pddf_dbg(GPIO, "GPIO_DATA MODULE.. init\n");

    device_kobj = get_device_i2c_kobj();
    if(!device_kobj)
        return -ENOMEM;

    gpio_kobj = kobject_create_and_add("gpio", device_kobj);
    if(!gpio_kobj)
        return -ENOMEM;


    ret = sysfs_create_group(gpio_kobj, &pddf_clients_data_group);
    if (ret)
    {
        kobject_put(gpio_kobj);
        return ret;
    }
    pddf_dbg(GPIO, "CREATED PDDF I2C CLIENTS CREATION SYSFS GROUP\n");

    ret = sysfs_create_group(gpio_kobj, &pddf_gpio_client_data_group);
    if (ret)
    {
        sysfs_remove_group(gpio_kobj, &pddf_clients_data_group);
        kobject_put(gpio_kobj);
        return ret;
    }
    pddf_dbg(GPIO, "CREATED GPIO DATA SYSFS GROUP\n");

    return ret;
}

void __exit gpio_data_exit(void)
{
    pddf_dbg(GPIO, "GPIO_DATA MODULE.. exit\n");
    sysfs_remove_group(gpio_kobj, &pddf_gpio_client_data_group);
    sysfs_remove_group(gpio_kobj, &pddf_clients_data_group);
    kobject_put(gpio_kobj);
    pddf_dbg(GPIO, KERN_ERR "%s: Removed the kobjects for 'gpio'\n",__FUNCTION__);
    return;
}

module_init(gpio_data_init);
module_exit(gpio_data_exit);

MODULE_AUTHOR("Broadcom");
MODULE_DESCRIPTION("gpio platform data");
MODULE_LICENSE("GPL");