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
940 if (err) {
941 pr_err("%s: tuning execution failed: %d\n",
942 mmc_hostname(host), err);
943 } else {
944 host->retune_now = 0;
945 host->need_retune = 0;
946 mmc_retune_enable(host);
947 }
948
949 return err;
950}
951
952
953
954
955void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
956{
957 host->ios.bus_mode = mode;
958 mmc_set_ios(host);
959}
960
961
962
963
964void mmc_set_bus_width(struct mmc_host *host, unsigned int width)
965{
966 host->ios.bus_width = width;
967 mmc_set_ios(host);
968}
969
970
971
972
973void mmc_set_initial_state(struct mmc_host *host)
974{
975 if (host->cqe_on)
976 host->cqe_ops->cqe_off(host);
977
978 mmc_retune_disable(host);
979
980 if (mmc_host_is_spi(host))
981 host->ios.chip_select = MMC_CS_HIGH;
982 else
983 host->ios.chip_select = MMC_CS_DONTCARE;
984 host->ios.bus_mode = MMC_BUSMODE_PUSHPULL;
985 host->ios.bus_width = MMC_BUS_WIDTH_1;
986 host->ios.timing = MMC_TIMING_LEGACY;
987 host->ios.drv_type = 0;
988 host->ios.enhanced_strobe = false;
989
990
991
992
993
994 if ((host->caps2 & MMC_CAP2_HS400_ES) &&
995 host->ops->hs400_enhanced_strobe)
996 host->ops->hs400_enhanced_strobe(host, &host->ios);
997
998 mmc_set_ios(host);
999
1000 mmc_crypto_set_initial_state(host);
1001}
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018static int mmc_vdd_to_ocrbitnum(int vdd, bool low_bits)
1019{
1020 const int max_bit = ilog2(MMC_VDD_35_36);
1021 int bit;
1022
1023 if (vdd < 1650 || vdd > 3600)
1024 return -EINVAL;
1025
1026 if (vdd >= 1650 && vdd <= 1950)
1027 return ilog2(MMC_VDD_165_195);
1028
1029 if (low_bits)
1030 vdd -= 1;
1031
1032
1033 bit = (vdd - 2000) / 100 + 8;
1034 if (bit > max_bit)
1035 return max_bit;
1036 return bit;
1037}
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052u32 mmc_vddrange_to_ocrmask(int vdd_min, int vdd_max)
1053{
1054 u32 mask = 0;
1055
1056 if (vdd_max < vdd_min)
1057 return 0;
1058
1059
1060 vdd_max = mmc_vdd_to_ocrbitnum(vdd_max, false);
1061 if (vdd_max < 0)
1062 return 0;
1063
1064
1065 vdd_min = mmc_vdd_to_ocrbitnum(vdd_min, true);
1066 if (vdd_min < 0)
1067 return 0;
1068
1069
1070 while (vdd_max >= vdd_min)
1071 mask |= 1 << vdd_max--;
1072
1073 return mask;
1074}
1075
1076static int mmc_of_get_func_num(struct device_node *node)
1077{
1078 u32 reg;
1079 int ret;
1080
1081 ret = of_property_read_u32(node, "reg", ®);
1082 if (ret < 0)
1083 return ret;
1084
1085 return reg;
1086}
1087
1088struct device_node *mmc_of_find_child_device(struct mmc_host *host,
1089 unsigned func_num)
1090{
1091 struct device_node *node;
1092
1093 if (!host->parent || !host->parent->of_node)
1094 return NULL;
1095
1096 for_each_child_of_node(host->parent->of_node, node) {
1097 if (mmc_of_get_func_num(node) == func_num)
1098 return node;
1099 }
1100
1101 return NULL;
1102}
1103
1104
1105
1106
1107
1108u32 mmc_select_voltage(struct mmc_host *host, u32 ocr)
1109{
1110 int bit;
1111
1112
1113
1114
1115
1116 if (ocr & 0x7F) {
1117 dev_warn(mmc_dev(host),
1118 "card claims to support voltages below defined range\n");
1119 ocr &= ~0x7F;
1120 }
1121
1122 ocr &= host->ocr_avail;
1123 if (!ocr) {
1124 dev_warn(mmc_dev(host), "no support for card's volts\n");
1125 return 0;
1126 }
1127
1128 if (host->caps2 & MMC_CAP2_FULL_PWR_CYCLE) {
1129 bit = ffs(ocr) - 1;
1130 ocr &= 3 << bit;
1131 mmc_power_cycle(host, ocr);
1132 } else {
1133 bit = fls(ocr) - 1;
1134 ocr &= 3 << bit;
1135 if (bit != host->ios.vdd)
1136 dev_warn(mmc_dev(host), "exceeding card's volts\n");
1137 }
1138
1139 return ocr;
1140}
1141
1142int mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage)
1143{
1144 int err = 0;
1145 int old_signal_voltage = host->ios.signal_voltage;
1146
1147 host->ios.signal_voltage = signal_voltage;
1148 if (host->ops->start_signal_voltage_switch)
1149 err = host->ops->start_signal_voltage_switch(host, &host->ios);
1150
1151 if (err)
1152 host->ios.signal_voltage = old_signal_voltage;
1153
1154 return err;
1155
1156}
1157
1158void mmc_set_initial_signal_voltage(struct mmc_host *host)
1159{
1160
1161 if (!mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330))
1162 dev_dbg(mmc_dev(host), "Initial signal voltage of 3.3v\n");
1163 else if (!mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180))
1164 dev_dbg(mmc_dev(host), "Initial signal voltage of 1.8v\n");
1165 else if (!mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120))
1166 dev_dbg(mmc_dev(host), "Initial signal voltage of 1.2v\n");
1167}
1168
1169int mmc_host_set_uhs_voltage(struct mmc_host *host)
1170{
1171 u32 clock;
1172
1173
1174
1175
1176
1177 clock = host->ios.clock;
1178 host->ios.clock = 0;
1179 mmc_set_ios(host);
1180
1181 if (mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180))
1182 return -EAGAIN;
1183
1184
1185 mmc_delay(10);
1186 host->ios.clock = clock;
1187 mmc_set_ios(host);
1188
1189 return 0;
1190}
1191
1192int mmc_set_uhs_voltage(struct mmc_host *host, u32 ocr)
1193{
1194 struct mmc_command cmd = {};
1195 int err = 0;
1196
1197
1198
1199
1200
1201 if (!host->ops->start_signal_voltage_switch)
1202 return -EPERM;
1203 if (!host->ops->card_busy)
1204 pr_warn("%s: cannot verify signal voltage switch\n",
1205 mmc_hostname(host));
1206
1207 cmd.opcode = SD_SWITCH_VOLTAGE;
1208 cmd.arg = 0;
1209 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
1210
1211 err = mmc_wait_for_cmd(host, &cmd, 0);
1212 if (err)
1213 goto power_cycle;
1214
1215 if (!mmc_host_is_spi(host) && (cmd.resp[0] & R1_ERROR))
1216 return -EIO;
1217
1218
1219
1220
1221
1222 mmc_delay(1);
1223 if (host->ops->card_busy && !host->ops->card_busy(host)) {
1224 err = -EAGAIN;
1225 goto power_cycle;
1226 }
1227
1228 if (mmc_host_set_uhs_voltage(host)) {
1229
1230
1231
1232
1233 err = -EAGAIN;
1234 goto power_cycle;
1235 }
1236
1237
1238 mmc_delay(1);
1239
1240
1241
1242
1243
1244 if (host->ops->card_busy && host->ops->card_busy(host))
1245 err = -EAGAIN;
1246
1247power_cycle:
1248 if (err) {
1249 pr_debug("%s: Signal voltage switch failed, "
1250 "power cycling card\n", mmc_hostname(host));
1251 mmc_power_cycle(host, ocr);
1252 }
1253
1254 return err;
1255}
1256
1257
1258
1259
1260void mmc_set_timing(struct mmc_host *host, unsigned int timing)
1261{
1262 host->ios.timing = timing;
1263 mmc_set_ios(host);
1264}
1265
1266
1267
1268
1269void mmc_set_driver_type(struct mmc_host *host, unsigned int drv_type)
1270{
1271 host->ios.drv_type = drv_type;
1272 mmc_set_ios(host);
1273}
1274
1275int mmc_select_drive_strength(struct mmc_card *card, unsigned int max_dtr,
1276 int card_drv_type, int *drv_type)
1277{
1278 struct mmc_host *host = card->host;
1279 int host_drv_type = SD_DRIVER_TYPE_B;
1280
1281 *drv_type = 0;
1282
1283 if (!host->ops->select_drive_strength)
1284 return 0;
1285
1286
1287 if (host->caps & MMC_CAP_DRIVER_TYPE_A)
1288 host_drv_type |= SD_DRIVER_TYPE_A;
1289
1290 if (host->caps & MMC_CAP_DRIVER_TYPE_C)
1291 host_drv_type |= SD_DRIVER_TYPE_C;
1292
1293 if (host->caps & MMC_CAP_DRIVER_TYPE_D)
1294 host_drv_type |= SD_DRIVER_TYPE_D;
1295
1296
1297
1298
1299
1300
1301
1302 return host->ops->select_drive_strength(card, max_dtr,
1303 host_drv_type,
1304 card_drv_type,
1305 drv_type);
1306}
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319void mmc_power_up(struct mmc_host *host, u32 ocr)
1320{
1321 if (host->ios.power_mode == MMC_POWER_ON)
1322 return;
1323
1324 mmc_pwrseq_pre_power_on(host);
1325
1326 host->ios.vdd = fls(ocr) - 1;
1327 host->ios.power_mode = MMC_POWER_UP;
1328
1329 mmc_set_initial_state(host);
1330
1331 mmc_set_initial_signal_voltage(host);
1332
1333
1334
1335
1336
1337 mmc_delay(host->ios.power_delay_ms);
1338
1339 mmc_pwrseq_post_power_on(host);
1340
1341 host->ios.clock = host->f_init;
1342
1343 host->ios.power_mode = MMC_POWER_ON;
1344 mmc_set_ios(host);
1345
1346
1347
1348
1349
1350 mmc_delay(host->ios.power_delay_ms);
1351}
1352
1353void mmc_power_off(struct mmc_host *host)
1354{
1355 if (host->ios.power_mode == MMC_POWER_OFF)
1356 return;
1357
1358 mmc_pwrseq_power_off(host);
1359
1360 host->ios.clock = 0;
1361 host->ios.vdd = 0;
1362
1363 host->ios.power_mode = MMC_POWER_OFF;
1364
1365 mmc_set_initial_state(host);
1366
1367
1368
1369
1370
1371
1372 mmc_delay(1);
1373}
1374
1375void mmc_power_cycle(struct mmc_host *host, u32 ocr)
1376{
1377 mmc_power_off(host);
1378
1379 mmc_delay(1);
1380 mmc_power_up(host, ocr);
1381}
1382
1383
1384
1385
1386
1387void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops)
1388{
1389 host->bus_ops = ops;
1390}
1391
1392
1393
1394
1395void mmc_detach_bus(struct mmc_host *host)
1396{
1397 host->bus_ops = NULL;
1398}
1399
1400void _mmc_detect_change(struct mmc_host *host, unsigned long delay, bool cd_irq)
1401{
1402
1403
1404
1405
1406
1407 if (cd_irq && !(host->caps & MMC_CAP_NEEDS_POLL))
1408 __pm_wakeup_event(host->ws, 5000);
1409
1410 host->detect_change = 1;
1411 mmc_schedule_delayed_work(&host->detect, delay);
1412}
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424void mmc_detect_change(struct mmc_host *host, unsigned long delay)
1425{
1426 _mmc_detect_change(host, delay, true);
1427}
1428EXPORT_SYMBOL(mmc_detect_change);
1429
1430void mmc_init_erase(struct mmc_card *card)
1431{
1432 unsigned int sz;
1433
1434 if (is_power_of_2(card->erase_size))
1435 card->erase_shift = ffs(card->erase_size) - 1;
1436 else
1437 card->erase_shift = 0;
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454 if (mmc_card_sd(card) && card->ssr.au) {
1455 card->pref_erase = card->ssr.au;
1456 card->erase_shift = ffs(card->ssr.au) - 1;
1457 } else if (card->erase_size) {
1458 sz = (card->csd.capacity << (card->csd.read_blkbits - 9)) >> 11;
1459 if (sz < 128)
1460 card->pref_erase = 512 * 1024 / 512;
1461 else if (sz < 512)
1462 card->pref_erase = 1024 * 1024 / 512;
1463 else if (sz < 1024)
1464 card->pref_erase = 2 * 1024 * 1024 / 512;
1465 else
1466 card->pref_erase = 4 * 1024 * 1024 / 512;
1467 if (card->pref_erase < card->erase_size)
1468 card->pref_erase = card->erase_size;
1469 else {
1470 sz = card->pref_erase % card->erase_size;
1471 if (sz)
1472 card->pref_erase += card->erase_size - sz;
1473 }
1474 } else
1475 card->pref_erase = 0;
1476}
1477
1478static unsigned int mmc_mmc_erase_timeout(struct mmc_card *card,
1479 unsigned int arg, unsigned int qty)
1480{
1481 unsigned int erase_timeout;
1482
1483 if (arg == MMC_DISCARD_ARG ||
1484 (arg == MMC_TRIM_ARG && card->ext_csd.rev >= 6)) {
1485 erase_timeout = card->ext_csd.trim_timeout;
1486 } else if (card->ext_csd.erase_group_def & 1) {
1487
1488 if (arg == MMC_TRIM_ARG)
1489 erase_timeout = card->ext_csd.trim_timeout;
1490 else
1491 erase_timeout = card->ext_csd.hc_erase_timeout;
1492 } else {
1493
1494 unsigned int mult = (10 << card->csd.r2w_factor);
1495 unsigned int timeout_clks = card->csd.taac_clks * mult;
1496 unsigned int timeout_us;
1497
1498
1499 if (card->csd.taac_ns < 1000000)
1500 timeout_us = (card->csd.taac_ns * mult) / 1000;
1501 else
1502 timeout_us = (card->csd.taac_ns / 1000) * mult;
1503
1504
1505
1506
1507
1508 timeout_clks <<= 1;
1509 timeout_us += (timeout_clks * 1000) /
1510 (card->host->ios.clock / 1000);
1511
1512 erase_timeout = timeout_us / 1000;
1513
1514
1515
1516
1517
1518 if (!erase_timeout)
1519 erase_timeout = 1;
1520 }
1521
1522
1523 if (arg & MMC_SECURE_ARGS) {
1524 if (arg == MMC_SECURE_ERASE_ARG)
1525 erase_timeout *= card->ext_csd.sec_erase_mult;
1526 else
1527 erase_timeout *= card->ext_csd.sec_trim_mult;
1528 }
1529
1530 erase_timeout *= qty;
1531
1532
1533
1534
1535
1536 if (mmc_host_is_spi(card->host) && erase_timeout < 1000)
1537 erase_timeout = 1000;
1538
1539 return erase_timeout;
1540}
1541
1542static unsigned int mmc_sd_erase_timeout(struct mmc_card *card,
1543 unsigned int arg,
1544 unsigned int qty)
1545{
1546 unsigned int erase_timeout;
1547
1548
1549
1550
1551 if (arg == SD_DISCARD_ARG)
1552 return SD_DISCARD_TIMEOUT_MS;
1553
1554 if (card->ssr.erase_timeout) {
1555
1556 erase_timeout = card->ssr.erase_timeout * qty +
1557 card->ssr.erase_offset;
1558 } else {
1559
1560
1561
1562
1563 erase_timeout = 250 * qty;
1564 }
1565
1566
1567 if (erase_timeout < 1000)
1568 erase_timeout = 1000;
1569
1570 return erase_timeout;
1571}
1572
1573static unsigned int mmc_erase_timeout(struct mmc_card *card,
1574 unsigned int arg,
1575 unsigned int qty)
1576{
1577 if (mmc_card_sd(card))
1578 return mmc_sd_erase_timeout(card, arg, qty);
1579 else
1580 return mmc_mmc_erase_timeout(card, arg, qty);
1581}
1582
1583static int mmc_do_erase(struct mmc_card *card, unsigned int from,
1584 unsigned int to, unsigned int arg)
1585{
1586 struct mmc_command cmd = {};
1587 unsigned int qty = 0, busy_timeout = 0;
1588 bool use_r1b_resp;
1589 int err;
1590
1591 mmc_retune_hold(card->host);
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609 if (card->erase_shift)
1610 qty += ((to >> card->erase_shift) -
1611 (from >> card->erase_shift)) + 1;
1612 else if (mmc_card_sd(card))
1613 qty += to - from + 1;
1614 else
1615 qty += ((to / card->erase_size) -
1616 (from / card->erase_size)) + 1;
1617
1618 if (!mmc_card_blockaddr(card)) {
1619 from <<= 9;
1620 to <<= 9;
1621 }
1622
1623 if (mmc_card_sd(card))
1624 cmd.opcode = SD_ERASE_WR_BLK_START;
1625 else
1626 cmd.opcode = MMC_ERASE_GROUP_START;
1627 cmd.arg = from;
1628 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
1629 err = mmc_wait_for_cmd(card->host, &cmd, 0);
1630 if (err) {
1631 pr_err("mmc_erase: group start error %d, "
1632 "status %#x\n", err, cmd.resp[0]);
1633 err = -EIO;
1634 goto out;
1635 }
1636
1637 memset(&cmd, 0, sizeof(struct mmc_command));
1638 if (mmc_card_sd(card))
1639 cmd.opcode = SD_ERASE_WR_BLK_END;
1640 else
1641 cmd.opcode = MMC_ERASE_GROUP_END;
1642 cmd.arg = to;
1643 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
1644 err = mmc_wait_for_cmd(card->host, &cmd, 0);
1645 if (err) {
1646 pr_err("mmc_erase: group end error %d, status %#x\n",
1647 err, cmd.resp[0]);
1648 err = -EIO;
1649 goto out;
1650 }
1651
1652 memset(&cmd, 0, sizeof(struct mmc_command));
1653 cmd.opcode = MMC_ERASE;
1654 cmd.arg = arg;
1655 busy_timeout = mmc_erase_timeout(card, arg, qty);
1656 use_r1b_resp = mmc_prepare_busy_cmd(card->host, &cmd, busy_timeout);
1657
1658 err = mmc_wait_for_cmd(card->host, &cmd, 0);
1659 if (err) {
1660 pr_err("mmc_erase: erase error %d, status %#x\n",
1661 err, cmd.resp[0]);
1662 err = -EIO;
1663 goto out;
1664 }
1665
1666 if (mmc_host_is_spi(card->host))
1667 goto out;
1668
1669
1670
1671
1672
1673 if ((card->host->caps & MMC_CAP_WAIT_WHILE_BUSY) && use_r1b_resp)
1674 goto out;
1675
1676
1677 err = mmc_poll_for_busy(card, busy_timeout, false, MMC_BUSY_ERASE);
1678
1679out:
1680 mmc_retune_release(card->host);
1681 return err;
1682}
1683
1684static unsigned int mmc_align_erase_size(struct mmc_card *card,
1685 unsigned int *from,
1686 unsigned int *to,
1687 unsigned int nr)
1688{
1689 unsigned int from_new = *from, nr_new = nr, rem;
1690
1691
1692
1693
1694
1695 if (is_power_of_2(card->erase_size)) {
1696 unsigned int temp = from_new;
1697
1698 from_new = round_up(temp, card->erase_size);
1699 rem = from_new - temp;
1700
1701 if (nr_new > rem)
1702 nr_new -= rem;
1703 else
1704 return 0;
1705
1706 nr_new = round_down(nr_new, card->erase_size);
1707 } else {
1708 rem = from_new % card->erase_size;
1709 if (rem) {
1710 rem = card->erase_size - rem;
1711 from_new += rem;
1712 if (nr_new > rem)
1713 nr_new -= rem;
1714 else
1715 return 0;
1716 }
1717
1718 rem = nr_new % card->erase_size;
1719 if (rem)
1720 nr_new -= rem;
1721 }
1722
1723 if (nr_new == 0)
1724 return 0;
1725
1726 *to = from_new + nr_new;
1727 *from = from_new;
1728
1729 return nr_new;
1730}
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741int mmc_erase(struct mmc_card *card, unsigned int from, unsigned int nr,
1742 unsigned int arg)
1743{
1744 unsigned int rem, to = from + nr;
1745 int err;
1746
1747 if (!(card->csd.cmdclass & CCC_ERASE))
1748 return -EOPNOTSUPP;
1749
1750 if (!card->erase_size)
1751 return -EOPNOTSUPP;
1752
1753 if (mmc_card_sd(card) && arg != SD_ERASE_ARG && arg != SD_DISCARD_ARG)
1754 return -EOPNOTSUPP;
1755
1756 if (mmc_card_mmc(card) && (arg & MMC_SECURE_ARGS) &&
1757 !(card->ext_csd.sec_feature_support & EXT_CSD_SEC_ER_EN))
1758 return -EOPNOTSUPP;
1759
1760 if (mmc_card_mmc(card) && (arg & MMC_TRIM_ARGS) &&
1761 !(card->ext_csd.sec_feature_support & EXT_CSD_SEC_GB_CL_EN))
1762 return -EOPNOTSUPP;
1763
1764 if (arg == MMC_SECURE_ERASE_ARG) {
1765 if (from % card->erase_size || nr % card->erase_size)
1766 return -EINVAL;
1767 }
1768
1769 if (arg == MMC_ERASE_ARG)
1770 nr = mmc_align_erase_size(card, &from, &to, nr);
1771
1772 if (nr == 0)
1773 return 0;
1774
1775 if (to <= from)
1776 return -EINVAL;
1777
1778
1779 to -= 1;
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789 rem = card->erase_size - (from % card->erase_size);
1790 if ((arg & MMC_TRIM_ARGS) && (card->eg_boundary) && (nr > rem)) {
1791 err = mmc_do_erase(card, from, from + rem - 1, arg);
1792 from += rem;
1793 if ((err) || (to <= from))
1794 return err;
1795 }
1796
1797 return mmc_do_erase(card, from, to, arg);
1798}
1799EXPORT_SYMBOL(mmc_erase);
1800
1801int mmc_can_erase(struct mmc_card *card)
1802{
1803 if (card->csd.cmdclass & CCC_ERASE && card->erase_size)
1804 return 1;
1805 return 0;
1806}
1807EXPORT_SYMBOL(mmc_can_erase);
1808
1809int mmc_can_trim(struct mmc_card *card)
1810{
1811 if ((card->ext_csd.sec_feature_support & EXT_CSD_SEC_GB_CL_EN) &&
1812 (!(card->quirks & MMC_QUIRK_TRIM_BROKEN)))
1813 return 1;
1814 return 0;
1815}
1816EXPORT_SYMBOL(mmc_can_trim);
1817
1818int mmc_can_discard(struct mmc_card *card)
1819{
1820
1821
1822
1823
1824 if (card->ext_csd.feature_support & MMC_DISCARD_FEATURE)
1825 return 1;
1826 return 0;
1827}
1828EXPORT_SYMBOL(mmc_can_discard);
1829
1830int mmc_can_sanitize(struct mmc_card *card)
1831{
1832 if (!mmc_can_trim(card) && !mmc_can_erase(card))
1833 return 0;
1834 if (card->ext_csd.sec_feature_support & EXT_CSD_SEC_SANITIZE)
1835 return 1;
1836 return 0;
1837}
1838
1839int mmc_can_secure_erase_trim(struct mmc_card *card)
1840{
1841 if ((card->ext_csd.sec_feature_support & EXT_CSD_SEC_ER_EN) &&
1842 !(card->quirks & MMC_QUIRK_SEC_ERASE_TRIM_BROKEN))
1843 return 1;
1844 return 0;
1845}
1846EXPORT_SYMBOL(mmc_can_secure_erase_trim);
1847
1848int mmc_erase_group_aligned(struct mmc_card *card, unsigned int from,
1849 unsigned int nr)
1850{
1851 if (!card->erase_size)
1852 return 0;
1853 if (from % card->erase_size || nr % card->erase_size)
1854 return 0;
1855 return 1;
1856}
1857EXPORT_SYMBOL(mmc_erase_group_aligned);
1858
1859static unsigned int mmc_do_calc_max_discard(struct mmc_card *card,
1860 unsigned int arg)
1861{
1862 struct mmc_host *host = card->host;
1863 unsigned int max_discard, x, y, qty = 0, max_qty, min_qty, timeout;
1864 unsigned int last_timeout = 0;
1865 unsigned int max_busy_timeout = host->max_busy_timeout ?
1866 host->max_busy_timeout : MMC_ERASE_TIMEOUT_MS;
1867
1868 if (card->erase_shift) {
1869 max_qty = UINT_MAX >> card->erase_shift;
1870 min_qty = card->pref_erase >> card->erase_shift;
1871 } else if (mmc_card_sd(card)) {
1872 max_qty = UINT_MAX;
1873 min_qty = card->pref_erase;
1874 } else {
1875 max_qty = UINT_MAX / card->erase_size;
1876 min_qty = card->pref_erase / card->erase_size;
1877 }
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892 do {
1893 y = 0;
1894 for (x = 1; x && x <= max_qty && max_qty - x >= qty; x <<= 1) {
1895 timeout = mmc_erase_timeout(card, arg, qty + x);
1896
1897 if (qty + x > min_qty && timeout > max_busy_timeout)
1898 break;
1899
1900 if (timeout < last_timeout)
1901 break;
1902 last_timeout = timeout;
1903 y = x;
1904 }
1905 qty += y;
1906 } while (y);
1907
1908 if (!qty)
1909 return 0;
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921 if (qty == 1)
1922 card->eg_boundary = 1;
1923 else
1924 qty--;
1925
1926
1927 if (card->erase_shift)
1928 max_discard = qty << card->erase_shift;
1929 else if (mmc_card_sd(card))
1930 max_discard = qty + 1;
1931 else
1932 max_discard = qty * card->erase_size;
1933
1934 return max_discard;
1935}
1936
1937unsigned int mmc_calc_max_discard(struct mmc_card *card)
1938{
1939 struct mmc_host *host = card->host;
1940 unsigned int max_discard, max_trim;
1941
1942
1943
1944
1945
1946
1947 if (mmc_card_mmc(card) && !(card->ext_csd.erase_group_def & 1))
1948 return card->pref_erase;
1949
1950 max_discard = mmc_do_calc_max_discard(card, MMC_ERASE_ARG);
1951 if (mmc_can_trim(card)) {
1952 max_trim = mmc_do_calc_max_discard(card, MMC_TRIM_ARG);
1953 if (max_trim < max_discard || max_discard == 0)
1954 max_discard = max_trim;
1955 } else if (max_discard < card->erase_size) {
1956 max_discard = 0;
1957 }
1958 pr_debug("%s: calculated max. discard sectors %u for timeout %u ms\n",
1959 mmc_hostname(host), max_discard, host->max_busy_timeout ?
1960 host->max_busy_timeout : MMC_ERASE_TIMEOUT_MS);
1961 return max_discard;
1962}
1963EXPORT_SYMBOL(mmc_calc_max_discard);
1964
1965bool mmc_card_is_blockaddr(struct mmc_card *card)
1966{
1967 return card ? mmc_card_blockaddr(card) : false;
1968}
1969EXPORT_SYMBOL(mmc_card_is_blockaddr);
1970
1971int mmc_set_blocklen(struct mmc_card *card, unsigned int blocklen)
1972{
1973 struct mmc_command cmd = {};
1974
1975 if (mmc_card_blockaddr(card) || mmc_card_ddr52(card) ||
1976 mmc_card_hs400(card) || mmc_card_hs400es(card))
1977 return 0;
1978
1979 cmd.opcode = MMC_SET_BLOCKLEN;
1980 cmd.arg = blocklen;
1981 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
1982 return mmc_wait_for_cmd(card->host, &cmd, 5);
1983}
1984EXPORT_SYMBOL(mmc_set_blocklen);
1985
1986static void mmc_hw_reset_for_init(struct mmc_host *host)
1987{
1988 mmc_pwrseq_reset(host);
1989
1990 if (!(host->caps & MMC_CAP_HW_RESET) || !host->ops->hw_reset)
1991 return;
1992 host->ops->hw_reset(host);
1993}
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005int mmc_hw_reset(struct mmc_host *host)
2006{
2007 int ret;
2008
2009 ret = host->bus_ops->hw_reset(host);
2010 if (ret < 0)
2011 pr_warn("%s: tried to HW reset card, got error %d\n",
2012 mmc_hostname(host), ret);
2013
2014 return ret;
2015}
2016EXPORT_SYMBOL(mmc_hw_reset);
2017
2018int mmc_sw_reset(struct mmc_host *host)
2019{
2020 int ret;
2021
2022 if (!host->bus_ops->sw_reset)
2023 return -EOPNOTSUPP;
2024
2025 ret = host->bus_ops->sw_reset(host);
2026 if (ret)
2027 pr_warn("%s: tried to SW reset card, got error %d\n",
2028 mmc_hostname(host), ret);
2029
2030 return ret;
2031}
2032EXPORT_SYMBOL(mmc_sw_reset);
2033
2034static int mmc_rescan_try_freq(struct mmc_host *host, unsigned freq)
2035{
2036 host->f_init = freq;
2037
2038 pr_debug("%s: %s: trying to init card at %u Hz\n",
2039 mmc_hostname(host), __func__, host->f_init);
2040
2041 mmc_power_up(host, host->ocr_avail);
2042
2043
2044
2045
2046
2047 mmc_hw_reset_for_init(host);
2048
2049
2050
2051
2052
2053
2054
2055 if (!(host->caps2 & MMC_CAP2_NO_SDIO))
2056 sdio_reset(host);
2057
2058 mmc_go_idle(host);
2059
2060 if (!(host->caps2 & MMC_CAP2_NO_SD)) {
2061 if (mmc_send_if_cond_pcie(host, host->ocr_avail))
2062 goto out;
2063 if (mmc_card_sd_express(host))
2064 return 0;
2065 }
2066
2067
2068 if (!(host->caps2 & MMC_CAP2_NO_SDIO))
2069 if (!mmc_attach_sdio(host))
2070 return 0;
2071
2072 if (!(host->caps2 & MMC_CAP2_NO_SD))
2073 if (!mmc_attach_sd(host))
2074 return 0;
2075
2076 if (!(host->caps2 & MMC_CAP2_NO_MMC))
2077 if (!mmc_attach_mmc(host))
2078 return 0;
2079
2080out:
2081 mmc_power_off(host);
2082 return -EIO;
2083}
2084
2085int _mmc_detect_card_removed(struct mmc_host *host)
2086{
2087 int ret;
2088
2089 if (!host->card || mmc_card_removed(host->card))
2090 return 1;
2091
2092 ret = host->bus_ops->alive(host);
2093
2094
2095
2096
2097
2098
2099
2100
2101 if (!ret && host->ops->get_cd && !host->ops->get_cd(host)) {
2102 mmc_detect_change(host, msecs_to_jiffies(200));
2103 pr_debug("%s: card removed too slowly\n", mmc_hostname(host));
2104 }
2105
2106 if (ret) {
2107 mmc_card_set_removed(host->card);
2108 pr_debug("%s: card remove detected\n", mmc_hostname(host));
2109 }
2110
2111 return ret;
2112}
2113
2114int mmc_detect_card_removed(struct mmc_host *host)
2115{
2116 struct mmc_card *card = host->card;
2117 int ret;
2118
2119 WARN_ON(!host->claimed);
2120
2121 if (!card)
2122 return 1;
2123
2124 if (!mmc_card_is_removable(host))
2125 return 0;
2126
2127 ret = mmc_card_removed(card);
2128
2129
2130
2131
2132 if (!host->detect_change && !(host->caps & MMC_CAP_NEEDS_POLL))
2133 return ret;
2134
2135 host->detect_change = 0;
2136 if (!ret) {
2137 ret = _mmc_detect_card_removed(host);
2138 if (ret && (host->caps & MMC_CAP_NEEDS_POLL)) {
2139
2140
2141
2142
2143 cancel_delayed_work(&host->detect);
2144 _mmc_detect_change(host, 0, false);
2145 }
2146 }
2147
2148 return ret;
2149}
2150EXPORT_SYMBOL(mmc_detect_card_removed);
2151
2152void mmc_rescan(struct work_struct *work)
2153{
2154 struct mmc_host *host =
2155 container_of(work, struct mmc_host, detect.work);
2156 int i;
2157
2158 if (host->rescan_disable)
2159 return;
2160
2161
2162 if (!mmc_card_is_removable(host) && host->rescan_entered)
2163 return;
2164 host->rescan_entered = 1;
2165
2166 if (host->trigger_card_event && host->ops->card_event) {
2167 mmc_claim_host(host);
2168 host->ops->card_event(host);
2169 mmc_release_host(host);
2170 host->trigger_card_event = false;
2171 }
2172
2173
2174 if (host->bus_ops)
2175 host->bus_ops->detect(host);
2176
2177 host->detect_change = 0;
2178
2179
2180 if (host->bus_ops != NULL)
2181 goto out;
2182
2183 mmc_claim_host(host);
2184 if (mmc_card_is_removable(host) && host->ops->get_cd &&
2185 host->ops->get_cd(host) == 0) {
2186 mmc_power_off(host);
2187 mmc_release_host(host);
2188 goto out;
2189 }
2190
2191
2192 if (mmc_card_sd_express(host)) {
2193 mmc_release_host(host);
2194 goto out;
2195 }
2196
2197 for (i = 0; i < ARRAY_SIZE(freqs); i++) {
2198 unsigned int freq = freqs[i];
2199 if (freq > host->f_max) {
2200 if (i + 1 < ARRAY_SIZE(freqs))
2201 continue;
2202 freq = host->f_max;
2203 }
2204 if (!mmc_rescan_try_freq(host, max(freq, host->f_min)))
2205 break;
2206 if (freqs[i] <= host->f_min)
2207 break;
2208 }
2209 mmc_release_host(host);
2210
2211 out:
2212 if (host->caps & MMC_CAP_NEEDS_POLL)
2213 mmc_schedule_delayed_work(&host->detect, HZ);
2214}
2215
2216void mmc_start_host(struct mmc_host *host)
2217{
2218 host->f_init = max(min(freqs[0], host->f_max), host->f_min);
2219 host->rescan_disable = 0;
2220
2221 if (!(host->caps2 & MMC_CAP2_NO_PRESCAN_POWERUP)) {
2222 mmc_claim_host(host);
2223 mmc_power_up(host, host->ocr_avail);
2224 mmc_release_host(host);
2225 }
2226
2227 mmc_gpiod_request_cd_irq(host);
2228 _mmc_detect_change(host, 0, false);
2229}
2230
2231void mmc_stop_host(struct mmc_host *host)
2232{
2233 if (host->slot.cd_irq >= 0) {
2234 mmc_gpio_set_cd_wake(host, false);
2235 disable_irq(host->slot.cd_irq);
2236 }
2237
2238 host->rescan_disable = 1;
2239 cancel_delayed_work_sync(&host->detect);
2240
2241
2242 host->pm_flags = 0;
2243
2244 if (host->bus_ops) {
2245
2246 host->bus_ops->remove(host);
2247 mmc_claim_host(host);
2248 mmc_detach_bus(host);
2249 mmc_power_off(host);
2250 mmc_release_host(host);
2251 return;
2252 }
2253
2254 mmc_claim_host(host);
2255 mmc_power_off(host);
2256 mmc_release_host(host);
2257}
2258
2259static int __init mmc_init(void)
2260{
2261 int ret;
2262
2263 ret = mmc_register_bus();
2264 if (ret)
2265 return ret;
2266
2267 ret = mmc_register_host_class();
2268 if (ret)
2269 goto unregister_bus;
2270
2271 ret = sdio_register_bus();
2272 if (ret)
2273 goto unregister_host_class;
2274
2275 return 0;
2276
2277unregister_host_class:
2278 mmc_unregister_host_class();
2279unregister_bus:
2280 mmc_unregister_bus();
2281 return ret;
2282}
2283
2284static void __exit mmc_exit(void)
2285{
2286 sdio_unregister_bus();
2287 mmc_unregister_host_class();
2288 mmc_unregister_bus();
2289}
2290
2291subsys_initcall(mmc_init);
2292module_exit(mmc_exit);
2293
2294MODULE_LICENSE("GPL");
2295