/*
 * GPIO /dev and configfs interface
 *
 * Copyright (C) 2008 Nias Digital P/L
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/err.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/spinlock.h>
#include <linux/configfs.h>
#include <linux/types.h>
#include <linux/platform_device.h>
#include <linux/poll.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/kfifo.h>

#include <asm/uaccess.h>
#include <asm/bug.h>
#include <asm/gpio.h>

#include "gpio-dev.h"

#define MAX_NR_DEVICES	8
#define IRQ_BUFFER_SIZE	256

#define BUF_PUT_INT(k, b) \
			do { \
				char *p = (char *)&b; \
				kfifo_put(k, p, sizeof(int)); \
			} while (0)

#define BUF_GET_INT(k, b) \
			do { \
				char *p = (char *)&b; \
				kfifo_get(k, p, sizeof(int)); \
			} while (0)

static struct class *dev_class;
static dev_t base_devt;

struct gpiodev {
	spinlock_t lock;

	int id;
	char *bankname;

	struct gpiodev_pin *pins;
	int nr_pins;

	int io_enabled;
	int irq_enabled;

	struct kfifo *irq_buf;
	spinlock_t irq_lock;

	struct device *io_dev;
	struct device *irq_dev;

	/* We can unify these somewhat by doing some fop switching
	 * magic, though I can't convince myself it's worth it*/
	struct cdev io_char_dev;
	struct cdev irq_char_dev;

	wait_queue_head_t irq_wq;
	struct fasync_struct *async_queue;

	struct config_group group;
};

struct gpiodev *devices[MAX_NR_DEVICES];
spinlock_t devices_lock;

static irqreturn_t irq_interrupt(int irq, void *dev_id)
{
	int i, found = 0;
	int gpio = irq_to_gpio(irq);

	struct gpiodev *bank = dev_id;

	for (i = 0; i < bank->nr_pins; i++) {
		if (bank->pins[i].pin == gpio) {
			found = 1;
			break;
		}
	}

	if (!found)
		return IRQ_NONE;

	BUF_PUT_INT(bank->irq_buf, i);

	wake_up_interruptible(&bank->irq_wq);

	if (bank->async_queue)
		kill_fasync(&bank->async_queue, SIGIO, POLL_IN);

	return IRQ_HANDLED;
}


static int io_open(struct inode *inode, struct file *file)
{
	struct gpiodev *bank = container_of(inode->i_cdev,
					      struct gpiodev,
					      io_char_dev);

	spin_lock(&bank->lock);
	config_item_get(&bank->group.cg_item);
	file->private_data = bank;
	spin_unlock(&bank->lock);

	return 0;
}

static int io_release(struct inode *inode, struct file *file)
{
	struct gpiodev *bank = file->private_data;

	spin_lock(&bank->lock);
	config_item_put(&bank->group.cg_item);
	spin_unlock(&bank->lock);

	return 0;
}

static ssize_t io_read(struct file *file, char __user *buf,
			     size_t count, loff_t *offset)
{
	int i, ret = 0;
	char *val;

	struct gpiodev *bank = file->private_data;

	count = min(count, (size_t)(bank->nr_pins - *offset));

	val = kmalloc(sizeof(char) * count, GFP_KERNEL);
	if (!val)
		return -ENOMEM;

	spin_lock(&bank->lock);
	for (i = *offset; i < *offset + count; i++) {
		int pin = bank->pins[i].pin;
		int value;

		if (file->f_flags & O_NONBLOCK)
			value = gpio_get_value(pin);
		else
			value = gpio_get_value_cansleep(pin);

		val[i] = (!!value) + '0';
	}

	*offset += count;
	spin_unlock(&bank->lock);

	if (copy_to_user(buf, val, count))
		ret = -EFAULT;

	kfree(val);
	return ret ? ret : count;
}

