[linux-2.6-block.git] / drivers / gpio / gpio-mockup.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * GPIO Testing Device Driver
 *
 * Copyright (C) 2014  Kamlakant Patel <kamlakant.patel@broadcom.com>
 * Copyright (C) 2015-2016  Bamvor Jian Zhang <bamv2005@gmail.com>
 * Copyright (C) 2017 Bartosz Golaszewski <brgl@bgdev.pl>
 */

#include <linux/init.h>
#include <linux/module.h>
#include <linux/gpio/driver.h>
#include <linux/gpio/consumer.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/irq_sim.h>
#include <linux/debugfs.h>
#include <linux/uaccess.h>
#include <linux/property.h>

#include "gpiolib.h"

#define GPIO_MOCKUP_NAME	"gpio-mockup"
#define GPIO_MOCKUP_MAX_GC	10
/*
 * We're storing two values per chip: the GPIO base and the number
 * of GPIO lines.
 */
#define GPIO_MOCKUP_MAX_RANGES	(GPIO_MOCKUP_MAX_GC * 2)
/* Maximum of three properties + the sentinel. */
#define GPIO_MOCKUP_MAX_PROP	4

#define gpio_mockup_err(...)	pr_err(GPIO_MOCKUP_NAME ": " __VA_ARGS__)

enum {
	GPIO_MOCKUP_DIR_OUT = 0,
	GPIO_MOCKUP_DIR_IN = 1,
};

/*
 * struct gpio_pin_status - structure describing a GPIO status
 * @dir:       Configures direction of gpio as "in" or "out", 0=in, 1=out
 * @value:     Configures status of the gpio as 0(low) or 1(high)
 */
struct gpio_mockup_line_status {
	int dir;
	int value;
};

struct gpio_mockup_chip {
	struct gpio_chip gc;
	struct gpio_mockup_line_status *lines;
	struct irq_sim irqsim;
	struct dentry *dbg_dir;
};

struct gpio_mockup_dbgfs_private {
	struct gpio_mockup_chip *chip;
	struct gpio_desc *desc;
	int offset;
};

static int gpio_mockup_ranges[GPIO_MOCKUP_MAX_RANGES];
static int gpio_mockup_num_ranges;
module_param_array(gpio_mockup_ranges, int, &gpio_mockup_num_ranges, 0400);

static bool gpio_mockup_named_lines;
module_param_named(gpio_mockup_named_lines,
		   gpio_mockup_named_lines, bool, 0400);

static struct dentry *gpio_mockup_dbg_dir;

static int gpio_mockup_range_base(unsigned int index)
{
	return gpio_mockup_ranges[index * 2];
}

static int gpio_mockup_range_ngpio(unsigned int index)
{
	return gpio_mockup_ranges[index * 2 + 1];
}

static int gpio_mockup_get(struct gpio_chip *gc, unsigned int offset)
{
	struct gpio_mockup_chip *chip = gpiochip_get_data(gc);

	return chip->lines[offset].value;
}

static void gpio_mockup_set(struct gpio_chip *gc,
			    unsigned int offset, int value)
{
	struct gpio_mockup_chip *chip = gpiochip_get_data(gc);

	chip->lines[offset].value = !!value;
}

static void gpio_mockup_set_multiple(struct gpio_chip *gc,
				     unsigned long *mask, unsigned long *bits)
{
	unsigned int bit;

	for_each_set_bit(bit, mask, gc->ngpio)
		gpio_mockup_set(gc, bit, test_bit(bit, bits));

}

static int gpio_mockup_dirout(struct gpio_chip *gc,
			      unsigned int offset, int value)
{
	struct gpio_mockup_chip *chip = gpiochip_get_data(gc);

	gpio_mockup_set(gc, offset, value);
	chip->lines[offset].dir = GPIO_MOCKUP_DIR_OUT;

	return 0;
}

static int gpio_mockup_dirin(struct gpio_chip *gc, unsigned int offset)
{
	struct gpio_mockup_chip *chip = gpiochip_get_data(gc);

	chip->lines[offset].dir = GPIO_MOCKUP_DIR_IN;

	return 0;
}

static int gpio_mockup_get_direction(struct gpio_chip *gc, unsigned int offset)
{
	struct gpio_mockup_chip *chip = gpiochip_get_data(gc);

	return chip->lines[offset].dir;
}

static int gpio_mockup_to_irq(struct gpio_chip *gc, unsigned int offset)
{
	struct gpio_mockup_chip *chip = gpiochip_get_data(gc);

	return irq_sim_irqnum(&chip->irqsim, offset);
}

static ssize_t gpio_mockup_event_write(struct file *file,
				       const char __user *usr_buf,
				       size_t size, loff_t *ppos)
{
	struct gpio_mockup_dbgfs_private *priv;
	struct gpio_mockup_chip *chip;
	struct seq_file *sfile;
	struct gpio_desc *desc;
	int rv, val;

	rv = kstrtoint_from_user(usr_buf, size, 0, &val);
	if (rv)
		return rv;
	if (val != 0 && val != 1)
		return -EINVAL;

	sfile = file->private_data;
	priv = sfile->private;
	desc = priv->desc;
	chip = priv->chip;

	gpiod_set_value_cansleep(desc, val);
	irq_sim_fire(&chip->irqsim, priv->offset);

	return size;
}

static int gpio_mockup_event_open(struct inode *inode, struct file *file)
{
	return single_open(file, NULL, inode->i_private);
}

static const struct file_operations gpio_mockup_event_ops = {
	.owner = THIS_MODULE,
	.open = gpio_mockup_event_open,
	.write = gpio_mockup_event_write,
	.llseek = no_llseek,
};

static void gpio_mockup_debugfs_setup(struct device *dev,
				      struct gpio_mockup_chip *chip)
{
	struct gpio_mockup_dbgfs_private *priv;
	struct dentry *evfile, *link;
	struct gpio_chip *gc;
	const char *devname;
	char *name;
	int i;

	gc = &chip->gc;
	devname = dev_name(&gc->gpiodev->dev);

	chip->dbg_dir = debugfs_create_dir(devname, gpio_mockup_dbg_dir);
	if (IS_ERR_OR_NULL(chip->dbg_dir))
		goto err;

	link = debugfs_create_symlink(gc->label, gpio_mockup_dbg_dir, devname);
	if (IS_ERR_OR_NULL(link))
		goto err;

	for (i = 0; i < gc->ngpio; i++) {
		name = devm_kasprintf(dev, GFP_KERNEL, "%d", i);
		if (!name)
			goto err;

		priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
		if (!priv)
			goto err;

		priv->chip = chip;
		priv->offset = i;
		priv->desc = &gc->gpiodev->descs[i];

		evfile = debugfs_create_file(name, 0200, chip->dbg_dir, priv,
					     &gpio_mockup_event_ops);
		if (IS_ERR_OR_NULL(evfile))
			goto err;
	}

	return;

err:
	dev_err(dev, "error creating debugfs event files\n");
}

static int gpio_mockup_name_lines(struct device *dev,
				  struct gpio_mockup_chip *chip)
{
	struct gpio_chip *gc = &chip->gc;
	char **names;
	int i;

	names = devm_kcalloc(dev, gc->ngpio, sizeof(char *), GFP_KERNEL);
	if (!names)
		return -ENOMEM;

	for (i = 0; i < gc->ngpio; i++) {
		names[i] = devm_kasprintf(dev, GFP_KERNEL,
					  "%s-%d", gc->label, i);
		if (!names[i])
			return -ENOMEM;
	}

	gc->names = (const char *const *)names;

	return 0;
}

