mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-28 18:51:56 -04:00
Merge branch 'master' into for-next
Fast-forwarded to current state of Linus' tree as there are patches to be applied for files that didn't exist on the old branch.
This commit is contained in:
Jiri Kosina
commit
07f9479a40
6039 changed files with 191389 additions and 81783 deletions
|
|
@ -100,18 +100,21 @@ config GPIO_VR41XX
|
|||
Say yes here to support the NEC VR4100 series General-purpose I/O Uint
|
||||
|
||||
config GPIO_SCH
|
||||
tristate "Intel SCH GPIO"
|
||||
tristate "Intel SCH/TunnelCreek GPIO"
|
||||
depends on GPIOLIB && PCI && X86
|
||||
select MFD_CORE
|
||||
select LPC_SCH
|
||||
help
|
||||
Say yes here to support GPIO interface on Intel Poulsbo SCH.
|
||||
Say yes here to support GPIO interface on Intel Poulsbo SCH
|
||||
or Intel Tunnel Creek processor.
|
||||
The Intel SCH contains a total of 14 GPIO pins. Ten GPIOs are
|
||||
powered by the core power rail and are turned off during sleep
|
||||
modes (S3 and higher). The remaining four GPIOs are powered by
|
||||
the Intel SCH suspend power supply. These GPIOs remain
|
||||
active during S3. The suspend powered GPIOs can be used to wake the
|
||||
system from the Suspend-to-RAM state.
|
||||
The Intel Tunnel Creek processor has 5 GPIOs powered by the
|
||||
core power rail and 9 from suspend power supply.
|
||||
|
||||
This driver can also be built as a module. If so, the module
|
||||
will be called sch-gpio.
|
||||
|
|
@ -411,4 +414,9 @@ config GPIO_JANZ_TTL
|
|||
This driver provides support for driving the pins in output
|
||||
mode only. Input mode is not supported.
|
||||
|
||||
config AB8500_GPIO
|
||||
bool "ST-Ericsson AB8500 Mixed Signal Circuit gpio functions"
|
||||
depends on AB8500_CORE && BROKEN
|
||||
help
|
||||
Select this to enable the AB8500 IC GPIO driver
|
||||
endif
|
||||
|
|
|
|||
|
|
@ -42,3 +42,4 @@ obj-$(CONFIG_GPIO_JANZ_TTL) += janz-ttl.o
|
|||
obj-$(CONFIG_GPIO_SX150X) += sx150x.o
|
||||
obj-$(CONFIG_GPIO_VX855) += vx855_gpio.o
|
||||
obj-$(CONFIG_GPIO_ML_IOH) += ml_ioh_gpio.o
|
||||
obj-$(CONFIG_AB8500_GPIO) += ab8500-gpio.o
|
||||
|
|
|
|||
522
drivers/gpio/ab8500-gpio.c
Normal file
522
drivers/gpio/ab8500-gpio.c
Normal file
|
|
@ -0,0 +1,522 @@
|
|||
/*
|
||||
* Copyright (C) ST-Ericsson SA 2011
|
||||
*
|
||||
* Author: BIBEK BASU <bibek.basu@stericsson.com>
|
||||
* License terms: GNU General Public License (GPL) version 2
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*/
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/types.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/platform_device.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/gpio.h>
|
||||
#include <linux/irq.h>
|
||||
#include <linux/interrupt.h>
|
||||
#include <linux/mfd/ab8500.h>
|
||||
#include <linux/mfd/abx500.h>
|
||||
#include <linux/mfd/ab8500/gpio.h>
|
||||
|
||||
/*
|
||||
* GPIO registers offset
|
||||
* Bank: 0x10
|
||||
*/
|
||||
#define AB8500_GPIO_SEL1_REG 0x00
|
||||
#define AB8500_GPIO_SEL2_REG 0x01
|
||||
#define AB8500_GPIO_SEL3_REG 0x02
|
||||
#define AB8500_GPIO_SEL4_REG 0x03
|
||||
#define AB8500_GPIO_SEL5_REG 0x04
|
||||
#define AB8500_GPIO_SEL6_REG 0x05
|
||||
|
||||
#define AB8500_GPIO_DIR1_REG 0x10
|
||||
#define AB8500_GPIO_DIR2_REG 0x11
|
||||
#define AB8500_GPIO_DIR3_REG 0x12
|
||||
#define AB8500_GPIO_DIR4_REG 0x13
|
||||
#define AB8500_GPIO_DIR5_REG 0x14
|
||||
#define AB8500_GPIO_DIR6_REG 0x15
|
||||
|
||||
#define AB8500_GPIO_OUT1_REG 0x20
|
||||
#define AB8500_GPIO_OUT2_REG 0x21
|
||||
#define AB8500_GPIO_OUT3_REG 0x22
|
||||
#define AB8500_GPIO_OUT4_REG 0x23
|
||||
#define AB8500_GPIO_OUT5_REG 0x24
|
||||
#define AB8500_GPIO_OUT6_REG 0x25
|
||||
|
||||
#define AB8500_GPIO_PUD1_REG 0x30
|
||||
#define AB8500_GPIO_PUD2_REG 0x31
|
||||
#define AB8500_GPIO_PUD3_REG 0x32
|
||||
#define AB8500_GPIO_PUD4_REG 0x33
|
||||
#define AB8500_GPIO_PUD5_REG 0x34
|
||||
#define AB8500_GPIO_PUD6_REG 0x35
|
||||
|
||||
#define AB8500_GPIO_IN1_REG 0x40
|
||||
#define AB8500_GPIO_IN2_REG 0x41
|
||||
#define AB8500_GPIO_IN3_REG 0x42
|
||||
#define AB8500_GPIO_IN4_REG 0x43
|
||||
#define AB8500_GPIO_IN5_REG 0x44
|
||||
#define AB8500_GPIO_IN6_REG 0x45
|
||||
#define AB8500_GPIO_ALTFUN_REG 0x45
|
||||
#define ALTFUN_REG_INDEX 6
|
||||
#define AB8500_NUM_GPIO 42
|
||||
#define AB8500_NUM_VIR_GPIO_IRQ 16
|
||||
|
||||
enum ab8500_gpio_action {
|
||||
NONE,
|
||||
STARTUP,
|
||||
SHUTDOWN,
|
||||
MASK,
|
||||
UNMASK
|
||||
};
|
||||
|
||||
struct ab8500_gpio {
|
||||
struct gpio_chip chip;
|
||||
struct ab8500 *parent;
|
||||
struct device *dev;
|
||||
struct mutex lock;
|
||||
u32 irq_base;
|
||||
enum ab8500_gpio_action irq_action;
|
||||
u16 rising;
|
||||
u16 falling;
|
||||
};
|
||||
/**
|
||||
* to_ab8500_gpio() - get the pointer to ab8500_gpio
|
||||
* @chip: Member of the structure ab8500_gpio
|
||||
*/
|
||||
static inline struct ab8500_gpio *to_ab8500_gpio(struct gpio_chip *chip)
|
||||
{
|
||||
return container_of(chip, struct ab8500_gpio, chip);
|
||||
}
|
||||
|
||||
static int ab8500_gpio_set_bits(struct gpio_chip *chip, u8 reg,
|
||||
unsigned offset, int val)
|
||||
{
|
||||
struct ab8500_gpio *ab8500_gpio = to_ab8500_gpio(chip);
|
||||
u8 pos = offset % 8;
|
||||
int ret;
|
||||
|
||||
reg = reg + (offset / 8);
|
||||
ret = abx500_mask_and_set_register_interruptible(ab8500_gpio->dev,
|
||||
AB8500_MISC, reg, 1 << pos, val << pos);
|
||||
if (ret < 0)
|
||||
dev_err(ab8500_gpio->dev, "%s write failed\n", __func__);
|
||||
return ret;
|
||||
}
|
||||
/**
|
||||
* ab8500_gpio_get() - Get the particular GPIO value
|
||||
* @chip: Gpio device
|
||||
* @offset: GPIO number to read
|
||||
*/
|
||||
static int ab8500_gpio_get(struct gpio_chip *chip, unsigned offset)
|
||||
{
|
||||
struct ab8500_gpio *ab8500_gpio = to_ab8500_gpio(chip);
|
||||
u8 mask = 1 << (offset % 8);
|
||||
u8 reg = AB8500_GPIO_OUT1_REG + (offset / 8);
|
||||
int ret;
|
||||
u8 data;
|
||||
ret = abx500_get_register_interruptible(ab8500_gpio->dev, AB8500_MISC,
|
||||
reg, &data);
|
||||
if (ret < 0) {
|
||||
dev_err(ab8500_gpio->dev, "%s read failed\n", __func__);
|
||||
return ret;
|
||||
}
|
||||
return (data & mask) >> (offset % 8);
|
||||
}
|
||||
|
||||
static void ab8500_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
|
||||
{
|
||||
struct ab8500_gpio *ab8500_gpio = to_ab8500_gpio(chip);
|
||||
int ret;
|
||||
/* Write the data */
|
||||
ret = ab8500_gpio_set_bits(chip, AB8500_GPIO_OUT1_REG, offset, 1);
|
||||
if (ret < 0)
|
||||
dev_err(ab8500_gpio->dev, "%s write failed\n", __func__);
|
||||
}
|
||||
|
||||
static int ab8500_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
|
||||
int val)
|
||||
{
|
||||
int ret;
|
||||
/* set direction as output */
|
||||
ret = ab8500_gpio_set_bits(chip, AB8500_GPIO_DIR1_REG, offset, 1);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
/* disable pull down */
|
||||
ret = ab8500_gpio_set_bits(chip, AB8500_GPIO_PUD1_REG, offset, 1);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
/* set the output as 1 or 0 */
|
||||
return ab8500_gpio_set_bits(chip, AB8500_GPIO_OUT1_REG, offset, val);
|
||||
|
||||
}
|
||||
|
||||
static int ab8500_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
|
||||
{
|
||||
/* set the register as input */
|
||||
return ab8500_gpio_set_bits(chip, AB8500_GPIO_DIR1_REG, offset, 0);
|
||||
}
|
||||
|
||||
static int ab8500_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
|
||||
{
|
||||
/*
|
||||
* Only some GPIOs are interrupt capable, and they are
|
||||
* organized in discontiguous clusters:
|
||||
*
|
||||
* GPIO6 to GPIO13
|
||||
* GPIO24 and GPIO25
|
||||
* GPIO36 to GPIO41
|
||||
*/
|
||||
static struct ab8500_gpio_irq_cluster {
|
||||
int start;
|
||||
int end;
|
||||
} clusters[] = {
|
||||
{.start = 6, .end = 13},
|
||||
{.start = 24, .end = 25},
|
||||
{.start = 36, .end = 41},
|
||||
};
|
||||
struct ab8500_gpio *ab8500_gpio = to_ab8500_gpio(chip);
|
||||
int base = ab8500_gpio->irq_base;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(clusters); i++) {
|
||||
struct ab8500_gpio_irq_cluster *cluster = &clusters[i];
|
||||
|
||||
if (offset >= cluster->start && offset <= cluster->end)
|
||||
return base + offset - cluster->start;
|
||||
|
||||
/* Advance by the number of gpios in this cluster */
|
||||
base += cluster->end - cluster->start + 1;
|
||||
}
|
||||
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
static struct gpio_chip ab8500gpio_chip = {
|
||||
.label = "ab8500_gpio",
|
||||
.owner = THIS_MODULE,
|
||||
.direction_input = ab8500_gpio_direction_input,
|
||||
.get = ab8500_gpio_get,
|
||||
.direction_output = ab8500_gpio_direction_output,
|
||||
.set = ab8500_gpio_set,
|
||||
.to_irq = ab8500_gpio_to_irq,
|
||||
};
|
||||
|
||||
static unsigned int irq_to_rising(unsigned int irq)
|
||||
{
|
||||
struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
|
||||
int offset = irq - ab8500_gpio->irq_base;
|
||||
int new_irq = offset + AB8500_INT_GPIO6R
|
||||
+ ab8500_gpio->parent->irq_base;
|
||||
return new_irq;
|
||||
}
|
||||
|
||||
static unsigned int irq_to_falling(unsigned int irq)
|
||||
{
|
||||
struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
|
||||
int offset = irq - ab8500_gpio->irq_base;
|
||||
int new_irq = offset + AB8500_INT_GPIO6F
|
||||
+ ab8500_gpio->parent->irq_base;
|
||||
return new_irq;
|
||||
|
||||
}
|
||||
|
||||
static unsigned int rising_to_irq(unsigned int irq, void *dev)
|
||||
{
|
||||
struct ab8500_gpio *ab8500_gpio = dev;
|
||||
int offset = irq - AB8500_INT_GPIO6R
|
||||
- ab8500_gpio->parent->irq_base ;
|
||||
int new_irq = offset + ab8500_gpio->irq_base;
|
||||
return new_irq;
|
||||
}
|
||||
|
||||
static unsigned int falling_to_irq(unsigned int irq, void *dev)
|
||||
{
|
||||
struct ab8500_gpio *ab8500_gpio = dev;
|
||||
int offset = irq - AB8500_INT_GPIO6F
|
||||
- ab8500_gpio->parent->irq_base ;
|
||||
int new_irq = offset + ab8500_gpio->irq_base;
|
||||
return new_irq;
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
* IRQ handler
|
||||
*/
|
||||
|
||||
static irqreturn_t handle_rising(int irq, void *dev)
|
||||
{
|
||||
|
||||
handle_nested_irq(rising_to_irq(irq , dev));
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
|
||||
static irqreturn_t handle_falling(int irq, void *dev)
|
||||
{
|
||||
|
||||
handle_nested_irq(falling_to_irq(irq, dev));
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
|
||||
static void ab8500_gpio_irq_lock(unsigned int irq)
|
||||
{
|
||||
struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
|
||||
mutex_lock(&ab8500_gpio->lock);
|
||||
}
|
||||
|
||||
static void ab8500_gpio_irq_sync_unlock(unsigned int irq)
|
||||
{
|
||||
struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
|
||||
int offset = irq - ab8500_gpio->irq_base;
|
||||
bool rising = ab8500_gpio->rising & BIT(offset);
|
||||
bool falling = ab8500_gpio->falling & BIT(offset);
|
||||
int ret;
|
||||
|
||||
switch (ab8500_gpio->irq_action) {
|
||||
case STARTUP:
|
||||
if (rising)
|
||||
ret = request_threaded_irq(irq_to_rising(irq),
|
||||
NULL, handle_rising,
|
||||
IRQF_TRIGGER_RISING,
|
||||
"ab8500-gpio-r", ab8500_gpio);
|
||||
if (falling)
|
||||
ret = request_threaded_irq(irq_to_falling(irq),
|
||||
NULL, handle_falling,
|
||||
IRQF_TRIGGER_FALLING,
|
||||
"ab8500-gpio-f", ab8500_gpio);
|
||||
break;
|
||||
case SHUTDOWN:
|
||||
if (rising)
|
||||
free_irq(irq_to_rising(irq), ab8500_gpio);
|
||||
if (falling)
|
||||
free_irq(irq_to_falling(irq), ab8500_gpio);
|
||||
break;
|
||||
case MASK:
|
||||
if (rising)
|
||||
disable_irq(irq_to_rising(irq));
|
||||
if (falling)
|
||||
disable_irq(irq_to_falling(irq));
|
||||
break;
|
||||
case UNMASK:
|
||||
if (rising)
|
||||
enable_irq(irq_to_rising(irq));
|
||||
if (falling)
|
||||
enable_irq(irq_to_falling(irq));
|
||||
break;
|
||||
case NONE:
|
||||
break;
|
||||
}
|
||||
ab8500_gpio->irq_action = NONE;
|
||||
ab8500_gpio->rising &= ~(BIT(offset));
|
||||
ab8500_gpio->falling &= ~(BIT(offset));
|
||||
mutex_unlock(&ab8500_gpio->lock);
|
||||
}
|
||||
|
||||
|
||||
static void ab8500_gpio_irq_mask(unsigned int irq)
|
||||
{
|
||||
struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
|
||||
ab8500_gpio->irq_action = MASK;
|
||||
}
|
||||
|
||||
static void ab8500_gpio_irq_unmask(unsigned int irq)
|
||||
{
|
||||
struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
|
||||
ab8500_gpio->irq_action = UNMASK;
|
||||
}
|
||||
|
||||
static int ab8500_gpio_irq_set_type(unsigned int irq, unsigned int type)
|
||||
{
|
||||
struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
|
||||
int offset = irq - ab8500_gpio->irq_base;
|
||||
|
||||
if (type == IRQ_TYPE_EDGE_BOTH) {
|
||||
ab8500_gpio->rising = BIT(offset);
|
||||
ab8500_gpio->falling = BIT(offset);
|
||||
} else if (type == IRQ_TYPE_EDGE_RISING) {
|
||||
ab8500_gpio->rising = BIT(offset);
|
||||
} else {
|
||||
ab8500_gpio->falling = BIT(offset);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
unsigned int ab8500_gpio_irq_startup(unsigned int irq)
|
||||
{
|
||||
struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
|
||||
ab8500_gpio->irq_action = STARTUP;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void ab8500_gpio_irq_shutdown(unsigned int irq)
|
||||
{
|
||||
struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
|
||||
ab8500_gpio->irq_action = SHUTDOWN;
|
||||
}
|
||||
|
||||
static struct irq_chip ab8500_gpio_irq_chip = {
|
||||
.name = "ab8500-gpio",
|
||||
.startup = ab8500_gpio_irq_startup,
|
||||
.shutdown = ab8500_gpio_irq_shutdown,
|
||||
.bus_lock = ab8500_gpio_irq_lock,
|
||||
.bus_sync_unlock = ab8500_gpio_irq_sync_unlock,
|
||||
.mask = ab8500_gpio_irq_mask,
|
||||
.unmask = ab8500_gpio_irq_unmask,
|
||||
.set_type = ab8500_gpio_irq_set_type,
|
||||
};
|
||||
|
||||
static int ab8500_gpio_irq_init(struct ab8500_gpio *ab8500_gpio)
|
||||
{
|
||||
u32 base = ab8500_gpio->irq_base;
|
||||
int irq;
|
||||
|
||||
for (irq = base; irq < base + AB8500_NUM_VIR_GPIO_IRQ ; irq++) {
|
||||
set_irq_chip_data(irq, ab8500_gpio);
|
||||
set_irq_chip_and_handler(irq, &ab8500_gpio_irq_chip,
|
||||
handle_simple_irq);
|
||||
set_irq_nested_thread(irq, 1);
|
||||
#ifdef CONFIG_ARM
|
||||
set_irq_flags(irq, IRQF_VALID);
|
||||
#else
|
||||
set_irq_noprobe(irq);
|
||||
#endif
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void ab8500_gpio_irq_remove(struct ab8500_gpio *ab8500_gpio)
|
||||
{
|
||||
int base = ab8500_gpio->irq_base;
|
||||
int irq;
|
||||
|
||||
for (irq = base; irq < base + AB8500_NUM_VIR_GPIO_IRQ; irq++) {
|
||||
#ifdef CONFIG_ARM
|
||||
set_irq_flags(irq, 0);
|
||||
#endif
|
||||
set_irq_chip_and_handler(irq, NULL, NULL);
|
||||
set_irq_chip_data(irq, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
static int __devinit ab8500_gpio_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct ab8500_platform_data *ab8500_pdata =
|
||||
dev_get_platdata(pdev->dev.parent);
|
||||
struct ab8500_gpio_platform_data *pdata;
|
||||
struct ab8500_gpio *ab8500_gpio;
|
||||
int ret;
|
||||
int i;
|
||||
|
||||
pdata = ab8500_pdata->gpio;
|
||||
if (!pdata) {
|
||||
dev_err(&pdev->dev, "gpio platform data missing\n");
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
ab8500_gpio = kzalloc(sizeof(struct ab8500_gpio), GFP_KERNEL);
|
||||
if (ab8500_gpio == NULL) {
|
||||
dev_err(&pdev->dev, "failed to allocate memory\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
ab8500_gpio->dev = &pdev->dev;
|
||||
ab8500_gpio->parent = dev_get_drvdata(pdev->dev.parent);
|
||||
ab8500_gpio->chip = ab8500gpio_chip;
|
||||
ab8500_gpio->chip.ngpio = AB8500_NUM_GPIO;
|
||||
ab8500_gpio->chip.dev = &pdev->dev;
|
||||
ab8500_gpio->chip.base = pdata->gpio_base;
|
||||
ab8500_gpio->irq_base = pdata->irq_base;
|
||||
/* initialize the lock */
|
||||
mutex_init(&ab8500_gpio->lock);
|
||||
/*
|
||||
* AB8500 core will handle and clear the IRQ
|
||||
* configre GPIO based on config-reg value.
|
||||
* These values are for selecting the PINs as
|
||||
* GPIO or alternate function
|
||||
*/
|
||||
for (i = AB8500_GPIO_SEL1_REG; i <= AB8500_GPIO_SEL6_REG; i++) {
|
||||
ret = abx500_set_register_interruptible(ab8500_gpio->dev,
|
||||
AB8500_MISC, i,
|
||||
pdata->config_reg[i]);
|
||||
if (ret < 0)
|
||||
goto out_free;
|
||||
}
|
||||
ret = abx500_set_register_interruptible(ab8500_gpio->dev, AB8500_MISC,
|
||||
AB8500_GPIO_ALTFUN_REG,
|
||||
pdata->config_reg[ALTFUN_REG_INDEX]);
|
||||
if (ret < 0)
|
||||
goto out_free;
|
||||
|
||||
ret = ab8500_gpio_irq_init(ab8500_gpio);
|
||||
if (ret)
|
||||
goto out_free;
|
||||
ret = gpiochip_add(&ab8500_gpio->chip);
|
||||
if (ret) {
|
||||
dev_err(&pdev->dev, "unable to add gpiochip: %d\n",
|
||||
ret);
|
||||
goto out_rem_irq;
|
||||
}
|
||||
platform_set_drvdata(pdev, ab8500_gpio);
|
||||
return 0;
|
||||
|
||||
out_rem_irq:
|
||||
ab8500_gpio_irq_remove(ab8500_gpio);
|
||||
out_free:
|
||||
mutex_destroy(&ab8500_gpio->lock);
|
||||
kfree(ab8500_gpio);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* ab8500_gpio_remove() - remove Ab8500-gpio driver
|
||||
* @pdev : Platform device registered
|
||||
*/
|
||||
static int __devexit ab8500_gpio_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct ab8500_gpio *ab8500_gpio = platform_get_drvdata(pdev);
|
||||
int ret;
|
||||
|
||||
ret = gpiochip_remove(&ab8500_gpio->chip);
|
||||
if (ret < 0) {
|
||||
dev_err(ab8500_gpio->dev, "unable to remove gpiochip:\
|
||||
%d\n", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
mutex_destroy(&ab8500_gpio->lock);
|
||||
kfree(ab8500_gpio);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct platform_driver ab8500_gpio_driver = {
|
||||
.driver = {
|
||||
.name = "ab8500-gpio",
|
||||
.owner = THIS_MODULE,
|
||||
},
|
||||
.probe = ab8500_gpio_probe,
|
||||
.remove = __devexit_p(ab8500_gpio_remove),
|
||||
};
|
||||
|
||||
static int __init ab8500_gpio_init(void)
|
||||
{
|
||||
return platform_driver_register(&ab8500_gpio_driver);
|
||||
}
|
||||
arch_initcall(ab8500_gpio_init);
|
||||
|
||||
static void __exit ab8500_gpio_exit(void)
|
||||
{
|
||||
platform_driver_unregister(&ab8500_gpio_driver);
|
||||
}
|
||||
module_exit(ab8500_gpio_exit);
|
||||
|
||||
MODULE_AUTHOR("BIBEK BASU <[email protected]>");
|
||||
MODULE_DESCRIPTION("Driver allows to use AB8500 unused pins\
|
||||
to be used as GPIO");
|
||||
MODULE_ALIAS("AB8500 GPIO driver");
|
||||
MODULE_LICENSE("GPL v2");
|
||||
|
|
@ -289,10 +289,10 @@ static int adp5588_irq_setup(struct adp5588_gpio *dev)
|
|||
|
||||
for (gpio = 0; gpio < dev->gpio_chip.ngpio; gpio++) {
|
||||
int irq = gpio + dev->irq_base;
|
||||
set_irq_chip_data(irq, dev);
|
||||
set_irq_chip_and_handler(irq, &adp5588_irq_chip,
|
||||
irq_set_chip_data(irq, dev);
|
||||
irq_set_chip_and_handler(irq, &adp5588_irq_chip,
|
||||
handle_level_irq);
|
||||
set_irq_nested_thread(irq, 1);
|
||||
irq_set_nested_thread(irq, 1);
|
||||
#ifdef CONFIG_ARM
|
||||
/*
|
||||
* ARM needs us to explicitly flag the IRQ as VALID,
|
||||
|
|
@ -300,7 +300,7 @@ static int adp5588_irq_setup(struct adp5588_gpio *dev)
|
|||
*/
|
||||
set_irq_flags(irq, IRQF_VALID);
|
||||
#else
|
||||
set_irq_noprobe(irq);
|
||||
irq_set_noprobe(irq);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1656,51 +1656,6 @@ static void gpiolib_dbg_show(struct seq_file *s, struct gpio_chip *chip)
|
|||
chip->get
|
||||
? (chip->get(chip, i) ? "hi" : "lo")
|
||||
: "? ");
|
||||
|
||||
if (!is_out) {
|
||||
int irq = gpio_to_irq(gpio);
|
||||
struct irq_desc *desc = irq_to_desc(irq);
|
||||
|
||||
/* This races with request_irq(), set_irq_type(),
|
||||
* and set_irq_wake() ... but those are "rare".
|
||||
*
|
||||
* More significantly, trigger type flags aren't
|
||||
* currently maintained by genirq.
|
||||
*/
|
||||
if (irq >= 0 && desc->action) {
|
||||
char *trigger;
|
||||
|
||||
switch (desc->status & IRQ_TYPE_SENSE_MASK) {
|
||||
case IRQ_TYPE_NONE:
|
||||
trigger = "(default)";
|
||||
break;
|
||||
case IRQ_TYPE_EDGE_FALLING:
|
||||
trigger = "edge-falling";
|
||||
break;
|
||||
case IRQ_TYPE_EDGE_RISING:
|
||||
trigger = "edge-rising";
|
||||
break;
|
||||
case IRQ_TYPE_EDGE_BOTH:
|
||||
trigger = "edge-both";
|
||||
break;
|
||||
case IRQ_TYPE_LEVEL_HIGH:
|
||||
trigger = "level-high";
|
||||
break;
|
||||
case IRQ_TYPE_LEVEL_LOW:
|
||||
trigger = "level-low";
|
||||
break;
|
||||
default:
|
||||
trigger = "?trigger?";
|
||||
break;
|
||||
}
|
||||
|
||||
seq_printf(s, " irq-%d %s%s",
|
||||
irq, trigger,
|
||||
(desc->status & IRQ_WAKEUP)
|
||||
? " wakeup" : "");
|
||||
}
|
||||
}
|
||||
|
||||
seq_printf(s, "\n");
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,6 +15,7 @@
|
|||
#include <linux/interrupt.h>
|
||||
#include <linux/delay.h>
|
||||
#include <linux/platform_device.h>
|
||||
#include <linux/mfd/core.h>
|
||||
#include <linux/io.h>
|
||||
#include <linux/gpio.h>
|
||||
#include <linux/slab.h>
|
||||
|
|
@ -149,7 +150,7 @@ static int __devinit ttl_probe(struct platform_device *pdev)
|
|||
struct resource *res;
|
||||
int ret;
|
||||
|
||||
pdata = pdev->dev.platform_data;
|
||||
pdata = mfd_get_data(pdev);
|
||||
if (!pdata) {
|
||||
dev_err(dev, "no platform data\n");
|
||||
ret = -ENXIO;
|
||||
|
|
|
|||
|
|
@ -470,14 +470,14 @@ static int max732x_irq_setup(struct max732x_chip *chip,
|
|||
if (!(chip->dir_input & (1 << lvl)))
|
||||
continue;
|
||||
|
||||
set_irq_chip_data(irq, chip);
|
||||
set_irq_chip_and_handler(irq, &max732x_irq_chip,
|
||||
irq_set_chip_data(irq, chip);
|
||||
irq_set_chip_and_handler(irq, &max732x_irq_chip,
|
||||
handle_edge_irq);
|
||||
set_irq_nested_thread(irq, 1);
|
||||
irq_set_nested_thread(irq, 1);
|
||||
#ifdef CONFIG_ARM
|
||||
set_irq_flags(irq, IRQF_VALID);
|
||||
#else
|
||||
set_irq_noprobe(irq);
|
||||
irq_set_noprobe(irq);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@
|
|||
* To save time we cache them here in memory
|
||||
*/
|
||||
struct mc33880 {
|
||||
struct mutex lock; /* protect from simultanous accesses */
|
||||
struct mutex lock; /* protect from simultaneous accesses */
|
||||
u8 port_config;
|
||||
struct gpio_chip chip;
|
||||
struct spi_device *spi;
|
||||
|
|
|
|||
|
|
@ -116,6 +116,7 @@ static int ioh_gpio_direction_output(struct gpio_chip *gpio, unsigned nr,
|
|||
reg_val |= (1 << nr);
|
||||
else
|
||||
reg_val &= ~(1 << nr);
|
||||
iowrite32(reg_val, &chip->reg->regs[chip->ch].po);
|
||||
|
||||
mutex_unlock(&chip->lock);
|
||||
|
||||
|
|
|
|||
|
|
@ -395,13 +395,13 @@ static int pca953x_irq_setup(struct pca953x_chip *chip,
|
|||
for (lvl = 0; lvl < chip->gpio_chip.ngpio; lvl++) {
|
||||
int irq = lvl + chip->irq_base;
|
||||
|
||||
set_irq_chip_data(irq, chip);
|
||||
set_irq_chip_and_handler(irq, &pca953x_irq_chip,
|
||||
irq_set_chip_data(irq, chip);
|
||||
irq_set_chip_and_handler(irq, &pca953x_irq_chip,
|
||||
handle_edge_irq);
|
||||
#ifdef CONFIG_ARM
|
||||
set_irq_flags(irq, IRQF_VALID);
|
||||
#else
|
||||
set_irq_noprobe(irq);
|
||||
irq_set_noprobe(irq);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
@ -558,7 +558,7 @@ static int __devinit pca953x_probe(struct i2c_client *client,
|
|||
|
||||
ret = gpiochip_add(&chip->gpio_chip);
|
||||
if (ret)
|
||||
goto out_failed;
|
||||
goto out_failed_irq;
|
||||
|
||||
if (pdata->setup) {
|
||||
ret = pdata->setup(client, chip->gpio_chip.base,
|
||||
|
|
@ -570,8 +570,9 @@ static int __devinit pca953x_probe(struct i2c_client *client,
|
|||
i2c_set_clientdata(client, chip);
|
||||
return 0;
|
||||
|
||||
out_failed:
|
||||
out_failed_irq:
|
||||
pca953x_irq_teardown(chip);
|
||||
out_failed:
|
||||
kfree(chip->dyn_pdata);
|
||||
kfree(chip);
|
||||
return ret;
|
||||
|
|
|
|||
|
|
@ -105,6 +105,7 @@ static int pch_gpio_direction_output(struct gpio_chip *gpio, unsigned nr,
|
|||
reg_val |= (1 << nr);
|
||||
else
|
||||
reg_val &= ~(1 << nr);
|
||||
iowrite32(reg_val, &chip->reg->po);
|
||||
|
||||
mutex_unlock(&chip->lock);
|
||||
|
||||
|
|
|
|||
|
|
@ -210,7 +210,7 @@ static struct irq_chip pl061_irqchip = {
|
|||
|
||||
static void pl061_irq_handler(unsigned irq, struct irq_desc *desc)
|
||||
{
|
||||
struct list_head *chip_list = get_irq_data(irq);
|
||||
struct list_head *chip_list = irq_get_handler_data(irq);
|
||||
struct list_head *ptr;
|
||||
struct pl061_gpio *chip;
|
||||
|
||||
|
|
@ -294,7 +294,7 @@ static int pl061_probe(struct amba_device *dev, const struct amba_id *id)
|
|||
ret = -ENODEV;
|
||||
goto iounmap;
|
||||
}
|
||||
set_irq_chained_handler(irq, pl061_irq_handler);
|
||||
irq_set_chained_handler(irq, pl061_irq_handler);
|
||||
if (!test_and_set_bit(irq, init_irq)) { /* list initialized? */
|
||||
chip_list = kmalloc(sizeof(*chip_list), GFP_KERNEL);
|
||||
if (chip_list == NULL) {
|
||||
|
|
@ -303,9 +303,9 @@ static int pl061_probe(struct amba_device *dev, const struct amba_id *id)
|
|||
goto iounmap;
|
||||
}
|
||||
INIT_LIST_HEAD(chip_list);
|
||||
set_irq_data(irq, chip_list);
|
||||
irq_set_handler_data(irq, chip_list);
|
||||
} else
|
||||
chip_list = get_irq_data(irq);
|
||||
chip_list = irq_get_handler_data(irq);
|
||||
list_add(&chip->list, chip_list);
|
||||
|
||||
for (i = 0; i < PL061_GPIO_NR; i++) {
|
||||
|
|
@ -315,10 +315,10 @@ static int pl061_probe(struct amba_device *dev, const struct amba_id *id)
|
|||
else
|
||||
pl061_direction_input(&chip->gc, i);
|
||||
|
||||
set_irq_chip(i+chip->irq_base, &pl061_irqchip);
|
||||
set_irq_handler(i+chip->irq_base, handle_simple_irq);
|
||||
irq_set_chip_and_handler(i + chip->irq_base, &pl061_irqchip,
|
||||
handle_simple_irq);
|
||||
set_irq_flags(i+chip->irq_base, IRQF_VALID);
|
||||
set_irq_chip_data(i+chip->irq_base, chip);
|
||||
irq_set_chip_data(i + chip->irq_base, chip);
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
|
|
|||
|
|
@ -27,6 +27,7 @@
|
|||
#include <linux/pci.h>
|
||||
#include <linux/gpio.h>
|
||||
#include <linux/mfd/rdc321x.h>
|
||||
#include <linux/mfd/core.h>
|
||||
#include <linux/slab.h>
|
||||
|
||||
struct rdc321x_gpio {
|
||||
|
|
@ -135,7 +136,7 @@ static int __devinit rdc321x_gpio_probe(struct platform_device *pdev)
|
|||
struct rdc321x_gpio *rdc321x_gpio_dev;
|
||||
struct rdc321x_gpio_pdata *pdata;
|
||||
|
||||
pdata = platform_get_drvdata(pdev);
|
||||
pdata = mfd_get_data(pdev);
|
||||
if (!pdata) {
|
||||
dev_err(&pdev->dev, "no platform data supplied\n");
|
||||
return -ENODEV;
|
||||
|
|
|
|||
|
|
@ -25,6 +25,7 @@
|
|||
#include <linux/errno.h>
|
||||
#include <linux/acpi.h>
|
||||
#include <linux/platform_device.h>
|
||||
#include <linux/pci_ids.h>
|
||||
|
||||
#include <linux/gpio.h>
|
||||
|
||||
|
|
@ -187,7 +188,11 @@ static struct gpio_chip sch_gpio_resume = {
|
|||
static int __devinit sch_gpio_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct resource *res;
|
||||
int err;
|
||||
int err, id;
|
||||
|
||||
id = pdev->id;
|
||||
if (!id)
|
||||
return -ENODEV;
|
||||
|
||||
res = platform_get_resource(pdev, IORESOURCE_IO, 0);
|
||||
if (!res)
|
||||
|
|
@ -198,12 +203,40 @@ static int __devinit sch_gpio_probe(struct platform_device *pdev)
|
|||
|
||||
gpio_ba = res->start;
|
||||
|
||||
sch_gpio_core.base = 0;
|
||||
sch_gpio_core.ngpio = 10;
|
||||
sch_gpio_core.dev = &pdev->dev;
|
||||
switch (id) {
|
||||
case PCI_DEVICE_ID_INTEL_SCH_LPC:
|
||||
sch_gpio_core.base = 0;
|
||||
sch_gpio_core.ngpio = 10;
|
||||
|
||||
sch_gpio_resume.base = 10;
|
||||
sch_gpio_resume.ngpio = 4;
|
||||
sch_gpio_resume.base = 10;
|
||||
sch_gpio_resume.ngpio = 4;
|
||||
|
||||
/*
|
||||
* GPIO[6:0] enabled by default
|
||||
* GPIO7 is configured by the CMC as SLPIOVR
|
||||
* Enable GPIO[9:8] core powered gpios explicitly
|
||||
*/
|
||||
outb(0x3, gpio_ba + CGEN + 1);
|
||||
/*
|
||||
* SUS_GPIO[2:0] enabled by default
|
||||
* Enable SUS_GPIO3 resume powered gpio explicitly
|
||||
*/
|
||||
outb(0x8, gpio_ba + RGEN);
|
||||
break;
|
||||
|
||||
case PCI_DEVICE_ID_INTEL_ITC_LPC:
|
||||
sch_gpio_core.base = 0;
|
||||
sch_gpio_core.ngpio = 5;
|
||||
|
||||
sch_gpio_resume.base = 5;
|
||||
sch_gpio_resume.ngpio = 9;
|
||||
break;
|
||||
|
||||
default:
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
sch_gpio_core.dev = &pdev->dev;
|
||||
sch_gpio_resume.dev = &pdev->dev;
|
||||
|
||||
err = gpiochip_add(&sch_gpio_core);
|
||||
|
|
@ -214,18 +247,6 @@ static int __devinit sch_gpio_probe(struct platform_device *pdev)
|
|||
if (err < 0)
|
||||
goto err_sch_gpio_resume;
|
||||
|
||||
/*
|
||||
* GPIO[6:0] enabled by default
|
||||
* GPIO7 is configured by the CMC as SLPIOVR
|
||||
* Enable GPIO[9:8] core powered gpios explicitly
|
||||
*/
|
||||
outb(0x3, gpio_ba + CGEN + 1);
|
||||
/*
|
||||
* SUS_GPIO[2:0] enabled by default
|
||||
* Enable SUS_GPIO3 resume powered gpio explicitly
|
||||
*/
|
||||
outb(0x8, gpio_ba + RGEN);
|
||||
|
||||
return 0;
|
||||
|
||||
err_sch_gpio_resume:
|
||||
|
|
|
|||
|
|
@ -254,14 +254,14 @@ static int __devinit stmpe_gpio_irq_init(struct stmpe_gpio *stmpe_gpio)
|
|||
int irq;
|
||||
|
||||
for (irq = base; irq < base + stmpe_gpio->chip.ngpio; irq++) {
|
||||
set_irq_chip_data(irq, stmpe_gpio);
|
||||
set_irq_chip_and_handler(irq, &stmpe_gpio_irq_chip,
|
||||
irq_set_chip_data(irq, stmpe_gpio);
|
||||
irq_set_chip_and_handler(irq, &stmpe_gpio_irq_chip,
|
||||
handle_simple_irq);
|
||||
set_irq_nested_thread(irq, 1);
|
||||
irq_set_nested_thread(irq, 1);
|
||||
#ifdef CONFIG_ARM
|
||||
set_irq_flags(irq, IRQF_VALID);
|
||||
#else
|
||||
set_irq_noprobe(irq);
|
||||
irq_set_noprobe(irq);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
@ -277,8 +277,8 @@ static void stmpe_gpio_irq_remove(struct stmpe_gpio *stmpe_gpio)
|
|||
#ifdef CONFIG_ARM
|
||||
set_irq_flags(irq, 0);
|
||||
#endif
|
||||
set_irq_chip_and_handler(irq, NULL, NULL);
|
||||
set_irq_chip_data(irq, NULL);
|
||||
irq_set_chip_and_handler(irq, NULL, NULL);
|
||||
irq_set_chip_data(irq, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -551,12 +551,12 @@ static int sx150x_install_irq_chip(struct sx150x_chip *chip,
|
|||
|
||||
for (n = 0; n < chip->dev_cfg->ngpios; ++n) {
|
||||
irq = irq_base + n;
|
||||
set_irq_chip_and_handler(irq, &chip->irq_chip, handle_edge_irq);
|
||||
set_irq_nested_thread(irq, 1);
|
||||
irq_set_chip_and_handler(irq, &chip->irq_chip, handle_edge_irq);
|
||||
irq_set_nested_thread(irq, 1);
|
||||
#ifdef CONFIG_ARM
|
||||
set_irq_flags(irq, IRQF_VALID);
|
||||
#else
|
||||
set_irq_noprobe(irq);
|
||||
irq_set_noprobe(irq);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
@ -583,8 +583,7 @@ static void sx150x_remove_irq_chip(struct sx150x_chip *chip)
|
|||
|
||||
for (n = 0; n < chip->dev_cfg->ngpios; ++n) {
|
||||
irq = chip->irq_base + n;
|
||||
set_irq_handler(irq, NULL);
|
||||
set_irq_chip(irq, NULL);
|
||||
irq_set_chip_and_handler(irq, NULL, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -239,14 +239,14 @@ static int tc3589x_gpio_irq_init(struct tc3589x_gpio *tc3589x_gpio)
|
|||
int irq;
|
||||
|
||||
for (irq = base; irq < base + tc3589x_gpio->chip.ngpio; irq++) {
|
||||
set_irq_chip_data(irq, tc3589x_gpio);
|
||||
set_irq_chip_and_handler(irq, &tc3589x_gpio_irq_chip,
|
||||
irq_set_chip_data(irq, tc3589x_gpio);
|
||||
irq_set_chip_and_handler(irq, &tc3589x_gpio_irq_chip,
|
||||
handle_simple_irq);
|
||||
set_irq_nested_thread(irq, 1);
|
||||
irq_set_nested_thread(irq, 1);
|
||||
#ifdef CONFIG_ARM
|
||||
set_irq_flags(irq, IRQF_VALID);
|
||||
#else
|
||||
set_irq_noprobe(irq);
|
||||
irq_set_noprobe(irq);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
@ -262,8 +262,8 @@ static void tc3589x_gpio_irq_remove(struct tc3589x_gpio *tc3589x_gpio)
|
|||
#ifdef CONFIG_ARM
|
||||
set_irq_flags(irq, 0);
|
||||
#endif
|
||||
set_irq_chip_and_handler(irq, NULL, NULL);
|
||||
set_irq_chip_data(irq, NULL);
|
||||
irq_set_chip_and_handler(irq, NULL, NULL);
|
||||
irq_set_chip_data(irq, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -23,6 +23,7 @@
|
|||
#include <linux/module.h>
|
||||
#include <linux/gpio.h>
|
||||
#include <linux/platform_device.h>
|
||||
#include <linux/mfd/core.h>
|
||||
#include <linux/irq.h>
|
||||
#include <linux/io.h>
|
||||
#include <linux/timb_gpio.h>
|
||||
|
|
@ -195,7 +196,7 @@ out:
|
|||
|
||||
static void timbgpio_irq(unsigned int irq, struct irq_desc *desc)
|
||||
{
|
||||
struct timbgpio *tgpio = get_irq_data(irq);
|
||||
struct timbgpio *tgpio = irq_get_handler_data(irq);
|
||||
unsigned long ipr;
|
||||
int offset;
|
||||
|
||||
|
|
@ -228,7 +229,7 @@ static int __devinit timbgpio_probe(struct platform_device *pdev)
|
|||
struct gpio_chip *gc;
|
||||
struct timbgpio *tgpio;
|
||||
struct resource *iomem;
|
||||
struct timbgpio_platform_data *pdata = pdev->dev.platform_data;
|
||||
struct timbgpio_platform_data *pdata = mfd_get_data(pdev);
|
||||
int irq = platform_get_irq(pdev, 0);
|
||||
|
||||
if (!pdata || pdata->nr_pins > 32) {
|
||||
|
|
@ -291,16 +292,16 @@ static int __devinit timbgpio_probe(struct platform_device *pdev)
|
|||
return 0;
|
||||
|
||||
for (i = 0; i < pdata->nr_pins; i++) {
|
||||
set_irq_chip_and_handler_name(tgpio->irq_base + i,
|
||||
irq_set_chip_and_handler_name(tgpio->irq_base + i,
|
||||
&timbgpio_irqchip, handle_simple_irq, "mux");
|
||||
set_irq_chip_data(tgpio->irq_base + i, tgpio);
|
||||
irq_set_chip_data(tgpio->irq_base + i, tgpio);
|
||||
#ifdef CONFIG_ARM
|
||||
set_irq_flags(tgpio->irq_base + i, IRQF_VALID | IRQF_PROBE);
|
||||
#endif
|
||||
}
|
||||
|
||||
set_irq_data(irq, tgpio);
|
||||
set_irq_chained_handler(irq, timbgpio_irq);
|
||||
irq_set_handler_data(irq, tgpio);
|
||||
irq_set_chained_handler(irq, timbgpio_irq);
|
||||
|
||||
return 0;
|
||||
|
||||
|
|
@ -319,20 +320,19 @@ err_mem:
|
|||
static int __devexit timbgpio_remove(struct platform_device *pdev)
|
||||
{
|
||||
int err;
|
||||
struct timbgpio_platform_data *pdata = pdev->dev.platform_data;
|
||||
struct timbgpio *tgpio = platform_get_drvdata(pdev);
|
||||
struct resource *iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
||||
int irq = platform_get_irq(pdev, 0);
|
||||
|
||||
if (irq >= 0 && tgpio->irq_base > 0) {
|
||||
int i;
|
||||
for (i = 0; i < pdata->nr_pins; i++) {
|
||||
set_irq_chip(tgpio->irq_base + i, NULL);
|
||||
set_irq_chip_data(tgpio->irq_base + i, NULL);
|
||||
for (i = 0; i < tgpio->gpio.ngpio; i++) {
|
||||
irq_set_chip(tgpio->irq_base + i, NULL);
|
||||
irq_set_chip_data(tgpio->irq_base + i, NULL);
|
||||
}
|
||||
|
||||
set_irq_handler(irq, NULL);
|
||||
set_irq_data(irq, NULL);
|
||||
irq_set_handler(irq, NULL);
|
||||
irq_set_handler_data(irq, NULL);
|
||||
}
|
||||
|
||||
err = gpiochip_remove(&tgpio->gpio);
|
||||
|
|
|
|||
|
|
@ -238,13 +238,13 @@ void vr41xx_set_irq_trigger(unsigned int pin, irq_trigger_t trigger,
|
|||
break;
|
||||
}
|
||||
}
|
||||
set_irq_chip_and_handler(GIU_IRQ(pin),
|
||||
irq_set_chip_and_handler(GIU_IRQ(pin),
|
||||
&giuint_low_irq_chip,
|
||||
handle_edge_irq);
|
||||
} else {
|
||||
giu_clear(GIUINTTYPL, mask);
|
||||
giu_clear(GIUINTHTSELL, mask);
|
||||
set_irq_chip_and_handler(GIU_IRQ(pin),
|
||||
irq_set_chip_and_handler(GIU_IRQ(pin),
|
||||
&giuint_low_irq_chip,
|
||||
handle_level_irq);
|
||||
}
|
||||
|
|
@ -273,13 +273,13 @@ void vr41xx_set_irq_trigger(unsigned int pin, irq_trigger_t trigger,
|
|||
break;
|
||||
}
|
||||
}
|
||||
set_irq_chip_and_handler(GIU_IRQ(pin),
|
||||
irq_set_chip_and_handler(GIU_IRQ(pin),
|
||||
&giuint_high_irq_chip,
|
||||
handle_edge_irq);
|
||||
} else {
|
||||
giu_clear(GIUINTTYPH, mask);
|
||||
giu_clear(GIUINTHTSELH, mask);
|
||||
set_irq_chip_and_handler(GIU_IRQ(pin),
|
||||
irq_set_chip_and_handler(GIU_IRQ(pin),
|
||||
&giuint_high_irq_chip,
|
||||
handle_level_irq);
|
||||
}
|
||||
|
|
@ -539,9 +539,9 @@ static int __devinit giu_probe(struct platform_device *pdev)
|
|||
chip = &giuint_high_irq_chip;
|
||||
|
||||
if (trigger & (1 << pin))
|
||||
set_irq_chip_and_handler(i, chip, handle_edge_irq);
|
||||
irq_set_chip_and_handler(i, chip, handle_edge_irq);
|
||||
else
|
||||
set_irq_chip_and_handler(i, chip, handle_level_irq);
|
||||
irq_set_chip_and_handler(i, chip, handle_level_irq);
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue