drivers/mmc/core/core.c

   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
  26 #include <linux/mmc/card.h>
  27 #include <linux/mmc/host.h>
  28 #include <linux/mmc/mmc.h>
  29 #include <linux/mmc/sd.h>
  30
  31 #include "core.h"
  32 #include "bus.h"
  33 #include "host.h"
  34 #include "sdio_bus.h"
  35
  36 #include "mmc_ops.h"
  37 #include "sd_ops.h"
  38 #include "sdio_ops.h"
  39
  40 static struct workqueue_struct *workqueue;
  41
  42 /*
  43  * Enabling software CRCs on the data blocks can be a significant (30%)
  44  * performance cost, and for other reasons may not always be desired.
  45  * So we allow it it to be disabled.
  46  */
  47 int use_spi_crc = 1;
  48 module_param(use_spi_crc, bool, 0);
  49
  50 /*
  51  * Internal function. Schedule delayed work in the MMC work queue.
  52  */
  53 static int mmc_schedule_delayed_work(struct delayed_work *work,
  54                                      unsigned long delay)
  55 {
  56         return queue_delayed_work(workqueue, work, delay);
  57 }
  58
  59 /*
  60  * Internal function. Flush all scheduled work from the MMC work queue.
  61  */
  62 static void mmc_flush_scheduled_work(void)
  63 {
  64         flush_workqueue(workqueue);
  65 }
  66
  67 /**
  68  *      mmc_request_done - finish processing an MMC request
  69  *      @host: MMC host which completed request
  70  *      @mrq: MMC request which request
  71  *
  72  *      MMC drivers should call this function when they have completed
  73  *      their processing of a request.
  74  */
  75 void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
  76 {
  77         struct mmc_command *cmd = mrq->cmd;
  78         int err = cmd->error;
  79
  80         if (err && cmd->retries && mmc_host_is_spi(host)) {
  81                 if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
  82                         cmd->retries = 0;
  83         }
  84
  85         if (err && cmd->retries) {
  86                 pr_debug("%s: req failed (CMD%u): %d, retrying...\n",
  87                         mmc_hostname(host), cmd->opcode, err);
  88
  89                 cmd->retries--;
  90                 cmd->error = 0;
  91                 host->ops->request(host, mrq);
  92         } else {
  93                 led_trigger_event(host->led, LED_OFF);
  94
  95                 pr_debug("%s: req done (CMD%u): %d: %08x %08x %08x %08x\n",
  96                         mmc_hostname(host), cmd->opcode, err,
  97                         cmd->resp[0], cmd->resp[1],
  98                         cmd->resp[2], cmd->resp[3]);
  99
 100                 if (mrq->data) {
 101                         pr_debug("%s:     %d bytes transferred: %d\n",
 102                                 mmc_hostname(host),
 103                                 mrq->data->bytes_xfered, mrq->data->error);
 104                 }
 105
 106                 if (mrq->stop) {
 107                         pr_debug("%s:     (CMD%u): %d: %08x %08x %08x %08x\n",
 108                                 mmc_hostname(host), mrq->stop->opcode,
 109                                 mrq->stop->error,
 110                                 mrq->stop->resp[0], mrq->stop->resp[1],
 111                                 mrq->stop->resp[2], mrq->stop->resp[3]);
 112                 }
 113
 114                 if (mrq->done)
 115                         mrq->done(mrq);
 116         }
 117 }
 118
 119 EXPORT_SYMBOL(mmc_request_done);
 120
 121 static void
 122 mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
 123 {
 124 #ifdef CONFIG_MMC_DEBUG
 125         unsigned int i, sz;
 126         struct scatterlist *sg;
 127 #endif
 128
 129         pr_debug("%s: starting CMD%u arg %08x flags %08x\n",
 130                  mmc_hostname(host), mrq->cmd->opcode,
 131                  mrq->cmd->arg, mrq->cmd->flags);
 132
 133         if (mrq->data) {
 134                 pr_debug("%s:     blksz %d blocks %d flags %08x "
 135                         "tsac %d ms nsac %d\n",
 136                         mmc_hostname(host), mrq->data->blksz,
 137                         mrq->data->blocks, mrq->data->flags,
 138                         mrq->data->timeout_ns / 1000000,
 139                         mrq->data->timeout_clks);
 140         }
 141
 142         if (mrq->stop) {
 143                 pr_debug("%s:     CMD%u arg %08x flags %08x\n",
 144                          mmc_hostname(host), mrq->stop->opcode,
 145                          mrq->stop->arg, mrq->stop->flags);
 146         }
 147
 148         WARN_ON(!host->claimed);
 149
 150         led_trigger_event(host->led, LED_FULL);
 151
 152         mrq->cmd->error = 0;
 153         mrq->cmd->mrq = mrq;
 154         if (mrq->data) {
 155                 BUG_ON(mrq->data->blksz > host->max_blk_size);
 156                 BUG_ON(mrq->data->blocks > host->max_blk_count);
 157                 BUG_ON(mrq->data->blocks * mrq->data->blksz >
 158                         host->max_req_size);
 159
 160 #ifdef CONFIG_MMC_DEBUG
 161                 sz = 0;
 162                 for_each_sg(mrq->data->sg, sg, mrq->data->sg_len, i)
 163                         sz += sg->length;
 164                 BUG_ON(sz != mrq->data->blocks * mrq->data->blksz);
 165 #endif
 166
 167                 mrq->cmd->data = mrq->data;
 168                 mrq->data->error = 0;
 169                 mrq->data->mrq = mrq;
 170                 if (mrq->stop) {
 171                         mrq->data->stop = mrq->stop;
 172                         mrq->stop->error = 0;
 173                         mrq->stop->mrq = mrq;
 174                 }
 175         }
 176         host->ops->request(host, mrq);
 177 }
 178
 179 static void mmc_wait_done(struct mmc_request *mrq)
 180 {
 181         complete(mrq->done_data);
 182 }
 183
 184 /**
 185  *      mmc_wait_for_req - start a request and wait for completion
 186  *      @host: MMC host to start command
 187  *      @mrq: MMC request to start
 188  *
 189  *      Start a new MMC custom command request for a host, and wait
 190  *      for the command to complete. Does not attempt to parse the
 191  *      response.
 192  */
 193 void mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq)
 194 {
 195         DECLARE_COMPLETION_ONSTACK(complete);
 196
 197         mrq->done_data = &complete;
 198         mrq->done = mmc_wait_done;
 199
 200         mmc_start_request(host, mrq);
 201
 202         wait_for_completion(&complete);
 203 }
 204
 205 EXPORT_SYMBOL(mmc_wait_for_req);
 206
 207 /**
 208  *      mmc_wait_for_cmd - start a command and wait for completion
 209  *      @host: MMC host to start command
 210  *      @cmd: MMC command to start
 211  *      @retries: maximum number of retries
 212  *
 213  *      Start a new MMC command for a host, and wait for the command
 214  *      to complete.  Return any error that occurred while the command
 215  *      was executing.  Do not attempt to parse the response.
 216  */
 217 int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries)
 218 {
 219         struct mmc_request mrq;
 220
 221         WARN_ON(!host->claimed);
 222
 223         memset(&mrq, 0, sizeof(struct mmc_request));
 224
 225         memset(cmd->resp, 0, sizeof(cmd->resp));
 226         cmd->retries = retries;
 227
 228         mrq.cmd = cmd;
 229         cmd->data = NULL;
 230
 231         mmc_wait_for_req(host, &mrq);
 232
 233         return cmd->error;
 234 }
 235
 236 EXPORT_SYMBOL(mmc_wait_for_cmd);
 237
 238 /**
 239  *      mmc_set_data_timeout - set the timeout for a data command
 240  *      @data: data phase for command
 241  *      @card: the MMC card associated with the data transfer
 242  *
 243  *      Computes the data timeout parameters according to the
 244  *      correct algorithm given the card type.
 245  */
 246 void mmc_set_data_timeout(struct mmc_data *data, const struct mmc_card *card)
 247 {
 248         unsigned int mult;
 249
 250         /*
 251          * SDIO cards only define an upper 1 s limit on access.
 252          */
 253         if (mmc_card_sdio(card)) {
 254                 data->timeout_ns = 1000000000;
 255                 data->timeout_clks = 0;
 256                 return;
 257         }
 258
 259         /*
 260          * SD cards use a 100 multiplier rather than 10
 261          */
 262         mult = mmc_card_sd(card) ? 100 : 10;
 263
 264         /*
 265          * Scale up the multiplier (and therefore the timeout) by
 266          * the r2w factor for writes.
 267          */
 268         if (data->flags & MMC_DATA_WRITE)
 269                 mult <<= card->csd.r2w_factor;
 270
 271         data->timeout_ns = card->csd.tacc_ns * mult;
 272         data->timeout_clks = card->csd.tacc_clks * mult;
 273
 274         /*
 275          * SD cards also have an upper limit on the timeout.
 276          */
 277         if (mmc_card_sd(card)) {
 278                 unsigned int timeout_us, limit_us;
 279
 280                 timeout_us = data->timeout_ns / 1000;
 281                 timeout_us += data->timeout_clks * 1000 /
 282                         (card->host->ios.clock / 1000);
 283
 284                 if (data->flags & MMC_DATA_WRITE)
 285                         /*
 286                          * The limit is really 250 ms, but that is
 287                          * insufficient for some crappy cards.
 288                          */
 289                         limit_us = 300000;
 290                 else
 291                         limit_us = 100000;
 292
 293                 /*
 294                  * SDHC cards always use these fixed values.
 295                  */
 296                 if (timeout_us > limit_us || mmc_card_blockaddr(card)) {
 297                         data->timeout_ns = limit_us * 1000;
 298                         data->timeout_clks = 0;
 299                 }
 300         }
 301         /*
 302          * Some cards need very high timeouts if driven in SPI mode.
 303          * The worst observed timeout was 900ms after writing a
 304          * continuous stream of data until the internal logic
 305          * overflowed.
 306          */
 307         if (mmc_host_is_spi(card->host)) {
 308                 if (data->flags & MMC_DATA_WRITE) {
 309                         if (data->timeout_ns < 1000000000)
 310                                 data->timeout_ns = 1000000000;  /* 1s */
 311                 } else {
 312                         if (data->timeout_ns < 100000000)
 313                                 data->timeout_ns =  100000000;  /* 100ms */
 314                 }
 315         }
 316 }
 317 EXPORT_SYMBOL(mmc_set_data_timeout);
 318
 319 /**
 320  *      mmc_align_data_size - pads a transfer size to a more optimal value
 321  *      @card: the MMC card associated with the data transfer
 322  *      @sz: original transfer size
 323  *
 324  *      Pads the original data size with a number of extra bytes in
 325  *      order to avoid controller bugs and/or performance hits
 326  *      (e.g. some controllers revert to PIO for certain sizes).
 327  *
 328  *      Returns the improved size, which might be unmodified.
 329  *
 330  *      Note that this function is only relevant when issuing a
 331  *      single scatter gather entry.
 332  */
 333 unsigned int mmc_align_data_size(struct mmc_card *card, unsigned int sz)
 334 {
 335         /*
 336          * FIXME: We don't have a system for the controller to tell
 337          * the core about its problems yet, so for now we just 32-bit
 338          * align the size.
 339          */
 340         sz = ((sz + 3) / 4) * 4;
 341
 342         return sz;
 343 }
 344 EXPORT_SYMBOL(mmc_align_data_size);
 345
 346 /**
 347  *      mmc_host_enable - enable a host.
 348  *      @host: mmc host to enable
 349  *
 350  *      Hosts that support power saving can use the 'enable' and 'disable'
 351  *      methods to exit and enter power saving states. For more information
 352  *      see comments for struct mmc_host_ops.
 353  */
 354 int mmc_host_enable(struct mmc_host *host)
 355 {
 356         if (!(host->caps & MMC_CAP_DISABLE))
 357                 return 0;
 358
 359         if (host->en_dis_recurs)
 360                 return 0;
 361
 362         if (host->nesting_cnt++)
 363                 return 0;
 364
 365         cancel_delayed_work_sync(&host->disable);
 366
 367         if (host->enabled)
 368                 return 0;
 369
 370         if (host->ops->enable) {
 371                 int err;
 372
 373                 host->en_dis_recurs = 1;
 374                 err = host->ops->enable(host);
 375                 host->en_dis_recurs = 0;
 376
 377                 if (err) {
 378                         pr_debug("%s: enable error %d\n",
 379                                  mmc_hostname(host), err);
 380                         return err;
 381                 }
 382         }
 383         host->enabled = 1;
 384         return 0;
 385 }
 386 EXPORT_SYMBOL(mmc_host_enable);
 387
 388 static int mmc_host_do_disable(struct mmc_host *host, int lazy)
 389 {
 390         if (host->ops->disable) {
 391                 int err;
 392
 393                 host->en_dis_recurs = 1;
 394                 err = host->ops->disable(host, lazy);
 395                 host->en_dis_recurs = 0;
 396
 397                 if (err < 0) {
 398                         pr_debug("%s: disable error %d\n",
 399                                  mmc_hostname(host), err);
 400                         return err;
 401                 }
 402                 if (err > 0) {
 403                         unsigned long delay = msecs_to_jiffies(err);
 404
 405                         mmc_schedule_delayed_work(&host->disable, delay);
 406                 }
 407         }
 408         host->enabled = 0;
 409         return 0;
 410 }
 411
 412 /**
 413  *      mmc_host_disable - disable a host.
 414  *      @host: mmc host to disable
 415  *
 416  *      Hosts that support power saving can use the 'enable' and 'disable'
 417  *      methods to exit and enter power saving states. For more information
 418  *      see comments for struct mmc_host_ops.
 419  */
 420 int mmc_host_disable(struct mmc_host *host)
 421 {
 422         int err;
 423
 424         if (!(host->caps & MMC_CAP_DISABLE))
 425                 return 0;
 426
 427         if (host->en_dis_recurs)
 428                 return 0;
 429
 430         if (--host->nesting_cnt)
 431                 return 0;
 432
 433         if (!host->enabled)
 434                 return 0;
 435
 436         err = mmc_host_do_disable(host, 0);
 437         return err;
 438 }
 439 EXPORT_SYMBOL(mmc_host_disable);
 440
 441 /**
 442  *      __mmc_claim_host - exclusively claim a host
 443  *      @host: mmc host to claim
 444  *      @abort: whether or not the operation should be aborted
 445  *
 446  *      Claim a host for a set of operations.  If @abort is non null and
 447  *      dereference a non-zero value then this will return prematurely with
 448  *      that non-zero value without acquiring the lock.  Returns zero
 449  *      with the lock held otherwise.
 450  */
 451 int __mmc_claim_host(struct mmc_host *host, atomic_t *abort)
 452 {
 453         DECLARE_WAITQUEUE(wait, current);
 454         unsigned long flags;
 455         int stop;
 456
 457         might_sleep();
 458
 459         add_wait_queue(&host->wq, &wait);
 460         spin_lock_irqsave(&host->lock, flags);
 461         while (1) {
 462                 set_current_state(TASK_UNINTERRUPTIBLE);
 463                 stop = abort ? atomic_read(abort) : 0;
 464                 if (stop || !host->claimed || host->claimer == current)
 465                         break;
 466                 spin_unlock_irqrestore(&host->lock, flags);
 467                 schedule();
 468                 spin_lock_irqsave(&host->lock, flags);
 469         }
 470         set_current_state(TASK_RUNNING);
 471         if (!stop) {
 472                 host->claimed = 1;
 473                 host->claimer = current;
 474                 host->claim_cnt += 1;
 475         } else
 476                 wake_up(&host->wq);
 477         spin_unlock_irqrestore(&host->lock, flags);
 478         remove_wait_queue(&host->wq, &wait);
 479         if (!stop)
 480                 mmc_host_enable(host);
 481         return stop;
 482 }
 483
 484 EXPORT_SYMBOL(__mmc_claim_host);
 485
 486 /**
 487  *      mmc_try_claim_host - try exclusively to claim a host
 488  *      @host: mmc host to claim
 489  *
 490  *      Returns %1 if the host is claimed, %0 otherwise.
 491  */
 492 int mmc_try_claim_host(struct mmc_host *host)
 493 {
 494         int claimed_host = 0;
 495         unsigned long flags;
 496
 497         spin_lock_irqsave(&host->lock, flags);
 498         if (!host->claimed || host->claimer == current) {
 499                 host->claimed = 1;
 500                 host->claimer = current;
 501                 host->claim_cnt += 1;
 502                 claimed_host = 1;
 503         }
 504         spin_unlock_irqrestore(&host->lock, flags);
 505         return claimed_host;
 506 }
 507 EXPORT_SYMBOL(mmc_try_claim_host);
 508
 509 static void mmc_do_release_host(struct mmc_host *host)
 510 {
 511         unsigned long flags;
 512
 513         spin_lock_irqsave(&host->lock, flags);
 514         if (--host->claim_cnt) {
 515                 /* Release for nested claim */
 516                 spin_unlock_irqrestore(&host->lock, flags);
 517         } else {
 518                 host->claimed = 0;
 519                 host->claimer = NULL;
 520                 spin_unlock_irqrestore(&host->lock, flags);
 521                 wake_up(&host->wq);
 522         }
 523 }
 524
 525 void mmc_host_deeper_disable(struct work_struct *work)
 526 {
 527         struct mmc_host *host =
 528                 container_of(work, struct mmc_host, disable.work);
 529
 530         /* If the host is claimed then we do not want to disable it anymore */
 531         if (!mmc_try_claim_host(host))
 532                 return;
 533         mmc_host_do_disable(host, 1);
 534         mmc_do_release_host(host);
 535 }
 536
 537 /**
 538  *      mmc_host_lazy_disable - lazily disable a host.
 539  *      @host: mmc host to disable
 540  *
 541  *      Hosts that support power saving can use the 'enable' and 'disable'
 542  *      methods to exit and enter power saving states. For more information
 543  *      see comments for struct mmc_host_ops.
 544  */
 545 int mmc_host_lazy_disable(struct mmc_host *host)
 546 {
 547         if (!(host->caps & MMC_CAP_DISABLE))
 548                 return 0;
 549
 550         if (host->en_dis_recurs)
 551                 return 0;
 552
 553         if (--host->nesting_cnt)
 554                 return 0;
 555
 556         if (!host->enabled)
 557                 return 0;
 558
 559         if (host->disable_delay) {
 560                 mmc_schedule_delayed_work(&host->disable,
 561                                 msecs_to_jiffies(host->disable_delay));
 562                 return 0;
 563         } else
 564                 return mmc_host_do_disable(host, 1);
 565 }
 566 EXPORT_SYMBOL(mmc_host_lazy_disable);
 567
 568 /**
 569  *      mmc_release_host - release a host
 570  *      @host: mmc host to release
 571  *
 572  *      Release a MMC host, allowing others to claim the host
 573  *      for their operations.
 574  */
 575 void mmc_release_host(struct mmc_host *host)
 576 {
 577         WARN_ON(!host->claimed);
 578
 579         mmc_host_lazy_disable(host);
 580
 581         mmc_do_release_host(host);
 582 }
 583
 584 EXPORT_SYMBOL(mmc_release_host);
 585
 586 /*
 587  * Internal function that does the actual ios call to the host driver,
 588  * optionally printing some debug output.
 589  */
 590 static inline void mmc_set_ios(struct mmc_host *host)
 591 {
 592         struct mmc_ios *ios = &host->ios;
 593
 594         pr_debug("%s: clock %uHz busmode %u powermode %u cs %u Vdd %u "
 595                 "width %u timing %u\n",
 596                  mmc_hostname(host), ios->clock, ios->bus_mode,
 597                  ios->power_mode, ios->chip_select, ios->vdd,
 598                  ios->bus_width, ios->timing);
 599
 600         host->ops->set_ios(host, ios);
 601 }
 602
 603 /*
 604  * Control chip select pin on a host.
 605  */
 606 void mmc_set_chip_select(struct mmc_host *host, int mode)
 607 {
 608         host->ios.chip_select = mode;
 609         mmc_set_ios(host);
 610 }
 611
 612 /*
 613  * Sets the host clock to the highest possible frequency that
 614  * is below "hz".
 615  */
 616 void mmc_set_clock(struct mmc_host *host, unsigned int hz)
 617 {
 618         WARN_ON(hz < host->f_min);
 619
 620         if (hz > host->f_max)
 621                 hz = host->f_max;
 622
 623         host->ios.clock = hz;
 624         mmc_set_ios(host);
 625 }
 626
 627 /*
 628  * Change the bus mode (open drain/push-pull) of a host.
 629  */
 630 void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
 631 {
 632         host->ios.bus_mode = mode;
 633         mmc_set_ios(host);
 634 }
 635
 636 /*
 637  * Change data bus width of a host.
 638  */
 639 void mmc_set_bus_width(struct mmc_host *host, unsigned int width)
 640 {
 641         host->ios.bus_width = width;
 642         mmc_set_ios(host);
 643 }
 644
 645 /**
 646  * mmc_vdd_to_ocrbitnum - Convert a voltage to the OCR bit number
 647  * @vdd:        voltage (mV)
 648  * @low_bits:   prefer low bits in boundary cases
 649  *
 650  * This function returns the OCR bit number according to the provided @vdd
 651  * value. If conversion is not possible a negative errno value returned.
 652  *
 653  * Depending on the @low_bits flag the function prefers low or high OCR bits
 654  * on boundary voltages. For example,
 655  * with @low_bits = true, 3300 mV translates to ilog2(MMC_VDD_32_33);
 656  * with @low_bits = false, 3300 mV translates to ilog2(MMC_VDD_33_34);
 657  *
 658  * Any value in the [1951:1999] range translates to the ilog2(MMC_VDD_20_21).
 659  */
 660 static int mmc_vdd_to_ocrbitnum(int vdd, bool low_bits)
 661 {
 662         const int max_bit = ilog2(MMC_VDD_35_36);
 663         int bit;
 664
 665         if (vdd < 1650 || vdd > 3600)
 666                 return -EINVAL;
 667
 668         if (vdd >= 1650 && vdd <= 1950)
 669                 return ilog2(MMC_VDD_165_195);
 670
 671         if (low_bits)
 672                 vdd -= 1;
 673
 674         /* Base 2000 mV, step 100 mV, bit's base 8. */
 675         bit = (vdd - 2000) / 100 + 8;
 676         if (bit > max_bit)
 677                 return max_bit;
 678         return bit;
 679 }
 680
 681 /**
 682  * mmc_vddrange_to_ocrmask - Convert a voltage range to the OCR mask
 683  * @vdd_min:    minimum voltage value (mV)
 684  * @vdd_max:    maximum voltage value (mV)
 685  *
 686  * This function returns the OCR mask bits according to the provided @vdd_min
 687  * and @vdd_max values. If conversion is not possible the function returns 0.
 688  *
 689  * Notes wrt boundary cases:
 690  * This function sets the OCR bits for all boundary voltages, for example
 691  * [3300:3400] range is translated to MMC_VDD_32_33 | MMC_VDD_33_34 |
 692  * MMC_VDD_34_35 mask.
 693  */
 694 u32 mmc_vddrange_to_ocrmask(int vdd_min, int vdd_max)
 695 {
 696         u32 mask = 0;
 697
 698         if (vdd_max < vdd_min)
 699                 return 0;
 700
 701         /* Prefer high bits for the boundary vdd_max values. */
 702         vdd_max = mmc_vdd_to_ocrbitnum(vdd_max, false);
 703         if (vdd_max < 0)
 704                 return 0;
 705
 706         /* Prefer low bits for the boundary vdd_min values. */
 707         vdd_min = mmc_vdd_to_ocrbitnum(vdd_min, true);
 708         if (vdd_min < 0)
 709                 return 0;
 710
 711         /* Fill the mask, from max bit to min bit. */
 712         while (vdd_max >= vdd_min)
 713                 mask |= 1 << vdd_max--;
 714
 715         return mask;
 716 }
 717 EXPORT_SYMBOL(mmc_vddrange_to_ocrmask);
 718
 719 #ifdef CONFIG_REGULATOR
 720
 721 /**
 722  * mmc_regulator_get_ocrmask - return mask of supported voltages
 723  * @supply: regulator to use
 724  *
 725  * This returns either a negative errno, or a mask of voltages that
 726  * can be provided to MMC/SD/SDIO devices using the specified voltage
 727  * regulator.  This would normally be called before registering the
 728  * MMC host adapter.
 729  */
 730 int mmc_regulator_get_ocrmask(struct regulator *supply)
 731 {
 732         int                     result = 0;
 733         int                     count;
 734         int                     i;
 735
 736         count = regulator_count_voltages(supply);
 737         if (count < 0)
 738                 return count;
 739
 740         for (i = 0; i < count; i++) {
 741                 int             vdd_uV;
 742                 int             vdd_mV;
 743
 744                 vdd_uV = regulator_list_voltage(supply, i);
 745                 if (vdd_uV <= 0)
 746                         continue;
 747
 748                 vdd_mV = vdd_uV / 1000;
 749                 result |= mmc_vddrange_to_ocrmask(vdd_mV, vdd_mV);
 750         }
 751
 752         return result;
 753 }
 754 EXPORT_SYMBOL(mmc_regulator_get_ocrmask);
 755
 756 /**
 757  * mmc_regulator_set_ocr - set regulator to match host->ios voltage
 758  * @vdd_bit: zero for power off, else a bit number (host->ios.vdd)
 759  * @supply: regulator to use
 760  *
 761  * Returns zero on success, else negative errno.
 762  *
 763  * MMC host drivers may use this to enable or disable a regulator using
 764  * a particular supply voltage.  This would normally be called from the
 765  * set_ios() method.
 766  */
 767 int mmc_regulator_set_ocr(struct regulator *supply, unsigned short vdd_bit)
 768 {
 769         int                     result = 0;
 770         int                     min_uV, max_uV;
 771         int                     enabled;
 772
 773         enabled = regulator_is_enabled(supply);
 774         if (enabled < 0)
 775                 return enabled;
 776
 777         if (vdd_bit) {
 778                 int             tmp;
 779                 int             voltage;
 780
 781                 /* REVISIT mmc_vddrange_to_ocrmask() may have set some
 782                  * bits this regulator doesn't quite support ... don't
 783                  * be too picky, most cards and regulators are OK with
 784                  * a 0.1V range goof (it's a small error percentage).
 785                  */
 786                 tmp = vdd_bit - ilog2(MMC_VDD_165_195);
 787                 if (tmp == 0) {
 788                         min_uV = 1650 * 1000;
 789                         max_uV = 1950 * 1000;
 790                 } else {
 791                         min_uV = 1900 * 1000 + tmp * 100 * 1000;
 792                         max_uV = min_uV + 100 * 1000;
 793                 }
 794
 795                 /* avoid needless changes to this voltage; the regulator
 796                  * might not allow this operation
 797                  */
 798                 voltage = regulator_get_voltage(supply);
 799                 if (voltage < 0)
 800                         result = voltage;
 801                 else if (voltage < min_uV || voltage > max_uV)
 802                         result = regulator_set_voltage(supply, min_uV, max_uV);
 803                 else
 804                         result = 0;
 805
 806                 if (result == 0 && !enabled)
 807                         result = regulator_enable(supply);
 808         } else if (enabled) {
 809                 result = regulator_disable(supply);
 810         }
 811
 812         return result;
 813 }
 814 EXPORT_SYMBOL(mmc_regulator_set_ocr);
 815
 816 #endif
 817
 818 /*
 819  * Mask off any voltages we don't support and select
 820  * the lowest voltage
 821  */
 822 u32 mmc_select_voltage(struct mmc_host *host, u32 ocr)
 823 {
 824         int bit;
 825
 826         ocr &= host->ocr_avail;
 827
 828         bit = ffs(ocr);
 829         if (bit) {
 830                 bit -= 1;
 831
 832                 ocr &= 3 << bit;
 833
 834                 host->ios.vdd = bit;
 835                 mmc_set_ios(host);
 836         } else {
 837                 pr_warning("%s: host doesn't support card's voltages\n",
 838                                 mmc_hostname(host));
 839                 ocr = 0;
 840         }
 841
 842         return ocr;
 843 }
 844
 845 /*
 846  * Select timing parameters for host.
 847  */
 848 void mmc_set_timing(struct mmc_host *host, unsigned int timing)
 849 {
 850         host->ios.timing = timing;
 851         mmc_set_ios(host);
 852 }
 853
 854 /*
 855  * Apply power to the MMC stack.  This is a two-stage process.
 856  * First, we enable power to the card without the clock running.
 857  * We then wait a bit for the power to stabilise.  Finally,
 858  * enable the bus drivers and clock to the card.
 859  *
 860  * We must _NOT_ enable the clock prior to power stablising.
 861  *
 862  * If a host does all the power sequencing itself, ignore the
 863  * initial MMC_POWER_UP stage.
 864  */
 865 static void mmc_power_up(struct mmc_host *host)
 866 {
 867         int bit;
 868
 869         /* If ocr is set, we use it */
 870         if (host->ocr)
 871                 bit = ffs(host->ocr) - 1;
 872         else
 873                 bit = fls(host->ocr_avail) - 1;
 874
 875         host->ios.vdd = bit;
 876         if (mmc_host_is_spi(host)) {
 877                 host->ios.chip_select = MMC_CS_HIGH;
 878                 host->ios.bus_mode = MMC_BUSMODE_PUSHPULL;
 879         } else {
 880                 host->ios.chip_select = MMC_CS_DONTCARE;
 881                 host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
 882         }
 883         host->ios.power_mode = MMC_POWER_UP;
 884         host->ios.bus_width = MMC_BUS_WIDTH_1;
 885         host->ios.timing = MMC_TIMING_LEGACY;
 886         mmc_set_ios(host);
 887
 888         /*
 889          * This delay should be sufficient to allow the power supply
 890          * to reach the minimum voltage.
 891          */
 892         mmc_delay(10);
 893
 894         if (host->f_min > 400000) {
 895                 pr_warning("%s: Minimum clock frequency too high for "
 896                                 "identification mode\n", mmc_hostname(host));
 897                 host->ios.clock = host->f_min;
 898         } else
 899                 host->ios.clock = 400000;
 900
 901         host->ios.power_mode = MMC_POWER_ON;
 902         mmc_set_ios(host);
 903
 904         /*
 905          * This delay must be at least 74 clock sizes, or 1 ms, or the
 906          * time required to reach a stable voltage.
 907          */
 908         mmc_delay(10);
 909 }
 910
 911 static void mmc_power_off(struct mmc_host *host)
 912 {
 913         host->ios.clock = 0;
 914         host->ios.vdd = 0;
 915         if (!mmc_host_is_spi(host)) {
 916                 host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
 917                 host->ios.chip_select = MMC_CS_DONTCARE;
 918         }
 919         host->ios.power_mode = MMC_POWER_OFF;
 920         host->ios.bus_width = MMC_BUS_WIDTH_1;
 921         host->ios.timing = MMC_TIMING_LEGACY;
 922         mmc_set_ios(host);
 923 }
 924
 925 /*
 926  * Cleanup when the last reference to the bus operator is dropped.
 927  */
 928 static void __mmc_release_bus(struct mmc_host *host)
 929 {
 930         BUG_ON(!host);
 931         BUG_ON(host->bus_refs);
 932         BUG_ON(!host->bus_dead);
 933
 934         host->bus_ops = NULL;
 935 }
 936
 937 /*
 938  * Increase reference count of bus operator
 939  */
 940 static inline void mmc_bus_get(struct mmc_host *host)
 941 {
 942         unsigned long flags;
 943
 944         spin_lock_irqsave(&host->lock, flags);
 945         host->bus_refs++;
 946         spin_unlock_irqrestore(&host->lock, flags);
 947 }
 948
 949 /*
 950  * Decrease reference count of bus operator and free it if
 951  * it is the last reference.
 952  */
 953 static inline void mmc_bus_put(struct mmc_host *host)
 954 {
 955         unsigned long flags;
 956
 957         spin_lock_irqsave(&host->lock, flags);
 958         host->bus_refs--;
 959         if ((host->bus_refs == 0) && host->bus_ops)
 960                 __mmc_release_bus(host);
 961         spin_unlock_irqrestore(&host->lock, flags);
 962 }
 963
 964 /*
 965  * Assign a mmc bus handler to a host. Only one bus handler may control a
 966  * host at any given time.
 967  */
 968 void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops)
 969 {
 970         unsigned long flags;
 971
 972         BUG_ON(!host);
 973         BUG_ON(!ops);
 974
 975         WARN_ON(!host->claimed);
 976
 977         spin_lock_irqsave(&host->lock, flags);
 978
 979         BUG_ON(host->bus_ops);
 980         BUG_ON(host->bus_refs);
 981
 982         host->bus_ops = ops;
 983         host->bus_refs = 1;
 984         host->bus_dead = 0;
 985
 986         spin_unlock_irqrestore(&host->lock, flags);
 987 }
 988
 989 /*
 990  * Remove the current bus handler from a host. Assumes that there are
 991  * no interesting cards left, so the bus is powered down.
 992  */
 993 void mmc_detach_bus(struct mmc_host *host)
 994 {
 995         unsigned long flags;
 996
 997         BUG_ON(!host);
 998
 999         WARN_ON(!host->claimed);
1000         WARN_ON(!host->bus_ops);
1001
1002         spin_lock_irqsave(&host->lock, flags);
1003
1004         host->bus_dead = 1;
1005
1006         spin_unlock_irqrestore(&host->lock, flags);
1007
1008         mmc_power_off(host);
1009
1010         mmc_bus_put(host);
1011 }
1012
1013 /**
1014  *      mmc_detect_change - process change of state on a MMC socket
1015  *      @host: host which changed state.
1016  *      @delay: optional delay to wait before detection (jiffies)
1017  *
1018  *      MMC drivers should call this when they detect a card has been
1019  *      inserted or removed. The MMC layer will confirm that any
1020  *      present card is still functional, and initialize any newly
1021  *      inserted.
1022  */
1023 void mmc_detect_change(struct mmc_host *host, unsigned long delay)
1024 {
1025 #ifdef CONFIG_MMC_DEBUG
1026         unsigned long flags;
1027         spin_lock_irqsave(&host->lock, flags);
1028         WARN_ON(host->removed);
1029         spin_unlock_irqrestore(&host->lock, flags);
1030 #endif
1031
1032         mmc_schedule_delayed_work(&host->detect, delay);
1033 }
1034
1035 EXPORT_SYMBOL(mmc_detect_change);
1036
1037
1038 void mmc_rescan(struct work_struct *work)
1039 {
1040         struct mmc_host *host =
1041                 container_of(work, struct mmc_host, detect.work);
1042         u32 ocr;
1043         int err;
1044
1045         mmc_bus_get(host);
1046
1047         /* if there is a card registered, check whether it is still present */
1048         if ((host->bus_ops != NULL) && host->bus_ops->detect && !host->bus_dead)
1049                 host->bus_ops->detect(host);
1050
1051         mmc_bus_put(host);
1052
1053
1054         mmc_bus_get(host);
1055
1056         /* if there still is a card present, stop here */
1057         if (host->bus_ops != NULL) {
1058                 mmc_bus_put(host);
1059                 goto out;
1060         }
1061
1062         /* detect a newly inserted card */
1063
1064         /*
1065          * Only we can add a new handler, so it's safe to
1066          * release the lock here.
1067          */
1068         mmc_bus_put(host);
1069
1070         if (host->ops->get_cd && host->ops->get_cd(host) == 0)
1071                 goto out;
1072
1073         mmc_claim_host(host);
1074
1075         mmc_power_up(host);
1076         mmc_go_idle(host);
1077
1078         mmc_send_if_cond(host, host->ocr_avail);
1079
1080         /*
1081          * First we search for SDIO...
1082          */
1083         err = mmc_send_io_op_cond(host, 0, &ocr);
1084         if (!err) {
1085                 if (mmc_attach_sdio(host, ocr))
1086                         mmc_power_off(host);
1087                 goto out;
1088         }
1089
1090         /*
1091          * ...then normal SD...
1092          */
1093         err = mmc_send_app_op_cond(host, 0, &ocr);
1094         if (!err) {
1095                 if (mmc_attach_sd(host, ocr))
1096                         mmc_power_off(host);
1097                 goto out;
1098         }
1099
1100         /*
1101          * ...and finally MMC.
1102          */
1103         err = mmc_send_op_cond(host, 0, &ocr);
1104         if (!err) {
1105                 if (mmc_attach_mmc(host, ocr))
1106                         mmc_power_off(host);
1107                 goto out;
1108         }
1109
1110         mmc_release_host(host);
1111         mmc_power_off(host);
1112
1113 out:
1114         if (host->caps & MMC_CAP_NEEDS_POLL)
1115                 mmc_schedule_delayed_work(&host->detect, HZ);
1116 }
1117
1118 void mmc_start_host(struct mmc_host *host)
1119 {
1120         mmc_power_off(host);
1121         mmc_detect_change(host, 0);
1122 }
1123
1124 void mmc_stop_host(struct mmc_host *host)
1125 {
1126 #ifdef CONFIG_MMC_DEBUG
1127         unsigned long flags;
1128         spin_lock_irqsave(&host->lock, flags);
1129         host->removed = 1;
1130         spin_unlock_irqrestore(&host->lock, flags);
1131 #endif
1132
1133         if (host->caps & MMC_CAP_DISABLE)
1134                 cancel_delayed_work(&host->disable);
1135         cancel_delayed_work(&host->detect);
1136         mmc_flush_scheduled_work();
1137
1138         mmc_bus_get(host);
1139         if (host->bus_ops && !host->bus_dead) {
1140                 if (host->bus_ops->remove)
1141                         host->bus_ops->remove(host);
1142
1143                 mmc_claim_host(host);
1144                 mmc_detach_bus(host);
1145                 mmc_release_host(host);
1146                 mmc_bus_put(host);
1147                 return;
1148         }
1149         mmc_bus_put(host);
1150
1151         BUG_ON(host->card);
1152
1153         mmc_power_off(host);
1154 }
1155
1156 void mmc_power_save_host(struct mmc_host *host)
1157 {
1158         mmc_bus_get(host);
1159
1160         if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore) {
1161                 mmc_bus_put(host);
1162                 return;
1163         }
1164
1165         if (host->bus_ops->power_save)
1166                 host->bus_ops->power_save(host);
1167
1168         mmc_bus_put(host);
1169
1170         mmc_power_off(host);
1171 }
1172 EXPORT_SYMBOL(mmc_power_save_host);
1173
1174 void mmc_power_restore_host(struct mmc_host *host)
1175 {
1176         mmc_bus_get(host);
1177
1178         if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore) {
1179                 mmc_bus_put(host);
1180                 return;
1181         }
1182
1183         mmc_power_up(host);
1184         host->bus_ops->power_restore(host);
1185
1186         mmc_bus_put(host);
1187 }
1188 EXPORT_SYMBOL(mmc_power_restore_host);
1189
1190 int mmc_card_awake(struct mmc_host *host)
1191 {
1192         int err = -ENOSYS;
1193
1194         mmc_bus_get(host);
1195
1196         if (host->bus_ops && !host->bus_dead && host->bus_ops->awake)
1197                 err = host->bus_ops->awake(host);
1198
1199         mmc_bus_put(host);
1200
1201         return err;
1202 }
1203 EXPORT_SYMBOL(mmc_card_awake);
1204
1205 int mmc_card_sleep(struct mmc_host *host)
1206 {
1207         int err = -ENOSYS;
1208
1209         mmc_bus_get(host);
1210
1211         if (host->bus_ops && !host->bus_dead && host->bus_ops->awake)
1212                 err = host->bus_ops->sleep(host);
1213
1214         mmc_bus_put(host);
1215
1216         return err;
1217 }
1218 EXPORT_SYMBOL(mmc_card_sleep);
1219
1220 int mmc_card_can_sleep(struct mmc_host *host)
1221 {
1222         struct mmc_card *card = host->card;
1223
1224         if (card && mmc_card_mmc(card) && card->ext_csd.rev >= 3)
1225                 return 1;
1226         return 0;
1227 }
1228 EXPORT_SYMBOL(mmc_card_can_sleep);
1229
1230 #ifdef CONFIG_PM
1231
1232 /**
1233  *      mmc_suspend_host - suspend a host
1234  *      @host: mmc host
1235  *      @state: suspend mode (PM_SUSPEND_xxx)
1236  */
1237 int mmc_suspend_host(struct mmc_host *host, pm_message_t state)
1238 {
1239         int err = 0;
1240
1241         if (host->caps & MMC_CAP_DISABLE)
1242                 cancel_delayed_work(&host->disable);
1243         cancel_delayed_work(&host->detect);
1244         mmc_flush_scheduled_work();
1245
1246         mmc_bus_get(host);
1247         if (host->bus_ops && !host->bus_dead) {
1248                 if (host->bus_ops->suspend)
1249                         err = host->bus_ops->suspend(host);
1250                 if (err == -ENOSYS || !host->bus_ops->resume) {
1251                         /*
1252                          * We simply "remove" the card in this case.
1253                          * It will be redetected on resume.
1254                          */
1255                         if (host->bus_ops->remove)
1256                                 host->bus_ops->remove(host);
1257                         mmc_claim_host(host);
1258                         mmc_detach_bus(host);
1259                         mmc_release_host(host);
1260                         err = 0;
1261                 }
1262         }
1263         mmc_bus_put(host);
1264
1265         if (!err)
1266                 mmc_power_off(host);
1267
1268         return err;
1269 }
1270
1271 EXPORT_SYMBOL(mmc_suspend_host);
1272
1273 /**
1274  *      mmc_resume_host - resume a previously suspended host
1275  *      @host: mmc host
1276  */
1277 int mmc_resume_host(struct mmc_host *host)
1278 {
1279         int err = 0;
1280
1281         mmc_bus_get(host);
1282         if (host->bus_ops && !host->bus_dead) {
1283                 mmc_power_up(host);
1284                 mmc_select_voltage(host, host->ocr);
1285                 BUG_ON(!host->bus_ops->resume);
1286                 err = host->bus_ops->resume(host);
1287                 if (err) {
1288                         printk(KERN_WARNING "%s: error %d during resume "
1289                                             "(card was removed?)\n",
1290                                             mmc_hostname(host), err);
1291                         if (host->bus_ops->remove)
1292                                 host->bus_ops->remove(host);
1293                         mmc_claim_host(host);
1294                         mmc_detach_bus(host);
1295                         mmc_release_host(host);
1296                         /* no need to bother upper layers */
1297                         err = 0;
1298                 }
1299         }
1300         mmc_bus_put(host);
1301
1302         /*
1303          * We add a slight delay here so that resume can progress
1304          * in parallel.
1305          */
1306         mmc_detect_change(host, 1);
1307
1308         return err;
1309 }
1310
1311 EXPORT_SYMBOL(mmc_resume_host);
1312
1313 #endif
1314
1315 static int __init mmc_init(void)
1316 {
1317         int ret;
1318
1319         workqueue = create_singlethread_workqueue("kmmcd");
1320         if (!workqueue)
1321                 return -ENOMEM;
1322
1323         ret = mmc_register_bus();
1324         if (ret)
1325                 goto destroy_workqueue;
1326
1327         ret = mmc_register_host_class();
1328         if (ret)
1329                 goto unregister_bus;
1330
1331         ret = sdio_register_bus();
1332         if (ret)
1333                 goto unregister_host_class;
1334
1335         return 0;
1336
1337 unregister_host_class:
1338         mmc_unregister_host_class();
1339 unregister_bus:
1340         mmc_unregister_bus();
1341 destroy_workqueue:
1342         destroy_workqueue(workqueue);
1343
1344         return ret;
1345 }
1346
1347 static void __exit mmc_exit(void)
1348 {
1349         sdio_unregister_bus();
1350         mmc_unregister_host_class();
1351         mmc_unregister_bus();
1352         destroy_workqueue(workqueue);
1353 }
1354
1355 subsys_initcall(mmc_init);
1356 module_exit(mmc_exit);
1357
1358 MODULE_LICENSE("GPL");