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

// SPDX-License-Identifier: GPL-2.0+
//
// Gateworks I2C PLD GPIO expander
//
// Copyright (C) 2019 Linus Walleij <linus.walleij@linaro.org>
//
// Based on code and know-how from the OpenWrt driver:
// Copyright (C) 2009 Gateworks Corporation
// Authors: Chris Lang, Imre Kaloz

#include <linux/bits.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/gpio/driver.h>
#include <linux/i2c.h>
#include <linux/module.h>

/**
 * struct gw_pld - State container for Gateworks PLD
 * @chip: GPIO chip instance
 * @client: I2C client
 * @out: shadow register for the output bute
 */
struct gw_pld {
	struct gpio_chip chip;
	struct i2c_client *client;
	u8 out;
};

/*
 * The Gateworks I2C PLD chip only expose one read and one write register.
 * Writing a "one" bit (to match the reset state) lets that pin be used as an
 * input. It is an open-drain model.
 */
static int gw_pld_input8(struct gpio_chip *gc, unsigned offset)
{
	struct gw_pld *gw = gpiochip_get_data(gc);

	gw->out |= BIT(offset);
	return i2c_smbus_write_byte(gw->client, gw->out);
}

static int gw_pld_get8(struct gpio_chip *gc, unsigned offset)
{
	struct gw_pld *gw = gpiochip_get_data(gc);
	s32 val;

	val = i2c_smbus_read_byte(gw->client);

	return (val < 0) ? 0 : !!(val & BIT(offset));
}

static int gw_pld_output8(struct gpio_chip *gc, unsigned offset, int value)
{
	struct gw_pld *gw = gpiochip_get_data(gc);

	if (value)
		gw->out |= BIT(offset);
	else
		gw->out &= ~BIT(offset);

	return i2c_smbus_write_byte(gw->client, gw->out);
}

static void gw_pld_set8(struct gpio_chip *gc, unsigned offset, int value)
{
	gw_pld_output8(gc, offset, value);
}

static int gw_pld_probe(struct i2c_client *client,
			const struct i2c_device_id *id)
{
	struct device *dev = &client->dev;
	struct device_node *np = dev->of_node;
	struct gw_pld *gw;
	int ret;

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

	gw->chip.base = -1;
	gw->chip.can_sleep = true;
	gw->chip.parent = dev;
	gw->chip.of_node = np;
	gw->chip.owner = THIS_MODULE;
	gw->chip.label = dev_name(dev);
	gw->chip.ngpio = 8;
	gw->chip.direction_input = gw_pld_input8;
	gw->chip.get = gw_pld_get8;
	gw->chip.direction_output = gw_pld_output8;
	gw->chip.set = gw_pld_set8;
	gw->client = client;

	/*
	 * The Gateworks I2C PLD chip does not properly send the acknowledge
	 * bit at all times, but we can still use the standard i2c_smbus
	 * functions by simply ignoring this bit.
	 */
	client->flags |= I2C_M_IGNORE_NAK;
	gw->out = 0xFF;

	i2c_set_clientdata(client, gw);

	ret = devm_gpiochip_add_data(dev, &gw->chip, gw);
	if (ret)
		return ret;

	dev_info(dev, "registered Gateworks PLD GPIO device\n");

	return 0;
}

static const struct i2c_device_id gw_pld_id[] = {
	{ "gw-pld", },
	{ }
};
MODULE_DEVICE_TABLE(i2c, gw_pld_id);

static const struct of_device_id gw_pld_dt_ids[] = {
	{ .compatible = "gateworks,pld-gpio", },
	{ },
};
MODULE_DEVICE_TABLE(of, gw_pld_dt_ids);

