1 /* 2 * linux/drivers/mmc/core/core.c 3 * 4 * Copyright (C) 2003-2004 Russell King, All Rights Reserved. 5 * SD support Copyright (C) 2004 Ian Molton, All Rights Reserved. 6 * Copyright (C) 2005-2008 Pierre Ossman, All Rights Reserved. 7 * MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved. 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License version 2 as 11 * published by the Free Software Foundation. 12 */ 13 #include <linux/module.h> 14 #include <linux/init.h> 15 #include <linux/interrupt.h> 16 #include <linux/completion.h> 17 #include <linux/device.h> 18 #include <linux/delay.h> 19 #include <linux/pagemap.h> 20 #include <linux/err.h> 21 #include <linux/leds.h> 22 #include <linux/scatterlist.h> 23 #include <linux/log2.h> 24 #include <linux/regulator/consumer.h> 25 #include <linux/pm_runtime.h> 26 #include <linux/pm_wakeup.h> 27 #include <linux/suspend.h> 28 #include <linux/fault-inject.h> 29 #include <linux/random.h> 30 #include <linux/slab.h> 31 #include <linux/of.h> 32 33 #include <linux/mmc/card.h> 34 #include <linux/mmc/host.h> 35 #include <linux/mmc/mmc.h> 36 #include <linux/mmc/sd.h> 37 #include <linux/mmc/slot-gpio.h> 38 39 #include "core.h" 40 #include "bus.h" 41 #include "host.h" 42 #include "sdio_bus.h" 43 #include "pwrseq.h" 44 45 #include "mmc_ops.h" 46 #include "sd_ops.h" 47 #include "sdio_ops.h" 48 49 /* If the device is not responding */ 50 #define MMC_CORE_TIMEOUT_MS (10 * 60 * 1000) /* 10 minute timeout */ 51 52 /* 53 * Background operations can take a long time, depending on the housekeeping 54 * operations the card has to perform. 55 */ 56 #define MMC_BKOPS_MAX_TIMEOUT (4 * 60 * 1000) /* max time to wait in ms */ 57 58 static struct workqueue_struct *workqueue; 59 static const unsigned freqs[] = { 400000, 300000, 200000, 100000 }; 60 61 /* 62 * Enabling software CRCs on the data blocks can be a significant (30%) 63 * performance cost, and for other reasons may not always be desired. 64 * So we allow it it to be disabled. 65 */ 66 bool use_spi_crc = 1; 67 module_param(use_spi_crc, bool, 0); 68 69 /* 70 * Internal function. Schedule delayed work in the MMC work queue. 71 */ 72 static int mmc_schedule_delayed_work(struct delayed_work *work, 73 unsigned long delay) 74 { 75 return queue_delayed_work(workqueue, work, delay); 76 } 77 78 /* 79 * Internal function. Flush all scheduled work from the MMC work queue. 80 */ 81 static void mmc_flush_scheduled_work(void) 82 { 83 flush_workqueue(workqueue); 84 } 85 86 #ifdef CONFIG_FAIL_MMC_REQUEST 87 88 /* 89 * Internal function. Inject random data errors. 90 * If mmc_data is NULL no errors are injected. 91 */ 92 static void mmc_should_fail_request(struct mmc_host *host, 93 struct mmc_request *mrq) 94 { 95 struct mmc_command *cmd = mrq->cmd; 96 struct mmc_data *data = mrq->data; 97 static const int data_errors[] = { 98 -ETIMEDOUT, 99 -EILSEQ, 100 -EIO, 101 }; 102 103 if (!data) 104 return; 105 106 if (cmd->error || data->error || 107 !should_fail(&host->fail_mmc_request, data->blksz * data->blocks)) 108 return; 109 110 data->error = data_errors[prandom_u32() % ARRAY_SIZE(data_errors)]; 111 data->bytes_xfered = (prandom_u32() % (data->bytes_xfered >> 9)) << 9; 112 } 113 114 #else /* CONFIG_FAIL_MMC_REQUEST */ 115 116 static inline void mmc_should_fail_request(struct mmc_host *host, 117 struct mmc_request *mrq) 118 { 119 } 120 121 #endif /* CONFIG_FAIL_MMC_REQUEST */ 122 123 /** 124 * mmc_request_done - finish processing an MMC request 125 * @host: MMC host which completed request 126 * @mrq: MMC request which request 127 * 128 * MMC drivers should call this function when they have completed 129 * their processing of a request. 130 */ 131 void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq) 132 { 133 struct mmc_command *cmd = mrq->cmd; 134 int err = cmd->error; 135 136 if (err && cmd->retries && mmc_host_is_spi(host)) { 137 if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND) 138 cmd->retries = 0; 139 } 140 141 if (err && cmd->retries && !mmc_card_removed(host->card)) { 142 /* 143 * Request starter must handle retries - see 144 * mmc_wait_for_req_done(). 145 */ 146 if (mrq->done) 147 mrq->done(mrq); 148 } else { 149 mmc_should_fail_request(host, mrq); 150 151 led_trigger_event(host->led, LED_OFF); 152 153 if (mrq->sbc) { 154 pr_debug("%s: req done <CMD%u>: %d: %08x %08x %08x %08x\n", 155 mmc_hostname(host), mrq->sbc->opcode, 156 mrq->sbc->error, 157 mrq->sbc->resp[0], mrq->sbc->resp[1], 158 mrq->sbc->resp[2], mrq->sbc->resp[3]); 159 } 160 161 pr_debug("%s: req done (CMD%u): %d: %08x %08x %08x %08x\n", 162 mmc_hostname(host), cmd->opcode, err, 163 cmd->resp[0], cmd->resp[1], 164 cmd->resp[2], cmd->resp[3]); 165 166 if (mrq->data) { 167 pr_debug("%s: %d bytes transferred: %d\n", 168 mmc_hostname(host), 169 mrq->data->bytes_xfered, mrq->data->error); 170 } 171 172 if (mrq->stop) { 173 pr_debug("%s: (CMD%u): %d: %08x %08x %08x %08x\n", 174 mmc_hostname(host), mrq->stop->opcode, 175 mrq->stop->error, 176 mrq->stop->resp[0], mrq->stop->resp[1], 177 mrq->stop->resp[2], mrq->stop->resp[3]); 178 } 179 180 if (mrq->done) 181 mrq->done(mrq); 182 183 mmc_host_clk_release(host); 184 } 185 } 186 187 EXPORT_SYMBOL(mmc_request_done); 188 189 static int mmc_start_request(struct mmc_host *host, struct mmc_request *mrq) 190 { 191 #ifdef CONFIG_MMC_DEBUG 192 unsigned int i, sz; 193 struct scatterlist *sg; 194 #endif 195 if (mmc_card_removed(host->card)) 196 return -ENOMEDIUM; 197 198 if (mrq->sbc) { 199 pr_debug("<%s: starting CMD%u arg %08x flags %08x>\n", 200 mmc_hostname(host), mrq->sbc->opcode, 201 mrq->sbc->arg, mrq->sbc->flags); 202 } 203 204 pr_debug("%s: starting CMD%u arg %08x flags %08x\n", 205 mmc_hostname(host), mrq->cmd->opcode, 206 mrq->cmd->arg, mrq->cmd->flags); 207 208 if (mrq->data) { 209 pr_debug("%s: blksz %d blocks %d flags %08x " 210 "tsac %d ms nsac %d\n", 211 mmc_hostname(host), mrq->data->blksz, 212 mrq->data->blocks, mrq->data->flags, 213 mrq->data->timeout_ns / 1000000, 214 mrq->data->timeout_clks); 215 } 216 217 if (mrq->stop) { 218 pr_debug("%s: CMD%u arg %08x flags %08x\n", 219 mmc_hostname(host), mrq->stop->opcode, 220 mrq->stop->arg, mrq->stop->flags); 221 } 222 223 WARN_ON(!host->claimed); 224 225 mrq->cmd->error = 0; 226 mrq->cmd->mrq = mrq; 227 if (mrq->sbc) { 228 mrq->sbc->error = 0; 229 mrq->sbc->mrq = mrq; 230 } 231 if (mrq->data) { 232 BUG_ON(mrq->data->blksz > host->max_blk_size); 233 BUG_ON(mrq->data->blocks > host->max_blk_count); 234 BUG_ON(mrq->data->blocks * mrq->data->blksz > 235 host->max_req_size); 236 237 #ifdef CONFIG_MMC_DEBUG 238 sz = 0; 239 for_each_sg(mrq->data->sg, sg, mrq->data->sg_len, i) 240 sz += sg->length; 241 BUG_ON(sz != mrq->data->blocks * mrq->data->blksz); 242 #endif 243 244 mrq->cmd->data = mrq->data; 245 mrq->data->error = 0; 246 mrq->data->mrq = mrq; 247 if (mrq->stop) { 248 mrq->data->stop = mrq->stop; 249 mrq->stop->error = 0; 250 mrq->stop->mrq = mrq; 251 } 252 } 253 mmc_host_clk_hold(host); 254 led_trigger_event(host->led, LED_FULL); 255 host->ops->request(host, mrq); 256 257 return 0; 258 } 259 260 /** 261 * mmc_start_bkops - start BKOPS for supported cards 262 * @card: MMC card to start BKOPS 263 * @form_exception: A flag to indicate if this function was 264 * called due to an exception raised by the card 265 * 266 * Start background operations whenever requested. 267 * When the urgent BKOPS bit is set in a R1 command response 268 * then background operations should be started immediately. 269 */ 270 void mmc_start_bkops(struct mmc_card *card, bool from_exception) 271 { 272 int err; 273 int timeout; 274 bool use_busy_signal; 275 276 BUG_ON(!card); 277 278 if (!card->ext_csd.man_bkops_en || mmc_card_doing_bkops(card)) 279 return; 280 281 err = mmc_read_bkops_status(card); 282 if (err) { 283 pr_err("%s: Failed to read bkops status: %d\n", 284 mmc_hostname(card->host), err); 285 return; 286 } 287 288 if (!card->ext_csd.raw_bkops_status) 289 return; 290 291 if (card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2 && 292 from_exception) 293 return; 294 295 mmc_claim_host(card->host); 296 if (card->ext_csd.raw_bkops_status >= EXT_CSD_BKOPS_LEVEL_2) { 297 timeout = MMC_BKOPS_MAX_TIMEOUT; 298 use_busy_signal = true; 299 } else { 300 timeout = 0; 301 use_busy_signal = false; 302 } 303 304 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 305 EXT_CSD_BKOPS_START, 1, timeout, 306 use_busy_signal, true, false); 307 if (err) { 308 pr_warn("%s: Error %d starting bkops\n", 309 mmc_hostname(card->host), err); 310 goto out; 311 } 312 313 /* 314 * For urgent bkops status (LEVEL_2 and more) 315 * bkops executed synchronously, otherwise 316 * the operation is in progress 317 */ 318 if (!use_busy_signal) 319 mmc_card_set_doing_bkops(card); 320 out: 321 mmc_release_host(card->host); 322 } 323 EXPORT_SYMBOL(mmc_start_bkops); 324 325 /* 326 * mmc_wait_data_done() - done callback for data request 327 * @mrq: done data request 328 * 329 * Wakes up mmc context, passed as a callback to host controller driver 330 */ 331 static void mmc_wait_data_done(struct mmc_request *mrq) 332 { 333 mrq->host->context_info.is_done_rcv = true; 334 wake_up_interruptible(&mrq->host->context_info.wait); 335 } 336 337 static void mmc_wait_done(struct mmc_request *mrq) 338 { 339 complete(&mrq->completion); 340 } 341 342 /* 343 *__mmc_start_data_req() - starts data request 344 * @host: MMC host to start the request 345 * @mrq: data request to start 346 * 347 * Sets the done callback to be called when request is completed by the card. 348 * Starts data mmc request execution 349 */ 350 static int __mmc_start_data_req(struct mmc_host *host, struct mmc_request *mrq) 351 { 352 int err; 353 354 mrq->done = mmc_wait_data_done; 355 mrq->host = host; 356 357 err = mmc_start_request(host, mrq); 358 if (err) { 359 mrq->cmd->error = err; 360 mmc_wait_data_done(mrq); 361 } 362 363 return err; 364 } 365 366 static int __mmc_start_req(struct mmc_host *host, struct mmc_request *mrq) 367 { 368 int err; 369 370 init_completion(&mrq->completion); 371 mrq->done = mmc_wait_done; 372 373 err = mmc_start_request(host, mrq); 374 if (err) { 375 mrq->cmd->error = err; 376 complete(&mrq->completion); 377 } 378 379 return err; 380 } 381 382 /* 383 * mmc_wait_for_data_req_done() - wait for request completed 384 * @host: MMC host to prepare the command. 385 * @mrq: MMC request to wait for 386 * 387 * Blocks MMC context till host controller will ack end of data request 388 * execution or new request notification arrives from the block layer. 389 * Handles command retries. 390 * 391 * Returns enum mmc_blk_status after checking errors. 392 */ 393 static int mmc_wait_for_data_req_done(struct mmc_host *host, 394 struct mmc_request *mrq, 395 struct mmc_async_req *next_req) 396 { 397 struct mmc_command *cmd; 398 struct mmc_context_info *context_info = &host->context_info; 399 int err; 400 unsigned long flags; 401 402 while (1) { 403 wait_event_interruptible(context_info->wait, 404 (context_info->is_done_rcv || 405 context_info->is_new_req)); 406 spin_lock_irqsave(&context_info->lock, flags); 407 context_info->is_waiting_last_req = false; 408 spin_unlock_irqrestore(&context_info->lock, flags); 409 if (context_info->is_done_rcv) { 410 context_info->is_done_rcv = false; 411 context_info->is_new_req = false; 412 cmd = mrq->cmd; 413 414 if (!cmd->error || !cmd->retries || 415 mmc_card_removed(host->card)) { 416 err = host->areq->err_check(host->card, 417 host->areq); 418 break; /* return err */ 419 } else { 420 pr_info("%s: req failed (CMD%u): %d, retrying...\n", 421 mmc_hostname(host), 422 cmd->opcode, cmd->error); 423 cmd->retries--; 424 cmd->error = 0; 425 host->ops->request(host, mrq); 426 continue; /* wait for done/new event again */ 427 } 428 } else if (context_info->is_new_req) { 429 context_info->is_new_req = false; 430 if (!next_req) { 431 err = MMC_BLK_NEW_REQUEST; 432 break; /* return err */ 433 } 434 } 435 } 436 return err; 437 } 438 439 static void mmc_wait_for_req_done(struct mmc_host *host, 440 struct mmc_request *mrq) 441 { 442 struct mmc_command *cmd; 443 444 while (1) { 445 wait_for_completion(&mrq->completion); 446 447 cmd = mrq->cmd; 448 449 /* 450 * If host has timed out waiting for the sanitize 451 * to complete, card might be still in programming state 452 * so let's try to bring the card out of programming 453 * state. 454 */ 455 if (cmd->sanitize_busy && cmd->error == -ETIMEDOUT) { 456 if (!mmc_interrupt_hpi(host->card)) { 457 pr_warn("%s: %s: Interrupted sanitize\n", 458 mmc_hostname(host), __func__); 459 cmd->error = 0; 460 break; 461 } else { 462 pr_err("%s: %s: Failed to interrupt sanitize\n", 463 mmc_hostname(host), __func__); 464 } 465 } 466 if (!cmd->error || !cmd->retries || 467 mmc_card_removed(host->card)) 468 break; 469 470 pr_debug("%s: req failed (CMD%u): %d, retrying...\n", 471 mmc_hostname(host), cmd->opcode, cmd->error); 472 cmd->retries--; 473 cmd->error = 0; 474 host->ops->request(host, mrq); 475 } 476 } 477 478 /** 479 * mmc_pre_req - Prepare for a new request 480 * @host: MMC host to prepare command 481 * @mrq: MMC request to prepare for 482 * @is_first_req: true if there is no previous started request 483 * that may run in parellel to this call, otherwise false 484 * 485 * mmc_pre_req() is called in prior to mmc_start_req() to let 486 * host prepare for the new request. Preparation of a request may be 487 * performed while another request is running on the host. 488 */ 489 static void mmc_pre_req(struct mmc_host *host, struct mmc_request *mrq, 490 bool is_first_req) 491 { 492 if (host->ops->pre_req) { 493 mmc_host_clk_hold(host); 494 host->ops->pre_req(host, mrq, is_first_req); 495 mmc_host_clk_release(host); 496 } 497 } 498 499 /** 500 * mmc_post_req - Post process a completed request 501 * @host: MMC host to post process command 502 * @mrq: MMC request to post process for 503 * @err: Error, if non zero, clean up any resources made in pre_req 504 * 505 * Let the host post process a completed request. Post processing of 506 * a request may be performed while another reuqest is running. 507 */ 508 static void mmc_post_req(struct mmc_host *host, struct mmc_request *mrq, 509 int err) 510 { 511 if (host->ops->post_req) { 512 mmc_host_clk_hold(host); 513 host->ops->post_req(host, mrq, err); 514 mmc_host_clk_release(host); 515 } 516 } 517 518 /** 519 * mmc_start_req - start a non-blocking request 520 * @host: MMC host to start command 521 * @areq: async request to start 522 * @error: out parameter returns 0 for success, otherwise non zero 523 * 524 * Start a new MMC custom command request for a host. 525 * If there is on ongoing async request wait for completion 526 * of that request and start the new one and return. 527 * Does not wait for the new request to complete. 528 * 529 * Returns the completed request, NULL in case of none completed. 530 * Wait for the an ongoing request (previoulsy started) to complete and 531 * return the completed request. If there is no ongoing request, NULL 532 * is returned without waiting. NULL is not an error condition. 533 */ 534 struct mmc_async_req *mmc_start_req(struct mmc_host *host, 535 struct mmc_async_req *areq, int *error) 536 { 537 int err = 0; 538 int start_err = 0; 539 struct mmc_async_req *data = host->areq; 540 541 /* Prepare a new request */ 542 if (areq) 543 mmc_pre_req(host, areq->mrq, !host->areq); 544 545 if (host->areq) { 546 err = mmc_wait_for_data_req_done(host, host->areq->mrq, areq); 547 if (err == MMC_BLK_NEW_REQUEST) { 548 if (error) 549 *error = err; 550 /* 551 * The previous request was not completed, 552 * nothing to return 553 */ 554 return NULL; 555 } 556 /* 557 * Check BKOPS urgency for each R1 response 558 */ 559 if (host->card && mmc_card_mmc(host->card) && 560 ((mmc_resp_type(host->areq->mrq->cmd) == MMC_RSP_R1) || 561 (mmc_resp_type(host->areq->mrq->cmd) == MMC_RSP_R1B)) && 562 (host->areq->mrq->cmd->resp[0] & R1_EXCEPTION_EVENT)) { 563 564 /* Cancel the prepared request */ 565 if (areq) 566 mmc_post_req(host, areq->mrq, -EINVAL); 567 568 mmc_start_bkops(host->card, true); 569 570 /* prepare the request again */ 571 if (areq) 572 mmc_pre_req(host, areq->mrq, !host->areq); 573 } 574 } 575 576 if (!err && areq) 577 start_err = __mmc_start_data_req(host, areq->mrq); 578 579 if (host->areq) 580 mmc_post_req(host, host->areq->mrq, 0); 581 582 /* Cancel a prepared request if it was not started. */ 583 if ((err || start_err) && areq) 584 mmc_post_req(host, areq->mrq, -EINVAL); 585 586 if (err) 587 host->areq = NULL; 588 else 589 host->areq = areq; 590 591 if (error) 592 *error = err; 593 return data; 594 } 595 EXPORT_SYMBOL(mmc_start_req); 596 597 /** 598 * mmc_wait_for_req - start a request and wait for completion 599 * @host: MMC host to start command 600 * @mrq: MMC request to start 601 * 602 * Start a new MMC custom command request for a host, and wait 603 * for the command to complete. Does not attempt to parse the 604 * response. 605 */ 606 void mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq) 607 { 608 __mmc_start_req(host, mrq); 609 mmc_wait_for_req_done(host, mrq); 610 } 611 EXPORT_SYMBOL(mmc_wait_for_req); 612 613 /** 614 * mmc_interrupt_hpi - Issue for High priority Interrupt 615 * @card: the MMC card associated with the HPI transfer 616 * 617 * Issued High Priority Interrupt, and check for card status 618 * until out-of prg-state. 619 */ 620 int mmc_interrupt_hpi(struct mmc_card *card) 621 { 622 int err; 623 u32 status; 624 unsigned long prg_wait; 625 626 BUG_ON(!card); 627 628 if (!card->ext_csd.hpi_en) { 629 pr_info("%s: HPI enable bit unset\n", mmc_hostname(card->host)); 630 return 1; 631 } 632 633 mmc_claim_host(card->host); 634 err = mmc_send_status(card, &status); 635 if (err) { 636 pr_err("%s: Get card status fail\n", mmc_hostname(card->host)); 637 goto out; 638 } 639 640 switch (R1_CURRENT_STATE(status)) { 641 case R1_STATE_IDLE: 642 case R1_STATE_READY: 643 case R1_STATE_STBY: 644 case R1_STATE_TRAN: 645 /* 646 * In idle and transfer states, HPI is not needed and the caller 647 * can issue the next intended command immediately 648 */ 649 goto out; 650 case R1_STATE_PRG: 651 break; 652 default: 653 /* In all other states, it's illegal to issue HPI */ 654 pr_debug("%s: HPI cannot be sent. Card state=%d\n", 655 mmc_hostname(card->host), R1_CURRENT_STATE(status)); 656 err = -EINVAL; 657 goto out; 658 } 659 660 err = mmc_send_hpi_cmd(card, &status); 661 if (err) 662 goto out; 663 664 prg_wait = jiffies + msecs_to_jiffies(card->ext_csd.out_of_int_time); 665 do { 666 err = mmc_send_status(card, &status); 667 668 if (!err && R1_CURRENT_STATE(status) == R1_STATE_TRAN) 669 break; 670 if (time_after(jiffies, prg_wait)) 671 err = -ETIMEDOUT; 672 } while (!err); 673 674 out: 675 mmc_release_host(card->host); 676 return err; 677 } 678 EXPORT_SYMBOL(mmc_interrupt_hpi); 679 680 /** 681 * mmc_wait_for_cmd - start a command and wait for completion 682 * @host: MMC host to start command 683 * @cmd: MMC command to start 684 * @retries: maximum number of retries 685 * 686 * Start a new MMC command for a host, and wait for the command 687 * to complete. Return any error that occurred while the command 688 * was executing. Do not attempt to parse the response. 689 */ 690 int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries) 691 { 692 struct mmc_request mrq = {NULL}; 693 694 WARN_ON(!host->claimed); 695 696 memset(cmd->resp, 0, sizeof(cmd->resp)); 697 cmd->retries = retries; 698 699 mrq.cmd = cmd; 700 cmd->data = NULL; 701 702 mmc_wait_for_req(host, &mrq); 703 704 return cmd->error; 705 } 706 707 EXPORT_SYMBOL(mmc_wait_for_cmd); 708 709 /** 710 * mmc_stop_bkops - stop ongoing BKOPS 711 * @card: MMC card to check BKOPS 712 * 713 * Send HPI command to stop ongoing background operations to 714 * allow rapid servicing of foreground operations, e.g. read/ 715 * writes. Wait until the card comes out of the programming state 716 * to avoid errors in servicing read/write requests. 717 */ 718 int mmc_stop_bkops(struct mmc_card *card) 719 { 720 int err = 0; 721 722 BUG_ON(!card); 723 err = mmc_interrupt_hpi(card); 724 725 /* 726 * If err is EINVAL, we can't issue an HPI. 727 * It should complete the BKOPS. 728 */ 729 if (!err || (err == -EINVAL)) { 730 mmc_card_clr_doing_bkops(card); 731 err = 0; 732 } 733 734 return err; 735 } 736 EXPORT_SYMBOL(mmc_stop_bkops); 737 738 int mmc_read_bkops_status(struct mmc_card *card) 739 { 740 int err; 741 u8 *ext_csd; 742 743 mmc_claim_host(card->host); 744 err = mmc_get_ext_csd(card, &ext_csd); 745 mmc_release_host(card->host); 746 if (err) 747 return err; 748 749 card->ext_csd.raw_bkops_status = ext_csd[EXT_CSD_BKOPS_STATUS]; 750 card->ext_csd.raw_exception_status = ext_csd[EXT_CSD_EXP_EVENTS_STATUS]; 751 kfree(ext_csd); 752 return 0; 753 } 754 EXPORT_SYMBOL(mmc_read_bkops_status); 755 756 /** 757 * mmc_set_data_timeout - set the timeout for a data command 758 * @data: data phase for command 759 * @card: the MMC card associated with the data transfer 760 * 761 * Computes the data timeout parameters according to the 762 * correct algorithm given the card type. 763 */ 764 void mmc_set_data_timeout(struct mmc_data *data, const struct mmc_card *card) 765 { 766 unsigned int mult; 767 768 /* 769 * SDIO cards only define an upper 1 s limit on access. 770 */ 771 if (mmc_card_sdio(card)) { 772 data->timeout_ns = 1000000000; 773 data->timeout_clks = 0; 774 return; 775 } 776 777 /* 778 * SD cards use a 100 multiplier rather than 10 779 */ 780 mult = mmc_card_sd(card) ? 100 : 10; 781 782 /* 783 * Scale up the multiplier (and therefore the timeout) by 784 * the r2w factor for writes. 785 */ 786 if (data->flags & MMC_DATA_WRITE) 787 mult <<= card->csd.r2w_factor; 788 789 data->timeout_ns = card->csd.tacc_ns * mult; 790 data->timeout_clks = card->csd.tacc_clks * mult; 791 792 /* 793 * SD cards also have an upper limit on the timeout. 794 */ 795 if (mmc_card_sd(card)) { 796 unsigned int timeout_us, limit_us; 797 798 timeout_us = data->timeout_ns / 1000; 799 if (mmc_host_clk_rate(card->host)) 800 timeout_us += data->timeout_clks * 1000 / 801 (mmc_host_clk_rate(card->host) / 1000); 802 803 if (data->flags & MMC_DATA_WRITE) 804 /* 805 * The MMC spec "It is strongly recommended 806 * for hosts to implement more than 500ms 807 * timeout value even if the card indicates 808 * the 250ms maximum busy length." Even the 809 * previous value of 300ms is known to be 810 * insufficient for some cards. 811 */ 812 limit_us = 3000000; 813 else 814 limit_us = 100000; 815 816 /* 817 * SDHC cards always use these fixed values. 818 */ 819 if (timeout_us > limit_us || mmc_card_blockaddr(card)) { 820 data->timeout_ns = limit_us * 1000; 821 data->timeout_clks = 0; 822 } 823 824 /* assign limit value if invalid */ 825 if (timeout_us == 0) 826 data->timeout_ns = limit_us * 1000; 827 } 828 829 /* 830 * Some cards require longer data read timeout than indicated in CSD. 831 * Address this by setting the read timeout to a "reasonably high" 832 * value. For the cards tested, 300ms has proven enough. If necessary, 833 * this value can be increased if other problematic cards require this. 834 */ 835 if (mmc_card_long_read_time(card) && data->flags & MMC_DATA_READ) { 836 data->timeout_ns = 300000000; 837 data->timeout_clks = 0; 838 } 839 840 /* 841 * Some cards need very high timeouts if driven in SPI mode. 842 * The worst observed timeout was 900ms after writing a 843 * continuous stream of data until the internal logic 844 * overflowed. 845 */ 846 if (mmc_host_is_spi(card->host)) { 847 if (data->flags & MMC_DATA_WRITE) { 848 if (data->timeout_ns < 1000000000) 849 data->timeout_ns = 1000000000; /* 1s */ 850 } else { 851 if (data->timeout_ns < 100000000) 852 data->timeout_ns = 100000000; /* 100ms */ 853 } 854 } 855 } 856 EXPORT_SYMBOL(mmc_set_data_timeout); 857 858 /** 859 * mmc_align_data_size - pads a transfer size to a more optimal value 860 * @card: the MMC card associated with the data transfer 861 * @sz: original transfer size 862 * 863 * Pads the original data size with a number of extra bytes in 864 * order to avoid controller bugs and/or performance hits 865 * (e.g. some controllers revert to PIO for certain sizes). 866 * 867 * Returns the improved size, which might be unmodified. 868 * 869 * Note that this function is only relevant when issuing a 870 * single scatter gather entry. 871 */ 872 unsigned int mmc_align_data_size(struct mmc_card *card, unsigned int sz) 873 { 874 /* 875 * FIXME: We don't have a system for the controller to tell 876 * the core about its problems yet, so for now we just 32-bit 877 * align the size. 878 */ 879 sz = ((sz + 3) / 4) * 4; 880 881 return sz; 882 } 883 EXPORT_SYMBOL(mmc_align_data_size); 884 885 /** 886 * __mmc_claim_host - exclusively claim a host 887 * @host: mmc host to claim 888 * @abort: whether or not the operation should be aborted 889 * 890 * Claim a host for a set of operations. If @abort is non null and 891 * dereference a non-zero value then this will return prematurely with 892 * that non-zero value without acquiring the lock. Returns zero 893 * with the lock held otherwise. 894 */ 895 int __mmc_claim_host(struct mmc_host *host, atomic_t *abort) 896 { 897 DECLARE_WAITQUEUE(wait, current); 898 unsigned long flags; 899 int stop; 900 bool pm = false; 901 902 might_sleep(); 903 904 add_wait_queue(&host->wq, &wait); 905 spin_lock_irqsave(&host->lock, flags); 906 while (1) { 907 set_current_state(TASK_UNINTERRUPTIBLE); 908 stop = abort ? atomic_read(abort) : 0; 909 if (stop || !host->claimed || host->claimer == current) 910 break; 911 spin_unlock_irqrestore(&host->lock, flags); 912 schedule(); 913 spin_lock_irqsave(&host->lock, flags); 914 } 915 set_current_state(TASK_RUNNING); 916 if (!stop) { 917 host->claimed = 1; 918 host->claimer = current; 919 host->claim_cnt += 1; 920 if (host->claim_cnt == 1) 921 pm = true; 922 } else 923 wake_up(&host->wq); 924 spin_unlock_irqrestore(&host->lock, flags); 925 remove_wait_queue(&host->wq, &wait); 926 927 if (pm) 928 pm_runtime_get_sync(mmc_dev(host)); 929 930 return stop; 931 } 932 EXPORT_SYMBOL(__mmc_claim_host); 933 934 /** 935 * mmc_release_host - release a host 936 * @host: mmc host to release 937 * 938 * Release a MMC host, allowing others to claim the host 939 * for their operations. 940 */ 941 void mmc_release_host(struct mmc_host *host) 942 { 943 unsigned long flags; 944 945 WARN_ON(!host->claimed); 946 947 spin_lock_irqsave(&host->lock, flags); 948 if (--host->claim_cnt) { 949 /* Release for nested claim */ 950 spin_unlock_irqrestore(&host->lock, flags); 951 } else { 952 host->claimed = 0; 953 host->claimer = NULL; 954 spin_unlock_irqrestore(&host->lock, flags); 955 wake_up(&host->wq); 956 pm_runtime_mark_last_busy(mmc_dev(host)); 957 pm_runtime_put_autosuspend(mmc_dev(host)); 958 } 959 } 960 EXPORT_SYMBOL(mmc_release_host); 961 962 /* 963 * This is a helper function, which fetches a runtime pm reference for the 964 * card device and also claims the host. 965 */ 966 void mmc_get_card(struct mmc_card *card) 967 { 968 pm_runtime_get_sync(&card->dev); 969 mmc_claim_host(card->host); 970 } 971 EXPORT_SYMBOL(mmc_get_card); 972 973 /* 974 * This is a helper function, which releases the host and drops the runtime 975 * pm reference for the card device. 976 */ 977 void mmc_put_card(struct mmc_card *card) 978 { 979 mmc_release_host(card->host); 980 pm_runtime_mark_last_busy(&card->dev); 981 pm_runtime_put_autosuspend(&card->dev); 982 } 983 EXPORT_SYMBOL(mmc_put_card); 984 985 /* 986 * Internal function that does the actual ios call to the host driver, 987 * optionally printing some debug output. 988 */ 989 static inline void mmc_set_ios(struct mmc_host *host) 990 { 991 struct mmc_ios *ios = &host->ios; 992 993 pr_debug("%s: clock %uHz busmode %u powermode %u cs %u Vdd %u " 994 "width %u timing %u\n", 995 mmc_hostname(host), ios->clock, ios->bus_mode, 996 ios->power_mode, ios->chip_select, ios->vdd, 997 ios->bus_width, ios->timing); 998 999 if (ios->clock > 0) 1000 mmc_set_ungated(host); 1001 host->ops->set_ios(host, ios); 1002 } 1003 1004 /* 1005 * Control chip select pin on a host. 1006 */ 1007 void mmc_set_chip_select(struct mmc_host *host, int mode) 1008 { 1009 mmc_host_clk_hold(host); 1010 host->ios.chip_select = mode; 1011 mmc_set_ios(host); 1012 mmc_host_clk_release(host); 1013 } 1014 1015 /* 1016 * Sets the host clock to the highest possible frequency that 1017 * is below "hz". 1018 */ 1019 static void __mmc_set_clock(struct mmc_host *host, unsigned int hz) 1020 { 1021 WARN_ON(hz && hz < host->f_min); 1022 1023 if (hz > host->f_max) 1024 hz = host->f_max; 1025 1026 host->ios.clock = hz; 1027 mmc_set_ios(host); 1028 } 1029 1030 void mmc_set_clock(struct mmc_host *host, unsigned int hz) 1031 { 1032 mmc_host_clk_hold(host); 1033 __mmc_set_clock(host, hz); 1034 mmc_host_clk_release(host); 1035 } 1036 1037 #ifdef CONFIG_MMC_CLKGATE 1038 /* 1039 * This gates the clock by setting it to 0 Hz. 1040 */ 1041 void mmc_gate_clock(struct mmc_host *host) 1042 { 1043 unsigned long flags; 1044 1045 spin_lock_irqsave(&host->clk_lock, flags); 1046 host->clk_old = host->ios.clock; 1047 host->ios.clock = 0; 1048 host->clk_gated = true; 1049 spin_unlock_irqrestore(&host->clk_lock, flags); 1050 mmc_set_ios(host); 1051 } 1052 1053 /* 1054 * This restores the clock from gating by using the cached 1055 * clock value. 1056 */ 1057 void mmc_ungate_clock(struct mmc_host *host) 1058 { 1059 /* 1060 * We should previously have gated the clock, so the clock shall 1061 * be 0 here! The clock may however be 0 during initialization, 1062 * when some request operations are performed before setting 1063 * the frequency. When ungate is requested in that situation 1064 * we just ignore the call. 1065 */ 1066 if (host->clk_old) { 1067 BUG_ON(host->ios.clock); 1068 /* This call will also set host->clk_gated to false */ 1069 __mmc_set_clock(host, host->clk_old); 1070 } 1071 } 1072 1073 void mmc_set_ungated(struct mmc_host *host) 1074 { 1075 unsigned long flags; 1076 1077 /* 1078 * We've been given a new frequency while the clock is gated, 1079 * so make sure we regard this as ungating it. 1080 */ 1081 spin_lock_irqsave(&host->clk_lock, flags); 1082 host->clk_gated = false; 1083 spin_unlock_irqrestore(&host->clk_lock, flags); 1084 } 1085 1086 #else 1087 void mmc_set_ungated(struct mmc_host *host) 1088 { 1089 } 1090 #endif 1091 1092 int mmc_execute_tuning(struct mmc_card *card) 1093 { 1094 struct mmc_host *host = card->host; 1095 u32 opcode; 1096 int err; 1097 1098 if (!host->ops->execute_tuning) 1099 return 0; 1100 1101 if (mmc_card_mmc(card)) 1102 opcode = MMC_SEND_TUNING_BLOCK_HS200; 1103 else 1104 opcode = MMC_SEND_TUNING_BLOCK; 1105 1106 mmc_host_clk_hold(host); 1107 err = host->ops->execute_tuning(host, opcode); 1108 mmc_host_clk_release(host); 1109 1110 if (err) 1111 pr_err("%s: tuning execution failed\n", mmc_hostname(host)); 1112 1113 return err; 1114 } 1115 1116 /* 1117 * Change the bus mode (open drain/push-pull) of a host. 1118 */ 1119 void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode) 1120 { 1121 mmc_host_clk_hold(host); 1122 host->ios.bus_mode = mode; 1123 mmc_set_ios(host); 1124 mmc_host_clk_release(host); 1125 } 1126 1127 /* 1128 * Change data bus width of a host. 1129 */ 1130 void mmc_set_bus_width(struct mmc_host *host, unsigned int width) 1131 { 1132 mmc_host_clk_hold(host); 1133 host->ios.bus_width = width; 1134 mmc_set_ios(host); 1135 mmc_host_clk_release(host); 1136 } 1137 1138 /* 1139 * Set initial state after a power cycle or a hw_reset. 1140 */ 1141 void mmc_set_initial_state(struct mmc_host *host) 1142 { 1143 if (mmc_host_is_spi(host)) 1144 host->ios.chip_select = MMC_CS_HIGH; 1145 else 1146 host->ios.chip_select = MMC_CS_DONTCARE; 1147 host->ios.bus_mode = MMC_BUSMODE_PUSHPULL; 1148 host->ios.bus_width = MMC_BUS_WIDTH_1; 1149 host->ios.timing = MMC_TIMING_LEGACY; 1150 1151 mmc_set_ios(host); 1152 } 1153 1154 /** 1155 * mmc_vdd_to_ocrbitnum - Convert a voltage to the OCR bit number 1156 * @vdd: voltage (mV) 1157 * @low_bits: prefer low bits in boundary cases 1158 * 1159 * This function returns the OCR bit number according to the provided @vdd 1160 * value. If conversion is not possible a negative errno value returned. 1161 * 1162 * Depending on the @low_bits flag the function prefers low or high OCR bits 1163 * on boundary voltages. For example, 1164 * with @low_bits = true, 3300 mV translates to ilog2(MMC_VDD_32_33); 1165 * with @low_bits = false, 3300 mV translates to ilog2(MMC_VDD_33_34); 1166 * 1167 * Any value in the [1951:1999] range translates to the ilog2(MMC_VDD_20_21). 1168 */ 1169 static int mmc_vdd_to_ocrbitnum(int vdd, bool low_bits) 1170 { 1171 const int max_bit = ilog2(MMC_VDD_35_36); 1172 int bit; 1173 1174 if (vdd < 1650 || vdd > 3600) 1175 return -EINVAL; 1176 1177 if (vdd >= 1650 && vdd <= 1950) 1178 return ilog2(MMC_VDD_165_195); 1179 1180 if (low_bits) 1181 vdd -= 1; 1182 1183 /* Base 2000 mV, step 100 mV, bit's base 8. */ 1184 bit = (vdd - 2000) / 100 + 8; 1185 if (bit > max_bit) 1186 return max_bit; 1187 return bit; 1188 } 1189 1190 /** 1191 * mmc_vddrange_to_ocrmask - Convert a voltage range to the OCR mask 1192 * @vdd_min: minimum voltage value (mV) 1193 * @vdd_max: maximum voltage value (mV) 1194 * 1195 * This function returns the OCR mask bits according to the provided @vdd_min 1196 * and @vdd_max values. If conversion is not possible the function returns 0. 1197 * 1198 * Notes wrt boundary cases: 1199 * This function sets the OCR bits for all boundary voltages, for example 1200 * [3300:3400] range is translated to MMC_VDD_32_33 | MMC_VDD_33_34 | 1201 * MMC_VDD_34_35 mask. 1202 */ 1203 u32 mmc_vddrange_to_ocrmask(int vdd_min, int vdd_max) 1204 { 1205 u32 mask = 0; 1206 1207 if (vdd_max < vdd_min) 1208 return 0; 1209 1210 /* Prefer high bits for the boundary vdd_max values. */ 1211 vdd_max = mmc_vdd_to_ocrbitnum(vdd_max, false); 1212 if (vdd_max < 0) 1213 return 0; 1214 1215 /* Prefer low bits for the boundary vdd_min values. */ 1216 vdd_min = mmc_vdd_to_ocrbitnum(vdd_min, true); 1217 if (vdd_min < 0) 1218 return 0; 1219 1220 /* Fill the mask, from max bit to min bit. */ 1221 while (vdd_max >= vdd_min) 1222 mask |= 1 << vdd_max--; 1223 1224 return mask; 1225 } 1226 EXPORT_SYMBOL(mmc_vddrange_to_ocrmask); 1227 1228 #ifdef CONFIG_OF 1229 1230 /** 1231 * mmc_of_parse_voltage - return mask of supported voltages 1232 * @np: The device node need to be parsed. 1233 * @mask: mask of voltages available for MMC/SD/SDIO 1234 * 1235 * 1. Return zero on success. 1236 * 2. Return negative errno: voltage-range is invalid. 1237 */ 1238 int mmc_of_parse_voltage(struct device_node *np, u32 *mask) 1239 { 1240 const u32 *voltage_ranges; 1241 int num_ranges, i; 1242 1243 voltage_ranges = of_get_property(np, "voltage-ranges", &num_ranges); 1244 num_ranges = num_ranges / sizeof(*voltage_ranges) / 2; 1245 if (!voltage_ranges || !num_ranges) { 1246 pr_info("%s: voltage-ranges unspecified\n", np->full_name); 1247 return -EINVAL; 1248 } 1249 1250 for (i = 0; i < num_ranges; i++) { 1251 const int j = i * 2; 1252 u32 ocr_mask; 1253 1254 ocr_mask = mmc_vddrange_to_ocrmask( 1255 be32_to_cpu(voltage_ranges[j]), 1256 be32_to_cpu(voltage_ranges[j + 1])); 1257 if (!ocr_mask) { 1258 pr_err("%s: voltage-range #%d is invalid\n", 1259 np->full_name, i); 1260 return -EINVAL; 1261 } 1262 *mask |= ocr_mask; 1263 } 1264 1265 return 0; 1266 } 1267 EXPORT_SYMBOL(mmc_of_parse_voltage); 1268 1269 #endif /* CONFIG_OF */ 1270 1271 static int mmc_of_get_func_num(struct device_node *node) 1272 { 1273 u32 reg; 1274 int ret; 1275 1276 ret = of_property_read_u32(node, "reg", ®); 1277 if (ret < 0) 1278 return ret; 1279 1280 return reg; 1281 } 1282 1283 struct device_node *mmc_of_find_child_device(struct mmc_host *host, 1284 unsigned func_num) 1285 { 1286 struct device_node *node; 1287 1288 if (!host->parent || !host->parent->of_node) 1289 return NULL; 1290 1291 for_each_child_of_node(host->parent->of_node, node) { 1292 if (mmc_of_get_func_num(node) == func_num) 1293 return node; 1294 } 1295 1296 return NULL; 1297 } 1298 1299 #ifdef CONFIG_REGULATOR 1300 1301 /** 1302 * mmc_regulator_get_ocrmask - return mask of supported voltages 1303 * @supply: regulator to use 1304 * 1305 * This returns either a negative errno, or a mask of voltages that 1306 * can be provided to MMC/SD/SDIO devices using the specified voltage 1307 * regulator. This would normally be called before registering the 1308 * MMC host adapter. 1309 */ 1310 int mmc_regulator_get_ocrmask(struct regulator *supply) 1311 { 1312 int result = 0; 1313 int count; 1314 int i; 1315 int vdd_uV; 1316 int vdd_mV; 1317 1318 count = regulator_count_voltages(supply); 1319 if (count < 0) 1320 return count; 1321 1322 for (i = 0; i < count; i++) { 1323 vdd_uV = regulator_list_voltage(supply, i); 1324 if (vdd_uV <= 0) 1325 continue; 1326 1327 vdd_mV = vdd_uV / 1000; 1328 result |= mmc_vddrange_to_ocrmask(vdd_mV, vdd_mV); 1329 } 1330 1331 if (!result) { 1332 vdd_uV = regulator_get_voltage(supply); 1333 if (vdd_uV <= 0) 1334 return vdd_uV; 1335 1336 vdd_mV = vdd_uV / 1000; 1337 result = mmc_vddrange_to_ocrmask(vdd_mV, vdd_mV); 1338 } 1339 1340 return result; 1341 } 1342 EXPORT_SYMBOL_GPL(mmc_regulator_get_ocrmask); 1343 1344 /** 1345 * mmc_regulator_set_ocr - set regulator to match host->ios voltage 1346 * @mmc: the host to regulate 1347 * @supply: regulator to use 1348 * @vdd_bit: zero for power off, else a bit number (host->ios.vdd) 1349 * 1350 * Returns zero on success, else negative errno. 1351 * 1352 * MMC host drivers may use this to enable or disable a regulator using 1353 * a particular supply voltage. This would normally be called from the 1354 * set_ios() method. 1355 */ 1356 int mmc_regulator_set_ocr(struct mmc_host *mmc, 1357 struct regulator *supply, 1358 unsigned short vdd_bit) 1359 { 1360 int result = 0; 1361 int min_uV, max_uV; 1362 1363 if (vdd_bit) { 1364 int tmp; 1365 1366 /* 1367 * REVISIT mmc_vddrange_to_ocrmask() may have set some 1368 * bits this regulator doesn't quite support ... don't 1369 * be too picky, most cards and regulators are OK with 1370 * a 0.1V range goof (it's a small error percentage). 1371 */ 1372 tmp = vdd_bit - ilog2(MMC_VDD_165_195); 1373 if (tmp == 0) { 1374 min_uV = 1650 * 1000; 1375 max_uV = 1950 * 1000; 1376 } else { 1377 min_uV = 1900 * 1000 + tmp * 100 * 1000; 1378 max_uV = min_uV + 100 * 1000; 1379 } 1380 1381 result = regulator_set_voltage(supply, min_uV, max_uV); 1382 if (result == 0 && !mmc->regulator_enabled) { 1383 result = regulator_enable(supply); 1384 if (!result) 1385 mmc->regulator_enabled = true; 1386 } 1387 } else if (mmc->regulator_enabled) { 1388 result = regulator_disable(supply); 1389 if (result == 0) 1390 mmc->regulator_enabled = false; 1391 } 1392 1393 if (result) 1394 dev_err(mmc_dev(mmc), 1395 "could not set regulator OCR (%d)\n", result); 1396 return result; 1397 } 1398 EXPORT_SYMBOL_GPL(mmc_regulator_set_ocr); 1399 1400 #endif /* CONFIG_REGULATOR */ 1401 1402 int mmc_regulator_get_supply(struct mmc_host *mmc) 1403 { 1404 struct device *dev = mmc_dev(mmc); 1405 int ret; 1406 1407 mmc->supply.vmmc = devm_regulator_get_optional(dev, "vmmc"); 1408 mmc->supply.vqmmc = devm_regulator_get_optional(dev, "vqmmc"); 1409 1410 if (IS_ERR(mmc->supply.vmmc)) { 1411 if (PTR_ERR(mmc->supply.vmmc) == -EPROBE_DEFER) 1412 return -EPROBE_DEFER; 1413 dev_info(dev, "No vmmc regulator found\n"); 1414 } else { 1415 ret = mmc_regulator_get_ocrmask(mmc->supply.vmmc); 1416 if (ret > 0) 1417 mmc->ocr_avail = ret; 1418 else 1419 dev_warn(dev, "Failed getting OCR mask: %d\n", ret); 1420 } 1421 1422 if (IS_ERR(mmc->supply.vqmmc)) { 1423 if (PTR_ERR(mmc->supply.vqmmc) == -EPROBE_DEFER) 1424 return -EPROBE_DEFER; 1425 dev_info(dev, "No vqmmc regulator found\n"); 1426 } 1427 1428 return 0; 1429 } 1430 EXPORT_SYMBOL_GPL(mmc_regulator_get_supply); 1431 1432 /* 1433 * Mask off any voltages we don't support and select 1434 * the lowest voltage 1435 */ 1436 u32 mmc_select_voltage(struct mmc_host *host, u32 ocr) 1437 { 1438 int bit; 1439 1440 /* 1441 * Sanity check the voltages that the card claims to 1442 * support. 1443 */ 1444 if (ocr & 0x7F) { 1445 dev_warn(mmc_dev(host), 1446 "card claims to support voltages below defined range\n"); 1447 ocr &= ~0x7F; 1448 } 1449 1450 ocr &= host->ocr_avail; 1451 if (!ocr) { 1452 dev_warn(mmc_dev(host), "no support for card's volts\n"); 1453 return 0; 1454 } 1455 1456 if (host->caps2 & MMC_CAP2_FULL_PWR_CYCLE) { 1457 bit = ffs(ocr) - 1; 1458 ocr &= 3 << bit; 1459 mmc_power_cycle(host, ocr); 1460 } else { 1461 bit = fls(ocr) - 1; 1462 ocr &= 3 << bit; 1463 if (bit != host->ios.vdd) 1464 dev_warn(mmc_dev(host), "exceeding card's volts\n"); 1465 } 1466 1467 return ocr; 1468 } 1469 1470 int __mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage) 1471 { 1472 int err = 0; 1473 int old_signal_voltage = host->ios.signal_voltage; 1474 1475 host->ios.signal_voltage = signal_voltage; 1476 if (host->ops->start_signal_voltage_switch) { 1477 mmc_host_clk_hold(host); 1478 err = host->ops->start_signal_voltage_switch(host, &host->ios); 1479 mmc_host_clk_release(host); 1480 } 1481 1482 if (err) 1483 host->ios.signal_voltage = old_signal_voltage; 1484 1485 return err; 1486 1487 } 1488 1489 int mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage, u32 ocr) 1490 { 1491 struct mmc_command cmd = {0}; 1492 int err = 0; 1493 u32 clock; 1494 1495 BUG_ON(!host); 1496 1497 /* 1498 * Send CMD11 only if the request is to switch the card to 1499 * 1.8V signalling. 1500 */ 1501 if (signal_voltage == MMC_SIGNAL_VOLTAGE_330) 1502 return __mmc_set_signal_voltage(host, signal_voltage); 1503 1504 /* 1505 * If we cannot switch voltages, return failure so the caller 1506 * can continue without UHS mode 1507 */ 1508 if (!host->ops->start_signal_voltage_switch) 1509 return -EPERM; 1510 if (!host->ops->card_busy) 1511 pr_warn("%s: cannot verify signal voltage switch\n", 1512 mmc_hostname(host)); 1513 1514 mmc_host_clk_hold(host); 1515 1516 cmd.opcode = SD_SWITCH_VOLTAGE; 1517 cmd.arg = 0; 1518 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 1519 1520 err = mmc_wait_for_cmd(host, &cmd, 0); 1521 if (err) 1522 goto err_command; 1523 1524 if (!mmc_host_is_spi(host) && (cmd.resp[0] & R1_ERROR)) { 1525 err = -EIO; 1526 goto err_command; 1527 } 1528 /* 1529 * The card should drive cmd and dat[0:3] low immediately 1530 * after the response of cmd11, but wait 1 ms to be sure 1531 */ 1532 mmc_delay(1); 1533 if (host->ops->card_busy && !host->ops->card_busy(host)) { 1534 err = -EAGAIN; 1535 goto power_cycle; 1536 } 1537 /* 1538 * During a signal voltage level switch, the clock must be gated 1539 * for 5 ms according to the SD spec 1540 */ 1541 clock = host->ios.clock; 1542 host->ios.clock = 0; 1543 mmc_set_ios(host); 1544 1545 if (__mmc_set_signal_voltage(host, signal_voltage)) { 1546 /* 1547 * Voltages may not have been switched, but we've already 1548 * sent CMD11, so a power cycle is required anyway 1549 */ 1550 err = -EAGAIN; 1551 goto power_cycle; 1552 } 1553 1554 /* Keep clock gated for at least 5 ms */ 1555 mmc_delay(5); 1556 host->ios.clock = clock; 1557 mmc_set_ios(host); 1558 1559 /* Wait for at least 1 ms according to spec */ 1560 mmc_delay(1); 1561 1562 /* 1563 * Failure to switch is indicated by the card holding 1564 * dat[0:3] low 1565 */ 1566 if (host->ops->card_busy && host->ops->card_busy(host)) 1567 err = -EAGAIN; 1568 1569 power_cycle: 1570 if (err) { 1571 pr_debug("%s: Signal voltage switch failed, " 1572 "power cycling card\n", mmc_hostname(host)); 1573 mmc_power_cycle(host, ocr); 1574 } 1575 1576 err_command: 1577 mmc_host_clk_release(host); 1578 1579 return err; 1580 } 1581 1582 /* 1583 * Select timing parameters for host. 1584 */ 1585 void mmc_set_timing(struct mmc_host *host, unsigned int timing) 1586 { 1587 mmc_host_clk_hold(host); 1588 host->ios.timing = timing; 1589 mmc_set_ios(host); 1590 mmc_host_clk_release(host); 1591 } 1592 1593 /* 1594 * Select appropriate driver type for host. 1595 */ 1596 void mmc_set_driver_type(struct mmc_host *host, unsigned int drv_type) 1597 { 1598 mmc_host_clk_hold(host); 1599 host->ios.drv_type = drv_type; 1600 mmc_set_ios(host); 1601 mmc_host_clk_release(host); 1602 } 1603 1604 /* 1605 * Apply power to the MMC stack. This is a two-stage process. 1606 * First, we enable power to the card without the clock running. 1607 * We then wait a bit for the power to stabilise. Finally, 1608 * enable the bus drivers and clock to the card. 1609 * 1610 * We must _NOT_ enable the clock prior to power stablising. 1611 * 1612 * If a host does all the power sequencing itself, ignore the 1613 * initial MMC_POWER_UP stage. 1614 */ 1615 void mmc_power_up(struct mmc_host *host, u32 ocr) 1616 { 1617 if (host->ios.power_mode == MMC_POWER_ON) 1618 return; 1619 1620 mmc_host_clk_hold(host); 1621 1622 mmc_pwrseq_pre_power_on(host); 1623 1624 host->ios.vdd = fls(ocr) - 1; 1625 host->ios.power_mode = MMC_POWER_UP; 1626 /* Set initial state and call mmc_set_ios */ 1627 mmc_set_initial_state(host); 1628 1629 /* Try to set signal voltage to 3.3V but fall back to 1.8v or 1.2v */ 1630 if (__mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330) == 0) 1631 dev_dbg(mmc_dev(host), "Initial signal voltage of 3.3v\n"); 1632 else if (__mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180) == 0) 1633 dev_dbg(mmc_dev(host), "Initial signal voltage of 1.8v\n"); 1634 else if (__mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120) == 0) 1635 dev_dbg(mmc_dev(host), "Initial signal voltage of 1.2v\n"); 1636 1637 /* 1638 * This delay should be sufficient to allow the power supply 1639 * to reach the minimum voltage. 1640 */ 1641 mmc_delay(10); 1642 1643 mmc_pwrseq_post_power_on(host); 1644 1645 host->ios.clock = host->f_init; 1646 1647 host->ios.power_mode = MMC_POWER_ON; 1648 mmc_set_ios(host); 1649 1650 /* 1651 * This delay must be at least 74 clock sizes, or 1 ms, or the 1652 * time required to reach a stable voltage. 1653 */ 1654 mmc_delay(10); 1655 1656 mmc_host_clk_release(host); 1657 } 1658 1659 void mmc_power_off(struct mmc_host *host) 1660 { 1661 if (host->ios.power_mode == MMC_POWER_OFF) 1662 return; 1663 1664 mmc_host_clk_hold(host); 1665 1666 mmc_pwrseq_power_off(host); 1667 1668 host->ios.clock = 0; 1669 host->ios.vdd = 0; 1670 1671 host->ios.power_mode = MMC_POWER_OFF; 1672 /* Set initial state and call mmc_set_ios */ 1673 mmc_set_initial_state(host); 1674 1675 /* 1676 * Some configurations, such as the 802.11 SDIO card in the OLPC 1677 * XO-1.5, require a short delay after poweroff before the card 1678 * can be successfully turned on again. 1679 */ 1680 mmc_delay(1); 1681 1682 mmc_host_clk_release(host); 1683 } 1684 1685 void mmc_power_cycle(struct mmc_host *host, u32 ocr) 1686 { 1687 mmc_power_off(host); 1688 /* Wait at least 1 ms according to SD spec */ 1689 mmc_delay(1); 1690 mmc_power_up(host, ocr); 1691 } 1692 1693 /* 1694 * Cleanup when the last reference to the bus operator is dropped. 1695 */ 1696 static void __mmc_release_bus(struct mmc_host *host) 1697 { 1698 BUG_ON(!host); 1699 BUG_ON(host->bus_refs); 1700 BUG_ON(!host->bus_dead); 1701 1702 host->bus_ops = NULL; 1703 } 1704 1705 /* 1706 * Increase reference count of bus operator 1707 */ 1708 static inline void mmc_bus_get(struct mmc_host *host) 1709 { 1710 unsigned long flags; 1711 1712 spin_lock_irqsave(&host->lock, flags); 1713 host->bus_refs++; 1714 spin_unlock_irqrestore(&host->lock, flags); 1715 } 1716 1717 /* 1718 * Decrease reference count of bus operator and free it if 1719 * it is the last reference. 1720 */ 1721 static inline void mmc_bus_put(struct mmc_host *host) 1722 { 1723 unsigned long flags; 1724 1725 spin_lock_irqsave(&host->lock, flags); 1726 host->bus_refs--; 1727 if ((host->bus_refs == 0) && host->bus_ops) 1728 __mmc_release_bus(host); 1729 spin_unlock_irqrestore(&host->lock, flags); 1730 } 1731 1732 /* 1733 * Assign a mmc bus handler to a host. Only one bus handler may control a 1734 * host at any given time. 1735 */ 1736 void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops) 1737 { 1738 unsigned long flags; 1739 1740 BUG_ON(!host); 1741 BUG_ON(!ops); 1742 1743 WARN_ON(!host->claimed); 1744 1745 spin_lock_irqsave(&host->lock, flags); 1746 1747 BUG_ON(host->bus_ops); 1748 BUG_ON(host->bus_refs); 1749 1750 host->bus_ops = ops; 1751 host->bus_refs = 1; 1752 host->bus_dead = 0; 1753 1754 spin_unlock_irqrestore(&host->lock, flags); 1755 } 1756 1757 /* 1758 * Remove the current bus handler from a host. 1759 */ 1760 void mmc_detach_bus(struct mmc_host *host) 1761 { 1762 unsigned long flags; 1763 1764 BUG_ON(!host); 1765 1766 WARN_ON(!host->claimed); 1767 WARN_ON(!host->bus_ops); 1768 1769 spin_lock_irqsave(&host->lock, flags); 1770 1771 host->bus_dead = 1; 1772 1773 spin_unlock_irqrestore(&host->lock, flags); 1774 1775 mmc_bus_put(host); 1776 } 1777 1778 static void _mmc_detect_change(struct mmc_host *host, unsigned long delay, 1779 bool cd_irq) 1780 { 1781 #ifdef CONFIG_MMC_DEBUG 1782 unsigned long flags; 1783 spin_lock_irqsave(&host->lock, flags); 1784 WARN_ON(host->removed); 1785 spin_unlock_irqrestore(&host->lock, flags); 1786 #endif 1787 1788 /* 1789 * If the device is configured as wakeup, we prevent a new sleep for 1790 * 5 s to give provision for user space to consume the event. 1791 */ 1792 if (cd_irq && !(host->caps & MMC_CAP_NEEDS_POLL) && 1793 device_can_wakeup(mmc_dev(host))) 1794 pm_wakeup_event(mmc_dev(host), 5000); 1795 1796 host->detect_change = 1; 1797 mmc_schedule_delayed_work(&host->detect, delay); 1798 } 1799 1800 /** 1801 * mmc_detect_change - process change of state on a MMC socket 1802 * @host: host which changed state. 1803 * @delay: optional delay to wait before detection (jiffies) 1804 * 1805 * MMC drivers should call this when they detect a card has been 1806 * inserted or removed. The MMC layer will confirm that any 1807 * present card is still functional, and initialize any newly 1808 * inserted. 1809 */ 1810 void mmc_detect_change(struct mmc_host *host, unsigned long delay) 1811 { 1812 _mmc_detect_change(host, delay, true); 1813 } 1814 EXPORT_SYMBOL(mmc_detect_change); 1815 1816 void mmc_init_erase(struct mmc_card *card) 1817 { 1818 unsigned int sz; 1819 1820 if (is_power_of_2(card->erase_size)) 1821 card->erase_shift = ffs(card->erase_size) - 1; 1822 else 1823 card->erase_shift = 0; 1824 1825 /* 1826 * It is possible to erase an arbitrarily large area of an SD or MMC 1827 * card. That is not desirable because it can take a long time 1828 * (minutes) potentially delaying more important I/O, and also the 1829 * timeout calculations become increasingly hugely over-estimated. 1830 * Consequently, 'pref_erase' is defined as a guide to limit erases 1831 * to that size and alignment. 1832 * 1833 * For SD cards that define Allocation Unit size, limit erases to one 1834 * Allocation Unit at a time. For MMC cards that define High Capacity 1835 * Erase Size, whether it is switched on or not, limit to that size. 1836 * Otherwise just have a stab at a good value. For modern cards it 1837 * will end up being 4MiB. Note that if the value is too small, it 1838 * can end up taking longer to erase. 1839 */ 1840 if (mmc_card_sd(card) && card->ssr.au) { 1841 card->pref_erase = card->ssr.au; 1842 card->erase_shift = ffs(card->ssr.au) - 1; 1843 } else if (card->ext_csd.hc_erase_size) { 1844 card->pref_erase = card->ext_csd.hc_erase_size; 1845 } else if (card->erase_size) { 1846 sz = (card->csd.capacity << (card->csd.read_blkbits - 9)) >> 11; 1847 if (sz < 128) 1848 card->pref_erase = 512 * 1024 / 512; 1849 else if (sz < 512) 1850 card->pref_erase = 1024 * 1024 / 512; 1851 else if (sz < 1024) 1852 card->pref_erase = 2 * 1024 * 1024 / 512; 1853 else 1854 card->pref_erase = 4 * 1024 * 1024 / 512; 1855 if (card->pref_erase < card->erase_size) 1856 card->pref_erase = card->erase_size; 1857 else { 1858 sz = card->pref_erase % card->erase_size; 1859 if (sz) 1860 card->pref_erase += card->erase_size - sz; 1861 } 1862 } else 1863 card->pref_erase = 0; 1864 } 1865 1866 static unsigned int mmc_mmc_erase_timeout(struct mmc_card *card, 1867 unsigned int arg, unsigned int qty) 1868 { 1869 unsigned int erase_timeout; 1870 1871 if (arg == MMC_DISCARD_ARG || 1872 (arg == MMC_TRIM_ARG && card->ext_csd.rev >= 6)) { 1873 erase_timeout = card->ext_csd.trim_timeout; 1874 } else if (card->ext_csd.erase_group_def & 1) { 1875 /* High Capacity Erase Group Size uses HC timeouts */ 1876 if (arg == MMC_TRIM_ARG) 1877 erase_timeout = card->ext_csd.trim_timeout; 1878 else 1879 erase_timeout = card->ext_csd.hc_erase_timeout; 1880 } else { 1881 /* CSD Erase Group Size uses write timeout */ 1882 unsigned int mult = (10 << card->csd.r2w_factor); 1883 unsigned int timeout_clks = card->csd.tacc_clks * mult; 1884 unsigned int timeout_us; 1885 1886 /* Avoid overflow: e.g. tacc_ns=80000000 mult=1280 */ 1887 if (card->csd.tacc_ns < 1000000) 1888 timeout_us = (card->csd.tacc_ns * mult) / 1000; 1889 else 1890 timeout_us = (card->csd.tacc_ns / 1000) * mult; 1891 1892 /* 1893 * ios.clock is only a target. The real clock rate might be 1894 * less but not that much less, so fudge it by multiplying by 2. 1895 */ 1896 timeout_clks <<= 1; 1897 timeout_us += (timeout_clks * 1000) / 1898 (mmc_host_clk_rate(card->host) / 1000); 1899 1900 erase_timeout = timeout_us / 1000; 1901 1902 /* 1903 * Theoretically, the calculation could underflow so round up 1904 * to 1ms in that case. 1905 */ 1906 if (!erase_timeout) 1907 erase_timeout = 1; 1908 } 1909 1910 /* Multiplier for secure operations */ 1911 if (arg & MMC_SECURE_ARGS) { 1912 if (arg == MMC_SECURE_ERASE_ARG) 1913 erase_timeout *= card->ext_csd.sec_erase_mult; 1914 else 1915 erase_timeout *= card->ext_csd.sec_trim_mult; 1916 } 1917 1918 erase_timeout *= qty; 1919 1920 /* 1921 * Ensure at least a 1 second timeout for SPI as per 1922 * 'mmc_set_data_timeout()' 1923 */ 1924 if (mmc_host_is_spi(card->host) && erase_timeout < 1000) 1925 erase_timeout = 1000; 1926 1927 return erase_timeout; 1928 } 1929 1930 static unsigned int mmc_sd_erase_timeout(struct mmc_card *card, 1931 unsigned int arg, 1932 unsigned int qty) 1933 { 1934 unsigned int erase_timeout; 1935 1936 if (card->ssr.erase_timeout) { 1937 /* Erase timeout specified in SD Status Register (SSR) */ 1938 erase_timeout = card->ssr.erase_timeout * qty + 1939 card->ssr.erase_offset; 1940 } else { 1941 /* 1942 * Erase timeout not specified in SD Status Register (SSR) so 1943 * use 250ms per write block. 1944 */ 1945 erase_timeout = 250 * qty; 1946 } 1947 1948 /* Must not be less than 1 second */ 1949 if (erase_timeout < 1000) 1950 erase_timeout = 1000; 1951 1952 return erase_timeout; 1953 } 1954 1955 static unsigned int mmc_erase_timeout(struct mmc_card *card, 1956 unsigned int arg, 1957 unsigned int qty) 1958 { 1959 if (mmc_card_sd(card)) 1960 return mmc_sd_erase_timeout(card, arg, qty); 1961 else 1962 return mmc_mmc_erase_timeout(card, arg, qty); 1963 } 1964 1965 static int mmc_do_erase(struct mmc_card *card, unsigned int from, 1966 unsigned int to, unsigned int arg) 1967 { 1968 struct mmc_command cmd = {0}; 1969 unsigned int qty = 0; 1970 unsigned long timeout; 1971 int err; 1972 1973 /* 1974 * qty is used to calculate the erase timeout which depends on how many 1975 * erase groups (or allocation units in SD terminology) are affected. 1976 * We count erasing part of an erase group as one erase group. 1977 * For SD, the allocation units are always a power of 2. For MMC, the 1978 * erase group size is almost certainly also power of 2, but it does not 1979 * seem to insist on that in the JEDEC standard, so we fall back to 1980 * division in that case. SD may not specify an allocation unit size, 1981 * in which case the timeout is based on the number of write blocks. 1982 * 1983 * Note that the timeout for secure trim 2 will only be correct if the 1984 * number of erase groups specified is the same as the total of all 1985 * preceding secure trim 1 commands. Since the power may have been 1986 * lost since the secure trim 1 commands occurred, it is generally 1987 * impossible to calculate the secure trim 2 timeout correctly. 1988 */ 1989 if (card->erase_shift) 1990 qty += ((to >> card->erase_shift) - 1991 (from >> card->erase_shift)) + 1; 1992 else if (mmc_card_sd(card)) 1993 qty += to - from + 1; 1994 else 1995 qty += ((to / card->erase_size) - 1996 (from / card->erase_size)) + 1; 1997 1998 if (!mmc_card_blockaddr(card)) { 1999 from <<= 9; 2000 to <<= 9; 2001 } 2002 2003 if (mmc_card_sd(card)) 2004 cmd.opcode = SD_ERASE_WR_BLK_START; 2005 else 2006 cmd.opcode = MMC_ERASE_GROUP_START; 2007 cmd.arg = from; 2008 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC; 2009 err = mmc_wait_for_cmd(card->host, &cmd, 0); 2010 if (err) { 2011 pr_err("mmc_erase: group start error %d, " 2012 "status %#x\n", err, cmd.resp[0]); 2013 err = -EIO; 2014 goto out; 2015 } 2016 2017 memset(&cmd, 0, sizeof(struct mmc_command)); 2018 if (mmc_card_sd(card)) 2019 cmd.opcode = SD_ERASE_WR_BLK_END; 2020 else 2021 cmd.opcode = MMC_ERASE_GROUP_END; 2022 cmd.arg = to; 2023 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC; 2024 err = mmc_wait_for_cmd(card->host, &cmd, 0); 2025 if (err) { 2026 pr_err("mmc_erase: group end error %d, status %#x\n", 2027 err, cmd.resp[0]); 2028 err = -EIO; 2029 goto out; 2030 } 2031 2032 memset(&cmd, 0, sizeof(struct mmc_command)); 2033 cmd.opcode = MMC_ERASE; 2034 cmd.arg = arg; 2035 cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC; 2036 cmd.busy_timeout = mmc_erase_timeout(card, arg, qty); 2037 err = mmc_wait_for_cmd(card->host, &cmd, 0); 2038 if (err) { 2039 pr_err("mmc_erase: erase error %d, status %#x\n", 2040 err, cmd.resp[0]); 2041 err = -EIO; 2042 goto out; 2043 } 2044 2045 if (mmc_host_is_spi(card->host)) 2046 goto out; 2047 2048 timeout = jiffies + msecs_to_jiffies(MMC_CORE_TIMEOUT_MS); 2049 do { 2050 memset(&cmd, 0, sizeof(struct mmc_command)); 2051 cmd.opcode = MMC_SEND_STATUS; 2052 cmd.arg = card->rca << 16; 2053 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 2054 /* Do not retry else we can't see errors */ 2055 err = mmc_wait_for_cmd(card->host, &cmd, 0); 2056 if (err || (cmd.resp[0] & 0xFDF92000)) { 2057 pr_err("error %d requesting status %#x\n", 2058 err, cmd.resp[0]); 2059 err = -EIO; 2060 goto out; 2061 } 2062 2063 /* Timeout if the device never becomes ready for data and 2064 * never leaves the program state. 2065 */ 2066 if (time_after(jiffies, timeout)) { 2067 pr_err("%s: Card stuck in programming state! %s\n", 2068 mmc_hostname(card->host), __func__); 2069 err = -EIO; 2070 goto out; 2071 } 2072 2073 } while (!(cmd.resp[0] & R1_READY_FOR_DATA) || 2074 (R1_CURRENT_STATE(cmd.resp[0]) == R1_STATE_PRG)); 2075 out: 2076 return err; 2077 } 2078 2079 /** 2080 * mmc_erase - erase sectors. 2081 * @card: card to erase 2082 * @from: first sector to erase 2083 * @nr: number of sectors to erase 2084 * @arg: erase command argument (SD supports only %MMC_ERASE_ARG) 2085 * 2086 * Caller must claim host before calling this function. 2087 */ 2088 int mmc_erase(struct mmc_card *card, unsigned int from, unsigned int nr, 2089 unsigned int arg) 2090 { 2091 unsigned int rem, to = from + nr; 2092 2093 if (!(card->host->caps & MMC_CAP_ERASE) || 2094 !(card->csd.cmdclass & CCC_ERASE)) 2095 return -EOPNOTSUPP; 2096 2097 if (!card->erase_size) 2098 return -EOPNOTSUPP; 2099 2100 if (mmc_card_sd(card) && arg != MMC_ERASE_ARG) 2101 return -EOPNOTSUPP; 2102 2103 if ((arg & MMC_SECURE_ARGS) && 2104 !(card->ext_csd.sec_feature_support & EXT_CSD_SEC_ER_EN)) 2105 return -EOPNOTSUPP; 2106 2107 if ((arg & MMC_TRIM_ARGS) && 2108 !(card->ext_csd.sec_feature_support & EXT_CSD_SEC_GB_CL_EN)) 2109 return -EOPNOTSUPP; 2110 2111 if (arg == MMC_SECURE_ERASE_ARG) { 2112 if (from % card->erase_size || nr % card->erase_size) 2113 return -EINVAL; 2114 } 2115 2116 if (arg == MMC_ERASE_ARG) { 2117 rem = from % card->erase_size; 2118 if (rem) { 2119 rem = card->erase_size - rem; 2120 from += rem; 2121 if (nr > rem) 2122 nr -= rem; 2123 else 2124 return 0; 2125 } 2126 rem = nr % card->erase_size; 2127 if (rem) 2128 nr -= rem; 2129 } 2130 2131 if (nr == 0) 2132 return 0; 2133 2134 to = from + nr; 2135 2136 if (to <= from) 2137 return -EINVAL; 2138 2139 /* 'from' and 'to' are inclusive */ 2140 to -= 1; 2141 2142 return mmc_do_erase(card, from, to, arg); 2143 } 2144 EXPORT_SYMBOL(mmc_erase); 2145 2146 int mmc_can_erase(struct mmc_card *card) 2147 { 2148 if ((card->host->caps & MMC_CAP_ERASE) && 2149 (card->csd.cmdclass & CCC_ERASE) && card->erase_size) 2150 return 1; 2151 return 0; 2152 } 2153 EXPORT_SYMBOL(mmc_can_erase); 2154 2155 int mmc_can_trim(struct mmc_card *card) 2156 { 2157 if (card->ext_csd.sec_feature_support & EXT_CSD_SEC_GB_CL_EN) 2158 return 1; 2159 return 0; 2160 } 2161 EXPORT_SYMBOL(mmc_can_trim); 2162 2163 int mmc_can_discard(struct mmc_card *card) 2164 { 2165 /* 2166 * As there's no way to detect the discard support bit at v4.5 2167 * use the s/w feature support filed. 2168 */ 2169 if (card->ext_csd.feature_support & MMC_DISCARD_FEATURE) 2170 return 1; 2171 return 0; 2172 } 2173 EXPORT_SYMBOL(mmc_can_discard); 2174 2175 int mmc_can_sanitize(struct mmc_card *card) 2176 { 2177 if (!mmc_can_trim(card) && !mmc_can_erase(card)) 2178 return 0; 2179 if (card->ext_csd.sec_feature_support & EXT_CSD_SEC_SANITIZE) 2180 return 1; 2181 return 0; 2182 } 2183 EXPORT_SYMBOL(mmc_can_sanitize); 2184 2185 int mmc_can_secure_erase_trim(struct mmc_card *card) 2186 { 2187 if ((card->ext_csd.sec_feature_support & EXT_CSD_SEC_ER_EN) && 2188 !(card->quirks & MMC_QUIRK_SEC_ERASE_TRIM_BROKEN)) 2189 return 1; 2190 return 0; 2191 } 2192 EXPORT_SYMBOL(mmc_can_secure_erase_trim); 2193 2194 int mmc_erase_group_aligned(struct mmc_card *card, unsigned int from, 2195 unsigned int nr) 2196 { 2197 if (!card->erase_size) 2198 return 0; 2199 if (from % card->erase_size || nr % card->erase_size) 2200 return 0; 2201 return 1; 2202 } 2203 EXPORT_SYMBOL(mmc_erase_group_aligned); 2204 2205 static unsigned int mmc_do_calc_max_discard(struct mmc_card *card, 2206 unsigned int arg) 2207 { 2208 struct mmc_host *host = card->host; 2209 unsigned int max_discard, x, y, qty = 0, max_qty, timeout; 2210 unsigned int last_timeout = 0; 2211 2212 if (card->erase_shift) 2213 max_qty = UINT_MAX >> card->erase_shift; 2214 else if (mmc_card_sd(card)) 2215 max_qty = UINT_MAX; 2216 else 2217 max_qty = UINT_MAX / card->erase_size; 2218 2219 /* Find the largest qty with an OK timeout */ 2220 do { 2221 y = 0; 2222 for (x = 1; x && x <= max_qty && max_qty - x >= qty; x <<= 1) { 2223 timeout = mmc_erase_timeout(card, arg, qty + x); 2224 if (timeout > host->max_busy_timeout) 2225 break; 2226 if (timeout < last_timeout) 2227 break; 2228 last_timeout = timeout; 2229 y = x; 2230 } 2231 qty += y; 2232 } while (y); 2233 2234 if (!qty) 2235 return 0; 2236 2237 if (qty == 1) 2238 return 1; 2239 2240 /* Convert qty to sectors */ 2241 if (card->erase_shift) 2242 max_discard = --qty << card->erase_shift; 2243 else if (mmc_card_sd(card)) 2244 max_discard = qty; 2245 else 2246 max_discard = --qty * card->erase_size; 2247 2248 return max_discard; 2249 } 2250 2251 unsigned int mmc_calc_max_discard(struct mmc_card *card) 2252 { 2253 struct mmc_host *host = card->host; 2254 unsigned int max_discard, max_trim; 2255 2256 if (!host->max_busy_timeout) 2257 return UINT_MAX; 2258 2259 /* 2260 * Without erase_group_def set, MMC erase timeout depends on clock 2261 * frequence which can change. In that case, the best choice is 2262 * just the preferred erase size. 2263 */ 2264 if (mmc_card_mmc(card) && !(card->ext_csd.erase_group_def & 1)) 2265 return card->pref_erase; 2266 2267 max_discard = mmc_do_calc_max_discard(card, MMC_ERASE_ARG); 2268 if (mmc_can_trim(card)) { 2269 max_trim = mmc_do_calc_max_discard(card, MMC_TRIM_ARG); 2270 if (max_trim < max_discard) 2271 max_discard = max_trim; 2272 } else if (max_discard < card->erase_size) { 2273 max_discard = 0; 2274 } 2275 pr_debug("%s: calculated max. discard sectors %u for timeout %u ms\n", 2276 mmc_hostname(host), max_discard, host->max_busy_timeout); 2277 return max_discard; 2278 } 2279 EXPORT_SYMBOL(mmc_calc_max_discard); 2280 2281 int mmc_set_blocklen(struct mmc_card *card, unsigned int blocklen) 2282 { 2283 struct mmc_command cmd = {0}; 2284 2285 if (mmc_card_blockaddr(card) || mmc_card_ddr52(card)) 2286 return 0; 2287 2288 cmd.opcode = MMC_SET_BLOCKLEN; 2289 cmd.arg = blocklen; 2290 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC; 2291 return mmc_wait_for_cmd(card->host, &cmd, 5); 2292 } 2293 EXPORT_SYMBOL(mmc_set_blocklen); 2294 2295 int mmc_set_blockcount(struct mmc_card *card, unsigned int blockcount, 2296 bool is_rel_write) 2297 { 2298 struct mmc_command cmd = {0}; 2299 2300 cmd.opcode = MMC_SET_BLOCK_COUNT; 2301 cmd.arg = blockcount & 0x0000FFFF; 2302 if (is_rel_write) 2303 cmd.arg |= 1 << 31; 2304 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC; 2305 return mmc_wait_for_cmd(card->host, &cmd, 5); 2306 } 2307 EXPORT_SYMBOL(mmc_set_blockcount); 2308 2309 static void mmc_hw_reset_for_init(struct mmc_host *host) 2310 { 2311 if (!(host->caps & MMC_CAP_HW_RESET) || !host->ops->hw_reset) 2312 return; 2313 mmc_host_clk_hold(host); 2314 host->ops->hw_reset(host); 2315 mmc_host_clk_release(host); 2316 } 2317 2318 int mmc_hw_reset(struct mmc_host *host) 2319 { 2320 int ret; 2321 2322 if (!host->card) 2323 return -EINVAL; 2324 2325 mmc_bus_get(host); 2326 if (!host->bus_ops || host->bus_dead || !host->bus_ops->reset) { 2327 mmc_bus_put(host); 2328 return -EOPNOTSUPP; 2329 } 2330 2331 ret = host->bus_ops->reset(host); 2332 mmc_bus_put(host); 2333 2334 pr_warn("%s: tried to reset card\n", mmc_hostname(host)); 2335 2336 return ret; 2337 } 2338 EXPORT_SYMBOL(mmc_hw_reset); 2339 2340 static int mmc_rescan_try_freq(struct mmc_host *host, unsigned freq) 2341 { 2342 host->f_init = freq; 2343 2344 #ifdef CONFIG_MMC_DEBUG 2345 pr_info("%s: %s: trying to init card at %u Hz\n", 2346 mmc_hostname(host), __func__, host->f_init); 2347 #endif 2348 mmc_power_up(host, host->ocr_avail); 2349 2350 /* 2351 * Some eMMCs (with VCCQ always on) may not be reset after power up, so 2352 * do a hardware reset if possible. 2353 */ 2354 mmc_hw_reset_for_init(host); 2355 2356 /* 2357 * sdio_reset sends CMD52 to reset card. Since we do not know 2358 * if the card is being re-initialized, just send it. CMD52 2359 * should be ignored by SD/eMMC cards. 2360 */ 2361 sdio_reset(host); 2362 mmc_go_idle(host); 2363 2364 mmc_send_if_cond(host, host->ocr_avail); 2365 2366 /* Order's important: probe SDIO, then SD, then MMC */ 2367 if (!mmc_attach_sdio(host)) 2368 return 0; 2369 if (!mmc_attach_sd(host)) 2370 return 0; 2371 if (!mmc_attach_mmc(host)) 2372 return 0; 2373 2374 mmc_power_off(host); 2375 return -EIO; 2376 } 2377 2378 int _mmc_detect_card_removed(struct mmc_host *host) 2379 { 2380 int ret; 2381 2382 if (host->caps & MMC_CAP_NONREMOVABLE) 2383 return 0; 2384 2385 if (!host->card || mmc_card_removed(host->card)) 2386 return 1; 2387 2388 ret = host->bus_ops->alive(host); 2389 2390 /* 2391 * Card detect status and alive check may be out of sync if card is 2392 * removed slowly, when card detect switch changes while card/slot 2393 * pads are still contacted in hardware (refer to "SD Card Mechanical 2394 * Addendum, Appendix C: Card Detection Switch"). So reschedule a 2395 * detect work 200ms later for this case. 2396 */ 2397 if (!ret && host->ops->get_cd && !host->ops->get_cd(host)) { 2398 mmc_detect_change(host, msecs_to_jiffies(200)); 2399 pr_debug("%s: card removed too slowly\n", mmc_hostname(host)); 2400 } 2401 2402 if (ret) { 2403 mmc_card_set_removed(host->card); 2404 pr_debug("%s: card remove detected\n", mmc_hostname(host)); 2405 } 2406 2407 return ret; 2408 } 2409 2410 int mmc_detect_card_removed(struct mmc_host *host) 2411 { 2412 struct mmc_card *card = host->card; 2413 int ret; 2414 2415 WARN_ON(!host->claimed); 2416 2417 if (!card) 2418 return 1; 2419 2420 ret = mmc_card_removed(card); 2421 /* 2422 * The card will be considered unchanged unless we have been asked to 2423 * detect a change or host requires polling to provide card detection. 2424 */ 2425 if (!host->detect_change && !(host->caps & MMC_CAP_NEEDS_POLL)) 2426 return ret; 2427 2428 host->detect_change = 0; 2429 if (!ret) { 2430 ret = _mmc_detect_card_removed(host); 2431 if (ret && (host->caps & MMC_CAP_NEEDS_POLL)) { 2432 /* 2433 * Schedule a detect work as soon as possible to let a 2434 * rescan handle the card removal. 2435 */ 2436 cancel_delayed_work(&host->detect); 2437 _mmc_detect_change(host, 0, false); 2438 } 2439 } 2440 2441 return ret; 2442 } 2443 EXPORT_SYMBOL(mmc_detect_card_removed); 2444 2445 void mmc_rescan(struct work_struct *work) 2446 { 2447 struct mmc_host *host = 2448 container_of(work, struct mmc_host, detect.work); 2449 int i; 2450 2451 if (host->trigger_card_event && host->ops->card_event) { 2452 host->ops->card_event(host); 2453 host->trigger_card_event = false; 2454 } 2455 2456 if (host->rescan_disable) 2457 return; 2458 2459 /* If there is a non-removable card registered, only scan once */ 2460 if ((host->caps & MMC_CAP_NONREMOVABLE) && host->rescan_entered) 2461 return; 2462 host->rescan_entered = 1; 2463 2464 mmc_bus_get(host); 2465 2466 /* 2467 * if there is a _removable_ card registered, check whether it is 2468 * still present 2469 */ 2470 if (host->bus_ops && !host->bus_dead 2471 && !(host->caps & MMC_CAP_NONREMOVABLE)) 2472 host->bus_ops->detect(host); 2473 2474 host->detect_change = 0; 2475 2476 /* 2477 * Let mmc_bus_put() free the bus/bus_ops if we've found that 2478 * the card is no longer present. 2479 */ 2480 mmc_bus_put(host); 2481 mmc_bus_get(host); 2482 2483 /* if there still is a card present, stop here */ 2484 if (host->bus_ops != NULL) { 2485 mmc_bus_put(host); 2486 goto out; 2487 } 2488 2489 /* 2490 * Only we can add a new handler, so it's safe to 2491 * release the lock here. 2492 */ 2493 mmc_bus_put(host); 2494 2495 if (!(host->caps & MMC_CAP_NONREMOVABLE) && host->ops->get_cd && 2496 host->ops->get_cd(host) == 0) { 2497 mmc_claim_host(host); 2498 mmc_power_off(host); 2499 mmc_release_host(host); 2500 goto out; 2501 } 2502 2503 mmc_claim_host(host); 2504 for (i = 0; i < ARRAY_SIZE(freqs); i++) { 2505 if (!mmc_rescan_try_freq(host, max(freqs[i], host->f_min))) 2506 break; 2507 if (freqs[i] <= host->f_min) 2508 break; 2509 } 2510 mmc_release_host(host); 2511 2512 out: 2513 if (host->caps & MMC_CAP_NEEDS_POLL) 2514 mmc_schedule_delayed_work(&host->detect, HZ); 2515 } 2516 2517 void mmc_start_host(struct mmc_host *host) 2518 { 2519 host->f_init = max(freqs[0], host->f_min); 2520 host->rescan_disable = 0; 2521 host->ios.power_mode = MMC_POWER_UNDEFINED; 2522 if (host->caps2 & MMC_CAP2_NO_PRESCAN_POWERUP) 2523 mmc_power_off(host); 2524 else 2525 mmc_power_up(host, host->ocr_avail); 2526 mmc_gpiod_request_cd_irq(host); 2527 _mmc_detect_change(host, 0, false); 2528 } 2529 2530 void mmc_stop_host(struct mmc_host *host) 2531 { 2532 #ifdef CONFIG_MMC_DEBUG 2533 unsigned long flags; 2534 spin_lock_irqsave(&host->lock, flags); 2535 host->removed = 1; 2536 spin_unlock_irqrestore(&host->lock, flags); 2537 #endif 2538 if (host->slot.cd_irq >= 0) 2539 disable_irq(host->slot.cd_irq); 2540 2541 host->rescan_disable = 1; 2542 cancel_delayed_work_sync(&host->detect); 2543 mmc_flush_scheduled_work(); 2544 2545 /* clear pm flags now and let card drivers set them as needed */ 2546 host->pm_flags = 0; 2547 2548 mmc_bus_get(host); 2549 if (host->bus_ops && !host->bus_dead) { 2550 /* Calling bus_ops->remove() with a claimed host can deadlock */ 2551 host->bus_ops->remove(host); 2552 mmc_claim_host(host); 2553 mmc_detach_bus(host); 2554 mmc_power_off(host); 2555 mmc_release_host(host); 2556 mmc_bus_put(host); 2557 return; 2558 } 2559 mmc_bus_put(host); 2560 2561 BUG_ON(host->card); 2562 2563 mmc_power_off(host); 2564 } 2565 2566 int mmc_power_save_host(struct mmc_host *host) 2567 { 2568 int ret = 0; 2569 2570 #ifdef CONFIG_MMC_DEBUG 2571 pr_info("%s: %s: powering down\n", mmc_hostname(host), __func__); 2572 #endif 2573 2574 mmc_bus_get(host); 2575 2576 if (!host->bus_ops || host->bus_dead) { 2577 mmc_bus_put(host); 2578 return -EINVAL; 2579 } 2580 2581 if (host->bus_ops->power_save) 2582 ret = host->bus_ops->power_save(host); 2583 2584 mmc_bus_put(host); 2585 2586 mmc_power_off(host); 2587 2588 return ret; 2589 } 2590 EXPORT_SYMBOL(mmc_power_save_host); 2591 2592 int mmc_power_restore_host(struct mmc_host *host) 2593 { 2594 int ret; 2595 2596 #ifdef CONFIG_MMC_DEBUG 2597 pr_info("%s: %s: powering up\n", mmc_hostname(host), __func__); 2598 #endif 2599 2600 mmc_bus_get(host); 2601 2602 if (!host->bus_ops || host->bus_dead) { 2603 mmc_bus_put(host); 2604 return -EINVAL; 2605 } 2606 2607 mmc_power_up(host, host->card->ocr); 2608 ret = host->bus_ops->power_restore(host); 2609 2610 mmc_bus_put(host); 2611 2612 return ret; 2613 } 2614 EXPORT_SYMBOL(mmc_power_restore_host); 2615 2616 /* 2617 * Flush the cache to the non-volatile storage. 2618 */ 2619 int mmc_flush_cache(struct mmc_card *card) 2620 { 2621 int err = 0; 2622 2623 if (mmc_card_mmc(card) && 2624 (card->ext_csd.cache_size > 0) && 2625 (card->ext_csd.cache_ctrl & 1)) { 2626 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, 2627 EXT_CSD_FLUSH_CACHE, 1, 0); 2628 if (err) 2629 pr_err("%s: cache flush error %d\n", 2630 mmc_hostname(card->host), err); 2631 } 2632 2633 return err; 2634 } 2635 EXPORT_SYMBOL(mmc_flush_cache); 2636 2637 #ifdef CONFIG_PM 2638 2639 /* Do the card removal on suspend if card is assumed removeable 2640 * Do that in pm notifier while userspace isn't yet frozen, so we will be able 2641 to sync the card. 2642 */ 2643 int mmc_pm_notify(struct notifier_block *notify_block, 2644 unsigned long mode, void *unused) 2645 { 2646 struct mmc_host *host = container_of( 2647 notify_block, struct mmc_host, pm_notify); 2648 unsigned long flags; 2649 int err = 0; 2650 2651 switch (mode) { 2652 case PM_HIBERNATION_PREPARE: 2653 case PM_SUSPEND_PREPARE: 2654 case PM_RESTORE_PREPARE: 2655 spin_lock_irqsave(&host->lock, flags); 2656 host->rescan_disable = 1; 2657 spin_unlock_irqrestore(&host->lock, flags); 2658 cancel_delayed_work_sync(&host->detect); 2659 2660 if (!host->bus_ops) 2661 break; 2662 2663 /* Validate prerequisites for suspend */ 2664 if (host->bus_ops->pre_suspend) 2665 err = host->bus_ops->pre_suspend(host); 2666 if (!err) 2667 break; 2668 2669 /* Calling bus_ops->remove() with a claimed host can deadlock */ 2670 host->bus_ops->remove(host); 2671 mmc_claim_host(host); 2672 mmc_detach_bus(host); 2673 mmc_power_off(host); 2674 mmc_release_host(host); 2675 host->pm_flags = 0; 2676 break; 2677 2678 case PM_POST_SUSPEND: 2679 case PM_POST_HIBERNATION: 2680 case PM_POST_RESTORE: 2681 2682 spin_lock_irqsave(&host->lock, flags); 2683 host->rescan_disable = 0; 2684 spin_unlock_irqrestore(&host->lock, flags); 2685 _mmc_detect_change(host, 0, false); 2686 2687 } 2688 2689 return 0; 2690 } 2691 #endif 2692 2693 /** 2694 * mmc_init_context_info() - init synchronization context 2695 * @host: mmc host 2696 * 2697 * Init struct context_info needed to implement asynchronous 2698 * request mechanism, used by mmc core, host driver and mmc requests 2699 * supplier. 2700 */ 2701 void mmc_init_context_info(struct mmc_host *host) 2702 { 2703 spin_lock_init(&host->context_info.lock); 2704 host->context_info.is_new_req = false; 2705 host->context_info.is_done_rcv = false; 2706 host->context_info.is_waiting_last_req = false; 2707 init_waitqueue_head(&host->context_info.wait); 2708 } 2709 2710 static int __init mmc_init(void) 2711 { 2712 int ret; 2713 2714 workqueue = alloc_ordered_workqueue("kmmcd", 0); 2715 if (!workqueue) 2716 return -ENOMEM; 2717 2718 ret = mmc_register_bus(); 2719 if (ret) 2720 goto destroy_workqueue; 2721 2722 ret = mmc_register_host_class(); 2723 if (ret) 2724 goto unregister_bus; 2725 2726 ret = sdio_register_bus(); 2727 if (ret) 2728 goto unregister_host_class; 2729 2730 return 0; 2731 2732 unregister_host_class: 2733 mmc_unregister_host_class(); 2734 unregister_bus: 2735 mmc_unregister_bus(); 2736 destroy_workqueue: 2737 destroy_workqueue(workqueue); 2738 2739 return ret; 2740 } 2741 2742 static void __exit mmc_exit(void) 2743 { 2744 sdio_unregister_bus(); 2745 mmc_unregister_host_class(); 2746 mmc_unregister_bus(); 2747 destroy_workqueue(workqueue); 2748 } 2749 2750 subsys_initcall(mmc_init); 2751 module_exit(mmc_exit); 2752 2753 MODULE_LICENSE("GPL"); 2754