sys/bus/gpio/gpio_intel/gpio_cherryview.c

   1 /*
   2  * Copyright (c) 2016 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Imre Vadász <imre@vdsz.com>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  * 3. Neither the name of The DragonFly Project nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific, prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34 /*
  35  * Cherryview GPIO support.
  36  */
  37
  38 #include <sys/param.h>
  39 #include <sys/systm.h>
  40 #include <sys/kernel.h>
  41 #include <sys/module.h>
  42 #include <sys/errno.h>
  43 #include <sys/lock.h>
  44 #include <sys/mutex.h>
  45 #include <sys/bus.h>
  46
  47 #include <sys/rman.h>
  48
  49 #include "opt_acpi.h"
  50 #include "acpi.h"
  51 #include <dev/acpica/acpivar.h>
  52
  53 #include "gpio_intel_var.h"
  54
  55 #include "gpio_if.h"
  56
  57 #define CHV_GPIO_REG_IS         0x300
  58 #define CHV_GPIO_REG_MASK       0x380
  59 #define CHV_GPIO_REG_PINS       0x4400  /* start of pin control registers */
  60
  61 #define CHV_GPIO_REGOFF_CTL0    0x0
  62 #define CHV_GPIO_REGOFF_CTL1    0x4
  63
  64 #define CHV_GPIO_CTL0_RXSTATE   0x00000001u
  65 #define CHV_GPIO_CTL0_TXSTATE   0x00000002u
  66 #define CHV_GPIO_CTL0_GPIOCFG_MASK 0x00000700u
  67 #define CHV_GPIO_CTL0_GPIOEN    0x00008000u
  68 #define CHV_GPIO_CTL0_PULLUP    0x00800000u
  69 #define CHV_GPIO_CTL1_INTCFG_MASK 0x00000007u
  70 #define CHV_GPIO_CTL1_INVRXDATA 0x00000040u
  71
  72 #define CHV_GPIO_PINSIZE        0x8     /* 8 bytes for each pin */
  73 #define CHV_GPIO_PINCHUNK       15      /* 15 pins at a time */
  74 #define CHV_GPIO_PININC         0x400   /* every 0x400 bytes */
  75
  76 #define PIN_ADDRESS(x)                                  \
  77     (CHV_GPIO_REG_PINS +                                \
  78      ((x) / CHV_GPIO_PINCHUNK) * CHV_GPIO_PININC +      \
  79      ((x) % CHV_GPIO_PINCHUNK) * CHV_GPIO_PINSIZE)
  80
  81 #define PIN_CTL0(x)             (PIN_ADDRESS(x) + CHV_GPIO_REGOFF_CTL0)
  82 #define PIN_CTL1(x)             (PIN_ADDRESS(x) + CHV_GPIO_REGOFF_CTL1)
  83
  84 static void     gpio_cherryview_init(struct gpio_intel_softc *sc);
  85 static void     gpio_cherryview_intr(void *arg);
  86 static int      gpio_cherryview_map_intr(struct gpio_intel_softc *sc,
  87                     uint16_t pin, int trigger, int polarity, int termination,
  88                     void *arg, driver_intr_t *handler);
  89 static void     gpio_cherryview_unmap_intr(struct gpio_intel_softc *sc,
  90                     uint16_t pin);
  91 static int      gpio_cherryview_read_pin(struct gpio_intel_softc *sc,
  92                     uint16_t pin);
  93 static void     gpio_cherryview_write_pin(struct gpio_intel_softc *sc,
  94                     uint16_t pin, int value);
  95
  96 static struct gpio_intel_fns gpio_cherryview_fns = {
  97         .init = gpio_cherryview_init,
  98         .intr = gpio_cherryview_intr,
  99         .map_intr = gpio_cherryview_map_intr,
 100         .unmap_intr = gpio_cherryview_unmap_intr,
 101         .read_pin = gpio_cherryview_read_pin,
 102         .write_pin = gpio_cherryview_write_pin,
 103 };
 104
 105 /* _UID=1 */
 106 static struct pinrange chv_sw_ranges[] = {
 107         { 0, 7 },
 108         { 15, 22 },
 109         { 30, 37 },
 110         { 45, 52 },
 111         { 60, 67 },
 112         { 75, 82 },
 113         { 90, 97 },
 114         { -1, -1 }
 115 };
 116
 117 /* _UID=2 */
 118 static struct pinrange chv_n_ranges[] = {
 119         { 0, 8 },
 120         { 15, 27 },
 121         { 30, 41 },
 122         { 45, 56 },
 123         { 60, 72 },
 124         { -1, -1 }
 125 };
 126
 127 /* _UID=3 */
 128 static struct pinrange chv_e_ranges[] = {
 129         { 0, 11 },
 130         { 15, 26 },
 131         { -1, -1 }
 132 };
 133
 134 /* _UID=4 */
 135 static struct pinrange chv_se_ranges[] = {
 136         { 0, 7 },
 137         { 15, 26 },
 138         { 30, 35 },
 139         { 45, 52 },
 140         { 60, 69 },
 141         { 75, 85 },
 142         { -1, -1 }
 143 };
 144
 145 int
 146 gpio_cherryview_matchuid(struct gpio_intel_softc *sc)
 147 {
 148         ACPI_HANDLE handle;
 149
 150         handle = acpi_get_handle(sc->dev);
 151         if (acpi_MatchUid(handle, "1")) {
 152                 sc->ranges = chv_sw_ranges;
 153         } else if (acpi_MatchUid(handle, "2")) {
 154                 sc->ranges = chv_n_ranges;
 155         } else if (acpi_MatchUid(handle, "3")) {
 156                 sc->ranges = chv_e_ranges;
 157         } else if (acpi_MatchUid(handle, "4")) {
 158                 sc->ranges = chv_se_ranges;
 159         } else {
 160                 return (ENXIO);
 161         }
 162
 163         sc->fns = &gpio_cherryview_fns;
 164
 165         return (0);
 166 }
 167
 168 static void
 169 gpio_cherryview_init(struct gpio_intel_softc *sc)
 170 {
 171         /* mask and clear all interrupt lines */
 172         bus_write_4(sc->mem_res, CHV_GPIO_REG_MASK, 0);
 173         bus_write_4(sc->mem_res, CHV_GPIO_REG_IS, 0xffff);
 174 }
 175
 176 static void
 177 gpio_cherryview_intr(void *arg)
 178 {
 179         struct gpio_intel_softc *sc = (struct gpio_intel_softc *)arg;
 180         struct pin_intr_map *mapping;
 181         uint32_t status;
 182         int i;
 183
 184         status = bus_read_4(sc->mem_res, CHV_GPIO_REG_IS);
 185         bus_write_4(sc->mem_res, CHV_GPIO_REG_IS, status);
 186         for (i = 0; i < 16; i++) {
 187                 if (status & (1 << i)) {
 188                         mapping = &sc->intrmaps[i];
 189                         if (mapping->pin != -1 && mapping->handler != NULL)
 190                                 mapping->handler(mapping->arg);
 191                 }
 192         }
 193 }
 194
 195 /* XXX Add shared/exclusive argument. */
 196 static int
 197 gpio_cherryview_map_intr(struct gpio_intel_softc *sc, uint16_t pin, int trigger,
 198     int polarity, int termination, void *arg, driver_intr_t *handler)
 199 {
 200         uint32_t reg, reg1, reg2;
 201         uint32_t intcfg, new_intcfg;
 202         int i;
 203
 204         reg1 = bus_read_4(sc->mem_res, PIN_CTL0(pin));
 205         reg2 = bus_read_4(sc->mem_res, PIN_CTL1(pin));
 206         device_printf(sc->dev,
 207             "pin=%d trigger=%d polarity=%d ctrl0=0x%08x ctrl1=0x%08x\n",
 208             pin, trigger, polarity, reg1, reg2);
 209
 210         new_intcfg = intcfg = reg2 & CHV_GPIO_CTL1_INTCFG_MASK;
 211
 212         /*
 213          * Sanity Checks, for now we just abort if the configuration doesn't
 214          * match our expectations.
 215          */
 216         if (!(reg1 & CHV_GPIO_CTL0_GPIOEN)) {
 217                 device_printf(sc->dev, "GPIO mode is disabled\n");
 218                 return (ENXIO);
 219         }
 220         if ((reg1 & CHV_GPIO_CTL0_GPIOCFG_MASK) != 0x0 &&
 221             (reg1 & CHV_GPIO_CTL0_GPIOCFG_MASK) != 0x200) {
 222                 device_printf(sc->dev, "RX is disabled\n");
 223                 return (ENXIO);
 224         }
 225         if (trigger == ACPI_LEVEL_SENSITIVE) {
 226                 if (intcfg != 4) {
 227                         device_printf(sc->dev,
 228                             "trigger is %x, should be 4 (Level)\n", intcfg);
 229                         return (ENXIO);
 230                 }
 231                 if (polarity == ACPI_ACTIVE_BOTH) {
 232                         device_printf(sc->dev,
 233                             "ACTIVE_BOTH incompatible with level trigger\n");
 234                         return (ENXIO);
 235                 } else if (polarity == ACPI_ACTIVE_LOW) {
 236                         if (!(reg2 & CHV_GPIO_CTL1_INVRXDATA)) {
 237                                 device_printf(sc->dev,
 238                                     "Invert RX not enabled (needed for "
 239                                     "level/low trigger/polarity)\n");
 240                                 return (ENXIO);
 241                         }
 242                 } else {
 243                         if (reg2 & CHV_GPIO_CTL1_INVRXDATA) {
 244                                 device_printf(sc->dev,
 245                                     "Invert RX should not be enabled for "
 246                                     "level/high trigger/polarity\n");
 247                                 return (ENXIO);
 248                         }
 249                 }
 250         } else {
 251                 /*
 252                  * For edge-triggered interrupts it's definitely harmless to
 253                  * change between rising-edge, falling-edge and both-edges
 254                  * triggering.
 255                  */
 256                 if (polarity == ACPI_ACTIVE_HIGH && intcfg != 2) {
 257                         device_printf(sc->dev,
 258                             "Wrong interrupt configuration, is 0x%x should "
 259                             "be 0x%x\n", intcfg, 2);
 260                         if (intcfg == 1 || intcfg == 3)
 261                                 new_intcfg = 2;
 262                         else
 263                                 return (ENXIO);
 264                 } else if (polarity == ACPI_ACTIVE_LOW && intcfg != 1) {
 265                         device_printf(sc->dev,
 266                             "Wrong interrupt configuration, is 0x%x should "
 267                             "be 0x%x\n", intcfg, 1);
 268                         if (intcfg == 2 || intcfg == 3)
 269                                 new_intcfg = 1;
 270                         else
 271                                 return (ENXIO);
 272                 } else if (polarity == ACPI_ACTIVE_BOTH && intcfg != 3) {
 273                         device_printf(sc->dev,
 274                             "Wrong interrupt configuration, is 0x%x should "
 275                             "be 0x%x\n", intcfg, 3);
 276                         if (intcfg == 1 || intcfg == 2)
 277                                 new_intcfg = 3;
 278                         else
 279                                 return (ENXIO);
 280                 }
 281         }
 282         if (termination == ACPI_PIN_CONFIG_PULLUP &&
 283             !(reg1 & CHV_GPIO_CTL0_PULLUP)) {
 284                 device_printf(sc->dev,
 285                     "Wrong termination, is pull-down, should be pull-up\n");
 286                 return (ENXIO);
 287         } else if (termination == ACPI_PIN_CONFIG_PULLDOWN &&
 288             (reg1 & CHV_GPIO_CTL0_PULLUP)) {
 289                 device_printf(sc->dev,
 290                     "Wrong termination, is pull-up, should be pull-down\n");
 291                 return (ENXIO);
 292         }
 293
 294         /* Check if the interrupt/line configured by BIOS/UEFI is unused */
 295         i = (reg1 >> 28) & 0xf;
 296         if (sc->intrmaps[i].pin != -1) {
 297                 device_printf(sc->dev, "Interrupt line %d already used\n", i);
 298                 return (ENXIO);
 299         }
 300
 301         if (new_intcfg != intcfg) {
 302                 device_printf(sc->dev,
 303                     "Switching interrupt configuration from 0x%x to 0x%x\n",
 304                     intcfg, new_intcfg);
 305                 reg = reg2 & ~CHV_GPIO_CTL1_INTCFG_MASK;
 306                 reg |= (new_intcfg & CHV_GPIO_CTL1_INTCFG_MASK) << 0;
 307                 bus_write_4(sc->mem_res, PIN_CTL1(pin), reg);
 308         }
 309
 310         sc->intrmaps[i].pin = pin;
 311         sc->intrmaps[i].arg = arg;
 312         sc->intrmaps[i].handler = handler;
 313         sc->intrmaps[i].orig_intcfg = intcfg;
 314
 315         /* unmask interrupt */
 316         reg = bus_read_4(sc->mem_res, CHV_GPIO_REG_MASK);
 317         reg |= (1 << i);
 318         bus_write_4(sc->mem_res, CHV_GPIO_REG_MASK, reg);
 319
 320         return (0);
 321 }
 322
 323 static void
 324 gpio_cherryview_unmap_intr(struct gpio_intel_softc *sc, uint16_t pin)
 325 {
 326         uint32_t reg, cfg;
 327         int i;
 328
 329         for (i = 0; i < 16; i++) {
 330                 if (sc->intrmaps[i].pin == pin) {
 331                         cfg = sc->intrmaps[i].orig_intcfg;
 332
 333                         sc->intrmaps[i].pin = -1;
 334                         sc->intrmaps[i].arg = NULL;
 335                         sc->intrmaps[i].handler = NULL;
 336                         sc->intrmaps[i].orig_intcfg = 0;
 337
 338                         /* mask interrupt line */
 339                         reg = bus_read_4(sc->mem_res, CHV_GPIO_REG_MASK);
 340                         reg &= ~(1 << i);
 341                         bus_write_4(sc->mem_res, CHV_GPIO_REG_MASK, reg);
 342
 343                         /* Restore interrupt configuration if needed */
 344                         reg = bus_read_4(sc->mem_res, PIN_CTL1(pin));
 345                         if ((reg & CHV_GPIO_CTL1_INTCFG_MASK) != cfg) {
 346                                 reg &= ~CHV_GPIO_CTL1_INTCFG_MASK;
 347                                 reg |= (cfg & CHV_GPIO_CTL1_INTCFG_MASK) << 0;
 348                                 bus_write_4(sc->mem_res, PIN_CTL1(pin), reg);
 349                         }
 350                 }
 351         }
 352 }
 353
 354 static int
 355 gpio_cherryview_read_pin(struct gpio_intel_softc *sc, uint16_t pin)
 356 {
 357         uint32_t reg;
 358         int val;
 359
 360         reg = bus_read_4(sc->mem_res, PIN_CTL0(pin));
 361         /* Verify that RX is enabled */
 362         KKASSERT((reg & CHV_GPIO_CTL0_GPIOCFG_MASK) == 0x0 ||
 363             (reg & CHV_GPIO_CTL0_GPIOCFG_MASK) == 0x200);
 364
 365         if (reg & CHV_GPIO_CTL0_RXSTATE)
 366                 val = 1;
 367         else
 368                 val = 0;
 369
 370         return (val);
 371 }
 372
 373 static void
 374 gpio_cherryview_write_pin(struct gpio_intel_softc *sc, uint16_t pin, int value)
 375 {
 376         uint32_t reg1, reg2;
 377
 378         reg2 = bus_read_4(sc->mem_res, PIN_CTL1(pin));
 379         /* Verify that interrupt is disabled */
 380         KKASSERT((reg2 & CHV_GPIO_CTL1_INTCFG_MASK) == 0);
 381
 382         reg1 = bus_read_4(sc->mem_res, PIN_CTL0(pin));
 383         /* Verify that TX is enabled */
 384         KKASSERT((reg1 & CHV_GPIO_CTL0_GPIOCFG_MASK) == 0 ||
 385             (reg1 & CHV_GPIO_CTL0_GPIOCFG_MASK) == 0x100);
 386
 387         if (value)
 388                 reg1 |= CHV_GPIO_CTL0_TXSTATE;
 389         else
 390                 reg1 &= ~CHV_GPIO_CTL0_TXSTATE;
 391         bus_write_4(sc->mem_res, PIN_CTL0(pin), reg1);
 392 }