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