git.oblomov.eu Git - linux-2.6/blob - 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_claim_host - exclusively claim a host
 348  *      @host: mmc host to claim
 349  *      @abort: whether or not the operation should be aborted
 350  *
 351  *      Claim a host for a set of operations.  If @abort is non null and
 352  *      dereference a non-zero value then this will return prematurely with
 353  *      that non-zero value without acquiring the lock.  Returns zero
 354  *      with the lock held otherwise.
 355  */
 356 int __mmc_claim_host(struct mmc_host *host, atomic_t *abort)
 357 {
 358         DECLARE_WAITQUEUE(wait, current);
 359         unsigned long flags;
 360         int stop;
 361
 362         might_sleep();
 363
 364         add_wait_queue(&host->wq, &wait);
 365         spin_lock_irqsave(&host->lock, flags);
 366         while (1) {
 367                 set_current_state(TASK_UNINTERRUPTIBLE);
 368                 stop = abort ? atomic_read(abort) : 0;
 369                 if (stop || !host->claimed)
 370                         break;
 371                 spin_unlock_irqrestore(&host->lock, flags);
 372                 schedule();
 373                 spin_lock_irqsave(&host->lock, flags);
 374         }
 375         set_current_state(TASK_RUNNING);
 376         if (!stop)
 377                 host->claimed = 1;
 378         else
 379                 wake_up(&host->wq);
 380         spin_unlock_irqrestore(&host->lock, flags);
 381         remove_wait_queue(&host->wq, &wait);
 382         return stop;
 383 }
 384
 385 EXPORT_SYMBOL(__mmc_claim_host);
 386
 387 /**
 388  *      mmc_release_host - release a host
 389  *      @host: mmc host to release
 390  *
 391  *      Release a MMC host, allowing others to claim the host
 392  *      for their operations.
 393  */
 394 void mmc_release_host(struct mmc_host *host)
 395 {
 396         unsigned long flags;
 397
 398         WARN_ON(!host->claimed);
 399
 400         spin_lock_irqsave(&host->lock, flags);
 401         host->claimed = 0;
 402         spin_unlock_irqrestore(&host->lock, flags);
 403
 404         wake_up(&host->wq);
 405 }
 406
 407 EXPORT_SYMBOL(mmc_release_host);
 408
 409 /*
 410  * Internal function that does the actual ios call to the host driver,
 411  * optionally printing some debug output.
 412  */
 413 static inline void mmc_set_ios(struct mmc_host *host)
 414 {
 415         struct mmc_ios *ios = &host->ios;
 416
 417         pr_debug("%s: clock %uHz busmode %u powermode %u cs %u Vdd %u "
 418                 "width %u timing %u\n",
 419                  mmc_hostname(host), ios->clock, ios->bus_mode,
 420                  ios->power_mode, ios->chip_select, ios->vdd,
 421                  ios->bus_width, ios->timing);
 422
 423         host->ops->set_ios(host, ios);
 424 }
 425
 426 /*
 427  * Control chip select pin on a host.
 428  */
 429 void mmc_set_chip_select(struct mmc_host *host, int mode)
 430 {
 431         host->ios.chip_select = mode;
 432         mmc_set_ios(host);
 433 }
 434
 435 /*
 436  * Sets the host clock to the highest possible frequency that
 437  * is below "hz".
 438  */
 439 void mmc_set_clock(struct mmc_host *host, unsigned int hz)
 440 {
 441         WARN_ON(hz < host->f_min);
 442
 443         if (hz > host->f_max)
 444                 hz = host->f_max;
 445
 446         host->ios.clock = hz;
 447         mmc_set_ios(host);
 448 }
 449
 450 /*
 451  * Change the bus mode (open drain/push-pull) of a host.
 452  */
 453 void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
 454 {
 455         host->ios.bus_mode = mode;
 456         mmc_set_ios(host);
 457 }
 458
 459 /*
 460  * Change data bus width of a host.
 461  */
 462 void mmc_set_bus_width(struct mmc_host *host, unsigned int width)
 463 {
 464         host->ios.bus_width = width;
 465         mmc_set_ios(host);
 466 }
 467
 468 /**
 469  * mmc_vdd_to_ocrbitnum - Convert a voltage to the OCR bit number
 470  * @vdd:        voltage (mV)
 471  * @low_bits:   prefer low bits in boundary cases
 472  *
 473  * This function returns the OCR bit number according to the provided @vdd
 474  * value. If conversion is not possible a negative errno value returned.
 475  *
 476  * Depending on the @low_bits flag the function prefers low or high OCR bits
 477  * on boundary voltages. For example,
 478  * with @low_bits = true, 3300 mV translates to ilog2(MMC_VDD_32_33);
 479  * with @low_bits = false, 3300 mV translates to ilog2(MMC_VDD_33_34);
 480  *
 481  * Any value in the [1951:1999] range translates to the ilog2(MMC_VDD_20_21).
 482  */
 483 static int mmc_vdd_to_ocrbitnum(int vdd, bool low_bits)
 484 {
 485         const int max_bit = ilog2(MMC_VDD_35_36);
 486         int bit;
 487
 488         if (vdd < 1650 || vdd > 3600)
 489                 return -EINVAL;
 490
 491         if (vdd >= 1650 && vdd <= 1950)
 492                 return ilog2(MMC_VDD_165_195);
 493
 494         if (low_bits)
 495                 vdd -= 1;
 496
 497         /* Base 2000 mV, step 100 mV, bit's base 8. */
 498         bit = (vdd - 2000) / 100 + 8;
 499         if (bit > max_bit)
 500                 return max_bit;
 501         return bit;
 502 }
 503
 504 /**
 505  * mmc_vddrange_to_ocrmask - Convert a voltage range to the OCR mask
 506  * @vdd_min:    minimum voltage value (mV)
 507  * @vdd_max:    maximum voltage value (mV)
 508  *
 509  * This function returns the OCR mask bits according to the provided @vdd_min
 510  * and @vdd_max values. If conversion is not possible the function returns 0.
 511  *
 512  * Notes wrt boundary cases:
 513  * This function sets the OCR bits for all boundary voltages, for example
 514  * [3300:3400] range is translated to MMC_VDD_32_33 | MMC_VDD_33_34 |
 515  * MMC_VDD_34_35 mask.
 516  */
 517 u32 mmc_vddrange_to_ocrmask(int vdd_min, int vdd_max)
 518 {
 519         u32 mask = 0;
 520
 521         if (vdd_max < vdd_min)
 522                 return 0;
 523
 524         /* Prefer high bits for the boundary vdd_max values. */
 525         vdd_max = mmc_vdd_to_ocrbitnum(vdd_max, false);
 526         if (vdd_max < 0)
 527                 return 0;
 528
 529         /* Prefer low bits for the boundary vdd_min values. */
 530         vdd_min = mmc_vdd_to_ocrbitnum(vdd_min, true);
 531         if (vdd_min < 0)
 532                 return 0;
 533
 534         /* Fill the mask, from max bit to min bit. */
 535         while (vdd_max >= vdd_min)
 536                 mask |= 1 << vdd_max--;
 537
 538         return mask;
 539 }
 540 EXPORT_SYMBOL(mmc_vddrange_to_ocrmask);
 541
 542 #ifdef CONFIG_REGULATOR
 543
 544 /**
 545  * mmc_regulator_get_ocrmask - return mask of supported voltages
 546  * @supply: regulator to use
 547  *
 548  * This returns either a negative errno, or a mask of voltages that
 549  * can be provided to MMC/SD/SDIO devices using the specified voltage
 550  * regulator.  This would normally be called before registering the
 551  * MMC host adapter.
 552  */
 553 int mmc_regulator_get_ocrmask(struct regulator *supply)
 554 {
 555         int                     result = 0;
 556         int                     count;
 557         int                     i;
 558
 559         count = regulator_count_voltages(supply);
 560         if (count < 0)
 561                 return count;
 562
 563         for (i = 0; i < count; i++) {
 564                 int             vdd_uV;
 565                 int             vdd_mV;
 566
 567                 vdd_uV = regulator_list_voltage(supply, i);
 568                 if (vdd_uV <= 0)
 569                         continue;
 570
 571                 vdd_mV = vdd_uV / 1000;
 572                 result |= mmc_vddrange_to_ocrmask(vdd_mV, vdd_mV);
 573         }
 574
 575         return result;
 576 }
 577 EXPORT_SYMBOL(mmc_regulator_get_ocrmask);
 578
 579 /**
 580  * mmc_regulator_set_ocr - set regulator to match host->ios voltage
 581  * @vdd_bit: zero for power off, else a bit number (host->ios.vdd)
 582  * @supply: regulator to use
 583  *
 584  * Returns zero on success, else negative errno.
 585  *
 586  * MMC host drivers may use this to enable or disable a regulator using
 587  * a particular supply voltage.  This would normally be called from the
 588  * set_ios() method.
 589  */
 590 int mmc_regulator_set_ocr(struct regulator *supply, unsigned short vdd_bit)
 591 {
 592         int                     result = 0;
 593         int                     min_uV, max_uV;
 594         int                     enabled;
 595
 596         enabled = regulator_is_enabled(supply);
 597         if (enabled < 0)
 598                 return enabled;
 599
 600         if (vdd_bit) {
 601                 int             tmp;
 602                 int             voltage;
 603
 604                 /* REVISIT mmc_vddrange_to_ocrmask() may have set some
 605                  * bits this regulator doesn't quite support ... don't
 606                  * be too picky, most cards and regulators are OK with
 607                  * a 0.1V range goof (it's a small error percentage).
 608                  */
 609                 tmp = vdd_bit - ilog2(MMC_VDD_165_195);
 610                 if (tmp == 0) {
 611                         min_uV = 1650 * 1000;
 612                         max_uV = 1950 * 1000;
 613                 } else {
 614                         min_uV = 1900 * 1000 + tmp * 100 * 1000;
 615                         max_uV = min_uV + 100 * 1000;
 616                 }
 617
 618                 /* avoid needless changes to this voltage; the regulator
 619                  * might not allow this operation
 620                  */
 621                 voltage = regulator_get_voltage(supply);
 622                 if (voltage < 0)
 623                         result = voltage;
 624                 else if (voltage < min_uV || voltage > max_uV)
 625                         result = regulator_set_voltage(supply, min_uV, max_uV);
 626                 else
 627                         result = 0;
 628
 629                 if (result == 0 && !enabled)
 630                         result = regulator_enable(supply);
 631         } else if (enabled) {
 632                 result = regulator_disable(supply);
 633         }
 634
 635         return result;
 636 }
 637 EXPORT_SYMBOL(mmc_regulator_set_ocr);
 638
 639 #endif
 640
 641 /*
 642  * Mask off any voltages we don't support and select
 643  * the lowest voltage
 644  */
 645 u32 mmc_select_voltage(struct mmc_host *host, u32 ocr)
 646 {
 647         int bit;
 648
 649         ocr &= host->ocr_avail;
 650
 651         bit = ffs(ocr);
 652         if (bit) {
 653                 bit -= 1;
 654
 655                 ocr &= 3 << bit;
 656
 657                 host->ios.vdd = bit;
 658                 mmc_set_ios(host);
 659         } else {
 660                 pr_warning("%s: host doesn't support card's voltages\n",
 661                                 mmc_hostname(host));
 662                 ocr = 0;
 663         }
 664
 665         return ocr;
 666 }
 667
 668 /*
 669  * Select timing parameters for host.
 670  */
 671 void mmc_set_timing(struct mmc_host *host, unsigned int timing)
 672 {
 673         host->ios.timing = timing;
 674         mmc_set_ios(host);
 675 }
 676
 677 /*
 678  * Apply power to the MMC stack.  This is a two-stage process.
 679  * First, we enable power to the card without the clock running.
 680  * We then wait a bit for the power to stabilise.  Finally,
 681  * enable the bus drivers and clock to the card.
 682  *
 683  * We must _NOT_ enable the clock prior to power stablising.
 684  *
 685  * If a host does all the power sequencing itself, ignore the
 686  * initial MMC_POWER_UP stage.
 687  */
 688 static void mmc_power_up(struct mmc_host *host)
 689 {
 690         int bit = fls(host->ocr_avail) - 1;
 691
 692         host->ios.vdd = bit;
 693         if (mmc_host_is_spi(host)) {
 694                 host->ios.chip_select = MMC_CS_HIGH;
 695                 host->ios.bus_mode = MMC_BUSMODE_PUSHPULL;
 696         } else {
 697                 host->ios.chip_select = MMC_CS_DONTCARE;
 698                 host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
 699         }
 700         host->ios.power_mode = MMC_POWER_UP;
 701         host->ios.bus_width = MMC_BUS_WIDTH_1;
 702         host->ios.timing = MMC_TIMING_LEGACY;
 703         mmc_set_ios(host);
 704
 705         /*
 706          * This delay should be sufficient to allow the power supply
 707          * to reach the minimum voltage.
 708          */
 709         mmc_delay(2);
 710
 711         host->ios.clock = host->f_min;
 712         host->ios.power_mode = MMC_POWER_ON;
 713         mmc_set_ios(host);
 714
 715         /*
 716          * This delay must be at least 74 clock sizes, or 1 ms, or the
 717          * time required to reach a stable voltage.
 718          */
 719         mmc_delay(2);
 720 }
 721
 722 static void mmc_power_off(struct mmc_host *host)
 723 {
 724         host->ios.clock = 0;
 725         host->ios.vdd = 0;
 726         if (!mmc_host_is_spi(host)) {
 727                 host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
 728                 host->ios.chip_select = MMC_CS_DONTCARE;
 729         }
 730         host->ios.power_mode = MMC_POWER_OFF;
 731         host->ios.bus_width = MMC_BUS_WIDTH_1;
 732         host->ios.timing = MMC_TIMING_LEGACY;
 733         mmc_set_ios(host);
 734 }
 735
 736 /*
 737  * Cleanup when the last reference to the bus operator is dropped.
 738  */
 739 static void __mmc_release_bus(struct mmc_host *host)
 740 {
 741         BUG_ON(!host);
 742         BUG_ON(host->bus_refs);
 743         BUG_ON(!host->bus_dead);
 744
 745         host->bus_ops = NULL;
 746 }
 747
 748 /*
 749  * Increase reference count of bus operator
 750  */
 751 static inline void mmc_bus_get(struct mmc_host *host)
 752 {
 753         unsigned long flags;
 754
 755         spin_lock_irqsave(&host->lock, flags);
 756         host->bus_refs++;
 757         spin_unlock_irqrestore(&host->lock, flags);
 758 }
 759
 760 /*
 761  * Decrease reference count of bus operator and free it if
 762  * it is the last reference.
 763  */
 764 static inline void mmc_bus_put(struct mmc_host *host)
 765 {
 766         unsigned long flags;
 767
 768         spin_lock_irqsave(&host->lock, flags);
 769         host->bus_refs--;
 770         if ((host->bus_refs == 0) && host->bus_ops)
 771                 __mmc_release_bus(host);
 772         spin_unlock_irqrestore(&host->lock, flags);
 773 }
 774
 775 /*
 776  * Assign a mmc bus handler to a host. Only one bus handler may control a
 777  * host at any given time.
 778  */
 779 void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops)
 780 {
 781         unsigned long flags;
 782
 783         BUG_ON(!host);
 784         BUG_ON(!ops);
 785
 786         WARN_ON(!host->claimed);
 787
 788         spin_lock_irqsave(&host->lock, flags);
 789
 790         BUG_ON(host->bus_ops);
 791         BUG_ON(host->bus_refs);
 792
 793         host->bus_ops = ops;
 794         host->bus_refs = 1;
 795         host->bus_dead = 0;
 796
 797         spin_unlock_irqrestore(&host->lock, flags);
 798 }
 799
 800 /*
 801  * Remove the current bus handler from a host. Assumes that there are
 802  * no interesting cards left, so the bus is powered down.
 803  */
 804 void mmc_detach_bus(struct mmc_host *host)
 805 {
 806         unsigned long flags;
 807
 808         BUG_ON(!host);
 809
 810         WARN_ON(!host->claimed);
 811         WARN_ON(!host->bus_ops);
 812
 813         spin_lock_irqsave(&host->lock, flags);
 814
 815         host->bus_dead = 1;
 816
 817         spin_unlock_irqrestore(&host->lock, flags);
 818
 819         mmc_power_off(host);
 820
 821         mmc_bus_put(host);
 822 }
 823
 824 /**
 825  *      mmc_detect_change - process change of state on a MMC socket
 826  *      @host: host which changed state.
 827  *      @delay: optional delay to wait before detection (jiffies)
 828  *
 829  *      MMC drivers should call this when they detect a card has been
 830  *      inserted or removed. The MMC layer will confirm that any
 831  *      present card is still functional, and initialize any newly
 832  *      inserted.
 833  */
 834 void mmc_detect_change(struct mmc_host *host, unsigned long delay)
 835 {
 836 #ifdef CONFIG_MMC_DEBUG
 837         unsigned long flags;
 838         spin_lock_irqsave(&host->lock, flags);
 839         WARN_ON(host->removed);
 840         spin_unlock_irqrestore(&host->lock, flags);
 841 #endif
 842
 843         mmc_schedule_delayed_work(&host->detect, delay);
 844 }
 845
 846 EXPORT_SYMBOL(mmc_detect_change);
 847
 848
 849 void mmc_rescan(struct work_struct *work)
 850 {
 851         struct mmc_host *host =
 852                 container_of(work, struct mmc_host, detect.work);
 853         u32 ocr;
 854         int err;
 855
 856         mmc_bus_get(host);
 857
 858         if (host->bus_ops == NULL) {
 859                 /*
 860                  * Only we can add a new handler, so it's safe to
 861                  * release the lock here.
 862                  */
 863                 mmc_bus_put(host);
 864
 865                 if (host->ops->get_cd && host->ops->get_cd(host) == 0)
 866                         goto out;
 867
 868                 mmc_claim_host(host);
 869
 870                 mmc_power_up(host);
 871                 mmc_go_idle(host);
 872
 873                 mmc_send_if_cond(host, host->ocr_avail);
 874
 875                 /*
 876                  * First we search for SDIO...
 877                  */
 878                 err = mmc_send_io_op_cond(host, 0, &ocr);
 879                 if (!err) {
 880                         if (mmc_attach_sdio(host, ocr))
 881                                 mmc_power_off(host);
 882                         goto out;
 883                 }
 884
 885                 /*
 886                  * ...then normal SD...
 887                  */
 888                 err = mmc_send_app_op_cond(host, 0, &ocr);
 889                 if (!err) {
 890                         if (mmc_attach_sd(host, ocr))
 891                                 mmc_power_off(host);
 892                         goto out;
 893                 }
 894
 895                 /*
 896                  * ...and finally MMC.
 897                  */
 898                 err = mmc_send_op_cond(host, 0, &ocr);
 899                 if (!err) {
 900                         if (mmc_attach_mmc(host, ocr))
 901                                 mmc_power_off(host);
 902                         goto out;
 903                 }
 904
 905                 mmc_release_host(host);
 906                 mmc_power_off(host);
 907         } else {
 908                 if (host->bus_ops->detect && !host->bus_dead)
 909                         host->bus_ops->detect(host);
 910
 911                 mmc_bus_put(host);
 912         }
 913 out:
 914         if (host->caps & MMC_CAP_NEEDS_POLL)
 915                 mmc_schedule_delayed_work(&host->detect, HZ);
 916 }
 917
 918 void mmc_start_host(struct mmc_host *host)
 919 {
 920         mmc_power_off(host);
 921         mmc_detect_change(host, 0);
 922 }
 923
 924 void mmc_stop_host(struct mmc_host *host)
 925 {
 926 #ifdef CONFIG_MMC_DEBUG
 927         unsigned long flags;
 928         spin_lock_irqsave(&host->lock, flags);
 929         host->removed = 1;
 930         spin_unlock_irqrestore(&host->lock, flags);
 931 #endif
 932
 933         cancel_delayed_work(&host->detect);
 934         mmc_flush_scheduled_work();
 935
 936         mmc_bus_get(host);
 937         if (host->bus_ops && !host->bus_dead) {
 938                 if (host->bus_ops->remove)
 939                         host->bus_ops->remove(host);
 940
 941                 mmc_claim_host(host);
 942                 mmc_detach_bus(host);
 943                 mmc_release_host(host);
 944         }
 945         mmc_bus_put(host);
 946
 947         BUG_ON(host->card);
 948
 949         mmc_power_off(host);
 950 }
 951
 952 #ifdef CONFIG_PM
 953
 954 /**
 955  *      mmc_suspend_host - suspend a host
 956  *      @host: mmc host
 957  *      @state: suspend mode (PM_SUSPEND_xxx)
 958  */
 959 int mmc_suspend_host(struct mmc_host *host, pm_message_t state)
 960 {
 961         cancel_delayed_work(&host->detect);
 962         mmc_flush_scheduled_work();
 963
 964         mmc_bus_get(host);
 965         if (host->bus_ops && !host->bus_dead) {
 966                 if (host->bus_ops->suspend)
 967                         host->bus_ops->suspend(host);
 968                 if (!host->bus_ops->resume) {
 969                         if (host->bus_ops->remove)
 970                                 host->bus_ops->remove(host);
 971
 972                         mmc_claim_host(host);
 973                         mmc_detach_bus(host);
 974                         mmc_release_host(host);
 975                 }
 976         }
 977         mmc_bus_put(host);
 978
 979         mmc_power_off(host);
 980
 981         return 0;
 982 }
 983
 984 EXPORT_SYMBOL(mmc_suspend_host);
 985
 986 /**
 987  *      mmc_resume_host - resume a previously suspended host
 988  *      @host: mmc host
 989  */
 990 int mmc_resume_host(struct mmc_host *host)
 991 {
 992         mmc_bus_get(host);
 993         if (host->bus_ops && !host->bus_dead) {
 994                 mmc_power_up(host);
 995                 mmc_select_voltage(host, host->ocr);
 996                 BUG_ON(!host->bus_ops->resume);
 997                 host->bus_ops->resume(host);
 998         }
 999         mmc_bus_put(host);
1000
1001         /*
1002          * We add a slight delay here so that resume can progress
1003          * in parallel.
1004          */
1005         mmc_detect_change(host, 1);
1006
1007         return 0;
1008 }
1009
1010 EXPORT_SYMBOL(mmc_resume_host);
1011
1012 #endif
1013
1014 static int __init mmc_init(void)
1015 {
1016         int ret;
1017
1018         workqueue = create_singlethread_workqueue("kmmcd");
1019         if (!workqueue)
1020                 return -ENOMEM;
1021
1022         ret = mmc_register_bus();
1023         if (ret)
1024                 goto destroy_workqueue;
1025
1026         ret = mmc_register_host_class();
1027         if (ret)
1028                 goto unregister_bus;
1029
1030         ret = sdio_register_bus();
1031         if (ret)
1032                 goto unregister_host_class;
1033
1034         return 0;
1035
1036 unregister_host_class:
1037         mmc_unregister_host_class();
1038 unregister_bus:
1039         mmc_unregister_bus();
1040 destroy_workqueue:
1041         destroy_workqueue(workqueue);
1042
1043         return ret;
1044 }
1045
1046 static void __exit mmc_exit(void)
1047 {
1048         sdio_unregister_bus();
1049         mmc_unregister_host_class();
1050         mmc_unregister_bus();
1051         destroy_workqueue(workqueue);
1052 }
1053
1054 subsys_initcall(mmc_init);
1055 module_exit(mmc_exit);
1056
1057 MODULE_LICENSE("GPL");