drivers/video/fbdev/via/via-gpio.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Support for viafb GPIO ports.
   4  *
   5  * Copyright 2009 Jonathan Corbet <corbet@lwn.net>
   6  */
   7
   8 #include <linux/spinlock.h>
   9 #include <linux/gpio/driver.h>
  10 #include <linux/gpio/machine.h>
  11 #include <linux/platform_device.h>
  12 #include <linux/via-core.h>
  13 #include <linux/export.h>
  14 #include "via-gpio.h"
  15
  16 /*
  17  * The ports we know about.  Note that the port-25 gpios are not
  18  * mentioned in the datasheet.
  19  */
  20
  21 struct viafb_gpio {
  22         char *vg_name;  /* Data sheet name */
  23         u16 vg_io_port;
  24         u8  vg_port_index;
  25         int  vg_mask_shift;
  26 };
  27
  28 static struct viafb_gpio viafb_all_gpios[] = {
  29         {
  30                 .vg_name = "VGPIO0",  /* Guess - not in datasheet */
  31                 .vg_io_port = VIASR,
  32                 .vg_port_index = 0x25,
  33                 .vg_mask_shift = 1
  34         },
  35         {
  36                 .vg_name = "VGPIO1",
  37                 .vg_io_port = VIASR,
  38                 .vg_port_index = 0x25,
  39                 .vg_mask_shift = 0
  40         },
  41         {
  42                 .vg_name = "VGPIO2",  /* aka DISPCLKI0 */
  43                 .vg_io_port = VIASR,
  44                 .vg_port_index = 0x2c,
  45                 .vg_mask_shift = 1
  46         },
  47         {
  48                 .vg_name = "VGPIO3",  /* aka DISPCLKO0 */
  49                 .vg_io_port = VIASR,
  50                 .vg_port_index = 0x2c,
  51                 .vg_mask_shift = 0
  52         },
  53         {
  54                 .vg_name = "VGPIO4",  /* DISPCLKI1 */
  55                 .vg_io_port = VIASR,
  56                 .vg_port_index = 0x3d,
  57                 .vg_mask_shift = 1
  58         },
  59         {
  60                 .vg_name = "VGPIO5",  /* DISPCLKO1 */
  61                 .vg_io_port = VIASR,
  62                 .vg_port_index = 0x3d,
  63                 .vg_mask_shift = 0
  64         },
  65 };
  66
  67 #define VIAFB_NUM_GPIOS ARRAY_SIZE(viafb_all_gpios)
  68
  69 /*
  70  * This structure controls the active GPIOs, which may be a subset
  71  * of those which are known.
  72  */
  73
  74 struct viafb_gpio_cfg {
  75         struct gpio_chip gpio_chip;
  76         struct viafb_dev *vdev;
  77         struct viafb_gpio *active_gpios[VIAFB_NUM_GPIOS];
  78         const char *gpio_names[VIAFB_NUM_GPIOS];
  79 };
  80
  81 /*
  82  * GPIO access functions
  83  */
  84 static void via_gpio_set(struct gpio_chip *chip, unsigned int nr,
  85                          int value)
  86 {
  87         struct viafb_gpio_cfg *cfg = gpiochip_get_data(chip);
  88         u8 reg;
  89         struct viafb_gpio *gpio;
  90         unsigned long flags;
  91
  92         spin_lock_irqsave(&cfg->vdev->reg_lock, flags);
  93         gpio = cfg->active_gpios[nr];
  94         reg = via_read_reg(VIASR, gpio->vg_port_index);
  95         reg |= 0x40 << gpio->vg_mask_shift;  /* output enable */
  96         if (value)
  97                 reg |= 0x10 << gpio->vg_mask_shift;
  98         else
  99                 reg &= ~(0x10 << gpio->vg_mask_shift);
 100         via_write_reg(VIASR, gpio->vg_port_index, reg);
 101         spin_unlock_irqrestore(&cfg->vdev->reg_lock, flags);
 102 }
 103
 104 static int via_gpio_dir_out(struct gpio_chip *chip, unsigned int nr,
 105                             int value)
 106 {
 107         via_gpio_set(chip, nr, value);
 108         return 0;
 109 }
 110
 111 /*
 112  * Set the input direction.  I'm not sure this is right; we should
 113  * be able to do input without disabling output.
 114  */
 115 static int via_gpio_dir_input(struct gpio_chip *chip, unsigned int nr)
 116 {
 117         struct viafb_gpio_cfg *cfg = gpiochip_get_data(chip);
 118         struct viafb_gpio *gpio;
 119         unsigned long flags;
 120
 121         spin_lock_irqsave(&cfg->vdev->reg_lock, flags);
 122         gpio = cfg->active_gpios[nr];
 123         via_write_reg_mask(VIASR, gpio->vg_port_index, 0,
 124                         0x40 << gpio->vg_mask_shift);
 125         spin_unlock_irqrestore(&cfg->vdev->reg_lock, flags);
 126         return 0;
 127 }
 128
 129 static int via_gpio_get(struct gpio_chip *chip, unsigned int nr)
 130 {
 131         struct viafb_gpio_cfg *cfg = gpiochip_get_data(chip);
 132         u8 reg;
 133         struct viafb_gpio *gpio;
 134         unsigned long flags;
 135
 136         spin_lock_irqsave(&cfg->vdev->reg_lock, flags);
 137         gpio = cfg->active_gpios[nr];
 138         reg = via_read_reg(VIASR, gpio->vg_port_index);
 139         spin_unlock_irqrestore(&cfg->vdev->reg_lock, flags);
 140         return !!(reg & (0x04 << gpio->vg_mask_shift));
 141 }
 142
 143
 144 static struct viafb_gpio_cfg viafb_gpio_config = {
 145         .gpio_chip = {
 146                 .label = "VIAFB onboard GPIO",
 147                 .owner = THIS_MODULE,
 148                 .direction_output = via_gpio_dir_out,
 149                 .set = via_gpio_set,
 150                 .direction_input = via_gpio_dir_input,
 151                 .get = via_gpio_get,
 152                 .base = -1,
 153                 .ngpio = 0,
 154                 .can_sleep = 0
 155         }
 156 };
 157
 158 /*
 159  * Manage the software enable bit.
 160  */
 161 static void viafb_gpio_enable(struct viafb_gpio *gpio)
 162 {
 163         via_write_reg_mask(VIASR, gpio->vg_port_index, 0x02, 0x02);
 164 }
 165
 166 static void viafb_gpio_disable(struct viafb_gpio *gpio)
 167 {
 168         via_write_reg_mask(VIASR, gpio->vg_port_index, 0, 0x02);
 169 }
 170
 171 #ifdef CONFIG_PM
 172
 173 static int viafb_gpio_suspend(void *private)
 174 {
 175         return 0;
 176 }
 177
 178 static int viafb_gpio_resume(void *private)
 179 {
 180         int i;
 181
 182         for (i = 0; i < viafb_gpio_config.gpio_chip.ngpio; i += 2)
 183                 viafb_gpio_enable(viafb_gpio_config.active_gpios[i]);
 184         return 0;
 185 }
 186
 187 static struct viafb_pm_hooks viafb_gpio_pm_hooks = {
 188         .suspend = viafb_gpio_suspend,
 189         .resume = viafb_gpio_resume
 190 };
 191 #endif /* CONFIG_PM */
 192
 193 static struct gpiod_lookup_table viafb_gpio_table = {
 194         .dev_id = "viafb-camera",
 195         .table = {
 196                 GPIO_LOOKUP("via-gpio", 2, "VGPIO2", GPIO_ACTIVE_LOW),
 197                 GPIO_LOOKUP("via-gpio", 3, "VGPIO3", GPIO_ACTIVE_HIGH),
 198                 { }
 199         },
 200 };
 201
 202 /*
 203  * Platform device stuff.
 204  */
 205 static int viafb_gpio_probe(struct platform_device *platdev)
 206 {
 207         struct viafb_dev *vdev = platdev->dev.platform_data;
 208         struct via_port_cfg *port_cfg = vdev->port_cfg;
 209         int i, ngpio = 0, ret;
 210         struct viafb_gpio *gpio;
 211         unsigned long flags;
 212
 213         /*
 214          * Set up entries for all GPIOs which have been configured to
 215          * operate as such (as opposed to as i2c ports).
 216          */
 217         for (i = 0; i < VIAFB_NUM_PORTS; i++) {
 218                 if (port_cfg[i].mode != VIA_MODE_GPIO)
 219                         continue;
 220                 for (gpio = viafb_all_gpios;
 221                      gpio < viafb_all_gpios + VIAFB_NUM_GPIOS; gpio++)
 222                         if (gpio->vg_port_index == port_cfg[i].ioport_index) {
 223                                 viafb_gpio_config.active_gpios[ngpio] = gpio;
 224                                 viafb_gpio_config.gpio_names[ngpio] =
 225                                         gpio->vg_name;
 226                                 ngpio++;
 227                         }
 228         }
 229         viafb_gpio_config.gpio_chip.ngpio = ngpio;
 230         viafb_gpio_config.gpio_chip.names = viafb_gpio_config.gpio_names;
 231         viafb_gpio_config.vdev = vdev;
 232         if (ngpio == 0) {
 233                 printk(KERN_INFO "viafb: no GPIOs configured\n");
 234                 return 0;
 235         }
 236         /*
 237          * Enable the ports.  They come in pairs, with a single
 238          * enable bit for both.
 239          */
 240         spin_lock_irqsave(&viafb_gpio_config.vdev->reg_lock, flags);
 241         for (i = 0; i < ngpio; i += 2)
 242                 viafb_gpio_enable(viafb_gpio_config.active_gpios[i]);
 243         spin_unlock_irqrestore(&viafb_gpio_config.vdev->reg_lock, flags);
 244         /*
 245          * Get registered.
 246          */
 247         viafb_gpio_config.gpio_chip.base = -1;  /* Dynamic */
 248         viafb_gpio_config.gpio_chip.label = "via-gpio";
 249         ret = gpiochip_add_data(&viafb_gpio_config.gpio_chip,
 250                                 &viafb_gpio_config);
 251         if (ret) {
 252                 printk(KERN_ERR "viafb: failed to add gpios (%d)\n", ret);
 253                 viafb_gpio_config.gpio_chip.ngpio = 0;
 254         }
 255
 256         gpiod_add_lookup_table(&viafb_gpio_table);
 257
 258 #ifdef CONFIG_PM
 259         viafb_pm_register(&viafb_gpio_pm_hooks);
 260 #endif
 261         return ret;
 262 }
 263
 264
 265 static void viafb_gpio_remove(struct platform_device *platdev)
 266 {
 267         unsigned long flags;
 268         int i;
 269
 270 #ifdef CONFIG_PM
 271         viafb_pm_unregister(&viafb_gpio_pm_hooks);
 272 #endif
 273
 274         /*
 275          * Get unregistered.
 276          */
 277         if (viafb_gpio_config.gpio_chip.ngpio > 0) {
 278                 gpiochip_remove(&viafb_gpio_config.gpio_chip);
 279         }
 280         /*
 281          * Disable the ports.
 282          */
 283         spin_lock_irqsave(&viafb_gpio_config.vdev->reg_lock, flags);
 284         for (i = 0; i < viafb_gpio_config.gpio_chip.ngpio; i += 2)
 285                 viafb_gpio_disable(viafb_gpio_config.active_gpios[i]);
 286         viafb_gpio_config.gpio_chip.ngpio = 0;
 287         spin_unlock_irqrestore(&viafb_gpio_config.vdev->reg_lock, flags);
 288 }
 289
 290 static struct platform_driver via_gpio_driver = {
 291         .driver = {
 292                 .name = "viafb-gpio",
 293         },
 294         .probe = viafb_gpio_probe,
 295         .remove = viafb_gpio_remove,
 296 };
 297
 298 int viafb_gpio_init(void)
 299 {
 300         return platform_driver_register(&via_gpio_driver);
 301 }
 302
 303 void viafb_gpio_exit(void)
 304 {
 305         platform_driver_unregister(&via_gpio_driver);
 306 }