drivers/mmc/core/slot-gpio.c

   1 /*
   2  * Generic GPIO card-detect helper
   3  *
   4  * Copyright (C) 2011, Guennadi Liakhovetski <g.liakhovetski@gmx.de>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  */
  10
  11 #include <linux/err.h>
  12 #include <linux/gpio/consumer.h>
  13 #include <linux/interrupt.h>
  14 #include <linux/jiffies.h>
  15 #include <linux/mmc/host.h>
  16 #include <linux/mmc/slot-gpio.h>
  17 #include <linux/module.h>
  18 #include <linux/slab.h>
  19
  20 #include "slot-gpio.h"
  21
  22 struct mmc_gpio {
  23         struct gpio_desc *ro_gpio;
  24         struct gpio_desc *cd_gpio;
  25         bool override_cd_active_level;
  26         irqreturn_t (*cd_gpio_isr)(int irq, void *dev_id);
  27         char *ro_label;
  28         char *cd_label;
  29         u32 cd_debounce_delay_ms;
  30 };
  31
  32 static irqreturn_t mmc_gpio_cd_irqt(int irq, void *dev_id)
  33 {
  34         /* Schedule a card detection after a debounce timeout */
  35         struct mmc_host *host = dev_id;
  36         struct mmc_gpio *ctx = host->slot.handler_priv;
  37
  38         host->trigger_card_event = true;
  39         mmc_detect_change(host, msecs_to_jiffies(ctx->cd_debounce_delay_ms));
  40
  41         return IRQ_HANDLED;
  42 }
  43
  44 int mmc_gpio_alloc(struct mmc_host *host)
  45 {
  46         struct mmc_gpio *ctx = devm_kzalloc(host->parent,
  47                                             sizeof(*ctx), GFP_KERNEL);
  48
  49         if (ctx) {
  50                 ctx->cd_debounce_delay_ms = 200;
  51                 ctx->cd_label = devm_kasprintf(host->parent, GFP_KERNEL,
  52                                 "%s cd", dev_name(host->parent));
  53                 if (!ctx->cd_label)
  54                         return -ENOMEM;
  55                 ctx->ro_label = devm_kasprintf(host->parent, GFP_KERNEL,
  56                                 "%s ro", dev_name(host->parent));
  57                 if (!ctx->ro_label)
  58                         return -ENOMEM;
  59                 host->slot.handler_priv = ctx;
  60                 host->slot.cd_irq = -EINVAL;
  61         }
  62
  63         return ctx ? 0 : -ENOMEM;
  64 }
  65
  66 int mmc_gpio_get_ro(struct mmc_host *host)
  67 {
  68         struct mmc_gpio *ctx = host->slot.handler_priv;
  69
  70         if (!ctx || !ctx->ro_gpio)
  71                 return -ENOSYS;
  72
  73         return gpiod_get_value_cansleep(ctx->ro_gpio);
  74 }
  75 EXPORT_SYMBOL(mmc_gpio_get_ro);
  76
  77 int mmc_gpio_get_cd(struct mmc_host *host)
  78 {
  79         struct mmc_gpio *ctx = host->slot.handler_priv;
  80         int cansleep;
  81
  82         if (!ctx || !ctx->cd_gpio)
  83                 return -ENOSYS;
  84
  85         cansleep = gpiod_cansleep(ctx->cd_gpio);
  86         if (ctx->override_cd_active_level) {
  87                 int value = cansleep ?
  88                                 gpiod_get_raw_value_cansleep(ctx->cd_gpio) :
  89                                 gpiod_get_raw_value(ctx->cd_gpio);
  90                 return !value ^ !!(host->caps2 & MMC_CAP2_CD_ACTIVE_HIGH);
  91         }
  92
  93         return cansleep ?
  94                 gpiod_get_value_cansleep(ctx->cd_gpio) :
  95                 gpiod_get_value(ctx->cd_gpio);
  96 }
  97 EXPORT_SYMBOL(mmc_gpio_get_cd);
  98
  99 void mmc_gpiod_request_cd_irq(struct mmc_host *host)
 100 {
 101         struct mmc_gpio *ctx = host->slot.handler_priv;
 102         int irq = -EINVAL;
 103         int ret;
 104
 105         if (host->slot.cd_irq >= 0 || !ctx || !ctx->cd_gpio)
 106                 return;
 107
 108         /*
 109          * Do not use IRQ if the platform prefers to poll, e.g., because that
 110          * IRQ number is already used by another unit and cannot be shared.
 111          */
 112         if (!(host->caps & MMC_CAP_NEEDS_POLL))
 113                 irq = gpiod_to_irq(ctx->cd_gpio);
 114
 115         if (irq >= 0) {
 116                 if (!ctx->cd_gpio_isr)
 117                         ctx->cd_gpio_isr = mmc_gpio_cd_irqt;
 118                 ret = devm_request_threaded_irq(host->parent, irq,
 119                         NULL, ctx->cd_gpio_isr,
 120                         IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
 121                         ctx->cd_label, host);
 122                 if (ret < 0)
 123                         irq = ret;
 124         }
 125
 126         host->slot.cd_irq = irq;
 127
 128         if (irq < 0)
 129                 host->caps |= MMC_CAP_NEEDS_POLL;
 130 }
 131 EXPORT_SYMBOL(mmc_gpiod_request_cd_irq);
 132
 133 int mmc_gpio_set_cd_wake(struct mmc_host *host, bool on)
 134 {
 135         int ret = 0;
 136
 137         if (!(host->caps & MMC_CAP_CD_WAKE) ||
 138             host->slot.cd_irq < 0 ||
 139             on == host->slot.cd_wake_enabled)
 140                 return 0;
 141
 142         if (on) {
 143                 ret = enable_irq_wake(host->slot.cd_irq);
 144                 host->slot.cd_wake_enabled = !ret;
 145         } else {
 146                 disable_irq_wake(host->slot.cd_irq);
 147                 host->slot.cd_wake_enabled = false;
 148         }
 149
 150         return ret;
 151 }
 152 EXPORT_SYMBOL(mmc_gpio_set_cd_wake);
 153
 154 /* Register an alternate interrupt service routine for
 155  * the card-detect GPIO.
 156  */
 157 void mmc_gpio_set_cd_isr(struct mmc_host *host,
 158                          irqreturn_t (*isr)(int irq, void *dev_id))
 159 {
 160         struct mmc_gpio *ctx = host->slot.handler_priv;
 161
 162         WARN_ON(ctx->cd_gpio_isr);
 163         ctx->cd_gpio_isr = isr;
 164 }
 165 EXPORT_SYMBOL(mmc_gpio_set_cd_isr);
 166
 167 /**
 168  * mmc_gpiod_request_cd - request a gpio descriptor for card-detection
 169  * @host: mmc host
 170  * @con_id: function within the GPIO consumer
 171  * @idx: index of the GPIO to obtain in the consumer
 172  * @override_active_level: ignore %GPIO_ACTIVE_LOW flag
 173  * @debounce: debounce time in microseconds
 174  * @gpio_invert: will return whether the GPIO line is inverted or not, set
 175  * to NULL to ignore
 176  *
 177  * Note that this must be called prior to mmc_add_host()
 178  * otherwise the caller must also call mmc_gpiod_request_cd_irq().
 179  *
 180  * Returns zero on success, else an error.
 181  */
 182 int mmc_gpiod_request_cd(struct mmc_host *host, const char *con_id,
 183                          unsigned int idx, bool override_active_level,
 184                          unsigned int debounce, bool *gpio_invert)
 185 {
 186         struct mmc_gpio *ctx = host->slot.handler_priv;
 187         struct gpio_desc *desc;
 188         int ret;
 189
 190         desc = devm_gpiod_get_index(host->parent, con_id, idx, GPIOD_IN);
 191         if (IS_ERR(desc))
 192                 return PTR_ERR(desc);
 193
 194         if (debounce) {
 195                 ret = gpiod_set_debounce(desc, debounce);
 196                 if (ret < 0)
 197                         ctx->cd_debounce_delay_ms = debounce / 1000;
 198         }
 199
 200         if (gpio_invert)
 201                 *gpio_invert = !gpiod_is_active_low(desc);
 202
 203         ctx->override_cd_active_level = override_active_level;
 204         ctx->cd_gpio = desc;
 205
 206         return 0;
 207 }
 208 EXPORT_SYMBOL(mmc_gpiod_request_cd);
 209
 210 bool mmc_can_gpio_cd(struct mmc_host *host)
 211 {
 212         struct mmc_gpio *ctx = host->slot.handler_priv;
 213
 214         return ctx->cd_gpio ? true : false;
 215 }
 216 EXPORT_SYMBOL(mmc_can_gpio_cd);
 217
 218 /**
 219  * mmc_gpiod_request_ro - request a gpio descriptor for write protection
 220  * @host: mmc host
 221  * @con_id: function within the GPIO consumer
 222  * @idx: index of the GPIO to obtain in the consumer
 223  * @debounce: debounce time in microseconds
 224  * @gpio_invert: will return whether the GPIO line is inverted or not,
 225  * set to NULL to ignore
 226  *
 227  * Returns zero on success, else an error.
 228  */
 229 int mmc_gpiod_request_ro(struct mmc_host *host, const char *con_id,
 230                          unsigned int idx,
 231                          unsigned int debounce, bool *gpio_invert)
 232 {
 233         struct mmc_gpio *ctx = host->slot.handler_priv;
 234         struct gpio_desc *desc;
 235         int ret;
 236
 237         desc = devm_gpiod_get_index(host->parent, con_id, idx, GPIOD_IN);
 238         if (IS_ERR(desc))
 239                 return PTR_ERR(desc);
 240
 241         if (debounce) {
 242                 ret = gpiod_set_debounce(desc, debounce);
 243                 if (ret < 0)
 244                         return ret;
 245         }
 246
 247         if (gpio_invert)
 248                 *gpio_invert = !gpiod_is_active_low(desc);
 249
 250         ctx->ro_gpio = desc;
 251
 252         return 0;
 253 }
 254 EXPORT_SYMBOL(mmc_gpiod_request_ro);
 255
 256 bool mmc_can_gpio_ro(struct mmc_host *host)
 257 {
 258         struct mmc_gpio *ctx = host->slot.handler_priv;
 259
 260         return ctx->ro_gpio ? true : false;
 261 }
 262 EXPORT_SYMBOL(mmc_can_gpio_ro);