static ssize_t io_write(struct file *file, const char __user *buf,
			      size_t count, loff_t *offset)
{
	int i, ret = 0;
	char *val, *p;

	struct gpiodev *bank = file->private_data;

	count = min(count, (size_t)(bank->nr_pins - *offset));

	val = kmalloc(sizeof(char) * count, GFP_KERNEL);
	if (!val)
		return -ENOMEM;

	if (copy_from_user(val, buf, count)) {
		ret = -EFAULT;
		goto out_cpy;
	}

	p = val;

	spin_lock(&bank->lock);

	for (i = *offset; i < *offset + count; i++) {
		int pin = bank->pins[i].pin;
		int value = val[i] - '0';

		if (value != 0 || value != 1)
			break;

		bank->pins[i].outval = value;

		if (file->f_flags & O_NONBLOCK)
			gpio_set_value(pin, value);
		else
			gpio_set_value_cansleep(pin, value);
	}

	*offset = i;

	spin_unlock(&bank->lock);

out_cpy:
	kfree(val);
	return ret ? ret : count;
}

static loff_t io_llseek(struct file *file, loff_t off, int whence)
{
	struct gpiodev *bank = file->private_data;
	loff_t newpos;

	spin_lock(&bank->lock);

	switch (whence) {
	case SEEK_SET:
		newpos = off;
		break;
	case SEEK_CUR:
		newpos = file->f_pos + off;
		break;
	case SEEK_END:
		newpos = bank->nr_pins + off;
		break;
	default:
		return -EINVAL;
	}

	spin_unlock(&bank->lock);

	return newpos;
}

static struct file_operations io_fops = {
	.owner		= THIS_MODULE,
	.llseek		= io_llseek,
	.open		= io_open,
	.release	= io_release,
	.read		= io_read,
	.write		= io_write,
};

static int irq_open(struct inode *inode, struct file *file)
{
	struct gpiodev *bank = container_of(inode->i_cdev,
					      struct gpiodev,
					      io_char_dev);

	nonseekable_open(inode, file);

	spin_lock(&bank->lock);
	config_item_get(&bank->group.cg_item);
	file->private_data = bank;
	spin_unlock(&bank->lock);

	return 0;
}

static int irq_release(struct inode *inode, struct file *file)
{
	struct gpiodev *bank = file->private_data;

	spin_lock(&bank->lock);
	config_item_put(&bank->group.cg_item);
	spin_unlock(&bank->lock);

	return 0;
}

static ssize_t irq_read(struct file *file, char __user *buf,
			     size_t count, loff_t *offset)
{
	int i, len, *kbuf;
	struct gpiodev *bank = file->private_data;

	while (!kfifo_len(bank->irq_buf)) {

		if (file->f_flags & O_NONBLOCK)
			return -EAGAIN;

		if (wait_event_interruptible(bank->irq_wq,
					     kfifo_len(bank->irq_buf)))
			return -ERESTARTSYS;

	}

	len = min((size_t)kfifo_len(bank->irq_buf), count);

	kbuf = kmalloc(len * sizeof(int), GFP_KERNEL);

	if (!kbuf)
		return -ENOMEM;

	for (i = 0; i < len; i++)
		BUF_GET_INT(bank->irq_buf, kbuf[i]);

	if (copy_to_user(buf, kbuf, len)) {
		kfree(kbuf);
		return -EFAULT;
	}

	kfree(kbuf);
	return len;
}

static ssize_t irq_write(struct file *file, const char __user *buf,
			      size_t count, loff_t *offset)
{
	struct gpiodev *bank = file->private_data;

	/* Flush buffer */
	kfifo_reset(bank->irq_buf);

	return count;
}

static int irq_fasync(int fd, struct file *file, int mode)
{
	struct gpiodev *bank = file->private_data;

	return fasync_helper(fd, file, mode, &bank->async_queue);
}

static struct file_operations irq_fops = {
	.owner		= THIS_MODULE,
	.llseek		= no_llseek,
	.open		= irq_open,
	.release	= irq_release,
	.read		= irq_read,
	.write		= irq_write,
	.fasync		= irq_fasync,
};