static struct i2c_driver gw_pld_driver = {
	.driver = {
		.name = "gw_pld",
		.of_match_table = gw_pld_dt_ids,
	},
	.probe = gw_pld_probe,
	.id_table = gw_pld_id,
};
module_i2c_driver(gw_pld_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Linus Walleij <linus.walleij@linaro.org>");
Commit	Line	Data
2a0b0a57 LW	1	// SPDX-License-Identifier: GPL-2.0+
	2	//
	3	// Gateworks I2C PLD GPIO expander
	4	//
	5	// Copyright (C) 2019 Linus Walleij <linus.walleij@linaro.org>
	6	//
	7	// Based on code and know-how from the OpenWrt driver:
	8	// Copyright (C) 2009 Gateworks Corporation
	9	// Authors: Chris Lang, Imre Kaloz
	10
	11	#include <linux/bits.h>
	12	#include <linux/kernel.h>
	13	#include <linux/slab.h>
	14	#include <linux/gpio/driver.h>
	15	#include <linux/i2c.h>
	16	#include <linux/module.h>
	17
	18	/**
	19	* struct gw_pld - State container for Gateworks PLD
	20	* @chip: GPIO chip instance
	21	* @client: I2C client
	22	* @out: shadow register for the output bute
	23	*/
	24	struct gw_pld {
	25	struct gpio_chip chip;
	26	struct i2c_client *client;
	27	u8 out;
	28	};
	29
	30	/*
	31	* The Gateworks I2C PLD chip only expose one read and one write register.
	32	* Writing a "one" bit (to match the reset state) lets that pin be used as an
	33	* input. It is an open-drain model.
	34	*/
	35	static int gw_pld_input8(struct gpio_chip *gc, unsigned offset)
	36	{
	37	struct gw_pld *gw = gpiochip_get_data(gc);
	38
	39	gw->out \|= BIT(offset);
	40	return i2c_smbus_write_byte(gw->client, gw->out);
	41	}
	42
	43	static int gw_pld_get8(struct gpio_chip *gc, unsigned offset)
	44	{
	45	struct gw_pld *gw = gpiochip_get_data(gc);
	46	s32 val;
	47
	48	val = i2c_smbus_read_byte(gw->client);
	49
	50	return (val < 0) ? 0 : !!(val & BIT(offset));
	51	}
	52
	53	static int gw_pld_output8(struct gpio_chip *gc, unsigned offset, int value)
	54	{
	55	struct gw_pld *gw = gpiochip_get_data(gc);
	56
	57	if (value)
	58	gw->out \|= BIT(offset);
	59	else
	60	gw->out &= ~BIT(offset);
	61
	62	return i2c_smbus_write_byte(gw->client, gw->out);
	63	}
	64
65	static void gw_pld_set8(struct gpio_chip *gc, unsigned offset, int value)
66	{
67	gw_pld_output8(gc, offset, value);
68	}
69
70	static int gw_pld_probe(struct i2c_client *client,
71	const struct i2c_device_id *id)
72	{
73	struct device *dev = &client->dev;
74	struct device_node *np = dev->of_node;
75	struct gw_pld *gw;
76	int ret;
77
78	gw = devm_kzalloc(dev, sizeof(*gw), GFP_KERNEL);
79	if (!gw)
80	return -ENOMEM;
81
82	gw->chip.base = -1;
83	gw->chip.can_sleep = true;
84	gw->chip.parent = dev;
85	gw->chip.of_node = np;
86	gw->chip.owner = THIS_MODULE;
87	gw->chip.label = dev_name(dev);
88	gw->chip.ngpio = 8;
89	gw->chip.direction_input = gw_pld_input8;
90	gw->chip.get = gw_pld_get8;
91	gw->chip.direction_output = gw_pld_output8;
92	gw->chip.set = gw_pld_set8;
93	gw->client = client;
94
95	/*
96	* The Gateworks I2C PLD chip does not properly send the acknowledge
97	* bit at all times, but we can still use the standard i2c_smbus
98	* functions by simply ignoring this bit.
99	*/
100	client->flags \|= I2C_M_IGNORE_NAK;
101	gw->out = 0xFF;
102
103	i2c_set_clientdata(client, gw);
104
105	ret = devm_gpiochip_add_data(dev, &gw->chip, gw);
106	if (ret)
107	return ret;
108
109	dev_info(dev, "registered Gateworks PLD GPIO device\n");
110
111	return 0;
112	}
113
114	static const struct i2c_device_id gw_pld_id[] = {
115	{ "gw-pld", },
116	{ }
117	};
118	MODULE_DEVICE_TABLE(i2c, gw_pld_id);
119
120	static const struct of_device_id gw_pld_dt_ids[] = {
121	{ .compatible = "gateworks,pld-gpio", },
122	{ },
123	};
124	MODULE_DEVICE_TABLE(of, gw_pld_dt_ids);
125
126	static struct i2c_driver gw_pld_driver = {
127	.driver = {
128	.name = "gw_pld",
129	.of_match_table = gw_pld_dt_ids,
130	},
131	.probe = gw_pld_probe,
132	.id_table = gw_pld_id,
133	};
134	module_i2c_driver(gw_pld_driver);
135
136	MODULE_LICENSE("GPL");
137	MODULE_AUTHOR("Linus Walleij <linus.walleij@linaro.org>");