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