/*
 * {enable,disable}_bank_{io,irq}() must be called under that bank's
 * lock.  They should only be called through their
 * set_bank_{io,irq}_enabled() which will (amongst other things)
 * take care of this locking for you.
 */
static int enable_bank_io(struct gpiodev *bank)
{
	int i;

	/* What error should a pin request failure be?? */
	int ret = -ENODEV;

	BUG_ON(!bank);

	for (i = 0; i < bank->nr_pins; i++) {
		if (!gpio_request(bank->pins[i].pin, bank->pins[i].label))
			goto err_alloc_pins;
	}

	cdev_init(&bank->io_char_dev, &io_fops);
	bank->io_char_dev.owner = THIS_MODULE;
	ret = cdev_add(&bank->io_char_dev, MKDEV(MAJOR(base_devt),
						 bank->id * 2), 1);

	if (ret < 0)
		goto err_cdev_add;

	bank->io_dev = device_create(dev_class, NULL,
				     MKDEV(MAJOR(base_devt), bank->id * 2),
				     "gpiod-%s", bank->bankname);

	if (IS_ERR(bank->io_dev)) {
		printk(KERN_ERR "gpio-dev: failed to create gpiod%d\n",
		       bank->id);
		ret = PTR_ERR(bank->io_dev);
		goto err_dev;
	}

	printk(KERN_INFO "gpio-dev: created gpiod%d as (%d:%d)\n",
	       bank->id, MAJOR(bank->io_dev->devt),
	       MINOR(bank->io_dev->devt));

	return 0;

err_dev:
	cdev_del(&bank->io_char_dev);
err_cdev_add:
err_alloc_pins:

	while (i--)
		gpio_free(bank->pins[i].pin);

	return ret;
}

static int disable_bank_io(struct gpiodev *bank)
{
	int i;

	BUG_ON(!bank);

	device_unregister(bank->io_dev);
	cdev_del(&bank->io_char_dev);

	for (i = 0; i < bank->nr_pins; i++)
		gpio_free(bank->pins[i].pin);

	return 0;
}

static int set_bank_io_enabled(struct gpiodev *bank, int enabled)
{
	int ret = 0;

	if (!bank) {
		printk(KERN_ERR "gpio-dev: Attempt to change enable " \
				"without valid device binding\n");
		return -EINVAL;
	}

	pr_debug("gpio-dev: setting bank %s enabled from %d to %d\n",
	       bank->bankname, bank->io_enabled, enabled);

	spin_lock(&bank->lock);

	if (bank->io_enabled == enabled)
		goto out;

	if (enabled)
		ret = enable_bank_io(bank);
	else
		ret = disable_bank_io(bank);

	if (!ret)
		bank->io_enabled = enabled;

out:
	spin_unlock(&bank->lock);
	return ret;
}


static int enable_bank_irq(struct gpiodev *bank)
{
	int ret;

	BUG_ON(!bank);

	cdev_init(&bank->irq_char_dev, &irq_fops);
	bank->irq_char_dev.owner = THIS_MODULE;
	ret = cdev_add(&bank->irq_char_dev, MKDEV(MAJOR(base_devt),
						bank->id * 2 + 1), 1);

	if (ret < 0)
		goto err_cdev_add;

	bank->irq_dev = device_create(dev_class, NULL,
					     MKDEV(MAJOR(base_devt), bank->id),
					     "gpioi-%s", bank->bankname);

	if (IS_ERR(bank->irq_dev)) {
		printk(KERN_ERR "gpio-dev: failed to create gpioi%d\n",
		       bank->id);
		ret = PTR_ERR(bank->irq_dev);
		goto err_dev;
	}

	printk(KERN_INFO "gpio-dev: created gpioi%d as (%d:%d)\n",
	       bank->id, MAJOR(bank->irq_dev->devt),
	       MINOR(bank->irq_dev->devt));

	return 0;

err_dev:
	cdev_del(&bank->irq_char_dev);
err_cdev_add:

	return ret;
}

