mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-08-30 05:48:51 +09:00
![Tom Rini](/assets/img/avatar_default.png)
The "method" parameter was part of the original port of the driver from the kernel. At some point this may have been added to allow for future differentiation (as omap1 and omap2 have different GPIO IP blocks, so this wasn't an unreasonable thing to do). At this point however it's just extra overhead, so drop. Signed-off-by: Tom Rini <trini@konsulko.com>
347 lines
6.8 KiB
C
347 lines
6.8 KiB
C
/*
|
|
* Copyright (c) 2009 Wind River Systems, Inc.
|
|
* Tom Rix <Tom.Rix@windriver.com>
|
|
*
|
|
* SPDX-License-Identifier: GPL-2.0
|
|
*
|
|
* This work is derived from the linux 2.6.27 kernel source
|
|
* To fetch, use the kernel repository
|
|
* git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6.git
|
|
* Use the v2.6.27 tag.
|
|
*
|
|
* Below is the original's header including its copyright
|
|
*
|
|
* linux/arch/arm/plat-omap/gpio.c
|
|
*
|
|
* Support functions for OMAP GPIO
|
|
*
|
|
* Copyright (C) 2003-2005 Nokia Corporation
|
|
* Written by Juha Yrjölä <juha.yrjola@nokia.com>
|
|
*/
|
|
#include <common.h>
|
|
#include <dm.h>
|
|
#include <fdtdec.h>
|
|
#include <asm/gpio.h>
|
|
#include <asm/io.h>
|
|
#include <asm/errno.h>
|
|
#include <malloc.h>
|
|
|
|
DECLARE_GLOBAL_DATA_PTR;
|
|
|
|
#define OMAP_GPIO_DIR_OUT 0
|
|
#define OMAP_GPIO_DIR_IN 1
|
|
|
|
#ifdef CONFIG_DM_GPIO
|
|
|
|
#define GPIO_PER_BANK 32
|
|
|
|
struct gpio_bank {
|
|
/* TODO(sjg@chromium.org): Can we use a struct here? */
|
|
void *base; /* address of registers in physical memory */
|
|
};
|
|
|
|
#endif
|
|
|
|
static inline int get_gpio_index(int gpio)
|
|
{
|
|
return gpio & 0x1f;
|
|
}
|
|
|
|
int gpio_is_valid(int gpio)
|
|
{
|
|
return (gpio >= 0) && (gpio < OMAP_MAX_GPIO);
|
|
}
|
|
|
|
static void _set_gpio_direction(const struct gpio_bank *bank, int gpio,
|
|
int is_input)
|
|
{
|
|
void *reg = bank->base;
|
|
u32 l;
|
|
|
|
reg += OMAP_GPIO_OE;
|
|
|
|
l = __raw_readl(reg);
|
|
if (is_input)
|
|
l |= 1 << gpio;
|
|
else
|
|
l &= ~(1 << gpio);
|
|
__raw_writel(l, reg);
|
|
}
|
|
|
|
/**
|
|
* Get the direction of the GPIO by reading the GPIO_OE register
|
|
* corresponding to the specified bank.
|
|
*/
|
|
static int _get_gpio_direction(const struct gpio_bank *bank, int gpio)
|
|
{
|
|
void *reg = bank->base;
|
|
u32 v;
|
|
|
|
reg += OMAP_GPIO_OE;
|
|
|
|
v = __raw_readl(reg);
|
|
|
|
if (v & (1 << gpio))
|
|
return OMAP_GPIO_DIR_IN;
|
|
else
|
|
return OMAP_GPIO_DIR_OUT;
|
|
}
|
|
|
|
static void _set_gpio_dataout(const struct gpio_bank *bank, int gpio,
|
|
int enable)
|
|
{
|
|
void *reg = bank->base;
|
|
u32 l = 0;
|
|
|
|
if (enable)
|
|
reg += OMAP_GPIO_SETDATAOUT;
|
|
else
|
|
reg += OMAP_GPIO_CLEARDATAOUT;
|
|
|
|
l = 1 << gpio;
|
|
__raw_writel(l, reg);
|
|
}
|
|
|
|
static int _get_gpio_value(const struct gpio_bank *bank, int gpio)
|
|
{
|
|
void *reg = bank->base;
|
|
int input;
|
|
|
|
input = _get_gpio_direction(bank, gpio);
|
|
switch (input) {
|
|
case OMAP_GPIO_DIR_IN:
|
|
reg += OMAP_GPIO_DATAIN;
|
|
break;
|
|
case OMAP_GPIO_DIR_OUT:
|
|
reg += OMAP_GPIO_DATAOUT;
|
|
break;
|
|
default:
|
|
return -1;
|
|
}
|
|
|
|
return (__raw_readl(reg) & (1 << gpio)) != 0;
|
|
}
|
|
|
|
#ifndef CONFIG_DM_GPIO
|
|
|
|
static inline const struct gpio_bank *get_gpio_bank(int gpio)
|
|
{
|
|
return &omap_gpio_bank[gpio >> 5];
|
|
}
|
|
|
|
static int check_gpio(int gpio)
|
|
{
|
|
if (!gpio_is_valid(gpio)) {
|
|
printf("ERROR : check_gpio: invalid GPIO %d\n", gpio);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Set value of the specified gpio
|
|
*/
|
|
int gpio_set_value(unsigned gpio, int value)
|
|
{
|
|
const struct gpio_bank *bank;
|
|
|
|
if (check_gpio(gpio) < 0)
|
|
return -1;
|
|
bank = get_gpio_bank(gpio);
|
|
_set_gpio_dataout(bank, get_gpio_index(gpio), value);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Get value of the specified gpio
|
|
*/
|
|
int gpio_get_value(unsigned gpio)
|
|
{
|
|
const struct gpio_bank *bank;
|
|
|
|
if (check_gpio(gpio) < 0)
|
|
return -1;
|
|
bank = get_gpio_bank(gpio);
|
|
|
|
return _get_gpio_value(bank, get_gpio_index(gpio));
|
|
}
|
|
|
|
/**
|
|
* Set gpio direction as input
|
|
*/
|
|
int gpio_direction_input(unsigned gpio)
|
|
{
|
|
const struct gpio_bank *bank;
|
|
|
|
if (check_gpio(gpio) < 0)
|
|
return -1;
|
|
|
|
bank = get_gpio_bank(gpio);
|
|
_set_gpio_direction(bank, get_gpio_index(gpio), 1);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Set gpio direction as output
|
|
*/
|
|
int gpio_direction_output(unsigned gpio, int value)
|
|
{
|
|
const struct gpio_bank *bank;
|
|
|
|
if (check_gpio(gpio) < 0)
|
|
return -1;
|
|
|
|
bank = get_gpio_bank(gpio);
|
|
_set_gpio_dataout(bank, get_gpio_index(gpio), value);
|
|
_set_gpio_direction(bank, get_gpio_index(gpio), 0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Request a gpio before using it.
|
|
*
|
|
* NOTE: Argument 'label' is unused.
|
|
*/
|
|
int gpio_request(unsigned gpio, const char *label)
|
|
{
|
|
if (check_gpio(gpio) < 0)
|
|
return -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Reset and free the gpio after using it.
|
|
*/
|
|
int gpio_free(unsigned gpio)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
#else /* new driver model interface CONFIG_DM_GPIO */
|
|
|
|
/* set GPIO pin 'gpio' as an input */
|
|
static int omap_gpio_direction_input(struct udevice *dev, unsigned offset)
|
|
{
|
|
struct gpio_bank *bank = dev_get_priv(dev);
|
|
|
|
/* Configure GPIO direction as input. */
|
|
_set_gpio_direction(bank, offset, 1);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* set GPIO pin 'gpio' as an output, with polarity 'value' */
|
|
static int omap_gpio_direction_output(struct udevice *dev, unsigned offset,
|
|
int value)
|
|
{
|
|
struct gpio_bank *bank = dev_get_priv(dev);
|
|
|
|
_set_gpio_dataout(bank, offset, value);
|
|
_set_gpio_direction(bank, offset, 0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* read GPIO IN value of pin 'gpio' */
|
|
static int omap_gpio_get_value(struct udevice *dev, unsigned offset)
|
|
{
|
|
struct gpio_bank *bank = dev_get_priv(dev);
|
|
|
|
return _get_gpio_value(bank, offset);
|
|
}
|
|
|
|
/* write GPIO OUT value to pin 'gpio' */
|
|
static int omap_gpio_set_value(struct udevice *dev, unsigned offset,
|
|
int value)
|
|
{
|
|
struct gpio_bank *bank = dev_get_priv(dev);
|
|
|
|
_set_gpio_dataout(bank, offset, value);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int omap_gpio_get_function(struct udevice *dev, unsigned offset)
|
|
{
|
|
struct gpio_bank *bank = dev_get_priv(dev);
|
|
|
|
/* GPIOF_FUNC is not implemented yet */
|
|
if (_get_gpio_direction(bank, offset) == OMAP_GPIO_DIR_OUT)
|
|
return GPIOF_OUTPUT;
|
|
else
|
|
return GPIOF_INPUT;
|
|
}
|
|
|
|
static const struct dm_gpio_ops gpio_omap_ops = {
|
|
.direction_input = omap_gpio_direction_input,
|
|
.direction_output = omap_gpio_direction_output,
|
|
.get_value = omap_gpio_get_value,
|
|
.set_value = omap_gpio_set_value,
|
|
.get_function = omap_gpio_get_function,
|
|
};
|
|
|
|
static int omap_gpio_probe(struct udevice *dev)
|
|
{
|
|
struct gpio_bank *bank = dev_get_priv(dev);
|
|
struct omap_gpio_platdata *plat = dev_get_platdata(dev);
|
|
struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
|
|
|
|
uc_priv->bank_name = plat->port_name;
|
|
uc_priv->gpio_count = GPIO_PER_BANK;
|
|
bank->base = (void *)plat->base;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int omap_gpio_bind(struct udevice *dev)
|
|
{
|
|
struct omap_gpio_platdata *plat = dev->platdata;
|
|
fdt_addr_t base_addr;
|
|
|
|
if (plat)
|
|
return 0;
|
|
|
|
base_addr = dev_get_addr(dev);
|
|
if (base_addr == FDT_ADDR_T_NONE)
|
|
return -ENODEV;
|
|
|
|
/*
|
|
* TODO:
|
|
* When every board is converted to driver model and DT is
|
|
* supported, this can be done by auto-alloc feature, but
|
|
* not using calloc to alloc memory for platdata.
|
|
*/
|
|
plat = calloc(1, sizeof(*plat));
|
|
if (!plat)
|
|
return -ENOMEM;
|
|
|
|
plat->base = base_addr;
|
|
plat->port_name = fdt_get_name(gd->fdt_blob, dev->of_offset, NULL);
|
|
dev->platdata = plat;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct udevice_id omap_gpio_ids[] = {
|
|
{ .compatible = "ti,omap3-gpio" },
|
|
{ .compatible = "ti,omap4-gpio" },
|
|
{ .compatible = "ti,am4372-gpio" },
|
|
{ }
|
|
};
|
|
|
|
U_BOOT_DRIVER(gpio_omap) = {
|
|
.name = "gpio_omap",
|
|
.id = UCLASS_GPIO,
|
|
.ops = &gpio_omap_ops,
|
|
.of_match = omap_gpio_ids,
|
|
.bind = omap_gpio_bind,
|
|
.probe = omap_gpio_probe,
|
|
.priv_auto_alloc_size = sizeof(struct gpio_bank),
|
|
};
|
|
|
|
#endif /* CONFIG_DM_GPIO */
|