Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
sdio_irq.c
Go to the documentation of this file.
1 /*
2  * linux/drivers/mmc/core/sdio_irq.c
3  *
4  * Author: Nicolas Pitre
5  * Created: June 18, 2007
6  * Copyright: MontaVista Software Inc.
7  *
8  * Copyright 2008 Pierre Ossman
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or (at
13  * your option) any later version.
14  */
15 
16 #include <linux/kernel.h>
17 #include <linux/sched.h>
18 #include <linux/kthread.h>
19 #include <linux/export.h>
20 #include <linux/wait.h>
21 #include <linux/delay.h>
22 
23 #include <linux/mmc/core.h>
24 #include <linux/mmc/host.h>
25 #include <linux/mmc/card.h>
26 #include <linux/mmc/sdio.h>
27 #include <linux/mmc/sdio_func.h>
28 
29 #include "sdio_ops.h"
30 
31 static int process_sdio_pending_irqs(struct mmc_host *host)
32 {
33  struct mmc_card *card = host->card;
34  int i, ret, count;
35  unsigned char pending;
36  struct sdio_func *func;
37 
38  /*
39  * Optimization, if there is only 1 function interrupt registered
40  * and we know an IRQ was signaled then call irq handler directly.
41  * Otherwise do the full probe.
42  */
43  func = card->sdio_single_irq;
44  if (func && host->sdio_irq_pending) {
45  func->irq_handler(func);
46  return 1;
47  }
48 
49  ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_INTx, 0, &pending);
50  if (ret) {
51  pr_debug("%s: error %d reading SDIO_CCCR_INTx\n",
52  mmc_card_id(card), ret);
53  return ret;
54  }
55 
56  count = 0;
57  for (i = 1; i <= 7; i++) {
58  if (pending & (1 << i)) {
59  func = card->sdio_func[i - 1];
60  if (!func) {
61  pr_warning("%s: pending IRQ for "
62  "non-existent function\n",
63  mmc_card_id(card));
64  ret = -EINVAL;
65  } else if (func->irq_handler) {
66  func->irq_handler(func);
67  count++;
68  } else {
69  pr_warning("%s: pending IRQ with no handler\n",
70  sdio_func_id(func));
71  ret = -EINVAL;
72  }
73  }
74  }
75 
76  if (count)
77  return count;
78 
79  return ret;
80 }
81 
82 static int sdio_irq_thread(void *_host)
83 {
84  struct mmc_host *host = _host;
85  struct sched_param param = { .sched_priority = 1 };
86  unsigned long period, idle_period;
87  int ret;
88 
90 
91  /*
92  * We want to allow for SDIO cards to work even on non SDIO
93  * aware hosts. One thing that non SDIO host cannot do is
94  * asynchronous notification of pending SDIO card interrupts
95  * hence we poll for them in that case.
96  */
97  idle_period = msecs_to_jiffies(10);
98  period = (host->caps & MMC_CAP_SDIO_IRQ) ?
99  MAX_SCHEDULE_TIMEOUT : idle_period;
100 
101  pr_debug("%s: IRQ thread started (poll period = %lu jiffies)\n",
102  mmc_hostname(host), period);
103 
104  do {
105  /*
106  * We claim the host here on drivers behalf for a couple
107  * reasons:
108  *
109  * 1) it is already needed to retrieve the CCCR_INTx;
110  * 2) we want the driver(s) to clear the IRQ condition ASAP;
111  * 3) we need to control the abort condition locally.
112  *
113  * Just like traditional hard IRQ handlers, we expect SDIO
114  * IRQ handlers to be quick and to the point, so that the
115  * holding of the host lock does not cover too much work
116  * that doesn't require that lock to be held.
117  */
118  ret = __mmc_claim_host(host, &host->sdio_irq_thread_abort);
119  if (ret)
120  break;
121  ret = process_sdio_pending_irqs(host);
122  host->sdio_irq_pending = false;
123  mmc_release_host(host);
124 
125  /*
126  * Give other threads a chance to run in the presence of
127  * errors.
128  */
129  if (ret < 0) {
131  if (!kthread_should_stop())
134  }
135 
136  /*
137  * Adaptive polling frequency based on the assumption
138  * that an interrupt will be closely followed by more.
139  * This has a substantial benefit for network devices.
140  */
141  if (!(host->caps & MMC_CAP_SDIO_IRQ)) {
142  if (ret > 0)
143  period /= 2;
144  else {
145  period++;
146  if (period > idle_period)
147  period = idle_period;
148  }
149  }
150 
152  if (host->caps & MMC_CAP_SDIO_IRQ) {
153  mmc_host_clk_hold(host);
154  host->ops->enable_sdio_irq(host, 1);
155  mmc_host_clk_release(host);
156  }
157  if (!kthread_should_stop())
158  schedule_timeout(period);
160  } while (!kthread_should_stop());
161 
162  if (host->caps & MMC_CAP_SDIO_IRQ) {
163  mmc_host_clk_hold(host);
164  host->ops->enable_sdio_irq(host, 0);
165  mmc_host_clk_release(host);
166  }
167 
168  pr_debug("%s: IRQ thread exiting with code %d\n",
169  mmc_hostname(host), ret);
170 
171  return ret;
172 }
173 
174 static int sdio_card_irq_get(struct mmc_card *card)
175 {
176  struct mmc_host *host = card->host;
177 
178  WARN_ON(!host->claimed);
179 
180  if (!host->sdio_irqs++) {
182  host->sdio_irq_thread =
183  kthread_run(sdio_irq_thread, host, "ksdioirqd/%s",
184  mmc_hostname(host));
185  if (IS_ERR(host->sdio_irq_thread)) {
186  int err = PTR_ERR(host->sdio_irq_thread);
187  host->sdio_irqs--;
188  return err;
189  }
190  }
191 
192  return 0;
193 }
194 
195 static int sdio_card_irq_put(struct mmc_card *card)
196 {
197  struct mmc_host *host = card->host;
198 
199  WARN_ON(!host->claimed);
200  BUG_ON(host->sdio_irqs < 1);
201 
202  if (!--host->sdio_irqs) {
205  }
206 
207  return 0;
208 }
209 
210 /* If there is only 1 function registered set sdio_single_irq */
211 static void sdio_single_irq_set(struct mmc_card *card)
212 {
213  struct sdio_func *func;
214  int i;
215 
216  card->sdio_single_irq = NULL;
217  if ((card->host->caps & MMC_CAP_SDIO_IRQ) &&
218  card->host->sdio_irqs == 1)
219  for (i = 0; i < card->sdio_funcs; i++) {
220  func = card->sdio_func[i];
221  if (func && func->irq_handler) {
222  card->sdio_single_irq = func;
223  break;
224  }
225  }
226 }
227 
238 int sdio_claim_irq(struct sdio_func *func, sdio_irq_handler_t *handler)
239 {
240  int ret;
241  unsigned char reg;
242 
243  BUG_ON(!func);
244  BUG_ON(!func->card);
245 
246  pr_debug("SDIO: Enabling IRQ for %s...\n", sdio_func_id(func));
247 
248  if (func->irq_handler) {
249  pr_debug("SDIO: IRQ for %s already in use.\n", sdio_func_id(func));
250  return -EBUSY;
251  }
252 
253  ret = mmc_io_rw_direct(func->card, 0, 0, SDIO_CCCR_IENx, 0, &reg);
254  if (ret)
255  return ret;
256 
257  reg |= 1 << func->num;
258 
259  reg |= 1; /* Master interrupt enable */
260 
261  ret = mmc_io_rw_direct(func->card, 1, 0, SDIO_CCCR_IENx, reg, NULL);
262  if (ret)
263  return ret;
264 
265  func->irq_handler = handler;
266  ret = sdio_card_irq_get(func->card);
267  if (ret)
268  func->irq_handler = NULL;
269  sdio_single_irq_set(func->card);
270 
271  return ret;
272 }
274 
281 int sdio_release_irq(struct sdio_func *func)
282 {
283  int ret;
284  unsigned char reg;
285 
286  BUG_ON(!func);
287  BUG_ON(!func->card);
288 
289  pr_debug("SDIO: Disabling IRQ for %s...\n", sdio_func_id(func));
290 
291  if (func->irq_handler) {
292  func->irq_handler = NULL;
293  sdio_card_irq_put(func->card);
294  sdio_single_irq_set(func->card);
295  }
296 
297  ret = mmc_io_rw_direct(func->card, 0, 0, SDIO_CCCR_IENx, 0, &reg);
298  if (ret)
299  return ret;
300 
301  reg &= ~(1 << func->num);
302 
303  /* Disable master interrupt with the last function interrupt */
304  if (!(reg & 0xFE))
305  reg = 0;
306 
307  ret = mmc_io_rw_direct(func->card, 1, 0, SDIO_CCCR_IENx, reg, NULL);
308  if (ret)
309  return ret;
310 
311  return 0;
312 }
314