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