2008-02-04 23:28:20 -07:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
2009-09-22 17:46:38 -06:00
|
|
|
#include <linux/interrupt.h>
|
2008-02-04 23:28:20 -07:00
|
|
|
#include <linux/irq.h>
|
|
|
|
#include <linux/spinlock.h>
|
2013-02-02 09:29:24 -07:00
|
|
|
#include <linux/list.h>
|
gpio: sysfs interface
This adds a simple sysfs interface for GPIOs.
/sys/class/gpio
/export ... asks the kernel to export a GPIO to userspace
/unexport ... to return a GPIO to the kernel
/gpioN ... for each exported GPIO #N
/value ... always readable, writes fail for input GPIOs
/direction ... r/w as: in, out (default low); write high, low
/gpiochipN ... for each gpiochip; #N is its first GPIO
/base ... (r/o) same as N
/label ... (r/o) descriptive, not necessarily unique
/ngpio ... (r/o) number of GPIOs; numbered N .. N+(ngpio - 1)
GPIOs claimed by kernel code may be exported by its owner using a new
gpio_export() call, which should be most useful for driver debugging.
Such exports may optionally be done without a "direction" attribute.
Userspace may ask to take over a GPIO by writing to a sysfs control file,
helping to cope with incomplete board support or other "one-off"
requirements that don't merit full kernel support:
echo 23 > /sys/class/gpio/export
... will gpio_request(23, "sysfs") and gpio_export(23);
use /sys/class/gpio/gpio-23/direction to (re)configure it,
when that GPIO can be used as both input and output.
echo 23 > /sys/class/gpio/unexport
... will gpio_free(23), when it was exported as above
The extra D-space footprint is a few hundred bytes, except for the sysfs
resources associated with each exported GPIO. The additional I-space
footprint is about two thirds of the current size of gpiolib (!). Since
no /dev node creation is involved, no "udev" support is needed.
Related changes:
* This adds a device pointer to "struct gpio_chip". When GPIO
providers initialize that, sysfs gpio class devices become children of
that device instead of being "virtual" devices.
* The (few) gpio_chip providers which have such a device node have
been updated.
* Some gpio_chip drivers also needed to update their module "owner"
field ... for which missing kerneldoc was added.
* Some gpio_chips don't support input GPIOs. Those GPIOs are now
flagged appropriately when the chip is registered.
Based on previous patches, and discussion both on and off LKML.
A Documentation/ABI/testing/sysfs-gpio update is ready to submit once this
merges to mainline.
[akpm@linux-foundation.org: a few maintenance build fixes]
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Cc: Guennadi Liakhovetski <g.liakhovetski@pengutronix.de>
Cc: Greg KH <greg@kroah.com>
Cc: Kay Sievers <kay.sievers@vrfy.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-07-25 02:46:07 -06:00
|
|
|
#include <linux/device.h>
|
|
|
|
#include <linux/err.h>
|
|
|
|
#include <linux/debugfs.h>
|
|
|
|
#include <linux/seq_file.h>
|
|
|
|
#include <linux/gpio.h>
|
2010-06-08 07:48:17 -06:00
|
|
|
#include <linux/of_gpio.h>
|
2009-09-22 17:46:38 -06:00
|
|
|
#include <linux/idr.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
ACPI / driver core: Store an ACPI device pointer in struct acpi_dev_node
Modify struct acpi_dev_node to contain a pointer to struct acpi_device
associated with the given device object (that is, its ACPI companion
device) instead of an ACPI handle corresponding to it. Introduce two
new macros for manipulating that pointer in a CONFIG_ACPI-safe way,
ACPI_COMPANION() and ACPI_COMPANION_SET(), and rework the
ACPI_HANDLE() macro to take the above changes into account.
Drop the ACPI_HANDLE_SET() macro entirely and rework its users to
use ACPI_COMPANION_SET() instead. For some of them who used to
pass the result of acpi_get_child() directly to ACPI_HANDLE_SET()
introduce a helper routine acpi_preset_companion() doing an
equivalent thing.
The main motivation for doing this is that there are things
represented by struct acpi_device objects that don't have valid
ACPI handles (so called fixed ACPI hardware features, such as
power and sleep buttons) and we would like to create platform
device objects for them and "glue" them to their ACPI companions
in the usual way (which currently is impossible due to the
lack of valid ACPI handles). However, there are more reasons
why it may be useful.
First, struct acpi_device pointers allow of much better type checking
than void pointers which are ACPI handles, so it should be more
difficult to write buggy code using modified struct acpi_dev_node
and the new macros. Second, the change should help to reduce (over
time) the number of places in which the result of ACPI_HANDLE() is
passed to acpi_bus_get_device() in order to obtain a pointer to the
struct acpi_device associated with the given "physical" device,
because now that pointer is returned by ACPI_COMPANION() directly.
Finally, the change should make it easier to write generic code that
will build both for CONFIG_ACPI set and unset without adding explicit
compiler directives to it.
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Tested-by: Mika Westerberg <mika.westerberg@linux.intel.com> # on Haswell
Reviewed-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Reviewed-by: Aaron Lu <aaron.lu@intel.com> # for ATA and SDIO part
2013-11-11 14:41:56 -07:00
|
|
|
#include <linux/acpi.h>
|
2013-11-16 05:44:52 -07:00
|
|
|
#include <linux/gpio/driver.h>
|
2014-07-24 12:08:55 -06:00
|
|
|
#include <linux/gpio/machine.h>
|
2015-10-11 09:34:15 -06:00
|
|
|
#include <linux/pinctrl/consumer.h>
|
2015-10-20 03:10:38 -06:00
|
|
|
#include <linux/idr.h>
|
gpio: add a userspace chardev ABI for GPIOs
A new chardev that is to be used for userspace GPIO access is
added in this patch. It is intended to gradually replace the
horribly broken sysfs ABI.
Using a chardev has many upsides:
- All operations are per-gpiochip, which is the actual
device underlying the GPIOs, making us tie in to the
kernel device model properly.
- Hotpluggable GPIO controllers can come and go, as this
kind of problem has been know to userspace for character
devices since ages, and if a gpiochip handle is held in
userspace we know we will break something, whereas the
sysfs is stateless.
- The one-value-per-file rule of sysfs is really hard to
maintain when you want to twist more than one knob at a time,
for example have in-kernel APIs to switch several GPIO
lines at the same time, and this will be possible to do
with a single ioctl() from userspace, saving a lot of
context switching.
We also need to add a new bus type for GPIO. This is
necessary for example for userspace coldplug, where sysfs is
traversed to find the boot-time device nodes and create the
character devices in /dev.
This new chardev ABI is *non* *optional* and can be counted
on to be present in the future, emphasizing the preference
of this ABI.
The ABI only implements one single ioctl() to get the name
and number of GPIO lines of a chip. Even this is debatable:
see it as a minimal example for review. This ABI shall be
ruthlessly reviewed and etched in stone.
The old /sys/class/gpio is still optional to compile in,
but will be deprecated.
Unique device IDs are created using IDR, which is overkill
and insanely scalable, but also well tested.
Cc: Johan Hovold <johan@kernel.org>
Cc: Michael Welling <mwelling@ieee.org>
Cc: Markus Pargmann <mpa@pengutronix.de>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2015-10-21 07:29:53 -06:00
|
|
|
#include <linux/cdev.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/uaccess.h>
|
|
|
|
#include <uapi/linux/gpio.h>
|
2008-02-04 23:28:20 -07:00
|
|
|
|
2014-01-08 03:40:54 -07:00
|
|
|
#include "gpiolib.h"
|
|
|
|
|
2011-05-20 00:40:19 -06:00
|
|
|
#define CREATE_TRACE_POINTS
|
|
|
|
#include <trace/events/gpio.h>
|
2008-02-04 23:28:20 -07:00
|
|
|
|
2013-10-17 11:21:36 -06:00
|
|
|
/* Implementation infrastructure for GPIO interfaces.
|
2008-02-04 23:28:20 -07:00
|
|
|
*
|
2013-10-17 11:21:36 -06:00
|
|
|
* The GPIO programming interface allows for inlining speed-critical
|
|
|
|
* get/set operations for common cases, so that access to SOC-integrated
|
|
|
|
* GPIOs can sometimes cost only an instruction or two per bit.
|
2008-02-04 23:28:20 -07:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
/* When debugging, extend minimal trust to callers and platform code.
|
|
|
|
* Also emit diagnostic messages that may help initial bringup, when
|
|
|
|
* board setup or driver bugs are most common.
|
|
|
|
*
|
|
|
|
* Otherwise, minimize overhead in what may be bitbanging codepaths.
|
|
|
|
*/
|
|
|
|
#ifdef DEBUG
|
|
|
|
#define extra_checks 1
|
|
|
|
#else
|
|
|
|
#define extra_checks 0
|
|
|
|
#endif
|
|
|
|
|
2015-10-20 03:10:38 -06:00
|
|
|
/* Device and char device-related information */
|
|
|
|
static DEFINE_IDA(gpio_ida);
|
gpio: add a userspace chardev ABI for GPIOs
A new chardev that is to be used for userspace GPIO access is
added in this patch. It is intended to gradually replace the
horribly broken sysfs ABI.
Using a chardev has many upsides:
- All operations are per-gpiochip, which is the actual
device underlying the GPIOs, making us tie in to the
kernel device model properly.
- Hotpluggable GPIO controllers can come and go, as this
kind of problem has been know to userspace for character
devices since ages, and if a gpiochip handle is held in
userspace we know we will break something, whereas the
sysfs is stateless.
- The one-value-per-file rule of sysfs is really hard to
maintain when you want to twist more than one knob at a time,
for example have in-kernel APIs to switch several GPIO
lines at the same time, and this will be possible to do
with a single ioctl() from userspace, saving a lot of
context switching.
We also need to add a new bus type for GPIO. This is
necessary for example for userspace coldplug, where sysfs is
traversed to find the boot-time device nodes and create the
character devices in /dev.
This new chardev ABI is *non* *optional* and can be counted
on to be present in the future, emphasizing the preference
of this ABI.
The ABI only implements one single ioctl() to get the name
and number of GPIO lines of a chip. Even this is debatable:
see it as a minimal example for review. This ABI shall be
ruthlessly reviewed and etched in stone.
The old /sys/class/gpio is still optional to compile in,
but will be deprecated.
Unique device IDs are created using IDR, which is overkill
and insanely scalable, but also well tested.
Cc: Johan Hovold <johan@kernel.org>
Cc: Michael Welling <mwelling@ieee.org>
Cc: Markus Pargmann <mpa@pengutronix.de>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2015-10-21 07:29:53 -06:00
|
|
|
static dev_t gpio_devt;
|
|
|
|
#define GPIO_DEV_MAX 256 /* 256 GPIO chip devices supported */
|
|
|
|
static struct bus_type gpio_bus_type = {
|
|
|
|
.name = "gpio",
|
|
|
|
};
|
2015-10-20 03:10:38 -06:00
|
|
|
|
2008-02-04 23:28:20 -07:00
|
|
|
/* gpio_lock prevents conflicts during gpio_desc[] table updates.
|
|
|
|
* While any GPIO is requested, its gpio_chip is not removable;
|
|
|
|
* each GPIO's "requested" flag serves as a lock and refcount.
|
|
|
|
*/
|
2014-06-30 23:45:15 -06:00
|
|
|
DEFINE_SPINLOCK(gpio_lock);
|
2008-02-04 23:28:20 -07:00
|
|
|
|
2013-10-17 11:21:38 -06:00
|
|
|
static DEFINE_MUTEX(gpio_lookup_lock);
|
|
|
|
static LIST_HEAD(gpio_lookup_list);
|
2015-10-20 03:10:38 -06:00
|
|
|
LIST_HEAD(gpio_devices);
|
2015-05-04 09:23:25 -06:00
|
|
|
|
|
|
|
static void gpiochip_free_hogs(struct gpio_chip *chip);
|
|
|
|
static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip);
|
|
|
|
|
2016-03-31 09:11:30 -06:00
|
|
|
static bool gpiolib_initialized;
|
2015-05-04 09:23:25 -06:00
|
|
|
|
2008-02-04 23:28:20 -07:00
|
|
|
static inline void desc_set_label(struct gpio_desc *d, const char *label)
|
|
|
|
{
|
|
|
|
d->label = label;
|
|
|
|
}
|
|
|
|
|
2013-02-02 09:29:29 -07:00
|
|
|
/**
|
|
|
|
* Convert a GPIO number to its descriptor
|
|
|
|
*/
|
2013-10-17 11:21:36 -06:00
|
|
|
struct gpio_desc *gpio_to_desc(unsigned gpio)
|
2013-02-02 09:29:29 -07:00
|
|
|
{
|
2015-10-20 03:10:38 -06:00
|
|
|
struct gpio_device *gdev;
|
2014-11-19 00:51:27 -07:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&gpio_lock, flags);
|
|
|
|
|
2015-10-20 03:10:38 -06:00
|
|
|
list_for_each_entry(gdev, &gpio_devices, list) {
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
if (gdev->base <= gpio &&
|
|
|
|
gdev->base + gdev->ngpio > gpio) {
|
2014-11-19 00:51:27 -07:00
|
|
|
spin_unlock_irqrestore(&gpio_lock, flags);
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
return &gdev->descs[gpio - gdev->base];
|
2014-11-19 00:51:27 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&gpio_lock, flags);
|
|
|
|
|
2014-12-02 07:15:05 -07:00
|
|
|
if (!gpio_is_valid(gpio))
|
|
|
|
WARN(1, "invalid GPIO %d\n", gpio);
|
|
|
|
|
2014-11-19 00:51:27 -07:00
|
|
|
return NULL;
|
2013-02-02 09:29:29 -07:00
|
|
|
}
|
2013-10-17 11:21:36 -06:00
|
|
|
EXPORT_SYMBOL_GPL(gpio_to_desc);
|
2013-02-02 09:29:29 -07:00
|
|
|
|
2013-09-24 03:54:38 -06:00
|
|
|
/**
|
2014-02-09 01:43:54 -07:00
|
|
|
* Get the GPIO descriptor corresponding to the given hw number for this chip.
|
2013-09-24 03:54:38 -06:00
|
|
|
*/
|
2014-02-09 01:43:54 -07:00
|
|
|
struct gpio_desc *gpiochip_get_desc(struct gpio_chip *chip,
|
|
|
|
u16 hwnum)
|
2013-09-24 03:54:38 -06:00
|
|
|
{
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
struct gpio_device *gdev = chip->gpiodev;
|
|
|
|
|
|
|
|
if (hwnum >= gdev->ngpio)
|
2013-12-02 20:31:11 -07:00
|
|
|
return ERR_PTR(-EINVAL);
|
2013-09-24 03:54:38 -06:00
|
|
|
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
return &gdev->descs[hwnum];
|
2013-09-24 03:54:38 -06:00
|
|
|
}
|
2013-02-02 09:29:29 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Convert a GPIO descriptor to the integer namespace.
|
|
|
|
* This should disappear in the future but is needed since we still
|
|
|
|
* use GPIO numbers for error messages and sysfs nodes
|
|
|
|
*/
|
2013-10-17 11:21:36 -06:00
|
|
|
int desc_to_gpio(const struct gpio_desc *desc)
|
2013-02-02 09:29:29 -07:00
|
|
|
{
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
return desc->gdev->base + (desc - &desc->gdev->descs[0]);
|
2013-02-02 09:29:29 -07:00
|
|
|
}
|
2013-10-17 11:21:36 -06:00
|
|
|
EXPORT_SYMBOL_GPL(desc_to_gpio);
|
2013-02-02 09:29:29 -07:00
|
|
|
|
|
|
|
|
2013-10-17 11:21:36 -06:00
|
|
|
/**
|
|
|
|
* gpiod_to_chip - Return the GPIO chip to which a GPIO descriptor belongs
|
|
|
|
* @desc: descriptor to return the chip of
|
|
|
|
*/
|
|
|
|
struct gpio_chip *gpiod_to_chip(const struct gpio_desc *desc)
|
2013-02-02 09:29:29 -07:00
|
|
|
{
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
if (!desc || !desc->gdev || !desc->gdev->chip)
|
|
|
|
return NULL;
|
|
|
|
return desc->gdev->chip;
|
2013-02-02 09:29:29 -07:00
|
|
|
}
|
2013-10-17 11:21:36 -06:00
|
|
|
EXPORT_SYMBOL_GPL(gpiod_to_chip);
|
2008-02-04 23:28:20 -07:00
|
|
|
|
2008-04-28 03:14:46 -06:00
|
|
|
/* dynamic allocation of GPIOs, e.g. on a hotplugged device */
|
|
|
|
static int gpiochip_find_base(int ngpio)
|
|
|
|
{
|
2015-10-20 03:10:38 -06:00
|
|
|
struct gpio_device *gdev;
|
2013-02-02 09:29:28 -07:00
|
|
|
int base = ARCH_NR_GPIOS - ngpio;
|
2008-04-28 03:14:46 -06:00
|
|
|
|
2015-10-20 03:10:38 -06:00
|
|
|
list_for_each_entry_reverse(gdev, &gpio_devices, list) {
|
2013-02-02 09:29:28 -07:00
|
|
|
/* found a free space? */
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
if (gdev->base + gdev->ngpio <= base)
|
2013-02-02 09:29:28 -07:00
|
|
|
break;
|
|
|
|
else
|
|
|
|
/* nope, check the space right before the chip */
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
base = gdev->base - ngpio;
|
2008-04-28 03:14:46 -06:00
|
|
|
}
|
|
|
|
|
2013-02-02 09:29:28 -07:00
|
|
|
if (gpio_is_valid(base)) {
|
2008-04-28 03:14:46 -06:00
|
|
|
pr_debug("%s: found new base at %d\n", __func__, base);
|
2013-02-02 09:29:28 -07:00
|
|
|
return base;
|
|
|
|
} else {
|
|
|
|
pr_err("%s: cannot find free range\n", __func__);
|
|
|
|
return -ENOSPC;
|
2008-04-28 03:14:47 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-10-17 11:21:36 -06:00
|
|
|
/**
|
|
|
|
* gpiod_get_direction - return the current direction of a GPIO
|
|
|
|
* @desc: GPIO to get the direction of
|
|
|
|
*
|
|
|
|
* Return GPIOF_DIR_IN or GPIOF_DIR_OUT, or an error code in case of error.
|
|
|
|
*
|
|
|
|
* This function may sleep if gpiod_cansleep() is true.
|
|
|
|
*/
|
2014-11-25 01:16:31 -07:00
|
|
|
int gpiod_get_direction(struct gpio_desc *desc)
|
2012-10-24 08:25:27 -06:00
|
|
|
{
|
|
|
|
struct gpio_chip *chip;
|
2013-02-02 09:29:29 -07:00
|
|
|
unsigned offset;
|
2012-10-24 08:25:27 -06:00
|
|
|
int status = -EINVAL;
|
|
|
|
|
2013-02-02 09:29:29 -07:00
|
|
|
chip = gpiod_to_chip(desc);
|
|
|
|
offset = gpio_chip_hwgpio(desc);
|
2012-10-24 08:25:27 -06:00
|
|
|
|
|
|
|
if (!chip->get_direction)
|
|
|
|
return status;
|
|
|
|
|
2013-02-02 09:29:29 -07:00
|
|
|
status = chip->get_direction(chip, offset);
|
2012-10-24 08:25:27 -06:00
|
|
|
if (status > 0) {
|
|
|
|
/* GPIOF_DIR_IN, or other positive */
|
|
|
|
status = 1;
|
2014-11-25 01:16:31 -07:00
|
|
|
clear_bit(FLAG_IS_OUT, &desc->flags);
|
2012-10-24 08:25:27 -06:00
|
|
|
}
|
|
|
|
if (status == 0) {
|
|
|
|
/* GPIOF_DIR_OUT */
|
2014-11-25 01:16:31 -07:00
|
|
|
set_bit(FLAG_IS_OUT, &desc->flags);
|
2012-10-24 08:25:27 -06:00
|
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
2013-10-17 11:21:36 -06:00
|
|
|
EXPORT_SYMBOL_GPL(gpiod_get_direction);
|
2012-10-24 08:25:27 -06:00
|
|
|
|
2013-02-02 09:29:24 -07:00
|
|
|
/*
|
|
|
|
* Add a new chip to the global chips list, keeping the list of chips sorted
|
2015-11-15 22:02:46 -07:00
|
|
|
* by range(means [base, base + ngpio - 1]) order.
|
2013-02-02 09:29:24 -07:00
|
|
|
*
|
|
|
|
* Return -EBUSY if the new chip overlaps with some other chip's integer
|
|
|
|
* space.
|
|
|
|
*/
|
2015-10-20 03:10:38 -06:00
|
|
|
static int gpiodev_add_to_list(struct gpio_device *gdev)
|
2013-02-02 09:29:24 -07:00
|
|
|
{
|
2016-02-26 07:37:14 -07:00
|
|
|
struct gpio_device *prev, *next;
|
2013-02-02 09:29:24 -07:00
|
|
|
|
2015-10-20 03:10:38 -06:00
|
|
|
if (list_empty(&gpio_devices)) {
|
2016-02-26 07:37:14 -07:00
|
|
|
/* initial entry in list */
|
2015-10-20 03:10:38 -06:00
|
|
|
list_add_tail(&gdev->list, &gpio_devices);
|
2015-12-27 06:36:50 -07:00
|
|
|
return 0;
|
2013-02-02 09:29:24 -07:00
|
|
|
}
|
|
|
|
|
2016-02-26 07:37:14 -07:00
|
|
|
next = list_entry(gpio_devices.next, struct gpio_device, list);
|
|
|
|
if (gdev->base + gdev->ngpio <= next->base) {
|
|
|
|
/* add before first entry */
|
|
|
|
list_add(&gdev->list, &gpio_devices);
|
|
|
|
return 0;
|
2013-02-02 09:29:24 -07:00
|
|
|
}
|
|
|
|
|
2016-02-26 07:37:14 -07:00
|
|
|
prev = list_entry(gpio_devices.prev, struct gpio_device, list);
|
|
|
|
if (prev->base + prev->ngpio <= gdev->base) {
|
|
|
|
/* add behind last entry */
|
|
|
|
list_add_tail(&gdev->list, &gpio_devices);
|
2016-01-07 14:46:45 -07:00
|
|
|
return 0;
|
2013-02-02 09:29:24 -07:00
|
|
|
}
|
|
|
|
|
2016-02-26 07:37:14 -07:00
|
|
|
list_for_each_entry_safe(prev, next, &gpio_devices, list) {
|
|
|
|
/* at the end of the list */
|
|
|
|
if (&next->list == &gpio_devices)
|
|
|
|
break;
|
2013-02-02 09:29:24 -07:00
|
|
|
|
2016-02-26 07:37:14 -07:00
|
|
|
/* add between prev and next */
|
|
|
|
if (prev->base + prev->ngpio <= gdev->base
|
|
|
|
&& gdev->base + gdev->ngpio <= next->base) {
|
|
|
|
list_add(&gdev->list, &prev->list);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
dev_err(&gdev->dev, "GPIO integer space overlap, cannot add chip\n");
|
|
|
|
return -EBUSY;
|
2013-02-02 09:29:24 -07:00
|
|
|
}
|
|
|
|
|
2015-09-23 17:20:43 -06:00
|
|
|
/**
|
|
|
|
* Convert a GPIO name to its descriptor
|
|
|
|
*/
|
|
|
|
static struct gpio_desc *gpio_name_to_desc(const char * const name)
|
|
|
|
{
|
2015-10-20 03:10:38 -06:00
|
|
|
struct gpio_device *gdev;
|
2015-09-23 17:20:43 -06:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&gpio_lock, flags);
|
|
|
|
|
2015-10-20 03:10:38 -06:00
|
|
|
list_for_each_entry(gdev, &gpio_devices, list) {
|
2015-09-23 17:20:43 -06:00
|
|
|
int i;
|
|
|
|
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
for (i = 0; i != gdev->ngpio; ++i) {
|
|
|
|
struct gpio_desc *desc = &gdev->descs[i];
|
2015-09-23 17:20:43 -06:00
|
|
|
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
if (!desc->name || !name)
|
2015-09-23 17:20:43 -06:00
|
|
|
continue;
|
|
|
|
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
if (!strcmp(desc->name, name)) {
|
2015-09-23 17:20:43 -06:00
|
|
|
spin_unlock_irqrestore(&gpio_lock, flags);
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
return desc;
|
2015-09-23 17:20:43 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&gpio_lock, flags);
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-08-14 08:11:00 -06:00
|
|
|
/*
|
|
|
|
* Takes the names from gc->names and checks if they are all unique. If they
|
|
|
|
* are, they are assigned to their gpio descriptors.
|
|
|
|
*
|
2015-11-14 01:43:20 -07:00
|
|
|
* Warning if one of the names is already used for a different GPIO.
|
2015-08-14 08:11:00 -06:00
|
|
|
*/
|
|
|
|
static int gpiochip_set_desc_names(struct gpio_chip *gc)
|
|
|
|
{
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
struct gpio_device *gdev = gc->gpiodev;
|
2015-08-14 08:11:00 -06:00
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!gc->names)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* First check all names if they are unique */
|
|
|
|
for (i = 0; i != gc->ngpio; ++i) {
|
|
|
|
struct gpio_desc *gpio;
|
|
|
|
|
|
|
|
gpio = gpio_name_to_desc(gc->names[i]);
|
2015-09-23 17:20:43 -06:00
|
|
|
if (gpio)
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
dev_warn(&gdev->dev,
|
2015-10-20 03:31:54 -06:00
|
|
|
"Detected name collision for GPIO name '%s'\n",
|
2015-09-23 17:20:43 -06:00
|
|
|
gc->names[i]);
|
2015-08-14 08:11:00 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Then add all names to the GPIO descriptors */
|
|
|
|
for (i = 0; i != gc->ngpio; ++i)
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
gdev->descs[i].name = gc->names[i];
|
2015-08-14 08:11:00 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
gpio: add a userspace chardev ABI for GPIOs
A new chardev that is to be used for userspace GPIO access is
added in this patch. It is intended to gradually replace the
horribly broken sysfs ABI.
Using a chardev has many upsides:
- All operations are per-gpiochip, which is the actual
device underlying the GPIOs, making us tie in to the
kernel device model properly.
- Hotpluggable GPIO controllers can come and go, as this
kind of problem has been know to userspace for character
devices since ages, and if a gpiochip handle is held in
userspace we know we will break something, whereas the
sysfs is stateless.
- The one-value-per-file rule of sysfs is really hard to
maintain when you want to twist more than one knob at a time,
for example have in-kernel APIs to switch several GPIO
lines at the same time, and this will be possible to do
with a single ioctl() from userspace, saving a lot of
context switching.
We also need to add a new bus type for GPIO. This is
necessary for example for userspace coldplug, where sysfs is
traversed to find the boot-time device nodes and create the
character devices in /dev.
This new chardev ABI is *non* *optional* and can be counted
on to be present in the future, emphasizing the preference
of this ABI.
The ABI only implements one single ioctl() to get the name
and number of GPIO lines of a chip. Even this is debatable:
see it as a minimal example for review. This ABI shall be
ruthlessly reviewed and etched in stone.
The old /sys/class/gpio is still optional to compile in,
but will be deprecated.
Unique device IDs are created using IDR, which is overkill
and insanely scalable, but also well tested.
Cc: Johan Hovold <johan@kernel.org>
Cc: Michael Welling <mwelling@ieee.org>
Cc: Markus Pargmann <mpa@pengutronix.de>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2015-10-21 07:29:53 -06:00
|
|
|
/**
|
|
|
|
* gpio_ioctl() - ioctl handler for the GPIO chardev
|
|
|
|
*/
|
|
|
|
static long gpio_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
|
|
|
|
{
|
|
|
|
struct gpio_device *gdev = filp->private_data;
|
|
|
|
struct gpio_chip *chip = gdev->chip;
|
|
|
|
int __user *ip = (int __user *)arg;
|
|
|
|
|
|
|
|
/* We fail any subsequent ioctl():s when the chip is gone */
|
|
|
|
if (!chip)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2016-02-12 14:25:22 -07:00
|
|
|
/* Fill in the struct and pass to userspace */
|
gpio: add a userspace chardev ABI for GPIOs
A new chardev that is to be used for userspace GPIO access is
added in this patch. It is intended to gradually replace the
horribly broken sysfs ABI.
Using a chardev has many upsides:
- All operations are per-gpiochip, which is the actual
device underlying the GPIOs, making us tie in to the
kernel device model properly.
- Hotpluggable GPIO controllers can come and go, as this
kind of problem has been know to userspace for character
devices since ages, and if a gpiochip handle is held in
userspace we know we will break something, whereas the
sysfs is stateless.
- The one-value-per-file rule of sysfs is really hard to
maintain when you want to twist more than one knob at a time,
for example have in-kernel APIs to switch several GPIO
lines at the same time, and this will be possible to do
with a single ioctl() from userspace, saving a lot of
context switching.
We also need to add a new bus type for GPIO. This is
necessary for example for userspace coldplug, where sysfs is
traversed to find the boot-time device nodes and create the
character devices in /dev.
This new chardev ABI is *non* *optional* and can be counted
on to be present in the future, emphasizing the preference
of this ABI.
The ABI only implements one single ioctl() to get the name
and number of GPIO lines of a chip. Even this is debatable:
see it as a minimal example for review. This ABI shall be
ruthlessly reviewed and etched in stone.
The old /sys/class/gpio is still optional to compile in,
but will be deprecated.
Unique device IDs are created using IDR, which is overkill
and insanely scalable, but also well tested.
Cc: Johan Hovold <johan@kernel.org>
Cc: Michael Welling <mwelling@ieee.org>
Cc: Markus Pargmann <mpa@pengutronix.de>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2015-10-21 07:29:53 -06:00
|
|
|
if (cmd == GPIO_GET_CHIPINFO_IOCTL) {
|
2016-02-12 14:25:22 -07:00
|
|
|
struct gpiochip_info chipinfo;
|
|
|
|
|
gpio: add a userspace chardev ABI for GPIOs
A new chardev that is to be used for userspace GPIO access is
added in this patch. It is intended to gradually replace the
horribly broken sysfs ABI.
Using a chardev has many upsides:
- All operations are per-gpiochip, which is the actual
device underlying the GPIOs, making us tie in to the
kernel device model properly.
- Hotpluggable GPIO controllers can come and go, as this
kind of problem has been know to userspace for character
devices since ages, and if a gpiochip handle is held in
userspace we know we will break something, whereas the
sysfs is stateless.
- The one-value-per-file rule of sysfs is really hard to
maintain when you want to twist more than one knob at a time,
for example have in-kernel APIs to switch several GPIO
lines at the same time, and this will be possible to do
with a single ioctl() from userspace, saving a lot of
context switching.
We also need to add a new bus type for GPIO. This is
necessary for example for userspace coldplug, where sysfs is
traversed to find the boot-time device nodes and create the
character devices in /dev.
This new chardev ABI is *non* *optional* and can be counted
on to be present in the future, emphasizing the preference
of this ABI.
The ABI only implements one single ioctl() to get the name
and number of GPIO lines of a chip. Even this is debatable:
see it as a minimal example for review. This ABI shall be
ruthlessly reviewed and etched in stone.
The old /sys/class/gpio is still optional to compile in,
but will be deprecated.
Unique device IDs are created using IDR, which is overkill
and insanely scalable, but also well tested.
Cc: Johan Hovold <johan@kernel.org>
Cc: Michael Welling <mwelling@ieee.org>
Cc: Markus Pargmann <mpa@pengutronix.de>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2015-10-21 07:29:53 -06:00
|
|
|
strncpy(chipinfo.name, dev_name(&gdev->dev),
|
|
|
|
sizeof(chipinfo.name));
|
|
|
|
chipinfo.name[sizeof(chipinfo.name)-1] = '\0';
|
2016-02-12 06:48:23 -07:00
|
|
|
strncpy(chipinfo.label, gdev->label,
|
|
|
|
sizeof(chipinfo.label));
|
|
|
|
chipinfo.label[sizeof(chipinfo.label)-1] = '\0';
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
chipinfo.lines = gdev->ngpio;
|
gpio: add a userspace chardev ABI for GPIOs
A new chardev that is to be used for userspace GPIO access is
added in this patch. It is intended to gradually replace the
horribly broken sysfs ABI.
Using a chardev has many upsides:
- All operations are per-gpiochip, which is the actual
device underlying the GPIOs, making us tie in to the
kernel device model properly.
- Hotpluggable GPIO controllers can come and go, as this
kind of problem has been know to userspace for character
devices since ages, and if a gpiochip handle is held in
userspace we know we will break something, whereas the
sysfs is stateless.
- The one-value-per-file rule of sysfs is really hard to
maintain when you want to twist more than one knob at a time,
for example have in-kernel APIs to switch several GPIO
lines at the same time, and this will be possible to do
with a single ioctl() from userspace, saving a lot of
context switching.
We also need to add a new bus type for GPIO. This is
necessary for example for userspace coldplug, where sysfs is
traversed to find the boot-time device nodes and create the
character devices in /dev.
This new chardev ABI is *non* *optional* and can be counted
on to be present in the future, emphasizing the preference
of this ABI.
The ABI only implements one single ioctl() to get the name
and number of GPIO lines of a chip. Even this is debatable:
see it as a minimal example for review. This ABI shall be
ruthlessly reviewed and etched in stone.
The old /sys/class/gpio is still optional to compile in,
but will be deprecated.
Unique device IDs are created using IDR, which is overkill
and insanely scalable, but also well tested.
Cc: Johan Hovold <johan@kernel.org>
Cc: Michael Welling <mwelling@ieee.org>
Cc: Markus Pargmann <mpa@pengutronix.de>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2015-10-21 07:29:53 -06:00
|
|
|
if (copy_to_user(ip, &chipinfo, sizeof(chipinfo)))
|
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
2016-02-12 14:25:22 -07:00
|
|
|
} else if (cmd == GPIO_GET_LINEINFO_IOCTL) {
|
|
|
|
struct gpioline_info lineinfo;
|
|
|
|
struct gpio_desc *desc;
|
|
|
|
|
|
|
|
if (copy_from_user(&lineinfo, ip, sizeof(lineinfo)))
|
|
|
|
return -EFAULT;
|
|
|
|
if (lineinfo.line_offset > gdev->ngpio)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
desc = &gdev->descs[lineinfo.line_offset];
|
|
|
|
if (desc->name) {
|
|
|
|
strncpy(lineinfo.name, desc->name,
|
|
|
|
sizeof(lineinfo.name));
|
|
|
|
lineinfo.name[sizeof(lineinfo.name)-1] = '\0';
|
|
|
|
} else {
|
|
|
|
lineinfo.name[0] = '\0';
|
|
|
|
}
|
|
|
|
if (desc->label) {
|
2016-02-25 13:01:48 -07:00
|
|
|
strncpy(lineinfo.consumer, desc->label,
|
|
|
|
sizeof(lineinfo.consumer));
|
|
|
|
lineinfo.consumer[sizeof(lineinfo.consumer)-1] = '\0';
|
2016-02-12 14:25:22 -07:00
|
|
|
} else {
|
2016-02-25 13:01:48 -07:00
|
|
|
lineinfo.consumer[0] = '\0';
|
2016-02-12 14:25:22 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Userspace only need to know that the kernel is using
|
|
|
|
* this GPIO so it can't use it.
|
|
|
|
*/
|
|
|
|
lineinfo.flags = 0;
|
2016-02-22 05:44:53 -07:00
|
|
|
if (test_bit(FLAG_REQUESTED, &desc->flags) ||
|
|
|
|
test_bit(FLAG_IS_HOGGED, &desc->flags) ||
|
|
|
|
test_bit(FLAG_USED_AS_IRQ, &desc->flags) ||
|
|
|
|
test_bit(FLAG_EXPORT, &desc->flags) ||
|
|
|
|
test_bit(FLAG_SYSFS, &desc->flags))
|
2016-02-12 14:25:22 -07:00
|
|
|
lineinfo.flags |= GPIOLINE_FLAG_KERNEL;
|
2016-02-22 05:44:53 -07:00
|
|
|
if (test_bit(FLAG_IS_OUT, &desc->flags))
|
2016-02-12 14:25:22 -07:00
|
|
|
lineinfo.flags |= GPIOLINE_FLAG_IS_OUT;
|
2016-02-22 05:44:53 -07:00
|
|
|
if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
|
2016-02-12 14:25:22 -07:00
|
|
|
lineinfo.flags |= GPIOLINE_FLAG_ACTIVE_LOW;
|
2016-02-22 05:44:53 -07:00
|
|
|
if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
|
2016-02-12 14:25:22 -07:00
|
|
|
lineinfo.flags |= GPIOLINE_FLAG_OPEN_DRAIN;
|
2016-02-22 05:44:53 -07:00
|
|
|
if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
|
2016-02-12 14:25:22 -07:00
|
|
|
lineinfo.flags |= GPIOLINE_FLAG_OPEN_SOURCE;
|
|
|
|
|
|
|
|
if (copy_to_user(ip, &lineinfo, sizeof(lineinfo)))
|
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
gpio: add a userspace chardev ABI for GPIOs
A new chardev that is to be used for userspace GPIO access is
added in this patch. It is intended to gradually replace the
horribly broken sysfs ABI.
Using a chardev has many upsides:
- All operations are per-gpiochip, which is the actual
device underlying the GPIOs, making us tie in to the
kernel device model properly.
- Hotpluggable GPIO controllers can come and go, as this
kind of problem has been know to userspace for character
devices since ages, and if a gpiochip handle is held in
userspace we know we will break something, whereas the
sysfs is stateless.
- The one-value-per-file rule of sysfs is really hard to
maintain when you want to twist more than one knob at a time,
for example have in-kernel APIs to switch several GPIO
lines at the same time, and this will be possible to do
with a single ioctl() from userspace, saving a lot of
context switching.
We also need to add a new bus type for GPIO. This is
necessary for example for userspace coldplug, where sysfs is
traversed to find the boot-time device nodes and create the
character devices in /dev.
This new chardev ABI is *non* *optional* and can be counted
on to be present in the future, emphasizing the preference
of this ABI.
The ABI only implements one single ioctl() to get the name
and number of GPIO lines of a chip. Even this is debatable:
see it as a minimal example for review. This ABI shall be
ruthlessly reviewed and etched in stone.
The old /sys/class/gpio is still optional to compile in,
but will be deprecated.
Unique device IDs are created using IDR, which is overkill
and insanely scalable, but also well tested.
Cc: Johan Hovold <johan@kernel.org>
Cc: Michael Welling <mwelling@ieee.org>
Cc: Markus Pargmann <mpa@pengutronix.de>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2015-10-21 07:29:53 -06:00
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gpio_chrdev_open() - open the chardev for ioctl operations
|
|
|
|
* @inode: inode for this chardev
|
|
|
|
* @filp: file struct for storing private data
|
|
|
|
* Returns 0 on success
|
|
|
|
*/
|
|
|
|
static int gpio_chrdev_open(struct inode *inode, struct file *filp)
|
|
|
|
{
|
|
|
|
struct gpio_device *gdev = container_of(inode->i_cdev,
|
|
|
|
struct gpio_device, chrdev);
|
|
|
|
|
|
|
|
/* Fail on open if the backing gpiochip is gone */
|
|
|
|
if (!gdev || !gdev->chip)
|
|
|
|
return -ENODEV;
|
|
|
|
get_device(&gdev->dev);
|
|
|
|
filp->private_data = gdev;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gpio_chrdev_release() - close chardev after ioctl operations
|
|
|
|
* @inode: inode for this chardev
|
|
|
|
* @filp: file struct for storing private data
|
|
|
|
* Returns 0 on success
|
|
|
|
*/
|
|
|
|
static int gpio_chrdev_release(struct inode *inode, struct file *filp)
|
|
|
|
{
|
|
|
|
struct gpio_device *gdev = container_of(inode->i_cdev,
|
|
|
|
struct gpio_device, chrdev);
|
|
|
|
|
|
|
|
if (!gdev)
|
|
|
|
return -ENODEV;
|
|
|
|
put_device(&gdev->dev);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static const struct file_operations gpio_fileops = {
|
|
|
|
.release = gpio_chrdev_release,
|
|
|
|
.open = gpio_chrdev_open,
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.llseek = noop_llseek,
|
|
|
|
.unlocked_ioctl = gpio_ioctl,
|
|
|
|
.compat_ioctl = gpio_ioctl,
|
|
|
|
};
|
|
|
|
|
2015-10-20 03:10:38 -06:00
|
|
|
static void gpiodevice_release(struct device *dev)
|
|
|
|
{
|
|
|
|
struct gpio_device *gdev = dev_get_drvdata(dev);
|
|
|
|
|
gpio: add a userspace chardev ABI for GPIOs
A new chardev that is to be used for userspace GPIO access is
added in this patch. It is intended to gradually replace the
horribly broken sysfs ABI.
Using a chardev has many upsides:
- All operations are per-gpiochip, which is the actual
device underlying the GPIOs, making us tie in to the
kernel device model properly.
- Hotpluggable GPIO controllers can come and go, as this
kind of problem has been know to userspace for character
devices since ages, and if a gpiochip handle is held in
userspace we know we will break something, whereas the
sysfs is stateless.
- The one-value-per-file rule of sysfs is really hard to
maintain when you want to twist more than one knob at a time,
for example have in-kernel APIs to switch several GPIO
lines at the same time, and this will be possible to do
with a single ioctl() from userspace, saving a lot of
context switching.
We also need to add a new bus type for GPIO. This is
necessary for example for userspace coldplug, where sysfs is
traversed to find the boot-time device nodes and create the
character devices in /dev.
This new chardev ABI is *non* *optional* and can be counted
on to be present in the future, emphasizing the preference
of this ABI.
The ABI only implements one single ioctl() to get the name
and number of GPIO lines of a chip. Even this is debatable:
see it as a minimal example for review. This ABI shall be
ruthlessly reviewed and etched in stone.
The old /sys/class/gpio is still optional to compile in,
but will be deprecated.
Unique device IDs are created using IDR, which is overkill
and insanely scalable, but also well tested.
Cc: Johan Hovold <johan@kernel.org>
Cc: Michael Welling <mwelling@ieee.org>
Cc: Markus Pargmann <mpa@pengutronix.de>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2015-10-21 07:29:53 -06:00
|
|
|
cdev_del(&gdev->chrdev);
|
2015-10-20 03:10:38 -06:00
|
|
|
list_del(&gdev->list);
|
|
|
|
ida_simple_remove(&gpio_ida, gdev->id);
|
2016-03-31 09:11:29 -06:00
|
|
|
kfree(gdev->label);
|
|
|
|
kfree(gdev->descs);
|
2016-02-09 06:27:42 -07:00
|
|
|
kfree(gdev);
|
2015-10-20 03:10:38 -06:00
|
|
|
}
|
|
|
|
|
2016-03-31 09:11:30 -06:00
|
|
|
static int gpiochip_setup_dev(struct gpio_device *gdev)
|
|
|
|
{
|
|
|
|
int status;
|
|
|
|
|
|
|
|
cdev_init(&gdev->chrdev, &gpio_fileops);
|
|
|
|
gdev->chrdev.owner = THIS_MODULE;
|
|
|
|
gdev->chrdev.kobj.parent = &gdev->dev.kobj;
|
|
|
|
gdev->dev.devt = MKDEV(MAJOR(gpio_devt), gdev->id);
|
|
|
|
status = cdev_add(&gdev->chrdev, gdev->dev.devt, 1);
|
|
|
|
if (status < 0)
|
|
|
|
chip_warn(gdev->chip, "failed to add char device %d:%d\n",
|
|
|
|
MAJOR(gpio_devt), gdev->id);
|
|
|
|
else
|
|
|
|
chip_dbg(gdev->chip, "added GPIO chardev (%d:%d)\n",
|
|
|
|
MAJOR(gpio_devt), gdev->id);
|
|
|
|
status = device_add(&gdev->dev);
|
|
|
|
if (status)
|
|
|
|
goto err_remove_chardev;
|
|
|
|
|
|
|
|
status = gpiochip_sysfs_register(gdev);
|
|
|
|
if (status)
|
|
|
|
goto err_remove_device;
|
|
|
|
|
|
|
|
/* From this point, the .release() function cleans up gpio_device */
|
|
|
|
gdev->dev.release = gpiodevice_release;
|
|
|
|
get_device(&gdev->dev);
|
|
|
|
pr_debug("%s: registered GPIOs %d to %d on device: %s (%s)\n",
|
|
|
|
__func__, gdev->base, gdev->base + gdev->ngpio - 1,
|
|
|
|
dev_name(&gdev->dev), gdev->chip->label ? : "generic");
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_remove_device:
|
|
|
|
device_del(&gdev->dev);
|
|
|
|
err_remove_chardev:
|
|
|
|
cdev_del(&gdev->chrdev);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void gpiochip_setup_devs(void)
|
|
|
|
{
|
|
|
|
struct gpio_device *gdev;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
list_for_each_entry(gdev, &gpio_devices, list) {
|
|
|
|
err = gpiochip_setup_dev(gdev);
|
|
|
|
if (err)
|
|
|
|
pr_err("%s: Failed to initialize gpio device (%d)\n",
|
|
|
|
dev_name(&gdev->dev), err);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-04 23:28:20 -07:00
|
|
|
/**
|
2015-12-03 07:14:13 -07:00
|
|
|
* gpiochip_add_data() - register a gpio_chip
|
2008-02-04 23:28:20 -07:00
|
|
|
* @chip: the chip to register, with chip->base initialized
|
2014-11-19 00:51:27 -07:00
|
|
|
* Context: potentially before irqs will work
|
2008-02-04 23:28:20 -07:00
|
|
|
*
|
|
|
|
* Returns a negative errno if the chip can't be registered, such as
|
|
|
|
* because the chip->base is invalid or already associated with a
|
|
|
|
* different chip. Otherwise it returns zero as a success code.
|
2008-04-28 03:14:46 -06:00
|
|
|
*
|
2015-12-03 07:14:13 -07:00
|
|
|
* When gpiochip_add_data() is called very early during boot, so that GPIOs
|
2015-11-18 02:07:07 -07:00
|
|
|
* can be freely used, the chip->parent device must be registered before
|
gpio: sysfs interface
This adds a simple sysfs interface for GPIOs.
/sys/class/gpio
/export ... asks the kernel to export a GPIO to userspace
/unexport ... to return a GPIO to the kernel
/gpioN ... for each exported GPIO #N
/value ... always readable, writes fail for input GPIOs
/direction ... r/w as: in, out (default low); write high, low
/gpiochipN ... for each gpiochip; #N is its first GPIO
/base ... (r/o) same as N
/label ... (r/o) descriptive, not necessarily unique
/ngpio ... (r/o) number of GPIOs; numbered N .. N+(ngpio - 1)
GPIOs claimed by kernel code may be exported by its owner using a new
gpio_export() call, which should be most useful for driver debugging.
Such exports may optionally be done without a "direction" attribute.
Userspace may ask to take over a GPIO by writing to a sysfs control file,
helping to cope with incomplete board support or other "one-off"
requirements that don't merit full kernel support:
echo 23 > /sys/class/gpio/export
... will gpio_request(23, "sysfs") and gpio_export(23);
use /sys/class/gpio/gpio-23/direction to (re)configure it,
when that GPIO can be used as both input and output.
echo 23 > /sys/class/gpio/unexport
... will gpio_free(23), when it was exported as above
The extra D-space footprint is a few hundred bytes, except for the sysfs
resources associated with each exported GPIO. The additional I-space
footprint is about two thirds of the current size of gpiolib (!). Since
no /dev node creation is involved, no "udev" support is needed.
Related changes:
* This adds a device pointer to "struct gpio_chip". When GPIO
providers initialize that, sysfs gpio class devices become children of
that device instead of being "virtual" devices.
* The (few) gpio_chip providers which have such a device node have
been updated.
* Some gpio_chip drivers also needed to update their module "owner"
field ... for which missing kerneldoc was added.
* Some gpio_chips don't support input GPIOs. Those GPIOs are now
flagged appropriately when the chip is registered.
Based on previous patches, and discussion both on and off LKML.
A Documentation/ABI/testing/sysfs-gpio update is ready to submit once this
merges to mainline.
[akpm@linux-foundation.org: a few maintenance build fixes]
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Cc: Guennadi Liakhovetski <g.liakhovetski@pengutronix.de>
Cc: Greg KH <greg@kroah.com>
Cc: Kay Sievers <kay.sievers@vrfy.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-07-25 02:46:07 -06:00
|
|
|
* the gpio framework's arch_initcall(). Otherwise sysfs initialization
|
|
|
|
* for GPIOs will fail rudely.
|
|
|
|
*
|
2016-03-31 09:11:30 -06:00
|
|
|
* gpiochip_add_data() must only be called after gpiolib initialization,
|
|
|
|
* ie after core_initcall().
|
|
|
|
*
|
2008-04-28 03:14:46 -06:00
|
|
|
* If chip->base is negative, this requests dynamic assignment of
|
|
|
|
* a range of valid GPIOs.
|
2008-02-04 23:28:20 -07:00
|
|
|
*/
|
2015-12-03 07:14:13 -07:00
|
|
|
int gpiochip_add_data(struct gpio_chip *chip, void *data)
|
2008-02-04 23:28:20 -07:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
int status = 0;
|
2015-10-20 03:10:38 -06:00
|
|
|
unsigned i;
|
2008-04-28 03:14:46 -06:00
|
|
|
int base = chip->base;
|
2015-10-20 03:10:38 -06:00
|
|
|
struct gpio_device *gdev;
|
2008-02-04 23:28:20 -07:00
|
|
|
|
2015-10-20 03:10:38 -06:00
|
|
|
/*
|
|
|
|
* First: allocate and populate the internal stat container, and
|
|
|
|
* set up the struct device.
|
|
|
|
*/
|
2016-02-17 15:44:15 -07:00
|
|
|
gdev = kzalloc(sizeof(*gdev), GFP_KERNEL);
|
2015-10-20 03:10:38 -06:00
|
|
|
if (!gdev)
|
2014-11-19 00:51:27 -07:00
|
|
|
return -ENOMEM;
|
gpio: add a userspace chardev ABI for GPIOs
A new chardev that is to be used for userspace GPIO access is
added in this patch. It is intended to gradually replace the
horribly broken sysfs ABI.
Using a chardev has many upsides:
- All operations are per-gpiochip, which is the actual
device underlying the GPIOs, making us tie in to the
kernel device model properly.
- Hotpluggable GPIO controllers can come and go, as this
kind of problem has been know to userspace for character
devices since ages, and if a gpiochip handle is held in
userspace we know we will break something, whereas the
sysfs is stateless.
- The one-value-per-file rule of sysfs is really hard to
maintain when you want to twist more than one knob at a time,
for example have in-kernel APIs to switch several GPIO
lines at the same time, and this will be possible to do
with a single ioctl() from userspace, saving a lot of
context switching.
We also need to add a new bus type for GPIO. This is
necessary for example for userspace coldplug, where sysfs is
traversed to find the boot-time device nodes and create the
character devices in /dev.
This new chardev ABI is *non* *optional* and can be counted
on to be present in the future, emphasizing the preference
of this ABI.
The ABI only implements one single ioctl() to get the name
and number of GPIO lines of a chip. Even this is debatable:
see it as a minimal example for review. This ABI shall be
ruthlessly reviewed and etched in stone.
The old /sys/class/gpio is still optional to compile in,
but will be deprecated.
Unique device IDs are created using IDR, which is overkill
and insanely scalable, but also well tested.
Cc: Johan Hovold <johan@kernel.org>
Cc: Michael Welling <mwelling@ieee.org>
Cc: Markus Pargmann <mpa@pengutronix.de>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2015-10-21 07:29:53 -06:00
|
|
|
gdev->dev.bus = &gpio_bus_type;
|
2015-10-20 03:10:38 -06:00
|
|
|
gdev->chip = chip;
|
|
|
|
chip->gpiodev = gdev;
|
|
|
|
if (chip->parent) {
|
|
|
|
gdev->dev.parent = chip->parent;
|
|
|
|
gdev->dev.of_node = chip->parent->of_node;
|
|
|
|
} else {
|
|
|
|
#ifdef CONFIG_OF_GPIO
|
|
|
|
/* If the gpiochip has an assigned OF node this takes precedence */
|
|
|
|
if (chip->of_node)
|
|
|
|
gdev->dev.of_node = chip->of_node;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
gdev->id = ida_simple_get(&gpio_ida, 0, 0, GFP_KERNEL);
|
|
|
|
if (gdev->id < 0) {
|
|
|
|
status = gdev->id;
|
|
|
|
goto err_free_gdev;
|
|
|
|
}
|
|
|
|
dev_set_name(&gdev->dev, "gpiochip%d", gdev->id);
|
|
|
|
device_initialize(&gdev->dev);
|
|
|
|
dev_set_drvdata(&gdev->dev, gdev);
|
|
|
|
if (chip->parent && chip->parent->driver)
|
|
|
|
gdev->owner = chip->parent->driver->owner;
|
|
|
|
else if (chip->owner)
|
|
|
|
/* TODO: remove chip->owner */
|
|
|
|
gdev->owner = chip->owner;
|
|
|
|
else
|
|
|
|
gdev->owner = THIS_MODULE;
|
2008-02-04 23:28:20 -07:00
|
|
|
|
2016-03-31 09:11:29 -06:00
|
|
|
gdev->descs = kcalloc(chip->ngpio, sizeof(gdev->descs[0]), GFP_KERNEL);
|
2016-02-09 05:51:59 -07:00
|
|
|
if (!gdev->descs) {
|
2015-10-20 03:10:38 -06:00
|
|
|
status = -ENOMEM;
|
|
|
|
goto err_free_gdev;
|
|
|
|
}
|
|
|
|
|
2015-11-15 22:02:47 -07:00
|
|
|
if (chip->ngpio == 0) {
|
|
|
|
chip_err(chip, "tried to insert a GPIO chip with zero lines\n");
|
2015-10-20 03:10:38 -06:00
|
|
|
status = -EINVAL;
|
2016-03-31 09:11:30 -06:00
|
|
|
goto err_free_descs;
|
2015-11-15 22:02:47 -07:00
|
|
|
}
|
2016-02-12 06:48:23 -07:00
|
|
|
|
|
|
|
if (chip->label)
|
2016-03-31 09:11:29 -06:00
|
|
|
gdev->label = kstrdup(chip->label, GFP_KERNEL);
|
2016-02-12 06:48:23 -07:00
|
|
|
else
|
2016-03-31 09:11:29 -06:00
|
|
|
gdev->label = kstrdup("unknown", GFP_KERNEL);
|
2016-02-12 06:48:23 -07:00
|
|
|
if (!gdev->label) {
|
|
|
|
status = -ENOMEM;
|
2016-03-31 09:11:29 -06:00
|
|
|
goto err_free_descs;
|
2016-02-12 06:48:23 -07:00
|
|
|
}
|
|
|
|
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
gdev->ngpio = chip->ngpio;
|
2016-02-11 03:37:48 -07:00
|
|
|
gdev->data = data;
|
2015-11-15 22:02:47 -07:00
|
|
|
|
2008-02-04 23:28:20 -07:00
|
|
|
spin_lock_irqsave(&gpio_lock, flags);
|
|
|
|
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
/*
|
|
|
|
* TODO: this allocates a Linux GPIO number base in the global
|
|
|
|
* GPIO numberspace for this chip. In the long run we want to
|
|
|
|
* get *rid* of this numberspace and use only descriptors, but
|
|
|
|
* it may be a pipe dream. It will not happen before we get rid
|
|
|
|
* of the sysfs interface anyways.
|
|
|
|
*/
|
2008-04-28 03:14:46 -06:00
|
|
|
if (base < 0) {
|
|
|
|
base = gpiochip_find_base(chip->ngpio);
|
|
|
|
if (base < 0) {
|
|
|
|
status = base;
|
2015-01-12 09:12:25 -07:00
|
|
|
spin_unlock_irqrestore(&gpio_lock, flags);
|
2016-03-31 09:11:29 -06:00
|
|
|
goto err_free_label;
|
2008-04-28 03:14:46 -06:00
|
|
|
}
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
/*
|
|
|
|
* TODO: it should not be necessary to reflect the assigned
|
|
|
|
* base outside of the GPIO subsystem. Go over drivers and
|
|
|
|
* see if anyone makes use of this, else drop this and assign
|
|
|
|
* a poison instead.
|
|
|
|
*/
|
2008-04-28 03:14:46 -06:00
|
|
|
chip->base = base;
|
|
|
|
}
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
gdev->base = base;
|
2008-04-28 03:14:46 -06:00
|
|
|
|
2015-10-20 03:10:38 -06:00
|
|
|
status = gpiodev_add_to_list(gdev);
|
2015-01-12 09:12:26 -07:00
|
|
|
if (status) {
|
|
|
|
spin_unlock_irqrestore(&gpio_lock, flags);
|
2016-03-31 09:11:29 -06:00
|
|
|
goto err_free_label;
|
2015-01-12 09:12:26 -07:00
|
|
|
}
|
2013-02-02 09:29:24 -07:00
|
|
|
|
2015-10-20 03:10:38 -06:00
|
|
|
for (i = 0; i < chip->ngpio; i++) {
|
2016-02-09 05:51:59 -07:00
|
|
|
struct gpio_desc *desc = &gdev->descs[i];
|
2015-01-12 09:12:26 -07:00
|
|
|
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
desc->gdev = gdev;
|
2015-01-12 09:12:26 -07:00
|
|
|
|
|
|
|
/* REVISIT: most hardware initializes GPIOs as inputs (often
|
|
|
|
* with pullups enabled) so power usage is minimized. Linux
|
|
|
|
* code should set the gpio direction first thing; but until
|
|
|
|
* it does, and in case chip->get_direction is not set, we may
|
|
|
|
* expose the wrong direction in sysfs.
|
|
|
|
*/
|
|
|
|
desc->flags = !chip->direction_input ? (1 << FLAG_IS_OUT) : 0;
|
2008-02-04 23:28:20 -07:00
|
|
|
}
|
2014-11-19 00:51:27 -07:00
|
|
|
|
2013-06-08 21:08:32 -06:00
|
|
|
spin_unlock_irqrestore(&gpio_lock, flags);
|
|
|
|
|
2012-10-27 03:51:36 -06:00
|
|
|
#ifdef CONFIG_PINCTRL
|
2016-02-11 03:03:06 -07:00
|
|
|
INIT_LIST_HEAD(&gdev->pin_ranges);
|
2012-10-27 03:51:36 -06:00
|
|
|
#endif
|
|
|
|
|
2015-08-14 08:11:00 -06:00
|
|
|
status = gpiochip_set_desc_names(chip);
|
|
|
|
if (status)
|
|
|
|
goto err_remove_from_list;
|
|
|
|
|
2015-07-14 02:29:54 -06:00
|
|
|
status = of_gpiochip_add(chip);
|
|
|
|
if (status)
|
|
|
|
goto err_remove_chip;
|
|
|
|
|
2014-01-08 03:40:54 -07:00
|
|
|
acpi_gpiochip_add(chip);
|
2010-06-08 07:48:17 -06:00
|
|
|
|
gpio: add a userspace chardev ABI for GPIOs
A new chardev that is to be used for userspace GPIO access is
added in this patch. It is intended to gradually replace the
horribly broken sysfs ABI.
Using a chardev has many upsides:
- All operations are per-gpiochip, which is the actual
device underlying the GPIOs, making us tie in to the
kernel device model properly.
- Hotpluggable GPIO controllers can come and go, as this
kind of problem has been know to userspace for character
devices since ages, and if a gpiochip handle is held in
userspace we know we will break something, whereas the
sysfs is stateless.
- The one-value-per-file rule of sysfs is really hard to
maintain when you want to twist more than one knob at a time,
for example have in-kernel APIs to switch several GPIO
lines at the same time, and this will be possible to do
with a single ioctl() from userspace, saving a lot of
context switching.
We also need to add a new bus type for GPIO. This is
necessary for example for userspace coldplug, where sysfs is
traversed to find the boot-time device nodes and create the
character devices in /dev.
This new chardev ABI is *non* *optional* and can be counted
on to be present in the future, emphasizing the preference
of this ABI.
The ABI only implements one single ioctl() to get the name
and number of GPIO lines of a chip. Even this is debatable:
see it as a minimal example for review. This ABI shall be
ruthlessly reviewed and etched in stone.
The old /sys/class/gpio is still optional to compile in,
but will be deprecated.
Unique device IDs are created using IDR, which is overkill
and insanely scalable, but also well tested.
Cc: Johan Hovold <johan@kernel.org>
Cc: Michael Welling <mwelling@ieee.org>
Cc: Markus Pargmann <mpa@pengutronix.de>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2015-10-21 07:29:53 -06:00
|
|
|
/*
|
|
|
|
* By first adding the chardev, and then adding the device,
|
|
|
|
* we get a device node entry in sysfs under
|
|
|
|
* /sys/bus/gpio/devices/gpiochipN/dev that can be used for
|
|
|
|
* coldplug of device nodes and other udev business.
|
2016-03-31 09:11:30 -06:00
|
|
|
* We can do this only if gpiolib has been initialized.
|
|
|
|
* Otherwise, defer until later.
|
gpio: add a userspace chardev ABI for GPIOs
A new chardev that is to be used for userspace GPIO access is
added in this patch. It is intended to gradually replace the
horribly broken sysfs ABI.
Using a chardev has many upsides:
- All operations are per-gpiochip, which is the actual
device underlying the GPIOs, making us tie in to the
kernel device model properly.
- Hotpluggable GPIO controllers can come and go, as this
kind of problem has been know to userspace for character
devices since ages, and if a gpiochip handle is held in
userspace we know we will break something, whereas the
sysfs is stateless.
- The one-value-per-file rule of sysfs is really hard to
maintain when you want to twist more than one knob at a time,
for example have in-kernel APIs to switch several GPIO
lines at the same time, and this will be possible to do
with a single ioctl() from userspace, saving a lot of
context switching.
We also need to add a new bus type for GPIO. This is
necessary for example for userspace coldplug, where sysfs is
traversed to find the boot-time device nodes and create the
character devices in /dev.
This new chardev ABI is *non* *optional* and can be counted
on to be present in the future, emphasizing the preference
of this ABI.
The ABI only implements one single ioctl() to get the name
and number of GPIO lines of a chip. Even this is debatable:
see it as a minimal example for review. This ABI shall be
ruthlessly reviewed and etched in stone.
The old /sys/class/gpio is still optional to compile in,
but will be deprecated.
Unique device IDs are created using IDR, which is overkill
and insanely scalable, but also well tested.
Cc: Johan Hovold <johan@kernel.org>
Cc: Michael Welling <mwelling@ieee.org>
Cc: Markus Pargmann <mpa@pengutronix.de>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2015-10-21 07:29:53 -06:00
|
|
|
*/
|
2016-03-31 09:11:30 -06:00
|
|
|
if (gpiolib_initialized) {
|
|
|
|
status = gpiochip_setup_dev(gdev);
|
|
|
|
if (status)
|
|
|
|
goto err_remove_chip;
|
|
|
|
}
|
2010-06-08 07:48:15 -06:00
|
|
|
return 0;
|
2013-06-08 21:08:32 -06:00
|
|
|
|
2015-01-12 09:12:25 -07:00
|
|
|
err_remove_chip:
|
|
|
|
acpi_gpiochip_remove(chip);
|
2015-05-04 09:23:25 -06:00
|
|
|
gpiochip_free_hogs(chip);
|
2015-01-12 09:12:25 -07:00
|
|
|
of_gpiochip_remove(chip);
|
2015-08-14 08:11:00 -06:00
|
|
|
err_remove_from_list:
|
2015-01-12 09:12:25 -07:00
|
|
|
spin_lock_irqsave(&gpio_lock, flags);
|
2015-10-20 03:10:38 -06:00
|
|
|
list_del(&gdev->list);
|
2013-06-08 21:08:32 -06:00
|
|
|
spin_unlock_irqrestore(&gpio_lock, flags);
|
2016-03-31 09:11:29 -06:00
|
|
|
err_free_label:
|
|
|
|
kfree(gdev->label);
|
|
|
|
err_free_descs:
|
|
|
|
kfree(gdev->descs);
|
2015-10-20 03:10:38 -06:00
|
|
|
err_free_gdev:
|
|
|
|
ida_simple_remove(&gpio_ida, gdev->id);
|
2008-02-04 23:28:20 -07:00
|
|
|
/* failures here can mean systems won't boot... */
|
2013-12-05 02:26:23 -07:00
|
|
|
pr_err("%s: GPIOs %d..%d (%s) failed to register\n", __func__,
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
gdev->base, gdev->base + gdev->ngpio - 1,
|
|
|
|
chip->label ? : "generic");
|
|
|
|
kfree(gdev);
|
2008-02-04 23:28:20 -07:00
|
|
|
return status;
|
|
|
|
}
|
2015-12-03 07:14:13 -07:00
|
|
|
EXPORT_SYMBOL_GPL(gpiochip_add_data);
|
2008-02-04 23:28:20 -07:00
|
|
|
|
2016-02-11 03:37:48 -07:00
|
|
|
/**
|
|
|
|
* gpiochip_get_data() - get per-subdriver data for the chip
|
|
|
|
*/
|
|
|
|
void *gpiochip_get_data(struct gpio_chip *chip)
|
|
|
|
{
|
|
|
|
return chip->gpiodev->data;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(gpiochip_get_data);
|
|
|
|
|
2008-02-04 23:28:20 -07:00
|
|
|
/**
|
|
|
|
* gpiochip_remove() - unregister a gpio_chip
|
|
|
|
* @chip: the chip to unregister
|
|
|
|
*
|
|
|
|
* A gpio_chip with any GPIOs still requested may not be removed.
|
|
|
|
*/
|
2014-07-05 10:28:50 -06:00
|
|
|
void gpiochip_remove(struct gpio_chip *chip)
|
2008-02-04 23:28:20 -07:00
|
|
|
{
|
2015-10-20 03:10:38 -06:00
|
|
|
struct gpio_device *gdev = chip->gpiodev;
|
2015-05-04 09:10:27 -06:00
|
|
|
struct gpio_desc *desc;
|
2008-02-04 23:28:20 -07:00
|
|
|
unsigned long flags;
|
2016-02-09 05:51:59 -07:00
|
|
|
unsigned i;
|
2015-05-04 09:10:27 -06:00
|
|
|
bool requested = false;
|
2008-02-04 23:28:20 -07:00
|
|
|
|
2015-10-20 03:10:38 -06:00
|
|
|
/* FIXME: should the legacy sysfs handling be moved to gpio_device? */
|
2016-02-09 05:21:06 -07:00
|
|
|
gpiochip_sysfs_unregister(gdev);
|
2016-02-19 22:13:19 -07:00
|
|
|
/* Numb the device, cancelling all outstanding operations */
|
|
|
|
gdev->chip = NULL;
|
2015-01-12 09:12:27 -07:00
|
|
|
gpiochip_irqchip_remove(chip);
|
2014-03-10 06:54:53 -06:00
|
|
|
acpi_gpiochip_remove(chip);
|
2012-11-06 07:15:44 -07:00
|
|
|
gpiochip_remove_pin_ranges(chip);
|
2015-02-02 10:44:44 -07:00
|
|
|
gpiochip_free_hogs(chip);
|
2010-06-08 07:48:17 -06:00
|
|
|
of_gpiochip_remove(chip);
|
2016-02-11 03:37:48 -07:00
|
|
|
/*
|
|
|
|
* We accept no more calls into the driver from this point, so
|
|
|
|
* NULL the driver data pointer
|
|
|
|
*/
|
|
|
|
gdev->data = NULL;
|
2010-06-08 07:48:17 -06:00
|
|
|
|
2015-01-12 09:12:28 -07:00
|
|
|
spin_lock_irqsave(&gpio_lock, flags);
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
for (i = 0; i < gdev->ngpio; i++) {
|
2016-02-09 05:51:59 -07:00
|
|
|
desc = &gdev->descs[i];
|
2015-05-04 09:10:27 -06:00
|
|
|
if (test_bit(FLAG_REQUESTED, &desc->flags))
|
|
|
|
requested = true;
|
2008-02-04 23:28:20 -07:00
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&gpio_lock, flags);
|
2014-11-19 00:51:27 -07:00
|
|
|
|
2015-05-04 09:10:27 -06:00
|
|
|
if (requested)
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
dev_crit(&gdev->dev,
|
2015-11-04 01:56:26 -07:00
|
|
|
"REMOVING GPIOCHIP WITH GPIOS STILL REQUESTED\n");
|
2015-05-04 09:10:27 -06:00
|
|
|
|
2015-10-20 03:10:38 -06:00
|
|
|
/*
|
|
|
|
* The gpiochip side puts its use of the device to rest here:
|
|
|
|
* if there are no userspace clients, the chardev and device will
|
|
|
|
* be removed, else it will be dangling until the last user is
|
|
|
|
* gone.
|
|
|
|
*/
|
|
|
|
put_device(&gdev->dev);
|
2008-02-04 23:28:20 -07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(gpiochip_remove);
|
|
|
|
|
2016-02-15 04:02:09 -07:00
|
|
|
static void devm_gpio_chip_release(struct device *dev, void *res)
|
|
|
|
{
|
|
|
|
struct gpio_chip *chip = *(struct gpio_chip **)res;
|
|
|
|
|
|
|
|
gpiochip_remove(chip);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int devm_gpio_chip_match(struct device *dev, void *res, void *data)
|
|
|
|
|
|
|
|
{
|
|
|
|
struct gpio_chip **r = res;
|
|
|
|
|
|
|
|
if (!r || !*r) {
|
|
|
|
WARN_ON(!r || !*r);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return *r == data;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* devm_gpiochip_add_data() - Resource manager piochip_add_data()
|
|
|
|
* @dev: the device pointer on which irq_chip belongs to.
|
|
|
|
* @chip: the chip to register, with chip->base initialized
|
|
|
|
* Context: potentially before irqs will work
|
|
|
|
*
|
|
|
|
* Returns a negative errno if the chip can't be registered, such as
|
|
|
|
* because the chip->base is invalid or already associated with a
|
|
|
|
* different chip. Otherwise it returns zero as a success code.
|
|
|
|
*
|
|
|
|
* The gpio chip automatically be released when the device is unbound.
|
|
|
|
*/
|
|
|
|
int devm_gpiochip_add_data(struct device *dev, struct gpio_chip *chip,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
struct gpio_chip **ptr;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ptr = devres_alloc(devm_gpio_chip_release, sizeof(*ptr),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!ptr)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
ret = gpiochip_add_data(chip, data);
|
|
|
|
if (ret < 0) {
|
|
|
|
devres_free(ptr);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
*ptr = chip;
|
|
|
|
devres_add(dev, ptr);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(devm_gpiochip_add_data);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* devm_gpiochip_remove() - Resource manager of gpiochip_remove()
|
|
|
|
* @dev: device for which which resource was allocated
|
|
|
|
* @chip: the chip to remove
|
|
|
|
*
|
|
|
|
* A gpio_chip with any GPIOs still requested may not be removed.
|
|
|
|
*/
|
|
|
|
void devm_gpiochip_remove(struct device *dev, struct gpio_chip *chip)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = devres_release(dev, devm_gpio_chip_release,
|
|
|
|
devm_gpio_chip_match, chip);
|
|
|
|
if (!ret)
|
|
|
|
WARN_ON(ret);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(devm_gpiochip_remove);
|
|
|
|
|
2010-06-08 07:48:16 -06:00
|
|
|
/**
|
|
|
|
* gpiochip_find() - iterator for locating a specific gpio_chip
|
|
|
|
* @data: data to pass to match function
|
|
|
|
* @callback: Callback function to check gpio_chip
|
|
|
|
*
|
|
|
|
* Similar to bus_find_device. It returns a reference to a gpio_chip as
|
|
|
|
* determined by a user supplied @match callback. The callback should return
|
|
|
|
* 0 if the device doesn't match and non-zero if it does. If the callback is
|
|
|
|
* non-zero, this function will return to the caller and not iterate over any
|
|
|
|
* more gpio_chips.
|
|
|
|
*/
|
2012-05-18 23:01:05 -06:00
|
|
|
struct gpio_chip *gpiochip_find(void *data,
|
2012-03-02 15:56:03 -07:00
|
|
|
int (*match)(struct gpio_chip *chip,
|
2012-05-17 13:54:40 -06:00
|
|
|
void *data))
|
2010-06-08 07:48:16 -06:00
|
|
|
{
|
2015-10-20 03:10:38 -06:00
|
|
|
struct gpio_device *gdev;
|
2013-02-02 09:29:26 -07:00
|
|
|
struct gpio_chip *chip;
|
2010-06-08 07:48:16 -06:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&gpio_lock, flags);
|
2015-10-20 03:10:38 -06:00
|
|
|
list_for_each_entry(gdev, &gpio_devices, list)
|
|
|
|
if (match(gdev->chip, data))
|
2010-06-08 07:48:16 -06:00
|
|
|
break;
|
2013-02-02 09:29:26 -07:00
|
|
|
|
|
|
|
/* No match? */
|
2015-10-20 03:10:38 -06:00
|
|
|
if (&gdev->list == &gpio_devices)
|
2013-02-02 09:29:26 -07:00
|
|
|
chip = NULL;
|
2015-10-20 03:10:38 -06:00
|
|
|
else
|
|
|
|
chip = gdev->chip;
|
|
|
|
|
2010-06-08 07:48:16 -06:00
|
|
|
spin_unlock_irqrestore(&gpio_lock, flags);
|
|
|
|
|
|
|
|
return chip;
|
|
|
|
}
|
2011-05-20 00:40:18 -06:00
|
|
|
EXPORT_SYMBOL_GPL(gpiochip_find);
|
2008-02-04 23:28:20 -07:00
|
|
|
|
2013-11-16 05:39:32 -07:00
|
|
|
static int gpiochip_match_name(struct gpio_chip *chip, void *data)
|
|
|
|
{
|
|
|
|
const char *name = data;
|
|
|
|
|
|
|
|
return !strcmp(chip->label, name);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct gpio_chip *find_chip_by_name(const char *name)
|
|
|
|
{
|
|
|
|
return gpiochip_find((void *)name, gpiochip_match_name);
|
|
|
|
}
|
|
|
|
|
2014-03-25 03:40:18 -06:00
|
|
|
#ifdef CONFIG_GPIOLIB_IRQCHIP
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The following is irqchip helper code for gpiochips.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
2014-09-26 06:19:52 -06:00
|
|
|
* gpiochip_set_chained_irqchip() - sets a chained irqchip to a gpiochip
|
|
|
|
* @gpiochip: the gpiochip to set the irqchip chain to
|
|
|
|
* @irqchip: the irqchip to chain to the gpiochip
|
2014-03-25 03:40:18 -06:00
|
|
|
* @parent_irq: the irq number corresponding to the parent IRQ for this
|
|
|
|
* chained irqchip
|
|
|
|
* @parent_handler: the parent interrupt handler for the accumulated IRQ
|
2014-09-26 06:19:52 -06:00
|
|
|
* coming out of the gpiochip. If the interrupt is nested rather than
|
|
|
|
* cascaded, pass NULL in this handler argument
|
2014-03-25 03:40:18 -06:00
|
|
|
*/
|
|
|
|
void gpiochip_set_chained_irqchip(struct gpio_chip *gpiochip,
|
|
|
|
struct irq_chip *irqchip,
|
|
|
|
int parent_irq,
|
|
|
|
irq_flow_handler_t parent_handler)
|
|
|
|
{
|
2014-09-26 05:50:12 -06:00
|
|
|
unsigned int offset;
|
|
|
|
|
|
|
|
if (!gpiochip->irqdomain) {
|
|
|
|
chip_err(gpiochip, "called %s before setting up irqchip\n",
|
|
|
|
__func__);
|
2014-04-09 05:34:39 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-09-26 06:19:52 -06:00
|
|
|
if (parent_handler) {
|
|
|
|
if (gpiochip->can_sleep) {
|
|
|
|
chip_err(gpiochip,
|
|
|
|
"you cannot have chained interrupts on a "
|
|
|
|
"chip that may sleep\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* The parent irqchip is already using the chip_data for this
|
|
|
|
* irqchip, so our callbacks simply use the handler_data.
|
|
|
|
*/
|
2015-06-21 13:10:48 -06:00
|
|
|
irq_set_chained_handler_and_data(parent_irq, parent_handler,
|
|
|
|
gpiochip);
|
2015-05-12 11:12:23 -06:00
|
|
|
|
|
|
|
gpiochip->irq_parent = parent_irq;
|
2014-09-26 06:19:52 -06:00
|
|
|
}
|
2014-09-26 05:50:12 -06:00
|
|
|
|
|
|
|
/* Set the parent IRQ for all affected IRQs */
|
|
|
|
for (offset = 0; offset < gpiochip->ngpio; offset++)
|
|
|
|
irq_set_parent(irq_find_mapping(gpiochip->irqdomain, offset),
|
|
|
|
parent_irq);
|
2014-03-25 03:40:18 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(gpiochip_set_chained_irqchip);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gpiochip_irq_map() - maps an IRQ into a GPIO irqchip
|
|
|
|
* @d: the irqdomain used by this irqchip
|
|
|
|
* @irq: the global irq number used by this GPIO irqchip irq
|
|
|
|
* @hwirq: the local IRQ/GPIO line offset on this gpiochip
|
|
|
|
*
|
|
|
|
* This function will set up the mapping for a certain IRQ line on a
|
|
|
|
* gpiochip by assigning the gpiochip as chip data, and using the irqchip
|
|
|
|
* stored inside the gpiochip.
|
|
|
|
*/
|
|
|
|
static int gpiochip_irq_map(struct irq_domain *d, unsigned int irq,
|
|
|
|
irq_hw_number_t hwirq)
|
|
|
|
{
|
|
|
|
struct gpio_chip *chip = d->host_data;
|
|
|
|
|
|
|
|
irq_set_chip_data(irq, chip);
|
gpiolib: irqchip: use different lockdep class for each gpio irqchip
Since IRQ chip helpers were introduced drivers lose ability to
register separate lockdep classes for each registered GPIO IRQ
chip and the gpiolib now is using shared lockdep class for
all GPIO IRQ chips (gpiochip_irq_lock_class).
As result, lockdep will produce warning when there are min two
stacked GPIO chips and all of them are interrupt controllers.
HW configuration which generates lockdep warning (TI dra7-evm):
[SOC GPIO bankA.gpioX]
<- irq - [pcf875x.gpioY]
<- irq - DevZ.enable_irq_wake(pcf_gpioY_irq);
The issue was reported in [1] and discussed [2].
=============================================
[ INFO: possible recursive locking detected ]
4.2.0-rc6-00013-g5d050ed-dirty #55 Not tainted
---------------------------------------------
sh/63 is trying to acquire lock:
(class){......}, at: [<c009b91c>] __irq_get_desc_lock+0x50/0x94
but task is already holding lock:
(class){......}, at: [<c009b91c>] __irq_get_desc_lock+0x50/0x94
other info that might help us debug this:
Possible unsafe locking scenario:
CPU0
----
lock(class);
lock(class);
*** DEADLOCK ***
May be due to missing lock nesting notation
7 locks held by sh/63:
#0: (sb_writers#4){.+.+.+}, at: [<c016bbb8>] vfs_write+0x13c/0x164
#1: (&of->mutex){+.+.+.}, at: [<c01debf4>] kernfs_fop_write+0x4c/0x1a0
#2: (s_active#36){.+.+.+}, at: [<c01debfc>] kernfs_fop_write+0x54/0x1a0
#3: (pm_mutex){+.+.+.}, at: [<c009758c>] pm_suspend+0xec/0x4c4
#4: (&dev->mutex){......}, at: [<c03f77f8>] __device_suspend+0xd4/0x398
#5: (&gpio->lock){+.+.+.}, at: [<c009b940>] __irq_get_desc_lock+0x74/0x94
#6: (class){......}, at: [<c009b91c>] __irq_get_desc_lock+0x50/0x94
stack backtrace:
CPU: 0 PID: 63 Comm: sh Not tainted 4.2.0-rc6-00013-g5d050ed-dirty #55
Hardware name: Generic DRA74X (Flattened Device Tree)
[<c0016e24>] (unwind_backtrace) from [<c0013338>] (show_stack+0x10/0x14)
[<c0013338>] (show_stack) from [<c05f6b24>] (dump_stack+0x84/0x9c)
[<c05f6b24>] (dump_stack) from [<c00903f4>] (__lock_acquire+0x19c0/0x1e20)
[<c00903f4>] (__lock_acquire) from [<c0091098>] (lock_acquire+0xa8/0x128)
[<c0091098>] (lock_acquire) from [<c05fd61c>] (_raw_spin_lock_irqsave+0x38/0x4c)
[<c05fd61c>] (_raw_spin_lock_irqsave) from [<c009b91c>] (__irq_get_desc_lock+0x50/0x94)
[<c009b91c>] (__irq_get_desc_lock) from [<c009c4f4>] (irq_set_irq_wake+0x20/0xfc)
[<c009c4f4>] (irq_set_irq_wake) from [<c0393ac4>] (pcf857x_irq_set_wake+0x24/0x54)
[<c0393ac4>] (pcf857x_irq_set_wake) from [<c009c560>] (irq_set_irq_wake+0x8c/0xfc)
[<c009c560>] (irq_set_irq_wake) from [<c04a02ac>] (gpio_keys_suspend+0x70/0xd4)
[<c04a02ac>] (gpio_keys_suspend) from [<c03f6a00>] (dpm_run_callback+0x50/0x124)
[<c03f6a00>] (dpm_run_callback) from [<c03f7830>] (__device_suspend+0x10c/0x398)
[<c03f7830>] (__device_suspend) from [<c03f90f0>] (dpm_suspend+0x134/0x2f4)
[<c03f90f0>] (dpm_suspend) from [<c0096e20>] (suspend_devices_and_enter+0xa8/0x728)
[<c0096e20>] (suspend_devices_and_enter) from [<c00977cc>] (pm_suspend+0x32c/0x4c4)
[<c00977cc>] (pm_suspend) from [<c0096060>] (state_store+0x64/0xb8)
[<c0096060>] (state_store) from [<c01dec64>] (kernfs_fop_write+0xbc/0x1a0)
[<c01dec64>] (kernfs_fop_write) from [<c016b280>] (__vfs_write+0x20/0xd8)
[<c016b280>] (__vfs_write) from [<c016bb0c>] (vfs_write+0x90/0x164)
[<c016bb0c>] (vfs_write) from [<c016c330>] (SyS_write+0x44/0x9c)
[<c016c330>] (SyS_write) from [<c000f500>] (ret_fast_syscall+0x0/0x54)
Lets fix it by using separate lockdep class for each registered GPIO
IRQ Chip. This is done by wrapping gpiochip_irqchip_add call into macros.
The implementation of this patch inspired by solution done by Nicolas
Boichat for regmap [3]
[1] http://www.spinics.net/lists/linux-gpio/msg05844.html
[2] http://www.spinics.net/lists/linux-gpio/msg06021.html
[3] http://www.spinics.net/lists/arm-kernel/msg429834.html
Cc: Geert Uytterhoeven <geert@linux-m68k.org>
Cc: Roger Quadros <rogerq@ti.com>
Reported-by: Roger Quadros <rogerq@ti.com>
Tested-by: Roger Quadros <rogerq@ti.com>
Signed-off-by: Grygorii Strashko <grygorii.strashko@ti.com>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2015-08-17 06:35:23 -06:00
|
|
|
/*
|
|
|
|
* This lock class tells lockdep that GPIO irqs are in a different
|
|
|
|
* category than their parents, so it won't report false recursion.
|
|
|
|
*/
|
|
|
|
irq_set_lockdep_class(irq, chip->lock_key);
|
2014-04-09 05:20:38 -06:00
|
|
|
irq_set_chip_and_handler(irq, chip->irqchip, chip->irq_handler);
|
2014-04-09 05:34:39 -06:00
|
|
|
/* Chips that can sleep need nested thread handlers */
|
2014-09-19 14:22:44 -06:00
|
|
|
if (chip->can_sleep && !chip->irq_not_threaded)
|
2014-04-09 05:34:39 -06:00
|
|
|
irq_set_nested_thread(irq, 1);
|
2014-03-25 03:40:18 -06:00
|
|
|
irq_set_noprobe(irq);
|
2015-07-27 14:55:16 -06:00
|
|
|
|
2014-04-23 08:45:12 -06:00
|
|
|
/*
|
|
|
|
* No set-up of the hardware will happen if IRQ_TYPE_NONE
|
|
|
|
* is passed as default type.
|
|
|
|
*/
|
|
|
|
if (chip->irq_default_type != IRQ_TYPE_NONE)
|
|
|
|
irq_set_irq_type(irq, chip->irq_default_type);
|
2014-03-25 03:40:18 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-03-28 13:42:01 -06:00
|
|
|
static void gpiochip_irq_unmap(struct irq_domain *d, unsigned int irq)
|
|
|
|
{
|
2014-04-09 05:34:39 -06:00
|
|
|
struct gpio_chip *chip = d->host_data;
|
|
|
|
|
|
|
|
if (chip->can_sleep)
|
|
|
|
irq_set_nested_thread(irq, 0);
|
2014-03-28 13:42:01 -06:00
|
|
|
irq_set_chip_and_handler(irq, NULL, NULL);
|
|
|
|
irq_set_chip_data(irq, NULL);
|
|
|
|
}
|
|
|
|
|
2014-03-25 03:40:18 -06:00
|
|
|
static const struct irq_domain_ops gpiochip_domain_ops = {
|
|
|
|
.map = gpiochip_irq_map,
|
2014-03-28 13:42:01 -06:00
|
|
|
.unmap = gpiochip_irq_unmap,
|
2014-03-25 03:40:18 -06:00
|
|
|
/* Virtually all GPIO irqchips are twocell:ed */
|
|
|
|
.xlate = irq_domain_xlate_twocell,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int gpiochip_irq_reqres(struct irq_data *d)
|
|
|
|
{
|
|
|
|
struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
|
|
|
|
|
2015-10-20 03:10:38 -06:00
|
|
|
if (!try_module_get(chip->gpiodev->owner))
|
2015-06-25 11:30:50 -06:00
|
|
|
return -ENODEV;
|
|
|
|
|
2014-10-23 02:27:07 -06:00
|
|
|
if (gpiochip_lock_as_irq(chip, d->hwirq)) {
|
2014-03-25 03:40:18 -06:00
|
|
|
chip_err(chip,
|
|
|
|
"unable to lock HW IRQ %lu for IRQ\n",
|
|
|
|
d->hwirq);
|
2015-10-20 03:10:38 -06:00
|
|
|
module_put(chip->gpiodev->owner);
|
2014-03-25 03:40:18 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void gpiochip_irq_relres(struct irq_data *d)
|
|
|
|
{
|
|
|
|
struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
|
|
|
|
|
2014-10-23 02:27:07 -06:00
|
|
|
gpiochip_unlock_as_irq(chip, d->hwirq);
|
2015-10-20 03:10:38 -06:00
|
|
|
module_put(chip->gpiodev->owner);
|
2014-03-25 03:40:18 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int gpiochip_to_irq(struct gpio_chip *chip, unsigned offset)
|
|
|
|
{
|
|
|
|
return irq_find_mapping(chip->irqdomain, offset);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gpiochip_irqchip_remove() - removes an irqchip added to a gpiochip
|
|
|
|
* @gpiochip: the gpiochip to remove the irqchip from
|
|
|
|
*
|
|
|
|
* This is called only from gpiochip_remove()
|
|
|
|
*/
|
|
|
|
static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip)
|
|
|
|
{
|
2014-03-28 13:42:01 -06:00
|
|
|
unsigned int offset;
|
|
|
|
|
2014-07-25 00:54:48 -06:00
|
|
|
acpi_gpiochip_free_interrupts(gpiochip);
|
|
|
|
|
2015-05-12 11:12:23 -06:00
|
|
|
if (gpiochip->irq_parent) {
|
|
|
|
irq_set_chained_handler(gpiochip->irq_parent, NULL);
|
|
|
|
irq_set_handler_data(gpiochip->irq_parent, NULL);
|
|
|
|
}
|
|
|
|
|
2014-03-28 13:42:01 -06:00
|
|
|
/* Remove all IRQ mappings and delete the domain */
|
|
|
|
if (gpiochip->irqdomain) {
|
|
|
|
for (offset = 0; offset < gpiochip->ngpio; offset++)
|
2014-09-25 10:09:23 -06:00
|
|
|
irq_dispose_mapping(
|
|
|
|
irq_find_mapping(gpiochip->irqdomain, offset));
|
2014-03-25 03:40:18 -06:00
|
|
|
irq_domain_remove(gpiochip->irqdomain);
|
2014-03-28 13:42:01 -06:00
|
|
|
}
|
2014-03-25 03:40:18 -06:00
|
|
|
|
|
|
|
if (gpiochip->irqchip) {
|
|
|
|
gpiochip->irqchip->irq_request_resources = NULL;
|
|
|
|
gpiochip->irqchip->irq_release_resources = NULL;
|
|
|
|
gpiochip->irqchip = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gpiochip_irqchip_add() - adds an irqchip to a gpiochip
|
|
|
|
* @gpiochip: the gpiochip to add the irqchip to
|
|
|
|
* @irqchip: the irqchip to add to the gpiochip
|
|
|
|
* @first_irq: if not dynamically assigned, the base (first) IRQ to
|
|
|
|
* allocate gpiochip irqs from
|
|
|
|
* @handler: the irq handler to use (often a predefined irq core function)
|
2014-04-23 08:45:12 -06:00
|
|
|
* @type: the default type for IRQs on this irqchip, pass IRQ_TYPE_NONE
|
|
|
|
* to have the core avoid setting up any default type in the hardware.
|
gpiolib: irqchip: use different lockdep class for each gpio irqchip
Since IRQ chip helpers were introduced drivers lose ability to
register separate lockdep classes for each registered GPIO IRQ
chip and the gpiolib now is using shared lockdep class for
all GPIO IRQ chips (gpiochip_irq_lock_class).
As result, lockdep will produce warning when there are min two
stacked GPIO chips and all of them are interrupt controllers.
HW configuration which generates lockdep warning (TI dra7-evm):
[SOC GPIO bankA.gpioX]
<- irq - [pcf875x.gpioY]
<- irq - DevZ.enable_irq_wake(pcf_gpioY_irq);
The issue was reported in [1] and discussed [2].
=============================================
[ INFO: possible recursive locking detected ]
4.2.0-rc6-00013-g5d050ed-dirty #55 Not tainted
---------------------------------------------
sh/63 is trying to acquire lock:
(class){......}, at: [<c009b91c>] __irq_get_desc_lock+0x50/0x94
but task is already holding lock:
(class){......}, at: [<c009b91c>] __irq_get_desc_lock+0x50/0x94
other info that might help us debug this:
Possible unsafe locking scenario:
CPU0
----
lock(class);
lock(class);
*** DEADLOCK ***
May be due to missing lock nesting notation
7 locks held by sh/63:
#0: (sb_writers#4){.+.+.+}, at: [<c016bbb8>] vfs_write+0x13c/0x164
#1: (&of->mutex){+.+.+.}, at: [<c01debf4>] kernfs_fop_write+0x4c/0x1a0
#2: (s_active#36){.+.+.+}, at: [<c01debfc>] kernfs_fop_write+0x54/0x1a0
#3: (pm_mutex){+.+.+.}, at: [<c009758c>] pm_suspend+0xec/0x4c4
#4: (&dev->mutex){......}, at: [<c03f77f8>] __device_suspend+0xd4/0x398
#5: (&gpio->lock){+.+.+.}, at: [<c009b940>] __irq_get_desc_lock+0x74/0x94
#6: (class){......}, at: [<c009b91c>] __irq_get_desc_lock+0x50/0x94
stack backtrace:
CPU: 0 PID: 63 Comm: sh Not tainted 4.2.0-rc6-00013-g5d050ed-dirty #55
Hardware name: Generic DRA74X (Flattened Device Tree)
[<c0016e24>] (unwind_backtrace) from [<c0013338>] (show_stack+0x10/0x14)
[<c0013338>] (show_stack) from [<c05f6b24>] (dump_stack+0x84/0x9c)
[<c05f6b24>] (dump_stack) from [<c00903f4>] (__lock_acquire+0x19c0/0x1e20)
[<c00903f4>] (__lock_acquire) from [<c0091098>] (lock_acquire+0xa8/0x128)
[<c0091098>] (lock_acquire) from [<c05fd61c>] (_raw_spin_lock_irqsave+0x38/0x4c)
[<c05fd61c>] (_raw_spin_lock_irqsave) from [<c009b91c>] (__irq_get_desc_lock+0x50/0x94)
[<c009b91c>] (__irq_get_desc_lock) from [<c009c4f4>] (irq_set_irq_wake+0x20/0xfc)
[<c009c4f4>] (irq_set_irq_wake) from [<c0393ac4>] (pcf857x_irq_set_wake+0x24/0x54)
[<c0393ac4>] (pcf857x_irq_set_wake) from [<c009c560>] (irq_set_irq_wake+0x8c/0xfc)
[<c009c560>] (irq_set_irq_wake) from [<c04a02ac>] (gpio_keys_suspend+0x70/0xd4)
[<c04a02ac>] (gpio_keys_suspend) from [<c03f6a00>] (dpm_run_callback+0x50/0x124)
[<c03f6a00>] (dpm_run_callback) from [<c03f7830>] (__device_suspend+0x10c/0x398)
[<c03f7830>] (__device_suspend) from [<c03f90f0>] (dpm_suspend+0x134/0x2f4)
[<c03f90f0>] (dpm_suspend) from [<c0096e20>] (suspend_devices_and_enter+0xa8/0x728)
[<c0096e20>] (suspend_devices_and_enter) from [<c00977cc>] (pm_suspend+0x32c/0x4c4)
[<c00977cc>] (pm_suspend) from [<c0096060>] (state_store+0x64/0xb8)
[<c0096060>] (state_store) from [<c01dec64>] (kernfs_fop_write+0xbc/0x1a0)
[<c01dec64>] (kernfs_fop_write) from [<c016b280>] (__vfs_write+0x20/0xd8)
[<c016b280>] (__vfs_write) from [<c016bb0c>] (vfs_write+0x90/0x164)
[<c016bb0c>] (vfs_write) from [<c016c330>] (SyS_write+0x44/0x9c)
[<c016c330>] (SyS_write) from [<c000f500>] (ret_fast_syscall+0x0/0x54)
Lets fix it by using separate lockdep class for each registered GPIO
IRQ Chip. This is done by wrapping gpiochip_irqchip_add call into macros.
The implementation of this patch inspired by solution done by Nicolas
Boichat for regmap [3]
[1] http://www.spinics.net/lists/linux-gpio/msg05844.html
[2] http://www.spinics.net/lists/linux-gpio/msg06021.html
[3] http://www.spinics.net/lists/arm-kernel/msg429834.html
Cc: Geert Uytterhoeven <geert@linux-m68k.org>
Cc: Roger Quadros <rogerq@ti.com>
Reported-by: Roger Quadros <rogerq@ti.com>
Tested-by: Roger Quadros <rogerq@ti.com>
Signed-off-by: Grygorii Strashko <grygorii.strashko@ti.com>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2015-08-17 06:35:23 -06:00
|
|
|
* @lock_key: lockdep class
|
2014-03-25 03:40:18 -06:00
|
|
|
*
|
|
|
|
* This function closely associates a certain irqchip with a certain
|
|
|
|
* gpiochip, providing an irq domain to translate the local IRQs to
|
|
|
|
* global irqs in the gpiolib core, and making sure that the gpiochip
|
|
|
|
* is passed as chip data to all related functions. Driver callbacks
|
2015-12-07 07:31:58 -07:00
|
|
|
* need to use gpiochip_get_data() to get their local state containers back
|
2014-03-25 03:40:18 -06:00
|
|
|
* from the gpiochip passed as chip data. An irqdomain will be stored
|
|
|
|
* in the gpiochip that shall be used by the driver to handle IRQ number
|
|
|
|
* translation. The gpiochip will need to be initialized and registered
|
|
|
|
* before calling this function.
|
|
|
|
*
|
2014-03-28 13:42:01 -06:00
|
|
|
* This function will handle two cell:ed simple IRQs and assumes all
|
|
|
|
* the pins on the gpiochip can generate a unique IRQ. Everything else
|
2014-03-25 03:40:18 -06:00
|
|
|
* need to be open coded.
|
|
|
|
*/
|
gpiolib: irqchip: use different lockdep class for each gpio irqchip
Since IRQ chip helpers were introduced drivers lose ability to
register separate lockdep classes for each registered GPIO IRQ
chip and the gpiolib now is using shared lockdep class for
all GPIO IRQ chips (gpiochip_irq_lock_class).
As result, lockdep will produce warning when there are min two
stacked GPIO chips and all of them are interrupt controllers.
HW configuration which generates lockdep warning (TI dra7-evm):
[SOC GPIO bankA.gpioX]
<- irq - [pcf875x.gpioY]
<- irq - DevZ.enable_irq_wake(pcf_gpioY_irq);
The issue was reported in [1] and discussed [2].
=============================================
[ INFO: possible recursive locking detected ]
4.2.0-rc6-00013-g5d050ed-dirty #55 Not tainted
---------------------------------------------
sh/63 is trying to acquire lock:
(class){......}, at: [<c009b91c>] __irq_get_desc_lock+0x50/0x94
but task is already holding lock:
(class){......}, at: [<c009b91c>] __irq_get_desc_lock+0x50/0x94
other info that might help us debug this:
Possible unsafe locking scenario:
CPU0
----
lock(class);
lock(class);
*** DEADLOCK ***
May be due to missing lock nesting notation
7 locks held by sh/63:
#0: (sb_writers#4){.+.+.+}, at: [<c016bbb8>] vfs_write+0x13c/0x164
#1: (&of->mutex){+.+.+.}, at: [<c01debf4>] kernfs_fop_write+0x4c/0x1a0
#2: (s_active#36){.+.+.+}, at: [<c01debfc>] kernfs_fop_write+0x54/0x1a0
#3: (pm_mutex){+.+.+.}, at: [<c009758c>] pm_suspend+0xec/0x4c4
#4: (&dev->mutex){......}, at: [<c03f77f8>] __device_suspend+0xd4/0x398
#5: (&gpio->lock){+.+.+.}, at: [<c009b940>] __irq_get_desc_lock+0x74/0x94
#6: (class){......}, at: [<c009b91c>] __irq_get_desc_lock+0x50/0x94
stack backtrace:
CPU: 0 PID: 63 Comm: sh Not tainted 4.2.0-rc6-00013-g5d050ed-dirty #55
Hardware name: Generic DRA74X (Flattened Device Tree)
[<c0016e24>] (unwind_backtrace) from [<c0013338>] (show_stack+0x10/0x14)
[<c0013338>] (show_stack) from [<c05f6b24>] (dump_stack+0x84/0x9c)
[<c05f6b24>] (dump_stack) from [<c00903f4>] (__lock_acquire+0x19c0/0x1e20)
[<c00903f4>] (__lock_acquire) from [<c0091098>] (lock_acquire+0xa8/0x128)
[<c0091098>] (lock_acquire) from [<c05fd61c>] (_raw_spin_lock_irqsave+0x38/0x4c)
[<c05fd61c>] (_raw_spin_lock_irqsave) from [<c009b91c>] (__irq_get_desc_lock+0x50/0x94)
[<c009b91c>] (__irq_get_desc_lock) from [<c009c4f4>] (irq_set_irq_wake+0x20/0xfc)
[<c009c4f4>] (irq_set_irq_wake) from [<c0393ac4>] (pcf857x_irq_set_wake+0x24/0x54)
[<c0393ac4>] (pcf857x_irq_set_wake) from [<c009c560>] (irq_set_irq_wake+0x8c/0xfc)
[<c009c560>] (irq_set_irq_wake) from [<c04a02ac>] (gpio_keys_suspend+0x70/0xd4)
[<c04a02ac>] (gpio_keys_suspend) from [<c03f6a00>] (dpm_run_callback+0x50/0x124)
[<c03f6a00>] (dpm_run_callback) from [<c03f7830>] (__device_suspend+0x10c/0x398)
[<c03f7830>] (__device_suspend) from [<c03f90f0>] (dpm_suspend+0x134/0x2f4)
[<c03f90f0>] (dpm_suspend) from [<c0096e20>] (suspend_devices_and_enter+0xa8/0x728)
[<c0096e20>] (suspend_devices_and_enter) from [<c00977cc>] (pm_suspend+0x32c/0x4c4)
[<c00977cc>] (pm_suspend) from [<c0096060>] (state_store+0x64/0xb8)
[<c0096060>] (state_store) from [<c01dec64>] (kernfs_fop_write+0xbc/0x1a0)
[<c01dec64>] (kernfs_fop_write) from [<c016b280>] (__vfs_write+0x20/0xd8)
[<c016b280>] (__vfs_write) from [<c016bb0c>] (vfs_write+0x90/0x164)
[<c016bb0c>] (vfs_write) from [<c016c330>] (SyS_write+0x44/0x9c)
[<c016c330>] (SyS_write) from [<c000f500>] (ret_fast_syscall+0x0/0x54)
Lets fix it by using separate lockdep class for each registered GPIO
IRQ Chip. This is done by wrapping gpiochip_irqchip_add call into macros.
The implementation of this patch inspired by solution done by Nicolas
Boichat for regmap [3]
[1] http://www.spinics.net/lists/linux-gpio/msg05844.html
[2] http://www.spinics.net/lists/linux-gpio/msg06021.html
[3] http://www.spinics.net/lists/arm-kernel/msg429834.html
Cc: Geert Uytterhoeven <geert@linux-m68k.org>
Cc: Roger Quadros <rogerq@ti.com>
Reported-by: Roger Quadros <rogerq@ti.com>
Tested-by: Roger Quadros <rogerq@ti.com>
Signed-off-by: Grygorii Strashko <grygorii.strashko@ti.com>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2015-08-17 06:35:23 -06:00
|
|
|
int _gpiochip_irqchip_add(struct gpio_chip *gpiochip,
|
|
|
|
struct irq_chip *irqchip,
|
|
|
|
unsigned int first_irq,
|
|
|
|
irq_flow_handler_t handler,
|
|
|
|
unsigned int type,
|
|
|
|
struct lock_class_key *lock_key)
|
2014-03-25 03:40:18 -06:00
|
|
|
{
|
|
|
|
struct device_node *of_node;
|
|
|
|
unsigned int offset;
|
2014-03-28 13:42:01 -06:00
|
|
|
unsigned irq_base = 0;
|
2014-03-25 03:40:18 -06:00
|
|
|
|
|
|
|
if (!gpiochip || !irqchip)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2015-11-04 01:56:26 -07:00
|
|
|
if (!gpiochip->parent) {
|
2014-03-25 03:40:18 -06:00
|
|
|
pr_err("missing gpiochip .dev parent pointer\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2015-11-04 01:56:26 -07:00
|
|
|
of_node = gpiochip->parent->of_node;
|
2014-03-25 03:40:18 -06:00
|
|
|
#ifdef CONFIG_OF_GPIO
|
|
|
|
/*
|
2015-05-18 12:41:43 -06:00
|
|
|
* If the gpiochip has an assigned OF node this takes precedence
|
2015-11-18 02:07:07 -07:00
|
|
|
* FIXME: get rid of this and use gpiochip->parent->of_node
|
|
|
|
* everywhere
|
2014-03-25 03:40:18 -06:00
|
|
|
*/
|
|
|
|
if (gpiochip->of_node)
|
|
|
|
of_node = gpiochip->of_node;
|
|
|
|
#endif
|
|
|
|
gpiochip->irqchip = irqchip;
|
|
|
|
gpiochip->irq_handler = handler;
|
|
|
|
gpiochip->irq_default_type = type;
|
|
|
|
gpiochip->to_irq = gpiochip_to_irq;
|
gpiolib: irqchip: use different lockdep class for each gpio irqchip
Since IRQ chip helpers were introduced drivers lose ability to
register separate lockdep classes for each registered GPIO IRQ
chip and the gpiolib now is using shared lockdep class for
all GPIO IRQ chips (gpiochip_irq_lock_class).
As result, lockdep will produce warning when there are min two
stacked GPIO chips and all of them are interrupt controllers.
HW configuration which generates lockdep warning (TI dra7-evm):
[SOC GPIO bankA.gpioX]
<- irq - [pcf875x.gpioY]
<- irq - DevZ.enable_irq_wake(pcf_gpioY_irq);
The issue was reported in [1] and discussed [2].
=============================================
[ INFO: possible recursive locking detected ]
4.2.0-rc6-00013-g5d050ed-dirty #55 Not tainted
---------------------------------------------
sh/63 is trying to acquire lock:
(class){......}, at: [<c009b91c>] __irq_get_desc_lock+0x50/0x94
but task is already holding lock:
(class){......}, at: [<c009b91c>] __irq_get_desc_lock+0x50/0x94
other info that might help us debug this:
Possible unsafe locking scenario:
CPU0
----
lock(class);
lock(class);
*** DEADLOCK ***
May be due to missing lock nesting notation
7 locks held by sh/63:
#0: (sb_writers#4){.+.+.+}, at: [<c016bbb8>] vfs_write+0x13c/0x164
#1: (&of->mutex){+.+.+.}, at: [<c01debf4>] kernfs_fop_write+0x4c/0x1a0
#2: (s_active#36){.+.+.+}, at: [<c01debfc>] kernfs_fop_write+0x54/0x1a0
#3: (pm_mutex){+.+.+.}, at: [<c009758c>] pm_suspend+0xec/0x4c4
#4: (&dev->mutex){......}, at: [<c03f77f8>] __device_suspend+0xd4/0x398
#5: (&gpio->lock){+.+.+.}, at: [<c009b940>] __irq_get_desc_lock+0x74/0x94
#6: (class){......}, at: [<c009b91c>] __irq_get_desc_lock+0x50/0x94
stack backtrace:
CPU: 0 PID: 63 Comm: sh Not tainted 4.2.0-rc6-00013-g5d050ed-dirty #55
Hardware name: Generic DRA74X (Flattened Device Tree)
[<c0016e24>] (unwind_backtrace) from [<c0013338>] (show_stack+0x10/0x14)
[<c0013338>] (show_stack) from [<c05f6b24>] (dump_stack+0x84/0x9c)
[<c05f6b24>] (dump_stack) from [<c00903f4>] (__lock_acquire+0x19c0/0x1e20)
[<c00903f4>] (__lock_acquire) from [<c0091098>] (lock_acquire+0xa8/0x128)
[<c0091098>] (lock_acquire) from [<c05fd61c>] (_raw_spin_lock_irqsave+0x38/0x4c)
[<c05fd61c>] (_raw_spin_lock_irqsave) from [<c009b91c>] (__irq_get_desc_lock+0x50/0x94)
[<c009b91c>] (__irq_get_desc_lock) from [<c009c4f4>] (irq_set_irq_wake+0x20/0xfc)
[<c009c4f4>] (irq_set_irq_wake) from [<c0393ac4>] (pcf857x_irq_set_wake+0x24/0x54)
[<c0393ac4>] (pcf857x_irq_set_wake) from [<c009c560>] (irq_set_irq_wake+0x8c/0xfc)
[<c009c560>] (irq_set_irq_wake) from [<c04a02ac>] (gpio_keys_suspend+0x70/0xd4)
[<c04a02ac>] (gpio_keys_suspend) from [<c03f6a00>] (dpm_run_callback+0x50/0x124)
[<c03f6a00>] (dpm_run_callback) from [<c03f7830>] (__device_suspend+0x10c/0x398)
[<c03f7830>] (__device_suspend) from [<c03f90f0>] (dpm_suspend+0x134/0x2f4)
[<c03f90f0>] (dpm_suspend) from [<c0096e20>] (suspend_devices_and_enter+0xa8/0x728)
[<c0096e20>] (suspend_devices_and_enter) from [<c00977cc>] (pm_suspend+0x32c/0x4c4)
[<c00977cc>] (pm_suspend) from [<c0096060>] (state_store+0x64/0xb8)
[<c0096060>] (state_store) from [<c01dec64>] (kernfs_fop_write+0xbc/0x1a0)
[<c01dec64>] (kernfs_fop_write) from [<c016b280>] (__vfs_write+0x20/0xd8)
[<c016b280>] (__vfs_write) from [<c016bb0c>] (vfs_write+0x90/0x164)
[<c016bb0c>] (vfs_write) from [<c016c330>] (SyS_write+0x44/0x9c)
[<c016c330>] (SyS_write) from [<c000f500>] (ret_fast_syscall+0x0/0x54)
Lets fix it by using separate lockdep class for each registered GPIO
IRQ Chip. This is done by wrapping gpiochip_irqchip_add call into macros.
The implementation of this patch inspired by solution done by Nicolas
Boichat for regmap [3]
[1] http://www.spinics.net/lists/linux-gpio/msg05844.html
[2] http://www.spinics.net/lists/linux-gpio/msg06021.html
[3] http://www.spinics.net/lists/arm-kernel/msg429834.html
Cc: Geert Uytterhoeven <geert@linux-m68k.org>
Cc: Roger Quadros <rogerq@ti.com>
Reported-by: Roger Quadros <rogerq@ti.com>
Tested-by: Roger Quadros <rogerq@ti.com>
Signed-off-by: Grygorii Strashko <grygorii.strashko@ti.com>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2015-08-17 06:35:23 -06:00
|
|
|
gpiochip->lock_key = lock_key;
|
2014-03-25 03:40:18 -06:00
|
|
|
gpiochip->irqdomain = irq_domain_add_simple(of_node,
|
|
|
|
gpiochip->ngpio, first_irq,
|
|
|
|
&gpiochip_domain_ops, gpiochip);
|
|
|
|
if (!gpiochip->irqdomain) {
|
|
|
|
gpiochip->irqchip = NULL;
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2015-07-31 06:48:56 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* It is possible for a driver to override this, but only if the
|
|
|
|
* alternative functions are both implemented.
|
|
|
|
*/
|
|
|
|
if (!irqchip->irq_request_resources &&
|
|
|
|
!irqchip->irq_release_resources) {
|
|
|
|
irqchip->irq_request_resources = gpiochip_irq_reqres;
|
|
|
|
irqchip->irq_release_resources = gpiochip_irq_relres;
|
|
|
|
}
|
2014-03-25 03:40:18 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Prepare the mapping since the irqchip shall be orthogonal to
|
|
|
|
* any gpiochip calls. If the first_irq was zero, this is
|
|
|
|
* necessary to allocate descriptors for all IRQs.
|
|
|
|
*/
|
2014-03-28 13:42:01 -06:00
|
|
|
for (offset = 0; offset < gpiochip->ngpio; offset++) {
|
|
|
|
irq_base = irq_create_mapping(gpiochip->irqdomain, offset);
|
|
|
|
if (offset == 0)
|
|
|
|
/*
|
|
|
|
* Store the base into the gpiochip to be used when
|
|
|
|
* unmapping the irqs.
|
|
|
|
*/
|
|
|
|
gpiochip->irq_base = irq_base;
|
|
|
|
}
|
2014-03-25 03:40:18 -06:00
|
|
|
|
2014-07-25 00:54:48 -06:00
|
|
|
acpi_gpiochip_request_interrupts(gpiochip);
|
|
|
|
|
2014-03-25 03:40:18 -06:00
|
|
|
return 0;
|
|
|
|
}
|
gpiolib: irqchip: use different lockdep class for each gpio irqchip
Since IRQ chip helpers were introduced drivers lose ability to
register separate lockdep classes for each registered GPIO IRQ
chip and the gpiolib now is using shared lockdep class for
all GPIO IRQ chips (gpiochip_irq_lock_class).
As result, lockdep will produce warning when there are min two
stacked GPIO chips and all of them are interrupt controllers.
HW configuration which generates lockdep warning (TI dra7-evm):
[SOC GPIO bankA.gpioX]
<- irq - [pcf875x.gpioY]
<- irq - DevZ.enable_irq_wake(pcf_gpioY_irq);
The issue was reported in [1] and discussed [2].
=============================================
[ INFO: possible recursive locking detected ]
4.2.0-rc6-00013-g5d050ed-dirty #55 Not tainted
---------------------------------------------
sh/63 is trying to acquire lock:
(class){......}, at: [<c009b91c>] __irq_get_desc_lock+0x50/0x94
but task is already holding lock:
(class){......}, at: [<c009b91c>] __irq_get_desc_lock+0x50/0x94
other info that might help us debug this:
Possible unsafe locking scenario:
CPU0
----
lock(class);
lock(class);
*** DEADLOCK ***
May be due to missing lock nesting notation
7 locks held by sh/63:
#0: (sb_writers#4){.+.+.+}, at: [<c016bbb8>] vfs_write+0x13c/0x164
#1: (&of->mutex){+.+.+.}, at: [<c01debf4>] kernfs_fop_write+0x4c/0x1a0
#2: (s_active#36){.+.+.+}, at: [<c01debfc>] kernfs_fop_write+0x54/0x1a0
#3: (pm_mutex){+.+.+.}, at: [<c009758c>] pm_suspend+0xec/0x4c4
#4: (&dev->mutex){......}, at: [<c03f77f8>] __device_suspend+0xd4/0x398
#5: (&gpio->lock){+.+.+.}, at: [<c009b940>] __irq_get_desc_lock+0x74/0x94
#6: (class){......}, at: [<c009b91c>] __irq_get_desc_lock+0x50/0x94
stack backtrace:
CPU: 0 PID: 63 Comm: sh Not tainted 4.2.0-rc6-00013-g5d050ed-dirty #55
Hardware name: Generic DRA74X (Flattened Device Tree)
[<c0016e24>] (unwind_backtrace) from [<c0013338>] (show_stack+0x10/0x14)
[<c0013338>] (show_stack) from [<c05f6b24>] (dump_stack+0x84/0x9c)
[<c05f6b24>] (dump_stack) from [<c00903f4>] (__lock_acquire+0x19c0/0x1e20)
[<c00903f4>] (__lock_acquire) from [<c0091098>] (lock_acquire+0xa8/0x128)
[<c0091098>] (lock_acquire) from [<c05fd61c>] (_raw_spin_lock_irqsave+0x38/0x4c)
[<c05fd61c>] (_raw_spin_lock_irqsave) from [<c009b91c>] (__irq_get_desc_lock+0x50/0x94)
[<c009b91c>] (__irq_get_desc_lock) from [<c009c4f4>] (irq_set_irq_wake+0x20/0xfc)
[<c009c4f4>] (irq_set_irq_wake) from [<c0393ac4>] (pcf857x_irq_set_wake+0x24/0x54)
[<c0393ac4>] (pcf857x_irq_set_wake) from [<c009c560>] (irq_set_irq_wake+0x8c/0xfc)
[<c009c560>] (irq_set_irq_wake) from [<c04a02ac>] (gpio_keys_suspend+0x70/0xd4)
[<c04a02ac>] (gpio_keys_suspend) from [<c03f6a00>] (dpm_run_callback+0x50/0x124)
[<c03f6a00>] (dpm_run_callback) from [<c03f7830>] (__device_suspend+0x10c/0x398)
[<c03f7830>] (__device_suspend) from [<c03f90f0>] (dpm_suspend+0x134/0x2f4)
[<c03f90f0>] (dpm_suspend) from [<c0096e20>] (suspend_devices_and_enter+0xa8/0x728)
[<c0096e20>] (suspend_devices_and_enter) from [<c00977cc>] (pm_suspend+0x32c/0x4c4)
[<c00977cc>] (pm_suspend) from [<c0096060>] (state_store+0x64/0xb8)
[<c0096060>] (state_store) from [<c01dec64>] (kernfs_fop_write+0xbc/0x1a0)
[<c01dec64>] (kernfs_fop_write) from [<c016b280>] (__vfs_write+0x20/0xd8)
[<c016b280>] (__vfs_write) from [<c016bb0c>] (vfs_write+0x90/0x164)
[<c016bb0c>] (vfs_write) from [<c016c330>] (SyS_write+0x44/0x9c)
[<c016c330>] (SyS_write) from [<c000f500>] (ret_fast_syscall+0x0/0x54)
Lets fix it by using separate lockdep class for each registered GPIO
IRQ Chip. This is done by wrapping gpiochip_irqchip_add call into macros.
The implementation of this patch inspired by solution done by Nicolas
Boichat for regmap [3]
[1] http://www.spinics.net/lists/linux-gpio/msg05844.html
[2] http://www.spinics.net/lists/linux-gpio/msg06021.html
[3] http://www.spinics.net/lists/arm-kernel/msg429834.html
Cc: Geert Uytterhoeven <geert@linux-m68k.org>
Cc: Roger Quadros <rogerq@ti.com>
Reported-by: Roger Quadros <rogerq@ti.com>
Tested-by: Roger Quadros <rogerq@ti.com>
Signed-off-by: Grygorii Strashko <grygorii.strashko@ti.com>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2015-08-17 06:35:23 -06:00
|
|
|
EXPORT_SYMBOL_GPL(_gpiochip_irqchip_add);
|
2014-03-25 03:40:18 -06:00
|
|
|
|
|
|
|
#else /* CONFIG_GPIOLIB_IRQCHIP */
|
|
|
|
|
|
|
|
static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip) {}
|
|
|
|
|
|
|
|
#endif /* CONFIG_GPIOLIB_IRQCHIP */
|
|
|
|
|
2015-10-11 09:34:15 -06:00
|
|
|
/**
|
|
|
|
* gpiochip_generic_request() - request the gpio function for a pin
|
|
|
|
* @chip: the gpiochip owning the GPIO
|
|
|
|
* @offset: the offset of the GPIO to request for GPIO function
|
|
|
|
*/
|
|
|
|
int gpiochip_generic_request(struct gpio_chip *chip, unsigned offset)
|
|
|
|
{
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
return pinctrl_request_gpio(chip->gpiodev->base + offset);
|
2015-10-11 09:34:15 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(gpiochip_generic_request);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gpiochip_generic_free() - free the gpio function from a pin
|
|
|
|
* @chip: the gpiochip to request the gpio function for
|
|
|
|
* @offset: the offset of the GPIO to free from GPIO function
|
|
|
|
*/
|
|
|
|
void gpiochip_generic_free(struct gpio_chip *chip, unsigned offset)
|
|
|
|
{
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
pinctrl_free_gpio(chip->gpiodev->base + offset);
|
2015-10-11 09:34:15 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(gpiochip_generic_free);
|
|
|
|
|
2012-10-27 03:51:36 -06:00
|
|
|
#ifdef CONFIG_PINCTRL
|
2012-11-06 06:49:39 -07:00
|
|
|
|
2013-10-15 07:37:54 -06:00
|
|
|
/**
|
|
|
|
* gpiochip_add_pingroup_range() - add a range for GPIO <-> pin mapping
|
|
|
|
* @chip: the gpiochip to add the range for
|
2015-06-17 07:42:11 -06:00
|
|
|
* @pctldev: the pin controller to map to
|
2013-10-15 07:37:54 -06:00
|
|
|
* @gpio_offset: the start offset in the current gpio_chip number space
|
|
|
|
* @pin_group: name of the pin group inside the pin controller
|
|
|
|
*/
|
|
|
|
int gpiochip_add_pingroup_range(struct gpio_chip *chip,
|
|
|
|
struct pinctrl_dev *pctldev,
|
|
|
|
unsigned int gpio_offset, const char *pin_group)
|
|
|
|
{
|
|
|
|
struct gpio_pin_range *pin_range;
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
struct gpio_device *gdev = chip->gpiodev;
|
2013-10-15 07:37:54 -06:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
|
|
|
|
if (!pin_range) {
|
2013-12-05 02:26:24 -07:00
|
|
|
chip_err(chip, "failed to allocate pin ranges\n");
|
2013-10-15 07:37:54 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Use local offset as range ID */
|
|
|
|
pin_range->range.id = gpio_offset;
|
|
|
|
pin_range->range.gc = chip;
|
|
|
|
pin_range->range.name = chip->label;
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
pin_range->range.base = gdev->base + gpio_offset;
|
2013-10-15 07:37:54 -06:00
|
|
|
pin_range->pctldev = pctldev;
|
|
|
|
|
|
|
|
ret = pinctrl_get_group_pins(pctldev, pin_group,
|
|
|
|
&pin_range->range.pins,
|
|
|
|
&pin_range->range.npins);
|
2013-11-13 13:20:39 -07:00
|
|
|
if (ret < 0) {
|
|
|
|
kfree(pin_range);
|
2013-10-15 07:37:54 -06:00
|
|
|
return ret;
|
2013-11-13 13:20:39 -07:00
|
|
|
}
|
2013-10-15 07:37:54 -06:00
|
|
|
|
|
|
|
pinctrl_add_gpio_range(pctldev, &pin_range->range);
|
|
|
|
|
2013-12-05 02:26:24 -07:00
|
|
|
chip_dbg(chip, "created GPIO range %d->%d ==> %s PINGRP %s\n",
|
|
|
|
gpio_offset, gpio_offset + pin_range->range.npins - 1,
|
2013-10-15 07:37:54 -06:00
|
|
|
pinctrl_dev_get_devname(pctldev), pin_group);
|
|
|
|
|
2016-02-11 03:03:06 -07:00
|
|
|
list_add_tail(&pin_range->node, &gdev->pin_ranges);
|
2013-10-15 07:37:54 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(gpiochip_add_pingroup_range);
|
|
|
|
|
2012-11-20 04:40:15 -07:00
|
|
|
/**
|
|
|
|
* gpiochip_add_pin_range() - add a range for GPIO <-> pin mapping
|
|
|
|
* @chip: the gpiochip to add the range for
|
|
|
|
* @pinctrl_name: the dev_name() of the pin controller to map to
|
2012-11-21 00:48:09 -07:00
|
|
|
* @gpio_offset: the start offset in the current gpio_chip number space
|
|
|
|
* @pin_offset: the start offset in the pin controller number space
|
2012-11-20 04:40:15 -07:00
|
|
|
* @npins: the number of pins from the offset of each pin space (GPIO and
|
|
|
|
* pin controller) to accumulate in this range
|
|
|
|
*/
|
2012-11-06 08:03:35 -07:00
|
|
|
int gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
|
2012-11-21 00:48:09 -07:00
|
|
|
unsigned int gpio_offset, unsigned int pin_offset,
|
2012-11-20 04:40:15 -07:00
|
|
|
unsigned int npins)
|
2012-10-27 03:51:36 -06:00
|
|
|
{
|
|
|
|
struct gpio_pin_range *pin_range;
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
struct gpio_device *gdev = chip->gpiodev;
|
2012-11-20 23:33:56 -07:00
|
|
|
int ret;
|
2012-10-27 03:51:36 -06:00
|
|
|
|
2012-11-20 04:40:15 -07:00
|
|
|
pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
|
2012-10-27 03:51:36 -06:00
|
|
|
if (!pin_range) {
|
2013-12-05 02:26:24 -07:00
|
|
|
chip_err(chip, "failed to allocate pin ranges\n");
|
2012-11-06 08:03:35 -07:00
|
|
|
return -ENOMEM;
|
2012-10-27 03:51:36 -06:00
|
|
|
}
|
|
|
|
|
2012-11-20 04:40:15 -07:00
|
|
|
/* Use local offset as range ID */
|
2012-11-21 00:48:09 -07:00
|
|
|
pin_range->range.id = gpio_offset;
|
2012-11-20 04:40:15 -07:00
|
|
|
pin_range->range.gc = chip;
|
2012-10-27 03:51:36 -06:00
|
|
|
pin_range->range.name = chip->label;
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
pin_range->range.base = gdev->base + gpio_offset;
|
2012-11-21 00:48:09 -07:00
|
|
|
pin_range->range.pin_base = pin_offset;
|
2012-10-27 03:51:36 -06:00
|
|
|
pin_range->range.npins = npins;
|
2012-11-20 06:03:37 -07:00
|
|
|
pin_range->pctldev = pinctrl_find_and_add_gpio_range(pinctl_name,
|
2012-10-27 03:51:36 -06:00
|
|
|
&pin_range->range);
|
2012-11-20 06:56:25 -07:00
|
|
|
if (IS_ERR(pin_range->pctldev)) {
|
2012-11-20 23:33:56 -07:00
|
|
|
ret = PTR_ERR(pin_range->pctldev);
|
2013-12-05 02:26:24 -07:00
|
|
|
chip_err(chip, "could not create pin range\n");
|
2012-11-20 04:40:15 -07:00
|
|
|
kfree(pin_range);
|
2012-11-20 23:33:56 -07:00
|
|
|
return ret;
|
2012-11-20 04:40:15 -07:00
|
|
|
}
|
2013-12-05 02:26:24 -07:00
|
|
|
chip_dbg(chip, "created GPIO range %d->%d ==> %s PIN %d->%d\n",
|
|
|
|
gpio_offset, gpio_offset + npins - 1,
|
2012-11-21 00:48:09 -07:00
|
|
|
pinctl_name,
|
|
|
|
pin_offset, pin_offset + npins - 1);
|
2012-10-27 03:51:36 -06:00
|
|
|
|
2016-02-11 03:03:06 -07:00
|
|
|
list_add_tail(&pin_range->node, &gdev->pin_ranges);
|
2012-11-06 08:03:35 -07:00
|
|
|
|
|
|
|
return 0;
|
2012-10-27 03:51:36 -06:00
|
|
|
}
|
2012-11-06 06:49:39 -07:00
|
|
|
EXPORT_SYMBOL_GPL(gpiochip_add_pin_range);
|
2012-10-27 03:51:36 -06:00
|
|
|
|
2012-11-20 04:40:15 -07:00
|
|
|
/**
|
|
|
|
* gpiochip_remove_pin_ranges() - remove all the GPIO <-> pin mappings
|
|
|
|
* @chip: the chip to remove all the mappings for
|
|
|
|
*/
|
2012-10-27 03:51:36 -06:00
|
|
|
void gpiochip_remove_pin_ranges(struct gpio_chip *chip)
|
|
|
|
{
|
|
|
|
struct gpio_pin_range *pin_range, *tmp;
|
2016-02-11 03:03:06 -07:00
|
|
|
struct gpio_device *gdev = chip->gpiodev;
|
2012-10-27 03:51:36 -06:00
|
|
|
|
2016-02-11 03:03:06 -07:00
|
|
|
list_for_each_entry_safe(pin_range, tmp, &gdev->pin_ranges, node) {
|
2012-10-27 03:51:36 -06:00
|
|
|
list_del(&pin_range->node);
|
|
|
|
pinctrl_remove_gpio_range(pin_range->pctldev,
|
|
|
|
&pin_range->range);
|
2012-11-20 04:40:15 -07:00
|
|
|
kfree(pin_range);
|
2012-10-27 03:51:36 -06:00
|
|
|
}
|
|
|
|
}
|
2012-11-06 06:49:39 -07:00
|
|
|
EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);
|
|
|
|
|
|
|
|
#endif /* CONFIG_PINCTRL */
|
2012-10-27 03:51:36 -06:00
|
|
|
|
2008-02-04 23:28:20 -07:00
|
|
|
/* These "optional" allocation calls help prevent drivers from stomping
|
|
|
|
* on each other, and help provide better diagnostics in debugfs.
|
|
|
|
* They're called even less than the "set direction" calls.
|
|
|
|
*/
|
2014-03-10 06:54:50 -06:00
|
|
|
static int __gpiod_request(struct gpio_desc *desc, const char *label)
|
2008-02-04 23:28:20 -07:00
|
|
|
{
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
struct gpio_chip *chip = desc->gdev->chip;
|
2014-03-10 06:54:50 -06:00
|
|
|
int status;
|
2008-02-04 23:28:20 -07:00
|
|
|
unsigned long flags;
|
|
|
|
|
2013-02-14 22:46:14 -07:00
|
|
|
spin_lock_irqsave(&gpio_lock, flags);
|
|
|
|
|
2008-02-04 23:28:20 -07:00
|
|
|
/* NOTE: gpio_request() can be called in early boot,
|
2008-10-15 23:03:16 -06:00
|
|
|
* before IRQs are enabled, for non-sleeping (SOC) GPIOs.
|
2008-02-04 23:28:20 -07:00
|
|
|
*/
|
|
|
|
|
|
|
|
if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
|
|
|
|
desc_set_label(desc, label ? : "?");
|
|
|
|
status = 0;
|
2008-04-28 03:14:44 -06:00
|
|
|
} else {
|
2008-02-04 23:28:20 -07:00
|
|
|
status = -EBUSY;
|
2009-01-29 15:25:12 -07:00
|
|
|
goto done;
|
2008-10-15 23:03:16 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (chip->request) {
|
|
|
|
/* chip->request may sleep */
|
|
|
|
spin_unlock_irqrestore(&gpio_lock, flags);
|
2013-02-02 09:29:29 -07:00
|
|
|
status = chip->request(chip, gpio_chip_hwgpio(desc));
|
2008-10-15 23:03:16 -06:00
|
|
|
spin_lock_irqsave(&gpio_lock, flags);
|
|
|
|
|
|
|
|
if (status < 0) {
|
|
|
|
desc_set_label(desc, NULL);
|
|
|
|
clear_bit(FLAG_REQUESTED, &desc->flags);
|
2012-10-24 08:25:27 -06:00
|
|
|
goto done;
|
2008-10-15 23:03:16 -06:00
|
|
|
}
|
2008-04-28 03:14:44 -06:00
|
|
|
}
|
2012-10-24 08:25:27 -06:00
|
|
|
if (chip->get_direction) {
|
|
|
|
/* chip->get_direction may sleep */
|
|
|
|
spin_unlock_irqrestore(&gpio_lock, flags);
|
2013-02-02 09:29:29 -07:00
|
|
|
gpiod_get_direction(desc);
|
2012-10-24 08:25:27 -06:00
|
|
|
spin_lock_irqsave(&gpio_lock, flags);
|
|
|
|
}
|
2014-03-10 06:54:50 -06:00
|
|
|
done:
|
2015-10-12 15:20:20 -06:00
|
|
|
if (status < 0) {
|
|
|
|
/* Clear flags that might have been set by the caller before
|
|
|
|
* requesting the GPIO.
|
|
|
|
*/
|
|
|
|
clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
|
|
|
|
clear_bit(FLAG_OPEN_DRAIN, &desc->flags);
|
|
|
|
clear_bit(FLAG_OPEN_SOURCE, &desc->flags);
|
|
|
|
}
|
2014-03-10 06:54:50 -06:00
|
|
|
spin_unlock_irqrestore(&gpio_lock, flags);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
/*
|
|
|
|
* This descriptor validation needs to be inserted verbatim into each
|
|
|
|
* function taking a descriptor, so we need to use a preprocessor
|
|
|
|
* macro to avoid endless duplication.
|
|
|
|
*/
|
|
|
|
#define VALIDATE_DESC(desc) do { \
|
|
|
|
if (!desc || !desc->gdev) { \
|
|
|
|
pr_warn("%s: invalid GPIO\n", __func__); \
|
|
|
|
return -EINVAL; \
|
|
|
|
} \
|
|
|
|
if ( !desc->gdev->chip ) { \
|
|
|
|
dev_warn(&desc->gdev->dev, \
|
|
|
|
"%s: backing chip is gone\n", __func__); \
|
|
|
|
return 0; \
|
|
|
|
} } while (0)
|
|
|
|
|
|
|
|
#define VALIDATE_DESC_VOID(desc) do { \
|
|
|
|
if (!desc || !desc->gdev) { \
|
|
|
|
pr_warn("%s: invalid GPIO\n", __func__); \
|
|
|
|
return; \
|
|
|
|
} \
|
|
|
|
if (!desc->gdev->chip) { \
|
|
|
|
dev_warn(&desc->gdev->dev, \
|
|
|
|
"%s: backing chip is gone\n", __func__); \
|
|
|
|
return; \
|
|
|
|
} } while (0)
|
|
|
|
|
|
|
|
|
2014-06-30 23:45:15 -06:00
|
|
|
int gpiod_request(struct gpio_desc *desc, const char *label)
|
2014-03-10 06:54:50 -06:00
|
|
|
{
|
|
|
|
int status = -EPROBE_DEFER;
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
struct gpio_device *gdev;
|
2014-03-10 06:54:50 -06:00
|
|
|
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
VALIDATE_DESC(desc);
|
|
|
|
gdev = desc->gdev;
|
2014-03-10 06:54:50 -06:00
|
|
|
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
if (try_module_get(gdev->owner)) {
|
2014-03-10 06:54:50 -06:00
|
|
|
status = __gpiod_request(desc, label);
|
|
|
|
if (status < 0)
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
module_put(gdev->owner);
|
2016-02-11 02:28:44 -07:00
|
|
|
else
|
|
|
|
get_device(&gdev->dev);
|
2014-03-10 06:54:50 -06:00
|
|
|
}
|
|
|
|
|
2008-02-04 23:28:20 -07:00
|
|
|
if (status)
|
2013-12-05 02:26:23 -07:00
|
|
|
gpiod_dbg(desc, "%s: status %d\n", __func__, status);
|
2014-03-10 06:54:50 -06:00
|
|
|
|
2008-02-04 23:28:20 -07:00
|
|
|
return status;
|
|
|
|
}
|
2013-02-02 09:29:29 -07:00
|
|
|
|
2014-03-10 06:54:50 -06:00
|
|
|
static bool __gpiod_free(struct gpio_desc *desc)
|
2008-02-04 23:28:20 -07:00
|
|
|
{
|
2014-03-10 06:54:50 -06:00
|
|
|
bool ret = false;
|
2008-02-04 23:28:20 -07:00
|
|
|
unsigned long flags;
|
2008-10-15 23:03:16 -06:00
|
|
|
struct gpio_chip *chip;
|
2008-02-04 23:28:20 -07:00
|
|
|
|
2008-10-15 23:03:12 -06:00
|
|
|
might_sleep();
|
|
|
|
|
2013-02-02 09:29:29 -07:00
|
|
|
gpiod_unexport(desc);
|
gpio: sysfs interface
This adds a simple sysfs interface for GPIOs.
/sys/class/gpio
/export ... asks the kernel to export a GPIO to userspace
/unexport ... to return a GPIO to the kernel
/gpioN ... for each exported GPIO #N
/value ... always readable, writes fail for input GPIOs
/direction ... r/w as: in, out (default low); write high, low
/gpiochipN ... for each gpiochip; #N is its first GPIO
/base ... (r/o) same as N
/label ... (r/o) descriptive, not necessarily unique
/ngpio ... (r/o) number of GPIOs; numbered N .. N+(ngpio - 1)
GPIOs claimed by kernel code may be exported by its owner using a new
gpio_export() call, which should be most useful for driver debugging.
Such exports may optionally be done without a "direction" attribute.
Userspace may ask to take over a GPIO by writing to a sysfs control file,
helping to cope with incomplete board support or other "one-off"
requirements that don't merit full kernel support:
echo 23 > /sys/class/gpio/export
... will gpio_request(23, "sysfs") and gpio_export(23);
use /sys/class/gpio/gpio-23/direction to (re)configure it,
when that GPIO can be used as both input and output.
echo 23 > /sys/class/gpio/unexport
... will gpio_free(23), when it was exported as above
The extra D-space footprint is a few hundred bytes, except for the sysfs
resources associated with each exported GPIO. The additional I-space
footprint is about two thirds of the current size of gpiolib (!). Since
no /dev node creation is involved, no "udev" support is needed.
Related changes:
* This adds a device pointer to "struct gpio_chip". When GPIO
providers initialize that, sysfs gpio class devices become children of
that device instead of being "virtual" devices.
* The (few) gpio_chip providers which have such a device node have
been updated.
* Some gpio_chip drivers also needed to update their module "owner"
field ... for which missing kerneldoc was added.
* Some gpio_chips don't support input GPIOs. Those GPIOs are now
flagged appropriately when the chip is registered.
Based on previous patches, and discussion both on and off LKML.
A Documentation/ABI/testing/sysfs-gpio update is ready to submit once this
merges to mainline.
[akpm@linux-foundation.org: a few maintenance build fixes]
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Cc: Guennadi Liakhovetski <g.liakhovetski@pengutronix.de>
Cc: Greg KH <greg@kroah.com>
Cc: Kay Sievers <kay.sievers@vrfy.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-07-25 02:46:07 -06:00
|
|
|
|
2008-02-04 23:28:20 -07:00
|
|
|
spin_lock_irqsave(&gpio_lock, flags);
|
|
|
|
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
chip = desc->gdev->chip;
|
2008-10-15 23:03:16 -06:00
|
|
|
if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) {
|
|
|
|
if (chip->free) {
|
|
|
|
spin_unlock_irqrestore(&gpio_lock, flags);
|
2010-08-10 19:02:24 -06:00
|
|
|
might_sleep_if(chip->can_sleep);
|
2013-02-02 09:29:29 -07:00
|
|
|
chip->free(chip, gpio_chip_hwgpio(desc));
|
2008-10-15 23:03:16 -06:00
|
|
|
spin_lock_irqsave(&gpio_lock, flags);
|
|
|
|
}
|
2008-02-04 23:28:20 -07:00
|
|
|
desc_set_label(desc, NULL);
|
2009-12-15 17:46:20 -07:00
|
|
|
clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
|
2008-10-15 23:03:16 -06:00
|
|
|
clear_bit(FLAG_REQUESTED, &desc->flags);
|
2012-02-17 07:56:21 -07:00
|
|
|
clear_bit(FLAG_OPEN_DRAIN, &desc->flags);
|
2012-02-17 07:56:22 -07:00
|
|
|
clear_bit(FLAG_OPEN_SOURCE, &desc->flags);
|
2015-02-02 10:44:44 -07:00
|
|
|
clear_bit(FLAG_IS_HOGGED, &desc->flags);
|
2014-03-10 06:54:50 -06:00
|
|
|
ret = true;
|
|
|
|
}
|
2008-02-04 23:28:20 -07:00
|
|
|
|
|
|
|
spin_unlock_irqrestore(&gpio_lock, flags);
|
2014-03-10 06:54:50 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-06-30 23:45:15 -06:00
|
|
|
void gpiod_free(struct gpio_desc *desc)
|
2014-03-10 06:54:50 -06:00
|
|
|
{
|
2016-02-11 02:28:44 -07:00
|
|
|
if (desc && desc->gdev && __gpiod_free(desc)) {
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
module_put(desc->gdev->owner);
|
2016-02-11 02:28:44 -07:00
|
|
|
put_device(&desc->gdev->dev);
|
|
|
|
} else {
|
2014-03-10 06:54:50 -06:00
|
|
|
WARN_ON(extra_checks);
|
2016-02-11 02:28:44 -07:00
|
|
|
}
|
2008-02-04 23:28:20 -07:00
|
|
|
}
|
2013-02-02 09:29:29 -07:00
|
|
|
|
2008-02-04 23:28:20 -07:00
|
|
|
/**
|
|
|
|
* gpiochip_is_requested - return string iff signal was requested
|
|
|
|
* @chip: controller managing the signal
|
|
|
|
* @offset: of signal within controller's 0..(ngpio - 1) range
|
|
|
|
*
|
|
|
|
* Returns NULL if the GPIO is not currently requested, else a string.
|
2014-06-30 23:45:14 -06:00
|
|
|
* The string returned is the label passed to gpio_request(); if none has been
|
|
|
|
* passed it is a meaningless, non-NULL constant.
|
2008-02-04 23:28:20 -07:00
|
|
|
*
|
|
|
|
* This function is for use by GPIO controller drivers. The label can
|
|
|
|
* help with diagnostics, and knowing that the signal is used as a GPIO
|
|
|
|
* can help avoid accidentally multiplexing it to another controller.
|
|
|
|
*/
|
|
|
|
const char *gpiochip_is_requested(struct gpio_chip *chip, unsigned offset)
|
|
|
|
{
|
2013-02-02 09:29:30 -07:00
|
|
|
struct gpio_desc *desc;
|
2008-02-04 23:28:20 -07:00
|
|
|
|
2015-08-18 10:02:32 -06:00
|
|
|
if (offset >= chip->ngpio)
|
2008-02-04 23:28:20 -07:00
|
|
|
return NULL;
|
2013-02-02 09:29:30 -07:00
|
|
|
|
2016-02-09 05:51:59 -07:00
|
|
|
desc = &chip->gpiodev->descs[offset];
|
2013-02-02 09:29:30 -07:00
|
|
|
|
2013-02-02 09:29:29 -07:00
|
|
|
if (test_bit(FLAG_REQUESTED, &desc->flags) == 0)
|
2008-02-04 23:28:20 -07:00
|
|
|
return NULL;
|
2013-02-02 09:29:29 -07:00
|
|
|
return desc->label;
|
2008-02-04 23:28:20 -07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(gpiochip_is_requested);
|
|
|
|
|
2014-03-10 06:54:50 -06:00
|
|
|
/**
|
|
|
|
* gpiochip_request_own_desc - Allow GPIO chip to request its own descriptor
|
|
|
|
* @desc: GPIO descriptor to request
|
|
|
|
* @label: label for the GPIO
|
|
|
|
*
|
|
|
|
* Function allows GPIO chip drivers to request and use their own GPIO
|
|
|
|
* descriptors via gpiolib API. Difference to gpiod_request() is that this
|
|
|
|
* function will not increase reference count of the GPIO chip module. This
|
|
|
|
* allows the GPIO chip module to be unloaded as needed (we assume that the
|
|
|
|
* GPIO chip driver handles freeing the GPIOs it has requested).
|
|
|
|
*/
|
2014-08-19 11:06:09 -06:00
|
|
|
struct gpio_desc *gpiochip_request_own_desc(struct gpio_chip *chip, u16 hwnum,
|
|
|
|
const char *label)
|
2014-03-10 06:54:50 -06:00
|
|
|
{
|
2014-08-19 11:06:09 -06:00
|
|
|
struct gpio_desc *desc = gpiochip_get_desc(chip, hwnum);
|
|
|
|
int err;
|
2014-03-10 06:54:50 -06:00
|
|
|
|
2014-08-19 11:06:09 -06:00
|
|
|
if (IS_ERR(desc)) {
|
|
|
|
chip_err(chip, "failed to get GPIO descriptor\n");
|
|
|
|
return desc;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = __gpiod_request(desc, label);
|
|
|
|
if (err < 0)
|
|
|
|
return ERR_PTR(err);
|
2014-03-10 06:54:50 -06:00
|
|
|
|
2014-08-19 11:06:09 -06:00
|
|
|
return desc;
|
2014-03-10 06:54:50 -06:00
|
|
|
}
|
2014-07-22 09:01:01 -06:00
|
|
|
EXPORT_SYMBOL_GPL(gpiochip_request_own_desc);
|
2014-03-10 06:54:50 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* gpiochip_free_own_desc - Free GPIO requested by the chip driver
|
|
|
|
* @desc: GPIO descriptor to free
|
|
|
|
*
|
|
|
|
* Function frees the given GPIO requested previously with
|
|
|
|
* gpiochip_request_own_desc().
|
|
|
|
*/
|
|
|
|
void gpiochip_free_own_desc(struct gpio_desc *desc)
|
|
|
|
{
|
|
|
|
if (desc)
|
|
|
|
__gpiod_free(desc);
|
|
|
|
}
|
2014-07-22 09:01:01 -06:00
|
|
|
EXPORT_SYMBOL_GPL(gpiochip_free_own_desc);
|
2008-02-04 23:28:20 -07:00
|
|
|
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
/*
|
|
|
|
* Drivers MUST set GPIO direction before making get/set calls. In
|
2008-02-04 23:28:20 -07:00
|
|
|
* some cases this is done in early boot, before IRQs are enabled.
|
|
|
|
*
|
|
|
|
* As a rule these aren't called more than once (except for drivers
|
|
|
|
* using the open-drain emulation idiom) so these are natural places
|
|
|
|
* to accumulate extra debugging checks. Note that we can't (yet)
|
|
|
|
* rely on gpio_request() having been called beforehand.
|
|
|
|
*/
|
|
|
|
|
2013-10-17 11:21:36 -06:00
|
|
|
/**
|
|
|
|
* gpiod_direction_input - set the GPIO direction to input
|
|
|
|
* @desc: GPIO to set to input
|
|
|
|
*
|
|
|
|
* Set the direction of the passed GPIO to input, such as gpiod_get_value() can
|
|
|
|
* be called safely on it.
|
|
|
|
*
|
|
|
|
* Return 0 in case of success, else an error code.
|
|
|
|
*/
|
|
|
|
int gpiod_direction_input(struct gpio_desc *desc)
|
2008-02-04 23:28:20 -07:00
|
|
|
{
|
|
|
|
struct gpio_chip *chip;
|
|
|
|
int status = -EINVAL;
|
|
|
|
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
VALIDATE_DESC(desc);
|
|
|
|
chip = desc->gdev->chip;
|
2013-02-14 22:46:14 -07:00
|
|
|
|
2013-08-30 01:41:45 -06:00
|
|
|
if (!chip->get || !chip->direction_input) {
|
2013-09-09 03:33:49 -06:00
|
|
|
gpiod_warn(desc,
|
|
|
|
"%s: missing get() or direction_input() operations\n",
|
2013-12-05 02:26:23 -07:00
|
|
|
__func__);
|
2013-08-30 01:41:45 -06:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2014-07-22 01:17:43 -06:00
|
|
|
status = chip->direction_input(chip, gpio_chip_hwgpio(desc));
|
2008-02-04 23:28:20 -07:00
|
|
|
if (status == 0)
|
|
|
|
clear_bit(FLAG_IS_OUT, &desc->flags);
|
2011-05-20 00:40:19 -06:00
|
|
|
|
2013-02-02 09:29:29 -07:00
|
|
|
trace_gpio_direction(desc_to_gpio(desc), 1, status);
|
2014-07-22 01:17:43 -06:00
|
|
|
|
2008-02-04 23:28:20 -07:00
|
|
|
return status;
|
|
|
|
}
|
2013-10-17 11:21:36 -06:00
|
|
|
EXPORT_SYMBOL_GPL(gpiod_direction_input);
|
2013-02-02 09:29:29 -07:00
|
|
|
|
2014-01-07 04:34:11 -07:00
|
|
|
static int _gpiod_direction_output_raw(struct gpio_desc *desc, int value)
|
2008-02-04 23:28:20 -07:00
|
|
|
{
|
|
|
|
struct gpio_chip *chip;
|
|
|
|
int status = -EINVAL;
|
|
|
|
|
2013-09-24 03:54:38 -06:00
|
|
|
/* GPIOs used for IRQs shall not be set as output */
|
|
|
|
if (test_bit(FLAG_USED_AS_IRQ, &desc->flags)) {
|
|
|
|
gpiod_err(desc,
|
|
|
|
"%s: tried to set a GPIO tied to an IRQ as output\n",
|
|
|
|
__func__);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2012-02-17 07:56:21 -07:00
|
|
|
/* Open drain pin should not be driven to 1 */
|
|
|
|
if (value && test_bit(FLAG_OPEN_DRAIN, &desc->flags))
|
2013-02-02 09:29:29 -07:00
|
|
|
return gpiod_direction_input(desc);
|
2012-02-17 07:56:21 -07:00
|
|
|
|
2012-02-17 07:56:22 -07:00
|
|
|
/* Open source pin should not be driven to 0 */
|
|
|
|
if (!value && test_bit(FLAG_OPEN_SOURCE, &desc->flags))
|
2013-02-02 09:29:29 -07:00
|
|
|
return gpiod_direction_input(desc);
|
2012-02-17 07:56:22 -07:00
|
|
|
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
chip = desc->gdev->chip;
|
2013-08-30 01:41:45 -06:00
|
|
|
if (!chip->set || !chip->direction_output) {
|
2013-09-09 03:33:49 -06:00
|
|
|
gpiod_warn(desc,
|
|
|
|
"%s: missing set() or direction_output() operations\n",
|
|
|
|
__func__);
|
2013-08-30 01:41:45 -06:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2014-07-22 01:17:43 -06:00
|
|
|
status = chip->direction_output(chip, gpio_chip_hwgpio(desc), value);
|
2008-02-04 23:28:20 -07:00
|
|
|
if (status == 0)
|
|
|
|
set_bit(FLAG_IS_OUT, &desc->flags);
|
2013-02-02 09:29:29 -07:00
|
|
|
trace_gpio_value(desc_to_gpio(desc), 0, value);
|
|
|
|
trace_gpio_direction(desc_to_gpio(desc), 0, status);
|
2008-02-04 23:28:20 -07:00
|
|
|
return status;
|
|
|
|
}
|
2014-01-07 04:34:11 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* gpiod_direction_output_raw - set the GPIO direction to output
|
|
|
|
* @desc: GPIO to set to output
|
|
|
|
* @value: initial output value of the GPIO
|
|
|
|
*
|
|
|
|
* Set the direction of the passed GPIO to output, such as gpiod_set_value() can
|
|
|
|
* be called safely on it. The initial value of the output must be specified
|
|
|
|
* as raw value on the physical line without regard for the ACTIVE_LOW status.
|
|
|
|
*
|
|
|
|
* Return 0 in case of success, else an error code.
|
|
|
|
*/
|
|
|
|
int gpiod_direction_output_raw(struct gpio_desc *desc, int value)
|
|
|
|
{
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
VALIDATE_DESC(desc);
|
2014-01-07 04:34:11 -07:00
|
|
|
return _gpiod_direction_output_raw(desc, value);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(gpiod_direction_output_raw);
|
|
|
|
|
|
|
|
/**
|
2014-02-07 23:25:25 -07:00
|
|
|
* gpiod_direction_output - set the GPIO direction to output
|
2014-01-07 04:34:11 -07:00
|
|
|
* @desc: GPIO to set to output
|
|
|
|
* @value: initial output value of the GPIO
|
|
|
|
*
|
|
|
|
* Set the direction of the passed GPIO to output, such as gpiod_set_value() can
|
|
|
|
* be called safely on it. The initial value of the output must be specified
|
|
|
|
* as the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
|
|
|
|
* account.
|
|
|
|
*
|
|
|
|
* Return 0 in case of success, else an error code.
|
|
|
|
*/
|
|
|
|
int gpiod_direction_output(struct gpio_desc *desc, int value)
|
|
|
|
{
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
VALIDATE_DESC(desc);
|
2014-01-07 04:34:11 -07:00
|
|
|
if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
|
|
|
|
value = !value;
|
|
|
|
return _gpiod_direction_output_raw(desc, value);
|
|
|
|
}
|
2013-10-17 11:21:36 -06:00
|
|
|
EXPORT_SYMBOL_GPL(gpiod_direction_output);
|
2008-02-04 23:28:20 -07:00
|
|
|
|
2010-05-26 15:42:23 -06:00
|
|
|
/**
|
2013-10-17 11:21:36 -06:00
|
|
|
* gpiod_set_debounce - sets @debounce time for a @gpio
|
2010-05-26 15:42:23 -06:00
|
|
|
* @gpio: the gpio to set debounce time
|
|
|
|
* @debounce: debounce time is microseconds
|
2013-09-04 06:17:08 -06:00
|
|
|
*
|
|
|
|
* returns -ENOTSUPP if the controller does not support setting
|
|
|
|
* debounce.
|
2010-05-26 15:42:23 -06:00
|
|
|
*/
|
2013-10-17 11:21:36 -06:00
|
|
|
int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
|
2010-05-26 15:42:23 -06:00
|
|
|
{
|
|
|
|
struct gpio_chip *chip;
|
|
|
|
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
VALIDATE_DESC(desc);
|
|
|
|
chip = desc->gdev->chip;
|
2013-08-30 01:41:45 -06:00
|
|
|
if (!chip->set || !chip->set_debounce) {
|
2013-09-09 03:33:49 -06:00
|
|
|
gpiod_dbg(desc,
|
|
|
|
"%s: missing set() or set_debounce() operations\n",
|
|
|
|
__func__);
|
2013-09-04 06:17:08 -06:00
|
|
|
return -ENOTSUPP;
|
2013-08-30 01:41:45 -06:00
|
|
|
}
|
|
|
|
|
2014-07-22 01:17:43 -06:00
|
|
|
return chip->set_debounce(chip, gpio_chip_hwgpio(desc), debounce);
|
2010-05-26 15:42:23 -06:00
|
|
|
}
|
2013-10-17 11:21:36 -06:00
|
|
|
EXPORT_SYMBOL_GPL(gpiod_set_debounce);
|
2013-02-02 09:29:29 -07:00
|
|
|
|
2013-10-17 11:21:36 -06:00
|
|
|
/**
|
|
|
|
* gpiod_is_active_low - test whether a GPIO is active-low or not
|
|
|
|
* @desc: the gpio descriptor to test
|
|
|
|
*
|
|
|
|
* Returns 1 if the GPIO is active-low, 0 otherwise.
|
|
|
|
*/
|
|
|
|
int gpiod_is_active_low(const struct gpio_desc *desc)
|
2013-02-02 09:29:29 -07:00
|
|
|
{
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
VALIDATE_DESC(desc);
|
2013-10-17 11:21:36 -06:00
|
|
|
return test_bit(FLAG_ACTIVE_LOW, &desc->flags);
|
2013-02-02 09:29:29 -07:00
|
|
|
}
|
2013-10-17 11:21:36 -06:00
|
|
|
EXPORT_SYMBOL_GPL(gpiod_is_active_low);
|
2008-02-04 23:28:20 -07:00
|
|
|
|
|
|
|
/* I/O calls are only valid after configuration completed; the relevant
|
|
|
|
* "is this a valid GPIO" error checks should already have been done.
|
|
|
|
*
|
|
|
|
* "Get" operations are often inlinable as reading a pin value register,
|
|
|
|
* and masking the relevant bit in that register.
|
|
|
|
*
|
|
|
|
* When "set" operations are inlinable, they involve writing that mask to
|
|
|
|
* one register to set a low value, or a different register to set it high.
|
|
|
|
* Otherwise locking is needed, so there may be little value to inlining.
|
|
|
|
*
|
|
|
|
*------------------------------------------------------------------------
|
|
|
|
*
|
|
|
|
* IMPORTANT!!! The hot paths -- get/set value -- assume that callers
|
|
|
|
* have requested the GPIO. That can include implicit requesting by
|
|
|
|
* a direction setting call. Marking a gpio as requested locks its chip
|
|
|
|
* in memory, guaranteeing that these table lookups need no more locking
|
|
|
|
* and that gpiochip_remove() will fail.
|
|
|
|
*
|
|
|
|
* REVISIT when debugging, consider adding some instrumentation to ensure
|
|
|
|
* that the GPIO was actually requested.
|
|
|
|
*/
|
|
|
|
|
2015-08-28 10:44:18 -06:00
|
|
|
static int _gpiod_get_raw_value(const struct gpio_desc *desc)
|
2008-02-04 23:28:20 -07:00
|
|
|
{
|
|
|
|
struct gpio_chip *chip;
|
2013-02-02 09:29:29 -07:00
|
|
|
int offset;
|
2015-08-28 10:44:18 -06:00
|
|
|
int value;
|
2008-02-04 23:28:20 -07:00
|
|
|
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
chip = desc->gdev->chip;
|
2013-02-02 09:29:29 -07:00
|
|
|
offset = gpio_chip_hwgpio(desc);
|
2015-08-28 10:44:18 -06:00
|
|
|
value = chip->get ? chip->get(chip, offset) : -EIO;
|
2015-12-21 15:10:12 -07:00
|
|
|
value = value < 0 ? value : !!value;
|
2013-02-02 09:29:29 -07:00
|
|
|
trace_gpio_value(desc_to_gpio(desc), 1, value);
|
2011-05-20 00:40:19 -06:00
|
|
|
return value;
|
2008-02-04 23:28:20 -07:00
|
|
|
}
|
2013-02-02 09:29:29 -07:00
|
|
|
|
2008-02-04 23:28:20 -07:00
|
|
|
/**
|
2013-10-17 11:21:36 -06:00
|
|
|
* gpiod_get_raw_value() - return a gpio's raw value
|
|
|
|
* @desc: gpio whose value will be returned
|
2008-02-04 23:28:20 -07:00
|
|
|
*
|
2013-10-17 11:21:36 -06:00
|
|
|
* Return the GPIO's raw value, i.e. the value of the physical line disregarding
|
2015-08-28 10:44:18 -06:00
|
|
|
* its ACTIVE_LOW status, or negative errno on failure.
|
2013-10-17 11:21:36 -06:00
|
|
|
*
|
|
|
|
* This function should be called from contexts where we cannot sleep, and will
|
|
|
|
* complain if the GPIO chip functions potentially sleep.
|
2008-02-04 23:28:20 -07:00
|
|
|
*/
|
2013-10-17 11:21:36 -06:00
|
|
|
int gpiod_get_raw_value(const struct gpio_desc *desc)
|
2008-02-04 23:28:20 -07:00
|
|
|
{
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
VALIDATE_DESC(desc);
|
2012-02-17 11:46:00 -07:00
|
|
|
/* Should be using gpio_get_value_cansleep() */
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
WARN_ON(desc->gdev->chip->can_sleep);
|
2013-10-17 11:21:36 -06:00
|
|
|
return _gpiod_get_raw_value(desc);
|
2008-02-04 23:28:20 -07:00
|
|
|
}
|
2013-10-17 11:21:36 -06:00
|
|
|
EXPORT_SYMBOL_GPL(gpiod_get_raw_value);
|
2013-02-02 09:29:29 -07:00
|
|
|
|
2013-10-17 11:21:36 -06:00
|
|
|
/**
|
|
|
|
* gpiod_get_value() - return a gpio's value
|
|
|
|
* @desc: gpio whose value will be returned
|
|
|
|
*
|
|
|
|
* Return the GPIO's logical value, i.e. taking the ACTIVE_LOW status into
|
2015-08-28 10:44:18 -06:00
|
|
|
* account, or negative errno on failure.
|
2013-10-17 11:21:36 -06:00
|
|
|
*
|
|
|
|
* This function should be called from contexts where we cannot sleep, and will
|
|
|
|
* complain if the GPIO chip functions potentially sleep.
|
|
|
|
*/
|
|
|
|
int gpiod_get_value(const struct gpio_desc *desc)
|
2013-02-02 09:29:29 -07:00
|
|
|
{
|
2013-10-17 11:21:36 -06:00
|
|
|
int value;
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
|
|
|
|
VALIDATE_DESC(desc);
|
2013-10-17 11:21:36 -06:00
|
|
|
/* Should be using gpio_get_value_cansleep() */
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
WARN_ON(desc->gdev->chip->can_sleep);
|
2013-10-17 11:21:36 -06:00
|
|
|
|
|
|
|
value = _gpiod_get_raw_value(desc);
|
2015-08-28 10:44:18 -06:00
|
|
|
if (value < 0)
|
|
|
|
return value;
|
|
|
|
|
2013-10-17 11:21:36 -06:00
|
|
|
if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
|
|
|
|
value = !value;
|
|
|
|
|
|
|
|
return value;
|
2013-02-02 09:29:29 -07:00
|
|
|
}
|
2013-10-17 11:21:36 -06:00
|
|
|
EXPORT_SYMBOL_GPL(gpiod_get_value);
|
2008-02-04 23:28:20 -07:00
|
|
|
|
2012-02-17 07:56:21 -07:00
|
|
|
/*
|
|
|
|
* _gpio_set_open_drain_value() - Set the open drain gpio's value.
|
2013-10-17 11:21:36 -06:00
|
|
|
* @desc: gpio descriptor whose state need to be set.
|
2015-05-18 12:41:43 -06:00
|
|
|
* @value: Non-zero for setting it HIGH otherwise it will set to LOW.
|
2012-02-17 07:56:21 -07:00
|
|
|
*/
|
2014-03-11 00:52:09 -06:00
|
|
|
static void _gpio_set_open_drain_value(struct gpio_desc *desc, bool value)
|
2012-02-17 07:56:21 -07:00
|
|
|
{
|
|
|
|
int err = 0;
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
struct gpio_chip *chip = desc->gdev->chip;
|
2013-02-02 09:29:29 -07:00
|
|
|
int offset = gpio_chip_hwgpio(desc);
|
|
|
|
|
2012-02-17 07:56:21 -07:00
|
|
|
if (value) {
|
2013-02-02 09:29:29 -07:00
|
|
|
err = chip->direction_input(chip, offset);
|
2012-02-17 07:56:21 -07:00
|
|
|
if (!err)
|
2013-02-02 09:29:29 -07:00
|
|
|
clear_bit(FLAG_IS_OUT, &desc->flags);
|
2012-02-17 07:56:21 -07:00
|
|
|
} else {
|
2013-02-02 09:29:29 -07:00
|
|
|
err = chip->direction_output(chip, offset, 0);
|
2012-02-17 07:56:21 -07:00
|
|
|
if (!err)
|
2013-02-02 09:29:29 -07:00
|
|
|
set_bit(FLAG_IS_OUT, &desc->flags);
|
2012-02-17 07:56:21 -07:00
|
|
|
}
|
2013-02-02 09:29:29 -07:00
|
|
|
trace_gpio_direction(desc_to_gpio(desc), value, err);
|
2012-02-17 07:56:21 -07:00
|
|
|
if (err < 0)
|
2013-09-09 03:33:49 -06:00
|
|
|
gpiod_err(desc,
|
|
|
|
"%s: Error in set_value for open drain err %d\n",
|
|
|
|
__func__, err);
|
2012-02-17 07:56:21 -07:00
|
|
|
}
|
|
|
|
|
2012-02-17 07:56:22 -07:00
|
|
|
/*
|
2013-10-17 11:21:36 -06:00
|
|
|
* _gpio_set_open_source_value() - Set the open source gpio's value.
|
|
|
|
* @desc: gpio descriptor whose state need to be set.
|
2015-05-18 12:41:43 -06:00
|
|
|
* @value: Non-zero for setting it HIGH otherwise it will set to LOW.
|
2012-02-17 07:56:22 -07:00
|
|
|
*/
|
2014-03-11 00:52:09 -06:00
|
|
|
static void _gpio_set_open_source_value(struct gpio_desc *desc, bool value)
|
2012-02-17 07:56:22 -07:00
|
|
|
{
|
|
|
|
int err = 0;
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
struct gpio_chip *chip = desc->gdev->chip;
|
2013-02-02 09:29:29 -07:00
|
|
|
int offset = gpio_chip_hwgpio(desc);
|
|
|
|
|
2012-02-17 07:56:22 -07:00
|
|
|
if (value) {
|
2013-02-02 09:29:29 -07:00
|
|
|
err = chip->direction_output(chip, offset, 1);
|
2012-02-17 07:56:22 -07:00
|
|
|
if (!err)
|
2013-02-02 09:29:29 -07:00
|
|
|
set_bit(FLAG_IS_OUT, &desc->flags);
|
2012-02-17 07:56:22 -07:00
|
|
|
} else {
|
2013-02-02 09:29:29 -07:00
|
|
|
err = chip->direction_input(chip, offset);
|
2012-02-17 07:56:22 -07:00
|
|
|
if (!err)
|
2013-02-02 09:29:29 -07:00
|
|
|
clear_bit(FLAG_IS_OUT, &desc->flags);
|
2012-02-17 07:56:22 -07:00
|
|
|
}
|
2013-02-02 09:29:29 -07:00
|
|
|
trace_gpio_direction(desc_to_gpio(desc), !value, err);
|
2012-02-17 07:56:22 -07:00
|
|
|
if (err < 0)
|
2013-09-09 03:33:49 -06:00
|
|
|
gpiod_err(desc,
|
|
|
|
"%s: Error in set_value for open source err %d\n",
|
|
|
|
__func__, err);
|
2012-02-17 07:56:22 -07:00
|
|
|
}
|
|
|
|
|
2014-03-11 00:52:09 -06:00
|
|
|
static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value)
|
2008-02-04 23:28:20 -07:00
|
|
|
{
|
|
|
|
struct gpio_chip *chip;
|
|
|
|
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
chip = desc->gdev->chip;
|
2013-02-02 09:29:29 -07:00
|
|
|
trace_gpio_value(desc_to_gpio(desc), 0, value);
|
|
|
|
if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
|
|
|
|
_gpio_set_open_drain_value(desc, value);
|
|
|
|
else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
|
|
|
|
_gpio_set_open_source_value(desc, value);
|
2012-02-17 07:56:21 -07:00
|
|
|
else
|
2013-02-02 09:29:29 -07:00
|
|
|
chip->set(chip, gpio_chip_hwgpio(desc), value);
|
|
|
|
}
|
|
|
|
|
2014-11-04 09:12:06 -07:00
|
|
|
/*
|
|
|
|
* set multiple outputs on the same chip;
|
|
|
|
* use the chip's set_multiple function if available;
|
|
|
|
* otherwise set the outputs sequentially;
|
|
|
|
* @mask: bit mask array; one bit per output; BITS_PER_LONG bits per word
|
|
|
|
* defines which outputs are to be changed
|
|
|
|
* @bits: bit value array; one bit per output; BITS_PER_LONG bits per word
|
|
|
|
* defines the values the outputs specified by mask are to be set to
|
|
|
|
*/
|
|
|
|
static void gpio_chip_set_multiple(struct gpio_chip *chip,
|
|
|
|
unsigned long *mask, unsigned long *bits)
|
|
|
|
{
|
|
|
|
if (chip->set_multiple) {
|
|
|
|
chip->set_multiple(chip, mask, bits);
|
|
|
|
} else {
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < chip->ngpio; i++) {
|
|
|
|
if (mask[BIT_WORD(i)] == 0) {
|
|
|
|
/* no more set bits in this mask word;
|
|
|
|
* skip ahead to the next word */
|
|
|
|
i = (BIT_WORD(i) + 1) * BITS_PER_LONG - 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
/* set outputs if the corresponding mask bit is set */
|
2015-06-10 07:26:27 -06:00
|
|
|
if (__test_and_clear_bit(i, mask))
|
2014-11-04 09:12:06 -07:00
|
|
|
chip->set(chip, i, test_bit(i, bits));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-05-13 03:04:56 -06:00
|
|
|
static void gpiod_set_array_value_priv(bool raw, bool can_sleep,
|
|
|
|
unsigned int array_size,
|
|
|
|
struct gpio_desc **desc_array,
|
|
|
|
int *value_array)
|
2014-11-04 09:12:06 -07:00
|
|
|
{
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
while (i < array_size) {
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
struct gpio_chip *chip = desc_array[i]->gdev->chip;
|
2014-11-04 09:12:06 -07:00
|
|
|
unsigned long mask[BITS_TO_LONGS(chip->ngpio)];
|
|
|
|
unsigned long bits[BITS_TO_LONGS(chip->ngpio)];
|
|
|
|
int count = 0;
|
|
|
|
|
2015-06-10 07:26:27 -06:00
|
|
|
if (!can_sleep)
|
2014-11-04 09:12:06 -07:00
|
|
|
WARN_ON(chip->can_sleep);
|
2015-06-10 07:26:27 -06:00
|
|
|
|
2014-11-04 09:12:06 -07:00
|
|
|
memset(mask, 0, sizeof(mask));
|
|
|
|
do {
|
|
|
|
struct gpio_desc *desc = desc_array[i];
|
|
|
|
int hwgpio = gpio_chip_hwgpio(desc);
|
|
|
|
int value = value_array[i];
|
|
|
|
|
|
|
|
if (!raw && test_bit(FLAG_ACTIVE_LOW, &desc->flags))
|
|
|
|
value = !value;
|
|
|
|
trace_gpio_value(desc_to_gpio(desc), 0, value);
|
|
|
|
/*
|
|
|
|
* collect all normal outputs belonging to the same chip
|
|
|
|
* open drain and open source outputs are set individually
|
|
|
|
*/
|
|
|
|
if (test_bit(FLAG_OPEN_DRAIN, &desc->flags)) {
|
2015-06-10 07:26:27 -06:00
|
|
|
_gpio_set_open_drain_value(desc, value);
|
2014-11-04 09:12:06 -07:00
|
|
|
} else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) {
|
|
|
|
_gpio_set_open_source_value(desc, value);
|
|
|
|
} else {
|
|
|
|
__set_bit(hwgpio, mask);
|
2015-06-10 07:26:27 -06:00
|
|
|
if (value)
|
2014-11-04 09:12:06 -07:00
|
|
|
__set_bit(hwgpio, bits);
|
2015-06-10 07:26:27 -06:00
|
|
|
else
|
2014-11-04 09:12:06 -07:00
|
|
|
__clear_bit(hwgpio, bits);
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
i++;
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
} while ((i < array_size) &&
|
|
|
|
(desc_array[i]->gdev->chip == chip));
|
2014-11-04 09:12:06 -07:00
|
|
|
/* push collected bits to outputs */
|
2015-06-10 07:26:27 -06:00
|
|
|
if (count != 0)
|
2014-11-04 09:12:06 -07:00
|
|
|
gpio_chip_set_multiple(chip, mask, bits);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-04 23:28:20 -07:00
|
|
|
/**
|
2013-10-17 11:21:36 -06:00
|
|
|
* gpiod_set_raw_value() - assign a gpio's raw value
|
|
|
|
* @desc: gpio whose value will be assigned
|
2008-02-04 23:28:20 -07:00
|
|
|
* @value: value to assign
|
|
|
|
*
|
2013-10-17 11:21:36 -06:00
|
|
|
* Set the raw value of the GPIO, i.e. the value of its physical line without
|
|
|
|
* regard for its ACTIVE_LOW status.
|
|
|
|
*
|
|
|
|
* This function should be called from contexts where we cannot sleep, and will
|
|
|
|
* complain if the GPIO chip functions potentially sleep.
|
2008-02-04 23:28:20 -07:00
|
|
|
*/
|
2013-10-17 11:21:36 -06:00
|
|
|
void gpiod_set_raw_value(struct gpio_desc *desc, int value)
|
2013-02-02 09:29:29 -07:00
|
|
|
{
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
VALIDATE_DESC_VOID(desc);
|
2016-03-14 09:24:12 -06:00
|
|
|
/* Should be using gpiod_set_value_cansleep() */
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
WARN_ON(desc->gdev->chip->can_sleep);
|
2013-10-17 11:21:36 -06:00
|
|
|
_gpiod_set_raw_value(desc, value);
|
2008-02-04 23:28:20 -07:00
|
|
|
}
|
2013-10-17 11:21:36 -06:00
|
|
|
EXPORT_SYMBOL_GPL(gpiod_set_raw_value);
|
2008-02-04 23:28:20 -07:00
|
|
|
|
|
|
|
/**
|
2013-10-17 11:21:36 -06:00
|
|
|
* gpiod_set_value() - assign a gpio's value
|
|
|
|
* @desc: gpio whose value will be assigned
|
|
|
|
* @value: value to assign
|
|
|
|
*
|
|
|
|
* Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
|
|
|
|
* account
|
2008-02-04 23:28:20 -07:00
|
|
|
*
|
2013-10-17 11:21:36 -06:00
|
|
|
* This function should be called from contexts where we cannot sleep, and will
|
|
|
|
* complain if the GPIO chip functions potentially sleep.
|
2008-02-04 23:28:20 -07:00
|
|
|
*/
|
2013-10-17 11:21:36 -06:00
|
|
|
void gpiod_set_value(struct gpio_desc *desc, int value)
|
2008-02-04 23:28:20 -07:00
|
|
|
{
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
VALIDATE_DESC_VOID(desc);
|
2016-03-14 09:24:12 -06:00
|
|
|
/* Should be using gpiod_set_value_cansleep() */
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
WARN_ON(desc->gdev->chip->can_sleep);
|
2013-10-17 11:21:36 -06:00
|
|
|
if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
|
|
|
|
value = !value;
|
|
|
|
_gpiod_set_raw_value(desc, value);
|
2013-02-02 09:29:29 -07:00
|
|
|
}
|
2013-10-17 11:21:36 -06:00
|
|
|
EXPORT_SYMBOL_GPL(gpiod_set_value);
|
2008-02-04 23:28:20 -07:00
|
|
|
|
2014-11-04 09:12:06 -07:00
|
|
|
/**
|
2015-05-13 03:04:56 -06:00
|
|
|
* gpiod_set_raw_array_value() - assign values to an array of GPIOs
|
2014-11-04 09:12:06 -07:00
|
|
|
* @array_size: number of elements in the descriptor / value arrays
|
|
|
|
* @desc_array: array of GPIO descriptors whose values will be assigned
|
|
|
|
* @value_array: array of values to assign
|
|
|
|
*
|
|
|
|
* Set the raw values of the GPIOs, i.e. the values of the physical lines
|
|
|
|
* without regard for their ACTIVE_LOW status.
|
|
|
|
*
|
|
|
|
* This function should be called from contexts where we cannot sleep, and will
|
|
|
|
* complain if the GPIO chip functions potentially sleep.
|
|
|
|
*/
|
2015-05-13 03:04:56 -06:00
|
|
|
void gpiod_set_raw_array_value(unsigned int array_size,
|
2014-11-04 09:12:06 -07:00
|
|
|
struct gpio_desc **desc_array, int *value_array)
|
|
|
|
{
|
|
|
|
if (!desc_array)
|
|
|
|
return;
|
2015-05-13 03:04:56 -06:00
|
|
|
gpiod_set_array_value_priv(true, false, array_size, desc_array,
|
|
|
|
value_array);
|
2014-11-04 09:12:06 -07:00
|
|
|
}
|
2015-05-13 03:04:56 -06:00
|
|
|
EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value);
|
2014-11-04 09:12:06 -07:00
|
|
|
|
|
|
|
/**
|
2015-05-13 03:04:56 -06:00
|
|
|
* gpiod_set_array_value() - assign values to an array of GPIOs
|
2014-11-04 09:12:06 -07:00
|
|
|
* @array_size: number of elements in the descriptor / value arrays
|
|
|
|
* @desc_array: array of GPIO descriptors whose values will be assigned
|
|
|
|
* @value_array: array of values to assign
|
|
|
|
*
|
|
|
|
* Set the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status
|
|
|
|
* into account.
|
|
|
|
*
|
|
|
|
* This function should be called from contexts where we cannot sleep, and will
|
|
|
|
* complain if the GPIO chip functions potentially sleep.
|
|
|
|
*/
|
2015-05-13 03:04:56 -06:00
|
|
|
void gpiod_set_array_value(unsigned int array_size,
|
|
|
|
struct gpio_desc **desc_array, int *value_array)
|
2014-11-04 09:12:06 -07:00
|
|
|
{
|
|
|
|
if (!desc_array)
|
|
|
|
return;
|
2015-05-13 03:04:56 -06:00
|
|
|
gpiod_set_array_value_priv(false, false, array_size, desc_array,
|
|
|
|
value_array);
|
2014-11-04 09:12:06 -07:00
|
|
|
}
|
2015-05-13 03:04:56 -06:00
|
|
|
EXPORT_SYMBOL_GPL(gpiod_set_array_value);
|
2014-11-04 09:12:06 -07:00
|
|
|
|
2008-02-04 23:28:20 -07:00
|
|
|
/**
|
2013-10-17 11:21:36 -06:00
|
|
|
* gpiod_cansleep() - report whether gpio value access may sleep
|
|
|
|
* @desc: gpio to check
|
2008-02-04 23:28:20 -07:00
|
|
|
*
|
|
|
|
*/
|
2013-10-17 11:21:36 -06:00
|
|
|
int gpiod_cansleep(const struct gpio_desc *desc)
|
2013-02-02 09:29:29 -07:00
|
|
|
{
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
VALIDATE_DESC(desc);
|
|
|
|
return desc->gdev->chip->can_sleep;
|
2008-02-04 23:28:20 -07:00
|
|
|
}
|
2013-10-17 11:21:36 -06:00
|
|
|
EXPORT_SYMBOL_GPL(gpiod_cansleep);
|
2008-02-04 23:28:20 -07:00
|
|
|
|
2008-10-15 23:03:14 -06:00
|
|
|
/**
|
2013-10-17 11:21:36 -06:00
|
|
|
* gpiod_to_irq() - return the IRQ corresponding to a GPIO
|
|
|
|
* @desc: gpio whose IRQ will be returned (already requested)
|
2008-10-15 23:03:14 -06:00
|
|
|
*
|
2013-10-17 11:21:36 -06:00
|
|
|
* Return the IRQ corresponding to the passed GPIO, or an error code in case of
|
|
|
|
* error.
|
2008-10-15 23:03:14 -06:00
|
|
|
*/
|
2013-10-17 11:21:36 -06:00
|
|
|
int gpiod_to_irq(const struct gpio_desc *desc)
|
2008-10-15 23:03:14 -06:00
|
|
|
{
|
|
|
|
struct gpio_chip *chip;
|
2013-02-02 09:29:29 -07:00
|
|
|
int offset;
|
2008-10-15 23:03:14 -06:00
|
|
|
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
VALIDATE_DESC(desc);
|
|
|
|
chip = desc->gdev->chip;
|
2013-02-02 09:29:29 -07:00
|
|
|
offset = gpio_chip_hwgpio(desc);
|
|
|
|
return chip->to_irq ? chip->to_irq(chip, offset) : -ENXIO;
|
2008-10-15 23:03:14 -06:00
|
|
|
}
|
2013-10-17 11:21:36 -06:00
|
|
|
EXPORT_SYMBOL_GPL(gpiod_to_irq);
|
2008-10-15 23:03:14 -06:00
|
|
|
|
2013-09-24 03:54:38 -06:00
|
|
|
/**
|
2014-10-23 02:27:07 -06:00
|
|
|
* gpiochip_lock_as_irq() - lock a GPIO to be used as IRQ
|
2014-07-22 01:17:42 -06:00
|
|
|
* @chip: the chip the GPIO to lock belongs to
|
|
|
|
* @offset: the offset of the GPIO to lock as IRQ
|
2013-09-24 03:54:38 -06:00
|
|
|
*
|
|
|
|
* This is used directly by GPIO drivers that want to lock down
|
2014-03-06 19:12:49 -07:00
|
|
|
* a certain GPIO line to be used for IRQs.
|
2013-09-24 03:54:38 -06:00
|
|
|
*/
|
2014-10-23 02:27:07 -06:00
|
|
|
int gpiochip_lock_as_irq(struct gpio_chip *chip, unsigned int offset)
|
2013-02-02 09:29:29 -07:00
|
|
|
{
|
2014-07-22 01:17:42 -06:00
|
|
|
if (offset >= chip->ngpio)
|
2013-09-24 03:54:38 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2016-02-09 05:51:59 -07:00
|
|
|
if (test_bit(FLAG_IS_OUT, &chip->gpiodev->descs[offset].flags)) {
|
2014-07-22 01:17:42 -06:00
|
|
|
chip_err(chip,
|
2013-09-24 03:54:38 -06:00
|
|
|
"%s: tried to flag a GPIO set as output for IRQ\n",
|
|
|
|
__func__);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2016-02-09 05:51:59 -07:00
|
|
|
set_bit(FLAG_USED_AS_IRQ, &chip->gpiodev->descs[offset].flags);
|
2013-09-24 03:54:38 -06:00
|
|
|
return 0;
|
2013-02-02 09:29:29 -07:00
|
|
|
}
|
2014-10-23 02:27:07 -06:00
|
|
|
EXPORT_SYMBOL_GPL(gpiochip_lock_as_irq);
|
2008-02-04 23:28:20 -07:00
|
|
|
|
2013-09-24 03:54:38 -06:00
|
|
|
/**
|
2014-10-23 02:27:07 -06:00
|
|
|
* gpiochip_unlock_as_irq() - unlock a GPIO used as IRQ
|
2014-07-22 01:17:42 -06:00
|
|
|
* @chip: the chip the GPIO to lock belongs to
|
|
|
|
* @offset: the offset of the GPIO to lock as IRQ
|
2013-09-24 03:54:38 -06:00
|
|
|
*
|
|
|
|
* This is used directly by GPIO drivers that want to indicate
|
|
|
|
* that a certain GPIO is no longer used exclusively for IRQ.
|
2008-02-04 23:28:20 -07:00
|
|
|
*/
|
2014-10-23 02:27:07 -06:00
|
|
|
void gpiochip_unlock_as_irq(struct gpio_chip *chip, unsigned int offset)
|
2013-09-24 03:54:38 -06:00
|
|
|
{
|
2014-07-22 01:17:42 -06:00
|
|
|
if (offset >= chip->ngpio)
|
2013-09-24 03:54:38 -06:00
|
|
|
return;
|
2008-02-04 23:28:20 -07:00
|
|
|
|
2016-02-09 05:51:59 -07:00
|
|
|
clear_bit(FLAG_USED_AS_IRQ, &chip->gpiodev->descs[offset].flags);
|
2013-09-24 03:54:38 -06:00
|
|
|
}
|
2014-10-23 02:27:07 -06:00
|
|
|
EXPORT_SYMBOL_GPL(gpiochip_unlock_as_irq);
|
2013-09-24 03:54:38 -06:00
|
|
|
|
2016-02-11 12:16:45 -07:00
|
|
|
bool gpiochip_line_is_irq(struct gpio_chip *chip, unsigned int offset)
|
|
|
|
{
|
|
|
|
if (offset >= chip->ngpio)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return test_bit(FLAG_USED_AS_IRQ, &chip->gpiodev->descs[offset].flags);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(gpiochip_line_is_irq);
|
|
|
|
|
2016-02-16 07:41:42 -07:00
|
|
|
bool gpiochip_line_is_open_drain(struct gpio_chip *chip, unsigned int offset)
|
|
|
|
{
|
|
|
|
if (offset >= chip->ngpio)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return test_bit(FLAG_OPEN_DRAIN, &chip->gpiodev->descs[offset].flags);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(gpiochip_line_is_open_drain);
|
|
|
|
|
|
|
|
bool gpiochip_line_is_open_source(struct gpio_chip *chip, unsigned int offset)
|
|
|
|
{
|
|
|
|
if (offset >= chip->ngpio)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return test_bit(FLAG_OPEN_SOURCE, &chip->gpiodev->descs[offset].flags);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(gpiochip_line_is_open_source);
|
|
|
|
|
2013-10-17 11:21:36 -06:00
|
|
|
/**
|
|
|
|
* gpiod_get_raw_value_cansleep() - return a gpio's raw value
|
|
|
|
* @desc: gpio whose value will be returned
|
|
|
|
*
|
|
|
|
* Return the GPIO's raw value, i.e. the value of the physical line disregarding
|
2015-08-28 10:44:18 -06:00
|
|
|
* its ACTIVE_LOW status, or negative errno on failure.
|
2013-10-17 11:21:36 -06:00
|
|
|
*
|
|
|
|
* This function is to be called from contexts that can sleep.
|
2008-02-04 23:28:20 -07:00
|
|
|
*/
|
2013-10-17 11:21:36 -06:00
|
|
|
int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
|
2008-02-04 23:28:20 -07:00
|
|
|
{
|
|
|
|
might_sleep_if(extra_checks);
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
VALIDATE_DESC(desc);
|
2013-10-17 11:21:36 -06:00
|
|
|
return _gpiod_get_raw_value(desc);
|
2008-02-04 23:28:20 -07:00
|
|
|
}
|
2013-10-17 11:21:36 -06:00
|
|
|
EXPORT_SYMBOL_GPL(gpiod_get_raw_value_cansleep);
|
2013-02-02 09:29:29 -07:00
|
|
|
|
2013-10-17 11:21:36 -06:00
|
|
|
/**
|
|
|
|
* gpiod_get_value_cansleep() - return a gpio's value
|
|
|
|
* @desc: gpio whose value will be returned
|
|
|
|
*
|
|
|
|
* Return the GPIO's logical value, i.e. taking the ACTIVE_LOW status into
|
2015-08-28 10:44:18 -06:00
|
|
|
* account, or negative errno on failure.
|
2013-10-17 11:21:36 -06:00
|
|
|
*
|
|
|
|
* This function is to be called from contexts that can sleep.
|
|
|
|
*/
|
|
|
|
int gpiod_get_value_cansleep(const struct gpio_desc *desc)
|
2008-02-04 23:28:20 -07:00
|
|
|
{
|
2011-05-20 00:40:19 -06:00
|
|
|
int value;
|
2008-02-04 23:28:20 -07:00
|
|
|
|
|
|
|
might_sleep_if(extra_checks);
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
VALIDATE_DESC(desc);
|
2013-10-17 11:21:36 -06:00
|
|
|
value = _gpiod_get_raw_value(desc);
|
2015-08-28 10:44:18 -06:00
|
|
|
if (value < 0)
|
|
|
|
return value;
|
|
|
|
|
2013-10-17 11:21:36 -06:00
|
|
|
if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
|
|
|
|
value = !value;
|
|
|
|
|
2011-05-20 00:40:19 -06:00
|
|
|
return value;
|
2008-02-04 23:28:20 -07:00
|
|
|
}
|
2013-10-17 11:21:36 -06:00
|
|
|
EXPORT_SYMBOL_GPL(gpiod_get_value_cansleep);
|
2013-02-02 09:29:29 -07:00
|
|
|
|
2013-10-17 11:21:36 -06:00
|
|
|
/**
|
|
|
|
* gpiod_set_raw_value_cansleep() - assign a gpio's raw value
|
|
|
|
* @desc: gpio whose value will be assigned
|
|
|
|
* @value: value to assign
|
|
|
|
*
|
|
|
|
* Set the raw value of the GPIO, i.e. the value of its physical line without
|
|
|
|
* regard for its ACTIVE_LOW status.
|
|
|
|
*
|
|
|
|
* This function is to be called from contexts that can sleep.
|
|
|
|
*/
|
|
|
|
void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value)
|
2013-02-02 09:29:29 -07:00
|
|
|
{
|
2008-02-04 23:28:20 -07:00
|
|
|
might_sleep_if(extra_checks);
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
VALIDATE_DESC_VOID(desc);
|
2013-10-17 11:21:36 -06:00
|
|
|
_gpiod_set_raw_value(desc, value);
|
2013-02-02 09:29:29 -07:00
|
|
|
}
|
2013-10-17 11:21:36 -06:00
|
|
|
EXPORT_SYMBOL_GPL(gpiod_set_raw_value_cansleep);
|
2008-02-04 23:28:20 -07:00
|
|
|
|
2013-10-17 11:21:36 -06:00
|
|
|
/**
|
|
|
|
* gpiod_set_value_cansleep() - assign a gpio's value
|
|
|
|
* @desc: gpio whose value will be assigned
|
|
|
|
* @value: value to assign
|
|
|
|
*
|
|
|
|
* Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
|
|
|
|
* account
|
|
|
|
*
|
|
|
|
* This function is to be called from contexts that can sleep.
|
|
|
|
*/
|
|
|
|
void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
|
2008-02-04 23:28:20 -07:00
|
|
|
{
|
|
|
|
might_sleep_if(extra_checks);
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
VALIDATE_DESC_VOID(desc);
|
2013-10-17 11:21:36 -06:00
|
|
|
if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
|
|
|
|
value = !value;
|
|
|
|
_gpiod_set_raw_value(desc, value);
|
2013-02-02 09:29:29 -07:00
|
|
|
}
|
2013-10-17 11:21:36 -06:00
|
|
|
EXPORT_SYMBOL_GPL(gpiod_set_value_cansleep);
|
2008-02-04 23:28:20 -07:00
|
|
|
|
2014-11-04 09:12:06 -07:00
|
|
|
/**
|
2015-05-13 03:04:56 -06:00
|
|
|
* gpiod_set_raw_array_value_cansleep() - assign values to an array of GPIOs
|
2014-11-04 09:12:06 -07:00
|
|
|
* @array_size: number of elements in the descriptor / value arrays
|
|
|
|
* @desc_array: array of GPIO descriptors whose values will be assigned
|
|
|
|
* @value_array: array of values to assign
|
|
|
|
*
|
|
|
|
* Set the raw values of the GPIOs, i.e. the values of the physical lines
|
|
|
|
* without regard for their ACTIVE_LOW status.
|
|
|
|
*
|
|
|
|
* This function is to be called from contexts that can sleep.
|
|
|
|
*/
|
2015-05-13 03:04:56 -06:00
|
|
|
void gpiod_set_raw_array_value_cansleep(unsigned int array_size,
|
|
|
|
struct gpio_desc **desc_array,
|
|
|
|
int *value_array)
|
2014-11-04 09:12:06 -07:00
|
|
|
{
|
|
|
|
might_sleep_if(extra_checks);
|
|
|
|
if (!desc_array)
|
|
|
|
return;
|
2015-05-13 03:04:56 -06:00
|
|
|
gpiod_set_array_value_priv(true, true, array_size, desc_array,
|
|
|
|
value_array);
|
2014-11-04 09:12:06 -07:00
|
|
|
}
|
2015-05-13 03:04:56 -06:00
|
|
|
EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value_cansleep);
|
2014-11-04 09:12:06 -07:00
|
|
|
|
|
|
|
/**
|
2015-05-13 03:04:56 -06:00
|
|
|
* gpiod_set_array_value_cansleep() - assign values to an array of GPIOs
|
2014-11-04 09:12:06 -07:00
|
|
|
* @array_size: number of elements in the descriptor / value arrays
|
|
|
|
* @desc_array: array of GPIO descriptors whose values will be assigned
|
|
|
|
* @value_array: array of values to assign
|
|
|
|
*
|
|
|
|
* Set the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status
|
|
|
|
* into account.
|
|
|
|
*
|
|
|
|
* This function is to be called from contexts that can sleep.
|
|
|
|
*/
|
2015-05-13 03:04:56 -06:00
|
|
|
void gpiod_set_array_value_cansleep(unsigned int array_size,
|
|
|
|
struct gpio_desc **desc_array,
|
|
|
|
int *value_array)
|
2014-11-04 09:12:06 -07:00
|
|
|
{
|
|
|
|
might_sleep_if(extra_checks);
|
|
|
|
if (!desc_array)
|
|
|
|
return;
|
2015-05-13 03:04:56 -06:00
|
|
|
gpiod_set_array_value_priv(false, true, array_size, desc_array,
|
|
|
|
value_array);
|
2014-11-04 09:12:06 -07:00
|
|
|
}
|
2015-05-13 03:04:56 -06:00
|
|
|
EXPORT_SYMBOL_GPL(gpiod_set_array_value_cansleep);
|
2014-11-04 09:12:06 -07:00
|
|
|
|
2013-10-17 11:21:38 -06:00
|
|
|
/**
|
2013-12-02 20:20:11 -07:00
|
|
|
* gpiod_add_lookup_table() - register GPIO device consumers
|
|
|
|
* @table: table of consumers to register
|
2013-10-17 11:21:38 -06:00
|
|
|
*/
|
2013-12-02 20:20:11 -07:00
|
|
|
void gpiod_add_lookup_table(struct gpiod_lookup_table *table)
|
2013-10-17 11:21:38 -06:00
|
|
|
{
|
|
|
|
mutex_lock(&gpio_lookup_lock);
|
|
|
|
|
2013-12-02 20:20:11 -07:00
|
|
|
list_add_tail(&table->list, &gpio_lookup_list);
|
2013-10-17 11:21:38 -06:00
|
|
|
|
|
|
|
mutex_unlock(&gpio_lookup_lock);
|
|
|
|
}
|
|
|
|
|
2015-06-26 03:02:04 -06:00
|
|
|
/**
|
|
|
|
* gpiod_remove_lookup_table() - unregister GPIO device consumers
|
|
|
|
* @table: table of consumers to unregister
|
|
|
|
*/
|
|
|
|
void gpiod_remove_lookup_table(struct gpiod_lookup_table *table)
|
|
|
|
{
|
|
|
|
mutex_lock(&gpio_lookup_lock);
|
|
|
|
|
|
|
|
list_del(&table->list);
|
|
|
|
|
|
|
|
mutex_unlock(&gpio_lookup_lock);
|
|
|
|
}
|
|
|
|
|
2013-10-17 11:21:38 -06:00
|
|
|
static struct gpio_desc *of_find_gpio(struct device *dev, const char *con_id,
|
2013-11-16 05:44:52 -07:00
|
|
|
unsigned int idx,
|
|
|
|
enum gpio_lookup_flags *flags)
|
2013-10-17 11:21:38 -06:00
|
|
|
{
|
|
|
|
char prop_name[32]; /* 32 is max size of property name */
|
|
|
|
enum of_gpio_flags of_flags;
|
|
|
|
struct gpio_desc *desc;
|
2014-04-23 09:28:09 -06:00
|
|
|
unsigned int i;
|
2013-10-17 11:21:38 -06:00
|
|
|
|
2015-02-11 09:27:55 -07:00
|
|
|
for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
|
2014-04-23 09:28:09 -06:00
|
|
|
if (con_id)
|
2015-01-21 14:33:45 -07:00
|
|
|
snprintf(prop_name, sizeof(prop_name), "%s-%s", con_id,
|
2015-02-11 09:27:55 -07:00
|
|
|
gpio_suffixes[i]);
|
2014-04-23 09:28:09 -06:00
|
|
|
else
|
2015-01-21 14:33:45 -07:00
|
|
|
snprintf(prop_name, sizeof(prop_name), "%s",
|
2015-02-11 09:27:55 -07:00
|
|
|
gpio_suffixes[i]);
|
2013-10-17 11:21:38 -06:00
|
|
|
|
2014-04-23 09:28:09 -06:00
|
|
|
desc = of_get_named_gpiod_flags(dev->of_node, prop_name, idx,
|
|
|
|
&of_flags);
|
2014-06-02 17:13:46 -06:00
|
|
|
if (!IS_ERR(desc) || (PTR_ERR(desc) == -EPROBE_DEFER))
|
2014-04-23 09:28:09 -06:00
|
|
|
break;
|
|
|
|
}
|
2013-10-17 11:21:38 -06:00
|
|
|
|
|
|
|
if (IS_ERR(desc))
|
|
|
|
return desc;
|
|
|
|
|
|
|
|
if (of_flags & OF_GPIO_ACTIVE_LOW)
|
2013-11-16 05:44:52 -07:00
|
|
|
*flags |= GPIO_ACTIVE_LOW;
|
2013-10-17 11:21:38 -06:00
|
|
|
|
2015-10-12 15:20:21 -06:00
|
|
|
if (of_flags & OF_GPIO_SINGLE_ENDED) {
|
|
|
|
if (of_flags & OF_GPIO_ACTIVE_LOW)
|
|
|
|
*flags |= GPIO_OPEN_DRAIN;
|
|
|
|
else
|
|
|
|
*flags |= GPIO_OPEN_SOURCE;
|
|
|
|
}
|
|
|
|
|
2013-10-17 11:21:38 -06:00
|
|
|
return desc;
|
|
|
|
}
|
2008-02-04 23:28:20 -07:00
|
|
|
|
gpio / ACPI: ignore GpioInt() GPIOs when requesting GPIO_OUT_*
When firmware does not use _DSD properties that allow properly name GPIO
resources, the kernel falls back on parsing _CRS resources, and will
return entries described as GpioInt() as general purpose GPIOs even
though they are meant to be used simply as interrupt sources for the
device:
Device (ETSA)
{
Name (_HID, "ELAN0001")
...
Method(_CRS, 0x0, NotSerialized)
{
Name(BUF0,ResourceTemplate ()
{
I2CSerialBus(
0x10, /* SlaveAddress */
ControllerInitiated, /* SlaveMode */
400000, /* ConnectionSpeed */
AddressingMode7Bit, /* AddressingMode */
"\\_SB.I2C1", /* ResourceSource */
)
GpioInt (Edge, ActiveLow, ExclusiveAndWake, PullNone,,
"\\_SB.GPSW") { BOARD_TOUCH_GPIO_INDEX }
} )
Return (BUF0)
}
...
}
This gives troubles with drivers such as Elan Touchscreen driver
(elants_i2c) that uses devm_gpiod_get to look up "reset" GPIO line and
decide whether the driver is responsible for powering up and resetting
the device, or firmware is. In the above case the lookup succeeds, we
map GPIO as output and later fail to request client->irq interrupt that
is mapped to the same GPIO.
Let's ignore resources described as GpioInt() while parsing _CRS when
requesting output GPIOs (but allow them when requesting GPIOD_ASIS or
GPIOD_IN as some drivers, such as i2c-hid, do request GPIO as input and
then map it to interrupt with gpiod_to_irq).
Acked-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Signed-off-by: Dmitry Torokhov <dtor@chromium.org>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-03-24 11:50:25 -06:00
|
|
|
static struct gpio_desc *acpi_find_gpio(struct device *dev,
|
|
|
|
const char *con_id,
|
2013-11-16 05:44:52 -07:00
|
|
|
unsigned int idx,
|
gpio / ACPI: ignore GpioInt() GPIOs when requesting GPIO_OUT_*
When firmware does not use _DSD properties that allow properly name GPIO
resources, the kernel falls back on parsing _CRS resources, and will
return entries described as GpioInt() as general purpose GPIOs even
though they are meant to be used simply as interrupt sources for the
device:
Device (ETSA)
{
Name (_HID, "ELAN0001")
...
Method(_CRS, 0x0, NotSerialized)
{
Name(BUF0,ResourceTemplate ()
{
I2CSerialBus(
0x10, /* SlaveAddress */
ControllerInitiated, /* SlaveMode */
400000, /* ConnectionSpeed */
AddressingMode7Bit, /* AddressingMode */
"\\_SB.I2C1", /* ResourceSource */
)
GpioInt (Edge, ActiveLow, ExclusiveAndWake, PullNone,,
"\\_SB.GPSW") { BOARD_TOUCH_GPIO_INDEX }
} )
Return (BUF0)
}
...
}
This gives troubles with drivers such as Elan Touchscreen driver
(elants_i2c) that uses devm_gpiod_get to look up "reset" GPIO line and
decide whether the driver is responsible for powering up and resetting
the device, or firmware is. In the above case the lookup succeeds, we
map GPIO as output and later fail to request client->irq interrupt that
is mapped to the same GPIO.
Let's ignore resources described as GpioInt() while parsing _CRS when
requesting output GPIOs (but allow them when requesting GPIOD_ASIS or
GPIOD_IN as some drivers, such as i2c-hid, do request GPIO as input and
then map it to interrupt with gpiod_to_irq).
Acked-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Signed-off-by: Dmitry Torokhov <dtor@chromium.org>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-03-24 11:50:25 -06:00
|
|
|
enum gpiod_flags flags,
|
|
|
|
enum gpio_lookup_flags *lookupflags)
|
2013-02-02 09:29:29 -07:00
|
|
|
{
|
gpio / ACPI: Add support for _DSD device properties
With release of ACPI 5.1 and _DSD method we can finally name GPIOs (and
other things as well) returned by _CRS. Previously we were only able to
use integer index to find the corresponding GPIO, which is pretty error
prone if the order changes.
With _DSD we can now query GPIOs using name instead of an integer index,
like the below example shows:
// Bluetooth device with reset and shutdown GPIOs
Device (BTH)
{
Name (_HID, ...)
Name (_CRS, ResourceTemplate ()
{
GpioIo (Exclusive, PullUp, 0, 0, IoRestrictionInputOnly,
"\\_SB.GPO0", 0, ResourceConsumer) {15}
GpioIo (Exclusive, PullUp, 0, 0, IoRestrictionInputOnly,
"\\_SB.GPO0", 0, ResourceConsumer) {27, 31}
})
Name (_DSD, Package ()
{
ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
Package ()
{
Package () {"reset-gpio", Package() {^BTH, 1, 1, 0 }},
Package () {"shutdown-gpio", Package() {^BTH, 0, 0, 0 }},
}
})
}
The format of the supported GPIO property is:
Package () { "name", Package () { ref, index, pin, active_low }}
ref - The device that has _CRS containing GpioIo()/GpioInt() resources,
typically this is the device itself (BTH in our case).
index - Index of the GpioIo()/GpioInt() resource in _CRS starting from zero.
pin - Pin in the GpioIo()/GpioInt() resource. Typically this is zero.
active_low - If 1 the GPIO is marked as active_low.
Since ACPI GpioIo() resource does not have field saying whether it is
active low or high, the "active_low" argument can be used here. Setting
it to 1 marks the GPIO as active low.
In our Bluetooth example the "reset-gpio" refers to the second GpioIo()
resource, second pin in that resource with the GPIO number of 31.
This patch implements necessary support to gpiolib for extracting GPIOs
using _DSD device properties.
Signed-off-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Acked-by: Linus Walleij <linus.walleij@linaro.org>
Acked-by: Grant Likely <grant.likely@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-10-29 08:41:01 -06:00
|
|
|
struct acpi_device *adev = ACPI_COMPANION(dev);
|
2013-10-10 02:01:10 -06:00
|
|
|
struct acpi_gpio_info info;
|
|
|
|
struct gpio_desc *desc;
|
gpio / ACPI: Add support for _DSD device properties
With release of ACPI 5.1 and _DSD method we can finally name GPIOs (and
other things as well) returned by _CRS. Previously we were only able to
use integer index to find the corresponding GPIO, which is pretty error
prone if the order changes.
With _DSD we can now query GPIOs using name instead of an integer index,
like the below example shows:
// Bluetooth device with reset and shutdown GPIOs
Device (BTH)
{
Name (_HID, ...)
Name (_CRS, ResourceTemplate ()
{
GpioIo (Exclusive, PullUp, 0, 0, IoRestrictionInputOnly,
"\\_SB.GPO0", 0, ResourceConsumer) {15}
GpioIo (Exclusive, PullUp, 0, 0, IoRestrictionInputOnly,
"\\_SB.GPO0", 0, ResourceConsumer) {27, 31}
})
Name (_DSD, Package ()
{
ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
Package ()
{
Package () {"reset-gpio", Package() {^BTH, 1, 1, 0 }},
Package () {"shutdown-gpio", Package() {^BTH, 0, 0, 0 }},
}
})
}
The format of the supported GPIO property is:
Package () { "name", Package () { ref, index, pin, active_low }}
ref - The device that has _CRS containing GpioIo()/GpioInt() resources,
typically this is the device itself (BTH in our case).
index - Index of the GpioIo()/GpioInt() resource in _CRS starting from zero.
pin - Pin in the GpioIo()/GpioInt() resource. Typically this is zero.
active_low - If 1 the GPIO is marked as active_low.
Since ACPI GpioIo() resource does not have field saying whether it is
active low or high, the "active_low" argument can be used here. Setting
it to 1 marks the GPIO as active low.
In our Bluetooth example the "reset-gpio" refers to the second GpioIo()
resource, second pin in that resource with the GPIO number of 31.
This patch implements necessary support to gpiolib for extracting GPIOs
using _DSD device properties.
Signed-off-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Acked-by: Linus Walleij <linus.walleij@linaro.org>
Acked-by: Grant Likely <grant.likely@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-10-29 08:41:01 -06:00
|
|
|
char propname[32];
|
|
|
|
int i;
|
2013-10-10 02:01:10 -06:00
|
|
|
|
gpio / ACPI: Add support for _DSD device properties
With release of ACPI 5.1 and _DSD method we can finally name GPIOs (and
other things as well) returned by _CRS. Previously we were only able to
use integer index to find the corresponding GPIO, which is pretty error
prone if the order changes.
With _DSD we can now query GPIOs using name instead of an integer index,
like the below example shows:
// Bluetooth device with reset and shutdown GPIOs
Device (BTH)
{
Name (_HID, ...)
Name (_CRS, ResourceTemplate ()
{
GpioIo (Exclusive, PullUp, 0, 0, IoRestrictionInputOnly,
"\\_SB.GPO0", 0, ResourceConsumer) {15}
GpioIo (Exclusive, PullUp, 0, 0, IoRestrictionInputOnly,
"\\_SB.GPO0", 0, ResourceConsumer) {27, 31}
})
Name (_DSD, Package ()
{
ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
Package ()
{
Package () {"reset-gpio", Package() {^BTH, 1, 1, 0 }},
Package () {"shutdown-gpio", Package() {^BTH, 0, 0, 0 }},
}
})
}
The format of the supported GPIO property is:
Package () { "name", Package () { ref, index, pin, active_low }}
ref - The device that has _CRS containing GpioIo()/GpioInt() resources,
typically this is the device itself (BTH in our case).
index - Index of the GpioIo()/GpioInt() resource in _CRS starting from zero.
pin - Pin in the GpioIo()/GpioInt() resource. Typically this is zero.
active_low - If 1 the GPIO is marked as active_low.
Since ACPI GpioIo() resource does not have field saying whether it is
active low or high, the "active_low" argument can be used here. Setting
it to 1 marks the GPIO as active low.
In our Bluetooth example the "reset-gpio" refers to the second GpioIo()
resource, second pin in that resource with the GPIO number of 31.
This patch implements necessary support to gpiolib for extracting GPIOs
using _DSD device properties.
Signed-off-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Acked-by: Linus Walleij <linus.walleij@linaro.org>
Acked-by: Grant Likely <grant.likely@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-10-29 08:41:01 -06:00
|
|
|
/* Try first from _DSD */
|
2015-02-11 09:27:55 -07:00
|
|
|
for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
|
gpio / ACPI: Add support for _DSD device properties
With release of ACPI 5.1 and _DSD method we can finally name GPIOs (and
other things as well) returned by _CRS. Previously we were only able to
use integer index to find the corresponding GPIO, which is pretty error
prone if the order changes.
With _DSD we can now query GPIOs using name instead of an integer index,
like the below example shows:
// Bluetooth device with reset and shutdown GPIOs
Device (BTH)
{
Name (_HID, ...)
Name (_CRS, ResourceTemplate ()
{
GpioIo (Exclusive, PullUp, 0, 0, IoRestrictionInputOnly,
"\\_SB.GPO0", 0, ResourceConsumer) {15}
GpioIo (Exclusive, PullUp, 0, 0, IoRestrictionInputOnly,
"\\_SB.GPO0", 0, ResourceConsumer) {27, 31}
})
Name (_DSD, Package ()
{
ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
Package ()
{
Package () {"reset-gpio", Package() {^BTH, 1, 1, 0 }},
Package () {"shutdown-gpio", Package() {^BTH, 0, 0, 0 }},
}
})
}
The format of the supported GPIO property is:
Package () { "name", Package () { ref, index, pin, active_low }}
ref - The device that has _CRS containing GpioIo()/GpioInt() resources,
typically this is the device itself (BTH in our case).
index - Index of the GpioIo()/GpioInt() resource in _CRS starting from zero.
pin - Pin in the GpioIo()/GpioInt() resource. Typically this is zero.
active_low - If 1 the GPIO is marked as active_low.
Since ACPI GpioIo() resource does not have field saying whether it is
active low or high, the "active_low" argument can be used here. Setting
it to 1 marks the GPIO as active low.
In our Bluetooth example the "reset-gpio" refers to the second GpioIo()
resource, second pin in that resource with the GPIO number of 31.
This patch implements necessary support to gpiolib for extracting GPIOs
using _DSD device properties.
Signed-off-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Acked-by: Linus Walleij <linus.walleij@linaro.org>
Acked-by: Grant Likely <grant.likely@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-10-29 08:41:01 -06:00
|
|
|
if (con_id && strcmp(con_id, "gpios")) {
|
|
|
|
snprintf(propname, sizeof(propname), "%s-%s",
|
2015-02-11 09:27:55 -07:00
|
|
|
con_id, gpio_suffixes[i]);
|
gpio / ACPI: Add support for _DSD device properties
With release of ACPI 5.1 and _DSD method we can finally name GPIOs (and
other things as well) returned by _CRS. Previously we were only able to
use integer index to find the corresponding GPIO, which is pretty error
prone if the order changes.
With _DSD we can now query GPIOs using name instead of an integer index,
like the below example shows:
// Bluetooth device with reset and shutdown GPIOs
Device (BTH)
{
Name (_HID, ...)
Name (_CRS, ResourceTemplate ()
{
GpioIo (Exclusive, PullUp, 0, 0, IoRestrictionInputOnly,
"\\_SB.GPO0", 0, ResourceConsumer) {15}
GpioIo (Exclusive, PullUp, 0, 0, IoRestrictionInputOnly,
"\\_SB.GPO0", 0, ResourceConsumer) {27, 31}
})
Name (_DSD, Package ()
{
ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
Package ()
{
Package () {"reset-gpio", Package() {^BTH, 1, 1, 0 }},
Package () {"shutdown-gpio", Package() {^BTH, 0, 0, 0 }},
}
})
}
The format of the supported GPIO property is:
Package () { "name", Package () { ref, index, pin, active_low }}
ref - The device that has _CRS containing GpioIo()/GpioInt() resources,
typically this is the device itself (BTH in our case).
index - Index of the GpioIo()/GpioInt() resource in _CRS starting from zero.
pin - Pin in the GpioIo()/GpioInt() resource. Typically this is zero.
active_low - If 1 the GPIO is marked as active_low.
Since ACPI GpioIo() resource does not have field saying whether it is
active low or high, the "active_low" argument can be used here. Setting
it to 1 marks the GPIO as active low.
In our Bluetooth example the "reset-gpio" refers to the second GpioIo()
resource, second pin in that resource with the GPIO number of 31.
This patch implements necessary support to gpiolib for extracting GPIOs
using _DSD device properties.
Signed-off-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Acked-by: Linus Walleij <linus.walleij@linaro.org>
Acked-by: Grant Likely <grant.likely@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-10-29 08:41:01 -06:00
|
|
|
} else {
|
|
|
|
snprintf(propname, sizeof(propname), "%s",
|
2015-02-11 09:27:55 -07:00
|
|
|
gpio_suffixes[i]);
|
gpio / ACPI: Add support for _DSD device properties
With release of ACPI 5.1 and _DSD method we can finally name GPIOs (and
other things as well) returned by _CRS. Previously we were only able to
use integer index to find the corresponding GPIO, which is pretty error
prone if the order changes.
With _DSD we can now query GPIOs using name instead of an integer index,
like the below example shows:
// Bluetooth device with reset and shutdown GPIOs
Device (BTH)
{
Name (_HID, ...)
Name (_CRS, ResourceTemplate ()
{
GpioIo (Exclusive, PullUp, 0, 0, IoRestrictionInputOnly,
"\\_SB.GPO0", 0, ResourceConsumer) {15}
GpioIo (Exclusive, PullUp, 0, 0, IoRestrictionInputOnly,
"\\_SB.GPO0", 0, ResourceConsumer) {27, 31}
})
Name (_DSD, Package ()
{
ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
Package ()
{
Package () {"reset-gpio", Package() {^BTH, 1, 1, 0 }},
Package () {"shutdown-gpio", Package() {^BTH, 0, 0, 0 }},
}
})
}
The format of the supported GPIO property is:
Package () { "name", Package () { ref, index, pin, active_low }}
ref - The device that has _CRS containing GpioIo()/GpioInt() resources,
typically this is the device itself (BTH in our case).
index - Index of the GpioIo()/GpioInt() resource in _CRS starting from zero.
pin - Pin in the GpioIo()/GpioInt() resource. Typically this is zero.
active_low - If 1 the GPIO is marked as active_low.
Since ACPI GpioIo() resource does not have field saying whether it is
active low or high, the "active_low" argument can be used here. Setting
it to 1 marks the GPIO as active low.
In our Bluetooth example the "reset-gpio" refers to the second GpioIo()
resource, second pin in that resource with the GPIO number of 31.
This patch implements necessary support to gpiolib for extracting GPIOs
using _DSD device properties.
Signed-off-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Acked-by: Linus Walleij <linus.walleij@linaro.org>
Acked-by: Grant Likely <grant.likely@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-10-29 08:41:01 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
desc = acpi_get_gpiod_by_index(adev, propname, idx, &info);
|
|
|
|
if (!IS_ERR(desc) || (PTR_ERR(desc) == -EPROBE_DEFER))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Then from plain _CRS GPIOs */
|
|
|
|
if (IS_ERR(desc)) {
|
2015-11-11 12:45:30 -07:00
|
|
|
if (!acpi_can_fallback_to_crs(adev, con_id))
|
|
|
|
return ERR_PTR(-ENOENT);
|
|
|
|
|
gpio / ACPI: Add support for _DSD device properties
With release of ACPI 5.1 and _DSD method we can finally name GPIOs (and
other things as well) returned by _CRS. Previously we were only able to
use integer index to find the corresponding GPIO, which is pretty error
prone if the order changes.
With _DSD we can now query GPIOs using name instead of an integer index,
like the below example shows:
// Bluetooth device with reset and shutdown GPIOs
Device (BTH)
{
Name (_HID, ...)
Name (_CRS, ResourceTemplate ()
{
GpioIo (Exclusive, PullUp, 0, 0, IoRestrictionInputOnly,
"\\_SB.GPO0", 0, ResourceConsumer) {15}
GpioIo (Exclusive, PullUp, 0, 0, IoRestrictionInputOnly,
"\\_SB.GPO0", 0, ResourceConsumer) {27, 31}
})
Name (_DSD, Package ()
{
ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
Package ()
{
Package () {"reset-gpio", Package() {^BTH, 1, 1, 0 }},
Package () {"shutdown-gpio", Package() {^BTH, 0, 0, 0 }},
}
})
}
The format of the supported GPIO property is:
Package () { "name", Package () { ref, index, pin, active_low }}
ref - The device that has _CRS containing GpioIo()/GpioInt() resources,
typically this is the device itself (BTH in our case).
index - Index of the GpioIo()/GpioInt() resource in _CRS starting from zero.
pin - Pin in the GpioIo()/GpioInt() resource. Typically this is zero.
active_low - If 1 the GPIO is marked as active_low.
Since ACPI GpioIo() resource does not have field saying whether it is
active low or high, the "active_low" argument can be used here. Setting
it to 1 marks the GPIO as active low.
In our Bluetooth example the "reset-gpio" refers to the second GpioIo()
resource, second pin in that resource with the GPIO number of 31.
This patch implements necessary support to gpiolib for extracting GPIOs
using _DSD device properties.
Signed-off-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Acked-by: Linus Walleij <linus.walleij@linaro.org>
Acked-by: Grant Likely <grant.likely@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-10-29 08:41:01 -06:00
|
|
|
desc = acpi_get_gpiod_by_index(adev, NULL, idx, &info);
|
|
|
|
if (IS_ERR(desc))
|
|
|
|
return desc;
|
gpio / ACPI: ignore GpioInt() GPIOs when requesting GPIO_OUT_*
When firmware does not use _DSD properties that allow properly name GPIO
resources, the kernel falls back on parsing _CRS resources, and will
return entries described as GpioInt() as general purpose GPIOs even
though they are meant to be used simply as interrupt sources for the
device:
Device (ETSA)
{
Name (_HID, "ELAN0001")
...
Method(_CRS, 0x0, NotSerialized)
{
Name(BUF0,ResourceTemplate ()
{
I2CSerialBus(
0x10, /* SlaveAddress */
ControllerInitiated, /* SlaveMode */
400000, /* ConnectionSpeed */
AddressingMode7Bit, /* AddressingMode */
"\\_SB.I2C1", /* ResourceSource */
)
GpioInt (Edge, ActiveLow, ExclusiveAndWake, PullNone,,
"\\_SB.GPSW") { BOARD_TOUCH_GPIO_INDEX }
} )
Return (BUF0)
}
...
}
This gives troubles with drivers such as Elan Touchscreen driver
(elants_i2c) that uses devm_gpiod_get to look up "reset" GPIO line and
decide whether the driver is responsible for powering up and resetting
the device, or firmware is. In the above case the lookup succeeds, we
map GPIO as output and later fail to request client->irq interrupt that
is mapped to the same GPIO.
Let's ignore resources described as GpioInt() while parsing _CRS when
requesting output GPIOs (but allow them when requesting GPIOD_ASIS or
GPIOD_IN as some drivers, such as i2c-hid, do request GPIO as input and
then map it to interrupt with gpiod_to_irq).
Acked-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Signed-off-by: Dmitry Torokhov <dtor@chromium.org>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-03-24 11:50:25 -06:00
|
|
|
|
|
|
|
if ((flags == GPIOD_OUT_LOW || flags == GPIOD_OUT_HIGH) &&
|
|
|
|
info.gpioint) {
|
|
|
|
dev_dbg(dev, "refusing GpioInt() entry when doing GPIOD_OUT_* lookup\n");
|
|
|
|
return ERR_PTR(-ENOENT);
|
|
|
|
}
|
gpio / ACPI: Add support for _DSD device properties
With release of ACPI 5.1 and _DSD method we can finally name GPIOs (and
other things as well) returned by _CRS. Previously we were only able to
use integer index to find the corresponding GPIO, which is pretty error
prone if the order changes.
With _DSD we can now query GPIOs using name instead of an integer index,
like the below example shows:
// Bluetooth device with reset and shutdown GPIOs
Device (BTH)
{
Name (_HID, ...)
Name (_CRS, ResourceTemplate ()
{
GpioIo (Exclusive, PullUp, 0, 0, IoRestrictionInputOnly,
"\\_SB.GPO0", 0, ResourceConsumer) {15}
GpioIo (Exclusive, PullUp, 0, 0, IoRestrictionInputOnly,
"\\_SB.GPO0", 0, ResourceConsumer) {27, 31}
})
Name (_DSD, Package ()
{
ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
Package ()
{
Package () {"reset-gpio", Package() {^BTH, 1, 1, 0 }},
Package () {"shutdown-gpio", Package() {^BTH, 0, 0, 0 }},
}
})
}
The format of the supported GPIO property is:
Package () { "name", Package () { ref, index, pin, active_low }}
ref - The device that has _CRS containing GpioIo()/GpioInt() resources,
typically this is the device itself (BTH in our case).
index - Index of the GpioIo()/GpioInt() resource in _CRS starting from zero.
pin - Pin in the GpioIo()/GpioInt() resource. Typically this is zero.
active_low - If 1 the GPIO is marked as active_low.
Since ACPI GpioIo() resource does not have field saying whether it is
active low or high, the "active_low" argument can be used here. Setting
it to 1 marks the GPIO as active low.
In our Bluetooth example the "reset-gpio" refers to the second GpioIo()
resource, second pin in that resource with the GPIO number of 31.
This patch implements necessary support to gpiolib for extracting GPIOs
using _DSD device properties.
Signed-off-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Acked-by: Linus Walleij <linus.walleij@linaro.org>
Acked-by: Grant Likely <grant.likely@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-10-29 08:41:01 -06:00
|
|
|
}
|
2013-10-10 02:01:10 -06:00
|
|
|
|
2015-12-23 15:25:34 -07:00
|
|
|
if (info.polarity == GPIO_ACTIVE_LOW)
|
gpio / ACPI: ignore GpioInt() GPIOs when requesting GPIO_OUT_*
When firmware does not use _DSD properties that allow properly name GPIO
resources, the kernel falls back on parsing _CRS resources, and will
return entries described as GpioInt() as general purpose GPIOs even
though they are meant to be used simply as interrupt sources for the
device:
Device (ETSA)
{
Name (_HID, "ELAN0001")
...
Method(_CRS, 0x0, NotSerialized)
{
Name(BUF0,ResourceTemplate ()
{
I2CSerialBus(
0x10, /* SlaveAddress */
ControllerInitiated, /* SlaveMode */
400000, /* ConnectionSpeed */
AddressingMode7Bit, /* AddressingMode */
"\\_SB.I2C1", /* ResourceSource */
)
GpioInt (Edge, ActiveLow, ExclusiveAndWake, PullNone,,
"\\_SB.GPSW") { BOARD_TOUCH_GPIO_INDEX }
} )
Return (BUF0)
}
...
}
This gives troubles with drivers such as Elan Touchscreen driver
(elants_i2c) that uses devm_gpiod_get to look up "reset" GPIO line and
decide whether the driver is responsible for powering up and resetting
the device, or firmware is. In the above case the lookup succeeds, we
map GPIO as output and later fail to request client->irq interrupt that
is mapped to the same GPIO.
Let's ignore resources described as GpioInt() while parsing _CRS when
requesting output GPIOs (but allow them when requesting GPIOD_ASIS or
GPIOD_IN as some drivers, such as i2c-hid, do request GPIO as input and
then map it to interrupt with gpiod_to_irq).
Acked-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Signed-off-by: Dmitry Torokhov <dtor@chromium.org>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-03-24 11:50:25 -06:00
|
|
|
*lookupflags |= GPIO_ACTIVE_LOW;
|
2013-10-10 02:01:10 -06:00
|
|
|
|
|
|
|
return desc;
|
2013-10-10 02:01:09 -06:00
|
|
|
}
|
|
|
|
|
2013-12-02 20:20:11 -07:00
|
|
|
static struct gpiod_lookup_table *gpiod_find_lookup_table(struct device *dev)
|
2013-10-17 11:21:38 -06:00
|
|
|
{
|
|
|
|
const char *dev_id = dev ? dev_name(dev) : NULL;
|
2013-12-02 20:20:11 -07:00
|
|
|
struct gpiod_lookup_table *table;
|
2013-10-17 11:21:38 -06:00
|
|
|
|
|
|
|
mutex_lock(&gpio_lookup_lock);
|
|
|
|
|
2013-12-02 20:20:11 -07:00
|
|
|
list_for_each_entry(table, &gpio_lookup_list, list) {
|
|
|
|
if (table->dev_id && dev_id) {
|
|
|
|
/*
|
|
|
|
* Valid strings on both ends, must be identical to have
|
|
|
|
* a match
|
|
|
|
*/
|
|
|
|
if (!strcmp(table->dev_id, dev_id))
|
|
|
|
goto found;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* One of the pointers is NULL, so both must be to have
|
|
|
|
* a match
|
|
|
|
*/
|
|
|
|
if (dev_id == table->dev_id)
|
|
|
|
goto found;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
table = NULL;
|
2013-10-17 11:21:38 -06:00
|
|
|
|
2013-12-02 20:20:11 -07:00
|
|
|
found:
|
|
|
|
mutex_unlock(&gpio_lookup_lock);
|
|
|
|
return table;
|
|
|
|
}
|
2013-10-17 11:21:38 -06:00
|
|
|
|
2013-12-02 20:20:11 -07:00
|
|
|
static struct gpio_desc *gpiod_find(struct device *dev, const char *con_id,
|
|
|
|
unsigned int idx,
|
|
|
|
enum gpio_lookup_flags *flags)
|
|
|
|
{
|
2013-12-10 19:32:28 -07:00
|
|
|
struct gpio_desc *desc = ERR_PTR(-ENOENT);
|
2013-12-02 20:20:11 -07:00
|
|
|
struct gpiod_lookup_table *table;
|
|
|
|
struct gpiod_lookup *p;
|
2013-10-17 11:21:38 -06:00
|
|
|
|
2013-12-02 20:20:11 -07:00
|
|
|
table = gpiod_find_lookup_table(dev);
|
|
|
|
if (!table)
|
|
|
|
return desc;
|
2013-10-17 11:21:38 -06:00
|
|
|
|
2013-12-02 20:20:11 -07:00
|
|
|
for (p = &table->table[0]; p->chip_label; p++) {
|
|
|
|
struct gpio_chip *chip;
|
2013-10-17 11:21:38 -06:00
|
|
|
|
2013-12-02 20:20:11 -07:00
|
|
|
/* idx must always match exactly */
|
2013-10-17 11:21:38 -06:00
|
|
|
if (p->idx != idx)
|
|
|
|
continue;
|
|
|
|
|
2013-12-02 20:20:11 -07:00
|
|
|
/* If the lookup entry has a con_id, require exact match */
|
|
|
|
if (p->con_id && (!con_id || strcmp(p->con_id, con_id)))
|
|
|
|
continue;
|
2013-10-17 11:21:38 -06:00
|
|
|
|
2013-12-02 20:20:11 -07:00
|
|
|
chip = find_chip_by_name(p->chip_label);
|
2013-10-17 11:21:38 -06:00
|
|
|
|
2013-12-02 20:20:11 -07:00
|
|
|
if (!chip) {
|
2013-12-10 19:32:28 -07:00
|
|
|
dev_err(dev, "cannot find GPIO chip %s\n",
|
|
|
|
p->chip_label);
|
|
|
|
return ERR_PTR(-ENODEV);
|
2013-12-02 20:20:11 -07:00
|
|
|
}
|
2013-10-17 11:21:38 -06:00
|
|
|
|
2013-12-02 20:20:11 -07:00
|
|
|
if (chip->ngpio <= p->chip_hwnum) {
|
2013-12-10 19:32:28 -07:00
|
|
|
dev_err(dev,
|
|
|
|
"requested GPIO %d is out of range [0..%d] for chip %s\n",
|
|
|
|
idx, chip->ngpio, chip->label);
|
|
|
|
return ERR_PTR(-EINVAL);
|
2013-10-17 11:21:38 -06:00
|
|
|
}
|
|
|
|
|
2014-02-09 01:43:54 -07:00
|
|
|
desc = gpiochip_get_desc(chip, p->chip_hwnum);
|
2013-12-02 20:20:11 -07:00
|
|
|
*flags = p->flags;
|
2013-10-17 11:21:38 -06:00
|
|
|
|
2013-12-10 19:32:28 -07:00
|
|
|
return desc;
|
2013-10-17 11:21:38 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return desc;
|
|
|
|
}
|
|
|
|
|
2015-02-11 09:27:58 -07:00
|
|
|
static int dt_gpio_count(struct device *dev, const char *con_id)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
char propname[32];
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
|
|
|
|
if (con_id)
|
|
|
|
snprintf(propname, sizeof(propname), "%s-%s",
|
|
|
|
con_id, gpio_suffixes[i]);
|
|
|
|
else
|
|
|
|
snprintf(propname, sizeof(propname), "%s",
|
|
|
|
gpio_suffixes[i]);
|
|
|
|
|
|
|
|
ret = of_gpio_named_count(dev->of_node, propname);
|
|
|
|
if (ret >= 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int platform_gpio_count(struct device *dev, const char *con_id)
|
|
|
|
{
|
|
|
|
struct gpiod_lookup_table *table;
|
|
|
|
struct gpiod_lookup *p;
|
|
|
|
unsigned int count = 0;
|
|
|
|
|
|
|
|
table = gpiod_find_lookup_table(dev);
|
|
|
|
if (!table)
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
for (p = &table->table[0]; p->chip_label; p++) {
|
|
|
|
if ((con_id && p->con_id && !strcmp(con_id, p->con_id)) ||
|
|
|
|
(!con_id && !p->con_id))
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
if (!count)
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gpiod_count - return the number of GPIOs associated with a device / function
|
|
|
|
* or -ENOENT if no GPIO has been assigned to the requested function
|
|
|
|
* @dev: GPIO consumer, can be NULL for system-global GPIOs
|
|
|
|
* @con_id: function within the GPIO consumer
|
|
|
|
*/
|
|
|
|
int gpiod_count(struct device *dev, const char *con_id)
|
|
|
|
{
|
|
|
|
int count = -ENOENT;
|
|
|
|
|
|
|
|
if (IS_ENABLED(CONFIG_OF) && dev && dev->of_node)
|
|
|
|
count = dt_gpio_count(dev, con_id);
|
|
|
|
else if (IS_ENABLED(CONFIG_ACPI) && dev && ACPI_HANDLE(dev))
|
|
|
|
count = acpi_gpio_count(dev, con_id);
|
|
|
|
|
|
|
|
if (count < 0)
|
|
|
|
count = platform_gpio_count(dev, con_id);
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(gpiod_count);
|
|
|
|
|
2013-10-17 11:21:38 -06:00
|
|
|
/**
|
2014-04-25 08:54:22 -06:00
|
|
|
* gpiod_get - obtain a GPIO for a given GPIO function
|
2013-12-02 20:20:11 -07:00
|
|
|
* @dev: GPIO consumer, can be NULL for system-global GPIOs
|
2013-10-17 11:21:38 -06:00
|
|
|
* @con_id: function within the GPIO consumer
|
2014-07-25 08:38:36 -06:00
|
|
|
* @flags: optional GPIO initialization flags
|
2013-10-17 11:21:38 -06:00
|
|
|
*
|
|
|
|
* Return the GPIO descriptor corresponding to the function con_id of device
|
2013-12-10 19:32:28 -07:00
|
|
|
* dev, -ENOENT if no GPIO has been assigned to the requested function, or
|
2015-05-18 12:41:43 -06:00
|
|
|
* another IS_ERR() code if an error occurred while trying to acquire the GPIO.
|
2013-10-17 11:21:38 -06:00
|
|
|
*/
|
2015-02-11 03:52:37 -07:00
|
|
|
struct gpio_desc *__must_check gpiod_get(struct device *dev, const char *con_id,
|
2014-07-25 08:38:36 -06:00
|
|
|
enum gpiod_flags flags)
|
2013-10-17 11:21:38 -06:00
|
|
|
{
|
2014-07-25 08:38:36 -06:00
|
|
|
return gpiod_get_index(dev, con_id, 0, flags);
|
2013-10-17 11:21:38 -06:00
|
|
|
}
|
2015-02-11 03:52:37 -07:00
|
|
|
EXPORT_SYMBOL_GPL(gpiod_get);
|
2013-10-17 11:21:38 -06:00
|
|
|
|
2014-04-25 09:10:06 -06:00
|
|
|
/**
|
|
|
|
* gpiod_get_optional - obtain an optional GPIO for a given GPIO function
|
|
|
|
* @dev: GPIO consumer, can be NULL for system-global GPIOs
|
|
|
|
* @con_id: function within the GPIO consumer
|
2014-07-25 08:38:36 -06:00
|
|
|
* @flags: optional GPIO initialization flags
|
2014-04-25 09:10:06 -06:00
|
|
|
*
|
|
|
|
* This is equivalent to gpiod_get(), except that when no GPIO was assigned to
|
|
|
|
* the requested function it will return NULL. This is convenient for drivers
|
|
|
|
* that need to handle optional GPIOs.
|
|
|
|
*/
|
2015-02-11 03:52:37 -07:00
|
|
|
struct gpio_desc *__must_check gpiod_get_optional(struct device *dev,
|
2014-07-25 08:38:36 -06:00
|
|
|
const char *con_id,
|
|
|
|
enum gpiod_flags flags)
|
2014-04-25 09:10:06 -06:00
|
|
|
{
|
2014-07-25 08:38:36 -06:00
|
|
|
return gpiod_get_index_optional(dev, con_id, 0, flags);
|
2014-04-25 09:10:06 -06:00
|
|
|
}
|
2015-02-11 03:52:37 -07:00
|
|
|
EXPORT_SYMBOL_GPL(gpiod_get_optional);
|
2014-04-25 09:10:06 -06:00
|
|
|
|
2015-10-12 15:20:20 -06:00
|
|
|
/**
|
|
|
|
* gpiod_parse_flags - helper function to parse GPIO lookup flags
|
|
|
|
* @desc: gpio to be setup
|
|
|
|
* @lflags: gpio_lookup_flags - returned from of_find_gpio() or
|
|
|
|
* of_get_gpio_hog()
|
|
|
|
*
|
|
|
|
* Set the GPIO descriptor flags based on the given GPIO lookup flags.
|
|
|
|
*/
|
|
|
|
static void gpiod_parse_flags(struct gpio_desc *desc, unsigned long lflags)
|
|
|
|
{
|
|
|
|
if (lflags & GPIO_ACTIVE_LOW)
|
|
|
|
set_bit(FLAG_ACTIVE_LOW, &desc->flags);
|
|
|
|
if (lflags & GPIO_OPEN_DRAIN)
|
|
|
|
set_bit(FLAG_OPEN_DRAIN, &desc->flags);
|
|
|
|
if (lflags & GPIO_OPEN_SOURCE)
|
|
|
|
set_bit(FLAG_OPEN_SOURCE, &desc->flags);
|
|
|
|
}
|
2015-02-02 10:44:44 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* gpiod_configure_flags - helper function to configure a given GPIO
|
|
|
|
* @desc: gpio whose value will be assigned
|
|
|
|
* @con_id: function within the GPIO consumer
|
|
|
|
* @dflags: gpiod_flags - optional GPIO initialization flags
|
|
|
|
*
|
|
|
|
* Return 0 on success, -ENOENT if no GPIO has been assigned to the
|
|
|
|
* requested function and/or index, or another IS_ERR() code if an error
|
|
|
|
* occurred while trying to acquire the GPIO.
|
|
|
|
*/
|
|
|
|
static int gpiod_configure_flags(struct gpio_desc *desc, const char *con_id,
|
2015-10-12 15:20:20 -06:00
|
|
|
enum gpiod_flags dflags)
|
2015-02-02 10:44:44 -07:00
|
|
|
{
|
|
|
|
int status;
|
|
|
|
|
|
|
|
/* No particular flag request, return here... */
|
|
|
|
if (!(dflags & GPIOD_FLAGS_BIT_DIR_SET)) {
|
|
|
|
pr_debug("no flags found for %s\n", con_id);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Process flags */
|
|
|
|
if (dflags & GPIOD_FLAGS_BIT_DIR_OUT)
|
|
|
|
status = gpiod_direction_output(desc,
|
|
|
|
dflags & GPIOD_FLAGS_BIT_DIR_VAL);
|
|
|
|
else
|
|
|
|
status = gpiod_direction_input(desc);
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2013-10-17 11:21:38 -06:00
|
|
|
/**
|
|
|
|
* gpiod_get_index - obtain a GPIO from a multi-index GPIO function
|
2013-12-05 02:26:26 -07:00
|
|
|
* @dev: GPIO consumer, can be NULL for system-global GPIOs
|
2013-10-17 11:21:38 -06:00
|
|
|
* @con_id: function within the GPIO consumer
|
|
|
|
* @idx: index of the GPIO to obtain in the consumer
|
2014-07-25 08:38:36 -06:00
|
|
|
* @flags: optional GPIO initialization flags
|
2013-10-17 11:21:38 -06:00
|
|
|
*
|
|
|
|
* This variant of gpiod_get() allows to access GPIOs other than the first
|
|
|
|
* defined one for functions that define several GPIOs.
|
|
|
|
*
|
2013-12-10 19:32:28 -07:00
|
|
|
* Return a valid GPIO descriptor, -ENOENT if no GPIO has been assigned to the
|
|
|
|
* requested function and/or index, or another IS_ERR() code if an error
|
2015-05-18 12:41:43 -06:00
|
|
|
* occurred while trying to acquire the GPIO.
|
2013-10-17 11:21:38 -06:00
|
|
|
*/
|
2015-02-11 03:52:37 -07:00
|
|
|
struct gpio_desc *__must_check gpiod_get_index(struct device *dev,
|
2013-10-17 11:21:38 -06:00
|
|
|
const char *con_id,
|
2014-07-25 08:38:36 -06:00
|
|
|
unsigned int idx,
|
|
|
|
enum gpiod_flags flags)
|
2013-10-17 11:21:38 -06:00
|
|
|
{
|
2013-11-23 03:34:50 -07:00
|
|
|
struct gpio_desc *desc = NULL;
|
2013-10-17 11:21:38 -06:00
|
|
|
int status;
|
2014-07-25 08:38:36 -06:00
|
|
|
enum gpio_lookup_flags lookupflags = 0;
|
2013-10-17 11:21:38 -06:00
|
|
|
|
|
|
|
dev_dbg(dev, "GPIO lookup for consumer %s\n", con_id);
|
|
|
|
|
2015-03-10 16:08:57 -06:00
|
|
|
if (dev) {
|
|
|
|
/* Using device tree? */
|
|
|
|
if (IS_ENABLED(CONFIG_OF) && dev->of_node) {
|
|
|
|
dev_dbg(dev, "using device tree for GPIO lookup\n");
|
|
|
|
desc = of_find_gpio(dev, con_id, idx, &lookupflags);
|
|
|
|
} else if (ACPI_COMPANION(dev)) {
|
|
|
|
dev_dbg(dev, "using ACPI for GPIO lookup\n");
|
gpio / ACPI: ignore GpioInt() GPIOs when requesting GPIO_OUT_*
When firmware does not use _DSD properties that allow properly name GPIO
resources, the kernel falls back on parsing _CRS resources, and will
return entries described as GpioInt() as general purpose GPIOs even
though they are meant to be used simply as interrupt sources for the
device:
Device (ETSA)
{
Name (_HID, "ELAN0001")
...
Method(_CRS, 0x0, NotSerialized)
{
Name(BUF0,ResourceTemplate ()
{
I2CSerialBus(
0x10, /* SlaveAddress */
ControllerInitiated, /* SlaveMode */
400000, /* ConnectionSpeed */
AddressingMode7Bit, /* AddressingMode */
"\\_SB.I2C1", /* ResourceSource */
)
GpioInt (Edge, ActiveLow, ExclusiveAndWake, PullNone,,
"\\_SB.GPSW") { BOARD_TOUCH_GPIO_INDEX }
} )
Return (BUF0)
}
...
}
This gives troubles with drivers such as Elan Touchscreen driver
(elants_i2c) that uses devm_gpiod_get to look up "reset" GPIO line and
decide whether the driver is responsible for powering up and resetting
the device, or firmware is. In the above case the lookup succeeds, we
map GPIO as output and later fail to request client->irq interrupt that
is mapped to the same GPIO.
Let's ignore resources described as GpioInt() while parsing _CRS when
requesting output GPIOs (but allow them when requesting GPIOD_ASIS or
GPIOD_IN as some drivers, such as i2c-hid, do request GPIO as input and
then map it to interrupt with gpiod_to_irq).
Acked-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Signed-off-by: Dmitry Torokhov <dtor@chromium.org>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-03-24 11:50:25 -06:00
|
|
|
desc = acpi_find_gpio(dev, con_id, idx, flags, &lookupflags);
|
2015-03-10 16:08:57 -06:00
|
|
|
}
|
2013-11-23 03:34:50 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Either we are not using DT or ACPI, or their lookup did not return
|
|
|
|
* a result. In that case, use platform lookup as a fallback.
|
|
|
|
*/
|
2013-12-10 19:32:28 -07:00
|
|
|
if (!desc || desc == ERR_PTR(-ENOENT)) {
|
2014-09-19 01:39:25 -06:00
|
|
|
dev_dbg(dev, "using lookup tables for GPIO lookup\n");
|
2014-07-25 08:38:36 -06:00
|
|
|
desc = gpiod_find(dev, con_id, idx, &lookupflags);
|
2013-10-17 11:21:38 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (IS_ERR(desc)) {
|
2013-11-29 06:47:34 -07:00
|
|
|
dev_dbg(dev, "lookup for GPIO %s failed\n", con_id);
|
2013-10-17 11:21:38 -06:00
|
|
|
return desc;
|
|
|
|
}
|
|
|
|
|
2015-10-12 15:20:20 -06:00
|
|
|
gpiod_parse_flags(desc, lookupflags);
|
|
|
|
|
2013-10-17 11:21:38 -06:00
|
|
|
status = gpiod_request(desc, con_id);
|
|
|
|
if (status < 0)
|
|
|
|
return ERR_PTR(status);
|
|
|
|
|
2015-10-12 15:20:20 -06:00
|
|
|
status = gpiod_configure_flags(desc, con_id, flags);
|
2014-07-25 08:38:36 -06:00
|
|
|
if (status < 0) {
|
|
|
|
dev_dbg(dev, "setup of GPIO %s failed\n", con_id);
|
|
|
|
gpiod_put(desc);
|
|
|
|
return ERR_PTR(status);
|
|
|
|
}
|
|
|
|
|
2013-10-17 11:21:38 -06:00
|
|
|
return desc;
|
|
|
|
}
|
2015-02-11 03:52:37 -07:00
|
|
|
EXPORT_SYMBOL_GPL(gpiod_get_index);
|
2013-10-17 11:21:38 -06:00
|
|
|
|
2014-10-21 05:33:59 -06:00
|
|
|
/**
|
|
|
|
* fwnode_get_named_gpiod - obtain a GPIO from firmware node
|
|
|
|
* @fwnode: handle of the firmware node
|
|
|
|
* @propname: name of the firmware property representing the GPIO
|
|
|
|
*
|
|
|
|
* This function can be used for drivers that get their configuration
|
|
|
|
* from firmware.
|
|
|
|
*
|
|
|
|
* Function properly finds the corresponding GPIO using whatever is the
|
|
|
|
* underlying firmware interface and then makes sure that the GPIO
|
|
|
|
* descriptor is requested before it is returned to the caller.
|
|
|
|
*
|
|
|
|
* In case of error an ERR_PTR() is returned.
|
|
|
|
*/
|
|
|
|
struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
|
|
|
|
const char *propname)
|
|
|
|
{
|
|
|
|
struct gpio_desc *desc = ERR_PTR(-ENODEV);
|
|
|
|
bool active_low = false;
|
2015-10-12 15:20:21 -06:00
|
|
|
bool single_ended = false;
|
2014-10-21 05:33:59 -06:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!fwnode)
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
|
|
|
|
if (is_of_node(fwnode)) {
|
|
|
|
enum of_gpio_flags flags;
|
|
|
|
|
2015-06-22 14:38:53 -06:00
|
|
|
desc = of_get_named_gpiod_flags(to_of_node(fwnode), propname, 0,
|
2014-10-21 05:33:59 -06:00
|
|
|
&flags);
|
2015-10-12 15:20:21 -06:00
|
|
|
if (!IS_ERR(desc)) {
|
2014-10-21 05:33:59 -06:00
|
|
|
active_low = flags & OF_GPIO_ACTIVE_LOW;
|
2015-10-12 15:20:21 -06:00
|
|
|
single_ended = flags & OF_GPIO_SINGLE_ENDED;
|
|
|
|
}
|
2014-10-21 05:33:59 -06:00
|
|
|
} else if (is_acpi_node(fwnode)) {
|
|
|
|
struct acpi_gpio_info info;
|
|
|
|
|
2015-08-26 20:42:33 -06:00
|
|
|
desc = acpi_node_get_gpiod(fwnode, propname, 0, &info);
|
2014-10-21 05:33:59 -06:00
|
|
|
if (!IS_ERR(desc))
|
2015-12-23 15:25:34 -07:00
|
|
|
active_low = info.polarity == GPIO_ACTIVE_LOW;
|
2014-10-21 05:33:59 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (IS_ERR(desc))
|
|
|
|
return desc;
|
|
|
|
|
|
|
|
if (active_low)
|
|
|
|
set_bit(FLAG_ACTIVE_LOW, &desc->flags);
|
|
|
|
|
2015-10-12 15:20:21 -06:00
|
|
|
if (single_ended) {
|
|
|
|
if (active_low)
|
|
|
|
set_bit(FLAG_OPEN_DRAIN, &desc->flags);
|
|
|
|
else
|
|
|
|
set_bit(FLAG_OPEN_SOURCE, &desc->flags);
|
|
|
|
}
|
|
|
|
|
2015-10-12 15:20:20 -06:00
|
|
|
ret = gpiod_request(desc, NULL);
|
|
|
|
if (ret)
|
|
|
|
return ERR_PTR(ret);
|
|
|
|
|
2014-10-21 05:33:59 -06:00
|
|
|
return desc;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(fwnode_get_named_gpiod);
|
|
|
|
|
2014-04-25 09:10:06 -06:00
|
|
|
/**
|
|
|
|
* gpiod_get_index_optional - obtain an optional GPIO from a multi-index GPIO
|
|
|
|
* function
|
|
|
|
* @dev: GPIO consumer, can be NULL for system-global GPIOs
|
|
|
|
* @con_id: function within the GPIO consumer
|
|
|
|
* @index: index of the GPIO to obtain in the consumer
|
2014-07-25 08:38:36 -06:00
|
|
|
* @flags: optional GPIO initialization flags
|
2014-04-25 09:10:06 -06:00
|
|
|
*
|
|
|
|
* This is equivalent to gpiod_get_index(), except that when no GPIO with the
|
|
|
|
* specified index was assigned to the requested function it will return NULL.
|
|
|
|
* This is convenient for drivers that need to handle optional GPIOs.
|
|
|
|
*/
|
2015-02-11 03:52:37 -07:00
|
|
|
struct gpio_desc *__must_check gpiod_get_index_optional(struct device *dev,
|
2014-04-25 09:10:06 -06:00
|
|
|
const char *con_id,
|
2014-07-25 08:38:36 -06:00
|
|
|
unsigned int index,
|
|
|
|
enum gpiod_flags flags)
|
2014-04-25 09:10:06 -06:00
|
|
|
{
|
|
|
|
struct gpio_desc *desc;
|
|
|
|
|
2014-07-25 08:38:36 -06:00
|
|
|
desc = gpiod_get_index(dev, con_id, index, flags);
|
2014-04-25 09:10:06 -06:00
|
|
|
if (IS_ERR(desc)) {
|
|
|
|
if (PTR_ERR(desc) == -ENOENT)
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return desc;
|
|
|
|
}
|
2015-02-11 03:52:37 -07:00
|
|
|
EXPORT_SYMBOL_GPL(gpiod_get_index_optional);
|
2014-04-25 09:10:06 -06:00
|
|
|
|
2015-02-02 10:44:44 -07:00
|
|
|
/**
|
|
|
|
* gpiod_hog - Hog the specified GPIO desc given the provided flags
|
|
|
|
* @desc: gpio whose value will be assigned
|
|
|
|
* @name: gpio line name
|
|
|
|
* @lflags: gpio_lookup_flags - returned from of_find_gpio() or
|
|
|
|
* of_get_gpio_hog()
|
|
|
|
* @dflags: gpiod_flags - optional GPIO initialization flags
|
|
|
|
*/
|
|
|
|
int gpiod_hog(struct gpio_desc *desc, const char *name,
|
|
|
|
unsigned long lflags, enum gpiod_flags dflags)
|
|
|
|
{
|
|
|
|
struct gpio_chip *chip;
|
|
|
|
struct gpio_desc *local_desc;
|
|
|
|
int hwnum;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
chip = gpiod_to_chip(desc);
|
|
|
|
hwnum = gpio_chip_hwgpio(desc);
|
|
|
|
|
2015-10-12 15:20:20 -06:00
|
|
|
gpiod_parse_flags(desc, lflags);
|
|
|
|
|
2015-02-02 10:44:44 -07:00
|
|
|
local_desc = gpiochip_request_own_desc(chip, hwnum, name);
|
|
|
|
if (IS_ERR(local_desc)) {
|
2015-06-05 03:36:10 -06:00
|
|
|
pr_err("requesting hog GPIO %s (chip %s, offset %d) failed\n",
|
|
|
|
name, chip->label, hwnum);
|
2015-02-02 10:44:44 -07:00
|
|
|
return PTR_ERR(local_desc);
|
|
|
|
}
|
|
|
|
|
2015-10-12 15:20:20 -06:00
|
|
|
status = gpiod_configure_flags(desc, name, dflags);
|
2015-02-02 10:44:44 -07:00
|
|
|
if (status < 0) {
|
2015-06-05 03:36:10 -06:00
|
|
|
pr_err("setup of hog GPIO %s (chip %s, offset %d) failed\n",
|
|
|
|
name, chip->label, hwnum);
|
2015-02-02 10:44:44 -07:00
|
|
|
gpiochip_free_own_desc(desc);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Mark GPIO as hogged so it can be identified and removed later */
|
|
|
|
set_bit(FLAG_IS_HOGGED, &desc->flags);
|
|
|
|
|
|
|
|
pr_info("GPIO line %d (%s) hogged as %s%s\n",
|
|
|
|
desc_to_gpio(desc), name,
|
|
|
|
(dflags&GPIOD_FLAGS_BIT_DIR_OUT) ? "output" : "input",
|
|
|
|
(dflags&GPIOD_FLAGS_BIT_DIR_OUT) ?
|
|
|
|
(dflags&GPIOD_FLAGS_BIT_DIR_VAL) ? "/high" : "/low":"");
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gpiochip_free_hogs - Scan gpio-controller chip and release GPIO hog
|
|
|
|
* @chip: gpio chip to act on
|
|
|
|
*
|
|
|
|
* This is only used by of_gpiochip_remove to free hogged gpios
|
|
|
|
*/
|
|
|
|
static void gpiochip_free_hogs(struct gpio_chip *chip)
|
|
|
|
{
|
|
|
|
int id;
|
|
|
|
|
|
|
|
for (id = 0; id < chip->ngpio; id++) {
|
2016-02-09 05:51:59 -07:00
|
|
|
if (test_bit(FLAG_IS_HOGGED, &chip->gpiodev->descs[id].flags))
|
|
|
|
gpiochip_free_own_desc(&chip->gpiodev->descs[id]);
|
2015-02-02 10:44:44 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-11 09:27:58 -07:00
|
|
|
/**
|
|
|
|
* gpiod_get_array - obtain multiple GPIOs from a multi-index GPIO function
|
|
|
|
* @dev: GPIO consumer, can be NULL for system-global GPIOs
|
|
|
|
* @con_id: function within the GPIO consumer
|
|
|
|
* @flags: optional GPIO initialization flags
|
|
|
|
*
|
|
|
|
* This function acquires all the GPIOs defined under a given function.
|
|
|
|
*
|
|
|
|
* Return a struct gpio_descs containing an array of descriptors, -ENOENT if
|
|
|
|
* no GPIO has been assigned to the requested function, or another IS_ERR()
|
|
|
|
* code if an error occurred while trying to acquire the GPIOs.
|
|
|
|
*/
|
|
|
|
struct gpio_descs *__must_check gpiod_get_array(struct device *dev,
|
|
|
|
const char *con_id,
|
|
|
|
enum gpiod_flags flags)
|
|
|
|
{
|
|
|
|
struct gpio_desc *desc;
|
|
|
|
struct gpio_descs *descs;
|
|
|
|
int count;
|
|
|
|
|
|
|
|
count = gpiod_count(dev, con_id);
|
|
|
|
if (count < 0)
|
|
|
|
return ERR_PTR(count);
|
|
|
|
|
|
|
|
descs = kzalloc(sizeof(*descs) + sizeof(descs->desc[0]) * count,
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!descs)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
for (descs->ndescs = 0; descs->ndescs < count; ) {
|
|
|
|
desc = gpiod_get_index(dev, con_id, descs->ndescs, flags);
|
|
|
|
if (IS_ERR(desc)) {
|
|
|
|
gpiod_put_array(descs);
|
|
|
|
return ERR_CAST(desc);
|
|
|
|
}
|
|
|
|
descs->desc[descs->ndescs] = desc;
|
|
|
|
descs->ndescs++;
|
|
|
|
}
|
|
|
|
return descs;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(gpiod_get_array);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gpiod_get_array_optional - obtain multiple GPIOs from a multi-index GPIO
|
|
|
|
* function
|
|
|
|
* @dev: GPIO consumer, can be NULL for system-global GPIOs
|
|
|
|
* @con_id: function within the GPIO consumer
|
|
|
|
* @flags: optional GPIO initialization flags
|
|
|
|
*
|
|
|
|
* This is equivalent to gpiod_get_array(), except that when no GPIO was
|
|
|
|
* assigned to the requested function it will return NULL.
|
|
|
|
*/
|
|
|
|
struct gpio_descs *__must_check gpiod_get_array_optional(struct device *dev,
|
|
|
|
const char *con_id,
|
|
|
|
enum gpiod_flags flags)
|
|
|
|
{
|
|
|
|
struct gpio_descs *descs;
|
|
|
|
|
|
|
|
descs = gpiod_get_array(dev, con_id, flags);
|
|
|
|
if (IS_ERR(descs) && (PTR_ERR(descs) == -ENOENT))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return descs;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(gpiod_get_array_optional);
|
|
|
|
|
2013-10-17 11:21:38 -06:00
|
|
|
/**
|
|
|
|
* gpiod_put - dispose of a GPIO descriptor
|
|
|
|
* @desc: GPIO descriptor to dispose of
|
|
|
|
*
|
|
|
|
* No descriptor can be used after gpiod_put() has been called on it.
|
|
|
|
*/
|
|
|
|
void gpiod_put(struct gpio_desc *desc)
|
|
|
|
{
|
|
|
|
gpiod_free(desc);
|
2013-02-02 09:29:29 -07:00
|
|
|
}
|
2013-10-17 11:21:38 -06:00
|
|
|
EXPORT_SYMBOL_GPL(gpiod_put);
|
2008-02-04 23:28:20 -07:00
|
|
|
|
2015-02-11 09:27:58 -07:00
|
|
|
/**
|
|
|
|
* gpiod_put_array - dispose of multiple GPIO descriptors
|
|
|
|
* @descs: struct gpio_descs containing an array of descriptors
|
|
|
|
*/
|
|
|
|
void gpiod_put_array(struct gpio_descs *descs)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
for (i = 0; i < descs->ndescs; i++)
|
|
|
|
gpiod_put(descs->desc[i]);
|
|
|
|
|
|
|
|
kfree(descs);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(gpiod_put_array);
|
|
|
|
|
gpio: add a userspace chardev ABI for GPIOs
A new chardev that is to be used for userspace GPIO access is
added in this patch. It is intended to gradually replace the
horribly broken sysfs ABI.
Using a chardev has many upsides:
- All operations are per-gpiochip, which is the actual
device underlying the GPIOs, making us tie in to the
kernel device model properly.
- Hotpluggable GPIO controllers can come and go, as this
kind of problem has been know to userspace for character
devices since ages, and if a gpiochip handle is held in
userspace we know we will break something, whereas the
sysfs is stateless.
- The one-value-per-file rule of sysfs is really hard to
maintain when you want to twist more than one knob at a time,
for example have in-kernel APIs to switch several GPIO
lines at the same time, and this will be possible to do
with a single ioctl() from userspace, saving a lot of
context switching.
We also need to add a new bus type for GPIO. This is
necessary for example for userspace coldplug, where sysfs is
traversed to find the boot-time device nodes and create the
character devices in /dev.
This new chardev ABI is *non* *optional* and can be counted
on to be present in the future, emphasizing the preference
of this ABI.
The ABI only implements one single ioctl() to get the name
and number of GPIO lines of a chip. Even this is debatable:
see it as a minimal example for review. This ABI shall be
ruthlessly reviewed and etched in stone.
The old /sys/class/gpio is still optional to compile in,
but will be deprecated.
Unique device IDs are created using IDR, which is overkill
and insanely scalable, but also well tested.
Cc: Johan Hovold <johan@kernel.org>
Cc: Michael Welling <mwelling@ieee.org>
Cc: Markus Pargmann <mpa@pengutronix.de>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2015-10-21 07:29:53 -06:00
|
|
|
static int __init gpiolib_dev_init(void)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* Register GPIO sysfs bus */
|
|
|
|
ret = bus_register(&gpio_bus_type);
|
|
|
|
if (ret < 0) {
|
|
|
|
pr_err("gpiolib: could not register GPIO bus type\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = alloc_chrdev_region(&gpio_devt, 0, GPIO_DEV_MAX, "gpiochip");
|
|
|
|
if (ret < 0) {
|
|
|
|
pr_err("gpiolib: failed to allocate char dev region\n");
|
|
|
|
bus_unregister(&gpio_bus_type);
|
2016-03-31 09:11:30 -06:00
|
|
|
} else {
|
|
|
|
gpiolib_initialized = true;
|
|
|
|
gpiochip_setup_devs();
|
gpio: add a userspace chardev ABI for GPIOs
A new chardev that is to be used for userspace GPIO access is
added in this patch. It is intended to gradually replace the
horribly broken sysfs ABI.
Using a chardev has many upsides:
- All operations are per-gpiochip, which is the actual
device underlying the GPIOs, making us tie in to the
kernel device model properly.
- Hotpluggable GPIO controllers can come and go, as this
kind of problem has been know to userspace for character
devices since ages, and if a gpiochip handle is held in
userspace we know we will break something, whereas the
sysfs is stateless.
- The one-value-per-file rule of sysfs is really hard to
maintain when you want to twist more than one knob at a time,
for example have in-kernel APIs to switch several GPIO
lines at the same time, and this will be possible to do
with a single ioctl() from userspace, saving a lot of
context switching.
We also need to add a new bus type for GPIO. This is
necessary for example for userspace coldplug, where sysfs is
traversed to find the boot-time device nodes and create the
character devices in /dev.
This new chardev ABI is *non* *optional* and can be counted
on to be present in the future, emphasizing the preference
of this ABI.
The ABI only implements one single ioctl() to get the name
and number of GPIO lines of a chip. Even this is debatable:
see it as a minimal example for review. This ABI shall be
ruthlessly reviewed and etched in stone.
The old /sys/class/gpio is still optional to compile in,
but will be deprecated.
Unique device IDs are created using IDR, which is overkill
and insanely scalable, but also well tested.
Cc: Johan Hovold <johan@kernel.org>
Cc: Michael Welling <mwelling@ieee.org>
Cc: Markus Pargmann <mpa@pengutronix.de>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2015-10-21 07:29:53 -06:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
core_initcall(gpiolib_dev_init);
|
|
|
|
|
2008-02-04 23:28:20 -07:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
static void gpiolib_dbg_show(struct seq_file *s, struct gpio_device *gdev)
|
2008-02-04 23:28:20 -07:00
|
|
|
{
|
|
|
|
unsigned i;
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
struct gpio_chip *chip = gdev->chip;
|
|
|
|
unsigned gpio = gdev->base;
|
|
|
|
struct gpio_desc *gdesc = &gdev->descs[0];
|
2008-02-04 23:28:20 -07:00
|
|
|
int is_out;
|
2013-09-24 03:54:38 -06:00
|
|
|
int is_irq;
|
2008-02-04 23:28:20 -07:00
|
|
|
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
for (i = 0; i < gdev->ngpio; i++, gpio++, gdesc++) {
|
2015-08-14 08:11:02 -06:00
|
|
|
if (!test_bit(FLAG_REQUESTED, &gdesc->flags)) {
|
|
|
|
if (gdesc->name) {
|
|
|
|
seq_printf(s, " gpio-%-3d (%-20.20s)\n",
|
|
|
|
gpio, gdesc->name);
|
|
|
|
}
|
2008-02-04 23:28:20 -07:00
|
|
|
continue;
|
2015-08-14 08:11:02 -06:00
|
|
|
}
|
2008-02-04 23:28:20 -07:00
|
|
|
|
2013-02-02 09:29:29 -07:00
|
|
|
gpiod_get_direction(gdesc);
|
2008-02-04 23:28:20 -07:00
|
|
|
is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
|
2013-09-24 03:54:38 -06:00
|
|
|
is_irq = test_bit(FLAG_USED_AS_IRQ, &gdesc->flags);
|
2015-08-14 08:11:02 -06:00
|
|
|
seq_printf(s, " gpio-%-3d (%-20.20s|%-20.20s) %s %s %s",
|
|
|
|
gpio, gdesc->name ? gdesc->name : "", gdesc->label,
|
2008-02-04 23:28:20 -07:00
|
|
|
is_out ? "out" : "in ",
|
|
|
|
chip->get
|
|
|
|
? (chip->get(chip, i) ? "hi" : "lo")
|
2013-09-24 03:54:38 -06:00
|
|
|
: "? ",
|
|
|
|
is_irq ? "IRQ" : " ");
|
2008-02-04 23:28:20 -07:00
|
|
|
seq_printf(s, "\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-12 05:26:01 -06:00
|
|
|
static void *gpiolib_seq_start(struct seq_file *s, loff_t *pos)
|
2008-02-04 23:28:20 -07:00
|
|
|
{
|
2013-02-09 02:41:49 -07:00
|
|
|
unsigned long flags;
|
2015-10-20 03:10:38 -06:00
|
|
|
struct gpio_device *gdev = NULL;
|
2013-02-02 09:29:27 -07:00
|
|
|
loff_t index = *pos;
|
2008-02-04 23:28:20 -07:00
|
|
|
|
2012-04-12 05:26:01 -06:00
|
|
|
s->private = "";
|
2008-02-04 23:28:20 -07:00
|
|
|
|
2013-02-09 02:41:49 -07:00
|
|
|
spin_lock_irqsave(&gpio_lock, flags);
|
2015-10-20 03:10:38 -06:00
|
|
|
list_for_each_entry(gdev, &gpio_devices, list)
|
2013-02-09 02:41:49 -07:00
|
|
|
if (index-- == 0) {
|
|
|
|
spin_unlock_irqrestore(&gpio_lock, flags);
|
2015-10-20 03:10:38 -06:00
|
|
|
return gdev;
|
2012-04-12 05:26:01 -06:00
|
|
|
}
|
2013-02-09 02:41:49 -07:00
|
|
|
spin_unlock_irqrestore(&gpio_lock, flags);
|
2012-04-12 05:26:01 -06:00
|
|
|
|
2013-02-02 09:29:27 -07:00
|
|
|
return NULL;
|
2012-04-12 05:26:01 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void *gpiolib_seq_next(struct seq_file *s, void *v, loff_t *pos)
|
|
|
|
{
|
2013-02-09 02:41:49 -07:00
|
|
|
unsigned long flags;
|
2015-10-20 03:10:38 -06:00
|
|
|
struct gpio_device *gdev = v;
|
2012-04-12 05:26:01 -06:00
|
|
|
void *ret = NULL;
|
|
|
|
|
2013-02-09 02:41:49 -07:00
|
|
|
spin_lock_irqsave(&gpio_lock, flags);
|
2015-10-20 03:10:38 -06:00
|
|
|
if (list_is_last(&gdev->list, &gpio_devices))
|
2013-02-02 09:29:27 -07:00
|
|
|
ret = NULL;
|
|
|
|
else
|
2015-10-20 03:10:38 -06:00
|
|
|
ret = list_entry(gdev->list.next, struct gpio_device, list);
|
2013-02-09 02:41:49 -07:00
|
|
|
spin_unlock_irqrestore(&gpio_lock, flags);
|
2012-04-12 05:26:01 -06:00
|
|
|
|
|
|
|
s->private = "\n";
|
|
|
|
++*pos;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void gpiolib_seq_stop(struct seq_file *s, void *v)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static int gpiolib_seq_show(struct seq_file *s, void *v)
|
|
|
|
{
|
2015-10-20 03:10:38 -06:00
|
|
|
struct gpio_device *gdev = v;
|
|
|
|
struct gpio_chip *chip = gdev->chip;
|
|
|
|
struct device *parent;
|
|
|
|
|
|
|
|
if (!chip) {
|
|
|
|
seq_printf(s, "%s%s: (dangling chip)", (char *)s->private,
|
|
|
|
dev_name(&gdev->dev));
|
|
|
|
return 0;
|
|
|
|
}
|
2012-04-12 05:26:01 -06:00
|
|
|
|
2015-10-20 03:10:38 -06:00
|
|
|
seq_printf(s, "%s%s: GPIOs %d-%d", (char *)s->private,
|
|
|
|
dev_name(&gdev->dev),
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
gdev->base, gdev->base + gdev->ngpio - 1);
|
2015-10-20 03:10:38 -06:00
|
|
|
parent = chip->parent;
|
|
|
|
if (parent)
|
|
|
|
seq_printf(s, ", parent: %s/%s",
|
|
|
|
parent->bus ? parent->bus->name : "no-bus",
|
|
|
|
dev_name(parent));
|
2012-04-12 05:26:01 -06:00
|
|
|
if (chip->label)
|
|
|
|
seq_printf(s, ", %s", chip->label);
|
|
|
|
if (chip->can_sleep)
|
|
|
|
seq_printf(s, ", can sleep");
|
|
|
|
seq_printf(s, ":\n");
|
|
|
|
|
|
|
|
if (chip->dbg_show)
|
|
|
|
chip->dbg_show(s, chip);
|
|
|
|
else
|
gpio: reflect base and ngpio into gpio_device
Some information about the GPIO chip need to stay around also
after the gpio_chip has been removed and only the gpio_device
persist. The base and ngpio are such things, for example we
don't want a new chip arriving to overlap the number space
of a dangling gpio_device, and the chardev may still query
the device for the number of lines etc.
Note that the code that assigns base and insert gpio_device
into the global list no longer check for a missing gpio_chip:
we respect the number space allocated by any other gpio_device.
As a consequence of the gdev being referenced directly from
the gpio_desc, we need to verify it differently from all
in-kernel API calls that fall through to direct queries to
the gpio_chip vtable: we first check that desc is !NULL, then
that desc->gdev is !NULL, then, if desc->gdev->chip is NULL,
we *BAIL OUT* without any error, so as to manage the case
where operations are requested on a device that is gone.
These checks were non-uniform and partly missing in the past:
so to simplify: create the macros VALIDATE_DESC() that will
return -EINVAL if the desc or desc->gdev is missing and just
0 if the chip is gone, and conversely VALIDATE_DESC_VOID()
for the case where the function does not return an error.
By using these macros, we get warning messages about missing
gdev with reference to the right function in the kernel log.
Despite the macro business this simplifies the code and make
it more readable than if we copy/paste the same descriptor
checking code into all code ABI call sites (IMHO).
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2016-02-10 02:57:36 -07:00
|
|
|
gpiolib_dbg_show(s, gdev);
|
2012-04-12 05:26:01 -06:00
|
|
|
|
2008-02-04 23:28:20 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-04-12 05:26:01 -06:00
|
|
|
static const struct seq_operations gpiolib_seq_ops = {
|
|
|
|
.start = gpiolib_seq_start,
|
|
|
|
.next = gpiolib_seq_next,
|
|
|
|
.stop = gpiolib_seq_stop,
|
|
|
|
.show = gpiolib_seq_show,
|
|
|
|
};
|
|
|
|
|
2008-02-04 23:28:20 -07:00
|
|
|
static int gpiolib_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
2012-04-12 05:26:01 -06:00
|
|
|
return seq_open(file, &gpiolib_seq_ops);
|
2008-02-04 23:28:20 -07:00
|
|
|
}
|
|
|
|
|
2009-10-01 16:43:56 -06:00
|
|
|
static const struct file_operations gpiolib_operations = {
|
2012-04-12 05:26:01 -06:00
|
|
|
.owner = THIS_MODULE,
|
2008-02-04 23:28:20 -07:00
|
|
|
.open = gpiolib_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
2012-04-12 05:26:01 -06:00
|
|
|
.release = seq_release,
|
2008-02-04 23:28:20 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
static int __init gpiolib_debugfs_init(void)
|
|
|
|
{
|
|
|
|
/* /sys/kernel/debug/gpio */
|
|
|
|
(void) debugfs_create_file("gpio", S_IFREG | S_IRUGO,
|
|
|
|
NULL, NULL, &gpiolib_operations);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
subsys_initcall(gpiolib_debugfs_init);
|
|
|
|
|
|
|
|
#endif /* DEBUG_FS */
|