From: Miguel Gaio <[email protected]>
This patch adds support for NXP's 74HC164 GPIO expander.
Signed-off-by: Miguel Gaio <[email protected]>
Signed-off-by: Juhos Gabor <[email protected]>
Signed-off-by: Florian Fainelli <[email protected]>
---
diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index 510aa20..1008901 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -361,4 +361,12 @@ config GPIO_JANZ_TTL
This driver provides support for driving the pins in output
mode only. Input mode is not supported.
+comment "Other GPIO expanders"
+
+config GPIO_NXP_74HC164
+ tristate "NXP 74HC164 Output expanders"
+ help
+ Platform driver for NXP 74HC164 8-output Expanders. This
+ provides a GPIO interface supporting outputs.
+
endif
diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile
index fc6019d..63221bf 100644
--- a/drivers/gpio/Makefile
+++ b/drivers/gpio/Makefile
@@ -17,6 +17,7 @@ obj-$(CONFIG_GPIO_MAX7301) += max7301.o
obj-$(CONFIG_GPIO_MAX732X) += max732x.o
obj-$(CONFIG_GPIO_MC33880) += mc33880.o
obj-$(CONFIG_GPIO_MCP23S08) += mcp23s08.o
+obj-$(CONFIG_GPIO_NXP_74HC164) += nxp_74hc164.o
obj-$(CONFIG_GPIO_PCA953X) += pca953x.o
obj-$(CONFIG_GPIO_PCF857X) += pcf857x.o
obj-$(CONFIG_GPIO_PL061) += pl061.o
diff --git a/drivers/gpio/nxp_74hc164.c b/drivers/gpio/nxp_74hc164.c
new file mode 100644
index 0000000..88cfe8a
--- /dev/null
+++ b/drivers/gpio/nxp_74hc164.c
@@ -0,0 +1,227 @@
+/*
+ * NXP 74HC164 - output expander GPIO driver
+ *
+ * Copyright (C) 2010 Gabor Juhos <[email protected]>
+ * Copyright (C) 2010 Miguel Gaio <[email protected]>
+ *
+ * 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.
+ *
+ * Copy from nxp_74hc153.c code
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/gpio.h>
+#include <linux/bitops.h>
+#include <linux/platform_device.h>
+#include <linux/nxp_74hc164.h>
+
+#define NXP_74HC164_NUM_GPIOS 8
+
+struct nxp_74hc164_chip {
+ struct device *parent;
+ struct gpio_chip gpio_chip;
+ struct mutex lock;
+ long mask;
+};
+
+static void nxp_74hc164_set_value(struct gpio_chip *, unsigned, int);
+
+static struct nxp_74hc164_chip *gpio_to_nxp(struct gpio_chip *gc)
+{
+ return container_of(gc, struct nxp_74hc164_chip, gpio_chip);
+}
+
+static int nxp_74hc164_direction_input(struct gpio_chip *gc, unsigned offset)
+{
+ WARN_ON(1);
+ return -EINVAL;
+}
+
+static int nxp_74hc164_direction_output(struct gpio_chip *gc,
+ unsigned offset, int val)
+{
+ nxp_74hc164_set_value(gc, offset, val);
+ return 0;
+}
+
+static int nxp_74hc164_get_value(struct gpio_chip *gc, unsigned offset)
+{
+ struct nxp_74hc164_chip *nxp = gpio_to_nxp(gc);
+ int ret;
+
+ mutex_lock(&nxp->lock);
+ ret = test_bit(offset, &nxp->mask);
+ mutex_unlock(&nxp->lock);
+
+ return ret;
+}
+
+static void nxp_74hc164_set_value(struct gpio_chip *gc,
+ unsigned offset, int val)
+{
+ struct nxp_74hc164_chip *nxp;
+ struct nxp_74hc164_platform_data *pdata;
+ long mask;
+ int refresh;
+ int i;
+
+ nxp = gpio_to_nxp(gc);
+ pdata = nxp->parent->platform_data;
+
+ mutex_lock(&nxp->lock);
+ if (val)
+ refresh = (test_and_set_bit(offset, &nxp->mask) != val);
+ else
+ refresh = (test_and_clear_bit(offset, &nxp->mask) != val);
+
+ if (refresh) {
+ mask = nxp->mask;
+ for (i = 8; i > 0; --i, mask <<= 1) {
+ gpio_set_value(pdata->gpio_pin_data, mask & 0x80);
+ gpio_set_value(pdata->gpio_pin_clk, 1);
+ gpio_set_value(pdata->gpio_pin_clk, 0);
+ }
+ }
+ mutex_unlock(&nxp->lock);
+}
+
+static int __devinit nxp_74hc164_probe(struct platform_device *pdev)
+{
+ struct nxp_74hc164_platform_data *pdata;
+ struct nxp_74hc164_chip *nxp;
+ struct gpio_chip *gc;
+ int err;
+
+ pdata = pdev->dev.platform_data;
+ if (pdata == NULL) {
+ dev_dbg(&pdev->dev, "no platform data specified\n");
+ return -EINVAL;
+ }
+
+ nxp = kzalloc(sizeof(struct nxp_74hc164_chip), GFP_KERNEL);
+ if (nxp == NULL) {
+ dev_err(&pdev->dev, "no memory for private data\n");
+ return -ENOMEM;
+ }
+
+ err = gpio_request(pdata->gpio_pin_clk, dev_name(&pdev->dev));
+ if (err) {
+ dev_err(&pdev->dev, "unable to claim gpio %u, err=%d\n",
+ pdata->gpio_pin_clk, err);
+ goto err_free_nxp;
+ }
+
+ err = gpio_request(pdata->gpio_pin_data, dev_name(&pdev->dev));
+ if (err) {
+ dev_err(&pdev->dev, "unable to claim gpio %u, err=%d\n",
+ pdata->gpio_pin_data, err);
+ goto err_free_clk;
+ }
+
+ err = gpio_direction_output(pdata->gpio_pin_clk, 0);
+ if (err) {
+ dev_err(&pdev->dev,
+ "unable to set direction of gpio %u, err=%d\n",
+ pdata->gpio_pin_clk, err);
+ goto err_free_data;
+ }
+
+ err = gpio_direction_output(pdata->gpio_pin_data, 0);
+ if (err) {
+ dev_err(&pdev->dev,
+ "unable to set direction of gpio %u, err=%d\n",
+ pdata->gpio_pin_data, err);
+ goto err_free_data;
+ }
+
+ nxp->parent = &pdev->dev;
+ mutex_init(&nxp->lock);
+
+ gc = &nxp->gpio_chip;
+
+ gc->direction_input = nxp_74hc164_direction_input;
+ gc->direction_output = nxp_74hc164_direction_output;
+ gc->get = nxp_74hc164_get_value;
+ gc->set = nxp_74hc164_set_value;
+ gc->can_sleep = 1;
+
+ gc->base = pdata->gpio_base;
+ gc->ngpio = NXP_74HC164_NUM_GPIOS;
+ gc->label = dev_name(nxp->parent);
+ gc->dev = nxp->parent;
+ gc->owner = THIS_MODULE;
+
+ err = gpiochip_add(&nxp->gpio_chip);
+ if (err) {
+ dev_err(&pdev->dev, "unable to add gpio chip, err=%d\n", err);
+ goto err_free_data;
+ }
+
+ platform_set_drvdata(pdev, nxp);
+ return 0;
+
+err_free_data:
+ gpio_free(pdata->gpio_pin_data);
+err_free_clk:
+ gpio_free(pdata->gpio_pin_clk);
+err_free_nxp:
+ kfree(nxp);
+ return err;
+}
+
+static int nxp_74hc164_remove(struct platform_device *pdev)
+{
+ struct nxp_74hc164_chip *nxp = platform_get_drvdata(pdev);
+ struct nxp_74hc164_platform_data *pdata = pdev->dev.platform_data;
+
+ if (nxp) {
+ int err;
+
+ err = gpiochip_remove(&nxp->gpio_chip);
+ if (err) {
+ dev_err(&pdev->dev,
+ "unable to remove gpio chip, err=%d\n",
+ err);
+ return err;
+ }
+
+ gpio_free(pdata->gpio_pin_clk);
+ gpio_free(pdata->gpio_pin_data);
+
+ kfree(nxp);
+ platform_set_drvdata(pdev, NULL);
+ }
+
+ return 0;
+}
+
+static struct platform_driver nxp_74hc164_driver = {
+ .probe = nxp_74hc164_probe,
+ .remove = __devexit_p(nxp_74hc164_remove),
+ .driver = {
+ .name = NXP_74HC164_DRIVER_NAME,
+ .owner = THIS_MODULE,
+ },
+};
+
+static int __init nxp_74hc164_init(void)
+{
+ return platform_driver_register(&nxp_74hc164_driver);
+}
+subsys_initcall(nxp_74hc164_init);
+
+static void __exit nxp_74hc164_exit(void)
+{
+ platform_driver_unregister(&nxp_74hc164_driver);
+}
+module_exit(nxp_74hc164_exit);
+
+MODULE_AUTHOR("Gabor Juhos <[email protected]>");
+MODULE_AUTHOR("Miguel Gaio <[email protected]>");
+MODULE_DESCRIPTION("GPIO expander driver for NXP 74HC164");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:" NXP_74HC164_DRIVER_NAME);
diff --git a/include/linux/nxp_74hc164.h b/include/linux/nxp_74hc164.h
new file mode 100644
index 0000000..eb0201f
--- /dev/null
+++ b/include/linux/nxp_74hc164.h
@@ -0,0 +1,22 @@
+/*
+ * NXP 74HC164 - Dual 4-input multiplexer defines
+ *
+ * Copyright (C) 2010 Gabor Juhos <[email protected]>
+ *
+ * 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.
+ */
+
+#ifndef _NXP_74HC164_H
+#define _NXP_74HC164_H
+
+#define NXP_74HC164_DRIVER_NAME "nxp-74hc164"
+
+struct nxp_74hc164_platform_data {
+ unsigned gpio_base;
+ unsigned gpio_pin_data;
+ unsigned gpio_pin_clk;
+};
+
+#endif /* _NXP_74HC164_H */
--- On Sat, 8/28/10, Florian Fainelli <[email protected]> wrote:
> This patch adds support for
> NXP's 74HC164 GPIO expander.
The 74164 parts are standard 74xxx series
discrete logic parts sold by many vendors
as 8 bit shift registers ... and in many
logic series (HC, HCT, more).
At least describe this as generic to all
those 8-bit shift registers, not just NXP.
And not as "GPIO expanders"; data sheets
describe them as shift registers. Kconfig
can say that the shift registers are being
used for GPIO (output) expansion.
I suppose it's reasonable not to support the
way these chips can be daisy-chained, but it'd
be worth a comment, IMO; that strikes me as a
think someone will add at some point, via some
platform data (e.g.32 GPIO outputs from 4 chips).
- Dave
p.s. I'd have to pull out my data sheet collection
to verify, but it might be the 74163 which can
be used as an 8 bit parallel to serial (input)
shift register...
On Sat, Aug 28, 2010 at 04:18:51PM -0700, David Brownell wrote:
>
> --- On Sat, 8/28/10, Florian Fainelli <[email protected]> wrote:
>
> > This patch adds support for
> > NXP's 74HC164 GPIO expander.
>
> The 74164 parts are standard 74xxx series
> discrete logic parts sold by many vendors
> as 8 bit shift registers ... and in many
> logic series (HC, HCT, more).
>
> At least describe this as generic to all
> those 8-bit shift registers, not just NXP.
Indeed, that was my concern too.
(...)
> p.s. I'd have to pull out my data sheet collection
> to verify, but it might be the 74163 which can
> be used as an 8 bit parallel to serial (input)
> shift register...
no, it's the 74165. But it would be worth supporting
both !
Willy
Hi,
Here is the second version of the patch:
--
From: Miguel Gaio <[email protected]>
This patch adds support for generic 74HC164 serial-in/parallel-out 8-bits
shift register. This driver can be used as a GPIO output expander.
Signed-off-by: Miguel Gaio <[email protected]>
Signed-off-by: Juhos Gabor <[email protected]>
Signed-off-by: Florian Fainelli <[email protected]>
---
Changes since v1:
- renamed nxp_ to gen_ since this driver is generic to all 74HC164 chips
- added comment on this driver not handling the 74HC164 daisy-chaining
- renamed misused GPIO expanders to Shift registers
diff --git a/drivers/gpio/74hc164.c b/drivers/gpio/74hc164.c
new file mode 100644
index 0000000..fa63215
--- /dev/null
+++ b/drivers/gpio/74hc164.c
@@ -0,0 +1,228 @@
+/*
+ * 74HC164 - Serial-in/parallel-out 8-bits shift register GPIO driver
+ *
+ * Copyright (C) 2010 Gabor Juhos <[email protected]>
+ * Copyright (C) 2010 Miguel Gaio <[email protected]>
+ *
+ * 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.
+ *
+ * Note: this driver does not support the way 74HC164 chips can be
+ * daisy-chained.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/gpio.h>
+#include <linux/bitops.h>
+#include <linux/platform_device.h>
+#include <linux/74hc164.h>
+
+#define GEN_74HC164_NUM_GPIOS 8
+
+struct gen_74hc164_chip {
+ struct device *parent;
+ struct gpio_chip gpio_chip;
+ struct mutex lock;
+ long mask;
+};
+
+static void gen_74hc164_set_value(struct gpio_chip *, unsigned, int);
+
+static struct gen_74hc164_chip *gpio_to_chip(struct gpio_chip *gc)
+{
+ return container_of(gc, struct gen_74hc164_chip, gpio_chip);
+}
+
+static int gen_74hc164_direction_input(struct gpio_chip *gc, unsigned offset)
+{
+ WARN_ON(1);
+ return -EINVAL;
+}
+
+static int gen_74hc164_direction_output(struct gpio_chip *gc,
+ unsigned offset, int val)
+{
+ gen_74hc164_set_value(gc, offset, val);
+ return 0;
+}
+
+static int gen_74hc164_get_value(struct gpio_chip *gc, unsigned offset)
+{
+ struct gen_74hc164_chip *chip = gpio_to_chip(gc);
+ int ret;
+
+ mutex_lock(&chip->lock);
+ ret = test_bit(offset, &chip->mask);
+ mutex_unlock(&chip->lock);
+
+ return ret;
+}
+
+static void gen_74hc164_set_value(struct gpio_chip *gc,
+ unsigned offset, int val)
+{
+ struct gen_74hc164_chip *chip;
+ struct gen_74hc164_platform_data *pdata;
+ long mask;
+ int refresh;
+ int i;
+
+ chip = gpio_to_chip(gc);
+ pdata = chip->parent->platform_data;
+
+ mutex_lock(&chip->lock);
+ if (val)
+ refresh = (test_and_set_bit(offset, &chip->mask) != val);
+ else
+ refresh = (test_and_clear_bit(offset, &chip->mask) != val);
+
+ if (refresh) {
+ mask = chip->mask;
+ for (i = 8; i > 0; --i, mask <<= 1) {
+ gpio_set_value(pdata->gpio_pin_data, mask & 0x80);
+ gpio_set_value(pdata->gpio_pin_clk, 1);
+ gpio_set_value(pdata->gpio_pin_clk, 0);
+ }
+ }
+ mutex_unlock(&chip->lock);
+}
+
+static int __devinit gen_74hc164_probe(struct platform_device *pdev)
+{
+ struct gen_74hc164_platform_data *pdata;
+ struct gen_74hc164_chip *chip;
+ struct gpio_chip *gc;
+ int err;
+
+ pdata = pdev->dev.platform_data;
+ if (pdata == NULL) {
+ dev_dbg(&pdev->dev, "no platform data specified\n");
+ return -EINVAL;
+ }
+
+ chip = kzalloc(sizeof(struct gen_74hc164_chip), GFP_KERNEL);
+ if (chip == NULL) {
+ dev_err(&pdev->dev, "no memory for private data\n");
+ return -ENOMEM;
+ }
+
+ err = gpio_request(pdata->gpio_pin_clk, dev_name(&pdev->dev));
+ if (err) {
+ dev_err(&pdev->dev, "unable to claim gpio %u, err=%d\n",
+ pdata->gpio_pin_clk, err);
+ goto err_free_chip;
+ }
+
+ err = gpio_request(pdata->gpio_pin_data, dev_name(&pdev->dev));
+ if (err) {
+ dev_err(&pdev->dev, "unable to claim gpio %u, err=%d\n",
+ pdata->gpio_pin_data, err);
+ goto err_free_clk;
+ }
+
+ err = gpio_direction_output(pdata->gpio_pin_clk, 0);
+ if (err) {
+ dev_err(&pdev->dev,
+ "unable to set direction of gpio %u, err=%d\n",
+ pdata->gpio_pin_clk, err);
+ goto err_free_data;
+ }
+
+ err = gpio_direction_output(pdata->gpio_pin_data, 0);
+ if (err) {
+ dev_err(&pdev->dev,
+ "unable to set direction of gpio %u, err=%d\n",
+ pdata->gpio_pin_data, err);
+ goto err_free_data;
+ }
+
+ chip->parent = &pdev->dev;
+ mutex_init(&chip->lock);
+
+ gc = &chip->gpio_chip;
+
+ gc->direction_input = gen_74hc164_direction_input;
+ gc->direction_output = gen_74hc164_direction_output;
+ gc->get = gen_74hc164_get_value;
+ gc->set = gen_74hc164_set_value;
+ gc->can_sleep = 1;
+
+ gc->base = pdata->gpio_base;
+ gc->ngpio = GEN_74HC164_NUM_GPIOS;
+ gc->label = dev_name(chip->parent);
+ gc->dev = chip->parent;
+ gc->owner = THIS_MODULE;
+
+ err = gpiochip_add(&chip->gpio_chip);
+ if (err) {
+ dev_err(&pdev->dev, "unable to add gpio chip, err=%d\n", err);
+ goto err_free_data;
+ }
+
+ platform_set_drvdata(pdev, chip);
+ return 0;
+
+err_free_data:
+ gpio_free(pdata->gpio_pin_data);
+err_free_clk:
+ gpio_free(pdata->gpio_pin_clk);
+err_free_chip:
+ kfree(chip);
+ return err;
+}
+
+static int gen_74hc164_remove(struct platform_device *pdev)
+{
+ struct gen_74hc164_chip *chip = platform_get_drvdata(pdev);
+ struct gen_74hc164_platform_data *pdata = pdev->dev.platform_data;
+
+ if (chip) {
+ int err;
+
+ err = gpiochip_remove(&chip->gpio_chip);
+ if (err) {
+ dev_err(&pdev->dev,
+ "unable to remove gpio chip, err=%d\n",
+ err);
+ return err;
+ }
+
+ gpio_free(pdata->gpio_pin_clk);
+ gpio_free(pdata->gpio_pin_data);
+
+ kfree(chip);
+ platform_set_drvdata(pdev, NULL);
+ }
+
+ return 0;
+}
+
+static struct platform_driver gen_74hc164_driver = {
+ .probe = gen_74hc164_probe,
+ .remove = __devexit_p(gen_74hc164_remove),
+ .driver = {
+ .name = GEN_74HC164_DRIVER_NAME,
+ .owner = THIS_MODULE,
+ },
+};
+
+static int __init gen_74hc164_init(void)
+{
+ return platform_driver_register(&gen_74hc164_driver);
+}
+subsys_initcall(gen_74hc164_init);
+
+static void __exit gen_74hc164_exit(void)
+{
+ platform_driver_unregister(&gen_74hc164_driver);
+}
+module_exit(gen_74hc164_exit);
+
+MODULE_AUTHOR("Gabor Juhos <[email protected]>");
+MODULE_AUTHOR("Miguel Gaio <[email protected]>");
+MODULE_DESCRIPTION("GPIO expander driver for 74HC164 8-bits shift register");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:" GEN_74HC164_DRIVER_NAME);
diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index 510aa20..ec27ab6 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -361,4 +361,13 @@ config GPIO_JANZ_TTL
This driver provides support for driving the pins in output
mode only. Input mode is not supported.
+comment "Shift registers:"
+
+config GPIO_74HC164
+ tristate "74HC164 serial-in/parallel-out 8-bit shift register"
+ help
+ Platform driver for 74HC164 serial-in/parallel-out 8-outputs shift
+ registers. This driver can be used to provide access to more gpio
+ outputs.
+
endif
diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile
index fc6019d..2fcb2b8 100644
--- a/drivers/gpio/Makefile
+++ b/drivers/gpio/Makefile
@@ -17,6 +17,7 @@ obj-$(CONFIG_GPIO_MAX7301) += max7301.o
obj-$(CONFIG_GPIO_MAX732X) += max732x.o
obj-$(CONFIG_GPIO_MC33880) += mc33880.o
obj-$(CONFIG_GPIO_MCP23S08) += mcp23s08.o
+obj-$(CONFIG_GPIO_74HC164) += 74hc164.o
obj-$(CONFIG_GPIO_PCA953X) += pca953x.o
obj-$(CONFIG_GPIO_PCF857X) += pcf857x.o
obj-$(CONFIG_GPIO_PL061) += pl061.o
diff --git a/include/linux/74hc164.h b/include/linux/74hc164.h
new file mode 100644
index 0000000..dae3d46
--- /dev/null
+++ b/include/linux/74hc164.h
@@ -0,0 +1,22 @@
+/*
+ * 74HC164 - Serial-in/parallel-out 8-bits shift register
+ *
+ * Copyright (C) 2010 Gabor Juhos <[email protected]>
+ *
+ * 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.
+ */
+
+#ifndef __74HC164_H
+#define __74HC164_H
+
+#define GEN_74HC164_DRIVER_NAME "74hc164"
+
+struct gen_74hc164_platform_data {
+ unsigned gpio_base;
+ unsigned gpio_pin_data;
+ unsigned gpio_pin_clk;
+};
+
+#endif /* __74HC164_H */
generic to all
> 74HC164 chips
Not just HC-series logic, also HCT, AC, etc (as
I noted previously).
I'm glad you took NXP (one of the N vendors)
out of the name, but I think you should also
take the logic series out; "74x164 might be sufficiently generic.
??? ??? ???
> pdata->gpio_pin_clk, err);
I'm a bit puzzled why you don't just hook the
chip up using standard SPI signals... ISTR they
matched up directly to what the chip needs, so
no GPIOs were needed for interface glue.
>
Hi David,
On Tuesday 31 August 2010 01:43:04 David Brownell wrote:
> generic to all
>
> > 74HC164 chips
>
> Not just HC-series logic, also HCT, AC, etc (as
> I noted previously).
>
> I'm glad you took NXP (one of the N vendors)
> out of the name, but I think you should also
> take the logic series out; "74x164 might be sufficiently generic.
Allright, I will respin with those changes. Note that I chose to prefix the
data structures with gen_ (for obvious C language reasons), I hope this is
fine.
>
>
> > pdata->gpio_pin_clk, err);
>
> I'm a bit puzzled why you don't just hook the
> chip up using standard SPI signals... ISTR they
> matched up directly to what the chip needs, so
> no GPIOs were needed for interface glue.
The board this driver is being used on had no SPI signals left I think, so it
was hooked up on separate GPIO lines (which cannot be muxed to the GPIO pad).
--
Florian
From: Miguel Gaio <[email protected]>
This patch adds support for generic 74x164 serial-in/parallel-out 8-bits
shift register. This driver can be used as a GPIO output expander.
Signed-off-by: Miguel Gaio <[email protected]>
Signed-off-by: Juhos Gabor <[email protected]>
Signed-off-by: Florian Fainelli <[email protected]>
---
Changes since v1:
- renamed nxp_ to gen_ since this driver is generic to all 74HC164 chips
- added comment on this driver not handling the 74HC164 daisy-chaining
- renamed misused GPIO expanders to Shift registers
Changes since v2:
- rename 74hc164 to 74x164
diff --git a/drivers/gpio/74x164.c b/drivers/gpio/74x164.c
new file mode 100644
index 0000000..9adeed4
--- /dev/null
+++ b/drivers/gpio/74x164.c
@@ -0,0 +1,228 @@
+/*
+ * 74Hx164 - Generic serial-in/parallel-out 8-bits shift register GPIO driver
+ *
+ * Copyright (C) 2010 Gabor Juhos <[email protected]>
+ * Copyright (C) 2010 Miguel Gaio <[email protected]>
+ *
+ * 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.
+ *
+ * Note: this driver does not support the way 74x164 chips can be
+ * daisy-chained.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/gpio.h>
+#include <linux/bitops.h>
+#include <linux/platform_device.h>
+#include <linux/74x164.h>
+
+#define GEN_74X164_NUM_GPIOS 8
+
+struct gen_74x164_chip {
+ struct device *parent;
+ struct gpio_chip gpio_chip;
+ struct mutex lock;
+ long mask;
+};
+
+static void gen_74x164_set_value(struct gpio_chip *, unsigned, int);
+
+static struct gen_74x164_chip *gpio_to_chip(struct gpio_chip *gc)
+{
+ return container_of(gc, struct gen_74x164_chip, gpio_chip);
+}
+
+static int gen_74x164_direction_input(struct gpio_chip *gc, unsigned offset)
+{
+ WARN_ON(1);
+ return -EINVAL;
+}
+
+static int gen_74x164_direction_output(struct gpio_chip *gc,
+ unsigned offset, int val)
+{
+ gen_74x164_set_value(gc, offset, val);
+ return 0;
+}
+
+static int gen_74x164_get_value(struct gpio_chip *gc, unsigned offset)
+{
+ struct gen_74x164_chip *chip = gpio_to_chip(gc);
+ int ret;
+
+ mutex_lock(&chip->lock);
+ ret = test_bit(offset, &chip->mask);
+ mutex_unlock(&chip->lock);
+
+ return ret;
+}
+
+static void gen_74x164_set_value(struct gpio_chip *gc,
+ unsigned offset, int val)
+{
+ struct gen_74x164_chip *chip;
+ struct gen_74x164_platform_data *pdata;
+ long mask;
+ int refresh;
+ int i;
+
+ chip = gpio_to_chip(gc);
+ pdata = chip->parent->platform_data;
+
+ mutex_lock(&chip->lock);
+ if (val)
+ refresh = (test_and_set_bit(offset, &chip->mask) != val);
+ else
+ refresh = (test_and_clear_bit(offset, &chip->mask) != val);
+
+ if (refresh) {
+ mask = chip->mask;
+ for (i = 8; i > 0; --i, mask <<= 1) {
+ gpio_set_value(pdata->gpio_pin_data, mask & 0x80);
+ gpio_set_value(pdata->gpio_pin_clk, 1);
+ gpio_set_value(pdata->gpio_pin_clk, 0);
+ }
+ }
+ mutex_unlock(&chip->lock);
+}
+
+static int __devinit gen_74x164_probe(struct platform_device *pdev)
+{
+ struct gen_74x164_platform_data *pdata;
+ struct gen_74x164_chip *chip;
+ struct gpio_chip *gc;
+ int err;
+
+ pdata = pdev->dev.platform_data;
+ if (pdata == NULL) {
+ dev_dbg(&pdev->dev, "no platform data specified\n");
+ return -EINVAL;
+ }
+
+ chip = kzalloc(sizeof(struct gen_74x164_chip), GFP_KERNEL);
+ if (chip == NULL) {
+ dev_err(&pdev->dev, "no memory for private data\n");
+ return -ENOMEM;
+ }
+
+ err = gpio_request(pdata->gpio_pin_clk, dev_name(&pdev->dev));
+ if (err) {
+ dev_err(&pdev->dev, "unable to claim gpio %u, err=%d\n",
+ pdata->gpio_pin_clk, err);
+ goto err_free_chip;
+ }
+
+ err = gpio_request(pdata->gpio_pin_data, dev_name(&pdev->dev));
+ if (err) {
+ dev_err(&pdev->dev, "unable to claim gpio %u, err=%d\n",
+ pdata->gpio_pin_data, err);
+ goto err_free_clk;
+ }
+
+ err = gpio_direction_output(pdata->gpio_pin_clk, 0);
+ if (err) {
+ dev_err(&pdev->dev,
+ "unable to set direction of gpio %u, err=%d\n",
+ pdata->gpio_pin_clk, err);
+ goto err_free_data;
+ }
+
+ err = gpio_direction_output(pdata->gpio_pin_data, 0);
+ if (err) {
+ dev_err(&pdev->dev,
+ "unable to set direction of gpio %u, err=%d\n",
+ pdata->gpio_pin_data, err);
+ goto err_free_data;
+ }
+
+ chip->parent = &pdev->dev;
+ mutex_init(&chip->lock);
+
+ gc = &chip->gpio_chip;
+
+ gc->direction_input = gen_74x164_direction_input;
+ gc->direction_output = gen_74x164_direction_output;
+ gc->get = gen_74x164_get_value;
+ gc->set = gen_74x164_set_value;
+ gc->can_sleep = 1;
+
+ gc->base = pdata->gpio_base;
+ gc->ngpio = GEN_74X164_NUM_GPIOS;
+ gc->label = dev_name(chip->parent);
+ gc->dev = chip->parent;
+ gc->owner = THIS_MODULE;
+
+ err = gpiochip_add(&chip->gpio_chip);
+ if (err) {
+ dev_err(&pdev->dev, "unable to add gpio chip, err=%d\n", err);
+ goto err_free_data;
+ }
+
+ platform_set_drvdata(pdev, chip);
+ return 0;
+
+err_free_data:
+ gpio_free(pdata->gpio_pin_data);
+err_free_clk:
+ gpio_free(pdata->gpio_pin_clk);
+err_free_chip:
+ kfree(chip);
+ return err;
+}
+
+static int gen_74x164_remove(struct platform_device *pdev)
+{
+ struct gen_74x164_chip *chip = platform_get_drvdata(pdev);
+ struct gen_74x164_platform_data *pdata = pdev->dev.platform_data;
+
+ if (chip) {
+ int err;
+
+ err = gpiochip_remove(&chip->gpio_chip);
+ if (err) {
+ dev_err(&pdev->dev,
+ "unable to remove gpio chip, err=%d\n",
+ err);
+ return err;
+ }
+
+ gpio_free(pdata->gpio_pin_clk);
+ gpio_free(pdata->gpio_pin_data);
+
+ kfree(chip);
+ platform_set_drvdata(pdev, NULL);
+ }
+
+ return 0;
+}
+
+static struct platform_driver gen_74x164_driver = {
+ .probe = gen_74x164_probe,
+ .remove = __devexit_p(gen_74x164_remove),
+ .driver = {
+ .name = GEN_74X164_DRIVER_NAME,
+ .owner = THIS_MODULE,
+ },
+};
+
+static int __init gen_74x164_init(void)
+{
+ return platform_driver_register(&gen_74x164_driver);
+}
+subsys_initcall(gen_74x164_init);
+
+static void __exit gen_74x164_exit(void)
+{
+ platform_driver_unregister(&gen_74x164_driver);
+}
+module_exit(gen_74x164_exit);
+
+MODULE_AUTHOR("Gabor Juhos <[email protected]>");
+MODULE_AUTHOR("Miguel Gaio <[email protected]>");
+MODULE_DESCRIPTION("GPIO expander driver for 74X164 8-bits shift register");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:" GEN_74X164_DRIVER_NAME);
diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index 510aa20..fc82c23 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -361,4 +361,13 @@ config GPIO_JANZ_TTL
This driver provides support for driving the pins in output
mode only. Input mode is not supported.
+comment "Shift registers:"
+
+config GPIO_74X164
+ tristate "74x164 serial-in/parallel-out 8-bits shift register"
+ help
+ Platform driver for 74x164 compatible serial-in/parallel-out
+ 8-outputs shift registers. This driver can be used to provide access
+ to more gpio outputs.
+
endif
diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile
index fc6019d..60456a4 100644
--- a/drivers/gpio/Makefile
+++ b/drivers/gpio/Makefile
@@ -17,6 +17,7 @@ obj-$(CONFIG_GPIO_MAX7301) += max7301.o
obj-$(CONFIG_GPIO_MAX732X) += max732x.o
obj-$(CONFIG_GPIO_MC33880) += mc33880.o
obj-$(CONFIG_GPIO_MCP23S08) += mcp23s08.o
+obj-$(CONFIG_GPIO_74X164) += 74x164.o
obj-$(CONFIG_GPIO_PCA953X) += pca953x.o
obj-$(CONFIG_GPIO_PCF857X) += pcf857x.o
obj-$(CONFIG_GPIO_PL061) += pl061.o
diff --git a/include/linux/74x164.h b/include/linux/74x164.h
new file mode 100644
index 0000000..1705732
--- /dev/null
+++ b/include/linux/74x164.h
@@ -0,0 +1,22 @@
+/*
+ * 74x164 - Serial-in/parallel-out 8-bits shift register
+ *
+ * Copyright (C) 2010 Gabor Juhos <[email protected]>
+ *
+ * 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.
+ */
+
+#ifndef __74X164_H
+#define __74X164_H
+
+#define GEN_74X164_DRIVER_NAME "74x164"
+
+struct gen_74x164_platform_data {
+ unsigned gpio_base;
+ unsigned gpio_pin_data;
+ unsigned gpio_pin_clk;
+};
+
+#endif /* __74x164_H */