cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

of_gpio.h (4170B)

      1/* SPDX-License-Identifier: GPL-2.0+ */
      2/*
      3 * OF helpers for the GPIO API
      4 *
      5 * Copyright (c) 2007-2008  MontaVista Software, Inc.
      6 *
      7 * Author: Anton Vorontsov <avorontsov@ru.mvista.com>
      8 */
      9
     10#ifndef __LINUX_OF_GPIO_H
     11#define __LINUX_OF_GPIO_H
     12
     13#include <linux/compiler.h>
     14#include <linux/gpio/driver.h>
     15#include <linux/gpio.h>		/* FIXME: Shouldn't be here */
     16#include <linux/of.h>
     17
     18struct device_node;
     19
     20/*
     21 * This is Linux-specific flags. By default controllers' and Linux' mapping
     22 * match, but GPIO controllers are free to translate their own flags to
     23 * Linux-specific in their .xlate callback. Though, 1:1 mapping is recommended.
     24 */
     25enum of_gpio_flags {
     26	OF_GPIO_ACTIVE_LOW = 0x1,
     27	OF_GPIO_SINGLE_ENDED = 0x2,
     28	OF_GPIO_OPEN_DRAIN = 0x4,
     29	OF_GPIO_TRANSITORY = 0x8,
     30	OF_GPIO_PULL_UP = 0x10,
     31	OF_GPIO_PULL_DOWN = 0x20,
     32};
     33
     34#ifdef CONFIG_OF_GPIO
     35
     36#include <linux/kernel.h>
     37
     38/*
     39 * OF GPIO chip for memory mapped banks
     40 */
     41struct of_mm_gpio_chip {
     42	struct gpio_chip gc;
     43	void (*save_regs)(struct of_mm_gpio_chip *mm_gc);
     44	void __iomem *regs;
     45};
     46
     47static inline struct of_mm_gpio_chip *to_of_mm_gpio_chip(struct gpio_chip *gc)
     48{
     49	return container_of(gc, struct of_mm_gpio_chip, gc);
     50}
     51
     52extern int of_get_named_gpio_flags(const struct device_node *np,
     53		const char *list_name, int index, enum of_gpio_flags *flags);
     54
     55extern int of_mm_gpiochip_add_data(struct device_node *np,
     56				   struct of_mm_gpio_chip *mm_gc,
     57				   void *data);
     58static inline int of_mm_gpiochip_add(struct device_node *np,
     59				     struct of_mm_gpio_chip *mm_gc)
     60{
     61	return of_mm_gpiochip_add_data(np, mm_gc, NULL);
     62}
     63extern void of_mm_gpiochip_remove(struct of_mm_gpio_chip *mm_gc);
     64
     65#else /* CONFIG_OF_GPIO */
     66
     67#include <linux/errno.h>
     68
     69/* Drivers may not strictly depend on the GPIO support, so let them link. */
     70static inline int of_get_named_gpio_flags(const struct device_node *np,
     71		const char *list_name, int index, enum of_gpio_flags *flags)
     72{
     73	if (flags)
     74		*flags = 0;
     75
     76	return -ENOSYS;
     77}
     78
     79#endif /* CONFIG_OF_GPIO */
     80
     81/**
     82 * of_gpio_named_count() - Count GPIOs for a device
     83 * @np:		device node to count GPIOs for
     84 * @propname:	property name containing gpio specifier(s)
     85 *
     86 * The function returns the count of GPIOs specified for a node.
     87 * Note that the empty GPIO specifiers count too. Returns either
     88 *   Number of gpios defined in property,
     89 *   -EINVAL for an incorrectly formed gpios property, or
     90 *   -ENOENT for a missing gpios property
     91 *
     92 * Example:
     93 * gpios = <0
     94 *          &gpio1 1 2
     95 *          0
     96 *          &gpio2 3 4>;
     97 *
     98 * The above example defines four GPIOs, two of which are not specified.
     99 * This function will return '4'
    100 */
    101static inline int of_gpio_named_count(const struct device_node *np,
    102				      const char *propname)
    103{
    104	return of_count_phandle_with_args(np, propname, "#gpio-cells");
    105}
    106
    107/**
    108 * of_gpio_count() - Count GPIOs for a device
    109 * @np:		device node to count GPIOs for
    110 *
    111 * Same as of_gpio_named_count, but hard coded to use the 'gpios' property
    112 */
    113static inline int of_gpio_count(const struct device_node *np)
    114{
    115	return of_gpio_named_count(np, "gpios");
    116}
    117
    118static inline int of_get_gpio_flags(const struct device_node *np, int index,
    119		      enum of_gpio_flags *flags)
    120{
    121	return of_get_named_gpio_flags(np, "gpios", index, flags);
    122}
    123
    124/**
    125 * of_get_named_gpio() - Get a GPIO number to use with GPIO API
    126 * @np:		device node to get GPIO from
    127 * @propname:	Name of property containing gpio specifier(s)
    128 * @index:	index of the GPIO
    129 *
    130 * Returns GPIO number to use with Linux generic GPIO API, or one of the errno
    131 * value on the error condition.
    132 */
    133static inline int of_get_named_gpio(const struct device_node *np,
    134                                   const char *propname, int index)
    135{
    136	return of_get_named_gpio_flags(np, propname, index, NULL);
    137}
    138
    139/**
    140 * of_get_gpio() - Get a GPIO number to use with GPIO API
    141 * @np:		device node to get GPIO from
    142 * @index:	index of the GPIO
    143 *
    144 * Returns GPIO number to use with Linux generic GPIO API, or one of the errno
    145 * value on the error condition.
    146 */
    147static inline int of_get_gpio(const struct device_node *np, int index)
    148{
    149	return of_get_gpio_flags(np, index, NULL);
    150}
    151
    152#endif /* __LINUX_OF_GPIO_H */