1
2
3
4
5
6
7
8
9
10#include <linux/module.h>
11#include <linux/init.h>
12#include <linux/interrupt.h>
13#include <linux/completion.h>
14#include <linux/device.h>
15#include <linux/delay.h>
16#include <linux/pagemap.h>
17#include <linux/err.h>
18#include <linux/leds.h>
19#include <linux/scatterlist.h>
20#include <linux/log2.h>
21#include <linux/pm_runtime.h>
22#include <linux/pm_wakeup.h>
23#include <linux/suspend.h>
24#include <linux/fault-inject.h>
25#include <linux/random.h>
26#include <linux/slab.h>
27#include <linux/of.h>
28
29#include <linux/mmc/card.h>
30#include <linux/mmc/host.h>
31#include <linux/mmc/mmc.h>
32#include <linux/mmc/sd.h>
33#include <linux/mmc/slot-gpio.h>
34
35#define CREATE_TRACE_POINTS
36#include <trace/events/mmc.h>
37
38#include "core.h"
39#include "card.h"
40#include "bus.h"
41#include "host.h"
42#include "sdio_bus.h"
43#include "pwrseq.h"
44
45#include "mmc_ops.h"
46#include "sd_ops.h"
47#include "sdio_ops.h"
48
49
50#define MMC_ERASE_TIMEOUT_MS (60 * 1000)
51#define SD_DISCARD_TIMEOUT_MS (250)
52
53static const unsigned freqs[] = { 400000, 300000, 200000, 100000 };
54
55
56
57
58
59
60bool use_spi_crc = 1;
61module_param(use_spi_crc, bool, 0);
62
63static int mmc_schedule_delayed_work(struct delayed_work *work,
64 unsigned long delay)
65{
66
67
68
69
70
71
72 return queue_delayed_work(system_freezable_wq, work, delay);
73}
74
75#ifdef CONFIG_FAIL_MMC_REQUEST
76
77
78
79
80
81static void mmc_should_fail_request(struct mmc_host *host,
82 struct mmc_request *mrq)
83{
84 struct mmc_command *cmd = mrq->cmd;
85 struct mmc_data *data = mrq->data;
86 static const int data_errors[] = {
87 -ETIMEDOUT,
88 -EILSEQ,
89 -EIO,
90 };
91
92 if (!data)
93 return;
94
95 if ((cmd && cmd->error) || data->error ||
96 !should_fail(&host->fail_mmc_request, data->blksz * data->blocks))
97 return;
98
99 data->error = data_errors[prandom_u32() % ARRAY_SIZE(data_errors)];
100 data->bytes_xfered = (prandom_u32() % (data->bytes_xfered >> 9)) << 9;
101}
102
103#else
104
105static inline void mmc_should_fail_request(struct mmc_host *host,
106 struct mmc_request *mrq)
107{
108}
109
110#endif
111
112static inline void mmc_complete_cmd(struct mmc_request *mrq)
113{
114 if (mrq->cap_cmd_during_tfr && !completion_done(&mrq->cmd_completion))
115 complete_all(&mrq->cmd_completion);
116}
117
118void mmc_command_done(struct mmc_host *host, struct mmc_request *mrq)
119{
120 if (!mrq->cap_cmd_during_tfr)
121 return;
122
123 mmc_complete_cmd(mrq);
124
125 pr_debug("%s: cmd done, tfr ongoing (CMD%u)\n",
126 mmc_hostname(host), mrq->cmd->opcode);
127}
128EXPORT_SYMBOL(mmc_command_done);
129
130
131
132
133
134
135
136
137
138void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
139{
140 struct mmc_command *cmd = mrq->cmd;
141 int err = cmd->error;
142
143
144 if (cmd->opcode != MMC_SEND_TUNING_BLOCK &&
145 cmd->opcode != MMC_SEND_TUNING_BLOCK_HS200 &&
146 !host->retune_crc_disable &&
147 (err == -EILSEQ || (mrq->sbc && mrq->sbc->error == -EILSEQ) ||
148 (mrq->data && mrq->data->error == -EILSEQ) ||
149 (mrq->stop && mrq->stop->error == -EILSEQ)))
150 mmc_retune_needed(host);
151
152 if (err && cmd->retries && mmc_host_is_spi(host)) {
153 if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
154 cmd->retries = 0;
155 }
156
157 if (host->ongoing_mrq == mrq)
158 host->ongoing_mrq = NULL;
159
160 mmc_complete_cmd(mrq);
161
162 trace_mmc_request_done(host, mrq);
163
164
165
166
167
168
169
170
171
172
173 if (!err || !cmd->retries || mmc_card_removed(host->card)) {
174 mmc_should_fail_request(host, mrq);
175
176 if (!host->ongoing_mrq)
177 led_trigger_event(host->led, LED_OFF);
178
179 if (mrq->sbc) {
180 pr_debug("%s: req done <CMD%u>: %d: %08x %08x %08x %08x\n",
181 mmc_hostname(host), mrq->sbc->opcode,
182 mrq->sbc->error,
183 mrq->sbc->resp[0], mrq->sbc->resp[1],
184 mrq->sbc->resp[2], mrq->sbc->resp[3]);
185 }
186
187 pr_debug("%s: req done (CMD%u): %d: %08x %08x %08x %08x\n",
188 mmc_hostname(host), cmd->opcode, err,
189 cmd->resp[0], cmd->resp[1],
190 cmd->resp[2], cmd->resp[3]);
191
192 if (mrq->data) {
193 pr_debug("%s: %d bytes transferred: %d\n",
194 mmc_hostname(host),
195 mrq->data->bytes_xfered, mrq->data->error);
196 }
197
198 if (mrq->stop) {
199 pr_debug("%s: (CMD%u): %d: %08x %08x %08x %08x\n",
200 mmc_hostname(host), mrq->stop->opcode,
201 mrq->stop->error,
202 mrq->stop->resp[0], mrq->stop->resp[1],
203 mrq->stop->resp[2], mrq->stop->resp[3]);
204 }
205 }
206
207
208
209
210 if (mrq->done)
211 mrq->done(mrq);
212}
213
214EXPORT_SYMBOL(mmc_request_done);
215
216static void __mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
217{
218 int err;
219
220
221 err = mmc_retune(host);
222 if (err) {
223 mrq->cmd->error = err;
224 mmc_request_done(host, mrq);
225 return;
226 }
227
228
229
230
231
232
233 if (sdio_is_io_busy(mrq->cmd->opcode, mrq->cmd->arg) &&
234 host->ops->card_busy) {
235 int tries = 500;
236
237 while (host->ops->card_busy(host) && --tries)
238 mmc_delay(1);
239
240 if (tries == 0) {
241 mrq->cmd->error = -EBUSY;
242 mmc_request_done(host, mrq);
243 return;
244 }
245 }
246
247 if (mrq->cap_cmd_during_tfr) {
248 host->ongoing_mrq = mrq;
249
250
251
252
253 reinit_completion(&mrq->cmd_completion);
254 }
255
256 trace_mmc_request_start(host, mrq);
257
258 if (host->cqe_on)
259 host->cqe_ops->cqe_off(host);
260
261 host->ops->request(host, mrq);
262}
263
264static void mmc_mrq_pr_debug(struct mmc_host *host, struct mmc_request *mrq,
265 bool cqe)
266{
267 if (mrq->sbc) {
268 pr_debug("<%s: starting CMD%u arg %08x flags %08x>\n",
269 mmc_hostname(host), mrq->sbc->opcode,
270 mrq->sbc->arg, mrq->sbc->flags);
271 }
272
273 if (mrq->cmd) {
274 pr_debug("%s: starting %sCMD%u arg %08x flags %08x\n",
275 mmc_hostname(host), cqe ? "CQE direct " : "",
276 mrq->cmd->opcode, mrq->cmd->arg, mrq->cmd->flags);
277 } else if (cqe) {
278 pr_debug("%s: starting CQE transfer for tag %d blkaddr %u\n",
279 mmc_hostname(host), mrq->tag, mrq->data->blk_addr);
280 }
281
282 if (mrq->data) {
283 pr_debug("%s: blksz %d blocks %d flags %08x "
284 "tsac %d ms nsac %d\n",
285 mmc_hostname(host), mrq->data->blksz,
286 mrq->data->blocks, mrq->data->flags,
287 mrq->data->timeout_ns / 1000000,
288 mrq->data->timeout_clks);
289 }
290
291 if (mrq->stop) {
292 pr_debug("%s: CMD%u arg %08x flags %08x\n",
293 mmc_hostname(host), mrq->stop->opcode,
294 mrq->stop->arg, mrq->stop->flags);
295 }
296}
297
298static int mmc_mrq_prep(struct mmc_host *host, struct mmc_request *mrq)
299{
300 unsigned int i, sz = 0;
301 struct scatterlist *sg;
302
303 if (mrq->cmd) {
304 mrq->cmd->error = 0;
305 mrq->cmd->mrq = mrq;
306 mrq->cmd->data = mrq->data;
307 }
308 if (mrq->sbc) {
309 mrq->sbc->error = 0;
310 mrq->sbc->mrq = mrq;
311 }
312 if (mrq->data) {
313 if (mrq->data->blksz > host->max_blk_size ||
314 mrq->data->blocks > host->max_blk_count ||
315 mrq->data->blocks * mrq->data->blksz > host->max_req_size)
316 return -EINVAL;
317
318 for_each_sg(mrq->data->sg, sg, mrq->data->sg_len, i)
319 sz += sg->length;
320 if (sz != mrq->data->blocks * mrq->data->blksz)
321 return -EINVAL;
322
323 mrq->data->error = 0;
324 mrq->data->mrq = mrq;
325 if (mrq->stop) {
326 mrq->data->stop = mrq->stop;
327 mrq->stop->error = 0;
328 mrq->stop->mrq = mrq;
329 }
330 }
331
332 return 0;
333}
334
335int mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
336{
337 int err;
338
339 init_completion(&mrq->cmd_completion);
340
341 mmc_retune_hold(host);
342
343 if (mmc_card_removed(host->card))
344 return -ENOMEDIUM;
345
346 mmc_mrq_pr_debug(host, mrq, false);
347
348 WARN_ON(!host->claimed);
349
350 err = mmc_mrq_prep(host, mrq);
351 if (err)
352 return err;
353
354 led_trigger_event(host->led, LED_FULL);
355 __mmc_start_request(host, mrq);
356
357 return 0;
358}
359EXPORT_SYMBOL(mmc_start_request);
360
361static void mmc_wait_done(struct mmc_request *mrq)
362{
363 complete(&mrq->completion);
364}
365
366static inline void mmc_wait_ongoing_tfr_cmd(struct mmc_host *host)
367{
368 struct mmc_request *ongoing_mrq = READ_ONCE(host->ongoing_mrq);
369
370
371
372
373
374 if (ongoing_mrq && !completion_done(&ongoing_mrq->cmd_completion))
375 wait_for_completion(&ongoing_mrq->cmd_completion);
376}
377
378static int __mmc_start_req(struct mmc_host *host, struct mmc_request *mrq)
379{
380 int err;
381
382 mmc_wait_ongoing_tfr_cmd(host);
383
384 init_completion(&mrq->completion);
385 mrq->done = mmc_wait_done;
386
387 err = mmc_start_request(host, mrq);
388 if (err) {
389 mrq->cmd->error = err;
390 mmc_complete_cmd(mrq);
391 complete(&mrq->completion);
392 }
393
394 return err;
395}
396
397void mmc_wait_for_req_done(struct mmc_host *host, struct mmc_request *mrq)
398{
399 struct mmc_command *cmd;
400
401 while (1) {
402 wait_for_completion(&mrq->completion);
403
404 cmd = mrq->cmd;
405
406 if (!cmd->error || !cmd->retries ||
407 mmc_card_removed(host->card))
408 break;
409
410 mmc_retune_recheck(host);
411
412 pr_debug("%s: req failed (CMD%u): %d, retrying...\n",
413 mmc_hostname(host), cmd->opcode, cmd->error);
414 cmd->retries--;
415 cmd->error = 0;
416 __mmc_start_request(host, mrq);
417 }
418
419 mmc_retune_release(host);
420}
421EXPORT_SYMBOL(mmc_wait_for_req_done);
422
423
424
425
426
427
428
429
430
431int mmc_cqe_start_req(struct mmc_host *host, struct mmc_request *mrq)
432{
433 int err;
434
435
436
437
438
439
440
441 err = mmc_retune(host);
442 if (err)
443 goto out_err;
444
445 mrq->host = host;
446
447 mmc_mrq_pr_debug(host, mrq, true);
448
449 err = mmc_mrq_prep(host, mrq);
450 if (err)
451 goto out_err;
452
453 err = host->cqe_ops->cqe_request(host, mrq);
454 if (err)
455 goto out_err;
456
457 trace_mmc_request_start(host, mrq);
458
459 return 0;
460
461out_err:
462 if (mrq->cmd) {
463 pr_debug("%s: failed to start CQE direct CMD%u, error %d\n",
464 mmc_hostname(host), mrq->cmd->opcode, err);
465 } else {
466 pr_debug("%s: failed to start CQE transfer for tag %d, error %d\n",
467 mmc_hostname(host), mrq->tag, err);
468 }
469 return err;
470}
471EXPORT_SYMBOL(mmc_cqe_start_req);
472
473
474
475
476
477
478
479
480
481void mmc_cqe_request_done(struct mmc_host *host, struct mmc_request *mrq)
482{
483 mmc_should_fail_request(host, mrq);
484
485
486 if ((mrq->cmd && mrq->cmd->error == -EILSEQ) ||
487 (mrq->data && mrq->data->error == -EILSEQ))
488 mmc_retune_needed(host);
489
490 trace_mmc_request_done(host, mrq);
491
492 if (mrq->cmd) {
493 pr_debug("%s: CQE req done (direct CMD%u): %d\n",
494 mmc_hostname(host), mrq->cmd->opcode, mrq->cmd->error);
495 } else {
496 pr_debug("%s: CQE transfer done tag %d\n",
497 mmc_hostname(host), mrq->tag);
498 }
499
500 if (mrq->data) {
501 pr_debug("%s: %d bytes transferred: %d\n",
502 mmc_hostname(host),
503 mrq->data->bytes_xfered, mrq->data->error);
504 }
505
506 mrq->done(mrq);
507}
508EXPORT_SYMBOL(mmc_cqe_request_done);
509
510
511
512
513
514
515void mmc_cqe_post_req(struct mmc_host *host, struct mmc_request *mrq)
516{
517 if (host->cqe_ops->cqe_post_req)
518 host->cqe_ops->cqe_post_req(host, mrq);
519}
520EXPORT_SYMBOL(mmc_cqe_post_req);
521
522
523#define MMC_CQE_RECOVERY_TIMEOUT 1000
524
525
526
527
528
529
530
531
532
533
534int mmc_cqe_recovery(struct mmc_host *host)
535{
536 struct mmc_command cmd;
537 int err;
538
539 mmc_retune_hold_now(host);
540
541
542
543
544
545 pr_warn("%s: running CQE recovery\n", mmc_hostname(host));
546
547 host->cqe_ops->cqe_recovery_start(host);
548
549 memset(&cmd, 0, sizeof(cmd));
550 cmd.opcode = MMC_STOP_TRANSMISSION,
551 cmd.flags = MMC_RSP_R1B | MMC_CMD_AC,
552 cmd.flags &= ~MMC_RSP_CRC;
553 cmd.busy_timeout = MMC_CQE_RECOVERY_TIMEOUT,
554 mmc_wait_for_cmd(host, &cmd, 0);
555
556 memset(&cmd, 0, sizeof(cmd));
557 cmd.opcode = MMC_CMDQ_TASK_MGMT;
558 cmd.arg = 1;
559 cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;
560 cmd.flags &= ~MMC_RSP_CRC;
561 cmd.busy_timeout = MMC_CQE_RECOVERY_TIMEOUT,
562 err = mmc_wait_for_cmd(host, &cmd, 0);
563
564 host->cqe_ops->cqe_recovery_finish(host);
565
566 mmc_retune_release(host);
567
568 return err;
569}
570EXPORT_SYMBOL(mmc_cqe_recovery);
571
572
573
574
575
576
577
578
579
580
581
582
583
584bool mmc_is_req_done(struct mmc_host *host, struct mmc_request *mrq)
585{
586 return completion_done(&mrq->completion);
587}
588EXPORT_SYMBOL(mmc_is_req_done);
589
590
591
592
593
594
595
596
597
598
599
600
601
602void mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq)
603{
604 __mmc_start_req(host, mrq);
605
606 if (!mrq->cap_cmd_during_tfr)
607 mmc_wait_for_req_done(host, mrq);
608}
609EXPORT_SYMBOL(mmc_wait_for_req);
610
611
612
613
614
615
616
617
618
619
620
621int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries)
622{
623 struct mmc_request mrq = {};
624
625 WARN_ON(!host->claimed);
626
627 memset(cmd->resp, 0, sizeof(cmd->resp));
628 cmd->retries = retries;
629
630 mrq.cmd = cmd;
631 cmd->data = NULL;
632
633 mmc_wait_for_req(host, &mrq);
634
635 return cmd->error;
636}
637
638EXPORT_SYMBOL(mmc_wait_for_cmd);
639
640
641
642
643
644
645
646
647
648void mmc_set_data_timeout(struct mmc_data *data, const struct mmc_card *card)
649{
650 unsigned int mult;
651
652
653
654
655 if (mmc_card_sdio(card)) {
656 data->timeout_ns = 1000000000;
657 data->timeout_clks = 0;
658 return;
659 }
660
661
662
663
664 mult = mmc_card_sd(card) ? 100 : 10;
665
666
667
668
669
670 if (data->flags & MMC_DATA_WRITE)
671 mult <<= card->csd.r2w_factor;
672
673 data->timeout_ns = card->csd.taac_ns * mult;
674 data->timeout_clks = card->csd.taac_clks * mult;
675
676
677
678
679 if (mmc_card_sd(card)) {
680 unsigned int timeout_us, limit_us;
681
682 timeout_us = data->timeout_ns / 1000;
683 if (card->host->ios.clock)
684 timeout_us += data->timeout_clks * 1000 /
685 (card->host->ios.clock / 1000);
686
687 if (data->flags & MMC_DATA_WRITE)
688
689
690
691
692
693
694
695
696 limit_us = 3000000;
697 else
698 limit_us = 100000;
699
700
701
702
703 if (timeout_us > limit_us) {
704 data->timeout_ns = limit_us * 1000;
705 data->timeout_clks = 0;
706 }
707
708
709 if (timeout_us == 0)
710 data->timeout_ns = limit_us * 1000;
711 }
712
713
714
715
716
717
718
719 if (mmc_card_long_read_time(card) && data->flags & MMC_DATA_READ) {
720 data->timeout_ns = 600000000;
721 data->timeout_clks = 0;
722 }
723
724
725
726
727
728
729
730 if (mmc_host_is_spi(card->host)) {
731 if (data->flags & MMC_DATA_WRITE) {
732 if (data->timeout_ns < 1000000000)
733 data->timeout_ns = 1000000000;
734 } else {
735 if (data->timeout_ns < 100000000)
736 data->timeout_ns = 100000000;
737 }
738 }
739}
740EXPORT_SYMBOL(mmc_set_data_timeout);
741
742
743
744
745
746static inline bool mmc_ctx_matches(struct mmc_host *host, struct mmc_ctx *ctx,
747 struct task_struct *task)
748{
749 return host->claimer == ctx ||
750 (!ctx && task && host->claimer->task == task);
751}
752
753static inline void mmc_ctx_set_claimer(struct mmc_host *host,
754 struct mmc_ctx *ctx,
755 struct task_struct *task)
756{
757 if (!host->claimer) {
758 if (ctx)
759 host->claimer = ctx;
760 else
761 host->claimer = &host->default_ctx;
762 }
763 if (task)
764 host->claimer->task = task;
765}
766
767
768
769
770
771
772
773
774
775
776
777
778
779int __mmc_claim_host(struct mmc_host *host, struct mmc_ctx *ctx,
780 atomic_t *abort)
781{
782 struct task_struct *task = ctx ? NULL : current;
783 DECLARE_WAITQUEUE(wait, current);
784 unsigned long flags;
785 int stop;
786 bool pm = false;
787
788 might_sleep();
789
790 add_wait_queue(&host->wq, &wait);
791 spin_lock_irqsave(&host->lock, flags);
792 while (1) {
793 set_current_state(TASK_UNINTERRUPTIBLE);
794 stop = abort ? atomic_read(abort) : 0;
795 if (stop || !host->claimed || mmc_ctx_matches(host, ctx, task))
796 break;
797 spin_unlock_irqrestore(&host->lock, flags);
798 schedule();
799 spin_lock_irqsave(&host->lock, flags);
800 }
801 set_current_state(TASK_RUNNING);
802 if (!stop) {
803 host->claimed = 1;
804 mmc_ctx_set_claimer(host, ctx, task);
805 host->claim_cnt += 1;
806 if (host->claim_cnt == 1)
807 pm = true;
808 } else
809 wake_up(&host->wq);
810 spin_unlock_irqrestore(&host->lock, flags);
811 remove_wait_queue(&host->wq, &wait);
812
813 if (pm)
814 pm_runtime_get_sync(mmc_dev(host));
815
816 return stop;
817}
818EXPORT_SYMBOL(__mmc_claim_host);
819
820
821
822
823
824
825
826
827void mmc_release_host(struct mmc_host *host)
828{
829 unsigned long flags;
830
831 WARN_ON(!host->claimed);
832
833 spin_lock_irqsave(&host->lock, flags);
834 if (--host->claim_cnt) {
835
836 spin_unlock_irqrestore(&host->lock, flags);
837 } else {
838 host->claimed = 0;
839 host->claimer->task = NULL;
840 host->claimer = NULL;
841 spin_unlock_irqrestore(&host->lock, flags);
842 wake_up(&host->wq);
843 pm_runtime_mark_last_busy(mmc_dev(host));
844 if (host->caps & MMC_CAP_SYNC_RUNTIME_PM)
845 pm_runtime_put_sync_suspend(mmc_dev(host));
846 else
847 pm_runtime_put_autosuspend(mmc_dev(host));
848 }
849}
850EXPORT_SYMBOL(mmc_release_host);
851
852
853
854
855
856void mmc_get_card(struct mmc_card *card, struct mmc_ctx *ctx)
857{
858 pm_runtime_get_sync(&card->dev);
859 __mmc_claim_host(card->host, ctx, NULL);
860}
861EXPORT_SYMBOL(mmc_get_card);
862
863
864
865
866
867void mmc_put_card(struct mmc_card *card, struct mmc_ctx *ctx)
868{
869 struct mmc_host *host = card->host;
870
871 WARN_ON(ctx && host->claimer != ctx);
872
873 mmc_release_host(host);
874 pm_runtime_mark_last_busy(&card->dev);
875 pm_runtime_put_autosuspend(&card->dev);
876}
877EXPORT_SYMBOL(mmc_put_card);
878
879
880
881
882
883static inline void mmc_set_ios(struct mmc_host *host)
884{
885 struct mmc_ios *ios = &host->ios;
886
887 pr_debug("%s: clock %uHz busmode %u powermode %u cs %u Vdd %u "
888 "width %u timing %u\n",
889 mmc_hostname(host), ios->clock, ios->bus_mode,
890 ios->power_mode, ios->chip_select, ios->vdd,
891 1 << ios->bus_width, ios->timing);
892
893 host->ops->set_ios(host, ios);
894}
895
896
897
898
899void mmc_set_chip_select(struct mmc_host *host, int mode)
900{
901 host->ios.chip_select = mode;
902 mmc_set_ios(host);
903}
904
905
906
907
908
909void mmc_set_clock(struct mmc_host *host, unsigned int hz)
910{
911 WARN_ON(hz && hz < host->f_min);
912
913 if (hz > host->f_max)
914 hz = host->f_max;
915
916 host->ios.clock = hz;
917 mmc_set_ios(host);
918}
919
920int mmc_execute_tuning(struct mmc_card *card)
921{
922 struct mmc_host *host = card->host;
923 u32 opcode;
924 int err;
925
926 if (!host->ops->execute_tuning)
927 return 0;
928
929 if (host->cqe_on)
930 host->cqe_ops->cqe_off(host);
931
932 if (mmc_card_mmc(card))
933 opcode = MMC_SEND_TUNING_BLOCK_HS200;
934 else
935 opcode = MMC_SEND_TUNING_BLOCK;
936
937 err = host->ops->execute_tuning(host, opcode);
938
939 if (err)
940 pr_err("%s: tuning execution failed: %d\n",
941 mmc_hostname(host), err);
942 else
943 mmc_retune_enable(host);
944
945 return err;
946}
947
948
949
950
951void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
952{
953 host->ios.bus_mode = mode;
954 mmc_set_ios(host);
955}
956
957
958
959
960void mmc_set_bus_width(struct mmc_host *host, unsigned int width)
961{
962 host->ios.bus_width = width;
963 mmc_set_ios(host);
964}
965
966
967
968
969void mmc_set_initial_state(struct mmc_host *host)
970{
971 if (host->cqe_on)
972 host->cqe_ops->cqe_off(host);
973
974 mmc_retune_disable(host);
975
976 if (mmc_host_is_spi(host))
977 host->ios.chip_select = MMC_CS_HIGH;
978 else
979 host->ios.chip_select = MMC_CS_DONTCARE;
980 host->ios.bus_mode = MMC_BUSMODE_PUSHPULL;
981 host->ios.bus_width = MMC_BUS_WIDTH_1;
982 host->ios.timing = MMC_TIMING_LEGACY;
983 host->ios.drv_type = 0;
984 host->ios.enhanced_strobe = false;
985
986
987
988
989
990 if ((host->caps2 & MMC_CAP2_HS400_ES) &&
991 host->ops->hs400_enhanced_strobe)
992 host->ops->hs400_enhanced_strobe(host, &host->ios);
993
994 mmc_set_ios(host);
995}
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012static int mmc_vdd_to_ocrbitnum(int vdd, bool low_bits)
1013{
1014 const int max_bit = ilog2(MMC_VDD_35_36);
1015 int bit;
1016
1017 if (vdd < 1650 || vdd > 3600)
1018 return -EINVAL;
1019
1020 if (vdd >= 1650 && vdd <= 1950)
1021 return ilog2(MMC_VDD_165_195);
1022
1023 if (low_bits)
1024 vdd -= 1;
1025
1026
1027 bit = (vdd - 2000) / 100 + 8;
1028 if (bit > max_bit)
1029 return max_bit;
1030 return bit;
1031}
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046u32 mmc_vddrange_to_ocrmask(int vdd_min, int vdd_max)
1047{
1048 u32 mask = 0;
1049
1050 if (vdd_max < vdd_min)
1051 return 0;
1052
1053
1054 vdd_max = mmc_vdd_to_ocrbitnum(vdd_max, false);
1055 if (vdd_max < 0)
1056 return 0;
1057
1058
1059 vdd_min = mmc_vdd_to_ocrbitnum(vdd_min, true);
1060 if (vdd_min < 0)
1061 return 0;
1062
1063
1064 while (vdd_max >= vdd_min)
1065 mask |= 1 << vdd_max--;
1066
1067 return mask;
1068}
1069
1070static int mmc_of_get_func_num(struct device_node *node)
1071{
1072 u32 reg;
1073 int ret;
1074
1075 ret = of_property_read_u32(node, "reg", ®);
1076 if (ret < 0)
1077 return ret;
1078
1079 return reg;
1080}
1081
1082struct device_node *mmc_of_find_child_device(struct mmc_host *host,
1083 unsigned func_num)
1084{
1085 struct device_node *node;
1086
1087 if (!host->parent || !host->parent->of_node)
1088 return NULL;
1089
1090 for_each_child_of_node(host->parent->of_node, node) {
1091 if (mmc_of_get_func_num(node) == func_num)
1092 return node;
1093 }
1094
1095 return NULL;
1096}
1097
1098
1099
1100
1101
1102u32 mmc_select_voltage(struct mmc_host *host, u32 ocr)
1103{
1104 int bit;
1105
1106
1107
1108
1109
1110 if (ocr & 0x7F) {
1111 dev_warn(mmc_dev(host),
1112 "card claims to support voltages below defined range\n");
1113 ocr &= ~0x7F;
1114 }
1115
1116 ocr &= host->ocr_avail;
1117 if (!ocr) {
1118 dev_warn(mmc_dev(host), "no support for card's volts\n");
1119 return 0;
1120 }
1121
1122 if (host->caps2 & MMC_CAP2_FULL_PWR_CYCLE) {
1123 bit = ffs(ocr) - 1;
1124 ocr &= 3 << bit;
1125 mmc_power_cycle(host, ocr);
1126 } else {
1127 bit = fls(ocr) - 1;
1128 ocr &= 3 << bit;
1129 if (bit != host->ios.vdd)
1130 dev_warn(mmc_dev(host), "exceeding card's volts\n");
1131 }
1132
1133 return ocr;
1134}
1135
1136int mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage)
1137{
1138 int err = 0;
1139 int old_signal_voltage = host->ios.signal_voltage;
1140
1141 host->ios.signal_voltage = signal_voltage;
1142 if (host->ops->start_signal_voltage_switch)
1143 err = host->ops->start_signal_voltage_switch(host, &host->ios);
1144
1145 if (err)
1146 host->ios.signal_voltage = old_signal_voltage;
1147
1148 return err;
1149
1150}
1151
1152void mmc_set_initial_signal_voltage(struct mmc_host *host)
1153{
1154
1155 if (!mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330))
1156 dev_dbg(mmc_dev(host), "Initial signal voltage of 3.3v\n");
1157 else if (!mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180))
1158 dev_dbg(mmc_dev(host), "Initial signal voltage of 1.8v\n");
1159 else if (!mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120))
1160 dev_dbg(mmc_dev(host), "Initial signal voltage of 1.2v\n");
1161}
1162
1163int mmc_host_set_uhs_voltage(struct mmc_host *host)
1164{
1165 u32 clock;
1166
1167
1168
1169
1170
1171 clock = host->ios.clock;
1172 host->ios.clock = 0;
1173 mmc_set_ios(host);
1174
1175 if (mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180))
1176 return -EAGAIN;
1177
1178
1179 mmc_delay(10);
1180 host->ios.clock = clock;
1181 mmc_set_ios(host);
1182
1183 return 0;
1184}
1185
1186int mmc_set_uhs_voltage(struct mmc_host *host, u32 ocr)
1187{
1188 struct mmc_command cmd = {};
1189 int err = 0;
1190
1191
1192
1193
1194
1195 if (!host->ops->start_signal_voltage_switch)
1196 return -EPERM;
1197 if (!host->ops->card_busy)
1198 pr_warn("%s: cannot verify signal voltage switch\n",
1199 mmc_hostname(host));
1200
1201 cmd.opcode = SD_SWITCH_VOLTAGE;
1202 cmd.arg = 0;
1203 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
1204
1205 err = mmc_wait_for_cmd(host, &cmd, 0);
1206 if (err)
1207 return err;
1208
1209 if (!mmc_host_is_spi(host) && (cmd.resp[0] & R1_ERROR))
1210 return -EIO;
1211
1212
1213
1214
1215
1216 mmc_delay(1);
1217 if (host->ops->card_busy && !host->ops->card_busy(host)) {
1218 err = -EAGAIN;
1219 goto power_cycle;
1220 }
1221
1222 if (mmc_host_set_uhs_voltage(host)) {
1223
1224
1225
1226
1227 err = -EAGAIN;
1228 goto power_cycle;
1229 }
1230
1231
1232 mmc_delay(1);
1233
1234
1235
1236
1237
1238 if (host->ops->card_busy && host->ops->card_busy(host))
1239 err = -EAGAIN;
1240
1241power_cycle:
1242 if (err) {
1243 pr_debug("%s: Signal voltage switch failed, "
1244 "power cycling card\n", mmc_hostname(host));
1245 mmc_power_cycle(host, ocr);
1246 }
1247
1248 return err;
1249}
1250
1251
1252
1253
1254void mmc_set_timing(struct mmc_host *host, unsigned int timing)
1255{
1256 host->ios.timing = timing;
1257 mmc_set_ios(host);
1258}
1259
1260
1261
1262
1263void mmc_set_driver_type(struct mmc_host *host, unsigned int drv_type)
1264{
1265 host->ios.drv_type = drv_type;
1266 mmc_set_ios(host);
1267}
1268
1269int mmc_select_drive_strength(struct mmc_card *card, unsigned int max_dtr,
1270 int card_drv_type, int *drv_type)
1271{
1272 struct mmc_host *host = card->host;
1273 int host_drv_type = SD_DRIVER_TYPE_B;
1274
1275 *drv_type = 0;
1276
1277 if (!host->ops->select_drive_strength)
1278 return 0;
1279
1280
1281 if (host->caps & MMC_CAP_DRIVER_TYPE_A)
1282 host_drv_type |= SD_DRIVER_TYPE_A;
1283
1284 if (host->caps & MMC_CAP_DRIVER_TYPE_C)
1285 host_drv_type |= SD_DRIVER_TYPE_C;
1286
1287 if (host->caps & MMC_CAP_DRIVER_TYPE_D)
1288 host_drv_type |= SD_DRIVER_TYPE_D;
1289
1290
1291
1292
1293
1294
1295
1296 return host->ops->select_drive_strength(card, max_dtr,
1297 host_drv_type,
1298 card_drv_type,
1299 drv_type);
1300}
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313void mmc_power_up(struct mmc_host *host, u32 ocr)
1314{
1315 if (host->ios.power_mode == MMC_POWER_ON)
1316 return;
1317
1318 mmc_pwrseq_pre_power_on(host);
1319
1320 host->ios.vdd = fls(ocr) - 1;
1321 host->ios.power_mode = MMC_POWER_UP;
1322
1323 mmc_set_initial_state(host);
1324
1325 mmc_set_initial_signal_voltage(host);
1326
1327
1328
1329
1330
1331 mmc_delay(host->ios.power_delay_ms);
1332
1333 mmc_pwrseq_post_power_on(host);
1334
1335 host->ios.clock = host->f_init;
1336
1337 host->ios.power_mode = MMC_POWER_ON;
1338 mmc_set_ios(host);
1339
1340
1341
1342
1343
1344 mmc_delay(host->ios.power_delay_ms);
1345}
1346
1347void mmc_power_off(struct mmc_host *host)
1348{
1349 if (host->ios.power_mode == MMC_POWER_OFF)
1350 return;
1351
1352 mmc_pwrseq_power_off(host);
1353
1354 host->ios.clock = 0;
1355 host->ios.vdd = 0;
1356
1357 host->ios.power_mode = MMC_POWER_OFF;
1358
1359 mmc_set_initial_state(host);
1360
1361
1362
1363
1364
1365
1366 mmc_delay(1);
1367}
1368
1369void mmc_power_cycle(struct mmc_host *host, u32 ocr)
1370{
1371 mmc_power_off(host);
1372
1373 mmc_delay(1);
1374 mmc_power_up(host, ocr);
1375}
1376
1377
1378
1379
1380static void __mmc_release_bus(struct mmc_host *host)
1381{
1382 WARN_ON(!host->bus_dead);
1383
1384 host->bus_ops = NULL;
1385}
1386
1387
1388
1389
1390static inline void mmc_bus_get(struct mmc_host *host)
1391{
1392 unsigned long flags;
1393
1394 spin_lock_irqsave(&host->lock, flags);
1395 host->bus_refs++;
1396 spin_unlock_irqrestore(&host->lock, flags);
1397}
1398
1399
1400
1401
1402
1403static inline void mmc_bus_put(struct mmc_host *host)
1404{
1405 unsigned long flags;
1406
1407 spin_lock_irqsave(&host->lock, flags);
1408 host->bus_refs--;
1409 if ((host->bus_refs == 0) && host->bus_ops)
1410 __mmc_release_bus(host);
1411 spin_unlock_irqrestore(&host->lock, flags);
1412}
1413
1414
1415
1416
1417
1418void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops)
1419{
1420 unsigned long flags;
1421
1422 WARN_ON(!host->claimed);
1423
1424 spin_lock_irqsave(&host->lock, flags);
1425
1426 WARN_ON(host->bus_ops);
1427 WARN_ON(host->bus_refs);
1428
1429 host->bus_ops = ops;
1430 host->bus_refs = 1;
1431 host->bus_dead = 0;
1432
1433 spin_unlock_irqrestore(&host->lock, flags);
1434}
1435
1436
1437
1438
1439void mmc_detach_bus(struct mmc_host *host)
1440{
1441 unsigned long flags;
1442
1443 WARN_ON(!host->claimed);
1444 WARN_ON(!host->bus_ops);
1445
1446 spin_lock_irqsave(&host->lock, flags);
1447
1448 host->bus_dead = 1;
1449
1450 spin_unlock_irqrestore(&host->lock, flags);
1451
1452 mmc_bus_put(host);
1453}
1454
1455void _mmc_detect_change(struct mmc_host *host, unsigned long delay, bool cd_irq)
1456{
1457
1458
1459
1460
1461
1462 if (cd_irq && !(host->caps & MMC_CAP_NEEDS_POLL))
1463 __pm_wakeup_event(host->ws, 5000);
1464
1465 host->detect_change = 1;
1466 mmc_schedule_delayed_work(&host->detect, delay);
1467}
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479void mmc_detect_change(struct mmc_host *host, unsigned long delay)
1480{
1481 _mmc_detect_change(host, delay, true);
1482}
1483EXPORT_SYMBOL(mmc_detect_change);
1484
1485void mmc_init_erase(struct mmc_card *card)
1486{
1487 unsigned int sz;
1488
1489 if (is_power_of_2(card->erase_size))
1490 card->erase_shift = ffs(card->erase_size) - 1;
1491 else
1492 card->erase_shift = 0;
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509 if (mmc_card_sd(card) && card->ssr.au) {
1510 card->pref_erase = card->ssr.au;
1511 card->erase_shift = ffs(card->ssr.au) - 1;
1512 } else if (card->erase_size) {
1513 sz = (card->csd.capacity << (card->csd.read_blkbits - 9)) >> 11;
1514 if (sz < 128)
1515 card->pref_erase = 512 * 1024 / 512;
1516 else if (sz < 512)
1517 card->pref_erase = 1024 * 1024 / 512;
1518 else if (sz < 1024)
1519 card->pref_erase = 2 * 1024 * 1024 / 512;
1520 else
1521 card->pref_erase = 4 * 1024 * 1024 / 512;
1522 if (card->pref_erase < card->erase_size)
1523 card->pref_erase = card->erase_size;
1524 else {
1525 sz = card->pref_erase % card->erase_size;
1526 if (sz)
1527 card->pref_erase += card->erase_size - sz;
1528 }
1529 } else
1530 card->pref_erase = 0;
1531}
1532
1533static unsigned int mmc_mmc_erase_timeout(struct mmc_card *card,
1534 unsigned int arg, unsigned int qty)
1535{
1536 unsigned int erase_timeout;
1537
1538 if (arg == MMC_DISCARD_ARG ||
1539 (arg == MMC_TRIM_ARG && card->ext_csd.rev >= 6)) {
1540 erase_timeout = card->ext_csd.trim_timeout;
1541 } else if (card->ext_csd.erase_group_def & 1) {
1542
1543 if (arg == MMC_TRIM_ARG)
1544 erase_timeout = card->ext_csd.trim_timeout;
1545 else
1546 erase_timeout = card->ext_csd.hc_erase_timeout;
1547 } else {
1548
1549 unsigned int mult = (10 << card->csd.r2w_factor);
1550 unsigned int timeout_clks = card->csd.taac_clks * mult;
1551 unsigned int timeout_us;
1552
1553
1554 if (card->csd.taac_ns < 1000000)
1555 timeout_us = (card->csd.taac_ns * mult) / 1000;
1556 else
1557 timeout_us = (card->csd.taac_ns / 1000) * mult;
1558
1559
1560
1561
1562
1563 timeout_clks <<= 1;
1564 timeout_us += (timeout_clks * 1000) /
1565 (card->host->ios.clock / 1000);
1566
1567 erase_timeout = timeout_us / 1000;
1568
1569
1570
1571
1572
1573 if (!erase_timeout)
1574 erase_timeout = 1;
1575 }
1576
1577
1578 if (arg & MMC_SECURE_ARGS) {
1579 if (arg == MMC_SECURE_ERASE_ARG)
1580 erase_timeout *= card->ext_csd.sec_erase_mult;
1581 else
1582 erase_timeout *= card->ext_csd.sec_trim_mult;
1583 }
1584
1585 erase_timeout *= qty;
1586
1587
1588
1589
1590
1591 if (mmc_host_is_spi(card->host) && erase_timeout < 1000)
1592 erase_timeout = 1000;
1593
1594 return erase_timeout;
1595}
1596
1597static unsigned int mmc_sd_erase_timeout(struct mmc_card *card,
1598 unsigned int arg,
1599 unsigned int qty)
1600{
1601 unsigned int erase_timeout;
1602
1603
1604
1605
1606 if (arg == SD_DISCARD_ARG)
1607 return SD_DISCARD_TIMEOUT_MS;
1608
1609 if (card->ssr.erase_timeout) {
1610
1611 erase_timeout = card->ssr.erase_timeout * qty +
1612 card->ssr.erase_offset;
1613 } else {
1614
1615
1616
1617
1618 erase_timeout = 250 * qty;
1619 }
1620
1621
1622 if (erase_timeout < 1000)
1623 erase_timeout = 1000;
1624
1625 return erase_timeout;
1626}
1627
1628static unsigned int mmc_erase_timeout(struct mmc_card *card,
1629 unsigned int arg,
1630 unsigned int qty)
1631{
1632 if (mmc_card_sd(card))
1633 return mmc_sd_erase_timeout(card, arg, qty);
1634 else
1635 return mmc_mmc_erase_timeout(card, arg, qty);
1636}
1637
1638static int mmc_do_erase(struct mmc_card *card, unsigned int from,
1639 unsigned int to, unsigned int arg)
1640{
1641 struct mmc_command cmd = {};
1642 unsigned int qty = 0, busy_timeout = 0;
1643 bool use_r1b_resp = false;
1644 int err;
1645
1646 mmc_retune_hold(card->host);
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664 if (card->erase_shift)
1665 qty += ((to >> card->erase_shift) -
1666 (from >> card->erase_shift)) + 1;
1667 else if (mmc_card_sd(card))
1668 qty += to - from + 1;
1669 else
1670 qty += ((to / card->erase_size) -
1671 (from / card->erase_size)) + 1;
1672
1673 if (!mmc_card_blockaddr(card)) {
1674 from <<= 9;
1675 to <<= 9;
1676 }
1677
1678 if (mmc_card_sd(card))
1679 cmd.opcode = SD_ERASE_WR_BLK_START;
1680 else
1681 cmd.opcode = MMC_ERASE_GROUP_START;
1682 cmd.arg = from;
1683 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
1684 err = mmc_wait_for_cmd(card->host, &cmd, 0);
1685 if (err) {
1686 pr_err("mmc_erase: group start error %d, "
1687 "status %#x\n", err, cmd.resp[0]);
1688 err = -EIO;
1689 goto out;
1690 }
1691
1692 memset(&cmd, 0, sizeof(struct mmc_command));
1693 if (mmc_card_sd(card))
1694 cmd.opcode = SD_ERASE_WR_BLK_END;
1695 else
1696 cmd.opcode = MMC_ERASE_GROUP_END;
1697 cmd.arg = to;
1698 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
1699 err = mmc_wait_for_cmd(card->host, &cmd, 0);
1700 if (err) {
1701 pr_err("mmc_erase: group end error %d, status %#x\n",
1702 err, cmd.resp[0]);
1703 err = -EIO;
1704 goto out;
1705 }
1706
1707 memset(&cmd, 0, sizeof(struct mmc_command));
1708 cmd.opcode = MMC_ERASE;
1709 cmd.arg = arg;
1710 busy_timeout = mmc_erase_timeout(card, arg, qty);
1711
1712
1713
1714
1715
1716
1717
1718
1719 if (!(card->host->caps & MMC_CAP_NEED_RSP_BUSY) &&
1720 card->host->max_busy_timeout &&
1721 busy_timeout > card->host->max_busy_timeout) {
1722 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
1723 } else {
1724 cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
1725 cmd.busy_timeout = busy_timeout;
1726 use_r1b_resp = true;
1727 }
1728
1729 err = mmc_wait_for_cmd(card->host, &cmd, 0);
1730 if (err) {
1731 pr_err("mmc_erase: erase error %d, status %#x\n",
1732 err, cmd.resp[0]);
1733 err = -EIO;
1734 goto out;
1735 }
1736
1737 if (mmc_host_is_spi(card->host))
1738 goto out;
1739
1740
1741
1742
1743
1744 if ((card->host->caps & MMC_CAP_WAIT_WHILE_BUSY) && use_r1b_resp)
1745 goto out;
1746
1747
1748 err = mmc_poll_for_busy(card, busy_timeout, MMC_BUSY_ERASE);
1749
1750out:
1751 mmc_retune_release(card->host);
1752 return err;
1753}
1754
1755static unsigned int mmc_align_erase_size(struct mmc_card *card,
1756 unsigned int *from,
1757 unsigned int *to,
1758 unsigned int nr)
1759{
1760 unsigned int from_new = *from, nr_new = nr, rem;
1761
1762
1763
1764
1765
1766 if (is_power_of_2(card->erase_size)) {
1767 unsigned int temp = from_new;
1768
1769 from_new = round_up(temp, card->erase_size);
1770 rem = from_new - temp;
1771
1772 if (nr_new > rem)
1773 nr_new -= rem;
1774 else
1775 return 0;
1776
1777 nr_new = round_down(nr_new, card->erase_size);
1778 } else {
1779 rem = from_new % card->erase_size;
1780 if (rem) {
1781 rem = card->erase_size - rem;
1782 from_new += rem;
1783 if (nr_new > rem)
1784 nr_new -= rem;
1785 else
1786 return 0;
1787 }
1788
1789 rem = nr_new % card->erase_size;
1790 if (rem)
1791 nr_new -= rem;
1792 }
1793
1794 if (nr_new == 0)
1795 return 0;
1796
1797 *to = from_new + nr_new;
1798 *from = from_new;
1799
1800 return nr_new;
1801}
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812int mmc_erase(struct mmc_card *card, unsigned int from, unsigned int nr,
1813 unsigned int arg)
1814{
1815 unsigned int rem, to = from + nr;
1816 int err;
1817
1818 if (!(card->csd.cmdclass & CCC_ERASE))
1819 return -EOPNOTSUPP;
1820
1821 if (!card->erase_size)
1822 return -EOPNOTSUPP;
1823
1824 if (mmc_card_sd(card) && arg != SD_ERASE_ARG && arg != SD_DISCARD_ARG)
1825 return -EOPNOTSUPP;
1826
1827 if (mmc_card_mmc(card) && (arg & MMC_SECURE_ARGS) &&
1828 !(card->ext_csd.sec_feature_support & EXT_CSD_SEC_ER_EN))
1829 return -EOPNOTSUPP;
1830
1831 if (mmc_card_mmc(card) && (arg & MMC_TRIM_ARGS) &&
1832 !(card->ext_csd.sec_feature_support & EXT_CSD_SEC_GB_CL_EN))
1833 return -EOPNOTSUPP;
1834
1835 if (arg == MMC_SECURE_ERASE_ARG) {
1836 if (from % card->erase_size || nr % card->erase_size)
1837 return -EINVAL;
1838 }
1839
1840 if (arg == MMC_ERASE_ARG)
1841 nr = mmc_align_erase_size(card, &from, &to, nr);
1842
1843 if (nr == 0)
1844 return 0;
1845
1846 if (to <= from)
1847 return -EINVAL;
1848
1849
1850 to -= 1;
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860 rem = card->erase_size - (from % card->erase_size);
1861 if ((arg & MMC_TRIM_ARGS) && (card->eg_boundary) && (nr > rem)) {
1862 err = mmc_do_erase(card, from, from + rem - 1, arg);
1863 from += rem;
1864 if ((err) || (to <= from))
1865 return err;
1866 }
1867
1868 return mmc_do_erase(card, from, to, arg);
1869}
1870EXPORT_SYMBOL(mmc_erase);
1871
1872int mmc_can_erase(struct mmc_card *card)
1873{
1874 if (card->csd.cmdclass & CCC_ERASE && card->erase_size)
1875 return 1;
1876 return 0;
1877}
1878EXPORT_SYMBOL(mmc_can_erase);
1879
1880int mmc_can_trim(struct mmc_card *card)
1881{
1882 if ((card->ext_csd.sec_feature_support & EXT_CSD_SEC_GB_CL_EN) &&
1883 (!(card->quirks & MMC_QUIRK_TRIM_BROKEN)))
1884 return 1;
1885 return 0;
1886}
1887EXPORT_SYMBOL(mmc_can_trim);
1888
1889int mmc_can_discard(struct mmc_card *card)
1890{
1891
1892
1893
1894
1895 if (card->ext_csd.feature_support & MMC_DISCARD_FEATURE)
1896 return 1;
1897 return 0;
1898}
1899EXPORT_SYMBOL(mmc_can_discard);
1900
1901int mmc_can_sanitize(struct mmc_card *card)
1902{
1903 if (!mmc_can_trim(card) && !mmc_can_erase(card))
1904 return 0;
1905 if (card->ext_csd.sec_feature_support & EXT_CSD_SEC_SANITIZE)
1906 return 1;
1907 return 0;
1908}
1909
1910int mmc_can_secure_erase_trim(struct mmc_card *card)
1911{
1912 if ((card->ext_csd.sec_feature_support & EXT_CSD_SEC_ER_EN) &&
1913 !(card->quirks & MMC_QUIRK_SEC_ERASE_TRIM_BROKEN))
1914 return 1;
1915 return 0;
1916}
1917EXPORT_SYMBOL(mmc_can_secure_erase_trim);
1918
1919int mmc_erase_group_aligned(struct mmc_card *card, unsigned int from,
1920 unsigned int nr)
1921{
1922 if (!card->erase_size)
1923 return 0;
1924 if (from % card->erase_size || nr % card->erase_size)
1925 return 0;
1926 return 1;
1927}
1928EXPORT_SYMBOL(mmc_erase_group_aligned);
1929
1930static unsigned int mmc_do_calc_max_discard(struct mmc_card *card,
1931 unsigned int arg)
1932{
1933 struct mmc_host *host = card->host;
1934 unsigned int max_discard, x, y, qty = 0, max_qty, min_qty, timeout;
1935 unsigned int last_timeout = 0;
1936 unsigned int max_busy_timeout = host->max_busy_timeout ?
1937 host->max_busy_timeout : MMC_ERASE_TIMEOUT_MS;
1938
1939 if (card->erase_shift) {
1940 max_qty = UINT_MAX >> card->erase_shift;
1941 min_qty = card->pref_erase >> card->erase_shift;
1942 } else if (mmc_card_sd(card)) {
1943 max_qty = UINT_MAX;
1944 min_qty = card->pref_erase;
1945 } else {
1946 max_qty = UINT_MAX / card->erase_size;
1947 min_qty = card->pref_erase / card->erase_size;
1948 }
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963 do {
1964 y = 0;
1965 for (x = 1; x && x <= max_qty && max_qty - x >= qty; x <<= 1) {
1966 timeout = mmc_erase_timeout(card, arg, qty + x);
1967
1968 if (qty + x > min_qty && timeout > max_busy_timeout)
1969 break;
1970
1971 if (timeout < last_timeout)
1972 break;
1973 last_timeout = timeout;
1974 y = x;
1975 }
1976 qty += y;
1977 } while (y);
1978
1979 if (!qty)
1980 return 0;
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992 if (qty == 1)
1993 card->eg_boundary = 1;
1994 else
1995 qty--;
1996
1997
1998 if (card->erase_shift)
1999 max_discard = qty << card->erase_shift;
2000 else if (mmc_card_sd(card))
2001 max_discard = qty + 1;
2002 else
2003 max_discard = qty * card->erase_size;
2004
2005 return max_discard;
2006}
2007
2008unsigned int mmc_calc_max_discard(struct mmc_card *card)
2009{
2010 struct mmc_host *host = card->host;
2011 unsigned int max_discard, max_trim;
2012
2013
2014
2015
2016
2017
2018 if (mmc_card_mmc(card) && !(card->ext_csd.erase_group_def & 1))
2019 return card->pref_erase;
2020
2021 max_discard = mmc_do_calc_max_discard(card, MMC_ERASE_ARG);
2022 if (mmc_can_trim(card)) {
2023 max_trim = mmc_do_calc_max_discard(card, MMC_TRIM_ARG);
2024 if (max_trim < max_discard || max_discard == 0)
2025 max_discard = max_trim;
2026 } else if (max_discard < card->erase_size) {
2027 max_discard = 0;
2028 }
2029 pr_debug("%s: calculated max. discard sectors %u for timeout %u ms\n",
2030 mmc_hostname(host), max_discard, host->max_busy_timeout ?
2031 host->max_busy_timeout : MMC_ERASE_TIMEOUT_MS);
2032 return max_discard;
2033}
2034EXPORT_SYMBOL(mmc_calc_max_discard);
2035
2036bool mmc_card_is_blockaddr(struct mmc_card *card)
2037{
2038 return card ? mmc_card_blockaddr(card) : false;
2039}
2040EXPORT_SYMBOL(mmc_card_is_blockaddr);
2041
2042int mmc_set_blocklen(struct mmc_card *card, unsigned int blocklen)
2043{
2044 struct mmc_command cmd = {};
2045
2046 if (mmc_card_blockaddr(card) || mmc_card_ddr52(card) ||
2047 mmc_card_hs400(card) || mmc_card_hs400es(card))
2048 return 0;
2049
2050 cmd.opcode = MMC_SET_BLOCKLEN;
2051 cmd.arg = blocklen;
2052 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
2053 return mmc_wait_for_cmd(card->host, &cmd, 5);
2054}
2055EXPORT_SYMBOL(mmc_set_blocklen);
2056
2057static void mmc_hw_reset_for_init(struct mmc_host *host)
2058{
2059 mmc_pwrseq_reset(host);
2060
2061 if (!(host->caps & MMC_CAP_HW_RESET) || !host->ops->hw_reset)
2062 return;
2063 host->ops->hw_reset(host);
2064}
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076int mmc_hw_reset(struct mmc_host *host)
2077{
2078 int ret;
2079
2080 if (!host->card)
2081 return -EINVAL;
2082
2083 mmc_bus_get(host);
2084 if (!host->bus_ops || host->bus_dead || !host->bus_ops->hw_reset) {
2085 mmc_bus_put(host);
2086 return -EOPNOTSUPP;
2087 }
2088
2089 ret = host->bus_ops->hw_reset(host);
2090 mmc_bus_put(host);
2091
2092 if (ret < 0)
2093 pr_warn("%s: tried to HW reset card, got error %d\n",
2094 mmc_hostname(host), ret);
2095
2096 return ret;
2097}
2098EXPORT_SYMBOL(mmc_hw_reset);
2099
2100int mmc_sw_reset(struct mmc_host *host)
2101{
2102 int ret;
2103
2104 if (!host->card)
2105 return -EINVAL;
2106
2107 mmc_bus_get(host);
2108 if (!host->bus_ops || host->bus_dead || !host->bus_ops->sw_reset) {
2109 mmc_bus_put(host);
2110 return -EOPNOTSUPP;
2111 }
2112
2113 ret = host->bus_ops->sw_reset(host);
2114 mmc_bus_put(host);
2115
2116 if (ret)
2117 pr_warn("%s: tried to SW reset card, got error %d\n",
2118 mmc_hostname(host), ret);
2119
2120 return ret;
2121}
2122EXPORT_SYMBOL(mmc_sw_reset);
2123
2124static int mmc_rescan_try_freq(struct mmc_host *host, unsigned freq)
2125{
2126 host->f_init = freq;
2127
2128 pr_debug("%s: %s: trying to init card at %u Hz\n",
2129 mmc_hostname(host), __func__, host->f_init);
2130
2131 mmc_power_up(host, host->ocr_avail);
2132
2133
2134
2135
2136
2137 mmc_hw_reset_for_init(host);
2138
2139
2140
2141
2142
2143
2144
2145 if (!(host->caps2 & MMC_CAP2_NO_SDIO))
2146 sdio_reset(host);
2147
2148 mmc_go_idle(host);
2149
2150 if (!(host->caps2 & MMC_CAP2_NO_SD)) {
2151 if (mmc_send_if_cond_pcie(host, host->ocr_avail))
2152 goto out;
2153 if (mmc_card_sd_express(host))
2154 return 0;
2155 }
2156
2157
2158 if (!(host->caps2 & MMC_CAP2_NO_SDIO))
2159 if (!mmc_attach_sdio(host))
2160 return 0;
2161
2162 if (!(host->caps2 & MMC_CAP2_NO_SD))
2163 if (!mmc_attach_sd(host))
2164 return 0;
2165
2166 if (!(host->caps2 & MMC_CAP2_NO_MMC))
2167 if (!mmc_attach_mmc(host))
2168 return 0;
2169
2170out:
2171 mmc_power_off(host);
2172 return -EIO;
2173}
2174
2175int _mmc_detect_card_removed(struct mmc_host *host)
2176{
2177 int ret;
2178
2179 if (!host->card || mmc_card_removed(host->card))
2180 return 1;
2181
2182 ret = host->bus_ops->alive(host);
2183
2184
2185
2186
2187
2188
2189
2190
2191 if (!ret && host->ops->get_cd && !host->ops->get_cd(host)) {
2192 mmc_detect_change(host, msecs_to_jiffies(200));
2193 pr_debug("%s: card removed too slowly\n", mmc_hostname(host));
2194 }
2195
2196 if (ret) {
2197 mmc_card_set_removed(host->card);
2198 pr_debug("%s: card remove detected\n", mmc_hostname(host));
2199 }
2200
2201 return ret;
2202}
2203
2204int mmc_detect_card_removed(struct mmc_host *host)
2205{
2206 struct mmc_card *card = host->card;
2207 int ret;
2208
2209 WARN_ON(!host->claimed);
2210
2211 if (!card)
2212 return 1;
2213
2214 if (!mmc_card_is_removable(host))
2215 return 0;
2216
2217 ret = mmc_card_removed(card);
2218
2219
2220
2221
2222 if (!host->detect_change && !(host->caps & MMC_CAP_NEEDS_POLL))
2223 return ret;
2224
2225 host->detect_change = 0;
2226 if (!ret) {
2227 ret = _mmc_detect_card_removed(host);
2228 if (ret && (host->caps & MMC_CAP_NEEDS_POLL)) {
2229
2230
2231
2232
2233 cancel_delayed_work(&host->detect);
2234 _mmc_detect_change(host, 0, false);
2235 }
2236 }
2237
2238 return ret;
2239}
2240EXPORT_SYMBOL(mmc_detect_card_removed);
2241
2242void mmc_rescan(struct work_struct *work)
2243{
2244 struct mmc_host *host =
2245 container_of(work, struct mmc_host, detect.work);
2246 int i;
2247
2248 if (host->rescan_disable)
2249 return;
2250
2251
2252 if (!mmc_card_is_removable(host) && host->rescan_entered)
2253 return;
2254 host->rescan_entered = 1;
2255
2256 if (host->trigger_card_event && host->ops->card_event) {
2257 mmc_claim_host(host);
2258 host->ops->card_event(host);
2259 mmc_release_host(host);
2260 host->trigger_card_event = false;
2261 }
2262
2263 mmc_bus_get(host);
2264
2265
2266 if (host->bus_ops && !host->bus_dead)
2267 host->bus_ops->detect(host);
2268
2269 host->detect_change = 0;
2270
2271
2272
2273
2274
2275 mmc_bus_put(host);
2276 mmc_bus_get(host);
2277
2278
2279 if (host->bus_ops != NULL) {
2280 mmc_bus_put(host);
2281 goto out;
2282 }
2283
2284
2285
2286
2287
2288 mmc_bus_put(host);
2289
2290 mmc_claim_host(host);
2291 if (mmc_card_is_removable(host) && host->ops->get_cd &&
2292 host->ops->get_cd(host) == 0) {
2293 mmc_power_off(host);
2294 mmc_release_host(host);
2295 goto out;
2296 }
2297
2298
2299 if (mmc_card_sd_express(host)) {
2300 mmc_release_host(host);
2301 goto out;
2302 }
2303
2304 for (i = 0; i < ARRAY_SIZE(freqs); i++) {
2305 unsigned int freq = freqs[i];
2306 if (freq > host->f_max) {
2307 if (i + 1 < ARRAY_SIZE(freqs))
2308 continue;
2309 freq = host->f_max;
2310 }
2311 if (!mmc_rescan_try_freq(host, max(freq, host->f_min)))
2312 break;
2313 if (freqs[i] <= host->f_min)
2314 break;
2315 }
2316 mmc_release_host(host);
2317
2318 out:
2319 if (host->caps & MMC_CAP_NEEDS_POLL)
2320 mmc_schedule_delayed_work(&host->detect, HZ);
2321}
2322
2323void mmc_start_host(struct mmc_host *host)
2324{
2325 host->f_init = max(min(freqs[0], host->f_max), host->f_min);
2326 host->rescan_disable = 0;
2327
2328 if (!(host->caps2 & MMC_CAP2_NO_PRESCAN_POWERUP)) {
2329 mmc_claim_host(host);
2330 mmc_power_up(host, host->ocr_avail);
2331 mmc_release_host(host);
2332 }
2333
2334 mmc_gpiod_request_cd_irq(host);
2335 _mmc_detect_change(host, 0, false);
2336}
2337
2338void mmc_stop_host(struct mmc_host *host)
2339{
2340 if (host->slot.cd_irq >= 0) {
2341 mmc_gpio_set_cd_wake(host, false);
2342 disable_irq(host->slot.cd_irq);
2343 }
2344
2345 host->rescan_disable = 1;
2346 cancel_delayed_work_sync(&host->detect);
2347
2348
2349 host->pm_flags = 0;
2350
2351 mmc_bus_get(host);
2352 if (host->bus_ops && !host->bus_dead) {
2353
2354 host->bus_ops->remove(host);
2355 mmc_claim_host(host);
2356 mmc_detach_bus(host);
2357 mmc_power_off(host);
2358 mmc_release_host(host);
2359 mmc_bus_put(host);
2360 return;
2361 }
2362 mmc_bus_put(host);
2363
2364 mmc_claim_host(host);
2365 mmc_power_off(host);
2366 mmc_release_host(host);
2367}
2368
2369#ifdef CONFIG_PM_SLEEP
2370
2371
2372
2373
2374static int mmc_pm_notify(struct notifier_block *notify_block,
2375 unsigned long mode, void *unused)
2376{
2377 struct mmc_host *host = container_of(
2378 notify_block, struct mmc_host, pm_notify);
2379 unsigned long flags;
2380 int err = 0;
2381
2382 switch (mode) {
2383 case PM_HIBERNATION_PREPARE:
2384 case PM_SUSPEND_PREPARE:
2385 case PM_RESTORE_PREPARE:
2386 spin_lock_irqsave(&host->lock, flags);
2387 host->rescan_disable = 1;
2388 spin_unlock_irqrestore(&host->lock, flags);
2389 cancel_delayed_work_sync(&host->detect);
2390
2391 if (!host->bus_ops)
2392 break;
2393
2394
2395 if (host->bus_ops->pre_suspend)
2396 err = host->bus_ops->pre_suspend(host);
2397 if (!err)
2398 break;
2399
2400 if (!mmc_card_is_removable(host)) {
2401 dev_warn(mmc_dev(host),
2402 "pre_suspend failed for non-removable host: "
2403 "%d\n", err);
2404
2405 break;
2406 }
2407
2408
2409 host->bus_ops->remove(host);
2410 mmc_claim_host(host);
2411 mmc_detach_bus(host);
2412 mmc_power_off(host);
2413 mmc_release_host(host);
2414 host->pm_flags = 0;
2415 break;
2416
2417 case PM_POST_SUSPEND:
2418 case PM_POST_HIBERNATION:
2419 case PM_POST_RESTORE:
2420
2421 spin_lock_irqsave(&host->lock, flags);
2422 host->rescan_disable = 0;
2423 spin_unlock_irqrestore(&host->lock, flags);
2424 _mmc_detect_change(host, 0, false);
2425
2426 }
2427
2428 return 0;
2429}
2430
2431void mmc_register_pm_notifier(struct mmc_host *host)
2432{
2433 host->pm_notify.notifier_call = mmc_pm_notify;
2434 register_pm_notifier(&host->pm_notify);
2435}
2436
2437void mmc_unregister_pm_notifier(struct mmc_host *host)
2438{
2439 unregister_pm_notifier(&host->pm_notify);
2440}
2441#endif
2442
2443static int __init mmc_init(void)
2444{
2445 int ret;
2446
2447 ret = mmc_register_bus();
2448 if (ret)
2449 return ret;
2450
2451 ret = mmc_register_host_class();
2452 if (ret)
2453 goto unregister_bus;
2454
2455 ret = sdio_register_bus();
2456 if (ret)
2457 goto unregister_host_class;
2458
2459 return 0;
2460
2461unregister_host_class:
2462 mmc_unregister_host_class();
2463unregister_bus:
2464 mmc_unregister_bus();
2465 return ret;
2466}
2467
2468static void __exit mmc_exit(void)
2469{
2470 sdio_unregister_bus();
2471 mmc_unregister_host_class();
2472 mmc_unregister_bus();
2473}
2474
2475subsys_initcall(mmc_init);
2476module_exit(mmc_exit);
2477
2478MODULE_LICENSE("GPL");
2479