drivers/ssb/driver_gpio.c

0001 /*
0002  * Sonics Silicon Backplane
0003  * GPIO driver
0004  *
0005  * Copyright 2011, Broadcom Corporation
0006  * Copyright 2012, Hauke Mehrtens <hauke@hauke-m.de>
0007  *
0008  * Licensed under the GNU/GPL. See COPYING for details.
0009  */
0010
0011 #include "ssb_private.h"
0012
0013 #include <linux/gpio/driver.h>
0014 #include <linux/irq.h>
0015 #include <linux/interrupt.h>
0016 #include <linux/irqdomain.h>
0017 #include <linux/export.h>
0018 #include <linux/ssb/ssb.h>
0019
0020
0021 /**************************************************
0022  * Shared
0023  **************************************************/
0024
0025 #if IS_ENABLED(CONFIG_SSB_EMBEDDED)
0026 static int ssb_gpio_to_irq(struct gpio_chip *chip, unsigned int gpio)
0027 {
0028     struct ssb_bus *bus = gpiochip_get_data(chip);
0029
0030     if (bus->bustype == SSB_BUSTYPE_SSB)
0031         return irq_find_mapping(bus->irq_domain, gpio);
0032     else
0033         return -EINVAL;
0034 }
0035 #endif
0036
0037 /**************************************************
0038  * ChipCommon
0039  **************************************************/
0040
0041 static int ssb_gpio_chipco_get_value(struct gpio_chip *chip, unsigned int gpio)
0042 {
0043     struct ssb_bus *bus = gpiochip_get_data(chip);
0044
0045     return !!ssb_chipco_gpio_in(&bus->chipco, 1 << gpio);
0046 }
0047
0048 static void ssb_gpio_chipco_set_value(struct gpio_chip *chip, unsigned int gpio,
0049                       int value)
0050 {
0051     struct ssb_bus *bus = gpiochip_get_data(chip);
0052
0053     ssb_chipco_gpio_out(&bus->chipco, 1 << gpio, value ? 1 << gpio : 0);
0054 }
0055
0056 static int ssb_gpio_chipco_direction_input(struct gpio_chip *chip,
0057                        unsigned int gpio)
0058 {
0059     struct ssb_bus *bus = gpiochip_get_data(chip);
0060
0061     ssb_chipco_gpio_outen(&bus->chipco, 1 << gpio, 0);
0062     return 0;
0063 }
0064
0065 static int ssb_gpio_chipco_direction_output(struct gpio_chip *chip,
0066                         unsigned int gpio, int value)
0067 {
0068     struct ssb_bus *bus = gpiochip_get_data(chip);
0069
0070     ssb_chipco_gpio_outen(&bus->chipco, 1 << gpio, 1 << gpio);
0071     ssb_chipco_gpio_out(&bus->chipco, 1 << gpio, value ? 1 << gpio : 0);
0072     return 0;
0073 }
0074
0075 static int ssb_gpio_chipco_request(struct gpio_chip *chip, unsigned int gpio)
0076 {
0077     struct ssb_bus *bus = gpiochip_get_data(chip);
0078
0079     ssb_chipco_gpio_control(&bus->chipco, 1 << gpio, 0);
0080     /* clear pulldown */
0081     ssb_chipco_gpio_pulldown(&bus->chipco, 1 << gpio, 0);
0082     /* Set pullup */
0083     ssb_chipco_gpio_pullup(&bus->chipco, 1 << gpio, 1 << gpio);
0084
0085     return 0;
0086 }
0087
0088 static void ssb_gpio_chipco_free(struct gpio_chip *chip, unsigned int gpio)
0089 {
0090     struct ssb_bus *bus = gpiochip_get_data(chip);
0091
0092     /* clear pullup */
0093     ssb_chipco_gpio_pullup(&bus->chipco, 1 << gpio, 0);
0094 }
0095
0096 #if IS_ENABLED(CONFIG_SSB_EMBEDDED)
0097 static void ssb_gpio_irq_chipco_mask(struct irq_data *d)
0098 {
0099     struct ssb_bus *bus = irq_data_get_irq_chip_data(d);
0100     int gpio = irqd_to_hwirq(d);
0101
0102     ssb_chipco_gpio_intmask(&bus->chipco, BIT(gpio), 0);
0103 }
0104
0105 static void ssb_gpio_irq_chipco_unmask(struct irq_data *d)
0106 {
0107     struct ssb_bus *bus = irq_data_get_irq_chip_data(d);
0108     int gpio = irqd_to_hwirq(d);
0109     u32 val = ssb_chipco_gpio_in(&bus->chipco, BIT(gpio));
0110
0111     ssb_chipco_gpio_polarity(&bus->chipco, BIT(gpio), val);
0112     ssb_chipco_gpio_intmask(&bus->chipco, BIT(gpio), BIT(gpio));
0113 }
0114
0115 static struct irq_chip ssb_gpio_irq_chipco_chip = {
0116     .name       = "SSB-GPIO-CC",
0117     .irq_mask   = ssb_gpio_irq_chipco_mask,
0118     .irq_unmask = ssb_gpio_irq_chipco_unmask,
0119 };
0120
0121 static irqreturn_t ssb_gpio_irq_chipco_handler(int irq, void *dev_id)
0122 {
0123     struct ssb_bus *bus = dev_id;
0124     struct ssb_chipcommon *chipco = &bus->chipco;
0125     u32 val = chipco_read32(chipco, SSB_CHIPCO_GPIOIN);
0126     u32 mask = chipco_read32(chipco, SSB_CHIPCO_GPIOIRQ);
0127     u32 pol = chipco_read32(chipco, SSB_CHIPCO_GPIOPOL);
0128     unsigned long irqs = (val ^ pol) & mask;
0129     int gpio;
0130
0131     if (!irqs)
0132         return IRQ_NONE;
0133
0134     for_each_set_bit(gpio, &irqs, bus->gpio.ngpio)
0135         generic_handle_irq(ssb_gpio_to_irq(&bus->gpio, gpio));
0136     ssb_chipco_gpio_polarity(chipco, irqs, val & irqs);
0137
0138     return IRQ_HANDLED;
0139 }
0140
0141 static int ssb_gpio_irq_chipco_domain_init(struct ssb_bus *bus)
0142 {
0143     struct ssb_chipcommon *chipco = &bus->chipco;
0144     struct gpio_chip *chip = &bus->gpio;
0145     int gpio, hwirq, err;
0146
0147     if (bus->bustype != SSB_BUSTYPE_SSB)
0148         return 0;
0149
0150     bus->irq_domain = irq_domain_add_linear(NULL, chip->ngpio,
0151                         &irq_domain_simple_ops, chipco);
0152     if (!bus->irq_domain) {
0153         err = -ENODEV;
0154         goto err_irq_domain;
0155     }
0156     for (gpio = 0; gpio < chip->ngpio; gpio++) {
0157         int irq = irq_create_mapping(bus->irq_domain, gpio);
0158
0159         irq_set_chip_data(irq, bus);
0160         irq_set_chip_and_handler(irq, &ssb_gpio_irq_chipco_chip,
0161                      handle_simple_irq);
0162     }
0163
0164     hwirq = ssb_mips_irq(bus->chipco.dev) + 2;
0165     err = request_irq(hwirq, ssb_gpio_irq_chipco_handler, IRQF_SHARED,
0166               "gpio", bus);
0167     if (err)
0168         goto err_req_irq;
0169
0170     ssb_chipco_gpio_intmask(&bus->chipco, ~0, 0);
0171     chipco_set32(chipco, SSB_CHIPCO_IRQMASK, SSB_CHIPCO_IRQ_GPIO);
0172
0173     return 0;
0174
0175 err_req_irq:
0176     for (gpio = 0; gpio < chip->ngpio; gpio++) {
0177         int irq = irq_find_mapping(bus->irq_domain, gpio);
0178
0179         irq_dispose_mapping(irq);
0180     }
0181     irq_domain_remove(bus->irq_domain);
0182 err_irq_domain:
0183     return err;
0184 }
0185
0186 static void ssb_gpio_irq_chipco_domain_exit(struct ssb_bus *bus)
0187 {
0188     struct ssb_chipcommon *chipco = &bus->chipco;
0189     struct gpio_chip *chip = &bus->gpio;
0190     int gpio;
0191
0192     if (bus->bustype != SSB_BUSTYPE_SSB)
0193         return;
0194
0195     chipco_mask32(chipco, SSB_CHIPCO_IRQMASK, ~SSB_CHIPCO_IRQ_GPIO);
0196     free_irq(ssb_mips_irq(bus->chipco.dev) + 2, chipco);
0197     for (gpio = 0; gpio < chip->ngpio; gpio++) {
0198         int irq = irq_find_mapping(bus->irq_domain, gpio);
0199
0200         irq_dispose_mapping(irq);
0201     }
0202     irq_domain_remove(bus->irq_domain);
0203 }
0204 #else
0205 static int ssb_gpio_irq_chipco_domain_init(struct ssb_bus *bus)
0206 {
0207     return 0;
0208 }
0209
0210 static void ssb_gpio_irq_chipco_domain_exit(struct ssb_bus *bus)
0211 {
0212 }
0213 #endif
0214
0215 static int ssb_gpio_chipco_init(struct ssb_bus *bus)
0216 {
0217     struct gpio_chip *chip = &bus->gpio;
0218     int err;
0219
0220     chip->label     = "ssb_chipco_gpio";
0221     chip->owner     = THIS_MODULE;
0222     chip->request       = ssb_gpio_chipco_request;
0223     chip->free      = ssb_gpio_chipco_free;
0224     chip->get       = ssb_gpio_chipco_get_value;
0225     chip->set       = ssb_gpio_chipco_set_value;
0226     chip->direction_input   = ssb_gpio_chipco_direction_input;
0227     chip->direction_output  = ssb_gpio_chipco_direction_output;
0228 #if IS_ENABLED(CONFIG_SSB_EMBEDDED)
0229     chip->to_irq        = ssb_gpio_to_irq;
0230 #endif
0231     chip->ngpio     = 16;
0232     /* There is just one SoC in one device and its GPIO addresses should be
0233      * deterministic to address them more easily. The other buses could get
0234      * a random base number.
0235      */
0236     if (bus->bustype == SSB_BUSTYPE_SSB)
0237         chip->base      = 0;
0238     else
0239         chip->base      = -1;
0240
0241     err = ssb_gpio_irq_chipco_domain_init(bus);
0242     if (err)
0243         return err;
0244
0245     err = gpiochip_add_data(chip, bus);
0246     if (err) {
0247         ssb_gpio_irq_chipco_domain_exit(bus);
0248         return err;
0249     }
0250
0251     return 0;
0252 }
0253
0254 /**************************************************
0255  * EXTIF
0256  **************************************************/
0257
0258 #ifdef CONFIG_SSB_DRIVER_EXTIF
0259
0260 static int ssb_gpio_extif_get_value(struct gpio_chip *chip, unsigned int gpio)
0261 {
0262     struct ssb_bus *bus = gpiochip_get_data(chip);
0263
0264     return !!ssb_extif_gpio_in(&bus->extif, 1 << gpio);
0265 }
0266
0267 static void ssb_gpio_extif_set_value(struct gpio_chip *chip, unsigned int gpio,
0268                      int value)
0269 {
0270     struct ssb_bus *bus = gpiochip_get_data(chip);
0271
0272     ssb_extif_gpio_out(&bus->extif, 1 << gpio, value ? 1 << gpio : 0);
0273 }
0274
0275 static int ssb_gpio_extif_direction_input(struct gpio_chip *chip,
0276                       unsigned int gpio)
0277 {
0278     struct ssb_bus *bus = gpiochip_get_data(chip);
0279
0280     ssb_extif_gpio_outen(&bus->extif, 1 << gpio, 0);
0281     return 0;
0282 }
0283
0284 static int ssb_gpio_extif_direction_output(struct gpio_chip *chip,
0285                        unsigned int gpio, int value)
0286 {
0287     struct ssb_bus *bus = gpiochip_get_data(chip);
0288
0289     ssb_extif_gpio_outen(&bus->extif, 1 << gpio, 1 << gpio);
0290     ssb_extif_gpio_out(&bus->extif, 1 << gpio, value ? 1 << gpio : 0);
0291     return 0;
0292 }
0293
0294 #if IS_ENABLED(CONFIG_SSB_EMBEDDED)
0295 static void ssb_gpio_irq_extif_mask(struct irq_data *d)
0296 {
0297     struct ssb_bus *bus = irq_data_get_irq_chip_data(d);
0298     int gpio = irqd_to_hwirq(d);
0299
0300     ssb_extif_gpio_intmask(&bus->extif, BIT(gpio), 0);
0301 }
0302
0303 static void ssb_gpio_irq_extif_unmask(struct irq_data *d)
0304 {
0305     struct ssb_bus *bus = irq_data_get_irq_chip_data(d);
0306     int gpio = irqd_to_hwirq(d);
0307     u32 val = ssb_extif_gpio_in(&bus->extif, BIT(gpio));
0308
0309     ssb_extif_gpio_polarity(&bus->extif, BIT(gpio), val);
0310     ssb_extif_gpio_intmask(&bus->extif, BIT(gpio), BIT(gpio));
0311 }
0312
0313 static struct irq_chip ssb_gpio_irq_extif_chip = {
0314     .name       = "SSB-GPIO-EXTIF",
0315     .irq_mask   = ssb_gpio_irq_extif_mask,
0316     .irq_unmask = ssb_gpio_irq_extif_unmask,
0317 };
0318
0319 static irqreturn_t ssb_gpio_irq_extif_handler(int irq, void *dev_id)
0320 {
0321     struct ssb_bus *bus = dev_id;
0322     struct ssb_extif *extif = &bus->extif;
0323     u32 val = ssb_read32(extif->dev, SSB_EXTIF_GPIO_IN);
0324     u32 mask = ssb_read32(extif->dev, SSB_EXTIF_GPIO_INTMASK);
0325     u32 pol = ssb_read32(extif->dev, SSB_EXTIF_GPIO_INTPOL);
0326     unsigned long irqs = (val ^ pol) & mask;
0327     int gpio;
0328
0329     if (!irqs)
0330         return IRQ_NONE;
0331
0332     for_each_set_bit(gpio, &irqs, bus->gpio.ngpio)
0333         generic_handle_irq(ssb_gpio_to_irq(&bus->gpio, gpio));
0334     ssb_extif_gpio_polarity(extif, irqs, val & irqs);
0335
0336     return IRQ_HANDLED;
0337 }
0338
0339 static int ssb_gpio_irq_extif_domain_init(struct ssb_bus *bus)
0340 {
0341     struct ssb_extif *extif = &bus->extif;
0342     struct gpio_chip *chip = &bus->gpio;
0343     int gpio, hwirq, err;
0344
0345     if (bus->bustype != SSB_BUSTYPE_SSB)
0346         return 0;
0347
0348     bus->irq_domain = irq_domain_add_linear(NULL, chip->ngpio,
0349                         &irq_domain_simple_ops, extif);
0350     if (!bus->irq_domain) {
0351         err = -ENODEV;
0352         goto err_irq_domain;
0353     }
0354     for (gpio = 0; gpio < chip->ngpio; gpio++) {
0355         int irq = irq_create_mapping(bus->irq_domain, gpio);
0356
0357         irq_set_chip_data(irq, bus);
0358         irq_set_chip_and_handler(irq, &ssb_gpio_irq_extif_chip,
0359                      handle_simple_irq);
0360     }
0361
0362     hwirq = ssb_mips_irq(bus->extif.dev) + 2;
0363     err = request_irq(hwirq, ssb_gpio_irq_extif_handler, IRQF_SHARED,
0364               "gpio", bus);
0365     if (err)
0366         goto err_req_irq;
0367
0368     ssb_extif_gpio_intmask(&bus->extif, ~0, 0);
0369
0370     return 0;
0371
0372 err_req_irq:
0373     for (gpio = 0; gpio < chip->ngpio; gpio++) {
0374         int irq = irq_find_mapping(bus->irq_domain, gpio);
0375
0376         irq_dispose_mapping(irq);
0377     }
0378     irq_domain_remove(bus->irq_domain);
0379 err_irq_domain:
0380     return err;
0381 }
0382
0383 static void ssb_gpio_irq_extif_domain_exit(struct ssb_bus *bus)
0384 {
0385     struct ssb_extif *extif = &bus->extif;
0386     struct gpio_chip *chip = &bus->gpio;
0387     int gpio;
0388
0389     if (bus->bustype != SSB_BUSTYPE_SSB)
0390         return;
0391
0392     free_irq(ssb_mips_irq(bus->extif.dev) + 2, extif);
0393     for (gpio = 0; gpio < chip->ngpio; gpio++) {
0394         int irq = irq_find_mapping(bus->irq_domain, gpio);
0395
0396         irq_dispose_mapping(irq);
0397     }
0398     irq_domain_remove(bus->irq_domain);
0399 }
0400 #else
0401 static int ssb_gpio_irq_extif_domain_init(struct ssb_bus *bus)
0402 {
0403     return 0;
0404 }
0405
0406 static void ssb_gpio_irq_extif_domain_exit(struct ssb_bus *bus)
0407 {
0408 }
0409 #endif
0410
0411 static int ssb_gpio_extif_init(struct ssb_bus *bus)
0412 {
0413     struct gpio_chip *chip = &bus->gpio;
0414     int err;
0415
0416     chip->label     = "ssb_extif_gpio";
0417     chip->owner     = THIS_MODULE;
0418     chip->get       = ssb_gpio_extif_get_value;
0419     chip->set       = ssb_gpio_extif_set_value;
0420     chip->direction_input   = ssb_gpio_extif_direction_input;
0421     chip->direction_output  = ssb_gpio_extif_direction_output;
0422 #if IS_ENABLED(CONFIG_SSB_EMBEDDED)
0423     chip->to_irq        = ssb_gpio_to_irq;
0424 #endif
0425     chip->ngpio     = 5;
0426     /* There is just one SoC in one device and its GPIO addresses should be
0427      * deterministic to address them more easily. The other buses could get
0428      * a random base number.
0429      */
0430     if (bus->bustype == SSB_BUSTYPE_SSB)
0431         chip->base      = 0;
0432     else
0433         chip->base      = -1;
0434
0435     err = ssb_gpio_irq_extif_domain_init(bus);
0436     if (err)
0437         return err;
0438
0439     err = gpiochip_add_data(chip, bus);
0440     if (err) {
0441         ssb_gpio_irq_extif_domain_exit(bus);
0442         return err;
0443     }
0444
0445     return 0;
0446 }
0447
0448 #else
0449 static int ssb_gpio_extif_init(struct ssb_bus *bus)
0450 {
0451     return -ENOTSUPP;
0452 }
0453 #endif
0454
0455 /**************************************************
0456  * Init
0457  **************************************************/
0458
0459 int ssb_gpio_init(struct ssb_bus *bus)
0460 {
0461     if (ssb_chipco_available(&bus->chipco))
0462         return ssb_gpio_chipco_init(bus);
0463     else if (ssb_extif_available(&bus->extif))
0464         return ssb_gpio_extif_init(bus);
0465     return -1;
0466 }
0467
0468 int ssb_gpio_unregister(struct ssb_bus *bus)
0469 {
0470     if (ssb_chipco_available(&bus->chipco) ||
0471         ssb_extif_available(&bus->extif)) {
0472         gpiochip_remove(&bus->gpio);
0473         return 0;
0474     }
0475     return -1;
0476 }