1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * linux/drivers/mmc/core/sdio_irq.c 4 * 5 * Author: Nicolas Pitre 6 * Created: June 18, 2007 7 * Copyright: MontaVista Software Inc. 8 * 9 * Copyright 2008 Pierre Ossman 10 */ 11 12 #include <linux/kernel.h> 13 #include <linux/sched.h> 14 #include <uapi/linux/sched/types.h> 15 #include <linux/kthread.h> 16 #include <linux/export.h> 17 #include <linux/wait.h> 18 #include <linux/delay.h> 19 20 #include <linux/mmc/core.h> 21 #include <linux/mmc/host.h> 22 #include <linux/mmc/card.h> 23 #include <linux/mmc/sdio.h> 24 #include <linux/mmc/sdio_func.h> 25 26 #include "sdio_ops.h" 27 #include "core.h" 28 #include "card.h" 29 30 static int process_sdio_pending_irqs(struct mmc_host *host) 31 { 32 struct mmc_card *card = host->card; 33 int i, ret, count; 34 unsigned char pending; 35 struct sdio_func *func; 36 37 /* Don't process SDIO IRQs if the card is suspended. */ 38 if (mmc_card_suspended(card)) 39 return 0; 40 41 /* 42 * Optimization, if there is only 1 function interrupt registered 43 * and we know an IRQ was signaled then call irq handler directly. 44 * Otherwise do the full probe. 45 */ 46 func = card->sdio_single_irq; 47 if (func && host->sdio_irq_pending) { 48 func->irq_handler(func); 49 return 1; 50 } 51 52 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_INTx, 0, &pending); 53 if (ret) { 54 pr_debug("%s: error %d reading SDIO_CCCR_INTx\n", 55 mmc_card_id(card), ret); 56 return ret; 57 } 58 59 if (pending && mmc_card_broken_irq_polling(card) && 60 !(host->caps & MMC_CAP_SDIO_IRQ)) { 61 unsigned char dummy; 62 63 /* A fake interrupt could be created when we poll SDIO_CCCR_INTx 64 * register with a Marvell SD8797 card. A dummy CMD52 read to 65 * function 0 register 0xff can avoid this. 66 */ 67 mmc_io_rw_direct(card, 0, 0, 0xff, 0, &dummy); 68 } 69 70 count = 0; 71 for (i = 1; i <= 7; i++) { 72 if (pending & (1 << i)) { 73 func = card->sdio_func[i - 1]; 74 if (!func) { 75 pr_warn("%s: pending IRQ for non-existent function\n", 76 mmc_card_id(card)); 77 ret = -EINVAL; 78 } else if (func->irq_handler) { 79 func->irq_handler(func); 80 count++; 81 } else { 82 pr_warn("%s: pending IRQ with no handler\n", 83 sdio_func_id(func)); 84 ret = -EINVAL; 85 } 86 } 87 } 88 89 if (count) 90 return count; 91 92 return ret; 93 } 94 95 static void sdio_run_irqs(struct mmc_host *host) 96 { 97 mmc_claim_host(host); 98 if (host->sdio_irqs) { 99 host->sdio_irq_pending = true; 100 process_sdio_pending_irqs(host); 101 if (host->ops->ack_sdio_irq) 102 host->ops->ack_sdio_irq(host); 103 } 104 mmc_release_host(host); 105 } 106 107 void sdio_irq_work(struct work_struct *work) 108 { 109 struct mmc_host *host = 110 container_of(work, struct mmc_host, sdio_irq_work.work); 111 112 sdio_run_irqs(host); 113 } 114 115 void sdio_signal_irq(struct mmc_host *host) 116 { 117 queue_delayed_work(system_wq, &host->sdio_irq_work, 0); 118 } 119 EXPORT_SYMBOL_GPL(sdio_signal_irq); 120 121 static int sdio_irq_thread(void *_host) 122 { 123 struct mmc_host *host = _host; 124 struct sched_param param = { .sched_priority = 1 }; 125 unsigned long period, idle_period; 126 int ret; 127 128 sched_setscheduler(current, SCHED_FIFO, ¶m); 129 130 /* 131 * We want to allow for SDIO cards to work even on non SDIO 132 * aware hosts. One thing that non SDIO host cannot do is 133 * asynchronous notification of pending SDIO card interrupts 134 * hence we poll for them in that case. 135 */ 136 idle_period = msecs_to_jiffies(10); 137 period = (host->caps & MMC_CAP_SDIO_IRQ) ? 138 MAX_SCHEDULE_TIMEOUT : idle_period; 139 140 pr_debug("%s: IRQ thread started (poll period = %lu jiffies)\n", 141 mmc_hostname(host), period); 142 143 do { 144 /* 145 * We claim the host here on drivers behalf for a couple 146 * reasons: 147 * 148 * 1) it is already needed to retrieve the CCCR_INTx; 149 * 2) we want the driver(s) to clear the IRQ condition ASAP; 150 * 3) we need to control the abort condition locally. 151 * 152 * Just like traditional hard IRQ handlers, we expect SDIO 153 * IRQ handlers to be quick and to the point, so that the 154 * holding of the host lock does not cover too much work 155 * that doesn't require that lock to be held. 156 */ 157 ret = __mmc_claim_host(host, NULL, 158 &host->sdio_irq_thread_abort); 159 if (ret) 160 break; 161 ret = process_sdio_pending_irqs(host); 162 host->sdio_irq_pending = false; 163 mmc_release_host(host); 164 165 /* 166 * Give other threads a chance to run in the presence of 167 * errors. 168 */ 169 if (ret < 0) { 170 set_current_state(TASK_INTERRUPTIBLE); 171 if (!kthread_should_stop()) 172 schedule_timeout(HZ); 173 set_current_state(TASK_RUNNING); 174 } 175 176 /* 177 * Adaptive polling frequency based on the assumption 178 * that an interrupt will be closely followed by more. 179 * This has a substantial benefit for network devices. 180 */ 181 if (!(host->caps & MMC_CAP_SDIO_IRQ)) { 182 if (ret > 0) 183 period /= 2; 184 else { 185 period++; 186 if (period > idle_period) 187 period = idle_period; 188 } 189 } 190 191 set_current_state(TASK_INTERRUPTIBLE); 192 if (host->caps & MMC_CAP_SDIO_IRQ) 193 host->ops->enable_sdio_irq(host, 1); 194 if (!kthread_should_stop()) 195 schedule_timeout(period); 196 set_current_state(TASK_RUNNING); 197 } while (!kthread_should_stop()); 198 199 if (host->caps & MMC_CAP_SDIO_IRQ) 200 host->ops->enable_sdio_irq(host, 0); 201 202 pr_debug("%s: IRQ thread exiting with code %d\n", 203 mmc_hostname(host), ret); 204 205 return ret; 206 } 207 208 static int sdio_card_irq_get(struct mmc_card *card) 209 { 210 struct mmc_host *host = card->host; 211 212 WARN_ON(!host->claimed); 213 214 if (!host->sdio_irqs++) { 215 if (!(host->caps2 & MMC_CAP2_SDIO_IRQ_NOTHREAD)) { 216 atomic_set(&host->sdio_irq_thread_abort, 0); 217 host->sdio_irq_thread = 218 kthread_run(sdio_irq_thread, host, 219 "ksdioirqd/%s", mmc_hostname(host)); 220 if (IS_ERR(host->sdio_irq_thread)) { 221 int err = PTR_ERR(host->sdio_irq_thread); 222 host->sdio_irqs--; 223 return err; 224 } 225 } else if (host->caps & MMC_CAP_SDIO_IRQ) { 226 host->ops->enable_sdio_irq(host, 1); 227 } 228 } 229 230 return 0; 231 } 232 233 static int sdio_card_irq_put(struct mmc_card *card) 234 { 235 struct mmc_host *host = card->host; 236 237 WARN_ON(!host->claimed); 238 239 if (host->sdio_irqs < 1) 240 return -EINVAL; 241 242 if (!--host->sdio_irqs) { 243 if (!(host->caps2 & MMC_CAP2_SDIO_IRQ_NOTHREAD)) { 244 atomic_set(&host->sdio_irq_thread_abort, 1); 245 kthread_stop(host->sdio_irq_thread); 246 } else if (host->caps & MMC_CAP_SDIO_IRQ) { 247 host->ops->enable_sdio_irq(host, 0); 248 } 249 } 250 251 return 0; 252 } 253 254 /* If there is only 1 function registered set sdio_single_irq */ 255 static void sdio_single_irq_set(struct mmc_card *card) 256 { 257 struct sdio_func *func; 258 int i; 259 260 card->sdio_single_irq = NULL; 261 if ((card->host->caps & MMC_CAP_SDIO_IRQ) && 262 card->host->sdio_irqs == 1) 263 for (i = 0; i < card->sdio_funcs; i++) { 264 func = card->sdio_func[i]; 265 if (func && func->irq_handler) { 266 card->sdio_single_irq = func; 267 break; 268 } 269 } 270 } 271 272 /** 273 * sdio_claim_irq - claim the IRQ for a SDIO function 274 * @func: SDIO function 275 * @handler: IRQ handler callback 276 * 277 * Claim and activate the IRQ for the given SDIO function. The provided 278 * handler will be called when that IRQ is asserted. The host is always 279 * claimed already when the handler is called so the handler should not 280 * call sdio_claim_host() or sdio_release_host(). 281 */ 282 int sdio_claim_irq(struct sdio_func *func, sdio_irq_handler_t *handler) 283 { 284 int ret; 285 unsigned char reg; 286 287 if (!func) 288 return -EINVAL; 289 290 pr_debug("SDIO: Enabling IRQ for %s...\n", sdio_func_id(func)); 291 292 if (func->irq_handler) { 293 pr_debug("SDIO: IRQ for %s already in use.\n", sdio_func_id(func)); 294 return -EBUSY; 295 } 296 297 ret = mmc_io_rw_direct(func->card, 0, 0, SDIO_CCCR_IENx, 0, ®); 298 if (ret) 299 return ret; 300 301 reg |= 1 << func->num; 302 303 reg |= 1; /* Master interrupt enable */ 304 305 ret = mmc_io_rw_direct(func->card, 1, 0, SDIO_CCCR_IENx, reg, NULL); 306 if (ret) 307 return ret; 308 309 func->irq_handler = handler; 310 ret = sdio_card_irq_get(func->card); 311 if (ret) 312 func->irq_handler = NULL; 313 sdio_single_irq_set(func->card); 314 315 return ret; 316 } 317 EXPORT_SYMBOL_GPL(sdio_claim_irq); 318 319 /** 320 * sdio_release_irq - release the IRQ for a SDIO function 321 * @func: SDIO function 322 * 323 * Disable and release the IRQ for the given SDIO function. 324 */ 325 int sdio_release_irq(struct sdio_func *func) 326 { 327 int ret; 328 unsigned char reg; 329 330 if (!func) 331 return -EINVAL; 332 333 pr_debug("SDIO: Disabling IRQ for %s...\n", sdio_func_id(func)); 334 335 if (func->irq_handler) { 336 func->irq_handler = NULL; 337 sdio_card_irq_put(func->card); 338 sdio_single_irq_set(func->card); 339 } 340 341 ret = mmc_io_rw_direct(func->card, 0, 0, SDIO_CCCR_IENx, 0, ®); 342 if (ret) 343 return ret; 344 345 reg &= ~(1 << func->num); 346 347 /* Disable master interrupt with the last function interrupt */ 348 if (!(reg & 0xFE)) 349 reg = 0; 350 351 ret = mmc_io_rw_direct(func->card, 1, 0, SDIO_CCCR_IENx, reg, NULL); 352 if (ret) 353 return ret; 354 355 return 0; 356 } 357 EXPORT_SYMBOL_GPL(sdio_release_irq); 358 359