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