linux/drivers/pinctrl/bcm/pinctrl-bcm2835.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Driver for Broadcom BCM2835 GPIO unit (pinctrl + GPIO)
 *
 * Copyright (C) 2012 Chris Boot, Simon Arlott, Stephen Warren
 *
 * This driver is inspired by:
 * pinctrl-nomadik.c, please see original file for copyright information
 * pinctrl-tegra.c, please see original file for copyright information
 */

#include <linux/bitmap.h>
#include <linux/bug.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/gpio/driver.h>
#include <linux/io.h>
#include <linux/irq.h>
#include <linux/irqdesc.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/of_address.h>
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/pinctrl/consumer.h>
#include <linux/pinctrl/machine.h>
#include <linux/pinctrl/pinconf.h>
#include <linux/pinctrl/pinctrl.h>
#include <linux/pinctrl/pinmux.h>
#include <linux/pinctrl/pinconf-generic.h>
#include <linux/platform_device.h>
#include <linux/seq_file.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/string_choices.h>
#include <linux/types.h>
#include <dt-bindings/pinctrl/bcm2835.h>

#define MODULE_NAME
#define BCM2835_NUM_GPIOS
#define BCM2711_NUM_GPIOS
#define BCM2835_NUM_BANKS
#define BCM2835_NUM_IRQS

/* GPIO register offsets */
#define GPFSEL0
#define GPSET0
#define GPCLR0
#define GPLEV0
#define GPEDS0
#define GPREN0
#define GPFEN0
#define GPHEN0
#define GPLEN0
#define GPAREN0
#define GPAFEN0
#define GPPUD
#define GPPUDCLK0
#define GP_GPIO_PUP_PDN_CNTRL_REG0

#define FSEL_REG(p)
#define FSEL_SHIFT(p)
#define GPIO_REG_OFFSET(p)
#define GPIO_REG_SHIFT(p)

#define PUD_2711_MASK
#define PUD_2711_REG_OFFSET(p)
#define PUD_2711_REG_SHIFT(p)

/* argument: bcm2835_pinconf_pull */
#define BCM2835_PINCONF_PARAM_PULL

#define BCM2711_PULL_NONE
#define BCM2711_PULL_UP
#define BCM2711_PULL_DOWN

struct bcm2835_pinctrl {};

/* pins are just named GPIO0..GPIO53 */
#define BCM2835_GPIO_PIN(a)
static struct pinctrl_pin_desc bcm2835_gpio_pins[] =;

/* one pin per group */
static const char * const bcm2835_gpio_groups[] =;

enum bcm2835_fsel {};

static const char * const bcm2835_functions[BCM2835_FSEL_COUNT] =;

static const char * const irq_type_names[] =;

static bool persist_gpio_outputs;
module_param(persist_gpio_outputs, bool, 0444);
MODULE_PARM_DESC();

static inline u32 bcm2835_gpio_rd(struct bcm2835_pinctrl *pc, unsigned reg)
{}

static inline void bcm2835_gpio_wr(struct bcm2835_pinctrl *pc, unsigned reg,
		u32 val)
{}

static inline int bcm2835_gpio_get_bit(struct bcm2835_pinctrl *pc, unsigned reg,
		unsigned bit)
{}

/* note NOT a read/modify/write cycle */
static inline void bcm2835_gpio_set_bit(struct bcm2835_pinctrl *pc,
		unsigned reg, unsigned bit)
{}

static inline enum bcm2835_fsel bcm2835_pinctrl_fsel_get(
		struct bcm2835_pinctrl *pc, unsigned pin)
{}

static inline void bcm2835_pinctrl_fsel_set(
		struct bcm2835_pinctrl *pc, unsigned pin,
		enum bcm2835_fsel fsel)
{}

static int bcm2835_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
{}

static int bcm2835_gpio_get(struct gpio_chip *chip, unsigned offset)
{}

static int bcm2835_gpio_get_direction(struct gpio_chip *chip, unsigned int offset)
{}

static void bcm2835_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
{}

static int bcm2835_gpio_direction_output(struct gpio_chip *chip,
		unsigned offset, int value)
{}

static int bcm2835_add_pin_ranges_fallback(struct gpio_chip *gc)
{}

static const struct gpio_chip bcm2835_gpio_chip =;

static const struct gpio_chip bcm2711_gpio_chip =;

static void bcm2835_gpio_irq_handle_bank(struct bcm2835_pinctrl *pc,
					 unsigned int bank, u32 mask)
{}

static void bcm2835_gpio_irq_handler(struct irq_desc *desc)
{}

static irqreturn_t bcm2835_gpio_wake_irq_handler(int irq, void *dev_id)
{}

static inline void __bcm2835_gpio_irq_config(struct bcm2835_pinctrl *pc,
	unsigned reg, unsigned offset, bool enable)
{}

/* fast path for IRQ handler */
static void bcm2835_gpio_irq_config(struct bcm2835_pinctrl *pc,
	unsigned offset, bool enable)
{}

static void bcm2835_gpio_irq_unmask(struct irq_data *data)
{}

static void bcm2835_gpio_irq_mask(struct irq_data *data)
{}