static int disable_bank_irq(struct gpiodev *bank)
{
	BUG_ON(!bank);

	device_unregister(bank->irq_dev);
	cdev_del(&bank->irq_char_dev);

	return 0;
}

static int set_bank_irq_enabled(struct gpiodev *bank, int enabled)
{
	int ret = 0;

	if (!bank) {
		printk(KERN_ERR "gpio-dev: Attempt to change irq enable " \
				"without valid device binding\n");
		return -EINVAL;
	}

	pr_debug("gpio-dev: setting bank irq %s enabled from %d to %d\n",
	       bank->bankname, bank->irq_enabled, enabled);

	spin_lock(&bank->lock);

	if (bank->irq_enabled == enabled)
		goto out;

	if (enabled)
		ret = enable_bank_irq(bank);
	else
		ret = disable_bank_irq(bank);

	if (!ret)
		bank->irq_enabled = enabled;

out:
	spin_unlock(&bank->lock);
	return ret;
}

static inline struct gpiodev *to_gpiodev(struct config_group *group)
{
	return group ? container_of(group, struct gpiodev, group) : NULL;
}

static struct configfs_attribute bank_attr_enableio = {
	.ca_owner = THIS_MODULE,
	.ca_name = "enable-io",
	.ca_mode = S_IRUGO | S_IWUGO,
};

static struct configfs_attribute bank_attr_enableirq = {
	.ca_owner = THIS_MODULE,
	.ca_name = "enable-irq",
	.ca_mode = S_IRUGO | S_IWUGO,
};

static struct configfs_attribute *cfg_bank_attrs[] = {
	&bank_attr_enableio,
	&bank_attr_enableirq,
	NULL,
};

static ssize_t cfg_bank_attr_show(struct config_item *item,
				      struct configfs_attribute *attr,
				      char *page)
{
	struct gpiodev *bank = to_gpiodev(to_config_group(item));

	if (attr == &bank_attr_enableio)
		return sprintf(page, "%d\n", bank->io_enabled);
	else if (attr == &bank_attr_enableirq)
		return sprintf(page, "%d\n", bank->irq_enabled);
	else
		WARN_ON(1);

	return 0;
}

static ssize_t cfg_bank_attr_store(struct config_item *item,
				       struct configfs_attribute *attr,
				       const char *page, size_t count)
{
	struct gpiodev *bank = to_gpiodev(to_config_group(item));

	/* The only attributes which will come here are enable-{io,irq} */

	unsigned long tmp;
	int ret = 0;
	char *p = (char *) page;

	tmp = simple_strtoul(p, &p, 10);
	if (!p || (*p && (*p != '\n')))
		return -EINVAL;

	if (tmp > INT_MAX)
		return -ERANGE;

	/* Booleanize */
	tmp = !!tmp;

	pr_debug("gpio-dev: changing enabled attr on bank %s, attribute %d\n",
	       bank->bankname, (int)attr);

	if (attr == &bank_attr_enableio)
		ret = set_bank_io_enabled(bank, tmp);
	else if (attr == &bank_attr_enableirq)
		ret = set_bank_irq_enabled(bank, tmp);
	else {
		printk(KERN_ERR "unexpected attribute at %s, %d",
			__func__, __LINE__);
		WARN_ON(1);
	}

	return ret ? ret : count;
}

static struct configfs_item_operations cfg_bank_item_ops = {
	.show_attribute		= cfg_bank_attr_show,
	.store_attribute	= cfg_bank_attr_store,
};

static struct config_item_type cfg_bank_type = {
	.ct_owner	= THIS_MODULE,
	.ct_item_ops	= &cfg_bank_item_ops,
	.ct_attrs	= cfg_bank_attrs,
};

