/*
 * Copyright (C) 2012 CERN (www.cern.ch)
 * Author: Alessandro Rubini <rubini@gnudd.com>
 *
 * Released according to the GNU GPL, version 2 or any later version.
 *
 * This work is part of the White Rabbit project, a research effort led
 * by CERN, the European Institute for Nuclear Research.
 */
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/fmc.h>
#include <linux/fmc-sdb.h>

#include "fmc-private.h"

static int fmc_check_version(unsigned long version, const char *name)
{
        if (__FMC_MAJOR(version) != FMC_MAJOR) {
                pr_err("%s: \"%s\" has wrong major (has %li, expected %i)\n",
                       __func__, name, __FMC_MAJOR(version), FMC_MAJOR);
                return -EINVAL;
        }

        if (__FMC_MINOR(version) != FMC_MINOR)
                pr_info("%s: \"%s\" has wrong minor (has %li, expected %i)\n",
                       __func__, name, __FMC_MINOR(version), FMC_MINOR);
        return 0;
}

static int fmc_uevent(struct device *dev, struct kobj_uevent_env *env)
{
        /* struct fmc_device *fdev = to_fmc_device(dev); */

        /* FIXME: The MODALIAS */
        add_uevent_var(env, "MODALIAS=%s", "fmc");
        return 0;
}

static int fmc_probe(struct device *dev)
{
        struct fmc_driver *fdrv = to_fmc_driver(dev->driver);
        struct fmc_device *fdev = to_fmc_device(dev);

        return fdrv->probe(fdev);
}

static int fmc_remove(struct device *dev)
{
        struct fmc_driver *fdrv = to_fmc_driver(dev->driver);
        struct fmc_device *fdev = to_fmc_device(dev);

        return fdrv->remove(fdev);
}

static void fmc_shutdown(struct device *dev)
{
        /* not implemented but mandatory */
}

static struct bus_type fmc_bus_type = {
        .name = "fmc",
        .match = fmc_match,
        .uevent = fmc_uevent,
        .probe = fmc_probe,
        .remove = fmc_remove,
        .shutdown = fmc_shutdown,
};

static void fmc_release(struct device *dev)
{
        struct fmc_device *fmc = container_of(dev, struct fmc_device, dev);

        kfree(fmc);
}

/*
 * The eeprom is exported in sysfs, through a binary attribute
 */

static ssize_t fmc_read_eeprom(struct file *file, struct kobject *kobj,
                           struct bin_attribute *bin_attr,
                           char *buf, loff_t off, size_t count)
{
        struct device *dev;
        struct fmc_device *fmc;
        int eelen;

        dev = container_of(kobj, struct device, kobj);
        fmc = container_of(dev, struct fmc_device, dev);
        eelen = fmc->eeprom_len;
        if (off > eelen)
                return -ESPIPE;
        if (off == eelen)
                return 0; /* EOF */
        if (off + count > eelen)
                count = eelen - off;
        memcpy(buf, fmc->eeprom + off, count);
        return count;
}

static ssize_t fmc_write_eeprom(struct file *file, struct kobject *kobj,
                                struct bin_attribute *bin_attr,
                                char *buf, loff_t off, size_t count)
{
        struct device *dev;
        struct fmc_device *fmc;

        dev = container_of(kobj, struct device, kobj);
        fmc = container_of(dev, struct fmc_device, dev);
        return fmc->op->write_ee(fmc, off, buf, count);
}

static struct bin_attribute fmc_eeprom_attr = {
        .attr = { .name = "eeprom", .mode = S_IRUGO | S_IWUSR, },
        .size = 8192, /* more or less standard */
        .read = fmc_read_eeprom,
        .write = fmc_write_eeprom,
};

int fmc_irq_request(struct fmc_device *fmc, irq_handler_t h,
                    char *name, int flags)
{
        if (fmc->op->irq_request)
                return fmc->op->irq_request(fmc, h, name, flags);
        return -EPERM;
}
EXPORT_SYMBOL(fmc_irq_request);

