![Linus Torvalds](/assets/img/avatar_default.png)
We have several new drivers, most of the time coming with their sub devices drivers: - Austria Microsystem's AS3711 - Nano River's viperboard - TI's TPS80031, AM335x TS/ADC, - Realtek's MMC/memstick card reader - Nokia's retu We also got some notable cleanups and improvements: - tps6586x got converted to IRQ domains. - tps65910 and tps65090 moved to the regmap IRQ API. - STMPE is now Device Tree aware. - A general twl6040 and twl-core cleanup, with moves to the regmap I/O and IRQ APIs and a conversion to the recently added PWM framework. - sta2x11 gained regmap support. Then the rest is mostly tiny cleanups and fixes, among which we have Mark's wm5xxx and wm8xxx patchset. -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.12 (GNU/Linux) iQIcBAABAgAGBQJQznPnAAoJEIqAPN1PVmxKuA8P/0nOJduXFM1c0Gy+DD5DnJnG cXzzeSTV8iO3a3sHIye43QPJ5V2YUR5uxLTUEOo/G7my/MoZ/azeNidkUD3qLVlm wVIq35lcS8dWTZaY7nlpBcWc6e39UB0sEueuJNxyhOv5lnMKdi2tAow5f4vIRQnd Q67/EbrgqdltcOpGmVuCdQcvphvWgy+K65jzbJG5zXs7hGX13Q+M5RnYhx76kc8f TDd0APZ71n5/RyISFSBSu2vfl2kES6o47aMgqqXMEHri6d3puAaXM0rFoMzXg/4G eBdxndN25H7rW7xvt9tuUod2rn1AO7tif5d7jal3Cfj61y3iqKY30yb3OzS9XQXH 9WZ2qDst11zvzQivxIkMGvfRXRfncNLWR4DrBSqVfSbYV2uQj2eS8C6ONwKVMXsQ 5tjNp91PFqN19sWQjIjSMcrNswxgpvdQ9mqFTyOGmISbqrpPSTi+MuO8r9+xTfUF PnzUX2nVOW/i9NcI7uotjzh8jiw6t8XMVHhkehiSYR9hzCb6MaPsFPN4jWq9XA2m 1htCHylNpHqHQ3Mup7Is6j0Li1ahdwfm4lbrgiVEA4t4Mqs5E/Ka+3V8laNAKylW PfCP/VmnJYzmgVTK/qobFNeKzRqR0i4WTL6T7oAxGL87Q4TJaqKpEkXWne8UXV+Q yIbN0fmWfCveCetM+vaf =F790 -----END PGP SIGNATURE----- Merge tag 'mfd-3.8-1' of git://git.kernel.org/pub/scm/linux/kernel/git/sameo/mfd-2.6 Pull MFS update from Samuel Ortiz: "This is the MFD patch set for the 3.8 merge window. We have several new drivers, most of the time coming with their sub devices drivers: - Austria Microsystem's AS3711 - Nano River's viperboard - TI's TPS80031, AM335x TS/ADC, - Realtek's MMC/memstick card reader - Nokia's retu We also got some notable cleanups and improvements: - tps6586x got converted to IRQ domains. - tps65910 and tps65090 moved to the regmap IRQ API. - STMPE is now Device Tree aware. - A general twl6040 and twl-core cleanup, with moves to the regmap I/O and IRQ APIs and a conversion to the recently added PWM framework. - sta2x11 gained regmap support. Then the rest is mostly tiny cleanups and fixes, among which we have Mark's wm5xxx and wm8xxx patchset." Far amount of annoying but largely trivial conflicts. Many due to __devinit/exit removal, others due to one or two of the new drivers also having come in through another tree. * tag 'mfd-3.8-1' of git://git.kernel.org/pub/scm/linux/kernel/git/sameo/mfd-2.6: (119 commits) mfd: tps6507x: Convert to devm_kzalloc mfd: stmpe: Update DT support for stmpe driver mfd: wm5102: Add readback of DSP status 3 register mfd: arizona: Log if we fail to create the primary IRQ domain mfd: tps80031: MFD_TPS80031 needs to select REGMAP_IRQ mfd: tps80031: Add terminating entry for tps80031_id_table mfd: sta2x11: Fix potential NULL pointer dereference in __sta2x11_mfd_mask() mfd: wm5102: Add tuning for revision B mfd: arizona: Defer patch initialistation until after first device boot mfd: tps65910: Fix wrong ack_base register mfd: tps65910: Remove unused data mfd: stmpe: Get rid of irq_invert_polarity mfd: ab8500-core: Fix invalid free of devm_ allocated data mfd: wm5102: Mark DSP memory regions as volatile mfd: wm5102: Correct default for LDO1_CONTROL_2 mfd: arizona: Register haptics devices mfd: wm8994: Make current device behaviour the default mfd: tps65090: MFD_TPS65090 needs to select REGMAP_IRQ mfd: Fix stmpe.c build when OF is not enabled mfd: jz4740-adc: Use devm_kzalloc ...
570 lines
14 KiB
C
570 lines
14 KiB
C
/*
|
|
* Access to GPIOs on TWL4030/TPS659x0 chips
|
|
*
|
|
* Copyright (C) 2006-2007 Texas Instruments, Inc.
|
|
* Copyright (C) 2006 MontaVista Software, Inc.
|
|
*
|
|
* Code re-arranged and cleaned up by:
|
|
* Syed Mohammed Khasim <x0khasim@ti.com>
|
|
*
|
|
* Initial Code:
|
|
* Andy Lowe / Nishanth Menon
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/init.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/kthread.h>
|
|
#include <linux/irq.h>
|
|
#include <linux/gpio.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/of.h>
|
|
#include <linux/irqdomain.h>
|
|
|
|
#include <linux/i2c/twl.h>
|
|
|
|
|
|
/*
|
|
* The GPIO "subchip" supports 18 GPIOs which can be configured as
|
|
* inputs or outputs, with pullups or pulldowns on each pin. Each
|
|
* GPIO can trigger interrupts on either or both edges.
|
|
*
|
|
* GPIO interrupts can be fed to either of two IRQ lines; this is
|
|
* intended to support multiple hosts.
|
|
*
|
|
* There are also two LED pins used sometimes as output-only GPIOs.
|
|
*/
|
|
|
|
|
|
static struct gpio_chip twl_gpiochip;
|
|
static int twl4030_gpio_base;
|
|
static int twl4030_gpio_irq_base;
|
|
|
|
/* genirq interfaces are not available to modules */
|
|
#ifdef MODULE
|
|
#define is_module() true
|
|
#else
|
|
#define is_module() false
|
|
#endif
|
|
|
|
/* GPIO_CTRL Fields */
|
|
#define MASK_GPIO_CTRL_GPIO0CD1 BIT(0)
|
|
#define MASK_GPIO_CTRL_GPIO1CD2 BIT(1)
|
|
#define MASK_GPIO_CTRL_GPIO_ON BIT(2)
|
|
|
|
/* Mask for GPIO registers when aggregated into a 32-bit integer */
|
|
#define GPIO_32_MASK 0x0003ffff
|
|
|
|
/* Data structures */
|
|
static DEFINE_MUTEX(gpio_lock);
|
|
|
|
/* store usage of each GPIO. - each bit represents one GPIO */
|
|
static unsigned int gpio_usage_count;
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
/*
|
|
* To configure TWL4030 GPIO module registers
|
|
*/
|
|
static inline int gpio_twl4030_write(u8 address, u8 data)
|
|
{
|
|
return twl_i2c_write_u8(TWL4030_MODULE_GPIO, data, address);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
/*
|
|
* LED register offsets from TWL_MODULE_LED base
|
|
* PWMs A and B are dedicated to LEDs A and B, respectively.
|
|
*/
|
|
|
|
#define TWL4030_LED_LEDEN_REG 0x00
|
|
#define TWL4030_PWMAON_REG 0x01
|
|
#define TWL4030_PWMAOFF_REG 0x02
|
|
#define TWL4030_PWMBON_REG 0x03
|
|
#define TWL4030_PWMBOFF_REG 0x04
|
|
|
|
/* LEDEN bits */
|
|
#define LEDEN_LEDAON BIT(0)
|
|
#define LEDEN_LEDBON BIT(1)
|
|
#define LEDEN_LEDAEXT BIT(2)
|
|
#define LEDEN_LEDBEXT BIT(3)
|
|
#define LEDEN_LEDAPWM BIT(4)
|
|
#define LEDEN_LEDBPWM BIT(5)
|
|
#define LEDEN_PWM_LENGTHA BIT(6)
|
|
#define LEDEN_PWM_LENGTHB BIT(7)
|
|
|
|
#define PWMxON_LENGTH BIT(7)
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
/*
|
|
* To read a TWL4030 GPIO module register
|
|
*/
|
|
static inline int gpio_twl4030_read(u8 address)
|
|
{
|
|
u8 data;
|
|
int ret = 0;
|
|
|
|
ret = twl_i2c_read_u8(TWL4030_MODULE_GPIO, &data, address);
|
|
return (ret < 0) ? ret : data;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static u8 cached_leden; /* protected by gpio_lock */
|
|
|
|
/* The LED lines are open drain outputs ... a FET pulls to GND, so an
|
|
* external pullup is needed. We could also expose the integrated PWM
|
|
* as a LED brightness control; we initialize it as "always on".
|
|
*/
|
|
static void twl4030_led_set_value(int led, int value)
|
|
{
|
|
u8 mask = LEDEN_LEDAON | LEDEN_LEDAPWM;
|
|
int status;
|
|
|
|
if (led)
|
|
mask <<= 1;
|
|
|
|
mutex_lock(&gpio_lock);
|
|
if (value)
|
|
cached_leden &= ~mask;
|
|
else
|
|
cached_leden |= mask;
|
|
status = twl_i2c_write_u8(TWL4030_MODULE_LED, cached_leden,
|
|
TWL4030_LED_LEDEN_REG);
|
|
mutex_unlock(&gpio_lock);
|
|
}
|
|
|
|
static int twl4030_set_gpio_direction(int gpio, int is_input)
|
|
{
|
|
u8 d_bnk = gpio >> 3;
|
|
u8 d_msk = BIT(gpio & 0x7);
|
|
u8 reg = 0;
|
|
u8 base = REG_GPIODATADIR1 + d_bnk;
|
|
int ret = 0;
|
|
|
|
mutex_lock(&gpio_lock);
|
|
ret = gpio_twl4030_read(base);
|
|
if (ret >= 0) {
|
|
if (is_input)
|
|
reg = ret & ~d_msk;
|
|
else
|
|
reg = ret | d_msk;
|
|
|
|
ret = gpio_twl4030_write(base, reg);
|
|
}
|
|
mutex_unlock(&gpio_lock);
|
|
return ret;
|
|
}
|
|
|
|
static int twl4030_set_gpio_dataout(int gpio, int enable)
|
|
{
|
|
u8 d_bnk = gpio >> 3;
|
|
u8 d_msk = BIT(gpio & 0x7);
|
|
u8 base = 0;
|
|
|
|
if (enable)
|
|
base = REG_SETGPIODATAOUT1 + d_bnk;
|
|
else
|
|
base = REG_CLEARGPIODATAOUT1 + d_bnk;
|
|
|
|
return gpio_twl4030_write(base, d_msk);
|
|
}
|
|
|
|
static int twl4030_get_gpio_datain(int gpio)
|
|
{
|
|
u8 d_bnk = gpio >> 3;
|
|
u8 d_off = gpio & 0x7;
|
|
u8 base = 0;
|
|
int ret = 0;
|
|
|
|
if (unlikely((gpio >= TWL4030_GPIO_MAX)
|
|
|| !(gpio_usage_count & BIT(gpio))))
|
|
return -EPERM;
|
|
|
|
base = REG_GPIODATAIN1 + d_bnk;
|
|
ret = gpio_twl4030_read(base);
|
|
if (ret > 0)
|
|
ret = (ret >> d_off) & 0x1;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static int twl_request(struct gpio_chip *chip, unsigned offset)
|
|
{
|
|
int status = 0;
|
|
|
|
mutex_lock(&gpio_lock);
|
|
|
|
/* Support the two LED outputs as output-only GPIOs. */
|
|
if (offset >= TWL4030_GPIO_MAX) {
|
|
u8 ledclr_mask = LEDEN_LEDAON | LEDEN_LEDAEXT
|
|
| LEDEN_LEDAPWM | LEDEN_PWM_LENGTHA;
|
|
u8 reg = TWL4030_PWMAON_REG;
|
|
|
|
offset -= TWL4030_GPIO_MAX;
|
|
if (offset) {
|
|
ledclr_mask <<= 1;
|
|
reg = TWL4030_PWMBON_REG;
|
|
}
|
|
|
|
/* initialize PWM to always-drive */
|
|
/* Configure PWM OFF register first */
|
|
status = twl_i2c_write_u8(TWL4030_MODULE_LED, 0x7f, reg + 1);
|
|
if (status < 0)
|
|
goto done;
|
|
|
|
/* Followed by PWM ON register */
|
|
status = twl_i2c_write_u8(TWL4030_MODULE_LED, 0x7f, reg);
|
|
if (status < 0)
|
|
goto done;
|
|
|
|
/* init LED to not-driven (high) */
|
|
status = twl_i2c_read_u8(TWL4030_MODULE_LED, &cached_leden,
|
|
TWL4030_LED_LEDEN_REG);
|
|
if (status < 0)
|
|
goto done;
|
|
cached_leden &= ~ledclr_mask;
|
|
status = twl_i2c_write_u8(TWL4030_MODULE_LED, cached_leden,
|
|
TWL4030_LED_LEDEN_REG);
|
|
if (status < 0)
|
|
goto done;
|
|
|
|
status = 0;
|
|
goto done;
|
|
}
|
|
|
|
/* on first use, turn GPIO module "on" */
|
|
if (!gpio_usage_count) {
|
|
struct twl4030_gpio_platform_data *pdata;
|
|
u8 value = MASK_GPIO_CTRL_GPIO_ON;
|
|
|
|
/* optionally have the first two GPIOs switch vMMC1
|
|
* and vMMC2 power supplies based on card presence.
|
|
*/
|
|
pdata = chip->dev->platform_data;
|
|
if (pdata)
|
|
value |= pdata->mmc_cd & 0x03;
|
|
|
|
status = gpio_twl4030_write(REG_GPIO_CTRL, value);
|
|
}
|
|
|
|
if (!status)
|
|
gpio_usage_count |= (0x1 << offset);
|
|
|
|
done:
|
|
mutex_unlock(&gpio_lock);
|
|
return status;
|
|
}
|
|
|
|
static void twl_free(struct gpio_chip *chip, unsigned offset)
|
|
{
|
|
if (offset >= TWL4030_GPIO_MAX) {
|
|
twl4030_led_set_value(offset - TWL4030_GPIO_MAX, 1);
|
|
return;
|
|
}
|
|
|
|
mutex_lock(&gpio_lock);
|
|
|
|
gpio_usage_count &= ~BIT(offset);
|
|
|
|
/* on last use, switch off GPIO module */
|
|
if (!gpio_usage_count)
|
|
gpio_twl4030_write(REG_GPIO_CTRL, 0x0);
|
|
|
|
mutex_unlock(&gpio_lock);
|
|
}
|
|
|
|
static int twl_direction_in(struct gpio_chip *chip, unsigned offset)
|
|
{
|
|
return (offset < TWL4030_GPIO_MAX)
|
|
? twl4030_set_gpio_direction(offset, 1)
|
|
: -EINVAL;
|
|
}
|
|
|
|
static int twl_get(struct gpio_chip *chip, unsigned offset)
|
|
{
|
|
int status = 0;
|
|
|
|
if (offset < TWL4030_GPIO_MAX)
|
|
status = twl4030_get_gpio_datain(offset);
|
|
else if (offset == TWL4030_GPIO_MAX)
|
|
status = cached_leden & LEDEN_LEDAON;
|
|
else
|
|
status = cached_leden & LEDEN_LEDBON;
|
|
return (status < 0) ? 0 : status;
|
|
}
|
|
|
|
static int twl_direction_out(struct gpio_chip *chip, unsigned offset, int value)
|
|
{
|
|
if (offset < TWL4030_GPIO_MAX) {
|
|
twl4030_set_gpio_dataout(offset, value);
|
|
return twl4030_set_gpio_direction(offset, 0);
|
|
} else {
|
|
twl4030_led_set_value(offset - TWL4030_GPIO_MAX, value);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
static void twl_set(struct gpio_chip *chip, unsigned offset, int value)
|
|
{
|
|
if (offset < TWL4030_GPIO_MAX)
|
|
twl4030_set_gpio_dataout(offset, value);
|
|
else
|
|
twl4030_led_set_value(offset - TWL4030_GPIO_MAX, value);
|
|
}
|
|
|
|
static int twl_to_irq(struct gpio_chip *chip, unsigned offset)
|
|
{
|
|
return (twl4030_gpio_irq_base && (offset < TWL4030_GPIO_MAX))
|
|
? (twl4030_gpio_irq_base + offset)
|
|
: -EINVAL;
|
|
}
|
|
|
|
static struct gpio_chip twl_gpiochip = {
|
|
.label = "twl4030",
|
|
.owner = THIS_MODULE,
|
|
.request = twl_request,
|
|
.free = twl_free,
|
|
.direction_input = twl_direction_in,
|
|
.get = twl_get,
|
|
.direction_output = twl_direction_out,
|
|
.set = twl_set,
|
|
.to_irq = twl_to_irq,
|
|
.can_sleep = 1,
|
|
};
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static int gpio_twl4030_pulls(u32 ups, u32 downs)
|
|
{
|
|
u8 message[5];
|
|
unsigned i, gpio_bit;
|
|
|
|
/* For most pins, a pulldown was enabled by default.
|
|
* We should have data that's specific to this board.
|
|
*/
|
|
for (gpio_bit = 1, i = 0; i < 5; i++) {
|
|
u8 bit_mask;
|
|
unsigned j;
|
|
|
|
for (bit_mask = 0, j = 0; j < 8; j += 2, gpio_bit <<= 1) {
|
|
if (ups & gpio_bit)
|
|
bit_mask |= 1 << (j + 1);
|
|
else if (downs & gpio_bit)
|
|
bit_mask |= 1 << (j + 0);
|
|
}
|
|
message[i] = bit_mask;
|
|
}
|
|
|
|
return twl_i2c_write(TWL4030_MODULE_GPIO, message,
|
|
REG_GPIOPUPDCTR1, 5);
|
|
}
|
|
|
|
static int gpio_twl4030_debounce(u32 debounce, u8 mmc_cd)
|
|
{
|
|
u8 message[3];
|
|
|
|
/* 30 msec of debouncing is always used for MMC card detect,
|
|
* and is optional for everything else.
|
|
*/
|
|
message[0] = (debounce & 0xff) | (mmc_cd & 0x03);
|
|
debounce >>= 8;
|
|
message[1] = (debounce & 0xff);
|
|
debounce >>= 8;
|
|
message[2] = (debounce & 0x03);
|
|
|
|
return twl_i2c_write(TWL4030_MODULE_GPIO, message,
|
|
REG_GPIO_DEBEN1, 3);
|
|
}
|
|
|
|
static int gpio_twl4030_remove(struct platform_device *pdev);
|
|
|
|
static struct twl4030_gpio_platform_data *of_gpio_twl4030(struct device *dev)
|
|
{
|
|
struct twl4030_gpio_platform_data *omap_twl_info;
|
|
|
|
omap_twl_info = devm_kzalloc(dev, sizeof(*omap_twl_info), GFP_KERNEL);
|
|
if (!omap_twl_info)
|
|
return NULL;
|
|
|
|
omap_twl_info->use_leds = of_property_read_bool(dev->of_node,
|
|
"ti,use-leds");
|
|
|
|
of_property_read_u32(dev->of_node, "ti,debounce",
|
|
&omap_twl_info->debounce);
|
|
of_property_read_u32(dev->of_node, "ti,mmc-cd",
|
|
(u32 *)&omap_twl_info->mmc_cd);
|
|
of_property_read_u32(dev->of_node, "ti,pullups",
|
|
&omap_twl_info->pullups);
|
|
of_property_read_u32(dev->of_node, "ti,pulldowns",
|
|
&omap_twl_info->pulldowns);
|
|
|
|
return omap_twl_info;
|
|
}
|
|
|
|
static int gpio_twl4030_probe(struct platform_device *pdev)
|
|
{
|
|
struct twl4030_gpio_platform_data *pdata = pdev->dev.platform_data;
|
|
struct device_node *node = pdev->dev.of_node;
|
|
int ret, irq_base;
|
|
|
|
/* maybe setup IRQs */
|
|
if (is_module()) {
|
|
dev_err(&pdev->dev, "can't dispatch IRQs from modules\n");
|
|
goto no_irqs;
|
|
}
|
|
|
|
irq_base = irq_alloc_descs(-1, 0, TWL4030_GPIO_MAX, 0);
|
|
if (irq_base < 0) {
|
|
dev_err(&pdev->dev, "Failed to alloc irq_descs\n");
|
|
return irq_base;
|
|
}
|
|
|
|
irq_domain_add_legacy(node, TWL4030_GPIO_MAX, irq_base, 0,
|
|
&irq_domain_simple_ops, NULL);
|
|
|
|
ret = twl4030_sih_setup(&pdev->dev, TWL4030_MODULE_GPIO, irq_base);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
twl4030_gpio_irq_base = irq_base;
|
|
|
|
no_irqs:
|
|
twl_gpiochip.base = -1;
|
|
twl_gpiochip.ngpio = TWL4030_GPIO_MAX;
|
|
twl_gpiochip.dev = &pdev->dev;
|
|
|
|
if (node)
|
|
pdata = of_gpio_twl4030(&pdev->dev);
|
|
|
|
if (pdata == NULL) {
|
|
dev_err(&pdev->dev, "Platform data is missing\n");
|
|
return -ENXIO;
|
|
}
|
|
|
|
/*
|
|
* NOTE: boards may waste power if they don't set pullups
|
|
* and pulldowns correctly ... default for non-ULPI pins is
|
|
* pulldown, and some other pins may have external pullups
|
|
* or pulldowns. Careful!
|
|
*/
|
|
ret = gpio_twl4030_pulls(pdata->pullups, pdata->pulldowns);
|
|
if (ret)
|
|
dev_dbg(&pdev->dev, "pullups %.05x %.05x --> %d\n",
|
|
pdata->pullups, pdata->pulldowns, ret);
|
|
|
|
ret = gpio_twl4030_debounce(pdata->debounce, pdata->mmc_cd);
|
|
if (ret)
|
|
dev_dbg(&pdev->dev, "debounce %.03x %.01x --> %d\n",
|
|
pdata->debounce, pdata->mmc_cd, ret);
|
|
|
|
/*
|
|
* NOTE: we assume VIBRA_CTL.VIBRA_EN, in MODULE_AUDIO_VOICE,
|
|
* is (still) clear if use_leds is set.
|
|
*/
|
|
if (pdata->use_leds)
|
|
twl_gpiochip.ngpio += 2;
|
|
|
|
ret = gpiochip_add(&twl_gpiochip);
|
|
if (ret < 0) {
|
|
dev_err(&pdev->dev, "could not register gpiochip, %d\n", ret);
|
|
twl_gpiochip.ngpio = 0;
|
|
gpio_twl4030_remove(pdev);
|
|
goto out;
|
|
}
|
|
|
|
twl4030_gpio_base = twl_gpiochip.base;
|
|
|
|
if (pdata && pdata->setup) {
|
|
int status;
|
|
|
|
status = pdata->setup(&pdev->dev,
|
|
twl4030_gpio_base, TWL4030_GPIO_MAX);
|
|
if (status)
|
|
dev_dbg(&pdev->dev, "setup --> %d\n", status);
|
|
}
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
|
|
/* Cannot use as gpio_twl4030_probe() calls us */
|
|
static int gpio_twl4030_remove(struct platform_device *pdev)
|
|
{
|
|
struct twl4030_gpio_platform_data *pdata = pdev->dev.platform_data;
|
|
int status;
|
|
|
|
if (pdata && pdata->teardown) {
|
|
status = pdata->teardown(&pdev->dev,
|
|
twl4030_gpio_base, TWL4030_GPIO_MAX);
|
|
if (status) {
|
|
dev_dbg(&pdev->dev, "teardown --> %d\n", status);
|
|
return status;
|
|
}
|
|
}
|
|
|
|
status = gpiochip_remove(&twl_gpiochip);
|
|
if (status < 0)
|
|
return status;
|
|
|
|
if (is_module())
|
|
return 0;
|
|
|
|
/* REVISIT no support yet for deregistering all the IRQs */
|
|
WARN_ON(1);
|
|
return -EIO;
|
|
}
|
|
|
|
static const struct of_device_id twl_gpio_match[] = {
|
|
{ .compatible = "ti,twl4030-gpio", },
|
|
{ },
|
|
};
|
|
MODULE_DEVICE_TABLE(of, twl_gpio_match);
|
|
|
|
/* Note: this hardware lives inside an I2C-based multi-function device. */
|
|
MODULE_ALIAS("platform:twl4030_gpio");
|
|
|
|
static struct platform_driver gpio_twl4030_driver = {
|
|
.driver = {
|
|
.name = "twl4030_gpio",
|
|
.owner = THIS_MODULE,
|
|
.of_match_table = of_match_ptr(twl_gpio_match),
|
|
},
|
|
.probe = gpio_twl4030_probe,
|
|
.remove = gpio_twl4030_remove,
|
|
};
|
|
|
|
static int __init gpio_twl4030_init(void)
|
|
{
|
|
return platform_driver_register(&gpio_twl4030_driver);
|
|
}
|
|
subsys_initcall(gpio_twl4030_init);
|
|
|
|
static void __exit gpio_twl4030_exit(void)
|
|
{
|
|
platform_driver_unregister(&gpio_twl4030_driver);
|
|
}
|
|
module_exit(gpio_twl4030_exit);
|
|
|
|
MODULE_AUTHOR("Texas Instruments, Inc.");
|
|
MODULE_DESCRIPTION("GPIO interface for TWL4030");
|
|
MODULE_LICENSE("GPL");
|