static struct config_group *cfg_make_group(struct config_group *group,
						   const char *name)
{
	int i;

	struct gpiodev *dev = NULL;

	spin_lock(&devices_lock);
	for (i = 0; i < MAX_NR_DEVICES; i++) {
		if (!devices[i])
			continue;

		if (strcmp(name, devices[i]->bankname) == 0) {
			dev = devices[i];
			printk(KERN_INFO "gpio-dev: Bound configfs instance" \
			       " to device %s\n", devices[i]->bankname);
		}
	}
	spin_unlock(&devices_lock);

	if (!dev) {
		printk(KERN_WARNING "gpio-dev: Can't find bank \"%s\"\n", name);
		/*
		 * Once I get home and can modify the configfs_mkdir code
		 * to allow more informative return types we can modify this
		 * to, eg, ERR_PTR(-ENODEV)
		 */
		return NULL;
	}

	/*
	 * REVISIT: Do we need to get this here?  The docco says we should drop
	 * a reference in drop_group() so I assume we need to actually get one
	 * at one stage
	 */
	config_item_get(&dev->group.cg_item);

	return &dev->group;
}

static void cfg_drop_group(struct config_group *group,
				   struct config_item *item)
{
	struct gpiodev *bank = to_gpiodev(to_config_group(item));

	pr_debug("gpio-dev: bank %s getting dropped\n",
	       bank->bankname);

	set_bank_io_enabled(bank, 0);
	set_bank_irq_enabled(bank, 0);

	config_item_put(item);
}

static struct configfs_attribute attr_banks = {
	.ca_owner = THIS_MODULE,
	.ca_name = "banks",
	.ca_mode = S_IRUGO,
};

static struct configfs_attribute *cfg_attrs[] = {
	&attr_banks,
	NULL,
};

static ssize_t cfg_attr_show(struct config_item *item,
					struct configfs_attribute *attr,
					char *page)
{
	int i;
	int count = 0;

	/* The only attribute which comes here is 'banks' */

	spin_lock(&devices_lock);
	for (i = 0; i < MAX_NR_DEVICES; i++) {
		if (devices[i])
			count += sprintf(page + count, "%s\n",
					 devices[i]->bankname);
	}
	spin_unlock(&devices_lock);

	return count;
}

static struct configfs_item_operations cfg_item_ops = {
	.show_attribute	= cfg_attr_show,
};

static struct configfs_group_operations cfg_group_ops = {
	.make_group	= cfg_make_group,
	.drop_item	= cfg_drop_group,
};

static struct config_item_type cfg_type = {
	.ct_item_ops	= &cfg_item_ops,
	.ct_group_ops	= &cfg_group_ops,
	.ct_attrs	= cfg_attrs,
	.ct_owner	= THIS_MODULE,
};

static struct configfs_subsystem cfg_subsys = {
	.su_group = {
		.cg_item = {
			.ci_namebuf = "gpio-dev",
			.ci_type = &cfg_type,
		},
	},
};


static struct configfs_attribute pin_attr_index = {
	.ca_owner = THIS_MODULE,
	.ca_name = "index",
	.ca_mode = S_IRUGO,
};

static struct configfs_attribute pin_attr_direction = {
	.ca_owner = THIS_MODULE,
	.ca_name = "direction",
	.ca_mode = S_IRUGO | S_IWUGO,
};

static struct configfs_attribute pin_attr_irq = {
	.ca_owner = THIS_MODULE,
	.ca_name = "irq",
	.ca_mode = S_IRUGO | S_IWUGO,
};

static struct configfs_attribute *pin_attrs[] = {
	&pin_attr_index,
	&pin_attr_direction,
	&pin_attr_irq,
	NULL,
};

static inline struct gpiodev_pin *to_gpiodev_pin(struct config_group *group)
{
	return group ? container_of(group, struct gpiodev_pin, group) : NULL;
}

static ssize_t pin_show(struct config_item *item,
				      struct configfs_attribute *attr,
				      char *page)
{
	struct gpiodev_pin *pin = to_gpiodev_pin(to_config_group(item));

	/* All attributes for a pin come here */

	if (attr == &pin_attr_index)
		return sprintf(page, "%d\n", pin->index);
	else if (attr == &pin_attr_direction)
		return sprintf(page, "%d\n", pin->direction);
	else if (attr == &pin_attr_irq)
		return sprintf(page, "%d\n", pin->irq);
	else {
		printk(KERN_ERR "gpio-dev: Unexpected attribute in %s\n",
		       __func__);
		return 0;
	}
}

static ssize_t pin_store(struct config_item *item,
				 struct configfs_attribute *attr,
				 const char *page, size_t count)
{
	struct gpiodev_pin *pin = to_gpiodev_pin(to_config_group(item));
	char *p = (char *)page;
	int val;
	int ret = 0;

	val = simple_strtoul(p, &p, 0);
	if (!p || (*p && (*p != '\n')))
		return -EINVAL;

	if (attr == &pin_attr_direction) {
		pin->direction = val;

		if (val)
			gpio_direction_output(pin->pin, pin->outval);
		else
			gpio_direction_input(pin->pin);


	} else if (attr == &pin_attr_irq) {

		if (!pin->irq && val) {
			ret = request_irq(gpio_to_irq(pin->pin), irq_interrupt,
					  0, "gpio-dev", pin);
			if (ret)
				return ret;
		} else if (pin->irq && !val) {
			free_irq(gpio_to_irq(pin->pin), pin);
		}

		pin->irq = val;

		/*
		 * The values written by the user directly correspond to
		 * the values behind the IRQF_TRIGGER_* tokens.  Can we
		 * rely on this or should we explicitly check and set each
		 * possible trigger type?
		 */
		if (val)
			ret = set_irq_type(gpio_to_irq(pin->pin), val);

		if (ret)
			return -EINVAL;

	} else {
		printk(KERN_ERR "gpio-dev: Unexpected attribute in %s\n",
		       __func__);
	}

	return count;
}

static struct configfs_item_operations pin_ops = {
	.show_attribute = pin_show,
	.store_attribute = pin_store,
};

static struct config_item_type cfg_pin_type = {
	.ct_owner	= THIS_MODULE,
	.ct_attrs	= pin_attrs,
	.ct_item_ops	= &pin_ops,
};

static int __init gpiodev_probe(struct platform_device *pdev)
{
	int i, ret;
	struct gpiodev *bank = NULL;
	struct device *dev = &pdev->dev;
	struct gpiodev_pdata *pdata = dev->platform_data;

	if (!pdata) {
		printk(KERN_ERR "gpio-dev: No configuration data available; "\
			"aborting probe.");
		return -EINVAL;
	}

	bank = kzalloc(sizeof(struct gpiodev), GFP_KERNEL);
	if (!bank)
		return -ENOMEM;

	spin_lock_init(&bank->lock);
	spin_lock_init(&bank->irq_lock);

	bank->bankname = pdata->bankname;
	bank->nr_pins = pdata->nr_pins;

	bank->pins = kmalloc(bank->nr_pins * sizeof(struct gpiodev_pin),
			     GFP_KERNEL);

	if (!bank->pins) {
		ret = -ENOMEM;
		goto err_pin_alloc;
	}

	bank->irq_buf = kfifo_alloc(IRQ_BUFFER_SIZE, GFP_KERNEL,
				    &bank->irq_lock);

	if (IS_ERR(bank->irq_buf)) {
		ret = PTR_ERR(bank->irq_buf);
		goto err_irq_buf_alloc;
	}

	memcpy(bank->pins, pdata->pins,
	       bank->nr_pins * sizeof(struct gpiodev_pin));

	pr_debug("gpio-dev: initing device group %s\n", bank->bankname);

	config_group_init_type_name(&bank->group, bank->bankname,
				    &cfg_bank_type);

	bank->group.default_groups = kzalloc(sizeof(struct config_group)
					     * bank->nr_pins, GFP_KERNEL);

	if (!bank->group.default_groups) {
		ret = -ENOMEM;
		goto err_group_alloc;
	}

	for (i = 0; i < bank->nr_pins; i++) {
		pr_debug("gpio-dev: initing pin %s on bank %s\n",
			bank->pins[i].label, bank->bankname);
		config_group_init_type_name(&bank->pins[i].group,
			bank->pins[i].label, &cfg_pin_type);
		bank->group.default_groups[i] = &bank->pins[i].group;
	}

	bank->io_enabled = 0;
	bank->irq_enabled = 0;

	platform_set_drvdata(pdev, bank);

	bank->id = -1;

	/* Find first empty slot */
	spin_lock(&devices_lock);
	for (i = 0; i < MAX_NR_DEVICES; i++) {
		if (devices[i] == NULL) {
			devices[i] = bank;
			bank->id = i;
			break;
		}
	}
	spin_unlock(&devices_lock);

	if (bank->id == -1) {
		printk(KERN_ERR "gpio-dev: More than MAX_NR_DEVICES probed;"\
				" no free slots found!");
		ret = -ENODEV;
		goto err_no_slot;
	}

	return 0;

err_no_slot:
	kfree(bank->group.default_groups);
err_group_alloc:
	kfifo_free(bank->irq_buf);
err_irq_buf_alloc:
	kfree(bank->pins);
err_pin_alloc:
	kfree(bank);

	return ret;
}

