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.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/seq_file.h>
  21
  22 #include <linux/mfd/arizona/core.h>
  23 #include <linux/mfd/arizona/pdata.h>
  24 #include <linux/mfd/arizona/registers.h>
  25
  26 struct arizona_gpio {
  27         struct arizona *arizona;
  28         struct gpio_chip gpio_chip;
  29 };
  30
  31 static int arizona_gpio_direction_in(struct gpio_chip *chip, unsigned offset)
  32 {
  33         struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip);
  34         struct arizona *arizona = arizona_gpio->arizona;
  35
  36         return regmap_update_bits(arizona->regmap, ARIZONA_GPIO1_CTRL + offset,
  37                                   ARIZONA_GPN_DIR, ARIZONA_GPN_DIR);
  38 }
  39
  40 static int arizona_gpio_get(struct gpio_chip *chip, unsigned offset)
  41 {
  42         struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip);
  43         struct arizona *arizona = arizona_gpio->arizona;
  44         unsigned int val;
  45         int ret;
  46
  47         ret = regmap_read(arizona->regmap, ARIZONA_GPIO1_CTRL + offset, &val);
  48         if (ret < 0)
  49                 return ret;
  50
  51         if (val & ARIZONA_GPN_LVL)
  52                 return 1;
  53         else
  54                 return 0;
  55 }
  56
  57 static int arizona_gpio_direction_out(struct gpio_chip *chip,
  58                                      unsigned offset, int value)
  59 {
  60         struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip);
  61         struct arizona *arizona = arizona_gpio->arizona;
  62
  63         if (value)
  64                 value = ARIZONA_GPN_LVL;
  65
  66         return regmap_update_bits(arizona->regmap, ARIZONA_GPIO1_CTRL + offset,
  67                                   ARIZONA_GPN_DIR | ARIZONA_GPN_LVL, value);
  68 }
  69
  70 static void arizona_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
  71 {
  72         struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip);
  73         struct arizona *arizona = arizona_gpio->arizona;
  74
  75         if (value)
  76                 value = ARIZONA_GPN_LVL;
  77
  78         regmap_update_bits(arizona->regmap, ARIZONA_GPIO1_CTRL + offset,
  79                            ARIZONA_GPN_LVL, value);
  80 }
  81
  82 static struct gpio_chip template_chip = {
  83         .label                  = "arizona",
  84         .owner                  = THIS_MODULE,
  85         .direction_input        = arizona_gpio_direction_in,
  86         .get                    = arizona_gpio_get,
  87         .direction_output       = arizona_gpio_direction_out,
  88         .set                    = arizona_gpio_set,
  89         .can_sleep              = true,
  90 };
  91
  92 static int arizona_gpio_probe(struct platform_device *pdev)
  93 {
  94         struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
  95         struct arizona_pdata *pdata = dev_get_platdata(arizona->dev);
  96         struct arizona_gpio *arizona_gpio;
  97         int ret;
  98
  99         arizona_gpio = devm_kzalloc(&pdev->dev, sizeof(*arizona_gpio),
 100                                     GFP_KERNEL);
 101         if (!arizona_gpio)
 102                 return -ENOMEM;
 103
 104         arizona_gpio->arizona = arizona;
 105         arizona_gpio->gpio_chip = template_chip;
 106         arizona_gpio->gpio_chip.parent = &pdev->dev;
 107 #ifdef CONFIG_OF_GPIO
 108         arizona_gpio->gpio_chip.of_node = arizona->dev->of_node;
 109 #endif
 110
 111         switch (arizona->type) {
 112         case WM5102:
 113         case WM5110:
 114         case WM8280:
 115         case WM8997:
 116         case WM8998:
 117         case WM1814:
 118                 arizona_gpio->gpio_chip.ngpio = 5;
 119                 break;
 120         case WM1831:
 121         case CS47L24:
 122                 arizona_gpio->gpio_chip.ngpio = 2;
 123                 break;
 124         default:
 125                 dev_err(&pdev->dev, "Unknown chip variant %d\n",
 126                         arizona->type);
 127                 return -EINVAL;
 128         }
 129
 130         if (pdata && pdata->gpio_base)
 131                 arizona_gpio->gpio_chip.base = pdata->gpio_base;
 132         else
 133                 arizona_gpio->gpio_chip.base = -1;
 134
 135         ret = gpiochip_add_data(&arizona_gpio->gpio_chip, arizona_gpio);
 136         if (ret < 0) {
 137                 dev_err(&pdev->dev, "Could not register gpiochip, %d\n",
 138                         ret);
 139                 goto err;
 140         }
 141
 142         platform_set_drvdata(pdev, arizona_gpio);
 143
 144         return ret;
 145
 146 err:
 147         return ret;
 148 }
 149
 150 static int arizona_gpio_remove(struct platform_device *pdev)
 151 {
 152         struct arizona_gpio *arizona_gpio = platform_get_drvdata(pdev);
 153
 154         gpiochip_remove(&arizona_gpio->gpio_chip);
 155         return 0;
 156 }
 157
 158 static struct platform_driver arizona_gpio_driver = {
 159         .driver.name    = "arizona-gpio",
 160         .probe          = arizona_gpio_probe,
 161         .remove         = arizona_gpio_remove,
 162 };
 163
 164 module_platform_driver(arizona_gpio_driver);
 165
 166 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
 167 MODULE_DESCRIPTION("GPIO interface for Arizona devices");
 168 MODULE_LICENSE("GPL");
 169 MODULE_ALIAS("platform:arizona-gpio");