drivers/gpio/gpio-arizona.c

   1 /*
   2  * gpiolib support for Wolfson Arizona class devices
   3  *
   4  * Copyright 2012 Wolfson Microelectronics PLC.
   5  *
   6  * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
   7  *
   8  *  This program is free software; you can redistribute  it and/or modify it
   9  *  under  the terms of  the GNU General  Public License as published by the
  10  *  Free Software Foundation;  either version 2 of the  License, or (at your
  11  *  option) any later version.
  12  *
  13  */
  14
  15 #include <linux/kernel.h>
  16 #include <linux/slab.h>
  17 #include <linux/module.h>
  18 #include <linux/gpio/driver.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/pm_runtime.h>
  21 #include <linux/seq_file.h>
  22
  23 #include <linux/mfd/arizona/core.h>
  24 #include <linux/mfd/arizona/pdata.h>
  25 #include <linux/mfd/arizona/registers.h>
  26
  27 struct arizona_gpio {
  28         struct arizona *arizona;
  29         struct gpio_chip gpio_chip;
  30 };
  31
  32 static int arizona_gpio_direction_in(struct gpio_chip *chip, unsigned offset)
  33 {
  34         struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip);
  35         struct arizona *arizona = arizona_gpio->arizona;
  36         bool persistent = gpiochip_line_is_persistent(chip, offset);
  37         bool change;
  38         int ret;
  39
  40         ret = regmap_update_bits_check(arizona->regmap,
  41                                        ARIZONA_GPIO1_CTRL + offset,
  42                                        ARIZONA_GPN_DIR, ARIZONA_GPN_DIR,
  43                                        &change);
  44         if (ret < 0)
  45                 return ret;
  46
  47         if (change && persistent) {
  48                 pm_runtime_mark_last_busy(chip->parent);
  49                 pm_runtime_put_autosuspend(chip->parent);
  50         }
  51
  52         return 0;
  53 }
  54
  55 static int arizona_gpio_get(struct gpio_chip *chip, unsigned offset)
  56 {
  57         struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip);
  58         struct arizona *arizona = arizona_gpio->arizona;
  59         unsigned int reg, val;
  60         int ret;
  61
  62         reg = ARIZONA_GPIO1_CTRL + offset;
  63         ret = regmap_read(arizona->regmap, reg, &val);
  64         if (ret < 0)
  65                 return ret;
  66
  67         /* Resume to read actual registers for input pins */
  68         if (val & ARIZONA_GPN_DIR) {
  69                 ret = pm_runtime_get_sync(chip->parent);
  70                 if (ret < 0) {
  71                         dev_err(chip->parent, "Failed to resume: %d\n", ret);
  72                         pm_runtime_put_autosuspend(chip->parent);
  73                         return ret;
  74                 }
  75
  76                 /* Register is cached, drop it to ensure a physical read */
  77                 ret = regcache_drop_region(arizona->regmap, reg, reg);
  78                 if (ret < 0) {
  79                         dev_err(chip->parent, "Failed to drop cache: %d\n",
  80                                 ret);
  81                         pm_runtime_put_autosuspend(chip->parent);
  82                         return ret;
  83                 }
  84
  85                 ret = regmap_read(arizona->regmap, reg, &val);
  86                 if (ret < 0) {
  87                         pm_runtime_put_autosuspend(chip->parent);
  88                         return ret;
  89                 }
  90
  91                 pm_runtime_mark_last_busy(chip->parent);
  92                 pm_runtime_put_autosuspend(chip->parent);
  93         }
  94
  95         if (val & ARIZONA_GPN_LVL)
  96                 return 1;
  97         else
  98                 return 0;
  99 }
 100
 101 static int arizona_gpio_direction_out(struct gpio_chip *chip,
 102                                      unsigned offset, int value)
 103 {
 104         struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip);
 105         struct arizona *arizona = arizona_gpio->arizona;
 106         bool persistent = gpiochip_line_is_persistent(chip, offset);
 107         unsigned int val;
 108         int ret;
 109
 110         ret = regmap_read(arizona->regmap, ARIZONA_GPIO1_CTRL + offset, &val);
 111         if (ret < 0)
 112                 return ret;
 113
 114         if ((val & ARIZONA_GPN_DIR) && persistent) {
 115                 ret = pm_runtime_get_sync(chip->parent);
 116                 if (ret < 0) {
 117                         dev_err(chip->parent, "Failed to resume: %d\n", ret);
 118                         pm_runtime_put(chip->parent);
 119                         return ret;
 120                 }
 121         }
 122
 123         if (value)
 124                 value = ARIZONA_GPN_LVL;
 125
 126         return regmap_update_bits(arizona->regmap, ARIZONA_GPIO1_CTRL + offset,
 127                                   ARIZONA_GPN_DIR | ARIZONA_GPN_LVL, value);
 128 }
 129
 130 static void arizona_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 131 {
 132         struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip);
 133         struct arizona *arizona = arizona_gpio->arizona;
 134
 135         if (value)
 136                 value = ARIZONA_GPN_LVL;
 137
 138         regmap_update_bits(arizona->regmap, ARIZONA_GPIO1_CTRL + offset,
 139                            ARIZONA_GPN_LVL, value);
 140 }
 141
 142 static const struct gpio_chip template_chip = {
 143         .label                  = "arizona",
 144         .owner                  = THIS_MODULE,
 145         .direction_input        = arizona_gpio_direction_in,
 146         .get                    = arizona_gpio_get,
 147         .direction_output       = arizona_gpio_direction_out,
 148         .set                    = arizona_gpio_set,
 149         .can_sleep              = true,
 150 };
 151
 152 static int arizona_gpio_probe(struct platform_device *pdev)
 153 {
 154         struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
 155         struct arizona_pdata *pdata = dev_get_platdata(arizona->dev);
 156         struct arizona_gpio *arizona_gpio;
 157         int ret;
 158
 159         arizona_gpio = devm_kzalloc(&pdev->dev, sizeof(*arizona_gpio),
 160                                     GFP_KERNEL);
 161         if (!arizona_gpio)
 162                 return -ENOMEM;
 163
 164         arizona_gpio->arizona = arizona;
 165         arizona_gpio->gpio_chip = template_chip;
 166         arizona_gpio->gpio_chip.parent = &pdev->dev;
 167 #ifdef CONFIG_OF_GPIO
 168         arizona_gpio->gpio_chip.of_node = arizona->dev->of_node;
 169 #endif
 170
 171         switch (arizona->type) {
 172         case WM5102:
 173         case WM5110:
 174         case WM8280:
 175         case WM8997:
 176         case WM8998:
 177         case WM1814:
 178                 arizona_gpio->gpio_chip.ngpio = 5;
 179                 break;
 180         case WM1831:
 181         case CS47L24:
 182                 arizona_gpio->gpio_chip.ngpio = 2;
 183                 break;
 184         default:
 185                 dev_err(&pdev->dev, "Unknown chip variant %d\n",
 186                         arizona->type);
 187                 return -EINVAL;
 188         }
 189
 190         if (pdata && pdata->gpio_base)
 191                 arizona_gpio->gpio_chip.base = pdata->gpio_base;
 192         else
 193                 arizona_gpio->gpio_chip.base = -1;
 194
 195         pm_runtime_enable(&pdev->dev);
 196
 197         ret = devm_gpiochip_add_data(&pdev->dev, &arizona_gpio->gpio_chip,
 198                                      arizona_gpio);
 199         if (ret < 0) {
 200                 dev_err(&pdev->dev, "Could not register gpiochip, %d\n",
 201                         ret);
 202                 return ret;
 203         }
 204
 205         return 0;
 206 }
 207
 208 static struct platform_driver arizona_gpio_driver = {
 209         .driver.name    = "arizona-gpio",
 210         .probe          = arizona_gpio_probe,
 211 };
 212
 213 module_platform_driver(arizona_gpio_driver);
 214
 215 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
 216 MODULE_DESCRIPTION("GPIO interface for Arizona devices");
 217 MODULE_LICENSE("GPL");
 218 MODULE_ALIAS("platform:arizona-gpio");