static int gpio_mockup_probe(struct platform_device *pdev)
{
	struct gpio_mockup_chip *chip;
	struct gpio_chip *gc;
	struct device *dev;
	const char *name;
	int rv, base;
	u16 ngpio;

	dev = &pdev->dev;

	rv = device_property_read_u32(dev, "gpio-base", &base);
	if (rv)
		base = -1;

	rv = device_property_read_u16(dev, "nr-gpios", &ngpio);
	if (rv)
		return rv;

	rv = device_property_read_string(dev, "chip-name", &name);
	if (rv)
		name = NULL;

	chip = devm_kzalloc(dev, sizeof(*chip), GFP_KERNEL);
	if (!chip)
		return -ENOMEM;

	if (!name) {
		name = devm_kasprintf(dev, GFP_KERNEL,
				      "%s-%c", pdev->name, pdev->id + 'A');
		if (!name)
			return -ENOMEM;
	}

	gc = &chip->gc;
	gc->base = base;
	gc->ngpio = ngpio;
	gc->label = name;
	gc->owner = THIS_MODULE;
	gc->parent = dev;
	gc->get = gpio_mockup_get;
	gc->set = gpio_mockup_set;
	gc->set_multiple = gpio_mockup_set_multiple;
	gc->direction_output = gpio_mockup_dirout;
	gc->direction_input = gpio_mockup_dirin;
	gc->get_direction = gpio_mockup_get_direction;
	gc->to_irq = gpio_mockup_to_irq;

	chip->lines = devm_kcalloc(dev, gc->ngpio,
				   sizeof(*chip->lines), GFP_KERNEL);
	if (!chip->lines)
		return -ENOMEM;

	if (device_property_read_bool(dev, "named-gpio-lines")) {
		rv = gpio_mockup_name_lines(dev, chip);
		if (rv)
			return rv;
	}

	rv = devm_irq_sim_init(dev, &chip->irqsim, gc->ngpio);
	if (rv < 0)
		return rv;

	rv = devm_gpiochip_add_data(dev, &chip->gc, chip);
	if (rv)
		return rv;

	if (!IS_ERR_OR_NULL(gpio_mockup_dbg_dir))
		gpio_mockup_debugfs_setup(dev, chip);

	return 0;
}

static struct platform_driver gpio_mockup_driver = {
	.driver = {
		.name = GPIO_MOCKUP_NAME,
	},
	.probe = gpio_mockup_probe,
};

static struct platform_device *gpio_mockup_pdevs[GPIO_MOCKUP_MAX_GC];

static void gpio_mockup_unregister_pdevs(void)
{
	struct platform_device *pdev;
	int i;

	for (i = 0; i < GPIO_MOCKUP_MAX_GC; i++) {
		pdev = gpio_mockup_pdevs[i];

		if (pdev)
			platform_device_unregister(pdev);
	}
}

static int __init gpio_mockup_init(void)
{
	struct property_entry properties[GPIO_MOCKUP_MAX_PROP];
	int i, prop, num_chips, err = 0, base;
	struct platform_device_info pdevinfo;
	struct platform_device *pdev;
	u16 ngpio;

	if ((gpio_mockup_num_ranges < 2) ||
	    (gpio_mockup_num_ranges % 2) ||
	    (gpio_mockup_num_ranges > GPIO_MOCKUP_MAX_RANGES))
		return -EINVAL;

	/* Each chip is described by two values. */
	num_chips = gpio_mockup_num_ranges / 2;

	/*
	 * The second value in the <base GPIO - number of GPIOS> pair must
	 * always be greater than 0.
	 */
	for (i = 0; i < num_chips; i++) {
		if (gpio_mockup_range_ngpio(i) < 0)
			return -EINVAL;
	}

	gpio_mockup_dbg_dir = debugfs_create_dir("gpio-mockup-event", NULL);
	if (IS_ERR_OR_NULL(gpio_mockup_dbg_dir))
		gpio_mockup_err("error creating debugfs directory\n");

	err = platform_driver_register(&gpio_mockup_driver);
	if (err) {
		gpio_mockup_err("error registering platform driver\n");
		return err;
	}

	for (i = 0; i < num_chips; i++) {
		memset(properties, 0, sizeof(properties));
		memset(&pdevinfo, 0, sizeof(pdevinfo));
		prop = 0;

		base = gpio_mockup_range_base(i);
		if (base >= 0)
			properties[prop++] = PROPERTY_ENTRY_U32("gpio-base",
								base);

		ngpio = base < 0 ? gpio_mockup_range_ngpio(i)
				 : gpio_mockup_range_ngpio(i) - base;
		properties[prop++] = PROPERTY_ENTRY_U16("nr-gpios", ngpio);

		if (gpio_mockup_named_lines)
			properties[prop++] = PROPERTY_ENTRY_BOOL(
						"named-gpio-lines");

		pdevinfo.name = GPIO_MOCKUP_NAME;
		pdevinfo.id = i;
		pdevinfo.properties = properties;

		pdev = platform_device_register_full(&pdevinfo);
		if (IS_ERR(pdev)) {
			gpio_mockup_err("error registering device");
			platform_driver_unregister(&gpio_mockup_driver);
			gpio_mockup_unregister_pdevs();
			return PTR_ERR(pdev);
		}

		gpio_mockup_pdevs[i] = pdev;
	}

	return 0;
}

