restore lost packages from 0.2.3 + fix overwritten 0.2.4 files
- Restore 29 recipe symlinks (libdrm, qtbase, dbus, sddm, pipewire, etc.) - Restore 33 patches (KDE, libdrm, mesa, pipewire, sddm, wireplumber) - Restore 20+ local/scripts (audit, lint, test, build helpers) - Restore src/cook/scheduler.rs, status.rs, gnu-config/ - Restore scripts/patch-inclusion-gate.sh, run_mini1.sh, validate-collision-log.sh - Recover TLC source from HEAD (was overwritten by 0.2.3 checkout) - Recover 11 local/docs plans from HEAD (were overwritten) - Recover qt6-wayland-smoke symlink from HEAD - Fix MOTD: remove garbled ASCII art, use clean text - Update version: 0.2.0 -> 0.2.4 in os-release, motd, config - Reduce filesystem_size: 1536 -> 512 MiB - Add ABSOLUTE RULE to AGENTS.md: never delete/ignore packages - Reduce pcid scheme log verbosity: info -> debug
This commit is contained in:
@@ -0,0 +1,239 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0-only */
|
||||
/*
|
||||
* Consumer interface the pin control subsystem
|
||||
*
|
||||
* Copyright (C) 2012 ST-Ericsson SA
|
||||
* Written on behalf of Linaro for ST-Ericsson
|
||||
* Based on bits of regulator core, gpio core and clk core
|
||||
*
|
||||
* Author: Linus Walleij <linus.walleij@linaro.org>
|
||||
*/
|
||||
#ifndef __LINUX_PINCTRL_CONSUMER_H
|
||||
#define __LINUX_PINCTRL_CONSUMER_H
|
||||
|
||||
#include <linux/err.h>
|
||||
#include <linux/types.h>
|
||||
|
||||
#include <linux/pinctrl/pinctrl-state.h>
|
||||
|
||||
struct device;
|
||||
struct gpio_chip;
|
||||
|
||||
/* This struct is private to the core and should be regarded as a cookie */
|
||||
struct pinctrl;
|
||||
struct pinctrl_state;
|
||||
|
||||
#ifdef CONFIG_PINCTRL
|
||||
|
||||
/* External interface to pin control */
|
||||
bool pinctrl_gpio_can_use_line(struct gpio_chip *gc, unsigned int offset);
|
||||
int pinctrl_gpio_request(struct gpio_chip *gc, unsigned int offset);
|
||||
void pinctrl_gpio_free(struct gpio_chip *gc, unsigned int offset);
|
||||
int pinctrl_gpio_direction_input(struct gpio_chip *gc,
|
||||
unsigned int offset);
|
||||
int pinctrl_gpio_direction_output(struct gpio_chip *gc,
|
||||
unsigned int offset);
|
||||
int pinctrl_gpio_set_config(struct gpio_chip *gc, unsigned int offset,
|
||||
unsigned long config);
|
||||
int pinctrl_gpio_get_config(struct gpio_chip *gc, unsigned int offset,
|
||||
unsigned long *config);
|
||||
|
||||
struct pinctrl * __must_check pinctrl_get(struct device *dev);
|
||||
void pinctrl_put(struct pinctrl *p);
|
||||
struct pinctrl_state * __must_check pinctrl_lookup_state(struct pinctrl *p,
|
||||
const char *name);
|
||||
int pinctrl_select_state(struct pinctrl *p, struct pinctrl_state *s);
|
||||
|
||||
struct pinctrl * __must_check devm_pinctrl_get(struct device *dev);
|
||||
void devm_pinctrl_put(struct pinctrl *p);
|
||||
int pinctrl_select_default_state(struct device *dev);
|
||||
|
||||
#ifdef CONFIG_PM
|
||||
int pinctrl_pm_select_default_state(struct device *dev);
|
||||
int pinctrl_pm_select_init_state(struct device *dev);
|
||||
int pinctrl_pm_select_sleep_state(struct device *dev);
|
||||
int pinctrl_pm_select_idle_state(struct device *dev);
|
||||
#else
|
||||
static inline int pinctrl_pm_select_default_state(struct device *dev)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
static inline int pinctrl_pm_select_init_state(struct device *dev)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
static inline int pinctrl_pm_select_sleep_state(struct device *dev)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
static inline int pinctrl_pm_select_idle_state(struct device *dev)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
#else /* !CONFIG_PINCTRL */
|
||||
|
||||
static inline bool
|
||||
pinctrl_gpio_can_use_line(struct gpio_chip *gc, unsigned int offset)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
static inline int
|
||||
pinctrl_gpio_request(struct gpio_chip *gc, unsigned int offset)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline void
|
||||
pinctrl_gpio_free(struct gpio_chip *gc, unsigned int offset)
|
||||
{
|
||||
}
|
||||
|
||||
static inline int
|
||||
pinctrl_gpio_direction_input(struct gpio_chip *gc, unsigned int offset)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int
|
||||
pinctrl_gpio_direction_output(struct gpio_chip *gc, unsigned int offset)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int
|
||||
pinctrl_gpio_get_config(struct gpio_chip *gc, unsigned int offset,
|
||||
unsigned long *config)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int
|
||||
pinctrl_gpio_set_config(struct gpio_chip *gc, unsigned int offset,
|
||||
unsigned long config)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline struct pinctrl * __must_check pinctrl_get(struct device *dev)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static inline void pinctrl_put(struct pinctrl *p)
|
||||
{
|
||||
}
|
||||
|
||||
static inline struct pinctrl_state * __must_check pinctrl_lookup_state(struct pinctrl *p,
|
||||
const char *name)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static inline int pinctrl_select_state(struct pinctrl *p,
|
||||
struct pinctrl_state *s)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline struct pinctrl * __must_check devm_pinctrl_get(struct device *dev)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static inline void devm_pinctrl_put(struct pinctrl *p)
|
||||
{
|
||||
}
|
||||
|
||||
static inline int pinctrl_select_default_state(struct device *dev)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int pinctrl_pm_select_default_state(struct device *dev)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int pinctrl_pm_select_init_state(struct device *dev)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int pinctrl_pm_select_sleep_state(struct device *dev)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int pinctrl_pm_select_idle_state(struct device *dev)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif /* CONFIG_PINCTRL */
|
||||
|
||||
static inline struct pinctrl * __must_check pinctrl_get_select(struct device *dev,
|
||||
const char *name)
|
||||
{
|
||||
struct pinctrl *p;
|
||||
struct pinctrl_state *s;
|
||||
int ret;
|
||||
|
||||
p = pinctrl_get(dev);
|
||||
if (IS_ERR(p))
|
||||
return p;
|
||||
|
||||
s = pinctrl_lookup_state(p, name);
|
||||
if (IS_ERR(s)) {
|
||||
pinctrl_put(p);
|
||||
return ERR_CAST(s);
|
||||
}
|
||||
|
||||
ret = pinctrl_select_state(p, s);
|
||||
if (ret < 0) {
|
||||
pinctrl_put(p);
|
||||
return ERR_PTR(ret);
|
||||
}
|
||||
|
||||
return p;
|
||||
}
|
||||
|
||||
static inline struct pinctrl * __must_check pinctrl_get_select_default(struct device *dev)
|
||||
{
|
||||
return pinctrl_get_select(dev, PINCTRL_STATE_DEFAULT);
|
||||
}
|
||||
|
||||
static inline struct pinctrl * __must_check devm_pinctrl_get_select(struct device *dev,
|
||||
const char *name)
|
||||
{
|
||||
struct pinctrl *p;
|
||||
struct pinctrl_state *s;
|
||||
int ret;
|
||||
|
||||
p = devm_pinctrl_get(dev);
|
||||
if (IS_ERR(p))
|
||||
return p;
|
||||
|
||||
s = pinctrl_lookup_state(p, name);
|
||||
if (IS_ERR(s)) {
|
||||
devm_pinctrl_put(p);
|
||||
return ERR_CAST(s);
|
||||
}
|
||||
|
||||
ret = pinctrl_select_state(p, s);
|
||||
if (ret < 0) {
|
||||
devm_pinctrl_put(p);
|
||||
return ERR_PTR(ret);
|
||||
}
|
||||
|
||||
return p;
|
||||
}
|
||||
|
||||
static inline struct pinctrl * __must_check devm_pinctrl_get_select_default(struct device *dev)
|
||||
{
|
||||
return devm_pinctrl_get_select(dev, PINCTRL_STATE_DEFAULT);
|
||||
}
|
||||
|
||||
#endif /* __LINUX_PINCTRL_CONSUMER_H */
|
||||
@@ -0,0 +1,71 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0-only */
|
||||
/*
|
||||
* Per-device information from the pin control system.
|
||||
* This is the stuff that get included into the device
|
||||
* core.
|
||||
*
|
||||
* Copyright (C) 2012 ST-Ericsson SA
|
||||
* Written on behalf of Linaro for ST-Ericsson
|
||||
* This interface is used in the core to keep track of pins.
|
||||
*
|
||||
* Author: Linus Walleij <linus.walleij@linaro.org>
|
||||
*/
|
||||
|
||||
#ifndef PINCTRL_DEVINFO_H
|
||||
#define PINCTRL_DEVINFO_H
|
||||
|
||||
struct device;
|
||||
|
||||
#ifdef CONFIG_PINCTRL
|
||||
|
||||
#include <linux/device.h>
|
||||
|
||||
/* The device core acts as a consumer toward pinctrl */
|
||||
#include <linux/pinctrl/consumer.h>
|
||||
|
||||
struct pinctrl;
|
||||
|
||||
/**
|
||||
* struct dev_pin_info - pin state container for devices
|
||||
* @p: pinctrl handle for the containing device
|
||||
* @default_state: the default state for the handle, if found
|
||||
* @init_state: the state at probe time, if found
|
||||
* @sleep_state: the state at suspend time, if found
|
||||
* @idle_state: the state at idle (runtime suspend) time, if found
|
||||
*/
|
||||
struct dev_pin_info {
|
||||
struct pinctrl *p;
|
||||
struct pinctrl_state *default_state;
|
||||
struct pinctrl_state *init_state;
|
||||
#ifdef CONFIG_PM
|
||||
struct pinctrl_state *sleep_state;
|
||||
struct pinctrl_state *idle_state;
|
||||
#endif
|
||||
};
|
||||
|
||||
extern int pinctrl_init_done(struct device *dev);
|
||||
|
||||
static inline struct pinctrl *dev_pinctrl(struct device *dev)
|
||||
{
|
||||
if (!dev->pins)
|
||||
return NULL;
|
||||
|
||||
return dev->pins->p;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
/* Stubs if we're not using pinctrl */
|
||||
|
||||
static inline int pinctrl_init_done(struct device *dev)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline struct pinctrl *dev_pinctrl(struct device *dev)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
#endif /* CONFIG_PINCTRL */
|
||||
#endif /* PINCTRL_DEVINFO_H */
|
||||
@@ -0,0 +1,187 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0-only */
|
||||
/*
|
||||
* Machine interface for the pinctrl subsystem.
|
||||
*
|
||||
* Copyright (C) 2011 ST-Ericsson SA
|
||||
* Written on behalf of Linaro for ST-Ericsson
|
||||
* Based on bits of regulator core, gpio core and clk core
|
||||
*
|
||||
* Author: Linus Walleij <linus.walleij@linaro.org>
|
||||
*/
|
||||
#ifndef __LINUX_PINCTRL_MACHINE_H
|
||||
#define __LINUX_PINCTRL_MACHINE_H
|
||||
|
||||
#include <linux/array_size.h>
|
||||
|
||||
#include <linux/pinctrl/pinctrl-state.h>
|
||||
|
||||
enum pinctrl_map_type {
|
||||
PIN_MAP_TYPE_INVALID,
|
||||
PIN_MAP_TYPE_DUMMY_STATE,
|
||||
PIN_MAP_TYPE_MUX_GROUP,
|
||||
PIN_MAP_TYPE_CONFIGS_PIN,
|
||||
PIN_MAP_TYPE_CONFIGS_GROUP,
|
||||
};
|
||||
|
||||
/**
|
||||
* struct pinctrl_map_mux - mapping table content for MAP_TYPE_MUX_GROUP
|
||||
* @group: the name of the group whose mux function is to be configured. This
|
||||
* field may be left NULL, and the first applicable group for the function
|
||||
* will be used.
|
||||
* @function: the mux function to select for the group
|
||||
*/
|
||||
struct pinctrl_map_mux {
|
||||
const char *group;
|
||||
const char *function;
|
||||
};
|
||||
|
||||
/**
|
||||
* struct pinctrl_map_configs - mapping table content for MAP_TYPE_CONFIGS_*
|
||||
* @group_or_pin: the name of the pin or group whose configuration parameters
|
||||
* are to be configured.
|
||||
* @configs: a pointer to an array of config parameters/values to program into
|
||||
* hardware. Each individual pin controller defines the format and meaning
|
||||
* of config parameters.
|
||||
* @num_configs: the number of entries in array @configs
|
||||
*/
|
||||
struct pinctrl_map_configs {
|
||||
const char *group_or_pin;
|
||||
unsigned long *configs;
|
||||
unsigned int num_configs;
|
||||
};
|
||||
|
||||
/**
|
||||
* struct pinctrl_map - boards/machines shall provide this map for devices
|
||||
* @dev_name: the name of the device using this specific mapping, the name
|
||||
* must be the same as in your struct device*. If this name is set to the
|
||||
* same name as the pin controllers own dev_name(), the map entry will be
|
||||
* hogged by the driver itself upon registration
|
||||
* @name: the name of this specific map entry for the particular machine.
|
||||
* This is the parameter passed to pinmux_lookup_state()
|
||||
* @type: the type of mapping table entry
|
||||
* @ctrl_dev_name: the name of the device controlling this specific mapping,
|
||||
* the name must be the same as in your struct device*. This field is not
|
||||
* used for PIN_MAP_TYPE_DUMMY_STATE
|
||||
* @data: Data specific to the mapping type
|
||||
*/
|
||||
struct pinctrl_map {
|
||||
const char *dev_name;
|
||||
const char *name;
|
||||
enum pinctrl_map_type type;
|
||||
const char *ctrl_dev_name;
|
||||
union {
|
||||
struct pinctrl_map_mux mux;
|
||||
struct pinctrl_map_configs configs;
|
||||
} data;
|
||||
};
|
||||
|
||||
/* Convenience macros to create mapping table entries */
|
||||
|
||||
#define PIN_MAP_DUMMY_STATE(dev, state) \
|
||||
{ \
|
||||
.dev_name = dev, \
|
||||
.name = state, \
|
||||
.type = PIN_MAP_TYPE_DUMMY_STATE, \
|
||||
}
|
||||
|
||||
#define PIN_MAP_MUX_GROUP(dev, state, pinctrl, grp, func) \
|
||||
{ \
|
||||
.dev_name = dev, \
|
||||
.name = state, \
|
||||
.type = PIN_MAP_TYPE_MUX_GROUP, \
|
||||
.ctrl_dev_name = pinctrl, \
|
||||
.data.mux = { \
|
||||
.group = grp, \
|
||||
.function = func, \
|
||||
}, \
|
||||
}
|
||||
|
||||
#define PIN_MAP_MUX_GROUP_DEFAULT(dev, pinctrl, grp, func) \
|
||||
PIN_MAP_MUX_GROUP(dev, PINCTRL_STATE_DEFAULT, pinctrl, grp, func)
|
||||
|
||||
#define PIN_MAP_MUX_GROUP_HOG(dev, state, grp, func) \
|
||||
PIN_MAP_MUX_GROUP(dev, state, dev, grp, func)
|
||||
|
||||
#define PIN_MAP_MUX_GROUP_HOG_DEFAULT(dev, grp, func) \
|
||||
PIN_MAP_MUX_GROUP(dev, PINCTRL_STATE_DEFAULT, dev, grp, func)
|
||||
|
||||
#define PIN_MAP_CONFIGS_PIN(dev, state, pinctrl, pin, cfgs) \
|
||||
{ \
|
||||
.dev_name = dev, \
|
||||
.name = state, \
|
||||
.type = PIN_MAP_TYPE_CONFIGS_PIN, \
|
||||
.ctrl_dev_name = pinctrl, \
|
||||
.data.configs = { \
|
||||
.group_or_pin = pin, \
|
||||
.configs = cfgs, \
|
||||
.num_configs = ARRAY_SIZE(cfgs), \
|
||||
}, \
|
||||
}
|
||||
|
||||
#define PIN_MAP_CONFIGS_PIN_DEFAULT(dev, pinctrl, pin, cfgs) \
|
||||
PIN_MAP_CONFIGS_PIN(dev, PINCTRL_STATE_DEFAULT, pinctrl, pin, cfgs)
|
||||
|
||||
#define PIN_MAP_CONFIGS_PIN_HOG(dev, state, pin, cfgs) \
|
||||
PIN_MAP_CONFIGS_PIN(dev, state, dev, pin, cfgs)
|
||||
|
||||
#define PIN_MAP_CONFIGS_PIN_HOG_DEFAULT(dev, pin, cfgs) \
|
||||
PIN_MAP_CONFIGS_PIN(dev, PINCTRL_STATE_DEFAULT, dev, pin, cfgs)
|
||||
|
||||
#define PIN_MAP_CONFIGS_GROUP(dev, state, pinctrl, grp, cfgs) \
|
||||
{ \
|
||||
.dev_name = dev, \
|
||||
.name = state, \
|
||||
.type = PIN_MAP_TYPE_CONFIGS_GROUP, \
|
||||
.ctrl_dev_name = pinctrl, \
|
||||
.data.configs = { \
|
||||
.group_or_pin = grp, \
|
||||
.configs = cfgs, \
|
||||
.num_configs = ARRAY_SIZE(cfgs), \
|
||||
}, \
|
||||
}
|
||||
|
||||
#define PIN_MAP_CONFIGS_GROUP_DEFAULT(dev, pinctrl, grp, cfgs) \
|
||||
PIN_MAP_CONFIGS_GROUP(dev, PINCTRL_STATE_DEFAULT, pinctrl, grp, cfgs)
|
||||
|
||||
#define PIN_MAP_CONFIGS_GROUP_HOG(dev, state, grp, cfgs) \
|
||||
PIN_MAP_CONFIGS_GROUP(dev, state, dev, grp, cfgs)
|
||||
|
||||
#define PIN_MAP_CONFIGS_GROUP_HOG_DEFAULT(dev, grp, cfgs) \
|
||||
PIN_MAP_CONFIGS_GROUP(dev, PINCTRL_STATE_DEFAULT, dev, grp, cfgs)
|
||||
|
||||
struct device;
|
||||
struct pinctrl_map;
|
||||
|
||||
#ifdef CONFIG_PINCTRL
|
||||
|
||||
int pinctrl_register_mappings(const struct pinctrl_map *map,
|
||||
unsigned int num_maps);
|
||||
int devm_pinctrl_register_mappings(struct device *dev,
|
||||
const struct pinctrl_map *map,
|
||||
unsigned int num_maps);
|
||||
void pinctrl_unregister_mappings(const struct pinctrl_map *map);
|
||||
void pinctrl_provide_dummies(void);
|
||||
#else
|
||||
|
||||
static inline int pinctrl_register_mappings(const struct pinctrl_map *map,
|
||||
unsigned int num_maps)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int devm_pinctrl_register_mappings(struct device *dev,
|
||||
const struct pinctrl_map *map,
|
||||
unsigned int num_maps)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline void pinctrl_unregister_mappings(const struct pinctrl_map *map)
|
||||
{
|
||||
}
|
||||
|
||||
static inline void pinctrl_provide_dummies(void)
|
||||
{
|
||||
}
|
||||
#endif /* !CONFIG_PINCTRL */
|
||||
#endif
|
||||
@@ -0,0 +1,256 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0-only */
|
||||
/*
|
||||
* Interface the generic pinconfig portions of the pinctrl subsystem
|
||||
*
|
||||
* Copyright (C) 2011 ST-Ericsson SA
|
||||
* Written on behalf of Linaro for ST-Ericsson
|
||||
* This interface is used in the core to keep track of pins.
|
||||
*
|
||||
* Author: Linus Walleij <linus.walleij@linaro.org>
|
||||
*/
|
||||
#ifndef __LINUX_PINCTRL_PINCONF_GENERIC_H
|
||||
#define __LINUX_PINCTRL_PINCONF_GENERIC_H
|
||||
|
||||
#include <linux/types.h>
|
||||
|
||||
#include <linux/pinctrl/machine.h>
|
||||
|
||||
struct device_node;
|
||||
|
||||
struct pinctrl_dev;
|
||||
struct pinctrl_map;
|
||||
|
||||
/**
|
||||
* enum pin_config_param - possible pin configuration parameters
|
||||
* @PIN_CONFIG_BIAS_BUS_HOLD: the pin will be set to weakly latch so that it
|
||||
* weakly drives the last value on a tristate bus, also known as a "bus
|
||||
* holder", "bus keeper" or "repeater". This allows another device on the
|
||||
* bus to change the value by driving the bus high or low and switching to
|
||||
* tristate. The argument is ignored.
|
||||
* @PIN_CONFIG_BIAS_DISABLE: disable any pin bias on the pin, a
|
||||
* transition from say pull-up to pull-down implies that you disable
|
||||
* pull-up in the process, this setting disables all biasing.
|
||||
* @PIN_CONFIG_BIAS_HIGH_IMPEDANCE: the pin will be set to a high impedance
|
||||
* mode, also know as "third-state" (tristate) or "high-Z" or "floating".
|
||||
* On output pins this effectively disconnects the pin, which is useful
|
||||
* if for example some other pin is going to drive the signal connected
|
||||
* to it for a while. Pins used for input are usually always high
|
||||
* impedance.
|
||||
* @PIN_CONFIG_BIAS_PULL_DOWN: the pin will be pulled down (usually with high
|
||||
* impedance to GROUND). If the argument is != 0 pull-down is enabled,
|
||||
* the value is interpreted by the driver and can be custom or an SI unit
|
||||
* such as Ohms.
|
||||
* @PIN_CONFIG_BIAS_PULL_PIN_DEFAULT: the pin will be pulled up or down based
|
||||
* on embedded knowledge of the controller hardware, like current mux
|
||||
* function. The pull direction and possibly strength too will normally
|
||||
* be decided completely inside the hardware block and not be readable
|
||||
* from the kernel side.
|
||||
* If the argument is != 0 pull up/down is enabled, if it is 0, the
|
||||
* configuration is ignored. The proper way to disable it is to use
|
||||
* @PIN_CONFIG_BIAS_DISABLE.
|
||||
* @PIN_CONFIG_BIAS_PULL_UP: the pin will be pulled up (usually with high
|
||||
* impedance to VDD). If the argument is != 0 pull-up is enabled,
|
||||
* the value is interpreted by the driver and can be custom or an SI unit
|
||||
* such as Ohms.
|
||||
* @PIN_CONFIG_DRIVE_OPEN_DRAIN: the pin will be driven with open drain (open
|
||||
* collector) which means it is usually wired with other output ports
|
||||
* which are then pulled up with an external resistor. Setting this
|
||||
* config will enable open drain mode, the argument is ignored.
|
||||
* @PIN_CONFIG_DRIVE_OPEN_SOURCE: the pin will be driven with open source
|
||||
* (open emitter). Setting this config will enable open source mode, the
|
||||
* argument is ignored.
|
||||
* @PIN_CONFIG_DRIVE_PUSH_PULL: the pin will be driven actively high and
|
||||
* low, this is the most typical case and is typically achieved with two
|
||||
* active transistors on the output. Setting this config will enable
|
||||
* push-pull mode, the argument is ignored.
|
||||
* @PIN_CONFIG_DRIVE_STRENGTH: the pin will sink or source at most the current
|
||||
* passed as argument. The argument is in mA.
|
||||
* @PIN_CONFIG_DRIVE_STRENGTH_UA: the pin will sink or source at most the current
|
||||
* passed as argument. The argument is in uA.
|
||||
* @PIN_CONFIG_INPUT_DEBOUNCE: this will configure the pin to debounce mode,
|
||||
* which means it will wait for signals to settle when reading inputs. The
|
||||
* argument gives the debounce time in usecs. Setting the
|
||||
* argument to zero turns debouncing off.
|
||||
* @PIN_CONFIG_INPUT_ENABLE: enable the pin's input. Note that this does not
|
||||
* affect the pin's ability to drive output. 1 enables input, 0 disables
|
||||
* input.
|
||||
* @PIN_CONFIG_INPUT_SCHMITT: this will configure an input pin to run in
|
||||
* schmitt-trigger mode. If the schmitt-trigger has adjustable hysteresis,
|
||||
* the threshold value is given on a custom format as argument when
|
||||
* setting pins to this mode.
|
||||
* @PIN_CONFIG_INPUT_SCHMITT_ENABLE: control schmitt-trigger mode on the pin.
|
||||
* If the argument != 0, schmitt-trigger mode is enabled. If it's 0,
|
||||
* schmitt-trigger mode is disabled.
|
||||
* @PIN_CONFIG_INPUT_SCHMITT_UV: this will configure an input pin to run in
|
||||
* schmitt-trigger mode. The argument is in uV.
|
||||
* @PIN_CONFIG_INPUT_VOLTAGE_UV: this will configure the input voltage level of
|
||||
* the pin. The argument is specified in microvolts.
|
||||
* @PIN_CONFIG_MODE_LOW_POWER: this will configure the pin for low power
|
||||
* operation, if several modes of operation are supported these can be
|
||||
* passed in the argument on a custom form, else just use argument 1
|
||||
* to indicate low power mode, argument 0 turns low power mode off.
|
||||
* @PIN_CONFIG_MODE_PWM: this will configure the pin for PWM
|
||||
* @PIN_CONFIG_LEVEL: setting this will configure the pin as an output and
|
||||
* drive a value on the line. Use argument 1 to indicate high level,
|
||||
* argument 0 to indicate low level. Conversely the value of the line
|
||||
* can be read using this parameter, if and only if that value can be
|
||||
* represented as a binary 0 or 1 where 0 indicate a low voltage level
|
||||
* and 1 indicate a high voltage level.
|
||||
* (Please see Documentation/driver-api/pin-control.rst,
|
||||
* section "GPIO mode pitfalls" for a discussion around this parameter.)
|
||||
* @PIN_CONFIG_OUTPUT_ENABLE: this will enable the pin's output mode
|
||||
* without driving a value there. For most platforms this reduces to
|
||||
* enable the output buffers and then let the pin controller current
|
||||
* configuration (eg. the currently selected mux function) drive values on
|
||||
* the line. Use argument 1 to enable output mode, argument 0 to disable
|
||||
* it.
|
||||
* @PIN_CONFIG_OUTPUT_IMPEDANCE_OHMS: this will configure the output impedance
|
||||
* of the pin with the value passed as argument. The argument is in ohms.
|
||||
* @PIN_CONFIG_PERSIST_STATE: retain pin state across sleep or controller reset
|
||||
* @PIN_CONFIG_POWER_SOURCE: if the pin can select between different power
|
||||
* supplies, the argument to this parameter (on a custom format) tells
|
||||
* the driver which alternative power source to use.
|
||||
* @PIN_CONFIG_SKEW_DELAY: if the pin has programmable skew rate (on inputs)
|
||||
* or latch delay (on outputs) this parameter (in a custom format)
|
||||
* specifies the clock skew or latch delay. It typically controls how
|
||||
* many double inverters are put in front of the line.
|
||||
* @PIN_CONFIG_SKEW_DELAY_INPUT_PS: if the pin has independent values for the
|
||||
* programmable skew rate (on inputs) and latch delay (on outputs), then
|
||||
* this parameter specifies the clock skew only. The argument is in ps.
|
||||
* @PIN_CONFIG_SKEW_DELAY_OUTPUT_PS: if the pin has independent values for the
|
||||
* programmable skew rate (on inputs) and latch delay (on outputs), then
|
||||
* this parameter specifies the latch delay only. The argument is in ps.
|
||||
* @PIN_CONFIG_SLEEP_HARDWARE_STATE: indicate this is sleep related state.
|
||||
* @PIN_CONFIG_SLEW_RATE: if the pin can select slew rate, the argument to
|
||||
* this parameter (on a custom format) tells the driver which alternative
|
||||
* slew rate to use.
|
||||
* @PIN_CONFIG_END: this is the last enumerator for pin configurations, if
|
||||
* you need to pass in custom configurations to the pin controller, use
|
||||
* PIN_CONFIG_END+1 as the base offset.
|
||||
* @PIN_CONFIG_MAX: this is the maximum configuration value that can be
|
||||
* presented using the packed format.
|
||||
*/
|
||||
enum pin_config_param {
|
||||
PIN_CONFIG_BIAS_BUS_HOLD,
|
||||
PIN_CONFIG_BIAS_DISABLE,
|
||||
PIN_CONFIG_BIAS_HIGH_IMPEDANCE,
|
||||
PIN_CONFIG_BIAS_PULL_DOWN,
|
||||
PIN_CONFIG_BIAS_PULL_PIN_DEFAULT,
|
||||
PIN_CONFIG_BIAS_PULL_UP,
|
||||
PIN_CONFIG_DRIVE_OPEN_DRAIN,
|
||||
PIN_CONFIG_DRIVE_OPEN_SOURCE,
|
||||
PIN_CONFIG_DRIVE_PUSH_PULL,
|
||||
PIN_CONFIG_DRIVE_STRENGTH,
|
||||
PIN_CONFIG_DRIVE_STRENGTH_UA,
|
||||
PIN_CONFIG_INPUT_DEBOUNCE,
|
||||
PIN_CONFIG_INPUT_ENABLE,
|
||||
PIN_CONFIG_INPUT_SCHMITT,
|
||||
PIN_CONFIG_INPUT_SCHMITT_ENABLE,
|
||||
PIN_CONFIG_INPUT_SCHMITT_UV,
|
||||
PIN_CONFIG_INPUT_VOLTAGE_UV,
|
||||
PIN_CONFIG_MODE_LOW_POWER,
|
||||
PIN_CONFIG_MODE_PWM,
|
||||
PIN_CONFIG_LEVEL,
|
||||
PIN_CONFIG_OUTPUT_ENABLE,
|
||||
PIN_CONFIG_OUTPUT_IMPEDANCE_OHMS,
|
||||
PIN_CONFIG_PERSIST_STATE,
|
||||
PIN_CONFIG_POWER_SOURCE,
|
||||
PIN_CONFIG_SKEW_DELAY,
|
||||
PIN_CONFIG_SKEW_DELAY_INPUT_PS,
|
||||
PIN_CONFIG_SKEW_DELAY_OUTPUT_PS,
|
||||
PIN_CONFIG_SLEEP_HARDWARE_STATE,
|
||||
PIN_CONFIG_SLEW_RATE,
|
||||
PIN_CONFIG_END = 0x7F,
|
||||
PIN_CONFIG_MAX = 0xFF,
|
||||
};
|
||||
|
||||
/*
|
||||
* Helpful configuration macro to be used in tables etc.
|
||||
*/
|
||||
#define PIN_CONF_PACKED(p, a) ((a << 8) | ((unsigned long) p & 0xffUL))
|
||||
|
||||
/*
|
||||
* The following inlines stuffs a configuration parameter and data value
|
||||
* into and out of an unsigned long argument, as used by the generic pin config
|
||||
* system. We put the parameter in the lower 8 bits and the argument in the
|
||||
* upper 24 bits.
|
||||
*/
|
||||
|
||||
static inline enum pin_config_param pinconf_to_config_param(unsigned long config)
|
||||
{
|
||||
return (enum pin_config_param) (config & 0xffUL);
|
||||
}
|
||||
|
||||
static inline u32 pinconf_to_config_argument(unsigned long config)
|
||||
{
|
||||
return (u32) ((config >> 8) & 0xffffffUL);
|
||||
}
|
||||
|
||||
static inline unsigned long pinconf_to_config_packed(enum pin_config_param param,
|
||||
u32 argument)
|
||||
{
|
||||
return PIN_CONF_PACKED(param, argument);
|
||||
}
|
||||
|
||||
#define PCONFDUMP_WITH_VALUES(a, b, c, d, e, f) { \
|
||||
.param = a, .display = b, .format = c, .has_arg = d, \
|
||||
.values = e, .num_values = f \
|
||||
}
|
||||
|
||||
#define PCONFDUMP(a, b, c, d) PCONFDUMP_WITH_VALUES(a, b, c, d, NULL, 0)
|
||||
|
||||
struct pin_config_item {
|
||||
const enum pin_config_param param;
|
||||
const char * const display;
|
||||
const char * const format;
|
||||
bool has_arg;
|
||||
const char * const *values;
|
||||
size_t num_values;
|
||||
};
|
||||
|
||||
struct pinconf_generic_params {
|
||||
const char * const property;
|
||||
enum pin_config_param param;
|
||||
u32 default_value;
|
||||
const char * const *values;
|
||||
size_t num_values;
|
||||
};
|
||||
|
||||
int pinconf_generic_dt_subnode_to_map(struct pinctrl_dev *pctldev,
|
||||
struct device_node *np, struct pinctrl_map **map,
|
||||
unsigned int *reserved_maps, unsigned int *num_maps,
|
||||
enum pinctrl_map_type type);
|
||||
int pinconf_generic_dt_node_to_map(struct pinctrl_dev *pctldev,
|
||||
struct device_node *np_config, struct pinctrl_map **map,
|
||||
unsigned int *num_maps, enum pinctrl_map_type type);
|
||||
void pinconf_generic_dt_free_map(struct pinctrl_dev *pctldev,
|
||||
struct pinctrl_map *map, unsigned int num_maps);
|
||||
|
||||
static inline int pinconf_generic_dt_node_to_map_group(struct pinctrl_dev *pctldev,
|
||||
struct device_node *np_config, struct pinctrl_map **map,
|
||||
unsigned int *num_maps)
|
||||
{
|
||||
return pinconf_generic_dt_node_to_map(pctldev, np_config, map, num_maps,
|
||||
PIN_MAP_TYPE_CONFIGS_GROUP);
|
||||
}
|
||||
|
||||
static inline int pinconf_generic_dt_node_to_map_pin(struct pinctrl_dev *pctldev,
|
||||
struct device_node *np_config, struct pinctrl_map **map,
|
||||
unsigned int *num_maps)
|
||||
{
|
||||
return pinconf_generic_dt_node_to_map(pctldev, np_config, map, num_maps,
|
||||
PIN_MAP_TYPE_CONFIGS_PIN);
|
||||
}
|
||||
|
||||
static inline int pinconf_generic_dt_node_to_map_all(struct pinctrl_dev *pctldev,
|
||||
struct device_node *np_config, struct pinctrl_map **map,
|
||||
unsigned *num_maps)
|
||||
{
|
||||
/*
|
||||
* passing the type as PIN_MAP_TYPE_INVALID causes the underlying parser
|
||||
* to infer the map type from the DT properties used.
|
||||
*/
|
||||
return pinconf_generic_dt_node_to_map(pctldev, np_config, map, num_maps,
|
||||
PIN_MAP_TYPE_INVALID);
|
||||
}
|
||||
#endif /* __LINUX_PINCTRL_PINCONF_GENERIC_H */
|
||||
@@ -0,0 +1,67 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0-only */
|
||||
/*
|
||||
* Interface the pinconfig portions of the pinctrl subsystem
|
||||
*
|
||||
* Copyright (C) 2011 ST-Ericsson SA
|
||||
* Written on behalf of Linaro for ST-Ericsson
|
||||
* This interface is used in the core to keep track of pins.
|
||||
*
|
||||
* Author: Linus Walleij <linus.walleij@linaro.org>
|
||||
*/
|
||||
#ifndef __LINUX_PINCTRL_PINCONF_H
|
||||
#define __LINUX_PINCTRL_PINCONF_H
|
||||
|
||||
#include <linux/types.h>
|
||||
|
||||
struct pinctrl_dev;
|
||||
struct seq_file;
|
||||
|
||||
/**
|
||||
* struct pinconf_ops - pin config operations, to be implemented by
|
||||
* pin configuration capable drivers.
|
||||
* @is_generic: for pin controllers that want to use the generic interface,
|
||||
* this flag tells the framework that it's generic.
|
||||
* @pin_config_get: get the config of a certain pin, if the requested config
|
||||
* is not available on this controller this should return -ENOTSUPP
|
||||
* and if it is available but disabled it should return -EINVAL
|
||||
* @pin_config_set: configure an individual pin
|
||||
* @pin_config_group_get: get configurations for an entire pin group; should
|
||||
* return -ENOTSUPP and -EINVAL using the same rules as pin_config_get.
|
||||
* @pin_config_group_set: configure all pins in a group
|
||||
* @pin_config_dbg_show: optional debugfs display hook that will provide
|
||||
* per-device info for a certain pin in debugfs
|
||||
* @pin_config_group_dbg_show: optional debugfs display hook that will provide
|
||||
* per-device info for a certain group in debugfs
|
||||
* @pin_config_config_dbg_show: optional debugfs display hook that will decode
|
||||
* and display a driver's pin configuration parameter
|
||||
*/
|
||||
struct pinconf_ops {
|
||||
#ifdef CONFIG_GENERIC_PINCONF
|
||||
bool is_generic;
|
||||
#endif
|
||||
int (*pin_config_get) (struct pinctrl_dev *pctldev,
|
||||
unsigned int pin,
|
||||
unsigned long *config);
|
||||
int (*pin_config_set) (struct pinctrl_dev *pctldev,
|
||||
unsigned int pin,
|
||||
unsigned long *configs,
|
||||
unsigned int num_configs);
|
||||
int (*pin_config_group_get) (struct pinctrl_dev *pctldev,
|
||||
unsigned int selector,
|
||||
unsigned long *config);
|
||||
int (*pin_config_group_set) (struct pinctrl_dev *pctldev,
|
||||
unsigned int selector,
|
||||
unsigned long *configs,
|
||||
unsigned int num_configs);
|
||||
void (*pin_config_dbg_show) (struct pinctrl_dev *pctldev,
|
||||
struct seq_file *s,
|
||||
unsigned int offset);
|
||||
void (*pin_config_group_dbg_show) (struct pinctrl_dev *pctldev,
|
||||
struct seq_file *s,
|
||||
unsigned int selector);
|
||||
void (*pin_config_config_dbg_show) (struct pinctrl_dev *pctldev,
|
||||
struct seq_file *s,
|
||||
unsigned long config);
|
||||
};
|
||||
|
||||
#endif /* __LINUX_PINCTRL_PINCONF_H */
|
||||
@@ -0,0 +1,38 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0 */
|
||||
/*
|
||||
* Standard pin control state definitions
|
||||
*/
|
||||
|
||||
#ifndef __LINUX_PINCTRL_PINCTRL_STATE_H
|
||||
#define __LINUX_PINCTRL_PINCTRL_STATE_H
|
||||
|
||||
/**
|
||||
* @PINCTRL_STATE_DEFAULT: the state the pinctrl handle shall be put
|
||||
* into as default, usually this means the pins are up and ready to
|
||||
* be used by the device driver. This state is commonly used by
|
||||
* hogs to configure muxing and pins at boot, and also as a state
|
||||
* to go into when returning from sleep and idle in
|
||||
* .pm_runtime_resume() or ordinary .resume() for example.
|
||||
* @PINCTRL_STATE_INIT: normally the pinctrl will be set to "default"
|
||||
* before the driver's probe() function is called. There are some
|
||||
* drivers where that is not appropriate becausing doing so would
|
||||
* glitch the pins. In those cases you can add an "init" pinctrl
|
||||
* which is the state of the pins before drive probe. After probe
|
||||
* if the pins are still in "init" state they'll be moved to
|
||||
* "default".
|
||||
* @PINCTRL_STATE_IDLE: the state the pinctrl handle shall be put into
|
||||
* when the pins are idle. This is a state where the system is relaxed
|
||||
* but not fully sleeping - some power may be on but clocks gated for
|
||||
* example. Could typically be set from a pm_runtime_suspend() or
|
||||
* pm_runtime_idle() operation.
|
||||
* @PINCTRL_STATE_SLEEP: the state the pinctrl handle shall be put into
|
||||
* when the pins are sleeping. This is a state where the system is in
|
||||
* its lowest sleep state. Could typically be set from an
|
||||
* ordinary .suspend() function.
|
||||
*/
|
||||
#define PINCTRL_STATE_DEFAULT "default"
|
||||
#define PINCTRL_STATE_INIT "init"
|
||||
#define PINCTRL_STATE_IDLE "idle"
|
||||
#define PINCTRL_STATE_SLEEP "sleep"
|
||||
|
||||
#endif /* __LINUX_PINCTRL_PINCTRL_STATE_H */
|
||||
@@ -0,0 +1,254 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0-only */
|
||||
/*
|
||||
* Interface the pinctrl subsystem
|
||||
*
|
||||
* Copyright (C) 2011 ST-Ericsson SA
|
||||
* Written on behalf of Linaro for ST-Ericsson
|
||||
* This interface is used in the core to keep track of pins.
|
||||
*
|
||||
* Author: Linus Walleij <linus.walleij@linaro.org>
|
||||
*/
|
||||
#ifndef __LINUX_PINCTRL_PINCTRL_H
|
||||
#define __LINUX_PINCTRL_PINCTRL_H
|
||||
|
||||
#include <linux/bits.h>
|
||||
#include <linux/types.h>
|
||||
|
||||
struct device;
|
||||
struct device_node;
|
||||
struct gpio_chip;
|
||||
struct module;
|
||||
struct seq_file;
|
||||
|
||||
struct pin_config_item;
|
||||
struct pinconf_generic_params;
|
||||
struct pinconf_ops;
|
||||
struct pinctrl_dev;
|
||||
struct pinctrl_map;
|
||||
struct pinmux_ops;
|
||||
|
||||
/**
|
||||
* struct pingroup - provides information on pingroup
|
||||
* @name: a name for pingroup
|
||||
* @pins: an array of pins in the pingroup
|
||||
* @npins: number of pins in the pingroup
|
||||
*/
|
||||
struct pingroup {
|
||||
const char *name;
|
||||
const unsigned int *pins;
|
||||
size_t npins;
|
||||
};
|
||||
|
||||
/* Convenience macro to define a single named or anonymous pingroup */
|
||||
#define PINCTRL_PINGROUP(_name, _pins, _npins) \
|
||||
(struct pingroup) { \
|
||||
.name = _name, \
|
||||
.pins = _pins, \
|
||||
.npins = _npins, \
|
||||
}
|
||||
|
||||
/**
|
||||
* struct pinctrl_pin_desc - boards/machines provide information on their
|
||||
* pins, pads or other muxable units in this struct
|
||||
* @number: unique pin number from the global pin number space
|
||||
* @name: a name for this pin
|
||||
* @drv_data: driver-defined per-pin data. pinctrl core does not touch this
|
||||
*/
|
||||
struct pinctrl_pin_desc {
|
||||
unsigned int number;
|
||||
const char *name;
|
||||
void *drv_data;
|
||||
};
|
||||
|
||||
/* Convenience macro to define a single named or anonymous pin descriptor */
|
||||
#define PINCTRL_PIN(a, b) { .number = a, .name = b }
|
||||
#define PINCTRL_PIN_ANON(a) { .number = a }
|
||||
|
||||
/**
|
||||
* struct pinctrl_gpio_range - each pin controller can provide subranges of
|
||||
* the GPIO number space to be handled by the controller
|
||||
* @node: list node for internal use
|
||||
* @name: a name for the chip in this range
|
||||
* @id: an ID number for the chip in this range
|
||||
* @base: base offset of the GPIO range
|
||||
* @pin_base: base pin number of the GPIO range if pins == NULL
|
||||
* @npins: number of pins in the GPIO range, including the base number
|
||||
* @pins: enumeration of pins in GPIO range or NULL
|
||||
* @gc: an optional pointer to a gpio_chip
|
||||
*/
|
||||
struct pinctrl_gpio_range {
|
||||
struct list_head node;
|
||||
const char *name;
|
||||
unsigned int id;
|
||||
unsigned int base;
|
||||
unsigned int pin_base;
|
||||
unsigned int npins;
|
||||
unsigned int const *pins;
|
||||
struct gpio_chip *gc;
|
||||
};
|
||||
|
||||
/**
|
||||
* struct pinctrl_ops - global pin control operations, to be implemented by
|
||||
* pin controller drivers.
|
||||
* @get_groups_count: Returns the count of total number of groups registered.
|
||||
* @get_group_name: return the group name of the pin group
|
||||
* @get_group_pins: return an array of pins corresponding to a certain
|
||||
* group selector @pins, and the size of the array in @num_pins
|
||||
* @pin_dbg_show: optional debugfs display hook that will provide per-device
|
||||
* info for a certain pin in debugfs
|
||||
* @dt_node_to_map: parse a device tree "pin configuration node", and create
|
||||
* mapping table entries for it. These are returned through the @map and
|
||||
* @num_maps output parameters. This function is optional, and may be
|
||||
* omitted for pinctrl drivers that do not support device tree.
|
||||
* @dt_free_map: free mapping table entries created via @dt_node_to_map. The
|
||||
* top-level @map pointer must be freed, along with any dynamically
|
||||
* allocated members of the mapping table entries themselves. This
|
||||
* function is optional, and may be omitted for pinctrl drivers that do
|
||||
* not support device tree.
|
||||
*/
|
||||
struct pinctrl_ops {
|
||||
int (*get_groups_count) (struct pinctrl_dev *pctldev);
|
||||
const char *(*get_group_name) (struct pinctrl_dev *pctldev,
|
||||
unsigned int selector);
|
||||
int (*get_group_pins) (struct pinctrl_dev *pctldev,
|
||||
unsigned int selector,
|
||||
const unsigned int **pins,
|
||||
unsigned int *num_pins);
|
||||
void (*pin_dbg_show) (struct pinctrl_dev *pctldev, struct seq_file *s,
|
||||
unsigned int offset);
|
||||
int (*dt_node_to_map) (struct pinctrl_dev *pctldev,
|
||||
struct device_node *np_config,
|
||||
struct pinctrl_map **map, unsigned int *num_maps);
|
||||
void (*dt_free_map) (struct pinctrl_dev *pctldev,
|
||||
struct pinctrl_map *map, unsigned int num_maps);
|
||||
};
|
||||
|
||||
/**
|
||||
* struct pinctrl_desc - pin controller descriptor, register this to pin
|
||||
* control subsystem
|
||||
* @name: name for the pin controller
|
||||
* @pins: an array of pin descriptors describing all the pins handled by
|
||||
* this pin controller
|
||||
* @npins: number of descriptors in the array, usually just ARRAY_SIZE()
|
||||
* of the pins field above
|
||||
* @pctlops: pin control operation vtable, to support global concepts like
|
||||
* grouping of pins, this is optional.
|
||||
* @pmxops: pinmux operations vtable, if you support pinmuxing in your driver
|
||||
* @confops: pin config operations vtable, if you support pin configuration in
|
||||
* your driver
|
||||
* @owner: module providing the pin controller, used for refcounting
|
||||
* @num_custom_params: Number of driver-specific custom parameters to be parsed
|
||||
* from the hardware description
|
||||
* @custom_params: List of driver_specific custom parameters to be parsed from
|
||||
* the hardware description
|
||||
* @custom_conf_items: Information how to print @params in debugfs, must be
|
||||
* the same size as the @custom_params, i.e. @num_custom_params
|
||||
* @link_consumers: If true create a device link between pinctrl and its
|
||||
* consumers (i.e. the devices requesting pin control states). This is
|
||||
* sometimes necessary to ascertain the right suspend/resume order for
|
||||
* example.
|
||||
*/
|
||||
struct pinctrl_desc {
|
||||
const char *name;
|
||||
const struct pinctrl_pin_desc *pins;
|
||||
unsigned int npins;
|
||||
const struct pinctrl_ops *pctlops;
|
||||
const struct pinmux_ops *pmxops;
|
||||
const struct pinconf_ops *confops;
|
||||
struct module *owner;
|
||||
#ifdef CONFIG_GENERIC_PINCONF
|
||||
unsigned int num_custom_params;
|
||||
const struct pinconf_generic_params *custom_params;
|
||||
const struct pin_config_item *custom_conf_items;
|
||||
#endif
|
||||
bool link_consumers;
|
||||
};
|
||||
|
||||
/* External interface to pin controller */
|
||||
|
||||
extern int pinctrl_register_and_init(const struct pinctrl_desc *pctldesc,
|
||||
struct device *dev, void *driver_data,
|
||||
struct pinctrl_dev **pctldev);
|
||||
extern int pinctrl_enable(struct pinctrl_dev *pctldev);
|
||||
|
||||
/* Please use pinctrl_register_and_init() and pinctrl_enable() instead */
|
||||
extern struct pinctrl_dev *pinctrl_register(const struct pinctrl_desc *pctldesc,
|
||||
struct device *dev, void *driver_data);
|
||||
|
||||
extern void pinctrl_unregister(struct pinctrl_dev *pctldev);
|
||||
|
||||
extern int devm_pinctrl_register_and_init(struct device *dev,
|
||||
const struct pinctrl_desc *pctldesc,
|
||||
void *driver_data,
|
||||
struct pinctrl_dev **pctldev);
|
||||
|
||||
/* Please use devm_pinctrl_register_and_init() instead */
|
||||
extern struct pinctrl_dev *devm_pinctrl_register(struct device *dev,
|
||||
const struct pinctrl_desc *pctldesc,
|
||||
void *driver_data);
|
||||
|
||||
extern void pinctrl_add_gpio_range(struct pinctrl_dev *pctldev,
|
||||
struct pinctrl_gpio_range *range);
|
||||
extern void pinctrl_add_gpio_ranges(struct pinctrl_dev *pctldev,
|
||||
struct pinctrl_gpio_range *ranges,
|
||||
unsigned int nranges);
|
||||
extern void pinctrl_remove_gpio_range(struct pinctrl_dev *pctldev,
|
||||
struct pinctrl_gpio_range *range);
|
||||
|
||||
extern struct pinctrl_dev *pinctrl_find_and_add_gpio_range(const char *devname,
|
||||
struct pinctrl_gpio_range *range);
|
||||
extern struct pinctrl_gpio_range *
|
||||
pinctrl_find_gpio_range_from_pin(struct pinctrl_dev *pctldev,
|
||||
unsigned int pin);
|
||||
extern int pinctrl_get_group_pins(struct pinctrl_dev *pctldev,
|
||||
const char *pin_group, const unsigned int **pins,
|
||||
unsigned int *num_pins);
|
||||
|
||||
#define PINFUNCTION_FLAG_GPIO BIT(0)
|
||||
|
||||
/**
|
||||
* struct pinfunction - Description about a function
|
||||
* @name: Name of the function
|
||||
* @groups: An array of groups for this function
|
||||
* @ngroups: Number of groups in @groups
|
||||
* @flags: Additional pin function flags
|
||||
*/
|
||||
struct pinfunction {
|
||||
const char *name;
|
||||
const char * const *groups;
|
||||
size_t ngroups;
|
||||
unsigned long flags;
|
||||
};
|
||||
|
||||
/* Convenience macro to define a single named pinfunction */
|
||||
#define PINCTRL_PINFUNCTION(_name, _groups, _ngroups) \
|
||||
(struct pinfunction) { \
|
||||
.name = (_name), \
|
||||
.groups = (_groups), \
|
||||
.ngroups = (_ngroups), \
|
||||
}
|
||||
|
||||
/* Same as PINCTRL_PINFUNCTION() but for the GPIO category of functions */
|
||||
#define PINCTRL_GPIO_PINFUNCTION(_name, _groups, _ngroups) \
|
||||
(struct pinfunction) { \
|
||||
.name = (_name), \
|
||||
.groups = (_groups), \
|
||||
.ngroups = (_ngroups), \
|
||||
.flags = PINFUNCTION_FLAG_GPIO, \
|
||||
}
|
||||
|
||||
#if IS_ENABLED(CONFIG_OF) && IS_ENABLED(CONFIG_PINCTRL)
|
||||
extern struct pinctrl_dev *of_pinctrl_get(struct device_node *np);
|
||||
#else
|
||||
static inline
|
||||
struct pinctrl_dev *of_pinctrl_get(struct device_node *np)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
#endif /* CONFIG_OF */
|
||||
|
||||
extern const char *pinctrl_dev_get_name(struct pinctrl_dev *pctldev);
|
||||
extern const char *pinctrl_dev_get_devname(struct pinctrl_dev *pctldev);
|
||||
extern void *pinctrl_dev_get_drvdata(struct pinctrl_dev *pctldev);
|
||||
|
||||
#endif /* __LINUX_PINCTRL_PINCTRL_H */
|
||||
@@ -0,0 +1,96 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0-only */
|
||||
/*
|
||||
* Interface the pinmux subsystem
|
||||
*
|
||||
* Copyright (C) 2011 ST-Ericsson SA
|
||||
* Written on behalf of Linaro for ST-Ericsson
|
||||
* Based on bits of regulator core, gpio core and clk core
|
||||
*
|
||||
* Author: Linus Walleij <linus.walleij@linaro.org>
|
||||
*/
|
||||
#ifndef __LINUX_PINCTRL_PINMUX_H
|
||||
#define __LINUX_PINCTRL_PINMUX_H
|
||||
|
||||
#include <linux/types.h>
|
||||
|
||||
struct pinctrl_dev;
|
||||
struct pinctrl_gpio_range;
|
||||
|
||||
/**
|
||||
* struct pinmux_ops - pinmux operations, to be implemented by pin controller
|
||||
* drivers that support pinmuxing
|
||||
* @request: called by the core to see if a certain pin can be made
|
||||
* available for muxing. This is called by the core to acquire the pins
|
||||
* before selecting any actual mux setting across a function. The driver
|
||||
* is allowed to answer "no" by returning a negative error code
|
||||
* @free: the reverse function of the request() callback, frees a pin after
|
||||
* being requested
|
||||
* @get_functions_count: returns number of selectable named functions available
|
||||
* in this pinmux driver
|
||||
* @get_function_name: return the function name of the muxing selector,
|
||||
* called by the core to figure out which mux setting it shall map a
|
||||
* certain device to
|
||||
* @get_function_groups: return an array of groups names (in turn
|
||||
* referencing pins) connected to a certain function selector. The group
|
||||
* name can be used with the generic @pinctrl_ops to retrieve the
|
||||
* actual pins affected. The applicable groups will be returned in
|
||||
* @groups and the number of groups in @num_groups
|
||||
* @function_is_gpio: determine if the indicated function selector passed
|
||||
* corresponds to the GPIO function which is used by the accelerated GPIO
|
||||
* functions @gpio_request_enable, @gpio_disable_free and
|
||||
* @gpio_set_direction. When the pin control core can properly determine
|
||||
* if a function is a GPIO function, it is easier to use the @strict mode
|
||||
* on the pin controller. Since a single function is passed, this is
|
||||
* only useful on pin controllers that use a specific function for GPIO,
|
||||
* and that usually presupposes that a one-group-per-pin approach is
|
||||
* used, so that a single function can be set on a single pin to turn
|
||||
* it to GPIO mode.
|
||||
* @set_mux: enable a certain muxing function with a certain pin group. The
|
||||
* driver does not need to figure out whether enabling this function
|
||||
* conflicts some other use of the pins in that group, such collisions
|
||||
* are handled by the pinmux subsystem. The @func_selector selects a
|
||||
* certain function whereas @group_selector selects a certain set of pins
|
||||
* to be used. On simple controllers the latter argument may be ignored
|
||||
* @gpio_request_enable: requests and enables GPIO on a certain pin.
|
||||
* Implement this only if you can mux every pin individually as GPIO. The
|
||||
* affected GPIO range is passed along with an offset(pin number) into that
|
||||
* specific GPIO range - function selectors and pin groups are orthogonal
|
||||
* to this, the core will however make sure the pins do not collide.
|
||||
* @gpio_disable_free: free up GPIO muxing on a certain pin, the reverse of
|
||||
* @gpio_request_enable
|
||||
* @gpio_set_direction: Since controllers may need different configurations
|
||||
* depending on whether the GPIO is configured as input or output,
|
||||
* a direction selector function may be implemented as a backing
|
||||
* to the GPIO controllers that need pin muxing.
|
||||
* @strict: do not allow simultaneous use of the same pin for GPIO and another
|
||||
* function. Check both gpio_owner and mux_owner strictly before approving
|
||||
* the pin request.
|
||||
*/
|
||||
struct pinmux_ops {
|
||||
int (*request) (struct pinctrl_dev *pctldev, unsigned int offset);
|
||||
int (*free) (struct pinctrl_dev *pctldev, unsigned int offset);
|
||||
int (*get_functions_count) (struct pinctrl_dev *pctldev);
|
||||
const char *(*get_function_name) (struct pinctrl_dev *pctldev,
|
||||
unsigned int selector);
|
||||
int (*get_function_groups) (struct pinctrl_dev *pctldev,
|
||||
unsigned int selector,
|
||||
const char * const **groups,
|
||||
unsigned int *num_groups);
|
||||
bool (*function_is_gpio) (struct pinctrl_dev *pctldev,
|
||||
unsigned int selector);
|
||||
int (*set_mux) (struct pinctrl_dev *pctldev, unsigned int func_selector,
|
||||
unsigned int group_selector);
|
||||
int (*gpio_request_enable) (struct pinctrl_dev *pctldev,
|
||||
struct pinctrl_gpio_range *range,
|
||||
unsigned int offset);
|
||||
void (*gpio_disable_free) (struct pinctrl_dev *pctldev,
|
||||
struct pinctrl_gpio_range *range,
|
||||
unsigned int offset);
|
||||
int (*gpio_set_direction) (struct pinctrl_dev *pctldev,
|
||||
struct pinctrl_gpio_range *range,
|
||||
unsigned int offset,
|
||||
bool input);
|
||||
bool strict;
|
||||
};
|
||||
|
||||
#endif /* __LINUX_PINCTRL_PINMUX_H */
|
||||
Reference in New Issue
Block a user