void fmc_irq_free(struct fmc_device *fmc)
{
        if (fmc->op->irq_free)
                fmc->op->irq_free(fmc);
}
EXPORT_SYMBOL(fmc_irq_free);

void fmc_irq_ack(struct fmc_device *fmc)
{
        if (likely(fmc->op->irq_ack))
                fmc->op->irq_ack(fmc);
}
EXPORT_SYMBOL(fmc_irq_ack);

int fmc_validate(struct fmc_device *fmc, struct fmc_driver *drv)
{
        if (fmc->op->validate)
                return fmc->op->validate(fmc, drv);
        return -EPERM;
}
EXPORT_SYMBOL(fmc_validate);

int fmc_gpio_config(struct fmc_device *fmc, struct fmc_gpio *gpio, int ngpio)
{
        if (fmc->op->gpio_config)
                return fmc->op->gpio_config(fmc, gpio, ngpio);
        return -EPERM;
}
EXPORT_SYMBOL(fmc_gpio_config);

int fmc_read_ee(struct fmc_device *fmc, int pos, void *d, int l)
{
        if (fmc->op->read_ee)
                return fmc->op->read_ee(fmc, pos, d, l);
        return -EPERM;
}
EXPORT_SYMBOL(fmc_read_ee);

int fmc_write_ee(struct fmc_device *fmc, int pos, const void *d, int l)
{
        if (fmc->op->write_ee)
                return fmc->op->write_ee(fmc, pos, d, l);
        return -EPERM;
}
EXPORT_SYMBOL(fmc_write_ee);

/*
 * Functions for client modules follow
 */

int fmc_driver_register(struct fmc_driver *drv)
{
        if (fmc_check_version(drv->version, drv->driver.name))
                return -EINVAL;
        drv->driver.bus = &fmc_bus_type;
        return driver_register(&drv->driver);
}
EXPORT_SYMBOL(fmc_driver_register);

void fmc_driver_unregister(struct fmc_driver *drv)
{
        driver_unregister(&drv->driver);
}
EXPORT_SYMBOL(fmc_driver_unregister);

/*
 * When a device set is registered, all eeproms must be read
 * and all FRUs must be parsed
 */
int fmc_device_register_n_gw(struct fmc_device **devs, int n,
                          struct fmc_gateware *gw)
{
        struct fmc_device *fmc, **devarray;
        uint32_t device_id;
        int i, ret = 0;

        if (n < 1)
                return 0;

        /* Check the version of the first data structure (function prints) */
        if (fmc_check_version(devs[0]->version, devs[0]->carrier_name))
                return -EINVAL;

        devarray = kmemdup(devs, n * sizeof(*devs), GFP_KERNEL);
        if (!devarray)
                return -ENOMEM;

        /* Make all other checks before continuing, for all devices */
        for (i = 0; i < n; i++) {
                fmc = devarray[i];
                if (!fmc->hwdev) {
                        pr_err("%s: device nr. %i has no hwdev pointer\n",
                               __func__, i);
                        ret = -EINVAL;
                        break;
                }
                if (fmc->flags & FMC_DEVICE_NO_MEZZANINE) {
                        dev_info(fmc->hwdev, "absent mezzanine in slot %d\n",
                                 fmc->slot_id);
                        continue;
                }
                if (!fmc->eeprom) {
                        dev_err(fmc->hwdev, "no eeprom provided for slot %i\n",
                                fmc->slot_id);
                        ret = -EINVAL;
                }
                if (!fmc->eeprom_addr) {
                        dev_err(fmc->hwdev, "no eeprom_addr for slot %i\n",
                                fmc->slot_id);
                        ret = -EINVAL;
                }
                if (!fmc->carrier_name || !fmc->carrier_data ||
                    !fmc->device_id) {
                        dev_err(fmc->hwdev,
                                "deivce nr %i: carrier name, "
                                "data or dev_id not set\n", i);
                        ret = -EINVAL;
                }
                if (ret)
                        break;

        }
        if (ret) {
                kfree(devarray);
                return ret;
        }

        /* Validation is ok. Now init and register the devices */
        for (i = 0; i < n; i++) {
                fmc = devarray[i];

                fmc->nr_slots = n; /* each slot must know how many are there */
                fmc->devarray = devarray;

                device_initialize(&fmc->dev);
                fmc->dev.release = fmc_release;
                fmc->dev.parent = fmc->hwdev;

                /* Fill the identification stuff (may fail) */
                fmc_fill_id_info(fmc);

                fmc->dev.bus = &fmc_bus_type;

                /* Name from mezzanine info or carrier info. Or 0,1,2.. */
                device_id = fmc->device_id;
                if (!fmc->mezzanine_name)
                        dev_set_name(&fmc->dev, "fmc-%04x", device_id);
                else
                        dev_set_name(&fmc->dev, "%s-%04x", fmc->mezzanine_name,
                                     device_id);

                if (gw) {
                        /*
                         * The carrier already know the bitstream to load
                         * for this set of FMC mezzanines.
                         */
                        ret = fmc->op->reprogram_raw(fmc, NULL,
                                                     gw->bitstream, gw->len);
                        if (ret) {
                                dev_warn(fmc->hwdev,
                                         "Invalid gateware for FMC mezzanine\n");
                                goto out;
                        }
                }

                ret = device_add(&fmc->dev);
                if (ret < 0) {
                        dev_err(fmc->hwdev, "Slot %i: Failed in registering "
                                "\"%s\"\n", fmc->slot_id, fmc->dev.kobj.name);
                        goto out;
                }
                ret = sysfs_create_bin_file(&fmc->dev.kobj, &fmc_eeprom_attr);
                if (ret < 0) {
                        dev_err(&fmc->dev, "Failed in registering eeprom\n");
                        goto out1;
                }
                /* This device went well, give information to the user */
                fmc_dump_eeprom(fmc);
                fmc_debug_init(fmc);
        }
        return 0;

out1:
        device_del(&fmc->dev);
out:
        kfree(devarray);
        for (i--; i >= 0; i--) {
                fmc_debug_exit(devs[i]);
                sysfs_remove_bin_file(&devs[i]->dev.kobj, &fmc_eeprom_attr);
                device_del(&devs[i]->dev);
                fmc_free_id_info(devs[i]);
                put_device(&devs[i]->dev);
        }
        return ret;

}
EXPORT_SYMBOL(fmc_device_register_n_gw);

int fmc_device_register_n(struct fmc_device **devs, int n)
{
        return fmc_device_register_n_gw(devs, n, NULL);
}
EXPORT_SYMBOL(fmc_device_register_n);

int fmc_device_register_gw(struct fmc_device *fmc, struct fmc_gateware *gw)
{
        return fmc_device_register_n_gw(&fmc, 1, gw);
}
EXPORT_SYMBOL(fmc_device_register_gw);

int fmc_device_register(struct fmc_device *fmc)
{
        return fmc_device_register_n(&fmc, 1);
}
EXPORT_SYMBOL(fmc_device_register);

void fmc_device_unregister_n(struct fmc_device **devs, int n)
{
        int i;

        if (n < 1)
                return;

        /* Free devarray first, not used by the later loop */
        kfree(devs[0]->devarray);

        for (i = 0; i < n; i++) {
                fmc_debug_exit(devs[i]);
                sysfs_remove_bin_file(&devs[i]->dev.kobj, &fmc_eeprom_attr);
                device_del(&devs[i]->dev);
                fmc_free_id_info(devs[i]);
                put_device(&devs[i]->dev);
        }
}
EXPORT_SYMBOL(fmc_device_unregister_n);

void fmc_device_unregister(struct fmc_device *fmc)
{
        fmc_device_unregister_n(&fmc, 1);
}
EXPORT_SYMBOL(fmc_device_unregister);

/* Init and exit are trivial */
static int fmc_init(void)
{
        return bus_register(&fmc_bus_type);
}

static void fmc_exit(void)
{
        bus_unregister(&fmc_bus_type);
}

module_init(fmc_init);
module_exit(fmc_exit);

MODULE_LICENSE("GPL");