static int __exit gpiodev_remove(struct platform_device *pdev)
{
	struct gpiodev *bank = platform_get_drvdata(pdev);

	spin_lock(&devices_lock);
	devices[bank->id] = NULL;
	spin_unlock(&devices_lock);

	kfifo_free(bank->irq_buf);

	kfree(bank->pins);
	kfree(bank);

	return 0;
}

static struct platform_driver gpiodev_driver = {
	.driver		= {
		.name	= "gpio-dev",
		.owner	= THIS_MODULE,
	},
	.remove		= __exit_p(gpiodev_remove),
	.probe		= gpiodev_probe,
};

static int __init gpiodev_init(void)
{
	int ret;

	spin_lock_init(&devices_lock);

	dev_class = class_create(THIS_MODULE, "gpio-dev");
	if (IS_ERR(dev_class)) {
		ret = PTR_ERR(dev_class);
		goto err_class_create;
	}

	ret = alloc_chrdev_region(&base_devt, 0, MAX_NR_DEVICES * 2, "gpio-dev");
	if (ret < 0)
		goto err_alloc_chrdev;

	pr_debug("gpio-dev: Registering configfs subsystem %s\n",
		cfg_subsys.su_group.cg_item.ci_namebuf);
	config_group_init(&cfg_subsys.su_group);
	mutex_init(&cfg_subsys.su_mutex);
	ret = configfs_register_subsystem(&cfg_subsys);
	if (ret) {
		printk(KERN_ERR "Error %d while registering subsystem %s\n",
		       ret,
		       cfg_subsys.su_group.cg_item.ci_namebuf);
		goto err_subsys;
	}


	ret = platform_driver_register(&gpiodev_driver);
	if (ret)
		goto err_dev_register;

	return 0;

err_dev_register:
	configfs_unregister_subsystem(&cfg_subsys);
err_subsys:
	unregister_chrdev_region(base_devt, MAX_NR_DEVICES);
err_alloc_chrdev:
	class_destroy(dev_class);
err_class_create:
	printk(KERN_ALERT "gpio-dev: Failed to init gpio-dev interface\n");
	return ret;
}

static void __exit gpiodev_exit(void)
{
	platform_driver_unregister(&gpiodev_driver);

	configfs_unregister_subsystem(&cfg_subsys);

	unregister_chrdev_region(base_devt, MAX_NR_DEVICES * 2);

	class_destroy(dev_class);

	printk(KERN_INFO "gpio-dev: unloaded gpio-dev\n");
}

module_init(gpiodev_init);
module_exit(gpiodev_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Ben Nizette <bn@niasdigital.com>");
MODULE_DESCRIPTION("Userspace interface to the gpio framework");