brcm2708: update against latest rpi-3.10.y branch
[openwrt/svn-archive/archive.git] / target / linux / brcm2708 / patches-3.10 / 0026-Add-low-latency-mode-to-sdcard-driver.-Disable-with-.patch
1 From fc153c5cb49f20f5e9644d92b8be064ed9159a16 Mon Sep 17 00:00:00 2001
2 From: popcornmix <popcornmix@gmail.com>
3 Date: Sun, 12 May 2013 12:27:48 +0100
4 Subject: [PATCH 026/174] Add low-latency mode to sdcard driver. Disable with
5 sdhci-bcm2708.enable_llm=0. Thanks ddv2005.
6
7 ---
8 drivers/mmc/host/sdhci-bcm2708.c | 17 ++--
9 drivers/mmc/host/sdhci.c | 165 ++++++++++++++++++++++++++++++---------
10 drivers/mmc/host/sdhci.h | 6 ++
11 include/linux/mmc/sdhci.h | 1 +
12 4 files changed, 145 insertions(+), 44 deletions(-)
13
14 --- a/drivers/mmc/host/sdhci-bcm2708.c
15 +++ b/drivers/mmc/host/sdhci-bcm2708.c
16 @@ -135,6 +135,7 @@ static bool allow_highspeed = 1;
17 static int emmc_clock_freq = BCM2708_EMMC_CLOCK_FREQ;
18 static bool sync_after_dma = 1;
19 static bool missing_status = 1;
20 +bool enable_llm = 1;
21
22 #if 0
23 static void hptime_test(void)
24 @@ -871,12 +872,11 @@ static irqreturn_t sdhci_bcm2708_dma_irq
25 struct sdhci_host *host = dev_id;
26 struct sdhci_bcm2708_priv *host_priv = SDHCI_HOST_PRIV(host);
27 u32 dma_cs; /* control and status register */
28 - unsigned long flags;
29
30 BUG_ON(NULL == dev_id);
31 BUG_ON(NULL == host_priv->dma_chan_base);
32
33 - spin_lock_irqsave(&host->lock, flags);
34 + sdhci_spin_lock(host);
35
36 dma_cs = readl(host_priv->dma_chan_base + BCM2708_DMA_CS);
37
38 @@ -917,8 +917,7 @@ static irqreturn_t sdhci_bcm2708_dma_irq
39
40 result = IRQ_HANDLED;
41 }
42 -
43 - spin_unlock_irqrestore(&host->lock, flags);
44 + sdhci_spin_unlock(host);
45
46 return result;
47 }
48 @@ -1193,9 +1192,12 @@ static int sdhci_bcm2708_probe(struct pl
49 sdhci_bcm2708_ops.missing_status = sdhci_bcm2708_missing_status;
50 }
51
52 + printk("sdhci: %s low-latency mode\n",enable_llm?"Enable":"Disable");
53 +
54 host->hw_name = "BCM2708_Arasan";
55 host->ops = &sdhci_bcm2708_ops;
56 host->irq = platform_get_irq(pdev, 0);
57 + host->second_irq = 0;
58
59 host->quirks = SDHCI_QUIRK_BROKEN_CARD_DETECTION |
60 SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK |
61 @@ -1256,12 +1258,13 @@ static int sdhci_bcm2708_probe(struct pl
62 }
63 host_priv->dma_chan = ret;
64
65 - ret = request_irq(host_priv->dma_irq, sdhci_bcm2708_dma_irq,
66 - IRQF_SHARED, DRIVER_NAME " (dma)", host);
67 + ret = request_irq(host_priv->dma_irq, sdhci_bcm2708_dma_irq,0,//IRQF_SHARED,
68 + DRIVER_NAME " (dma)", host);
69 if (ret) {
70 dev_err(&pdev->dev, "cannot set DMA IRQ\n");
71 goto err_add_dma_irq;
72 }
73 + host->second_irq = host_priv->dma_irq;
74 DBG("DMA CBs %p handle %08X DMA%d %p DMA IRQ %d\n",
75 host_priv->cb_base, (unsigned)host_priv->cb_handle,
76 host_priv->dma_chan, host_priv->dma_chan_base,
77 @@ -1384,6 +1387,7 @@ module_param(allow_highspeed, bool, 0444
78 module_param(emmc_clock_freq, int, 0444);
79 module_param(sync_after_dma, bool, 0444);
80 module_param(missing_status, bool, 0444);
81 +module_param(enable_llm, bool, 0444);
82
83 MODULE_DESCRIPTION("Secure Digital Host Controller Interface platform driver");
84 MODULE_AUTHOR("Broadcom <info@broadcom.com>");
85 @@ -1394,5 +1398,6 @@ MODULE_PARM_DESC(allow_highspeed, "Allow
86 MODULE_PARM_DESC(emmc_clock_freq, "Specify the speed of emmc clock");
87 MODULE_PARM_DESC(sync_after_dma, "Block in driver until dma complete");
88 MODULE_PARM_DESC(missing_status, "Use the missing status quirk");
89 +MODULE_PARM_DESC(enable_llm, "Enable low-latency mode");
90
91
92 --- a/drivers/mmc/host/sdhci.c
93 +++ b/drivers/mmc/host/sdhci.c
94 @@ -124,6 +124,91 @@ static void sdhci_dumpregs(struct sdhci_
95 * Low level functions *
96 * *
97 \*****************************************************************************/
98 +extern bool enable_llm;
99 +static int sdhci_locked=0;
100 +void sdhci_spin_lock(struct sdhci_host *host)
101 +{
102 + spin_lock(&host->lock);
103 +#ifdef CONFIG_PREEMPT
104 + if(enable_llm)
105 + {
106 + disable_irq_nosync(host->irq);
107 + if(host->second_irq)
108 + disable_irq_nosync(host->second_irq);
109 + local_irq_enable();
110 + }
111 +#endif
112 +}
113 +
114 +void sdhci_spin_unlock(struct sdhci_host *host)
115 +{
116 +#ifdef CONFIG_PREEMPT
117 + if(enable_llm)
118 + {
119 + local_irq_disable();
120 + if(host->second_irq)
121 + enable_irq(host->second_irq);
122 + enable_irq(host->irq);
123 + }
124 +#endif
125 + spin_unlock(&host->lock);
126 +}
127 +
128 +void sdhci_spin_lock_irqsave(struct sdhci_host *host,unsigned long *flags)
129 +{
130 +#ifdef CONFIG_PREEMPT
131 + if(enable_llm)
132 + {
133 + while(sdhci_locked)
134 + {
135 + preempt_schedule();
136 + }
137 + spin_lock_irqsave(&host->lock,*flags);
138 + disable_irq(host->irq);
139 + if(host->second_irq)
140 + disable_irq(host->second_irq);
141 + local_irq_enable();
142 + }
143 + else
144 +#endif
145 + spin_lock_irqsave(&host->lock,*flags);
146 +}
147 +
148 +void sdhci_spin_unlock_irqrestore(struct sdhci_host *host,unsigned long flags)
149 +{
150 +#ifdef CONFIG_PREEMPT
151 + if(enable_llm)
152 + {
153 + local_irq_disable();
154 + if(host->second_irq)
155 + enable_irq(host->second_irq);
156 + enable_irq(host->irq);
157 + }
158 +#endif
159 + spin_unlock_irqrestore(&host->lock,flags);
160 +}
161 +
162 +static void sdhci_spin_enable_schedule(struct sdhci_host *host)
163 +{
164 +#ifdef CONFIG_PREEMPT
165 + if(enable_llm)
166 + {
167 + sdhci_locked = 1;
168 + preempt_enable();
169 + }
170 +#endif
171 +}
172 +
173 +static void sdhci_spin_disable_schedule(struct sdhci_host *host)
174 +{
175 +#ifdef CONFIG_PREEMPT
176 + if(enable_llm)
177 + {
178 + preempt_disable();
179 + sdhci_locked = 0;
180 + }
181 +#endif
182 +}
183
184 static void sdhci_clear_set_irqs(struct sdhci_host *host, u32 clear, u32 set)
185 {
186 @@ -289,7 +374,7 @@ static void sdhci_led_control(struct led
187 struct sdhci_host *host = container_of(led, struct sdhci_host, led);
188 unsigned long flags;
189
190 - spin_lock_irqsave(&host->lock, flags);
191 + sdhci_spin_lock_irqsave(host, &flags);
192
193 if (host->runtime_suspended)
194 goto out;
195 @@ -299,7 +384,7 @@ static void sdhci_led_control(struct led
196 else
197 sdhci_activate_led(host);
198 out:
199 - spin_unlock_irqrestore(&host->lock, flags);
200 + sdhci_spin_unlock_irqrestore(host, flags);
201 }
202 #endif
203
204 @@ -1007,7 +1092,9 @@ static void sdhci_send_command(struct sd
205 return;
206 }
207 timeout--;
208 + sdhci_spin_enable_schedule(host);
209 mdelay(1);
210 + sdhci_spin_disable_schedule(host);
211 }
212 DBG("send cmd %d - wait 0x%X irq 0x%x\n", cmd->opcode, mask,
213 sdhci_readl(host, SDHCI_INT_STATUS));
214 @@ -1234,7 +1321,9 @@ clock_set:
215 return;
216 }
217 timeout--;
218 + sdhci_spin_enable_schedule(host);
219 mdelay(1);
220 + sdhci_spin_disable_schedule(host);
221 }
222
223 clk |= SDHCI_CLOCK_CARD_EN;
224 @@ -1330,7 +1419,7 @@ static void sdhci_request(struct mmc_hos
225
226 sdhci_runtime_pm_get(host);
227
228 - spin_lock_irqsave(&host->lock, flags);
229 + sdhci_spin_lock_irqsave(host, &flags);
230
231 WARN_ON(host->mrq != NULL);
232
233 @@ -1388,9 +1477,9 @@ static void sdhci_request(struct mmc_hos
234 mmc->card->type == MMC_TYPE_MMC ?
235 MMC_SEND_TUNING_BLOCK_HS200 :
236 MMC_SEND_TUNING_BLOCK;
237 - spin_unlock_irqrestore(&host->lock, flags);
238 + sdhci_spin_unlock_irqrestore(host, flags);
239 sdhci_execute_tuning(mmc, tuning_opcode);
240 - spin_lock_irqsave(&host->lock, flags);
241 + sdhci_spin_lock_irqsave(host, &flags);
242
243 /* Restore original mmc_request structure */
244 host->mrq = mrq;
245 @@ -1404,7 +1493,7 @@ static void sdhci_request(struct mmc_hos
246 }
247
248 mmiowb();
249 - spin_unlock_irqrestore(&host->lock, flags);
250 + sdhci_spin_unlock_irqrestore(host, flags);
251 }
252
253 static void sdhci_do_set_ios(struct sdhci_host *host, struct mmc_ios *ios)
254 @@ -1413,10 +1502,10 @@ static void sdhci_do_set_ios(struct sdhc
255 int vdd_bit = -1;
256 u8 ctrl;
257
258 - spin_lock_irqsave(&host->lock, flags);
259 + sdhci_spin_lock_irqsave(host, &flags);
260
261 if (host->flags & SDHCI_DEVICE_DEAD) {
262 - spin_unlock_irqrestore(&host->lock, flags);
263 + sdhci_spin_unlock_irqrestore(host, flags);
264 if (host->vmmc && ios->power_mode == MMC_POWER_OFF)
265 mmc_regulator_set_ocr(host->mmc, host->vmmc, 0);
266 return;
267 @@ -1443,9 +1532,9 @@ static void sdhci_do_set_ios(struct sdhc
268 vdd_bit = sdhci_set_power(host, ios->vdd);
269
270 if (host->vmmc && vdd_bit != -1) {
271 - spin_unlock_irqrestore(&host->lock, flags);
272 + sdhci_spin_unlock_irqrestore(host, flags);
273 mmc_regulator_set_ocr(host->mmc, host->vmmc, vdd_bit);
274 - spin_lock_irqsave(&host->lock, flags);
275 + sdhci_spin_lock_irqsave(host, &flags);
276 }
277
278 if (host->ops->platform_send_init_74_clocks)
279 @@ -1583,7 +1672,7 @@ static void sdhci_do_set_ios(struct sdhc
280 sdhci_reset(host, SDHCI_RESET_CMD | SDHCI_RESET_DATA);
281
282 mmiowb();
283 - spin_unlock_irqrestore(&host->lock, flags);
284 + sdhci_spin_unlock_irqrestore(host, flags);
285 }
286
287 static void sdhci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
288 @@ -1631,7 +1720,7 @@ static int sdhci_check_ro(struct sdhci_h
289 unsigned long flags;
290 int is_readonly;
291
292 - spin_lock_irqsave(&host->lock, flags);
293 + sdhci_spin_lock_irqsave(host, &flags);
294
295 if (host->flags & SDHCI_DEVICE_DEAD)
296 is_readonly = 0;
297 @@ -1641,7 +1730,7 @@ static int sdhci_check_ro(struct sdhci_h
298 is_readonly = !(sdhci_readl(host, SDHCI_PRESENT_STATE)
299 & SDHCI_WRITE_PROTECT);
300
301 - spin_unlock_irqrestore(&host->lock, flags);
302 + sdhci_spin_unlock_irqrestore(host, flags);
303
304 /* This quirk needs to be replaced by a callback-function later */
305 return host->quirks & SDHCI_QUIRK_INVERTED_WRITE_PROTECT ?
306 @@ -1714,9 +1803,9 @@ static void sdhci_enable_sdio_irq(struct
307 struct sdhci_host *host = mmc_priv(mmc);
308 unsigned long flags;
309
310 - spin_lock_irqsave(&host->lock, flags);
311 + sdhci_spin_lock_irqsave(host, &flags);
312 sdhci_enable_sdio_irq_nolock(host, enable);
313 - spin_unlock_irqrestore(&host->lock, flags);
314 + sdhci_spin_unlock_irqrestore(host, flags);
315 }
316
317 static int sdhci_do_start_signal_voltage_switch(struct sdhci_host *host,
318 @@ -2060,7 +2149,7 @@ static void sdhci_card_event(struct mmc_
319 struct sdhci_host *host = mmc_priv(mmc);
320 unsigned long flags;
321
322 - spin_lock_irqsave(&host->lock, flags);
323 + sdhci_spin_lock_irqsave(host, &flags);
324
325 /* Check host->mrq first in case we are runtime suspended */
326 if (host->mrq &&
327 @@ -2077,7 +2166,7 @@ static void sdhci_card_event(struct mmc_
328 tasklet_schedule(&host->finish_tasklet);
329 }
330
331 - spin_unlock_irqrestore(&host->lock, flags);
332 + sdhci_spin_unlock_irqrestore(host, flags);
333 }
334
335 static const struct mmc_host_ops sdhci_ops = {
336 @@ -2116,14 +2205,14 @@ static void sdhci_tasklet_finish(unsigne
337
338 host = (struct sdhci_host*)param;
339
340 - spin_lock_irqsave(&host->lock, flags);
341 + sdhci_spin_lock_irqsave(host, &flags);
342
343 /*
344 * If this tasklet gets rescheduled while running, it will
345 * be run again afterwards but without any active request.
346 */
347 if (!host->mrq) {
348 - spin_unlock_irqrestore(&host->lock, flags);
349 + sdhci_spin_unlock_irqrestore(host, flags);
350 return;
351 }
352
353 @@ -2161,7 +2250,7 @@ static void sdhci_tasklet_finish(unsigne
354 #endif
355
356 mmiowb();
357 - spin_unlock_irqrestore(&host->lock, flags);
358 + sdhci_spin_unlock_irqrestore(host, flags);
359
360 mmc_request_done(host->mmc, mrq);
361 sdhci_runtime_pm_put(host);
362 @@ -2174,7 +2263,7 @@ static void sdhci_timeout_timer(unsigned
363
364 host = (struct sdhci_host*)data;
365
366 - spin_lock_irqsave(&host->lock, flags);
367 + sdhci_spin_lock_irqsave(host, &flags);
368
369 if (host->mrq) {
370 pr_err("%s: Timeout waiting for hardware "
371 @@ -2195,7 +2284,7 @@ static void sdhci_timeout_timer(unsigned
372 }
373
374 mmiowb();
375 - spin_unlock_irqrestore(&host->lock, flags);
376 + sdhci_spin_unlock_irqrestore(host, flags);
377 }
378
379 static void sdhci_tuning_timer(unsigned long data)
380 @@ -2205,11 +2294,11 @@ static void sdhci_tuning_timer(unsigned
381
382 host = (struct sdhci_host *)data;
383
384 - spin_lock_irqsave(&host->lock, flags);
385 + sdhci_spin_lock_irqsave(host, &flags);
386
387 host->flags |= SDHCI_NEEDS_RETUNING;
388
389 - spin_unlock_irqrestore(&host->lock, flags);
390 + sdhci_spin_unlock_irqrestore(host, flags);
391 }
392
393 /*****************************************************************************\
394 @@ -2433,10 +2522,10 @@ static irqreturn_t sdhci_irq(int irq, vo
395 u32 intmask, unexpected = 0;
396 int cardint = 0, max_loops = 16;
397
398 - spin_lock(&host->lock);
399 + sdhci_spin_lock(host);
400
401 if (host->runtime_suspended) {
402 - spin_unlock(&host->lock);
403 + sdhci_spin_unlock(host);
404 pr_warning("%s: got irq while runtime suspended\n",
405 mmc_hostname(host->mmc));
406 return IRQ_HANDLED;
407 @@ -2540,7 +2629,7 @@ again:
408 if (intmask && --max_loops)
409 goto again;
410 out:
411 - spin_unlock(&host->lock);
412 + sdhci_spin_unlock(host);
413
414 if (unexpected) {
415 pr_err("%s: Unexpected interrupt 0x%08x.\n",
416 @@ -2702,15 +2791,15 @@ int sdhci_runtime_suspend_host(struct sd
417 host->flags &= ~SDHCI_NEEDS_RETUNING;
418 }
419
420 - spin_lock_irqsave(&host->lock, flags);
421 + sdhci_spin_lock_irqsave(host, &flags);
422 sdhci_mask_irqs(host, SDHCI_INT_ALL_MASK);
423 - spin_unlock_irqrestore(&host->lock, flags);
424 + sdhci_spin_unlock_irqrestore(host, flags);
425
426 synchronize_irq(host->irq);
427
428 - spin_lock_irqsave(&host->lock, flags);
429 + sdhci_spin_lock_irqsave(host, &flags);
430 host->runtime_suspended = true;
431 - spin_unlock_irqrestore(&host->lock, flags);
432 + sdhci_spin_unlock_irqrestore(host, flags);
433
434 return ret;
435 }
436 @@ -2736,16 +2825,16 @@ int sdhci_runtime_resume_host(struct sdh
437 sdhci_do_start_signal_voltage_switch(host, &host->mmc->ios);
438 if ((host_flags & SDHCI_PV_ENABLED) &&
439 !(host->quirks2 & SDHCI_QUIRK2_PRESET_VALUE_BROKEN)) {
440 - spin_lock_irqsave(&host->lock, flags);
441 + sdhci_spin_lock_irqsave(host, &flags);
442 sdhci_enable_preset_value(host, true);
443 - spin_unlock_irqrestore(&host->lock, flags);
444 + sdhci_spin_unlock_irqrestore(host, flags);
445 }
446
447 /* Set the re-tuning expiration flag */
448 if (host->flags & SDHCI_USING_RETUNING_TIMER)
449 host->flags |= SDHCI_NEEDS_RETUNING;
450
451 - spin_lock_irqsave(&host->lock, flags);
452 + sdhci_spin_lock_irqsave(host, &flags);
453
454 host->runtime_suspended = false;
455
456 @@ -2756,7 +2845,7 @@ int sdhci_runtime_resume_host(struct sdh
457 /* Enable Card Detection */
458 sdhci_enable_card_detection(host);
459
460 - spin_unlock_irqrestore(&host->lock, flags);
461 + sdhci_spin_unlock_irqrestore(host, flags);
462
463 return ret;
464 }
465 @@ -3248,7 +3337,7 @@ int sdhci_add_host(struct sdhci_host *ho
466 host->tuning_timer.function = sdhci_tuning_timer;
467 }
468
469 - ret = request_irq(host->irq, sdhci_irq, IRQF_SHARED,
470 + ret = request_irq(host->irq, sdhci_irq, 0,//IRQF_SHARED,
471 mmc_hostname(mmc), host);
472 if (ret) {
473 pr_err("%s: Failed to request IRQ %d: %d\n",
474 @@ -3312,7 +3401,7 @@ void sdhci_remove_host(struct sdhci_host
475 unsigned long flags;
476
477 if (dead) {
478 - spin_lock_irqsave(&host->lock, flags);
479 + sdhci_spin_lock_irqsave(host, &flags);
480
481 host->flags |= SDHCI_DEVICE_DEAD;
482
483 @@ -3324,7 +3413,7 @@ void sdhci_remove_host(struct sdhci_host
484 tasklet_schedule(&host->finish_tasklet);
485 }
486
487 - spin_unlock_irqrestore(&host->lock, flags);
488 + sdhci_spin_unlock_irqrestore(host, flags);
489 }
490
491 sdhci_disable_card_detection(host);
492 --- a/drivers/mmc/host/sdhci.h
493 +++ b/drivers/mmc/host/sdhci.h
494 @@ -441,4 +441,10 @@ extern int sdhci_runtime_suspend_host(st
495 extern int sdhci_runtime_resume_host(struct sdhci_host *host);
496 #endif
497
498 +extern void sdhci_spin_lock_irqsave(struct sdhci_host *host,unsigned long *flags);
499 +extern void sdhci_spin_unlock_irqrestore(struct sdhci_host *host,unsigned long flags);
500 +extern void sdhci_spin_lock(struct sdhci_host *host);
501 +extern void sdhci_spin_unlock(struct sdhci_host *host);
502 +
503 +
504 #endif /* __SDHCI_HW_H */
505 --- a/include/linux/mmc/sdhci.h
506 +++ b/include/linux/mmc/sdhci.h
507 @@ -97,6 +97,7 @@ struct sdhci_host {
508 #define SDHCI_QUIRK2_PRESET_VALUE_BROKEN (1<<3)
509
510 int irq; /* Device IRQ */
511 + int second_irq; /* Additional IRQ to disable/enable in low-latency mode */
512 void __iomem *ioaddr; /* Mapped address */
513
514 const struct sdhci_ops *ops; /* Low level hw interface */