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                         return ret;
  73                 }
  74
  75                 /* Register is cached, drop it to ensure a physical read */
  76                 ret = regcache_drop_region(arizona->regmap, reg, reg);
  77                 if (ret < 0) {
  78                         dev_err(chip->parent, "Failed to drop cache: %d\n",
  79                                 ret);
  80                         return ret;
  81                 }
  82
  83                 ret = regmap_read(arizona->regmap, reg, &val);
  84                 if (ret < 0)
  85                         return ret;
  86
  87                 pm_runtime_mark_last_busy(chip->parent);
  88                 pm_runtime_put_autosuspend(chip->parent);
  89         }
  90
  91         if (val & ARIZONA_GPN_LVL)
  92                 return 1;
  93         else
  94                 return 0;
  95 }
  96
  97 static int arizona_gpio_direction_out(struct gpio_chip *chip,
  98                                      unsigned offset, int value)
  99 {
 100         struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip);
 101         struct arizona *arizona = arizona_gpio->arizona;
 102         bool persistent = gpiochip_line_is_persistent(chip, offset);
 103         unsigned int val;
 104         int ret;
 105
 106         ret = regmap_read(arizona->regmap, ARIZONA_GPIO1_CTRL + offset, &val);
 107         if (ret < 0)
 108                 return ret;
 109
 110         if ((val & ARIZONA_GPN_DIR) && persistent) {
 111                 ret = pm_runtime_get_sync(chip->parent);
 112                 if (ret < 0) {
 113                         dev_err(chip->parent, "Failed to resume: %d\n", ret);
 114                         return ret;
 115                 }
 116         }
 117
 118         if (value)
 119                 value = ARIZONA_GPN_LVL;
 120
 121         return regmap_update_bits(arizona->regmap, ARIZONA_GPIO1_CTRL + offset,
 122                                   ARIZONA_GPN_DIR | ARIZONA_GPN_LVL, value);
 123 }
 124
 125 static void arizona_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 126 {
 127         struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip);
 128         struct arizona *arizona = arizona_gpio->arizona;
 129
 130         if (value)
 131                 value = ARIZONA_GPN_LVL;
 132
 133         regmap_update_bits(arizona->regmap, ARIZONA_GPIO1_CTRL + offset,
 134                            ARIZONA_GPN_LVL, value);
 135 }
 136
 137 static const struct gpio_chip template_chip = {
 138         .label                  = "arizona",
 139         .owner                  = THIS_MODULE,
 140         .direction_input        = arizona_gpio_direction_in,
 141         .get                    = arizona_gpio_get,
 142         .direction_output       = arizona_gpio_direction_out,
 143         .set                    = arizona_gpio_set,
 144         .can_sleep              = true,
 145 };
 146
 147 static int arizona_gpio_probe(struct platform_device *pdev)
 148 {
 149         struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
 150         struct arizona_pdata *pdata = dev_get_platdata(arizona->dev);
 151         struct arizona_gpio *arizona_gpio;
 152         int ret;
 153
 154         arizona_gpio = devm_kzalloc(&pdev->dev, sizeof(*arizona_gpio),
 155                                     GFP_KERNEL);
 156         if (!arizona_gpio)
 157                 return -ENOMEM;
 158
 159         arizona_gpio->arizona = arizona;
 160         arizona_gpio->gpio_chip = template_chip;
 161         arizona_gpio->gpio_chip.parent = &pdev->dev;
 162 #ifdef CONFIG_OF_GPIO
 163         arizona_gpio->gpio_chip.of_node = arizona->dev->of_node;
 164 #endif
 165
 166         switch (arizona->type) {
 167         case WM5102:
 168         case WM5110:
 169         case WM8280:
 170         case WM8997:
 171         case WM8998:
 172         case WM1814:
 173                 arizona_gpio->gpio_chip.ngpio = 5;
 174                 break;
 175         case WM1831:
 176         case CS47L24:
 177                 arizona_gpio->gpio_chip.ngpio = 2;
 178                 break;
 179         default:
 180                 dev_err(&pdev->dev, "Unknown chip variant %d\n",
 181                         arizona->type);
 182                 return -EINVAL;
 183         }
 184
 185         if (pdata && pdata->gpio_base)
 186                 arizona_gpio->gpio_chip.base = pdata->gpio_base;
 187         else
 188                 arizona_gpio->gpio_chip.base = -1;
 189
 190         pm_runtime_enable(&pdev->dev);
 191
 192         ret = devm_gpiochip_add_data(&pdev->dev, &arizona_gpio->gpio_chip,
 193                                      arizona_gpio);
 194         if (ret < 0) {
 195                 dev_err(&pdev->dev, "Could not register gpiochip, %d\n",
 196                         ret);
 197                 return ret;
 198         }
 199
 200         return 0;
 201 }
 202
 203 static struct platform_driver arizona_gpio_driver = {
 204         .driver.name    = "arizona-gpio",
 205         .probe          = arizona_gpio_probe,
 206 };
 207
 208 module_platform_driver(arizona_gpio_driver);
 209
 210 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
 211 MODULE_DESCRIPTION("GPIO interface for Arizona devices");
 212 MODULE_LICENSE("GPL");
 213 MODULE_ALIAS("platform:arizona-gpio");