2019-06-04 08:11:33 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2005-07-10 18:58:15 +00:00
|
|
|
/*
|
|
|
|
* Support functions for OMAP GPIO
|
|
|
|
*
|
2005-09-07 16:20:26 +00:00
|
|
|
* Copyright (C) 2003-2005 Nokia Corporation
|
2007-10-19 21:21:04 +00:00
|
|
|
* Written by Juha Yrjölä <juha.yrjola@nokia.com>
|
2005-07-10 18:58:15 +00:00
|
|
|
*
|
2009-05-28 21:16:04 +00:00
|
|
|
* Copyright (C) 2009 Texas Instruments
|
|
|
|
* Added OMAP4 support - Santosh Shilimkar <santosh.shilimkar@ti.com>
|
2005-07-10 18:58:15 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/interrupt.h>
|
2011-04-22 20:02:46 +00:00
|
|
|
#include <linux/syscore_ops.h>
|
2005-09-07 16:20:26 +00:00
|
|
|
#include <linux/err.h>
|
2006-01-07 16:15:52 +00:00
|
|
|
#include <linux/clk.h>
|
2008-09-06 11:10:45 +00:00
|
|
|
#include <linux/io.h>
|
2018-09-20 19:35:31 +00:00
|
|
|
#include <linux/cpu_pm.h>
|
2012-02-01 15:01:39 +00:00
|
|
|
#include <linux/device.h>
|
2010-12-08 00:26:57 +00:00
|
|
|
#include <linux/pm_runtime.h>
|
2011-09-29 01:53:22 +00:00
|
|
|
#include <linux/pm.h>
|
2011-08-16 09:53:02 +00:00
|
|
|
#include <linux/of.h>
|
|
|
|
#include <linux/of_device.h>
|
2018-05-24 12:24:00 +00:00
|
|
|
#include <linux/gpio/driver.h>
|
2014-04-24 06:57:39 +00:00
|
|
|
#include <linux/bitops.h>
|
2012-08-30 22:37:24 +00:00
|
|
|
#include <linux/platform_data/gpio-omap.h>
|
2005-07-10 18:58:15 +00:00
|
|
|
|
2015-08-18 11:10:54 +00:00
|
|
|
#define OMAP4_GPIO_DEBOUNCINGTIME_MASK 0xFF
|
2011-11-23 21:14:29 +00:00
|
|
|
|
2011-04-18 15:06:51 +00:00
|
|
|
struct gpio_regs {
|
|
|
|
u32 irqenable1;
|
|
|
|
u32 irqenable2;
|
|
|
|
u32 wake_en;
|
|
|
|
u32 ctrl;
|
|
|
|
u32 oe;
|
|
|
|
u32 leveldetect0;
|
|
|
|
u32 leveldetect1;
|
|
|
|
u32 risingdetect;
|
|
|
|
u32 fallingdetect;
|
|
|
|
u32 dataout;
|
2011-09-09 13:38:58 +00:00
|
|
|
u32 debounce;
|
|
|
|
u32 debounce_en;
|
2011-04-18 15:06:51 +00:00
|
|
|
};
|
|
|
|
|
2005-07-10 18:58:15 +00:00
|
|
|
struct gpio_bank {
|
2005-09-07 16:20:26 +00:00
|
|
|
void __iomem *base;
|
2019-06-10 17:11:00 +00:00
|
|
|
const struct omap_gpio_reg_offs *regs;
|
|
|
|
|
2015-09-25 19:06:02 +00:00
|
|
|
int irq;
|
2006-12-07 01:13:52 +00:00
|
|
|
u32 non_wakeup_gpios;
|
|
|
|
u32 enabled_non_wakeup_gpios;
|
2011-04-18 15:06:51 +00:00
|
|
|
struct gpio_regs context;
|
2006-12-07 01:13:52 +00:00
|
|
|
u32 saved_datain;
|
2008-01-17 05:56:15 +00:00
|
|
|
u32 level_mask;
|
omap: gpio: Simultaneously requested rising and falling edge
Some chips, namely any OMAP1 chips using METHOD_MPUIO,
OMAP15xx and OMAP7xx, cannot be setup to respond to on-chip GPIO
interrupts in both rising and falling edge directions -- they can
only respond to one direction or the other, depending on how the
ICR is configured.
Additionally, current code forces rising edge detection if both
flags are specified:
if (trigger & IRQ_TYPE_EDGE_RISING)
l |= 1 << gpio;
else if (trigger & IRQ_TYPE_EDGE_FALLING)
l &= ~(1 << gpio);
else
goto bad;
This change implements a toggle function that will modify the ICR
to flip the direction of interrupt for IRQs that are requested with
both rising and falling flags. The toggle function is not called
for chips and GPIOs it does not apply to through the use of a flip_mask
that's added on a per-bank basis. The mask is only set for those
GPIOs where a toggle is necessary. Edge detection starts out the
same as above with FALLING mode first.
The toggle happens on EACH interrupt; without it, we have the
following sequence of actions on GPIO transition:
ICR GPIO Result
0x1 0 -> 1 (rising) Interrupt
0x1 1 -> 0 (falling) No interrupt
(set ICR to 0x0 manually)
0x0 0 -> 1 (rising) No interrupt
0x0 1 -> 0 (falling) Interrupt
That is, with the ICR set to 1 for a gpio, only rising edge interrupts
are caught, and with it set to 0, only falling edge interrupts are
caught. If we add in the toggle, we get this:
ICR GPIO Result
0x1 0 -> 1 (rising) Interrupt (ICR set to 0x0)
0x0 1 -> 0 (falling) Interrupt (ICR set to 0x1)
0x1 0 -> 1 ...
so, both rising and falling are caught, per the request for both
(IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING).
Signed-off-by: Cory Maccarrone <darkstar6262@gmail.com>
Acked-by: Kevin Hilman <khilman@deeprootsystems.com>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2010-01-08 18:29:04 +00:00
|
|
|
u32 toggle_mask;
|
2015-07-21 16:26:51 +00:00
|
|
|
raw_spinlock_t lock;
|
2015-09-25 19:28:03 +00:00
|
|
|
raw_spinlock_t wa_lock;
|
2008-03-03 20:43:23 +00:00
|
|
|
struct gpio_chip chip;
|
2008-12-11 01:35:24 +00:00
|
|
|
struct clk *dbck;
|
2018-09-20 19:35:31 +00:00
|
|
|
struct notifier_block nb;
|
|
|
|
unsigned int is_suspended:1;
|
2020-06-29 16:41:14 +00:00
|
|
|
unsigned int needs_resume:1;
|
2009-11-22 18:11:25 +00:00
|
|
|
u32 mod_usage;
|
2013-09-25 00:36:52 +00:00
|
|
|
u32 irq_usage;
|
2009-01-27 19:15:34 +00:00
|
|
|
u32 dbck_enable_mask;
|
2011-11-23 21:33:28 +00:00
|
|
|
bool dbck_enabled;
|
2011-08-30 18:32:21 +00:00
|
|
|
bool is_mpuio;
|
2010-12-08 00:26:57 +00:00
|
|
|
bool dbck_flag;
|
2011-05-05 14:45:16 +00:00
|
|
|
bool loses_context;
|
2013-04-15 18:06:54 +00:00
|
|
|
bool context_valid;
|
2010-12-08 00:26:58 +00:00
|
|
|
int stride;
|
2011-04-21 16:23:00 +00:00
|
|
|
u32 width;
|
2011-09-28 23:17:25 +00:00
|
|
|
int context_loss_count;
|
2011-04-20 23:31:23 +00:00
|
|
|
|
2015-03-23 12:18:24 +00:00
|
|
|
void (*set_dataout)(struct gpio_bank *bank, unsigned gpio, int enable);
|
2011-09-28 23:17:25 +00:00
|
|
|
int (*get_context_loss_count)(struct device *dev);
|
2005-07-10 18:58:15 +00:00
|
|
|
};
|
|
|
|
|
2011-05-02 09:51:42 +00:00
|
|
|
#define GPIO_MOD_CTRL_BIT BIT(0)
|
2005-07-10 18:58:15 +00:00
|
|
|
|
2013-09-25 00:36:52 +00:00
|
|
|
#define BANK_USED(bank) (bank->mod_usage || bank->irq_usage)
|
2014-04-27 00:00:49 +00:00
|
|
|
#define LINE_USED(line, offset) (line & (BIT(offset)))
|
2013-09-25 00:36:52 +00:00
|
|
|
|
2015-01-16 22:50:50 +00:00
|
|
|
static void omap_gpio_unmask_irq(struct irq_data *d);
|
|
|
|
|
2014-06-27 20:17:37 +00:00
|
|
|
static inline struct gpio_bank *omap_irq_data_get_bank(struct irq_data *d)
|
2013-03-01 17:22:47 +00:00
|
|
|
{
|
2014-04-06 14:58:16 +00:00
|
|
|
struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
|
2015-12-07 10:16:00 +00:00
|
|
|
return gpiochip_get_data(chip);
|
2012-02-23 20:50:10 +00:00
|
|
|
}
|
|
|
|
|
2019-06-10 17:10:55 +00:00
|
|
|
static inline u32 omap_gpio_rmw(void __iomem *reg, u32 mask, bool set)
|
2005-07-10 18:58:15 +00:00
|
|
|
{
|
2019-06-10 17:10:55 +00:00
|
|
|
u32 val = readl_relaxed(reg);
|
2005-07-10 18:58:15 +00:00
|
|
|
|
2019-06-10 17:10:55 +00:00
|
|
|
if (set)
|
|
|
|
val |= mask;
|
2005-07-10 18:58:15 +00:00
|
|
|
else
|
2019-06-10 17:10:55 +00:00
|
|
|
val &= ~mask;
|
|
|
|
|
|
|
|
writel_relaxed(val, reg);
|
|
|
|
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void omap_set_gpio_direction(struct gpio_bank *bank, int gpio,
|
|
|
|
int is_input)
|
|
|
|
{
|
|
|
|
bank->context.oe = omap_gpio_rmw(bank->base + bank->regs->direction,
|
|
|
|
BIT(gpio), is_input);
|
2005-07-10 18:58:15 +00:00
|
|
|
}
|
|
|
|
|
2011-04-20 23:31:23 +00:00
|
|
|
|
|
|
|
/* set data out value using dedicate set/clear register */
|
2015-03-23 12:18:24 +00:00
|
|
|
static void omap_set_gpio_dataout_reg(struct gpio_bank *bank, unsigned offset,
|
2014-06-27 20:17:37 +00:00
|
|
|
int enable)
|
2005-07-10 18:58:15 +00:00
|
|
|
{
|
2005-09-07 16:20:26 +00:00
|
|
|
void __iomem *reg = bank->base;
|
2015-03-23 12:18:24 +00:00
|
|
|
u32 l = BIT(offset);
|
2005-07-10 18:58:15 +00:00
|
|
|
|
2012-03-02 07:22:52 +00:00
|
|
|
if (enable) {
|
2011-04-20 23:31:23 +00:00
|
|
|
reg += bank->regs->set_dataout;
|
2012-03-02 07:22:52 +00:00
|
|
|
bank->context.dataout |= l;
|
|
|
|
} else {
|
2011-04-20 23:31:23 +00:00
|
|
|
reg += bank->regs->clr_dataout;
|
2012-03-02 07:22:52 +00:00
|
|
|
bank->context.dataout &= ~l;
|
|
|
|
}
|
2005-07-10 18:58:15 +00:00
|
|
|
|
2013-11-16 00:01:04 +00:00
|
|
|
writel_relaxed(l, reg);
|
2005-07-10 18:58:15 +00:00
|
|
|
}
|
|
|
|
|
2011-04-20 23:31:23 +00:00
|
|
|
/* set data out value using mask register */
|
2015-03-23 12:18:24 +00:00
|
|
|
static void omap_set_gpio_dataout_mask(struct gpio_bank *bank, unsigned offset,
|
2014-06-27 20:17:37 +00:00
|
|
|
int enable)
|
2005-07-10 18:58:15 +00:00
|
|
|
{
|
2019-06-10 17:10:55 +00:00
|
|
|
bank->context.dataout = omap_gpio_rmw(bank->base + bank->regs->dataout,
|
|
|
|
BIT(offset), enable);
|
2011-07-12 15:18:15 +00:00
|
|
|
}
|
2005-09-07 16:20:26 +00:00
|
|
|
|
2014-06-27 20:17:37 +00:00
|
|
|
static inline void omap_gpio_dbck_enable(struct gpio_bank *bank)
|
2011-11-23 21:33:28 +00:00
|
|
|
{
|
|
|
|
if (bank->dbck_enable_mask && !bank->dbck_enabled) {
|
2015-08-18 11:10:56 +00:00
|
|
|
clk_enable(bank->dbck);
|
2011-11-23 21:33:28 +00:00
|
|
|
bank->dbck_enabled = true;
|
2012-06-16 19:01:25 +00:00
|
|
|
|
2013-11-16 00:01:04 +00:00
|
|
|
writel_relaxed(bank->dbck_enable_mask,
|
2012-06-16 19:01:25 +00:00
|
|
|
bank->base + bank->regs->debounce_en);
|
2011-11-23 21:33:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-27 20:17:37 +00:00
|
|
|
static inline void omap_gpio_dbck_disable(struct gpio_bank *bank)
|
2011-11-23 21:33:28 +00:00
|
|
|
{
|
|
|
|
if (bank->dbck_enable_mask && bank->dbck_enabled) {
|
2012-06-16 19:01:25 +00:00
|
|
|
/*
|
|
|
|
* Disable debounce before cutting it's clock. If debounce is
|
|
|
|
* enabled but the clock is not, GPIO module seems to be unable
|
|
|
|
* to detect events and generate interrupts at least on OMAP3.
|
|
|
|
*/
|
2013-11-16 00:01:04 +00:00
|
|
|
writel_relaxed(0, bank->base + bank->regs->debounce_en);
|
2012-06-16 19:01:25 +00:00
|
|
|
|
2015-08-18 11:10:56 +00:00
|
|
|
clk_disable(bank->dbck);
|
2011-11-23 21:33:28 +00:00
|
|
|
bank->dbck_enabled = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-26 21:42:23 +00:00
|
|
|
/**
|
2014-06-27 20:17:37 +00:00
|
|
|
* omap2_set_gpio_debounce - low level gpio debounce time
|
2010-05-26 21:42:23 +00:00
|
|
|
* @bank: the gpio bank we're acting upon
|
2015-03-23 12:18:25 +00:00
|
|
|
* @offset: the gpio number on this @bank
|
2010-05-26 21:42:23 +00:00
|
|
|
* @debounce: debounce time to use
|
|
|
|
*
|
2015-08-18 11:10:54 +00:00
|
|
|
* OMAP's debounce time is in 31us steps
|
|
|
|
* <debounce time> = (GPIO_DEBOUNCINGTIME[7:0].DEBOUNCETIME + 1) x 31
|
|
|
|
* so we need to convert and round up to the closest unit.
|
2017-04-24 22:56:50 +00:00
|
|
|
*
|
|
|
|
* Return: 0 on success, negative error otherwise.
|
2010-05-26 21:42:23 +00:00
|
|
|
*/
|
2017-04-24 22:56:50 +00:00
|
|
|
static int omap2_set_gpio_debounce(struct gpio_bank *bank, unsigned offset,
|
|
|
|
unsigned debounce)
|
2010-05-26 21:42:23 +00:00
|
|
|
{
|
|
|
|
u32 val;
|
|
|
|
u32 l;
|
2015-08-18 11:10:54 +00:00
|
|
|
bool enable = !!debounce;
|
2010-05-26 21:42:23 +00:00
|
|
|
|
2010-12-08 00:26:57 +00:00
|
|
|
if (!bank->dbck_flag)
|
2017-04-24 22:56:50 +00:00
|
|
|
return -ENOTSUPP;
|
2010-12-08 00:26:57 +00:00
|
|
|
|
2015-08-18 11:10:54 +00:00
|
|
|
if (enable) {
|
|
|
|
debounce = DIV_ROUND_UP(debounce, 31) - 1;
|
2017-04-24 22:56:50 +00:00
|
|
|
if ((debounce & OMAP4_GPIO_DEBOUNCINGTIME_MASK) != debounce)
|
|
|
|
return -EINVAL;
|
2015-08-18 11:10:54 +00:00
|
|
|
}
|
2010-05-26 21:42:23 +00:00
|
|
|
|
2015-03-23 12:18:25 +00:00
|
|
|
l = BIT(offset);
|
2010-05-26 21:42:23 +00:00
|
|
|
|
2015-08-18 11:10:56 +00:00
|
|
|
clk_enable(bank->dbck);
|
2019-06-10 17:11:03 +00:00
|
|
|
writel_relaxed(debounce, bank->base + bank->regs->debounce);
|
2010-05-26 21:42:23 +00:00
|
|
|
|
2019-06-10 17:10:55 +00:00
|
|
|
val = omap_gpio_rmw(bank->base + bank->regs->debounce_en, l, enable);
|
2010-06-09 10:53:07 +00:00
|
|
|
bank->dbck_enable_mask = val;
|
2010-05-26 21:42:23 +00:00
|
|
|
|
2015-08-18 11:10:56 +00:00
|
|
|
clk_disable(bank->dbck);
|
2011-11-23 22:28:54 +00:00
|
|
|
/*
|
|
|
|
* Enable debounce clock per module.
|
|
|
|
* This call is mandatory because in omap_gpio_request() when
|
|
|
|
* *_runtime_get_sync() is called, _gpio_dbck_enable() within
|
|
|
|
* runtime callbck fails to turn on dbck because dbck_enable_mask
|
|
|
|
* used within _gpio_dbck_enable() is still not initialized at
|
|
|
|
* that point. Therefore we have to enable dbck here.
|
|
|
|
*/
|
2014-06-27 20:17:37 +00:00
|
|
|
omap_gpio_dbck_enable(bank);
|
2011-09-09 13:38:58 +00:00
|
|
|
if (bank->dbck_enable_mask) {
|
|
|
|
bank->context.debounce = debounce;
|
|
|
|
bank->context.debounce_en = val;
|
|
|
|
}
|
2017-04-24 22:56:50 +00:00
|
|
|
|
|
|
|
return 0;
|
2010-05-26 21:42:23 +00:00
|
|
|
}
|
|
|
|
|
gpio/omap: fix off-mode bug: clear debounce settings on free/reset
This change was originally titled "gpio/omap: fix off-mode bug: clear debounce
clock enable mask on free/reset". The title has been updated slightly to
reflect (what should be) the final fix.
When a GPIO is freed or shutdown, we need to ensure that any debounce settings
are cleared and if the GPIO is the only GPIO in the bank that is currently
using debounce, then disable the debounce clock as well to save power.
Currently, the debounce settings are not cleared on a GPIO free or shutdown and
so during a context restore on subsequent off-mode transition, the previous
debounce values are restored from the shadow copies (bank->context.debounce*)
leading to mismatch state between driver state and hardware state.
This was discovered when board code was doing
gpio_request_one()
gpio_set_debounce()
gpio_free()
which was leaving the GPIO debounce settings in a confused state. If that GPIO
bank is subsequently used with off-mode enabled, bogus state would be restored,
leaving GPIO debounce enabled which then prevented the CORE powerdomain from
transitioning.
To fix this, introduce a new function called _clear_gpio_debounce() to clear
any debounce settings when the GPIO is freed or shutdown. If this GPIO is the
last debounce-enabled GPIO in the bank, the debounce will also be cut.
Please note that we cannot use _gpio_dbck_disable() to disable the debounce
clock because this has been specifically created for the gpio suspend path
and is intended to shutdown the debounce clock while debounce is enabled.
Special thanks to Kevin Hilman for root causing the bug. This fix is a
collaborative effort with inputs from Kevin Hilman, Grazvydas Ignotas and
Santosh Shilimkar.
Testing:
- This has been unit tested on an OMAP3430 Beagle board, by requesting a gpio,
enabling debounce and then freeing the gpio and checking the register
contents, the saved register context and the debounce clock state.
- Kevin Hilman tested on 37xx/EVM board which configures GPIO debounce for the
ads7846 touchscreen in its board file using the above sequence, and so was
failing off-mode tests in dynamic idle. Verified that off-mode tests are
passing with this patch.
V5 changes:
- Corrected author
Reported-by: Paul Walmsley <paul@pwsan.com>
Cc: Igor Grinberg <grinberg@compulab.co.il>
Cc: Grazvydas Ignotas <notasas@gmail.com>
Cc: Jon Hunter <jon-hunter@ti.com>
Signed-off-by: Jon Hunter <jon-hunter@ti.com>
Reviewed-by: Kevin Hilman <khilman@ti.com>
Tested-by: Kevin Hilman <khilman@ti.com>
Acked-by: Santosh Shilimkar <santosh.shilimkar@ti.com>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2012-10-26 19:26:04 +00:00
|
|
|
/**
|
2014-06-27 20:17:37 +00:00
|
|
|
* omap_clear_gpio_debounce - clear debounce settings for a gpio
|
gpio/omap: fix off-mode bug: clear debounce settings on free/reset
This change was originally titled "gpio/omap: fix off-mode bug: clear debounce
clock enable mask on free/reset". The title has been updated slightly to
reflect (what should be) the final fix.
When a GPIO is freed or shutdown, we need to ensure that any debounce settings
are cleared and if the GPIO is the only GPIO in the bank that is currently
using debounce, then disable the debounce clock as well to save power.
Currently, the debounce settings are not cleared on a GPIO free or shutdown and
so during a context restore on subsequent off-mode transition, the previous
debounce values are restored from the shadow copies (bank->context.debounce*)
leading to mismatch state between driver state and hardware state.
This was discovered when board code was doing
gpio_request_one()
gpio_set_debounce()
gpio_free()
which was leaving the GPIO debounce settings in a confused state. If that GPIO
bank is subsequently used with off-mode enabled, bogus state would be restored,
leaving GPIO debounce enabled which then prevented the CORE powerdomain from
transitioning.
To fix this, introduce a new function called _clear_gpio_debounce() to clear
any debounce settings when the GPIO is freed or shutdown. If this GPIO is the
last debounce-enabled GPIO in the bank, the debounce will also be cut.
Please note that we cannot use _gpio_dbck_disable() to disable the debounce
clock because this has been specifically created for the gpio suspend path
and is intended to shutdown the debounce clock while debounce is enabled.
Special thanks to Kevin Hilman for root causing the bug. This fix is a
collaborative effort with inputs from Kevin Hilman, Grazvydas Ignotas and
Santosh Shilimkar.
Testing:
- This has been unit tested on an OMAP3430 Beagle board, by requesting a gpio,
enabling debounce and then freeing the gpio and checking the register
contents, the saved register context and the debounce clock state.
- Kevin Hilman tested on 37xx/EVM board which configures GPIO debounce for the
ads7846 touchscreen in its board file using the above sequence, and so was
failing off-mode tests in dynamic idle. Verified that off-mode tests are
passing with this patch.
V5 changes:
- Corrected author
Reported-by: Paul Walmsley <paul@pwsan.com>
Cc: Igor Grinberg <grinberg@compulab.co.il>
Cc: Grazvydas Ignotas <notasas@gmail.com>
Cc: Jon Hunter <jon-hunter@ti.com>
Signed-off-by: Jon Hunter <jon-hunter@ti.com>
Reviewed-by: Kevin Hilman <khilman@ti.com>
Tested-by: Kevin Hilman <khilman@ti.com>
Acked-by: Santosh Shilimkar <santosh.shilimkar@ti.com>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2012-10-26 19:26:04 +00:00
|
|
|
* @bank: the gpio bank we're acting upon
|
2015-03-23 12:18:25 +00:00
|
|
|
* @offset: the gpio number on this @bank
|
gpio/omap: fix off-mode bug: clear debounce settings on free/reset
This change was originally titled "gpio/omap: fix off-mode bug: clear debounce
clock enable mask on free/reset". The title has been updated slightly to
reflect (what should be) the final fix.
When a GPIO is freed or shutdown, we need to ensure that any debounce settings
are cleared and if the GPIO is the only GPIO in the bank that is currently
using debounce, then disable the debounce clock as well to save power.
Currently, the debounce settings are not cleared on a GPIO free or shutdown and
so during a context restore on subsequent off-mode transition, the previous
debounce values are restored from the shadow copies (bank->context.debounce*)
leading to mismatch state between driver state and hardware state.
This was discovered when board code was doing
gpio_request_one()
gpio_set_debounce()
gpio_free()
which was leaving the GPIO debounce settings in a confused state. If that GPIO
bank is subsequently used with off-mode enabled, bogus state would be restored,
leaving GPIO debounce enabled which then prevented the CORE powerdomain from
transitioning.
To fix this, introduce a new function called _clear_gpio_debounce() to clear
any debounce settings when the GPIO is freed or shutdown. If this GPIO is the
last debounce-enabled GPIO in the bank, the debounce will also be cut.
Please note that we cannot use _gpio_dbck_disable() to disable the debounce
clock because this has been specifically created for the gpio suspend path
and is intended to shutdown the debounce clock while debounce is enabled.
Special thanks to Kevin Hilman for root causing the bug. This fix is a
collaborative effort with inputs from Kevin Hilman, Grazvydas Ignotas and
Santosh Shilimkar.
Testing:
- This has been unit tested on an OMAP3430 Beagle board, by requesting a gpio,
enabling debounce and then freeing the gpio and checking the register
contents, the saved register context and the debounce clock state.
- Kevin Hilman tested on 37xx/EVM board which configures GPIO debounce for the
ads7846 touchscreen in its board file using the above sequence, and so was
failing off-mode tests in dynamic idle. Verified that off-mode tests are
passing with this patch.
V5 changes:
- Corrected author
Reported-by: Paul Walmsley <paul@pwsan.com>
Cc: Igor Grinberg <grinberg@compulab.co.il>
Cc: Grazvydas Ignotas <notasas@gmail.com>
Cc: Jon Hunter <jon-hunter@ti.com>
Signed-off-by: Jon Hunter <jon-hunter@ti.com>
Reviewed-by: Kevin Hilman <khilman@ti.com>
Tested-by: Kevin Hilman <khilman@ti.com>
Acked-by: Santosh Shilimkar <santosh.shilimkar@ti.com>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2012-10-26 19:26:04 +00:00
|
|
|
*
|
|
|
|
* If a gpio is using debounce, then clear the debounce enable bit and if
|
|
|
|
* this is the only gpio in this bank using debounce, then clear the debounce
|
|
|
|
* time too. The debounce clock will also be disabled when calling this function
|
|
|
|
* if this is the only gpio in the bank using debounce.
|
|
|
|
*/
|
2015-03-23 12:18:25 +00:00
|
|
|
static void omap_clear_gpio_debounce(struct gpio_bank *bank, unsigned offset)
|
gpio/omap: fix off-mode bug: clear debounce settings on free/reset
This change was originally titled "gpio/omap: fix off-mode bug: clear debounce
clock enable mask on free/reset". The title has been updated slightly to
reflect (what should be) the final fix.
When a GPIO is freed or shutdown, we need to ensure that any debounce settings
are cleared and if the GPIO is the only GPIO in the bank that is currently
using debounce, then disable the debounce clock as well to save power.
Currently, the debounce settings are not cleared on a GPIO free or shutdown and
so during a context restore on subsequent off-mode transition, the previous
debounce values are restored from the shadow copies (bank->context.debounce*)
leading to mismatch state between driver state and hardware state.
This was discovered when board code was doing
gpio_request_one()
gpio_set_debounce()
gpio_free()
which was leaving the GPIO debounce settings in a confused state. If that GPIO
bank is subsequently used with off-mode enabled, bogus state would be restored,
leaving GPIO debounce enabled which then prevented the CORE powerdomain from
transitioning.
To fix this, introduce a new function called _clear_gpio_debounce() to clear
any debounce settings when the GPIO is freed or shutdown. If this GPIO is the
last debounce-enabled GPIO in the bank, the debounce will also be cut.
Please note that we cannot use _gpio_dbck_disable() to disable the debounce
clock because this has been specifically created for the gpio suspend path
and is intended to shutdown the debounce clock while debounce is enabled.
Special thanks to Kevin Hilman for root causing the bug. This fix is a
collaborative effort with inputs from Kevin Hilman, Grazvydas Ignotas and
Santosh Shilimkar.
Testing:
- This has been unit tested on an OMAP3430 Beagle board, by requesting a gpio,
enabling debounce and then freeing the gpio and checking the register
contents, the saved register context and the debounce clock state.
- Kevin Hilman tested on 37xx/EVM board which configures GPIO debounce for the
ads7846 touchscreen in its board file using the above sequence, and so was
failing off-mode tests in dynamic idle. Verified that off-mode tests are
passing with this patch.
V5 changes:
- Corrected author
Reported-by: Paul Walmsley <paul@pwsan.com>
Cc: Igor Grinberg <grinberg@compulab.co.il>
Cc: Grazvydas Ignotas <notasas@gmail.com>
Cc: Jon Hunter <jon-hunter@ti.com>
Signed-off-by: Jon Hunter <jon-hunter@ti.com>
Reviewed-by: Kevin Hilman <khilman@ti.com>
Tested-by: Kevin Hilman <khilman@ti.com>
Acked-by: Santosh Shilimkar <santosh.shilimkar@ti.com>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2012-10-26 19:26:04 +00:00
|
|
|
{
|
2015-03-23 12:18:25 +00:00
|
|
|
u32 gpio_bit = BIT(offset);
|
gpio/omap: fix off-mode bug: clear debounce settings on free/reset
This change was originally titled "gpio/omap: fix off-mode bug: clear debounce
clock enable mask on free/reset". The title has been updated slightly to
reflect (what should be) the final fix.
When a GPIO is freed or shutdown, we need to ensure that any debounce settings
are cleared and if the GPIO is the only GPIO in the bank that is currently
using debounce, then disable the debounce clock as well to save power.
Currently, the debounce settings are not cleared on a GPIO free or shutdown and
so during a context restore on subsequent off-mode transition, the previous
debounce values are restored from the shadow copies (bank->context.debounce*)
leading to mismatch state between driver state and hardware state.
This was discovered when board code was doing
gpio_request_one()
gpio_set_debounce()
gpio_free()
which was leaving the GPIO debounce settings in a confused state. If that GPIO
bank is subsequently used with off-mode enabled, bogus state would be restored,
leaving GPIO debounce enabled which then prevented the CORE powerdomain from
transitioning.
To fix this, introduce a new function called _clear_gpio_debounce() to clear
any debounce settings when the GPIO is freed or shutdown. If this GPIO is the
last debounce-enabled GPIO in the bank, the debounce will also be cut.
Please note that we cannot use _gpio_dbck_disable() to disable the debounce
clock because this has been specifically created for the gpio suspend path
and is intended to shutdown the debounce clock while debounce is enabled.
Special thanks to Kevin Hilman for root causing the bug. This fix is a
collaborative effort with inputs from Kevin Hilman, Grazvydas Ignotas and
Santosh Shilimkar.
Testing:
- This has been unit tested on an OMAP3430 Beagle board, by requesting a gpio,
enabling debounce and then freeing the gpio and checking the register
contents, the saved register context and the debounce clock state.
- Kevin Hilman tested on 37xx/EVM board which configures GPIO debounce for the
ads7846 touchscreen in its board file using the above sequence, and so was
failing off-mode tests in dynamic idle. Verified that off-mode tests are
passing with this patch.
V5 changes:
- Corrected author
Reported-by: Paul Walmsley <paul@pwsan.com>
Cc: Igor Grinberg <grinberg@compulab.co.il>
Cc: Grazvydas Ignotas <notasas@gmail.com>
Cc: Jon Hunter <jon-hunter@ti.com>
Signed-off-by: Jon Hunter <jon-hunter@ti.com>
Reviewed-by: Kevin Hilman <khilman@ti.com>
Tested-by: Kevin Hilman <khilman@ti.com>
Acked-by: Santosh Shilimkar <santosh.shilimkar@ti.com>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2012-10-26 19:26:04 +00:00
|
|
|
|
|
|
|
if (!bank->dbck_flag)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!(bank->dbck_enable_mask & gpio_bit))
|
|
|
|
return;
|
|
|
|
|
|
|
|
bank->dbck_enable_mask &= ~gpio_bit;
|
|
|
|
bank->context.debounce_en &= ~gpio_bit;
|
2013-11-16 00:01:04 +00:00
|
|
|
writel_relaxed(bank->context.debounce_en,
|
gpio/omap: fix off-mode bug: clear debounce settings on free/reset
This change was originally titled "gpio/omap: fix off-mode bug: clear debounce
clock enable mask on free/reset". The title has been updated slightly to
reflect (what should be) the final fix.
When a GPIO is freed or shutdown, we need to ensure that any debounce settings
are cleared and if the GPIO is the only GPIO in the bank that is currently
using debounce, then disable the debounce clock as well to save power.
Currently, the debounce settings are not cleared on a GPIO free or shutdown and
so during a context restore on subsequent off-mode transition, the previous
debounce values are restored from the shadow copies (bank->context.debounce*)
leading to mismatch state between driver state and hardware state.
This was discovered when board code was doing
gpio_request_one()
gpio_set_debounce()
gpio_free()
which was leaving the GPIO debounce settings in a confused state. If that GPIO
bank is subsequently used with off-mode enabled, bogus state would be restored,
leaving GPIO debounce enabled which then prevented the CORE powerdomain from
transitioning.
To fix this, introduce a new function called _clear_gpio_debounce() to clear
any debounce settings when the GPIO is freed or shutdown. If this GPIO is the
last debounce-enabled GPIO in the bank, the debounce will also be cut.
Please note that we cannot use _gpio_dbck_disable() to disable the debounce
clock because this has been specifically created for the gpio suspend path
and is intended to shutdown the debounce clock while debounce is enabled.
Special thanks to Kevin Hilman for root causing the bug. This fix is a
collaborative effort with inputs from Kevin Hilman, Grazvydas Ignotas and
Santosh Shilimkar.
Testing:
- This has been unit tested on an OMAP3430 Beagle board, by requesting a gpio,
enabling debounce and then freeing the gpio and checking the register
contents, the saved register context and the debounce clock state.
- Kevin Hilman tested on 37xx/EVM board which configures GPIO debounce for the
ads7846 touchscreen in its board file using the above sequence, and so was
failing off-mode tests in dynamic idle. Verified that off-mode tests are
passing with this patch.
V5 changes:
- Corrected author
Reported-by: Paul Walmsley <paul@pwsan.com>
Cc: Igor Grinberg <grinberg@compulab.co.il>
Cc: Grazvydas Ignotas <notasas@gmail.com>
Cc: Jon Hunter <jon-hunter@ti.com>
Signed-off-by: Jon Hunter <jon-hunter@ti.com>
Reviewed-by: Kevin Hilman <khilman@ti.com>
Tested-by: Kevin Hilman <khilman@ti.com>
Acked-by: Santosh Shilimkar <santosh.shilimkar@ti.com>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2012-10-26 19:26:04 +00:00
|
|
|
bank->base + bank->regs->debounce_en);
|
|
|
|
|
|
|
|
if (!bank->dbck_enable_mask) {
|
|
|
|
bank->context.debounce = 0;
|
2013-11-16 00:01:04 +00:00
|
|
|
writel_relaxed(bank->context.debounce, bank->base +
|
gpio/omap: fix off-mode bug: clear debounce settings on free/reset
This change was originally titled "gpio/omap: fix off-mode bug: clear debounce
clock enable mask on free/reset". The title has been updated slightly to
reflect (what should be) the final fix.
When a GPIO is freed or shutdown, we need to ensure that any debounce settings
are cleared and if the GPIO is the only GPIO in the bank that is currently
using debounce, then disable the debounce clock as well to save power.
Currently, the debounce settings are not cleared on a GPIO free or shutdown and
so during a context restore on subsequent off-mode transition, the previous
debounce values are restored from the shadow copies (bank->context.debounce*)
leading to mismatch state between driver state and hardware state.
This was discovered when board code was doing
gpio_request_one()
gpio_set_debounce()
gpio_free()
which was leaving the GPIO debounce settings in a confused state. If that GPIO
bank is subsequently used with off-mode enabled, bogus state would be restored,
leaving GPIO debounce enabled which then prevented the CORE powerdomain from
transitioning.
To fix this, introduce a new function called _clear_gpio_debounce() to clear
any debounce settings when the GPIO is freed or shutdown. If this GPIO is the
last debounce-enabled GPIO in the bank, the debounce will also be cut.
Please note that we cannot use _gpio_dbck_disable() to disable the debounce
clock because this has been specifically created for the gpio suspend path
and is intended to shutdown the debounce clock while debounce is enabled.
Special thanks to Kevin Hilman for root causing the bug. This fix is a
collaborative effort with inputs from Kevin Hilman, Grazvydas Ignotas and
Santosh Shilimkar.
Testing:
- This has been unit tested on an OMAP3430 Beagle board, by requesting a gpio,
enabling debounce and then freeing the gpio and checking the register
contents, the saved register context and the debounce clock state.
- Kevin Hilman tested on 37xx/EVM board which configures GPIO debounce for the
ads7846 touchscreen in its board file using the above sequence, and so was
failing off-mode tests in dynamic idle. Verified that off-mode tests are
passing with this patch.
V5 changes:
- Corrected author
Reported-by: Paul Walmsley <paul@pwsan.com>
Cc: Igor Grinberg <grinberg@compulab.co.il>
Cc: Grazvydas Ignotas <notasas@gmail.com>
Cc: Jon Hunter <jon-hunter@ti.com>
Signed-off-by: Jon Hunter <jon-hunter@ti.com>
Reviewed-by: Kevin Hilman <khilman@ti.com>
Tested-by: Kevin Hilman <khilman@ti.com>
Acked-by: Santosh Shilimkar <santosh.shilimkar@ti.com>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2012-10-26 19:26:04 +00:00
|
|
|
bank->regs->debounce);
|
2015-08-18 11:10:56 +00:00
|
|
|
clk_disable(bank->dbck);
|
gpio/omap: fix off-mode bug: clear debounce settings on free/reset
This change was originally titled "gpio/omap: fix off-mode bug: clear debounce
clock enable mask on free/reset". The title has been updated slightly to
reflect (what should be) the final fix.
When a GPIO is freed or shutdown, we need to ensure that any debounce settings
are cleared and if the GPIO is the only GPIO in the bank that is currently
using debounce, then disable the debounce clock as well to save power.
Currently, the debounce settings are not cleared on a GPIO free or shutdown and
so during a context restore on subsequent off-mode transition, the previous
debounce values are restored from the shadow copies (bank->context.debounce*)
leading to mismatch state between driver state and hardware state.
This was discovered when board code was doing
gpio_request_one()
gpio_set_debounce()
gpio_free()
which was leaving the GPIO debounce settings in a confused state. If that GPIO
bank is subsequently used with off-mode enabled, bogus state would be restored,
leaving GPIO debounce enabled which then prevented the CORE powerdomain from
transitioning.
To fix this, introduce a new function called _clear_gpio_debounce() to clear
any debounce settings when the GPIO is freed or shutdown. If this GPIO is the
last debounce-enabled GPIO in the bank, the debounce will also be cut.
Please note that we cannot use _gpio_dbck_disable() to disable the debounce
clock because this has been specifically created for the gpio suspend path
and is intended to shutdown the debounce clock while debounce is enabled.
Special thanks to Kevin Hilman for root causing the bug. This fix is a
collaborative effort with inputs from Kevin Hilman, Grazvydas Ignotas and
Santosh Shilimkar.
Testing:
- This has been unit tested on an OMAP3430 Beagle board, by requesting a gpio,
enabling debounce and then freeing the gpio and checking the register
contents, the saved register context and the debounce clock state.
- Kevin Hilman tested on 37xx/EVM board which configures GPIO debounce for the
ads7846 touchscreen in its board file using the above sequence, and so was
failing off-mode tests in dynamic idle. Verified that off-mode tests are
passing with this patch.
V5 changes:
- Corrected author
Reported-by: Paul Walmsley <paul@pwsan.com>
Cc: Igor Grinberg <grinberg@compulab.co.il>
Cc: Grazvydas Ignotas <notasas@gmail.com>
Cc: Jon Hunter <jon-hunter@ti.com>
Signed-off-by: Jon Hunter <jon-hunter@ti.com>
Reviewed-by: Kevin Hilman <khilman@ti.com>
Tested-by: Kevin Hilman <khilman@ti.com>
Acked-by: Santosh Shilimkar <santosh.shilimkar@ti.com>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2012-10-26 19:26:04 +00:00
|
|
|
bank->dbck_enabled = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-25 22:43:18 +00:00
|
|
|
/*
|
|
|
|
* Off mode wake-up capable GPIOs in bank(s) that are in the wakeup domain.
|
|
|
|
* See TRM section for GPIO for "Wake-Up Generation" for the list of GPIOs
|
|
|
|
* in wakeup domain. If bank->non_wakeup_gpios is not configured, assume none
|
|
|
|
* are capable waking up the system from off mode.
|
|
|
|
*/
|
|
|
|
static bool omap_gpio_is_off_wakeup_capable(struct gpio_bank *bank, u32 gpio_mask)
|
|
|
|
{
|
|
|
|
u32 no_wake = bank->non_wakeup_gpios;
|
|
|
|
|
|
|
|
if (no_wake)
|
|
|
|
return !!(~no_wake & gpio_mask);
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-06-27 20:17:37 +00:00
|
|
|
static inline void omap_set_gpio_trigger(struct gpio_bank *bank, int gpio,
|
gpio/omap: fix trigger type to unsigned
The GPIO trigger parameter is of type unsigned.
enum {
IRQ_TYPE_NONE = 0x00000000,
IRQ_TYPE_EDGE_RISING = 0x00000001,
IRQ_TYPE_EDGE_FALLING = 0x00000002,
IRQ_TYPE_EDGE_BOTH = (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING),
IRQ_TYPE_LEVEL_HIGH = 0x00000004,
IRQ_TYPE_LEVEL_LOW = 0x00000008,
IRQ_TYPE_LEVEL_MASK = (IRQ_TYPE_LEVEL_LOW | IRQ_TYPE_LEVEL_HIGH),
IRQ_TYPE_SENSE_MASK = 0x0000000f,
IRQ_TYPE_PROBE = 0x00000010,
...
};
Even though gpio_irq_type(struct irq_data *d, unsigned type) has the right type
of parameter, the subsequent called functions set_gpio_triggering() and
set_gpio_trigger() wrongly makes it signed integer. Fix this.
Signed-off-by: Tarun Kanti DebBarma <tarun.kanti@ti.com>
Reviewed-by: Santosh Shilimkar <santosh.shilimkar@ti.com>
Acked-by: Felipe Balbi <balbi@ti.com>
Reviewed-by: Kevin Hilman <khilman@ti.com>
Signed-off-by: Kevin Hilman <khilman@ti.com>
2011-11-25 10:11:06 +00:00
|
|
|
unsigned trigger)
|
2005-07-10 18:58:15 +00:00
|
|
|
{
|
2006-12-07 01:13:52 +00:00
|
|
|
void __iomem *base = bank->base;
|
2014-04-27 00:00:49 +00:00
|
|
|
u32 gpio_bit = BIT(gpio);
|
2005-09-07 16:20:26 +00:00
|
|
|
|
2019-06-10 17:10:55 +00:00
|
|
|
omap_gpio_rmw(base + bank->regs->leveldetect0, gpio_bit,
|
2014-06-27 20:17:37 +00:00
|
|
|
trigger & IRQ_TYPE_LEVEL_LOW);
|
2019-06-10 17:10:55 +00:00
|
|
|
omap_gpio_rmw(base + bank->regs->leveldetect1, gpio_bit,
|
2014-06-27 20:17:37 +00:00
|
|
|
trigger & IRQ_TYPE_LEVEL_HIGH);
|
2019-04-08 19:46:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We need the edge detection enabled for to allow the GPIO block
|
|
|
|
* to be woken from idle state. Set the appropriate edge detection
|
|
|
|
* in addition to the level detection.
|
|
|
|
*/
|
2019-06-10 17:10:55 +00:00
|
|
|
omap_gpio_rmw(base + bank->regs->risingdetect, gpio_bit,
|
2019-04-08 19:46:53 +00:00
|
|
|
trigger & (IRQ_TYPE_EDGE_RISING | IRQ_TYPE_LEVEL_HIGH));
|
2019-06-10 17:10:55 +00:00
|
|
|
omap_gpio_rmw(base + bank->regs->fallingdetect, gpio_bit,
|
2019-04-08 19:46:53 +00:00
|
|
|
trigger & (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_LEVEL_LOW));
|
2011-09-13 09:32:14 +00:00
|
|
|
|
2011-11-15 07:22:38 +00:00
|
|
|
bank->context.leveldetect0 =
|
2013-11-16 00:01:04 +00:00
|
|
|
readl_relaxed(bank->base + bank->regs->leveldetect0);
|
2011-11-15 07:22:38 +00:00
|
|
|
bank->context.leveldetect1 =
|
2013-11-16 00:01:04 +00:00
|
|
|
readl_relaxed(bank->base + bank->regs->leveldetect1);
|
2011-11-15 07:22:38 +00:00
|
|
|
bank->context.risingdetect =
|
2013-11-16 00:01:04 +00:00
|
|
|
readl_relaxed(bank->base + bank->regs->risingdetect);
|
2011-11-15 07:22:38 +00:00
|
|
|
bank->context.fallingdetect =
|
2013-11-16 00:01:04 +00:00
|
|
|
readl_relaxed(bank->base + bank->regs->fallingdetect);
|
2011-11-15 07:22:38 +00:00
|
|
|
|
2019-06-10 17:10:54 +00:00
|
|
|
bank->level_mask = bank->context.leveldetect0 |
|
|
|
|
bank->context.leveldetect1;
|
2011-09-13 09:32:14 +00:00
|
|
|
|
2011-06-15 20:40:45 +00:00
|
|
|
/* This part needs to be executed always for OMAP{34xx, 44xx} */
|
2019-03-25 22:43:18 +00:00
|
|
|
if (!bank->regs->irqctrl && !omap_gpio_is_off_wakeup_capable(bank, gpio)) {
|
2009-06-24 17:13:39 +00:00
|
|
|
/*
|
|
|
|
* Log the edge gpio and manually trigger the IRQ
|
|
|
|
* after resume if the input level changes
|
|
|
|
* to avoid irq lost during PER RET/OFF mode
|
|
|
|
* Applies for omap2 non-wakeup gpio and all omap3 gpios
|
|
|
|
*/
|
|
|
|
if (trigger & IRQ_TYPE_EDGE_BOTH)
|
2006-12-07 01:13:52 +00:00
|
|
|
bank->enabled_non_wakeup_gpios |= gpio_bit;
|
|
|
|
else
|
|
|
|
bank->enabled_non_wakeup_gpios &= ~gpio_bit;
|
|
|
|
}
|
2005-09-07 16:20:26 +00:00
|
|
|
}
|
|
|
|
|
omap: gpio: Simultaneously requested rising and falling edge
Some chips, namely any OMAP1 chips using METHOD_MPUIO,
OMAP15xx and OMAP7xx, cannot be setup to respond to on-chip GPIO
interrupts in both rising and falling edge directions -- they can
only respond to one direction or the other, depending on how the
ICR is configured.
Additionally, current code forces rising edge detection if both
flags are specified:
if (trigger & IRQ_TYPE_EDGE_RISING)
l |= 1 << gpio;
else if (trigger & IRQ_TYPE_EDGE_FALLING)
l &= ~(1 << gpio);
else
goto bad;
This change implements a toggle function that will modify the ICR
to flip the direction of interrupt for IRQs that are requested with
both rising and falling flags. The toggle function is not called
for chips and GPIOs it does not apply to through the use of a flip_mask
that's added on a per-bank basis. The mask is only set for those
GPIOs where a toggle is necessary. Edge detection starts out the
same as above with FALLING mode first.
The toggle happens on EACH interrupt; without it, we have the
following sequence of actions on GPIO transition:
ICR GPIO Result
0x1 0 -> 1 (rising) Interrupt
0x1 1 -> 0 (falling) No interrupt
(set ICR to 0x0 manually)
0x0 0 -> 1 (rising) No interrupt
0x0 1 -> 0 (falling) Interrupt
That is, with the ICR set to 1 for a gpio, only rising edge interrupts
are caught, and with it set to 0, only falling edge interrupts are
caught. If we add in the toggle, we get this:
ICR GPIO Result
0x1 0 -> 1 (rising) Interrupt (ICR set to 0x0)
0x0 1 -> 0 (falling) Interrupt (ICR set to 0x1)
0x1 0 -> 1 ...
so, both rising and falling are caught, per the request for both
(IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING).
Signed-off-by: Cory Maccarrone <darkstar6262@gmail.com>
Acked-by: Kevin Hilman <khilman@deeprootsystems.com>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2010-01-08 18:29:04 +00:00
|
|
|
/*
|
|
|
|
* This only applies to chips that can't do both rising and falling edge
|
|
|
|
* detection at once. For all other chips, this function is a noop.
|
|
|
|
*/
|
2014-06-27 20:17:37 +00:00
|
|
|
static void omap_toggle_gpio_edge_triggering(struct gpio_bank *bank, int gpio)
|
omap: gpio: Simultaneously requested rising and falling edge
Some chips, namely any OMAP1 chips using METHOD_MPUIO,
OMAP15xx and OMAP7xx, cannot be setup to respond to on-chip GPIO
interrupts in both rising and falling edge directions -- they can
only respond to one direction or the other, depending on how the
ICR is configured.
Additionally, current code forces rising edge detection if both
flags are specified:
if (trigger & IRQ_TYPE_EDGE_RISING)
l |= 1 << gpio;
else if (trigger & IRQ_TYPE_EDGE_FALLING)
l &= ~(1 << gpio);
else
goto bad;
This change implements a toggle function that will modify the ICR
to flip the direction of interrupt for IRQs that are requested with
both rising and falling flags. The toggle function is not called
for chips and GPIOs it does not apply to through the use of a flip_mask
that's added on a per-bank basis. The mask is only set for those
GPIOs where a toggle is necessary. Edge detection starts out the
same as above with FALLING mode first.
The toggle happens on EACH interrupt; without it, we have the
following sequence of actions on GPIO transition:
ICR GPIO Result
0x1 0 -> 1 (rising) Interrupt
0x1 1 -> 0 (falling) No interrupt
(set ICR to 0x0 manually)
0x0 0 -> 1 (rising) No interrupt
0x0 1 -> 0 (falling) Interrupt
That is, with the ICR set to 1 for a gpio, only rising edge interrupts
are caught, and with it set to 0, only falling edge interrupts are
caught. If we add in the toggle, we get this:
ICR GPIO Result
0x1 0 -> 1 (rising) Interrupt (ICR set to 0x0)
0x0 1 -> 0 (falling) Interrupt (ICR set to 0x1)
0x1 0 -> 1 ...
so, both rising and falling are caught, per the request for both
(IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING).
Signed-off-by: Cory Maccarrone <darkstar6262@gmail.com>
Acked-by: Kevin Hilman <khilman@deeprootsystems.com>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2010-01-08 18:29:04 +00:00
|
|
|
{
|
2019-06-10 17:10:56 +00:00
|
|
|
if (IS_ENABLED(CONFIG_ARCH_OMAP1) && bank->regs->irqctrl) {
|
|
|
|
void __iomem *reg = bank->base + bank->regs->irqctrl;
|
2011-09-13 09:32:14 +00:00
|
|
|
|
2019-06-10 17:10:56 +00:00
|
|
|
writel_relaxed(readl_relaxed(reg) ^ BIT(gpio), reg);
|
|
|
|
}
|
omap: gpio: Simultaneously requested rising and falling edge
Some chips, namely any OMAP1 chips using METHOD_MPUIO,
OMAP15xx and OMAP7xx, cannot be setup to respond to on-chip GPIO
interrupts in both rising and falling edge directions -- they can
only respond to one direction or the other, depending on how the
ICR is configured.
Additionally, current code forces rising edge detection if both
flags are specified:
if (trigger & IRQ_TYPE_EDGE_RISING)
l |= 1 << gpio;
else if (trigger & IRQ_TYPE_EDGE_FALLING)
l &= ~(1 << gpio);
else
goto bad;
This change implements a toggle function that will modify the ICR
to flip the direction of interrupt for IRQs that are requested with
both rising and falling flags. The toggle function is not called
for chips and GPIOs it does not apply to through the use of a flip_mask
that's added on a per-bank basis. The mask is only set for those
GPIOs where a toggle is necessary. Edge detection starts out the
same as above with FALLING mode first.
The toggle happens on EACH interrupt; without it, we have the
following sequence of actions on GPIO transition:
ICR GPIO Result
0x1 0 -> 1 (rising) Interrupt
0x1 1 -> 0 (falling) No interrupt
(set ICR to 0x0 manually)
0x0 0 -> 1 (rising) No interrupt
0x0 1 -> 0 (falling) Interrupt
That is, with the ICR set to 1 for a gpio, only rising edge interrupts
are caught, and with it set to 0, only falling edge interrupts are
caught. If we add in the toggle, we get this:
ICR GPIO Result
0x1 0 -> 1 (rising) Interrupt (ICR set to 0x0)
0x0 1 -> 0 (falling) Interrupt (ICR set to 0x1)
0x1 0 -> 1 ...
so, both rising and falling are caught, per the request for both
(IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING).
Signed-off-by: Cory Maccarrone <darkstar6262@gmail.com>
Acked-by: Kevin Hilman <khilman@deeprootsystems.com>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2010-01-08 18:29:04 +00:00
|
|
|
}
|
|
|
|
|
2014-06-27 20:17:37 +00:00
|
|
|
static int omap_set_gpio_triggering(struct gpio_bank *bank, int gpio,
|
|
|
|
unsigned trigger)
|
2005-09-07 16:20:26 +00:00
|
|
|
{
|
|
|
|
void __iomem *reg = bank->base;
|
|
|
|
u32 l = 0;
|
2005-07-10 18:58:15 +00:00
|
|
|
|
2011-09-13 09:32:14 +00:00
|
|
|
if (bank->regs->leveldetect0 && bank->regs->wkup_en) {
|
2014-06-27 20:17:37 +00:00
|
|
|
omap_set_gpio_trigger(bank, gpio, trigger);
|
2011-09-13 09:32:14 +00:00
|
|
|
} else if (bank->regs->irqctrl) {
|
|
|
|
reg += bank->regs->irqctrl;
|
|
|
|
|
2013-11-16 00:01:04 +00:00
|
|
|
l = readl_relaxed(reg);
|
2010-04-05 11:38:06 +00:00
|
|
|
if ((trigger & IRQ_TYPE_SENSE_MASK) == IRQ_TYPE_EDGE_BOTH)
|
2014-04-27 00:00:49 +00:00
|
|
|
bank->toggle_mask |= BIT(gpio);
|
2008-07-27 03:23:31 +00:00
|
|
|
if (trigger & IRQ_TYPE_EDGE_RISING)
|
2014-04-27 00:00:49 +00:00
|
|
|
l |= BIT(gpio);
|
2008-07-27 03:23:31 +00:00
|
|
|
else if (trigger & IRQ_TYPE_EDGE_FALLING)
|
2014-04-27 00:00:49 +00:00
|
|
|
l &= ~(BIT(gpio));
|
2005-09-07 16:20:26 +00:00
|
|
|
else
|
2011-09-13 09:32:14 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2013-11-16 00:01:04 +00:00
|
|
|
writel_relaxed(l, reg);
|
2011-09-13 09:32:14 +00:00
|
|
|
} else if (bank->regs->edgectrl1) {
|
2005-07-10 18:58:15 +00:00
|
|
|
if (gpio & 0x08)
|
2011-09-13 09:32:14 +00:00
|
|
|
reg += bank->regs->edgectrl2;
|
2005-07-10 18:58:15 +00:00
|
|
|
else
|
2011-09-13 09:32:14 +00:00
|
|
|
reg += bank->regs->edgectrl1;
|
|
|
|
|
2005-07-10 18:58:15 +00:00
|
|
|
gpio &= 0x07;
|
2013-11-16 00:01:04 +00:00
|
|
|
l = readl_relaxed(reg);
|
2005-07-10 18:58:15 +00:00
|
|
|
l &= ~(3 << (gpio << 1));
|
2008-07-27 03:23:31 +00:00
|
|
|
if (trigger & IRQ_TYPE_EDGE_RISING)
|
2006-04-02 16:46:23 +00:00
|
|
|
l |= 2 << (gpio << 1);
|
2008-07-27 03:23:31 +00:00
|
|
|
if (trigger & IRQ_TYPE_EDGE_FALLING)
|
2014-04-27 00:00:49 +00:00
|
|
|
l |= BIT(gpio << 1);
|
2013-11-16 00:01:04 +00:00
|
|
|
writel_relaxed(l, reg);
|
2005-07-10 18:58:15 +00:00
|
|
|
}
|
2005-09-07 16:20:26 +00:00
|
|
|
return 0;
|
2005-07-10 18:58:15 +00:00
|
|
|
}
|
|
|
|
|
2014-06-27 20:17:37 +00:00
|
|
|
static void omap_enable_gpio_module(struct gpio_bank *bank, unsigned offset)
|
2013-09-25 00:36:54 +00:00
|
|
|
{
|
|
|
|
if (bank->regs->pinctrl) {
|
|
|
|
void __iomem *reg = bank->base + bank->regs->pinctrl;
|
|
|
|
|
|
|
|
/* Claim the pin for MPU */
|
2014-04-27 00:00:49 +00:00
|
|
|
writel_relaxed(readl_relaxed(reg) | (BIT(offset)), reg);
|
2013-09-25 00:36:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (bank->regs->ctrl && !BANK_USED(bank)) {
|
|
|
|
void __iomem *reg = bank->base + bank->regs->ctrl;
|
|
|
|
u32 ctrl;
|
|
|
|
|
2013-11-16 00:01:04 +00:00
|
|
|
ctrl = readl_relaxed(reg);
|
2013-09-25 00:36:54 +00:00
|
|
|
/* Module is enabled, clocks are not gated */
|
|
|
|
ctrl &= ~GPIO_MOD_CTRL_BIT;
|
2013-11-16 00:01:04 +00:00
|
|
|
writel_relaxed(ctrl, reg);
|
2013-09-25 00:36:54 +00:00
|
|
|
bank->context.ctrl = ctrl;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-27 20:17:37 +00:00
|
|
|
static void omap_disable_gpio_module(struct gpio_bank *bank, unsigned offset)
|
2013-09-25 00:36:54 +00:00
|
|
|
{
|
|
|
|
if (bank->regs->ctrl && !BANK_USED(bank)) {
|
|
|
|
void __iomem *reg = bank->base + bank->regs->ctrl;
|
|
|
|
u32 ctrl;
|
|
|
|
|
2013-11-16 00:01:04 +00:00
|
|
|
ctrl = readl_relaxed(reg);
|
2013-09-25 00:36:54 +00:00
|
|
|
/* Module is disabled, clocks are gated */
|
|
|
|
ctrl |= GPIO_MOD_CTRL_BIT;
|
2013-11-16 00:01:04 +00:00
|
|
|
writel_relaxed(ctrl, reg);
|
2013-09-25 00:36:54 +00:00
|
|
|
bank->context.ctrl = ctrl;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-23 12:18:23 +00:00
|
|
|
static int omap_gpio_is_input(struct gpio_bank *bank, unsigned offset)
|
2013-09-25 00:36:52 +00:00
|
|
|
{
|
|
|
|
void __iomem *reg = bank->base + bank->regs->direction;
|
|
|
|
|
2015-03-23 12:18:23 +00:00
|
|
|
return readl_relaxed(reg) & BIT(offset);
|
2013-09-25 00:36:52 +00:00
|
|
|
}
|
|
|
|
|
2015-03-23 12:18:26 +00:00
|
|
|
static void omap_gpio_init_irq(struct gpio_bank *bank, unsigned offset)
|
2015-01-16 22:50:50 +00:00
|
|
|
{
|
|
|
|
if (!LINE_USED(bank->mod_usage, offset)) {
|
|
|
|
omap_enable_gpio_module(bank, offset);
|
|
|
|
omap_set_gpio_direction(bank, offset, 1);
|
|
|
|
}
|
2015-03-23 12:18:26 +00:00
|
|
|
bank->irq_usage |= BIT(offset);
|
2015-01-16 22:50:50 +00:00
|
|
|
}
|
|
|
|
|
2014-06-27 20:17:37 +00:00
|
|
|
static int omap_gpio_irq_type(struct irq_data *d, unsigned type)
|
2005-07-10 18:58:15 +00:00
|
|
|
{
|
2014-06-27 20:17:37 +00:00
|
|
|
struct gpio_bank *bank = omap_irq_data_get_bank(d);
|
2005-09-07 16:20:26 +00:00
|
|
|
int retval;
|
2008-03-03 12:33:30 +00:00
|
|
|
unsigned long flags;
|
2015-03-23 12:18:29 +00:00
|
|
|
unsigned offset = d->hwirq;
|
2005-09-07 16:20:26 +00:00
|
|
|
|
2006-12-07 01:13:59 +00:00
|
|
|
if (type & ~IRQ_TYPE_SENSE_MASK)
|
2006-04-02 16:46:23 +00:00
|
|
|
return -EINVAL;
|
2006-12-07 01:13:59 +00:00
|
|
|
|
2011-08-30 09:35:44 +00:00
|
|
|
if (!bank->regs->leveldetect0 &&
|
|
|
|
(type & (IRQ_TYPE_LEVEL_LOW|IRQ_TYPE_LEVEL_HIGH)))
|
2005-09-07 16:20:26 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2015-07-21 16:26:51 +00:00
|
|
|
raw_spin_lock_irqsave(&bank->lock, flags);
|
2014-06-27 20:17:37 +00:00
|
|
|
retval = omap_set_gpio_triggering(bank, offset, type);
|
2015-06-24 14:54:17 +00:00
|
|
|
if (retval) {
|
2015-08-05 14:37:41 +00:00
|
|
|
raw_spin_unlock_irqrestore(&bank->lock, flags);
|
2015-05-22 14:35:49 +00:00
|
|
|
goto error;
|
2015-06-24 14:54:17 +00:00
|
|
|
}
|
2015-03-23 12:18:26 +00:00
|
|
|
omap_gpio_init_irq(bank, offset);
|
2015-03-23 12:18:23 +00:00
|
|
|
if (!omap_gpio_is_input(bank, offset)) {
|
2015-07-21 16:26:51 +00:00
|
|
|
raw_spin_unlock_irqrestore(&bank->lock, flags);
|
2015-05-22 14:35:49 +00:00
|
|
|
retval = -EINVAL;
|
|
|
|
goto error;
|
2013-09-25 00:36:54 +00:00
|
|
|
}
|
2015-07-21 16:26:51 +00:00
|
|
|
raw_spin_unlock_irqrestore(&bank->lock, flags);
|
2008-01-17 05:56:16 +00:00
|
|
|
|
|
|
|
if (type & (IRQ_TYPE_LEVEL_LOW | IRQ_TYPE_LEVEL_HIGH))
|
2015-06-23 13:52:39 +00:00
|
|
|
irq_set_handler_locked(d, handle_level_irq);
|
2008-01-17 05:56:16 +00:00
|
|
|
else if (type & (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING))
|
2017-10-03 16:17:05 +00:00
|
|
|
/*
|
|
|
|
* Edge IRQs are already cleared/acked in irq_handler and
|
|
|
|
* not need to be masked, as result handle_edge_irq()
|
|
|
|
* logic is excessed here and may cause lose of interrupts.
|
|
|
|
* So just use handle_simple_irq.
|
|
|
|
*/
|
|
|
|
irq_set_handler_locked(d, handle_simple_irq);
|
2008-01-17 05:56:16 +00:00
|
|
|
|
2015-05-22 14:35:49 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
2005-09-07 16:20:26 +00:00
|
|
|
return retval;
|
2005-07-10 18:58:15 +00:00
|
|
|
}
|
|
|
|
|
2014-06-27 20:17:37 +00:00
|
|
|
static void omap_clear_gpio_irqbank(struct gpio_bank *bank, int gpio_mask)
|
2005-07-10 18:58:15 +00:00
|
|
|
{
|
2005-09-07 16:20:26 +00:00
|
|
|
void __iomem *reg = bank->base;
|
2005-07-10 18:58:15 +00:00
|
|
|
|
2011-04-21 16:17:35 +00:00
|
|
|
reg += bank->regs->irqstatus;
|
2013-11-16 00:01:04 +00:00
|
|
|
writel_relaxed(gpio_mask, reg);
|
2006-09-25 09:41:46 +00:00
|
|
|
|
|
|
|
/* Workaround for clearing DSP GPIO interrupts to allow retention */
|
2011-04-21 16:17:35 +00:00
|
|
|
if (bank->regs->irqstatus2) {
|
|
|
|
reg = bank->base + bank->regs->irqstatus2;
|
2013-11-16 00:01:04 +00:00
|
|
|
writel_relaxed(gpio_mask, reg);
|
2011-04-21 16:17:35 +00:00
|
|
|
}
|
2009-04-23 18:10:50 +00:00
|
|
|
|
|
|
|
/* Flush posted write for the irq status to avoid spurious interrupts */
|
2013-11-16 00:01:04 +00:00
|
|
|
readl_relaxed(reg);
|
2005-07-10 18:58:15 +00:00
|
|
|
}
|
|
|
|
|
2015-03-23 12:18:27 +00:00
|
|
|
static inline void omap_clear_gpio_irqstatus(struct gpio_bank *bank,
|
|
|
|
unsigned offset)
|
2005-07-10 18:58:15 +00:00
|
|
|
{
|
2015-03-23 12:18:27 +00:00
|
|
|
omap_clear_gpio_irqbank(bank, BIT(offset));
|
2005-07-10 18:58:15 +00:00
|
|
|
}
|
|
|
|
|
2014-06-27 20:17:37 +00:00
|
|
|
static u32 omap_get_gpio_irqbank_mask(struct gpio_bank *bank)
|
2006-06-26 23:16:00 +00:00
|
|
|
{
|
|
|
|
void __iomem *reg = bank->base;
|
2006-06-26 23:16:07 +00:00
|
|
|
u32 l;
|
2014-04-27 00:00:49 +00:00
|
|
|
u32 mask = (BIT(bank->width)) - 1;
|
2006-06-26 23:16:00 +00:00
|
|
|
|
2011-04-21 16:53:06 +00:00
|
|
|
reg += bank->regs->irqenable;
|
2013-11-16 00:01:04 +00:00
|
|
|
l = readl_relaxed(reg);
|
2011-04-21 16:53:06 +00:00
|
|
|
if (bank->regs->irqenable_inv)
|
2006-06-26 23:16:07 +00:00
|
|
|
l = ~l;
|
|
|
|
l &= mask;
|
|
|
|
return l;
|
2006-06-26 23:16:00 +00:00
|
|
|
}
|
|
|
|
|
2019-06-10 17:10:57 +00:00
|
|
|
static inline void omap_set_gpio_irqenable(struct gpio_bank *bank,
|
|
|
|
unsigned offset, int enable)
|
2005-07-10 18:58:15 +00:00
|
|
|
{
|
2005-09-07 16:20:26 +00:00
|
|
|
void __iomem *reg = bank->base;
|
2019-06-10 17:10:57 +00:00
|
|
|
u32 gpio_mask = BIT(offset);
|
2005-07-10 18:58:15 +00:00
|
|
|
|
2019-06-10 17:10:57 +00:00
|
|
|
if (bank->regs->set_irqenable && bank->regs->clr_irqenable) {
|
|
|
|
if (enable) {
|
|
|
|
reg += bank->regs->set_irqenable;
|
|
|
|
bank->context.irqenable1 |= gpio_mask;
|
|
|
|
} else {
|
|
|
|
reg += bank->regs->clr_irqenable;
|
|
|
|
bank->context.irqenable1 &= ~gpio_mask;
|
|
|
|
}
|
|
|
|
writel_relaxed(gpio_mask, reg);
|
2011-04-21 16:53:06 +00:00
|
|
|
} else {
|
2019-06-10 17:10:57 +00:00
|
|
|
bank->context.irqenable1 =
|
|
|
|
omap_gpio_rmw(reg + bank->regs->irqenable, gpio_mask,
|
|
|
|
enable ^ bank->regs->irqenable_inv);
|
2011-04-21 16:53:06 +00:00
|
|
|
}
|
|
|
|
|
2019-06-10 17:11:01 +00:00
|
|
|
/*
|
|
|
|
* Program GPIO wakeup along with IRQ enable to satisfy OMAP4430 TRM
|
|
|
|
* note requiring correlation between the IRQ enable registers and
|
|
|
|
* the wakeup registers. In any case, we want wakeup from idle
|
|
|
|
* enabled for the GPIOs which support this feature.
|
|
|
|
*/
|
|
|
|
if (bank->regs->wkup_en &&
|
|
|
|
(bank->regs->edgectrl1 || !(bank->non_wakeup_gpios & gpio_mask))) {
|
|
|
|
bank->context.wake_en =
|
|
|
|
omap_gpio_rmw(bank->base + bank->regs->wkup_en,
|
|
|
|
gpio_mask, enable);
|
2005-07-10 18:58:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-09-07 16:20:26 +00:00
|
|
|
/* Use disable_irq_wake() and enable_irq_wake() functions from drivers */
|
2014-06-27 20:17:37 +00:00
|
|
|
static int omap_gpio_wake_enable(struct irq_data *d, unsigned int enable)
|
2005-09-07 16:20:26 +00:00
|
|
|
{
|
2014-06-27 20:17:37 +00:00
|
|
|
struct gpio_bank *bank = omap_irq_data_get_bank(d);
|
2015-09-25 19:28:03 +00:00
|
|
|
|
2016-04-12 10:52:31 +00:00
|
|
|
return irq_set_irq_wake(bank->irq, enable);
|
2005-09-07 16:20:26 +00:00
|
|
|
}
|
|
|
|
|
2005-07-10 18:58:15 +00:00
|
|
|
/*
|
|
|
|
* We need to unmask the GPIO bank interrupt as soon as possible to
|
|
|
|
* avoid missing GPIO interrupts for other lines in the bank.
|
|
|
|
* Then we need to mask-read-clear-unmask the triggered GPIO lines
|
|
|
|
* in the bank to avoid missing nested interrupts for a GPIO line.
|
|
|
|
* If we wait to unmask individual GPIO lines in the bank after the
|
|
|
|
* line's interrupt handler has been run, we may miss some nested
|
|
|
|
* interrupts.
|
|
|
|
*/
|
2015-09-25 19:28:03 +00:00
|
|
|
static irqreturn_t omap_gpio_irq_handler(int irq, void *gpiobank)
|
2005-07-10 18:58:15 +00:00
|
|
|
{
|
2005-09-07 16:20:26 +00:00
|
|
|
void __iomem *isr_reg = NULL;
|
2019-06-10 17:10:47 +00:00
|
|
|
u32 enabled, isr, edge;
|
2013-04-04 20:16:14 +00:00
|
|
|
unsigned int bit;
|
2015-09-25 19:28:03 +00:00
|
|
|
struct gpio_bank *bank = gpiobank;
|
|
|
|
unsigned long wa_lock_flags;
|
2015-08-18 11:10:55 +00:00
|
|
|
unsigned long lock_flags;
|
2005-07-10 18:58:15 +00:00
|
|
|
|
2011-04-21 16:17:35 +00:00
|
|
|
isr_reg = bank->base + bank->regs->irqstatus;
|
2010-12-08 00:25:40 +00:00
|
|
|
if (WARN_ON(!isr_reg))
|
|
|
|
goto exit;
|
|
|
|
|
2018-09-20 19:35:32 +00:00
|
|
|
if (WARN_ONCE(!pm_runtime_active(bank->chip.parent),
|
|
|
|
"gpio irq%i while runtime suspended?\n", irq))
|
|
|
|
return IRQ_NONE;
|
2015-09-25 19:28:03 +00:00
|
|
|
|
2013-03-20 12:15:57 +00:00
|
|
|
while (1) {
|
2015-08-18 11:10:55 +00:00
|
|
|
raw_spin_lock_irqsave(&bank->lock, lock_flags);
|
|
|
|
|
2014-06-27 20:17:37 +00:00
|
|
|
enabled = omap_get_gpio_irqbank_mask(bank);
|
2017-10-03 16:17:05 +00:00
|
|
|
isr = readl_relaxed(isr_reg) & enabled;
|
2006-04-02 16:46:23 +00:00
|
|
|
|
2019-06-10 17:10:47 +00:00
|
|
|
/*
|
|
|
|
* Clear edge sensitive interrupts before calling handler(s)
|
|
|
|
* so subsequent edge transitions are not missed while the
|
|
|
|
* handlers are running.
|
|
|
|
*/
|
|
|
|
edge = isr & ~bank->level_mask;
|
|
|
|
if (edge)
|
|
|
|
omap_clear_gpio_irqbank(bank, edge);
|
2006-04-02 16:46:23 +00:00
|
|
|
|
2015-08-18 11:10:55 +00:00
|
|
|
raw_spin_unlock_irqrestore(&bank->lock, lock_flags);
|
|
|
|
|
2005-09-07 16:20:26 +00:00
|
|
|
if (!isr)
|
|
|
|
break;
|
|
|
|
|
2013-04-04 20:16:14 +00:00
|
|
|
while (isr) {
|
|
|
|
bit = __ffs(isr);
|
2014-04-27 00:00:49 +00:00
|
|
|
isr &= ~(BIT(bit));
|
2012-02-23 20:50:10 +00:00
|
|
|
|
2015-08-18 11:10:55 +00:00
|
|
|
raw_spin_lock_irqsave(&bank->lock, lock_flags);
|
omap: gpio: Simultaneously requested rising and falling edge
Some chips, namely any OMAP1 chips using METHOD_MPUIO,
OMAP15xx and OMAP7xx, cannot be setup to respond to on-chip GPIO
interrupts in both rising and falling edge directions -- they can
only respond to one direction or the other, depending on how the
ICR is configured.
Additionally, current code forces rising edge detection if both
flags are specified:
if (trigger & IRQ_TYPE_EDGE_RISING)
l |= 1 << gpio;
else if (trigger & IRQ_TYPE_EDGE_FALLING)
l &= ~(1 << gpio);
else
goto bad;
This change implements a toggle function that will modify the ICR
to flip the direction of interrupt for IRQs that are requested with
both rising and falling flags. The toggle function is not called
for chips and GPIOs it does not apply to through the use of a flip_mask
that's added on a per-bank basis. The mask is only set for those
GPIOs where a toggle is necessary. Edge detection starts out the
same as above with FALLING mode first.
The toggle happens on EACH interrupt; without it, we have the
following sequence of actions on GPIO transition:
ICR GPIO Result
0x1 0 -> 1 (rising) Interrupt
0x1 1 -> 0 (falling) No interrupt
(set ICR to 0x0 manually)
0x0 0 -> 1 (rising) No interrupt
0x0 1 -> 0 (falling) Interrupt
That is, with the ICR set to 1 for a gpio, only rising edge interrupts
are caught, and with it set to 0, only falling edge interrupts are
caught. If we add in the toggle, we get this:
ICR GPIO Result
0x1 0 -> 1 (rising) Interrupt (ICR set to 0x0)
0x0 1 -> 0 (falling) Interrupt (ICR set to 0x1)
0x1 0 -> 1 ...
so, both rising and falling are caught, per the request for both
(IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING).
Signed-off-by: Cory Maccarrone <darkstar6262@gmail.com>
Acked-by: Kevin Hilman <khilman@deeprootsystems.com>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2010-01-08 18:29:04 +00:00
|
|
|
/*
|
|
|
|
* Some chips can't respond to both rising and falling
|
|
|
|
* at the same time. If this irq was requested with
|
|
|
|
* both flags, we need to flip the ICR data for the IRQ
|
|
|
|
* to respond to the IRQ for the opposite direction.
|
|
|
|
* This will be indicated in the bank toggle_mask.
|
|
|
|
*/
|
2014-04-27 00:00:49 +00:00
|
|
|
if (bank->toggle_mask & (BIT(bit)))
|
2014-06-27 20:17:37 +00:00
|
|
|
omap_toggle_gpio_edge_triggering(bank, bit);
|
omap: gpio: Simultaneously requested rising and falling edge
Some chips, namely any OMAP1 chips using METHOD_MPUIO,
OMAP15xx and OMAP7xx, cannot be setup to respond to on-chip GPIO
interrupts in both rising and falling edge directions -- they can
only respond to one direction or the other, depending on how the
ICR is configured.
Additionally, current code forces rising edge detection if both
flags are specified:
if (trigger & IRQ_TYPE_EDGE_RISING)
l |= 1 << gpio;
else if (trigger & IRQ_TYPE_EDGE_FALLING)
l &= ~(1 << gpio);
else
goto bad;
This change implements a toggle function that will modify the ICR
to flip the direction of interrupt for IRQs that are requested with
both rising and falling flags. The toggle function is not called
for chips and GPIOs it does not apply to through the use of a flip_mask
that's added on a per-bank basis. The mask is only set for those
GPIOs where a toggle is necessary. Edge detection starts out the
same as above with FALLING mode first.
The toggle happens on EACH interrupt; without it, we have the
following sequence of actions on GPIO transition:
ICR GPIO Result
0x1 0 -> 1 (rising) Interrupt
0x1 1 -> 0 (falling) No interrupt
(set ICR to 0x0 manually)
0x0 0 -> 1 (rising) No interrupt
0x0 1 -> 0 (falling) Interrupt
That is, with the ICR set to 1 for a gpio, only rising edge interrupts
are caught, and with it set to 0, only falling edge interrupts are
caught. If we add in the toggle, we get this:
ICR GPIO Result
0x1 0 -> 1 (rising) Interrupt (ICR set to 0x0)
0x0 1 -> 0 (falling) Interrupt (ICR set to 0x1)
0x1 0 -> 1 ...
so, both rising and falling are caught, per the request for both
(IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING).
Signed-off-by: Cory Maccarrone <darkstar6262@gmail.com>
Acked-by: Kevin Hilman <khilman@deeprootsystems.com>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2010-01-08 18:29:04 +00:00
|
|
|
|
2015-08-18 11:10:55 +00:00
|
|
|
raw_spin_unlock_irqrestore(&bank->lock, lock_flags);
|
|
|
|
|
2015-09-25 19:28:03 +00:00
|
|
|
raw_spin_lock_irqsave(&bank->wa_lock, wa_lock_flags);
|
|
|
|
|
2017-11-07 18:15:47 +00:00
|
|
|
generic_handle_irq(irq_find_mapping(bank->chip.irq.domain,
|
2014-04-06 14:58:16 +00:00
|
|
|
bit));
|
2015-09-25 19:28:03 +00:00
|
|
|
|
|
|
|
raw_spin_unlock_irqrestore(&bank->wa_lock,
|
|
|
|
wa_lock_flags);
|
2005-09-07 16:20:26 +00:00
|
|
|
}
|
2005-11-10 14:26:50 +00:00
|
|
|
}
|
2010-12-08 00:25:40 +00:00
|
|
|
exit:
|
2015-09-25 19:28:03 +00:00
|
|
|
return IRQ_HANDLED;
|
2005-07-10 18:58:15 +00:00
|
|
|
}
|
|
|
|
|
2015-01-16 22:50:50 +00:00
|
|
|
static unsigned int omap_gpio_irq_startup(struct irq_data *d)
|
|
|
|
{
|
|
|
|
struct gpio_bank *bank = omap_irq_data_get_bank(d);
|
|
|
|
unsigned long flags;
|
2015-03-23 12:18:26 +00:00
|
|
|
unsigned offset = d->hwirq;
|
2015-01-16 22:50:50 +00:00
|
|
|
|
2015-07-21 16:26:51 +00:00
|
|
|
raw_spin_lock_irqsave(&bank->lock, flags);
|
2015-05-22 14:35:52 +00:00
|
|
|
|
|
|
|
if (!LINE_USED(bank->mod_usage, offset))
|
|
|
|
omap_set_gpio_direction(bank, offset, 1);
|
|
|
|
omap_enable_gpio_module(bank, offset);
|
|
|
|
bank->irq_usage |= BIT(offset);
|
|
|
|
|
2015-07-21 16:26:51 +00:00
|
|
|
raw_spin_unlock_irqrestore(&bank->lock, flags);
|
2015-01-16 22:50:50 +00:00
|
|
|
omap_gpio_unmask_irq(d);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-06-27 20:17:37 +00:00
|
|
|
static void omap_gpio_irq_shutdown(struct irq_data *d)
|
2006-09-25 09:41:38 +00:00
|
|
|
{
|
2014-06-27 20:17:37 +00:00
|
|
|
struct gpio_bank *bank = omap_irq_data_get_bank(d);
|
2011-06-06 20:38:18 +00:00
|
|
|
unsigned long flags;
|
2015-03-23 12:18:27 +00:00
|
|
|
unsigned offset = d->hwirq;
|
2006-09-25 09:41:38 +00:00
|
|
|
|
2015-07-21 16:26:51 +00:00
|
|
|
raw_spin_lock_irqsave(&bank->lock, flags);
|
2014-04-27 00:00:49 +00:00
|
|
|
bank->irq_usage &= ~(BIT(offset));
|
2015-05-22 14:35:50 +00:00
|
|
|
omap_set_gpio_triggering(bank, offset, IRQ_TYPE_NONE);
|
2019-06-10 17:10:44 +00:00
|
|
|
omap_clear_gpio_irqstatus(bank, offset);
|
|
|
|
omap_set_gpio_irqenable(bank, offset, 0);
|
2015-05-22 14:35:50 +00:00
|
|
|
if (!LINE_USED(bank->mod_usage, offset))
|
|
|
|
omap_clear_gpio_debounce(bank, offset);
|
2014-06-27 20:17:37 +00:00
|
|
|
omap_disable_gpio_module(bank, offset);
|
2015-07-21 16:26:51 +00:00
|
|
|
raw_spin_unlock_irqrestore(&bank->lock, flags);
|
2015-09-25 19:28:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void omap_gpio_irq_bus_lock(struct irq_data *data)
|
|
|
|
{
|
|
|
|
struct gpio_bank *bank = omap_irq_data_get_bank(data);
|
|
|
|
|
2018-09-28 21:39:50 +00:00
|
|
|
pm_runtime_get_sync(bank->chip.parent);
|
2015-09-25 19:28:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void gpio_irq_bus_sync_unlock(struct irq_data *data)
|
|
|
|
{
|
|
|
|
struct gpio_bank *bank = omap_irq_data_get_bank(data);
|
2013-09-25 00:36:54 +00:00
|
|
|
|
2018-09-28 21:39:50 +00:00
|
|
|
pm_runtime_put(bank->chip.parent);
|
2006-09-25 09:41:38 +00:00
|
|
|
}
|
|
|
|
|
2014-06-27 20:17:37 +00:00
|
|
|
static void omap_gpio_mask_irq(struct irq_data *d)
|
2005-07-10 18:58:15 +00:00
|
|
|
{
|
2014-06-27 20:17:37 +00:00
|
|
|
struct gpio_bank *bank = omap_irq_data_get_bank(d);
|
2015-03-23 12:18:27 +00:00
|
|
|
unsigned offset = d->hwirq;
|
2011-06-06 20:38:18 +00:00
|
|
|
unsigned long flags;
|
2005-07-10 18:58:15 +00:00
|
|
|
|
2015-07-21 16:26:51 +00:00
|
|
|
raw_spin_lock_irqsave(&bank->lock, flags);
|
2015-03-23 12:18:27 +00:00
|
|
|
omap_set_gpio_triggering(bank, offset, IRQ_TYPE_NONE);
|
2019-06-10 17:10:44 +00:00
|
|
|
omap_set_gpio_irqenable(bank, offset, 0);
|
2015-07-21 16:26:51 +00:00
|
|
|
raw_spin_unlock_irqrestore(&bank->lock, flags);
|
2005-07-10 18:58:15 +00:00
|
|
|
}
|
|
|
|
|
2014-06-27 20:17:37 +00:00
|
|
|
static void omap_gpio_unmask_irq(struct irq_data *d)
|
2005-07-10 18:58:15 +00:00
|
|
|
{
|
2014-06-27 20:17:37 +00:00
|
|
|
struct gpio_bank *bank = omap_irq_data_get_bank(d);
|
2015-03-23 12:18:27 +00:00
|
|
|
unsigned offset = d->hwirq;
|
2011-03-24 11:40:15 +00:00
|
|
|
u32 trigger = irqd_get_trigger_type(d);
|
2011-06-06 20:38:18 +00:00
|
|
|
unsigned long flags;
|
2009-06-04 22:57:10 +00:00
|
|
|
|
2015-07-21 16:26:51 +00:00
|
|
|
raw_spin_lock_irqsave(&bank->lock, flags);
|
gpio: gpio-omap: fix level interrupt idling
Tony notes that the GPIO module does not idle when level interrupts are
in use, as the wakeup appears to get stuck.
After extensive investigation, it appears that the wakeup will only be
cleared if the interrupt status register is cleared while the interrupt
is enabled. However, we are currently clearing it with the interrupt
disabled for level-based interrupts.
It is acknowledged that this observed behaviour conflicts with a
statement in the TRM:
CAUTION
After servicing the interrupt, the status bit in the interrupt status
register (GPIOi.GPIO_IRQSTATUS_0 or GPIOi.GPIO_IRQSTATUS_1) must be
reset and the interrupt line released (by setting the corresponding
bit of the interrupt status register to 1) before enabling an
interrupt for the GPIO channel in the interrupt-enable register
(GPIOi.GPIO_IRQSTATUS_SET_0 or GPIOi.GPIO_IRQSTATUS_SET_1) to prevent
the occurrence of unexpected interrupts when enabling an interrupt
for the GPIO channel.
However, this does not appear to be a practical problem.
Further, as reported by Grygorii Strashko <grygorii.strashko@ti.com>,
the TI Android kernel tree has an earlier similar patch as "GPIO: OMAP:
Fix the sequence to clear the IRQ status" saying:
if the status is cleared after disabling the IRQ then sWAKEUP will not
be cleared and gates the module transition
When we unmask the level interrupt after the interrupt has been handled,
enable the interrupt and only then clear the interrupt. If the interrupt
is still pending, the hardware will re-assert the interrupt status.
Should the caution note in the TRM prove to be a problem, we could
use a clear-enable-clear sequence instead.
Cc: Aaro Koskinen <aaro.koskinen@iki.fi>
Cc: Keerthy <j-keerthy@ti.com>
Cc: Peter Ujfalusi <peter.ujfalusi@ti.com>
Signed-off-by: Russell King <rmk+kernel@armlinux.org.uk>
[tony@atomide.com: updated comments based on an earlier TI patch]
Signed-off-by: Tony Lindgren <tony@atomide.com>
Acked-by: Grygorii Strashko <grygorii.strashko@ti.com>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
2019-03-01 19:02:52 +00:00
|
|
|
omap_set_gpio_irqenable(bank, offset, 1);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For level-triggered GPIOs, clearing must be done after the source
|
|
|
|
* is cleared, thus after the handler has run. OMAP4 needs this done
|
|
|
|
* after enabing the interrupt to clear the wakeup status.
|
|
|
|
*/
|
2019-06-10 17:10:44 +00:00
|
|
|
if (bank->regs->leveldetect0 && bank->regs->wkup_en &&
|
|
|
|
trigger & (IRQ_TYPE_LEVEL_HIGH | IRQ_TYPE_LEVEL_LOW))
|
2015-03-23 12:18:27 +00:00
|
|
|
omap_clear_gpio_irqstatus(bank, offset);
|
2005-07-10 18:58:15 +00:00
|
|
|
|
2019-06-10 17:10:44 +00:00
|
|
|
if (trigger)
|
|
|
|
omap_set_gpio_triggering(bank, offset, trigger);
|
|
|
|
|
2015-07-21 16:26:51 +00:00
|
|
|
raw_spin_unlock_irqrestore(&bank->lock, flags);
|
2005-07-10 18:58:15 +00:00
|
|
|
}
|
|
|
|
|
2006-12-07 01:13:59 +00:00
|
|
|
/*---------------------------------------------------------------------*/
|
|
|
|
|
2009-07-08 11:22:04 +00:00
|
|
|
static int omap_mpuio_suspend_noirq(struct device *dev)
|
2006-12-07 01:14:11 +00:00
|
|
|
{
|
2018-10-21 19:59:59 +00:00
|
|
|
struct gpio_bank *bank = dev_get_drvdata(dev);
|
2010-12-08 00:26:58 +00:00
|
|
|
void __iomem *mask_reg = bank->base +
|
|
|
|
OMAP_MPUIO_GPIO_MASKIT / bank->stride;
|
2008-03-03 12:33:30 +00:00
|
|
|
unsigned long flags;
|
2006-12-07 01:14:11 +00:00
|
|
|
|
2015-07-21 16:26:51 +00:00
|
|
|
raw_spin_lock_irqsave(&bank->lock, flags);
|
2013-11-16 00:01:04 +00:00
|
|
|
writel_relaxed(0xffff & ~bank->context.wake_en, mask_reg);
|
2015-07-21 16:26:51 +00:00
|
|
|
raw_spin_unlock_irqrestore(&bank->lock, flags);
|
2006-12-07 01:14:11 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-08 11:22:04 +00:00
|
|
|
static int omap_mpuio_resume_noirq(struct device *dev)
|
2006-12-07 01:14:11 +00:00
|
|
|
{
|
2018-10-21 19:59:59 +00:00
|
|
|
struct gpio_bank *bank = dev_get_drvdata(dev);
|
2010-12-08 00:26:58 +00:00
|
|
|
void __iomem *mask_reg = bank->base +
|
|
|
|
OMAP_MPUIO_GPIO_MASKIT / bank->stride;
|
2008-03-03 12:33:30 +00:00
|
|
|
unsigned long flags;
|
2006-12-07 01:14:11 +00:00
|
|
|
|
2015-07-21 16:26:51 +00:00
|
|
|
raw_spin_lock_irqsave(&bank->lock, flags);
|
2013-11-16 00:01:04 +00:00
|
|
|
writel_relaxed(bank->context.wake_en, mask_reg);
|
2015-07-21 16:26:51 +00:00
|
|
|
raw_spin_unlock_irqrestore(&bank->lock, flags);
|
2006-12-07 01:14:11 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-12-15 02:00:08 +00:00
|
|
|
static const struct dev_pm_ops omap_mpuio_dev_pm_ops = {
|
2009-07-08 11:22:04 +00:00
|
|
|
.suspend_noirq = omap_mpuio_suspend_noirq,
|
|
|
|
.resume_noirq = omap_mpuio_resume_noirq,
|
|
|
|
};
|
|
|
|
|
2011-04-22 20:02:46 +00:00
|
|
|
/* use platform_driver for this. */
|
2006-12-07 01:14:11 +00:00
|
|
|
static struct platform_driver omap_mpuio_driver = {
|
|
|
|
.driver = {
|
|
|
|
.name = "mpuio",
|
2009-07-08 11:22:04 +00:00
|
|
|
.pm = &omap_mpuio_dev_pm_ops,
|
2006-12-07 01:14:11 +00:00
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct platform_device omap_mpuio_device = {
|
|
|
|
.name = "mpuio",
|
|
|
|
.id = -1,
|
|
|
|
.dev = {
|
|
|
|
.driver = &omap_mpuio_driver.driver,
|
|
|
|
}
|
|
|
|
/* could list the /proc/iomem resources */
|
|
|
|
};
|
|
|
|
|
2014-06-27 20:17:37 +00:00
|
|
|
static inline void omap_mpuio_init(struct gpio_bank *bank)
|
2006-12-07 01:14:11 +00:00
|
|
|
{
|
2010-12-08 00:26:57 +00:00
|
|
|
platform_set_drvdata(&omap_mpuio_device, bank);
|
2007-04-02 19:46:47 +00:00
|
|
|
|
2006-12-07 01:14:11 +00:00
|
|
|
if (platform_driver_register(&omap_mpuio_driver) == 0)
|
|
|
|
(void) platform_device_register(&omap_mpuio_device);
|
|
|
|
}
|
|
|
|
|
2006-12-07 01:13:59 +00:00
|
|
|
/*---------------------------------------------------------------------*/
|
2005-07-10 18:58:15 +00:00
|
|
|
|
2019-06-10 17:10:49 +00:00
|
|
|
static int omap_gpio_request(struct gpio_chip *chip, unsigned offset)
|
2014-04-24 06:57:39 +00:00
|
|
|
{
|
2019-06-10 17:10:49 +00:00
|
|
|
struct gpio_bank *bank = gpiochip_get_data(chip);
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
pm_runtime_get_sync(chip->parent);
|
|
|
|
|
|
|
|
raw_spin_lock_irqsave(&bank->lock, flags);
|
|
|
|
omap_enable_gpio_module(bank, offset);
|
|
|
|
bank->mod_usage |= BIT(offset);
|
|
|
|
raw_spin_unlock_irqrestore(&bank->lock, flags);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void omap_gpio_free(struct gpio_chip *chip, unsigned offset)
|
|
|
|
{
|
|
|
|
struct gpio_bank *bank = gpiochip_get_data(chip);
|
2014-04-24 06:57:39 +00:00
|
|
|
unsigned long flags;
|
|
|
|
|
2015-07-21 16:26:51 +00:00
|
|
|
raw_spin_lock_irqsave(&bank->lock, flags);
|
2019-06-10 17:10:49 +00:00
|
|
|
bank->mod_usage &= ~(BIT(offset));
|
|
|
|
if (!LINE_USED(bank->irq_usage, offset)) {
|
|
|
|
omap_set_gpio_direction(bank, offset, 1);
|
|
|
|
omap_clear_gpio_debounce(bank, offset);
|
|
|
|
}
|
|
|
|
omap_disable_gpio_module(bank, offset);
|
2015-07-21 16:26:51 +00:00
|
|
|
raw_spin_unlock_irqrestore(&bank->lock, flags);
|
2019-06-10 17:10:49 +00:00
|
|
|
|
|
|
|
pm_runtime_put(chip->parent);
|
|
|
|
}
|
|
|
|
|
2014-06-27 20:17:37 +00:00
|
|
|
static int omap_gpio_get_direction(struct gpio_chip *chip, unsigned offset)
|
2014-04-24 06:57:39 +00:00
|
|
|
{
|
2019-06-10 17:10:50 +00:00
|
|
|
struct gpio_bank *bank = gpiochip_get_data(chip);
|
2014-04-24 06:57:39 +00:00
|
|
|
|
2019-11-06 08:54:12 +00:00
|
|
|
if (readl_relaxed(bank->base + bank->regs->direction) & BIT(offset))
|
|
|
|
return GPIO_LINE_DIRECTION_IN;
|
|
|
|
|
|
|
|
return GPIO_LINE_DIRECTION_OUT;
|
2014-04-24 06:57:39 +00:00
|
|
|
}
|
|
|
|
|
2014-06-27 20:17:37 +00:00
|
|
|
static int omap_gpio_input(struct gpio_chip *chip, unsigned offset)
|
2008-03-03 20:43:23 +00:00
|
|
|
{
|
|
|
|
struct gpio_bank *bank;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2015-12-07 10:16:00 +00:00
|
|
|
bank = gpiochip_get_data(chip);
|
2015-07-21 16:26:51 +00:00
|
|
|
raw_spin_lock_irqsave(&bank->lock, flags);
|
2014-06-27 20:17:37 +00:00
|
|
|
omap_set_gpio_direction(bank, offset, 1);
|
2015-07-21 16:26:51 +00:00
|
|
|
raw_spin_unlock_irqrestore(&bank->lock, flags);
|
2008-03-03 20:43:23 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-06-27 20:17:37 +00:00
|
|
|
static int omap_gpio_get(struct gpio_chip *chip, unsigned offset)
|
2008-03-03 20:43:23 +00:00
|
|
|
{
|
2019-06-10 17:10:51 +00:00
|
|
|
struct gpio_bank *bank = gpiochip_get_data(chip);
|
|
|
|
void __iomem *reg;
|
2009-08-05 13:53:24 +00:00
|
|
|
|
2015-03-23 12:18:23 +00:00
|
|
|
if (omap_gpio_is_input(bank, offset))
|
2019-06-10 17:10:51 +00:00
|
|
|
reg = bank->base + bank->regs->datain;
|
2009-08-05 13:53:24 +00:00
|
|
|
else
|
2019-06-10 17:10:51 +00:00
|
|
|
reg = bank->base + bank->regs->dataout;
|
|
|
|
|
|
|
|
return (readl_relaxed(reg) & BIT(offset)) != 0;
|
2008-03-03 20:43:23 +00:00
|
|
|
}
|
|
|
|
|
2014-06-27 20:17:37 +00:00
|
|
|
static int omap_gpio_output(struct gpio_chip *chip, unsigned offset, int value)
|
2008-03-03 20:43:23 +00:00
|
|
|
{
|
|
|
|
struct gpio_bank *bank;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2015-12-07 10:16:00 +00:00
|
|
|
bank = gpiochip_get_data(chip);
|
2015-07-21 16:26:51 +00:00
|
|
|
raw_spin_lock_irqsave(&bank->lock, flags);
|
2011-04-20 23:31:23 +00:00
|
|
|
bank->set_dataout(bank, offset, value);
|
2014-06-27 20:17:37 +00:00
|
|
|
omap_set_gpio_direction(bank, offset, 0);
|
2015-07-21 16:26:51 +00:00
|
|
|
raw_spin_unlock_irqrestore(&bank->lock, flags);
|
2013-10-16 00:47:30 +00:00
|
|
|
return 0;
|
2008-03-03 20:43:23 +00:00
|
|
|
}
|
|
|
|
|
2018-07-18 23:57:08 +00:00
|
|
|
static int omap_gpio_get_multiple(struct gpio_chip *chip, unsigned long *mask,
|
|
|
|
unsigned long *bits)
|
|
|
|
{
|
|
|
|
struct gpio_bank *bank = gpiochip_get_data(chip);
|
2019-06-10 17:10:52 +00:00
|
|
|
void __iomem *base = bank->base;
|
|
|
|
u32 direction, m, val = 0;
|
2018-07-18 23:57:08 +00:00
|
|
|
|
2019-06-10 17:10:52 +00:00
|
|
|
direction = readl_relaxed(base + bank->regs->direction);
|
2018-07-18 23:57:08 +00:00
|
|
|
|
2019-06-10 17:10:52 +00:00
|
|
|
m = direction & *mask;
|
|
|
|
if (m)
|
|
|
|
val |= readl_relaxed(base + bank->regs->datain) & m;
|
2018-07-18 23:57:08 +00:00
|
|
|
|
2019-06-10 17:10:52 +00:00
|
|
|
m = ~direction & *mask;
|
|
|
|
if (m)
|
|
|
|
val |= readl_relaxed(base + bank->regs->dataout) & m;
|
2018-07-18 23:57:08 +00:00
|
|
|
|
2019-06-10 17:10:52 +00:00
|
|
|
*bits = val;
|
2018-07-18 23:57:08 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-06-27 20:17:37 +00:00
|
|
|
static int omap_gpio_debounce(struct gpio_chip *chip, unsigned offset,
|
|
|
|
unsigned debounce)
|
2010-05-26 21:42:23 +00:00
|
|
|
{
|
|
|
|
struct gpio_bank *bank;
|
|
|
|
unsigned long flags;
|
2017-04-24 22:56:50 +00:00
|
|
|
int ret;
|
2010-05-26 21:42:23 +00:00
|
|
|
|
2015-12-07 10:16:00 +00:00
|
|
|
bank = gpiochip_get_data(chip);
|
2010-12-08 00:26:57 +00:00
|
|
|
|
2015-07-21 16:26:51 +00:00
|
|
|
raw_spin_lock_irqsave(&bank->lock, flags);
|
2017-04-24 22:56:50 +00:00
|
|
|
ret = omap2_set_gpio_debounce(bank, offset, debounce);
|
2015-07-21 16:26:51 +00:00
|
|
|
raw_spin_unlock_irqrestore(&bank->lock, flags);
|
2010-05-26 21:42:23 +00:00
|
|
|
|
2017-04-24 22:56:50 +00:00
|
|
|
if (ret)
|
|
|
|
dev_info(chip->parent,
|
|
|
|
"Could not set line %u debounce to %u microseconds (%d)",
|
|
|
|
offset, debounce, ret);
|
|
|
|
|
|
|
|
return ret;
|
2010-05-26 21:42:23 +00:00
|
|
|
}
|
|
|
|
|
2017-01-23 12:34:34 +00:00
|
|
|
static int omap_gpio_set_config(struct gpio_chip *chip, unsigned offset,
|
|
|
|
unsigned long config)
|
|
|
|
{
|
|
|
|
u32 debounce;
|
2020-07-17 19:40:43 +00:00
|
|
|
int ret = -ENOTSUPP;
|
|
|
|
|
2020-07-22 12:07:56 +00:00
|
|
|
switch (pinconf_to_config_param(config)) {
|
|
|
|
case PIN_CONFIG_BIAS_DISABLE:
|
|
|
|
case PIN_CONFIG_BIAS_PULL_UP:
|
|
|
|
case PIN_CONFIG_BIAS_PULL_DOWN:
|
2020-07-17 19:40:43 +00:00
|
|
|
ret = gpiochip_generic_config(chip, offset, config);
|
2020-07-22 12:07:56 +00:00
|
|
|
break;
|
|
|
|
case PIN_CONFIG_INPUT_DEBOUNCE:
|
2020-07-17 19:40:43 +00:00
|
|
|
debounce = pinconf_to_config_argument(config);
|
|
|
|
ret = omap_gpio_debounce(chip, offset, debounce);
|
2020-07-22 12:07:56 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2020-07-17 19:40:43 +00:00
|
|
|
}
|
2017-01-23 12:34:34 +00:00
|
|
|
|
2020-07-17 19:40:43 +00:00
|
|
|
return ret;
|
2017-01-23 12:34:34 +00:00
|
|
|
}
|
|
|
|
|
2014-06-27 20:17:37 +00:00
|
|
|
static void omap_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
|
2008-03-03 20:43:23 +00:00
|
|
|
{
|
|
|
|
struct gpio_bank *bank;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2015-12-07 10:16:00 +00:00
|
|
|
bank = gpiochip_get_data(chip);
|
2015-07-21 16:26:51 +00:00
|
|
|
raw_spin_lock_irqsave(&bank->lock, flags);
|
2011-04-20 23:31:23 +00:00
|
|
|
bank->set_dataout(bank, offset, value);
|
2015-07-21 16:26:51 +00:00
|
|
|
raw_spin_unlock_irqrestore(&bank->lock, flags);
|
2008-03-03 20:43:23 +00:00
|
|
|
}
|
|
|
|
|
2018-07-18 23:57:08 +00:00
|
|
|
static void omap_gpio_set_multiple(struct gpio_chip *chip, unsigned long *mask,
|
|
|
|
unsigned long *bits)
|
|
|
|
{
|
|
|
|
struct gpio_bank *bank = gpiochip_get_data(chip);
|
2019-06-10 17:10:53 +00:00
|
|
|
void __iomem *reg = bank->base + bank->regs->dataout;
|
2018-07-18 23:57:08 +00:00
|
|
|
unsigned long flags;
|
2019-06-10 17:10:53 +00:00
|
|
|
u32 l;
|
2018-07-18 23:57:08 +00:00
|
|
|
|
|
|
|
raw_spin_lock_irqsave(&bank->lock, flags);
|
2019-06-10 17:10:53 +00:00
|
|
|
l = (readl_relaxed(reg) & ~*mask) | (*bits & *mask);
|
|
|
|
writel_relaxed(l, reg);
|
|
|
|
bank->context.dataout = l;
|
2018-07-18 23:57:08 +00:00
|
|
|
raw_spin_unlock_irqrestore(&bank->lock, flags);
|
|
|
|
}
|
|
|
|
|
2008-03-03 20:43:23 +00:00
|
|
|
/*---------------------------------------------------------------------*/
|
|
|
|
|
2017-09-16 20:42:21 +00:00
|
|
|
static void omap_gpio_show_rev(struct gpio_bank *bank)
|
2009-10-19 22:25:20 +00:00
|
|
|
{
|
2011-04-22 21:37:16 +00:00
|
|
|
static bool called;
|
2009-10-19 22:25:20 +00:00
|
|
|
u32 rev;
|
|
|
|
|
2011-04-22 21:37:16 +00:00
|
|
|
if (called || bank->regs->revision == USHRT_MAX)
|
2009-10-19 22:25:20 +00:00
|
|
|
return;
|
|
|
|
|
2013-11-16 00:01:04 +00:00
|
|
|
rev = readw_relaxed(bank->base + bank->regs->revision);
|
2011-04-22 21:37:16 +00:00
|
|
|
pr_info("OMAP GPIO hardware version %d.%d\n",
|
2009-10-19 22:25:20 +00:00
|
|
|
(rev >> 4) & 0x0f, rev & 0x0f);
|
2011-04-22 21:37:16 +00:00
|
|
|
|
|
|
|
called = true;
|
2009-10-19 22:25:20 +00:00
|
|
|
}
|
|
|
|
|
2011-05-05 14:28:01 +00:00
|
|
|
static void omap_gpio_mod_init(struct gpio_bank *bank)
|
2010-12-08 00:26:55 +00:00
|
|
|
{
|
2011-09-13 09:42:05 +00:00
|
|
|
void __iomem *base = bank->base;
|
|
|
|
u32 l = 0xffffffff;
|
2010-12-08 00:26:55 +00:00
|
|
|
|
2011-09-13 09:42:05 +00:00
|
|
|
if (bank->width == 16)
|
|
|
|
l = 0xffff;
|
|
|
|
|
2011-08-30 18:32:21 +00:00
|
|
|
if (bank->is_mpuio) {
|
2013-11-16 00:01:04 +00:00
|
|
|
writel_relaxed(l, bank->base + bank->regs->irqenable);
|
2011-09-13 09:42:05 +00:00
|
|
|
return;
|
2010-12-08 00:26:55 +00:00
|
|
|
}
|
2011-09-13 09:42:05 +00:00
|
|
|
|
2019-06-10 17:10:55 +00:00
|
|
|
omap_gpio_rmw(base + bank->regs->irqenable, l,
|
2014-06-27 20:17:37 +00:00
|
|
|
bank->regs->irqenable_inv);
|
2019-06-10 17:10:55 +00:00
|
|
|
omap_gpio_rmw(base + bank->regs->irqstatus, l,
|
2014-06-27 20:17:37 +00:00
|
|
|
!bank->regs->irqenable_inv);
|
2011-09-13 09:42:05 +00:00
|
|
|
if (bank->regs->debounce_en)
|
2013-11-16 00:01:04 +00:00
|
|
|
writel_relaxed(0, base + bank->regs->debounce_en);
|
2011-09-13 09:42:05 +00:00
|
|
|
|
2011-11-23 21:14:29 +00:00
|
|
|
/* Save OE default value (0xffffffff) in the context */
|
2013-11-16 00:01:04 +00:00
|
|
|
bank->context.oe = readl_relaxed(bank->base + bank->regs->direction);
|
2011-09-13 09:42:05 +00:00
|
|
|
/* Initialize interface clk ungated, module enabled */
|
|
|
|
if (bank->regs->ctrl)
|
2013-11-16 00:01:04 +00:00
|
|
|
writel_relaxed(0, base + bank->regs->ctrl);
|
2010-12-08 00:26:55 +00:00
|
|
|
}
|
|
|
|
|
2014-09-05 19:52:55 +00:00
|
|
|
static int omap_gpio_chip_init(struct gpio_bank *bank, struct irq_chip *irqc)
|
2010-12-08 00:26:55 +00:00
|
|
|
{
|
2017-11-15 18:36:33 +00:00
|
|
|
struct gpio_irq_chip *irq;
|
2010-12-08 00:26:55 +00:00
|
|
|
static int gpio;
|
2017-12-29 12:22:58 +00:00
|
|
|
const char *label;
|
2014-04-06 14:58:16 +00:00
|
|
|
int irq_base = 0;
|
2014-04-06 14:58:14 +00:00
|
|
|
int ret;
|
2010-12-08 00:26:55 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* REVISIT eventually switch from OMAP-specific gpio structs
|
|
|
|
* over to the generic ones
|
|
|
|
*/
|
|
|
|
bank->chip.request = omap_gpio_request;
|
|
|
|
bank->chip.free = omap_gpio_free;
|
2014-06-27 20:17:37 +00:00
|
|
|
bank->chip.get_direction = omap_gpio_get_direction;
|
|
|
|
bank->chip.direction_input = omap_gpio_input;
|
|
|
|
bank->chip.get = omap_gpio_get;
|
2018-07-18 23:57:08 +00:00
|
|
|
bank->chip.get_multiple = omap_gpio_get_multiple;
|
2014-06-27 20:17:37 +00:00
|
|
|
bank->chip.direction_output = omap_gpio_output;
|
2017-01-23 12:34:34 +00:00
|
|
|
bank->chip.set_config = omap_gpio_set_config;
|
2014-06-27 20:17:37 +00:00
|
|
|
bank->chip.set = omap_gpio_set;
|
2018-07-18 23:57:08 +00:00
|
|
|
bank->chip.set_multiple = omap_gpio_set_multiple;
|
2011-08-30 18:32:21 +00:00
|
|
|
if (bank->is_mpuio) {
|
2010-12-08 00:26:55 +00:00
|
|
|
bank->chip.label = "mpuio";
|
2011-09-13 09:11:44 +00:00
|
|
|
if (bank->regs->wkup_en)
|
2015-11-04 08:56:26 +00:00
|
|
|
bank->chip.parent = &omap_mpuio_device.dev;
|
2010-12-08 00:26:55 +00:00
|
|
|
bank->chip.base = OMAP_MPUIO(0);
|
|
|
|
} else {
|
2017-12-29 12:22:58 +00:00
|
|
|
label = devm_kasprintf(bank->chip.parent, GFP_KERNEL, "gpio-%d-%d",
|
|
|
|
gpio, gpio + bank->width - 1);
|
|
|
|
if (!label)
|
|
|
|
return -ENOMEM;
|
|
|
|
bank->chip.label = label;
|
2010-12-08 00:26:55 +00:00
|
|
|
bank->chip.base = gpio;
|
|
|
|
}
|
2011-04-21 16:23:00 +00:00
|
|
|
bank->chip.ngpio = bank->width;
|
2010-12-08 00:26:55 +00:00
|
|
|
|
2014-04-06 14:58:16 +00:00
|
|
|
#ifdef CONFIG_ARCH_OMAP1
|
|
|
|
/*
|
|
|
|
* REVISIT: Once we have OMAP1 supporting SPARSE_IRQ, we can drop
|
|
|
|
* irq_alloc_descs() since a base IRQ offset will no longer be needed.
|
|
|
|
*/
|
2017-03-04 16:23:31 +00:00
|
|
|
irq_base = devm_irq_alloc_descs(bank->chip.parent,
|
|
|
|
-1, 0, bank->width, 0);
|
2014-04-06 14:58:16 +00:00
|
|
|
if (irq_base < 0) {
|
2016-03-04 15:25:35 +00:00
|
|
|
dev_err(bank->chip.parent, "Couldn't allocate IRQ numbers\n");
|
2014-04-06 14:58:16 +00:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2015-04-23 23:54:17 +00:00
|
|
|
/* MPUIO is a bit different, reading IRQ status clears it */
|
2019-06-10 17:10:48 +00:00
|
|
|
if (bank->is_mpuio && !bank->regs->wkup_en)
|
|
|
|
irqc->irq_set_wake = NULL;
|
2015-04-23 23:54:17 +00:00
|
|
|
|
2017-11-15 18:36:33 +00:00
|
|
|
irq = &bank->chip.irq;
|
|
|
|
irq->chip = irqc;
|
|
|
|
irq->handler = handle_bad_irq;
|
|
|
|
irq->default_type = IRQ_TYPE_NONE;
|
|
|
|
irq->num_parents = 1;
|
|
|
|
irq->parents = &bank->irq;
|
|
|
|
irq->first = irq_base;
|
2014-04-06 14:58:16 +00:00
|
|
|
|
2017-11-15 18:36:33 +00:00
|
|
|
ret = gpiochip_add_data(&bank->chip, bank);
|
2020-11-18 14:31:49 +00:00
|
|
|
if (ret)
|
|
|
|
return dev_err_probe(bank->chip.parent, ret, "Could not register gpio chip\n");
|
2014-04-06 14:58:16 +00:00
|
|
|
|
2016-03-04 15:25:35 +00:00
|
|
|
ret = devm_request_irq(bank->chip.parent, bank->irq,
|
|
|
|
omap_gpio_irq_handler,
|
|
|
|
0, dev_name(bank->chip.parent), bank);
|
2015-09-25 19:28:03 +00:00
|
|
|
if (ret)
|
|
|
|
gpiochip_remove(&bank->chip);
|
|
|
|
|
2017-11-15 18:36:33 +00:00
|
|
|
if (!bank->is_mpuio)
|
|
|
|
gpio += bank->width;
|
|
|
|
|
2015-09-25 19:28:03 +00:00
|
|
|
return ret;
|
2010-12-08 00:26:55 +00:00
|
|
|
}
|
|
|
|
|
2019-03-07 10:33:32 +00:00
|
|
|
static void omap_gpio_init_context(struct gpio_bank *p)
|
2018-09-20 19:35:31 +00:00
|
|
|
{
|
2019-06-10 17:11:00 +00:00
|
|
|
const struct omap_gpio_reg_offs *regs = p->regs;
|
2019-03-07 10:33:32 +00:00
|
|
|
void __iomem *base = p->base;
|
2018-09-20 19:35:31 +00:00
|
|
|
|
2019-03-07 10:33:32 +00:00
|
|
|
p->context.ctrl = readl_relaxed(base + regs->ctrl);
|
|
|
|
p->context.oe = readl_relaxed(base + regs->direction);
|
|
|
|
p->context.wake_en = readl_relaxed(base + regs->wkup_en);
|
|
|
|
p->context.leveldetect0 = readl_relaxed(base + regs->leveldetect0);
|
|
|
|
p->context.leveldetect1 = readl_relaxed(base + regs->leveldetect1);
|
|
|
|
p->context.risingdetect = readl_relaxed(base + regs->risingdetect);
|
|
|
|
p->context.fallingdetect = readl_relaxed(base + regs->fallingdetect);
|
|
|
|
p->context.irqenable1 = readl_relaxed(base + regs->irqenable);
|
|
|
|
p->context.irqenable2 = readl_relaxed(base + regs->irqenable2);
|
2019-06-10 17:10:58 +00:00
|
|
|
p->context.dataout = readl_relaxed(base + regs->dataout);
|
2018-09-20 19:35:31 +00:00
|
|
|
|
2019-03-07 10:33:32 +00:00
|
|
|
p->context_valid = true;
|
2018-09-20 19:35:31 +00:00
|
|
|
}
|
|
|
|
|
2019-03-07 10:33:32 +00:00
|
|
|
static void omap_gpio_restore_context(struct gpio_bank *bank)
|
2005-07-10 18:58:15 +00:00
|
|
|
{
|
2019-06-10 17:11:00 +00:00
|
|
|
const struct omap_gpio_reg_offs *regs = bank->regs;
|
2019-06-10 17:10:59 +00:00
|
|
|
void __iomem *base = bank->base;
|
|
|
|
|
|
|
|
writel_relaxed(bank->context.wake_en, base + regs->wkup_en);
|
|
|
|
writel_relaxed(bank->context.ctrl, base + regs->ctrl);
|
|
|
|
writel_relaxed(bank->context.leveldetect0, base + regs->leveldetect0);
|
|
|
|
writel_relaxed(bank->context.leveldetect1, base + regs->leveldetect1);
|
|
|
|
writel_relaxed(bank->context.risingdetect, base + regs->risingdetect);
|
|
|
|
writel_relaxed(bank->context.fallingdetect, base + regs->fallingdetect);
|
|
|
|
writel_relaxed(bank->context.dataout, base + regs->dataout);
|
|
|
|
writel_relaxed(bank->context.oe, base + regs->direction);
|
2009-10-19 22:25:20 +00:00
|
|
|
|
2019-03-07 10:33:32 +00:00
|
|
|
if (bank->dbck_enable_mask) {
|
2019-06-10 17:10:59 +00:00
|
|
|
writel_relaxed(bank->context.debounce, base + regs->debounce);
|
2019-03-07 10:33:32 +00:00
|
|
|
writel_relaxed(bank->context.debounce_en,
|
2019-06-10 17:10:59 +00:00
|
|
|
base + regs->debounce_en);
|
2018-09-20 19:35:31 +00:00
|
|
|
}
|
|
|
|
|
2019-06-10 17:10:59 +00:00
|
|
|
writel_relaxed(bank->context.irqenable1, base + regs->irqenable);
|
|
|
|
writel_relaxed(bank->context.irqenable2, base + regs->irqenable2);
|
2015-04-23 23:56:22 +00:00
|
|
|
}
|
|
|
|
|
2018-09-20 19:35:31 +00:00
|
|
|
static void omap_gpio_idle(struct gpio_bank *bank, bool may_lose_context)
|
2006-12-07 01:13:52 +00:00
|
|
|
{
|
2018-09-20 19:35:31 +00:00
|
|
|
struct device *dev = bank->chip.parent;
|
2019-03-25 22:43:16 +00:00
|
|
|
void __iomem *base = bank->base;
|
2020-10-28 06:05:56 +00:00
|
|
|
u32 mask, nowake;
|
2019-03-25 22:43:16 +00:00
|
|
|
|
|
|
|
bank->saved_datain = readl_relaxed(base + bank->regs->datain);
|
2012-03-05 23:10:04 +00:00
|
|
|
|
2012-05-17 23:42:16 +00:00
|
|
|
if (!bank->enabled_non_wakeup_gpios)
|
|
|
|
goto update_gpio_context_count;
|
|
|
|
|
2020-10-28 06:05:56 +00:00
|
|
|
/* Check for pending EDGE_FALLING, ignore EDGE_BOTH */
|
|
|
|
mask = bank->enabled_non_wakeup_gpios & bank->context.fallingdetect;
|
|
|
|
mask &= ~bank->context.risingdetect;
|
|
|
|
bank->saved_datain |= mask;
|
|
|
|
|
|
|
|
/* Check for pending EDGE_RISING, ignore EDGE_BOTH */
|
|
|
|
mask = bank->enabled_non_wakeup_gpios & bank->context.risingdetect;
|
|
|
|
mask &= ~bank->context.fallingdetect;
|
|
|
|
bank->saved_datain &= ~mask;
|
|
|
|
|
2018-09-20 19:35:31 +00:00
|
|
|
if (!may_lose_context)
|
2011-11-15 07:22:38 +00:00
|
|
|
goto update_gpio_context_count;
|
2018-09-20 19:35:31 +00:00
|
|
|
|
2011-11-23 21:14:29 +00:00
|
|
|
/*
|
2019-03-25 22:43:16 +00:00
|
|
|
* If going to OFF, remove triggering for all wkup domain
|
2011-11-23 21:14:29 +00:00
|
|
|
* non-wakeup GPIOs. Otherwise spurious IRQs will be
|
|
|
|
* generated. See OMAP2420 Errata item 1.101.
|
|
|
|
*/
|
2019-03-25 22:43:16 +00:00
|
|
|
if (!bank->loses_context && bank->enabled_non_wakeup_gpios) {
|
|
|
|
nowake = bank->enabled_non_wakeup_gpios;
|
2019-06-10 17:10:55 +00:00
|
|
|
omap_gpio_rmw(base + bank->regs->fallingdetect, nowake, ~nowake);
|
|
|
|
omap_gpio_rmw(base + bank->regs->risingdetect, nowake, ~nowake);
|
2019-03-25 22:43:16 +00:00
|
|
|
}
|
2010-02-15 17:27:25 +00:00
|
|
|
|
2011-11-15 07:22:38 +00:00
|
|
|
update_gpio_context_count:
|
2011-11-23 21:14:29 +00:00
|
|
|
if (bank->get_context_loss_count)
|
|
|
|
bank->context_loss_count =
|
2016-03-04 15:25:35 +00:00
|
|
|
bank->get_context_loss_count(dev);
|
2011-09-28 23:17:25 +00:00
|
|
|
|
2014-06-27 20:17:37 +00:00
|
|
|
omap_gpio_dbck_disable(bank);
|
2006-12-07 01:13:52 +00:00
|
|
|
}
|
|
|
|
|
2018-09-20 19:35:31 +00:00
|
|
|
static void omap_gpio_unidle(struct gpio_bank *bank)
|
2006-12-07 01:13:52 +00:00
|
|
|
{
|
2018-09-20 19:35:31 +00:00
|
|
|
struct device *dev = bank->chip.parent;
|
2011-11-23 21:14:29 +00:00
|
|
|
u32 l = 0, gen, gen0, gen1;
|
2013-04-04 20:16:15 +00:00
|
|
|
int c;
|
2009-01-27 19:15:34 +00:00
|
|
|
|
2013-04-15 18:06:54 +00:00
|
|
|
/*
|
|
|
|
* On the first resume during the probe, the context has not
|
|
|
|
* been initialised and so initialise it now. Also initialise
|
|
|
|
* the context loss count.
|
|
|
|
*/
|
|
|
|
if (bank->loses_context && !bank->context_valid) {
|
|
|
|
omap_gpio_init_context(bank);
|
|
|
|
|
|
|
|
if (bank->get_context_loss_count)
|
|
|
|
bank->context_loss_count =
|
2016-03-04 15:25:35 +00:00
|
|
|
bank->get_context_loss_count(dev);
|
2013-04-15 18:06:54 +00:00
|
|
|
}
|
|
|
|
|
2014-06-27 20:17:37 +00:00
|
|
|
omap_gpio_dbck_enable(bank);
|
2012-03-05 23:10:04 +00:00
|
|
|
|
2013-04-04 20:16:15 +00:00
|
|
|
if (bank->loses_context) {
|
|
|
|
if (!bank->get_context_loss_count) {
|
2011-11-23 21:14:29 +00:00
|
|
|
omap_gpio_restore_context(bank);
|
|
|
|
} else {
|
2016-03-04 15:25:35 +00:00
|
|
|
c = bank->get_context_loss_count(dev);
|
2013-04-04 20:16:15 +00:00
|
|
|
if (c != bank->context_loss_count) {
|
|
|
|
omap_gpio_restore_context(bank);
|
|
|
|
} else {
|
2018-09-20 19:35:31 +00:00
|
|
|
return;
|
2013-04-04 20:16:15 +00:00
|
|
|
}
|
2011-09-28 23:17:25 +00:00
|
|
|
}
|
2019-03-25 22:43:16 +00:00
|
|
|
} else {
|
|
|
|
/* Restore changes done for OMAP2420 errata 1.101 */
|
|
|
|
writel_relaxed(bank->context.fallingdetect,
|
|
|
|
bank->base + bank->regs->fallingdetect);
|
|
|
|
writel_relaxed(bank->context.risingdetect,
|
|
|
|
bank->base + bank->regs->risingdetect);
|
2011-11-23 21:14:29 +00:00
|
|
|
}
|
2009-01-27 19:09:24 +00:00
|
|
|
|
2013-11-16 00:01:04 +00:00
|
|
|
l = readl_relaxed(bank->base + bank->regs->datain);
|
2010-02-15 17:27:25 +00:00
|
|
|
|
2011-11-23 21:14:29 +00:00
|
|
|
/*
|
|
|
|
* Check if any of the non-wakeup interrupt GPIOs have changed
|
|
|
|
* state. If so, generate an IRQ by software. This is
|
|
|
|
* horribly racy, but it's the best we can do to work around
|
|
|
|
* this silicon bug.
|
|
|
|
*/
|
|
|
|
l ^= bank->saved_datain;
|
|
|
|
l &= bank->enabled_non_wakeup_gpios;
|
2010-02-15 17:27:25 +00:00
|
|
|
|
2011-11-23 21:14:29 +00:00
|
|
|
/*
|
|
|
|
* No need to generate IRQs for the rising edge for gpio IRQs
|
|
|
|
* configured with falling edge only; and vice versa.
|
|
|
|
*/
|
2012-04-27 14:13:32 +00:00
|
|
|
gen0 = l & bank->context.fallingdetect;
|
2011-11-23 21:14:29 +00:00
|
|
|
gen0 &= bank->saved_datain;
|
2009-08-28 17:51:36 +00:00
|
|
|
|
2012-04-27 14:13:32 +00:00
|
|
|
gen1 = l & bank->context.risingdetect;
|
2011-11-23 21:14:29 +00:00
|
|
|
gen1 &= ~(bank->saved_datain);
|
2009-08-28 17:51:36 +00:00
|
|
|
|
2011-11-23 21:14:29 +00:00
|
|
|
/* FIXME: Consider GPIO IRQs with level detections properly! */
|
2012-04-27 14:13:32 +00:00
|
|
|
gen = l & (~(bank->context.fallingdetect) &
|
|
|
|
~(bank->context.risingdetect));
|
2011-11-23 21:14:29 +00:00
|
|
|
/* Consider all GPIO IRQs needed to be updated */
|
|
|
|
gen |= gen0 | gen1;
|
2009-08-28 17:51:36 +00:00
|
|
|
|
2011-11-23 21:14:29 +00:00
|
|
|
if (gen) {
|
|
|
|
u32 old0, old1;
|
2009-08-28 17:51:36 +00:00
|
|
|
|
2013-11-16 00:01:04 +00:00
|
|
|
old0 = readl_relaxed(bank->base + bank->regs->leveldetect0);
|
|
|
|
old1 = readl_relaxed(bank->base + bank->regs->leveldetect1);
|
2010-02-15 17:27:25 +00:00
|
|
|
|
2012-04-27 14:13:37 +00:00
|
|
|
if (!bank->regs->irqstatus_raw0) {
|
2013-11-16 00:01:04 +00:00
|
|
|
writel_relaxed(old0 | gen, bank->base +
|
2011-08-30 09:35:44 +00:00
|
|
|
bank->regs->leveldetect0);
|
2013-11-16 00:01:04 +00:00
|
|
|
writel_relaxed(old1 | gen, bank->base +
|
2011-08-30 09:35:44 +00:00
|
|
|
bank->regs->leveldetect1);
|
2011-11-23 21:14:29 +00:00
|
|
|
}
|
2011-08-30 09:35:44 +00:00
|
|
|
|
2012-04-27 14:13:37 +00:00
|
|
|
if (bank->regs->irqstatus_raw0) {
|
2013-11-16 00:01:04 +00:00
|
|
|
writel_relaxed(old0 | l, bank->base +
|
2011-08-30 09:35:44 +00:00
|
|
|
bank->regs->leveldetect0);
|
2013-11-16 00:01:04 +00:00
|
|
|
writel_relaxed(old1 | l, bank->base +
|
2011-08-30 09:35:44 +00:00
|
|
|
bank->regs->leveldetect1);
|
2006-12-07 01:13:52 +00:00
|
|
|
}
|
2013-11-16 00:01:04 +00:00
|
|
|
writel_relaxed(old0, bank->base + bank->regs->leveldetect0);
|
|
|
|
writel_relaxed(old1, bank->base + bank->regs->leveldetect1);
|
2011-11-23 21:14:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-07 10:33:32 +00:00
|
|
|
static int gpio_omap_cpu_notifier(struct notifier_block *nb,
|
|
|
|
unsigned long cmd, void *v)
|
2013-04-15 18:06:54 +00:00
|
|
|
{
|
2019-03-07 10:33:32 +00:00
|
|
|
struct gpio_bank *bank;
|
|
|
|
unsigned long flags;
|
2020-03-04 22:54:31 +00:00
|
|
|
int ret = NOTIFY_OK;
|
|
|
|
u32 isr, mask;
|
2013-04-15 18:06:54 +00:00
|
|
|
|
2019-03-07 10:33:32 +00:00
|
|
|
bank = container_of(nb, struct gpio_bank, nb);
|
2013-04-15 18:06:54 +00:00
|
|
|
|
2019-03-07 10:33:32 +00:00
|
|
|
raw_spin_lock_irqsave(&bank->lock, flags);
|
2020-03-04 22:54:31 +00:00
|
|
|
if (bank->is_suspended)
|
|
|
|
goto out_unlock;
|
|
|
|
|
2019-03-07 10:33:32 +00:00
|
|
|
switch (cmd) {
|
|
|
|
case CPU_CLUSTER_PM_ENTER:
|
2020-03-04 22:54:31 +00:00
|
|
|
mask = omap_get_gpio_irqbank_mask(bank);
|
|
|
|
isr = readl_relaxed(bank->base + bank->regs->irqstatus) & mask;
|
|
|
|
if (isr) {
|
|
|
|
ret = NOTIFY_BAD;
|
2019-03-07 10:33:32 +00:00
|
|
|
break;
|
2020-03-04 22:54:31 +00:00
|
|
|
}
|
2019-03-07 10:33:32 +00:00
|
|
|
omap_gpio_idle(bank, true);
|
|
|
|
break;
|
|
|
|
case CPU_CLUSTER_PM_ENTER_FAILED:
|
|
|
|
case CPU_CLUSTER_PM_EXIT:
|
|
|
|
omap_gpio_unidle(bank);
|
|
|
|
break;
|
|
|
|
}
|
2020-03-04 22:54:31 +00:00
|
|
|
|
|
|
|
out_unlock:
|
2019-03-07 10:33:32 +00:00
|
|
|
raw_spin_unlock_irqrestore(&bank->lock, flags);
|
2013-04-15 18:06:54 +00:00
|
|
|
|
2020-03-04 22:54:31 +00:00
|
|
|
return ret;
|
2018-09-20 19:35:31 +00:00
|
|
|
}
|
|
|
|
|
2019-06-10 17:11:00 +00:00
|
|
|
static const struct omap_gpio_reg_offs omap2_gpio_regs = {
|
2011-08-16 09:53:02 +00:00
|
|
|
.revision = OMAP24XX_GPIO_REVISION,
|
|
|
|
.direction = OMAP24XX_GPIO_OE,
|
|
|
|
.datain = OMAP24XX_GPIO_DATAIN,
|
|
|
|
.dataout = OMAP24XX_GPIO_DATAOUT,
|
|
|
|
.set_dataout = OMAP24XX_GPIO_SETDATAOUT,
|
|
|
|
.clr_dataout = OMAP24XX_GPIO_CLEARDATAOUT,
|
|
|
|
.irqstatus = OMAP24XX_GPIO_IRQSTATUS1,
|
|
|
|
.irqstatus2 = OMAP24XX_GPIO_IRQSTATUS2,
|
|
|
|
.irqenable = OMAP24XX_GPIO_IRQENABLE1,
|
|
|
|
.irqenable2 = OMAP24XX_GPIO_IRQENABLE2,
|
|
|
|
.set_irqenable = OMAP24XX_GPIO_SETIRQENABLE1,
|
|
|
|
.clr_irqenable = OMAP24XX_GPIO_CLEARIRQENABLE1,
|
|
|
|
.debounce = OMAP24XX_GPIO_DEBOUNCE_VAL,
|
|
|
|
.debounce_en = OMAP24XX_GPIO_DEBOUNCE_EN,
|
|
|
|
.ctrl = OMAP24XX_GPIO_CTRL,
|
|
|
|
.wkup_en = OMAP24XX_GPIO_WAKE_EN,
|
|
|
|
.leveldetect0 = OMAP24XX_GPIO_LEVELDETECT0,
|
|
|
|
.leveldetect1 = OMAP24XX_GPIO_LEVELDETECT1,
|
|
|
|
.risingdetect = OMAP24XX_GPIO_RISINGDETECT,
|
|
|
|
.fallingdetect = OMAP24XX_GPIO_FALLINGDETECT,
|
|
|
|
};
|
|
|
|
|
2019-06-10 17:11:00 +00:00
|
|
|
static const struct omap_gpio_reg_offs omap4_gpio_regs = {
|
2011-08-16 09:53:02 +00:00
|
|
|
.revision = OMAP4_GPIO_REVISION,
|
|
|
|
.direction = OMAP4_GPIO_OE,
|
|
|
|
.datain = OMAP4_GPIO_DATAIN,
|
|
|
|
.dataout = OMAP4_GPIO_DATAOUT,
|
|
|
|
.set_dataout = OMAP4_GPIO_SETDATAOUT,
|
|
|
|
.clr_dataout = OMAP4_GPIO_CLEARDATAOUT,
|
|
|
|
.irqstatus = OMAP4_GPIO_IRQSTATUS0,
|
|
|
|
.irqstatus2 = OMAP4_GPIO_IRQSTATUS1,
|
2019-06-10 17:10:45 +00:00
|
|
|
.irqstatus_raw0 = OMAP4_GPIO_IRQSTATUSRAW0,
|
|
|
|
.irqstatus_raw1 = OMAP4_GPIO_IRQSTATUSRAW1,
|
2011-08-16 09:53:02 +00:00
|
|
|
.irqenable = OMAP4_GPIO_IRQSTATUSSET0,
|
|
|
|
.irqenable2 = OMAP4_GPIO_IRQSTATUSSET1,
|
|
|
|
.set_irqenable = OMAP4_GPIO_IRQSTATUSSET0,
|
|
|
|
.clr_irqenable = OMAP4_GPIO_IRQSTATUSCLR0,
|
|
|
|
.debounce = OMAP4_GPIO_DEBOUNCINGTIME,
|
|
|
|
.debounce_en = OMAP4_GPIO_DEBOUNCENABLE,
|
|
|
|
.ctrl = OMAP4_GPIO_CTRL,
|
|
|
|
.wkup_en = OMAP4_GPIO_IRQWAKEN0,
|
|
|
|
.leveldetect0 = OMAP4_GPIO_LEVELDETECT0,
|
|
|
|
.leveldetect1 = OMAP4_GPIO_LEVELDETECT1,
|
|
|
|
.risingdetect = OMAP4_GPIO_RISINGDETECT,
|
|
|
|
.fallingdetect = OMAP4_GPIO_FALLINGDETECT,
|
|
|
|
};
|
|
|
|
|
2013-02-06 10:44:32 +00:00
|
|
|
static const struct omap_gpio_platform_data omap2_pdata = {
|
2011-08-16 09:53:02 +00:00
|
|
|
.regs = &omap2_gpio_regs,
|
|
|
|
.bank_width = 32,
|
|
|
|
.dbck_flag = false,
|
|
|
|
};
|
|
|
|
|
2013-02-06 10:44:32 +00:00
|
|
|
static const struct omap_gpio_platform_data omap3_pdata = {
|
2011-08-16 09:53:02 +00:00
|
|
|
.regs = &omap2_gpio_regs,
|
|
|
|
.bank_width = 32,
|
|
|
|
.dbck_flag = true,
|
|
|
|
};
|
|
|
|
|
2013-02-06 10:44:32 +00:00
|
|
|
static const struct omap_gpio_platform_data omap4_pdata = {
|
2011-08-16 09:53:02 +00:00
|
|
|
.regs = &omap4_gpio_regs,
|
|
|
|
.bank_width = 32,
|
|
|
|
.dbck_flag = true,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct of_device_id omap_gpio_match[] = {
|
|
|
|
{
|
|
|
|
.compatible = "ti,omap4-gpio",
|
|
|
|
.data = &omap4_pdata,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.compatible = "ti,omap3-gpio",
|
|
|
|
.data = &omap3_pdata,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.compatible = "ti,omap2-gpio",
|
|
|
|
.data = &omap2_pdata,
|
|
|
|
},
|
|
|
|
{ },
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(of, omap_gpio_match);
|
2019-03-07 10:33:32 +00:00
|
|
|
|
|
|
|
static int omap_gpio_probe(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct device *dev = &pdev->dev;
|
|
|
|
struct device_node *node = dev->of_node;
|
|
|
|
const struct of_device_id *match;
|
|
|
|
const struct omap_gpio_platform_data *pdata;
|
|
|
|
struct gpio_bank *bank;
|
|
|
|
struct irq_chip *irqc;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
match = of_match_device(of_match_ptr(omap_gpio_match), dev);
|
|
|
|
|
|
|
|
pdata = match ? match->data : dev_get_platdata(dev);
|
|
|
|
if (!pdata)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
bank = devm_kzalloc(dev, sizeof(*bank), GFP_KERNEL);
|
|
|
|
if (!bank)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
irqc = devm_kzalloc(dev, sizeof(*irqc), GFP_KERNEL);
|
|
|
|
if (!irqc)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
irqc->irq_startup = omap_gpio_irq_startup,
|
|
|
|
irqc->irq_shutdown = omap_gpio_irq_shutdown,
|
2019-06-10 17:10:48 +00:00
|
|
|
irqc->irq_ack = dummy_irq_chip.irq_ack,
|
2019-03-07 10:33:32 +00:00
|
|
|
irqc->irq_mask = omap_gpio_mask_irq,
|
|
|
|
irqc->irq_unmask = omap_gpio_unmask_irq,
|
|
|
|
irqc->irq_set_type = omap_gpio_irq_type,
|
|
|
|
irqc->irq_set_wake = omap_gpio_wake_enable,
|
|
|
|
irqc->irq_bus_lock = omap_gpio_irq_bus_lock,
|
|
|
|
irqc->irq_bus_sync_unlock = gpio_irq_bus_sync_unlock,
|
|
|
|
irqc->name = dev_name(&pdev->dev);
|
|
|
|
irqc->flags = IRQCHIP_MASK_ON_SUSPEND;
|
|
|
|
irqc->parent_device = dev;
|
|
|
|
|
|
|
|
bank->irq = platform_get_irq(pdev, 0);
|
|
|
|
if (bank->irq <= 0) {
|
|
|
|
if (!bank->irq)
|
|
|
|
bank->irq = -ENXIO;
|
2020-08-27 20:08:24 +00:00
|
|
|
return dev_err_probe(dev, bank->irq, "can't get irq resource\n");
|
2019-03-07 10:33:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bank->chip.parent = dev;
|
|
|
|
bank->chip.owner = THIS_MODULE;
|
|
|
|
bank->dbck_flag = pdata->dbck_flag;
|
|
|
|
bank->stride = pdata->bank_stride;
|
|
|
|
bank->width = pdata->bank_width;
|
|
|
|
bank->is_mpuio = pdata->is_mpuio;
|
|
|
|
bank->non_wakeup_gpios = pdata->non_wakeup_gpios;
|
|
|
|
bank->regs = pdata->regs;
|
|
|
|
#ifdef CONFIG_OF_GPIO
|
|
|
|
bank->chip.of_node = of_node_get(node);
|
2011-08-16 09:53:02 +00:00
|
|
|
#endif
|
|
|
|
|
2019-03-07 10:33:32 +00:00
|
|
|
if (node) {
|
|
|
|
if (!of_property_read_bool(node, "ti,gpio-always-on"))
|
|
|
|
bank->loses_context = true;
|
|
|
|
} else {
|
|
|
|
bank->loses_context = pdata->loses_context;
|
|
|
|
|
|
|
|
if (bank->loses_context)
|
|
|
|
bank->get_context_loss_count =
|
|
|
|
pdata->get_context_loss_count;
|
|
|
|
}
|
|
|
|
|
2019-06-10 17:10:53 +00:00
|
|
|
if (bank->regs->set_dataout && bank->regs->clr_dataout)
|
2019-03-07 10:33:32 +00:00
|
|
|
bank->set_dataout = omap_set_gpio_dataout_reg;
|
2019-06-10 17:10:53 +00:00
|
|
|
else
|
2019-03-07 10:33:32 +00:00
|
|
|
bank->set_dataout = omap_set_gpio_dataout_mask;
|
|
|
|
|
|
|
|
raw_spin_lock_init(&bank->lock);
|
|
|
|
raw_spin_lock_init(&bank->wa_lock);
|
|
|
|
|
|
|
|
/* Static mapping, never released */
|
2019-03-11 19:50:05 +00:00
|
|
|
bank->base = devm_platform_ioremap_resource(pdev, 0);
|
2019-03-07 10:33:32 +00:00
|
|
|
if (IS_ERR(bank->base)) {
|
|
|
|
return PTR_ERR(bank->base);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bank->dbck_flag) {
|
|
|
|
bank->dbck = devm_clk_get(dev, "dbclk");
|
|
|
|
if (IS_ERR(bank->dbck)) {
|
|
|
|
dev_err(dev,
|
|
|
|
"Could not get gpio dbck. Disable debounce\n");
|
|
|
|
bank->dbck_flag = false;
|
|
|
|
} else {
|
|
|
|
clk_prepare(bank->dbck);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
platform_set_drvdata(pdev, bank);
|
|
|
|
|
|
|
|
pm_runtime_enable(dev);
|
|
|
|
pm_runtime_get_sync(dev);
|
|
|
|
|
|
|
|
if (bank->is_mpuio)
|
|
|
|
omap_mpuio_init(bank);
|
|
|
|
|
|
|
|
omap_gpio_mod_init(bank);
|
|
|
|
|
|
|
|
ret = omap_gpio_chip_init(bank, irqc);
|
|
|
|
if (ret) {
|
|
|
|
pm_runtime_put_sync(dev);
|
|
|
|
pm_runtime_disable(dev);
|
|
|
|
if (bank->dbck_flag)
|
|
|
|
clk_unprepare(bank->dbck);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
omap_gpio_show_rev(bank);
|
|
|
|
|
2019-04-08 19:46:53 +00:00
|
|
|
bank->nb.notifier_call = gpio_omap_cpu_notifier;
|
|
|
|
cpu_pm_register_notifier(&bank->nb);
|
2019-03-07 10:33:32 +00:00
|
|
|
|
|
|
|
pm_runtime_put(dev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int omap_gpio_remove(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct gpio_bank *bank = platform_get_drvdata(pdev);
|
|
|
|
|
2019-04-08 19:46:53 +00:00
|
|
|
cpu_pm_unregister_notifier(&bank->nb);
|
2019-03-07 10:33:32 +00:00
|
|
|
gpiochip_remove(&bank->chip);
|
|
|
|
pm_runtime_disable(&pdev->dev);
|
|
|
|
if (bank->dbck_flag)
|
|
|
|
clk_unprepare(bank->dbck);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __maybe_unused omap_gpio_runtime_suspend(struct device *dev)
|
|
|
|
{
|
|
|
|
struct gpio_bank *bank = dev_get_drvdata(dev);
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
raw_spin_lock_irqsave(&bank->lock, flags);
|
|
|
|
omap_gpio_idle(bank, true);
|
|
|
|
bank->is_suspended = true;
|
|
|
|
raw_spin_unlock_irqrestore(&bank->lock, flags);
|
|
|
|
|
2019-04-10 19:51:13 +00:00
|
|
|
return 0;
|
2019-03-07 10:33:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int __maybe_unused omap_gpio_runtime_resume(struct device *dev)
|
|
|
|
{
|
|
|
|
struct gpio_bank *bank = dev_get_drvdata(dev);
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
raw_spin_lock_irqsave(&bank->lock, flags);
|
|
|
|
omap_gpio_unidle(bank);
|
|
|
|
bank->is_suspended = false;
|
|
|
|
raw_spin_unlock_irqrestore(&bank->lock, flags);
|
|
|
|
|
2019-04-10 19:51:13 +00:00
|
|
|
return 0;
|
2019-03-07 10:33:32 +00:00
|
|
|
}
|
|
|
|
|
2020-08-19 09:24:45 +00:00
|
|
|
static int __maybe_unused omap_gpio_suspend(struct device *dev)
|
2020-06-29 16:41:14 +00:00
|
|
|
{
|
|
|
|
struct gpio_bank *bank = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
if (bank->is_suspended)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
bank->needs_resume = 1;
|
|
|
|
|
|
|
|
return omap_gpio_runtime_suspend(dev);
|
|
|
|
}
|
|
|
|
|
2020-08-19 09:24:45 +00:00
|
|
|
static int __maybe_unused omap_gpio_resume(struct device *dev)
|
2020-06-29 16:41:14 +00:00
|
|
|
{
|
|
|
|
struct gpio_bank *bank = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
if (!bank->needs_resume)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
bank->needs_resume = 0;
|
|
|
|
|
|
|
|
return omap_gpio_runtime_resume(dev);
|
|
|
|
}
|
|
|
|
|
2019-03-07 10:33:32 +00:00
|
|
|
static const struct dev_pm_ops gpio_pm_ops = {
|
|
|
|
SET_RUNTIME_PM_OPS(omap_gpio_runtime_suspend, omap_gpio_runtime_resume,
|
|
|
|
NULL)
|
2020-06-29 16:41:14 +00:00
|
|
|
SET_LATE_SYSTEM_SLEEP_PM_OPS(omap_gpio_suspend, omap_gpio_resume)
|
2019-03-07 10:33:32 +00:00
|
|
|
};
|
|
|
|
|
2010-12-08 00:26:57 +00:00
|
|
|
static struct platform_driver omap_gpio_driver = {
|
|
|
|
.probe = omap_gpio_probe,
|
2015-04-23 23:56:22 +00:00
|
|
|
.remove = omap_gpio_remove,
|
2010-12-08 00:26:57 +00:00
|
|
|
.driver = {
|
|
|
|
.name = "omap_gpio",
|
2011-09-29 01:53:22 +00:00
|
|
|
.pm = &gpio_pm_ops,
|
2019-03-07 10:33:32 +00:00
|
|
|
.of_match_table = omap_gpio_match,
|
2010-12-08 00:26:57 +00:00
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2005-07-10 18:58:15 +00:00
|
|
|
/*
|
2010-12-08 00:26:57 +00:00
|
|
|
* gpio driver register needs to be done before
|
|
|
|
* machine_init functions access gpio APIs.
|
|
|
|
* Hence omap_gpio_drv_reg() is a postcore_initcall.
|
2005-07-10 18:58:15 +00:00
|
|
|
*/
|
2010-12-08 00:26:57 +00:00
|
|
|
static int __init omap_gpio_drv_reg(void)
|
2005-07-10 18:58:15 +00:00
|
|
|
{
|
2010-12-08 00:26:57 +00:00
|
|
|
return platform_driver_register(&omap_gpio_driver);
|
2005-07-10 18:58:15 +00:00
|
|
|
}
|
2010-12-08 00:26:57 +00:00
|
|
|
postcore_initcall(omap_gpio_drv_reg);
|
2015-04-23 23:56:22 +00:00
|
|
|
|
|
|
|
static void __exit omap_gpio_exit(void)
|
|
|
|
{
|
|
|
|
platform_driver_unregister(&omap_gpio_driver);
|
|
|
|
}
|
|
|
|
module_exit(omap_gpio_exit);
|
|
|
|
|
|
|
|
MODULE_DESCRIPTION("omap gpio driver");
|
|
|
|
MODULE_ALIAS("platform:gpio-omap");
|
|
|
|
MODULE_LICENSE("GPL v2");
|