static int __bcm2835_gpio_irq_set_type_disabled(struct bcm2835_pinctrl *pc,
	unsigned offset, unsigned int type)
{}

/* slower path for reconfiguring IRQ type */
static int __bcm2835_gpio_irq_set_type_enabled(struct bcm2835_pinctrl *pc,
	unsigned offset, unsigned int type)
{}

static int bcm2835_gpio_irq_set_type(struct irq_data *data, unsigned int type)
{}

static void bcm2835_gpio_irq_ack(struct irq_data *data)
{}

static int bcm2835_gpio_irq_set_wake(struct irq_data *data, unsigned int on)
{}

static const struct irq_chip bcm2835_gpio_irq_chip =;

static int bcm2835_pctl_get_groups_count(struct pinctrl_dev *pctldev)
{}

static const char *bcm2835_pctl_get_group_name(struct pinctrl_dev *pctldev,
		unsigned selector)
{}

static int bcm2835_pctl_get_group_pins(struct pinctrl_dev *pctldev,
		unsigned selector,
		const unsigned **pins,
		unsigned *num_pins)
{}

static void bcm2835_pctl_pin_dbg_show(struct pinctrl_dev *pctldev,
		struct seq_file *s,
		unsigned offset)
{}

static void bcm2835_pctl_dt_free_map(struct pinctrl_dev *pctldev,
		struct pinctrl_map *maps, unsigned num_maps)
{}

static int bcm2835_pctl_dt_node_to_map_func(struct bcm2835_pinctrl *pc,
		struct device_node *np, u32 pin, u32 fnum,
		struct pinctrl_map **maps)
{}

static int bcm2835_pctl_dt_node_to_map_pull(struct bcm2835_pinctrl *pc,
		struct device_node *np, u32 pin, u32 pull,
		struct pinctrl_map **maps)
{}

static int bcm2835_pctl_dt_node_to_map(struct pinctrl_dev *pctldev,
		struct device_node *np,
		struct pinctrl_map **map, unsigned int *num_maps)
{}

static const struct pinctrl_ops bcm2835_pctl_ops =;

static int bcm2835_pmx_free(struct pinctrl_dev *pctldev,
		unsigned offset)
{}

static int bcm2835_pmx_get_functions_count(struct pinctrl_dev *pctldev)
{}

static const char *bcm2835_pmx_get_function_name(struct pinctrl_dev *pctldev,
		unsigned selector)
{}

static int bcm2835_pmx_get_function_groups(struct pinctrl_dev *pctldev,
		unsigned selector,
		const char * const **groups,
		unsigned * const num_groups)
{}

static int bcm2835_pmx_set(struct pinctrl_dev *pctldev,
		unsigned func_selector,
		unsigned group_selector)
{}

static void bcm2835_pmx_gpio_disable_free(struct pinctrl_dev *pctldev,
		struct pinctrl_gpio_range *range,
		unsigned offset)
{}

static int bcm2835_pmx_gpio_set_direction(struct pinctrl_dev *pctldev,
		struct pinctrl_gpio_range *range,
		unsigned offset,
		bool input)
{}

static const struct pinmux_ops bcm2835_pmx_ops =;

static int bcm2835_pinconf_get(struct pinctrl_dev *pctldev,
			unsigned pin, unsigned long *config)
{}

static void bcm2835_pull_config_set(struct bcm2835_pinctrl *pc,
		unsigned int pin, unsigned int arg)
{}

static int bcm2835_pinconf_set(struct pinctrl_dev *pctldev,
			unsigned int pin, unsigned long *configs,
			unsigned int num_configs)
{}

static const struct pinconf_ops bcm2835_pinconf_ops =;

static int bcm2711_pinconf_get(struct pinctrl_dev *pctldev, unsigned pin,
			       unsigned long *config)
{}

static void bcm2711_pull_config_set(struct bcm2835_pinctrl *pc,
				    unsigned int pin, unsigned int arg)
{}

static int bcm2711_pinconf_set(struct pinctrl_dev *pctldev,
			       unsigned int pin, unsigned long *configs,
			       unsigned int num_configs)
{}

static const struct pinconf_ops bcm2711_pinconf_ops =;

static const struct pinctrl_desc bcm2835_pinctrl_desc =;

static const struct pinctrl_desc bcm2711_pinctrl_desc =;

static const struct pinctrl_gpio_range bcm2835_pinctrl_gpio_range =;

static const struct pinctrl_gpio_range bcm2711_pinctrl_gpio_range =;

struct bcm_plat_data {};

static const struct bcm_plat_data bcm2835_plat_data =;

static const struct bcm_plat_data bcm2711_plat_data =;

static const struct of_device_id bcm2835_pinctrl_match[] =;
MODULE_DEVICE_TABLE(of, bcm2835_pinctrl_match);

static int bcm2835_pinctrl_probe(struct platform_device *pdev)
{}

static struct platform_driver bcm2835_pinctrl_driver =;
module_platform_driver();

MODULE_AUTHOR();
MODULE_AUTHOR();
MODULE_AUTHOR();
MODULE_DESCRIPTION();
MODULE_LICENSE();