static void __exit gpio_mockup_exit(void)
{
	debugfs_remove_recursive(gpio_mockup_dbg_dir);
	platform_driver_unregister(&gpio_mockup_driver);
	gpio_mockup_unregister_pdevs();
}

module_init(gpio_mockup_init);
module_exit(gpio_mockup_exit);

MODULE_AUTHOR("Kamlakant Patel <kamlakant.patel@broadcom.com>");
MODULE_AUTHOR("Bamvor Jian Zhang <bamv2005@gmail.com>");
MODULE_AUTHOR("Bartosz Golaszewski <brgl@bgdev.pl>");
MODULE_DESCRIPTION("GPIO Testing driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
058de348	1	// SPDX-License-Identifier: GPL-2.0+
0f98dd1b BJZ	2	/*
	3	* GPIO Testing Device Driver
	4	*
	5	* Copyright (C) 2014 Kamlakant Patel <kamlakant.patel@broadcom.com>
4f9a4cd6	6	* Copyright (C) 2015-2016 Bamvor Jian Zhang <bamv2005@gmail.com>
c60c7f4c	7	* Copyright (C) 2017 Bartosz Golaszewski <brgl@bgdev.pl>
0f98dd1b BJZ	8	*/
	9
	10	#include <linux/init.h>
	11	#include <linux/module.h>
	12	#include <linux/gpio/driver.h>
9202ba23	13	#include <linux/gpio/consumer.h>
0f98dd1b	14	#include <linux/platform_device.h>
8a68ea00	15	#include <linux/slab.h>
e2ff7408 BG	16	#include <linux/interrupt.h>
e2ff7408 BG	17	#include <linux/irq.h>
b4c495f0	18	#include <linux/irq_sim.h>
9202ba23 BG	19	#include <linux/debugfs.h>
9202ba23 BG	20	#include <linux/uaccess.h>
3ea47b44	21	#include <linux/property.h>
9202ba23 BG	22
9202ba23 BG	23	#include "gpiolib.h"
0f98dd1b	24
ca409160	25	#define GPIO_MOCKUP_NAME "gpio-mockup"
b9576d03	26	#define GPIO_MOCKUP_MAX_GC 10
b652336d BG	27	/*
	28	* We're storing two values per chip: the GPIO base and the number
	29	* of GPIO lines.
	30	*/
	31	#define GPIO_MOCKUP_MAX_RANGES (GPIO_MOCKUP_MAX_GC * 2)
3ea47b44 BG	32	/* Maximum of three properties + the sentinel. */
3ea47b44 BG	33	#define GPIO_MOCKUP_MAX_PROP 4
0f98dd1b	34
f1bec99a BG	35	#define gpio_mockup_err(...) pr_err(GPIO_MOCKUP_NAME ": " __VA_ARGS__)
f1bec99a BG	36
ca409160	37	enum {
c650c00c BG	38	GPIO_MOCKUP_DIR_OUT = 0,
c650c00c BG	39	GPIO_MOCKUP_DIR_IN = 1,
0f98dd1b BJZ	40	};
	41
	42	/*
	43	* struct gpio_pin_status - structure describing a GPIO status
	44	* @dir: Configures direction of gpio as "in" or "out", 0=in, 1=out
	45	* @value: Configures status of the gpio as 0(low) or 1(high)
	46	*/
ca409160 BG	47	struct gpio_mockup_line_status {
ca409160 BG	48	int dir;
5b7908c0	49	int value;
e2ff7408 BG	50	};
e2ff7408 BG	51
ca409160	52	struct gpio_mockup_chip {
0f98dd1b	53	struct gpio_chip gc;
ca409160	54	struct gpio_mockup_line_status *lines;
b4c495f0	55	struct irq_sim irqsim;
9202ba23 BG	56	struct dentry *dbg_dir;
	57	};
	58
	59	struct gpio_mockup_dbgfs_private {
	60	struct gpio_mockup_chip *chip;
	61	struct gpio_desc *desc;
	62	int offset;
0f98dd1b BJZ	63	};
0f98dd1b BJZ	64
b652336d	65	static int gpio_mockup_ranges[GPIO_MOCKUP_MAX_RANGES];
e63a006f BG	66	static int gpio_mockup_num_ranges;
e63a006f BG	67	module_param_array(gpio_mockup_ranges, int, &gpio_mockup_num_ranges, 0400);
0f98dd1b	68
8a68ea00 BG	69	static bool gpio_mockup_named_lines;
	70	module_param_named(gpio_mockup_named_lines,
	71	gpio_mockup_named_lines, bool, 0400);
	72
9202ba23	73	static struct dentry *gpio_mockup_dbg_dir;
0f98dd1b	74
cd9835f1 BG	75	static int gpio_mockup_range_base(unsigned int index)
	76	{
	77	return gpio_mockup_ranges[index * 2];
	78	}
	79
	80	static int gpio_mockup_range_ngpio(unsigned int index)
	81	{
	82	return gpio_mockup_ranges[index * 2 + 1];
	83	}
	84
ca409160	85	static int gpio_mockup_get(struct gpio_chip *gc, unsigned int offset)
0f98dd1b	86	{
ca409160	87	struct gpio_mockup_chip *chip = gpiochip_get_data(gc);
0f98dd1b	88
ca409160	89	return chip->lines[offset].value;
0f98dd1b BJZ	90	}
0f98dd1b BJZ	91
2a9d742c BG	92	static void gpio_mockup_set(struct gpio_chip *gc,
2a9d742c BG	93	unsigned int offset, int value)
0f98dd1b	94	{
ca409160	95	struct gpio_mockup_chip *chip = gpiochip_get_data(gc);
0f98dd1b	96
ca409160	97	chip->lines[offset].value = !!value;
0f98dd1b BJZ	98	}
0f98dd1b BJZ	99
c47bee95 BG	100	static void gpio_mockup_set_multiple(struct gpio_chip *gc,
	101	unsigned long mask, unsigned long bits)
	102	{
	103	unsigned int bit;
	104
	105	for_each_set_bit(bit, mask, gc->ngpio)
	106	gpio_mockup_set(gc, bit, test_bit(bit, bits));
	107
	108	}
	109
2a9d742c BG	110	static int gpio_mockup_dirout(struct gpio_chip *gc,
2a9d742c BG	111	unsigned int offset, int value)
0f98dd1b	112	{
ca409160 BG	113	struct gpio_mockup_chip *chip = gpiochip_get_data(gc);
	114
	115	gpio_mockup_set(gc, offset, value);
c650c00c	116	chip->lines[offset].dir = GPIO_MOCKUP_DIR_OUT;
0f98dd1b	117
0f98dd1b BJZ	118	return 0;
	119	}
	120
ca409160	121	static int gpio_mockup_dirin(struct gpio_chip *gc, unsigned int offset)
0f98dd1b	122	{
ca409160 BG	123	struct gpio_mockup_chip *chip = gpiochip_get_data(gc);
ca409160 BG	124
c650c00c	125	chip->lines[offset].dir = GPIO_MOCKUP_DIR_IN;
0f98dd1b	126
0f98dd1b BJZ	127	return 0;
	128	}
	129
ca409160	130	static int gpio_mockup_get_direction(struct gpio_chip *gc, unsigned int offset)
0f98dd1b	131	{
ca409160	132	struct gpio_mockup_chip *chip = gpiochip_get_data(gc);
0f98dd1b	133
ca409160	134	return chip->lines[offset].dir;
0f98dd1b BJZ	135	}
0f98dd1b BJZ	136
b4c495f0	137	static int gpio_mockup_to_irq(struct gpio_chip *gc, unsigned int offset)
c7f5326f	138	{
c7f5326f BG	139	struct gpio_mockup_chip *chip = gpiochip_get_data(gc);
c7f5326f BG	140
b4c495f0	141	return irq_sim_irqnum(&chip->irqsim, offset);
e2ff7408 BG	142	}
e2ff7408 BG	143
9202ba23 BG	144	static ssize_t gpio_mockup_event_write(struct file *file,
	145	const char __user *usr_buf,
	146	size_t size, loff_t *ppos)
	147	{
	148	struct gpio_mockup_dbgfs_private *priv;
	149	struct gpio_mockup_chip *chip;
	150	struct seq_file *sfile;
	151	struct gpio_desc *desc;
6f9b3e77	152	int rv, val;
9202ba23	153
6f9b3e77 BG	154	rv = kstrtoint_from_user(usr_buf, size, 0, &val);
	155	if (rv)
	156	return rv;
	157	if (val != 0 && val != 1)
	158	return -EINVAL;
	159
650b57b0 BG	160	sfile = file->private_data;
	161	priv = sfile->private;
	162	desc = priv->desc;
	163	chip = priv->chip;
c7f5326f	164
b4c495f0 BG	165	gpiod_set_value_cansleep(desc, val);
b4c495f0 BG	166	irq_sim_fire(&chip->irqsim, priv->offset);
9202ba23 BG	167
	168	return size;
	169	}
	170
	171	static int gpio_mockup_event_open(struct inode inode, struct file file)
	172	{
	173	return single_open(file, NULL, inode->i_private);
	174	}
	175
	176	static const struct file_operations gpio_mockup_event_ops = {
	177	.owner = THIS_MODULE,
	178	.open = gpio_mockup_event_open,
	179	.write = gpio_mockup_event_write,
	180	.llseek = no_llseek,
	181	};
	182
	183	static void gpio_mockup_debugfs_setup(struct device *dev,
	184	struct gpio_mockup_chip *chip)
	185	{
	186	struct gpio_mockup_dbgfs_private *priv;
ca8792af	187	struct dentry evfile, link;
9202ba23	188	struct gpio_chip *gc;
ca8792af	189	const char *devname;
9202ba23 BG	190	char *name;
	191	int i;
	192
	193	gc = &chip->gc;
ca8792af	194	devname = dev_name(&gc->gpiodev->dev);
9202ba23	195
ca8792af	196	chip->dbg_dir = debugfs_create_dir(devname, gpio_mockup_dbg_dir);
46526c15	197	if (IS_ERR_OR_NULL(chip->dbg_dir))
9202ba23 BG	198	goto err;
9202ba23 BG	199
ca8792af	200	link = debugfs_create_symlink(gc->label, gpio_mockup_dbg_dir, devname);
46526c15	201	if (IS_ERR_OR_NULL(link))
ca8792af BG	202	goto err;
ca8792af BG	203
9202ba23 BG	204	for (i = 0; i < gc->ngpio; i++) {
	205	name = devm_kasprintf(dev, GFP_KERNEL, "%d", i);
	206	if (!name)
	207	goto err;
	208
	209	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
	210	if (!priv)
	211	goto err;
	212
	213	priv->chip = chip;
	214	priv->offset = i;
	215	priv->desc = &gc->gpiodev->descs[i];
	216
	217	evfile = debugfs_create_file(name, 0200, chip->dbg_dir, priv,
	218	&gpio_mockup_event_ops);
46526c15	219	if (IS_ERR_OR_NULL(evfile))
9202ba23 BG	220	goto err;
	221	}
	222
	223	return;
	224
	225	err:
46526c15	226	dev_err(dev, "error creating debugfs event files\n");
9202ba23 BG	227	}
9202ba23 BG	228
1cea4734 BG	229	static int gpio_mockup_name_lines(struct device *dev,
	230	struct gpio_mockup_chip *chip)
	231	{
	232	struct gpio_chip *gc = &chip->gc;
	233	char **names;
	234	int i;
	235
	236	names = devm_kcalloc(dev, gc->ngpio, sizeof(char *), GFP_KERNEL);
	237	if (!names)
	238	return -ENOMEM;
	239
	240	for (i = 0; i < gc->ngpio; i++) {
	241	names[i] = devm_kasprintf(dev, GFP_KERNEL,
	242	"%s-%d", gc->label, i);
	243	if (!names[i])
	244	return -ENOMEM;
	245	}
	246
	247	gc->names = (const char const )names;
	248
	249	return 0;
	250	}
	251
6d974d32	252	static int gpio_mockup_probe(struct platform_device *pdev)
0f98dd1b	253	{
6d974d32 BG	254	struct gpio_mockup_chip *chip;
6d974d32 BG	255	struct gpio_chip *gc;
6d974d32	256	struct device *dev;
3ea47b44 BG	257	const char *name;
	258	int rv, base;
	259	u16 ngpio;
6d974d32 BG	260
6d974d32 BG	261	dev = &pdev->dev;
3ea47b44 BG	262
	263	rv = device_property_read_u32(dev, "gpio-base", &base);
	264	if (rv)
	265	base = -1;
	266
	267	rv = device_property_read_u16(dev, "nr-gpios", &ngpio);
	268	if (rv)
	269	return rv;
	270
	271	rv = device_property_read_string(dev, "chip-name", &name);
	272	if (rv)
	273	name = NULL;
6d974d32 BG	274
	275	chip = devm_kzalloc(dev, sizeof(*chip), GFP_KERNEL);
	276	if (!chip)
	277	return -ENOMEM;
	278
3ea47b44 BG	279	if (!name) {
	280	name = devm_kasprintf(dev, GFP_KERNEL,
	281	"%s-%c", pdev->name, pdev->id + 'A');
	282	if (!name)
	283	return -ENOMEM;
	284	}
0f98dd1b	285
6d974d32	286	gc = &chip->gc;
ca409160 BG	287	gc->base = base;
	288	gc->ngpio = ngpio;
	289	gc->label = name;
	290	gc->owner = THIS_MODULE;
	291	gc->parent = dev;
	292	gc->get = gpio_mockup_get;
	293	gc->set = gpio_mockup_set;
c47bee95	294	gc->set_multiple = gpio_mockup_set_multiple;
ca409160 BG	295	gc->direction_output = gpio_mockup_dirout;
	296	gc->direction_input = gpio_mockup_dirin;
	297	gc->get_direction = gpio_mockup_get_direction;
e2ff7408	298	gc->to_irq = gpio_mockup_to_irq;
ca409160	299
f6ac438e BG	300	chip->lines = devm_kcalloc(dev, gc->ngpio,
f6ac438e BG	301	sizeof(*chip->lines), GFP_KERNEL);
e4ba07bf BG	302	if (!chip->lines)
e4ba07bf BG	303	return -ENOMEM;
ca409160	304
3ea47b44	305	if (device_property_read_bool(dev, "named-gpio-lines")) {
6d974d32 BG	306	rv = gpio_mockup_name_lines(dev, chip);
	307	if (rv)
	308	return rv;
8a68ea00 BG	309	}
8a68ea00 BG	310
6d974d32	311	rv = devm_irq_sim_init(dev, &chip->irqsim, gc->ngpio);
1e0dca67	312	if (rv < 0)
6d974d32	313	return rv;
e2ff7408	314
6d974d32 BG	315	rv = devm_gpiochip_add_data(dev, &chip->gc, chip);
	316	if (rv)
	317	return rv;
9202ba23	318
6cb9215b	319	if (!IS_ERR_OR_NULL(gpio_mockup_dbg_dir))
9202ba23 BG	320	gpio_mockup_debugfs_setup(dev, chip);
	321
	322	return 0;
0f98dd1b BJZ	323	}
0f98dd1b BJZ	324
ca409160	325	static struct platform_driver gpio_mockup_driver = {
0f98dd1b	326	.driver = {
ca409160	327	.name = GPIO_MOCKUP_NAME,
364ac456	328	},
ca409160	329	.probe = gpio_mockup_probe,
0f98dd1b BJZ	330	};
0f98dd1b BJZ	331
8a39f597 BG	332	static struct platform_device *gpio_mockup_pdevs[GPIO_MOCKUP_MAX_GC];
	333
	334	static void gpio_mockup_unregister_pdevs(void)
	335	{
	336	struct platform_device *pdev;
	337	int i;
	338
	339	for (i = 0; i < GPIO_MOCKUP_MAX_GC; i++) {
	340	pdev = gpio_mockup_pdevs[i];
	341
	342	if (pdev)
	343	platform_device_unregister(pdev);
	344	}
	345	}
f3b47170 BG	346
f3b47170 BG	347	static int __init gpio_mockup_init(void)
0f98dd1b	348	{
3ea47b44 BG	349	struct property_entry properties[GPIO_MOCKUP_MAX_PROP];
	350	int i, prop, num_chips, err = 0, base;
	351	struct platform_device_info pdevinfo;
8a39f597	352	struct platform_device *pdev;
3ea47b44	353	u16 ngpio;
0f98dd1b	354
e63a006f BG	355	if ((gpio_mockup_num_ranges < 2) \|\|
	356	(gpio_mockup_num_ranges % 2) \|\|
	357	(gpio_mockup_num_ranges > GPIO_MOCKUP_MAX_RANGES))
20c35ac4 BG	358	return -EINVAL;
20c35ac4 BG	359
8a39f597	360	/* Each chip is described by two values. */
e63a006f	361	num_chips = gpio_mockup_num_ranges / 2;
8a39f597	362
fa86963a BG	363	/*
	364	* The second value in the <base GPIO - number of GPIOS> pair must
	365	* always be greater than 0.
	366	*/
	367	for (i = 0; i < num_chips; i++) {
cd9835f1	368	if (gpio_mockup_range_ngpio(i) < 0)
fa86963a BG	369	return -EINVAL;
	370	}
	371
9202ba23	372	gpio_mockup_dbg_dir = debugfs_create_dir("gpio-mockup-event", NULL);
46526c15	373	if (IS_ERR_OR_NULL(gpio_mockup_dbg_dir))
f1bec99a	374	gpio_mockup_err("error creating debugfs directory\n");
9202ba23	375
8a39f597	376	err = platform_driver_register(&gpio_mockup_driver);
0f98dd1b	377	if (err) {
f1bec99a	378	gpio_mockup_err("error registering platform driver\n");
0f98dd1b BJZ	379	return err;
	380	}
	381
8a39f597	382	for (i = 0; i < num_chips; i++) {
3ea47b44 BG	383	memset(properties, 0, sizeof(properties));
	384	memset(&pdevinfo, 0, sizeof(pdevinfo));
	385	prop = 0;
	386
	387	base = gpio_mockup_range_base(i);
	388	if (base >= 0)
	389	properties[prop++] = PROPERTY_ENTRY_U32("gpio-base",
	390	base);
	391
	392	ngpio = base < 0 ? gpio_mockup_range_ngpio(i)
	393	: gpio_mockup_range_ngpio(i) - base;
	394	properties[prop++] = PROPERTY_ENTRY_U16("nr-gpios", ngpio);
	395
	396	if (gpio_mockup_named_lines)
	397	properties[prop++] = PROPERTY_ENTRY_BOOL(
	398	"named-gpio-lines");
	399
	400	pdevinfo.name = GPIO_MOCKUP_NAME;
	401	pdevinfo.id = i;
	402	pdevinfo.properties = properties;
	403
	404	pdev = platform_device_register_full(&pdevinfo);
c4b54e13	405	if (IS_ERR(pdev)) {
f1bec99a	406	gpio_mockup_err("error registering device");
8a39f597 BG	407	platform_driver_unregister(&gpio_mockup_driver);
8a39f597 BG	408	gpio_mockup_unregister_pdevs();
c4b54e13	409	return PTR_ERR(pdev);
8a39f597 BG	410	}
	411
	412	gpio_mockup_pdevs[i] = pdev;
0f98dd1b BJZ	413	}
	414
	415	return 0;
	416	}
	417
f3b47170	418	static void __exit gpio_mockup_exit(void)
0f98dd1b	419	{
9202ba23	420	debugfs_remove_recursive(gpio_mockup_dbg_dir);
ca409160	421	platform_driver_unregister(&gpio_mockup_driver);
8a39f597	422	gpio_mockup_unregister_pdevs();
0f98dd1b BJZ	423	}
0f98dd1b BJZ	424
f3b47170 BG	425	module_init(gpio_mockup_init);
f3b47170 BG	426	module_exit(gpio_mockup_exit);
0f98dd1b BJZ	427
0f98dd1b BJZ	428	MODULE_AUTHOR("Kamlakant Patel <kamlakant.patel@broadcom.com>");
4f9a4cd6	429	MODULE_AUTHOR("Bamvor Jian Zhang <bamv2005@gmail.com>");
c60c7f4c	430	MODULE_AUTHOR("Bartosz Golaszewski <brgl@bgdev.pl>");
0f98dd1b BJZ	431	MODULE_DESCRIPTION("GPIO Testing driver");
0f98dd1b BJZ	432	MODULE_LICENSE("GPL v2");