[kernel] fix yaffs build failure on 2.6.28.2 (thanks to Alexandros C. Couloumbis...

[openwrt.git] / target / linux / generic-2.6 / patches-2.6.23 / 300-add-mmc-spi-driver.patch

This is a port of the MMC-SPI driver from 2.6.24.3
--mb


--- a/drivers/mmc/host/Kconfig
+++ b/drivers/mmc/host/Kconfig
@@ -100,3 +100,16 @@
           To compile this driver as a module, choose M here: the
          module will be called tifm_sd.
 
+config MMC_SPI
+       tristate "MMC/SD over SPI (EXPERIMENTAL)"
+       depends on MMC && SPI_MASTER && !HIGHMEM && EXPERIMENTAL
+       select CRC7
+       select CRC_ITU_T
+       help
+         Some systems accss MMC/SD cards using a SPI controller instead of
+         using a "native" MMC/SD controller.  This has a disadvantage of
+         being relatively high overhead, but a compensating advantage of
+         working on many systems without dedicated MMC/SD controllers.
+
+         If unsure, or if your system has no SPI master driver, say N.
+
--- a/drivers/mmc/host/Makefile
+++ b/drivers/mmc/host/Makefile
@@ -15,4 +15,5 @@
 obj-$(CONFIG_MMC_OMAP)         += omap.o
 obj-$(CONFIG_MMC_AT91)         += at91_mci.o
 obj-$(CONFIG_MMC_TIFM_SD)      += tifm_sd.o
+obj-$(CONFIG_MMC_SPI)          += mmc_spi.o
 
--- /dev/null
+++ b/drivers/mmc/host/mmc_spi.c
@@ -0,0 +1,1419 @@
+/*
+ * mmc_spi.c - Access SD/MMC cards through SPI master controllers
+ *
+ * (C) Copyright 2005, Intec Automation,
+ *             Mike Lavender (mike@steroidmicros)
+ * (C) Copyright 2006-2007, David Brownell
+ * (C) Copyright 2007, Axis Communications,
+ *             Hans-Peter Nilsson (hp@axis.com)
+ * (C) Copyright 2007, ATRON electronic GmbH,
+ *             Jan Nikitenko <jan.nikitenko@gmail.com>
+ *
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#include <linux/hrtimer.h>
+#include <linux/delay.h>
+#include <linux/bio.h>
+#include <linux/dma-mapping.h>
+#include <linux/crc7.h>
+#include <linux/crc-itu-t.h>
+#include <linux/scatterlist.h>
+
+#include <linux/mmc/host.h>
+#include <linux/mmc/mmc.h>             /* for R1_SPI_* bit values */
+
+#include <linux/spi/spi.h>
+#include <linux/spi/mmc_spi.h>
+
+#include <asm/unaligned.h>
+
+
+#define sg_page(sg)    (sg)->page
+
+
+/* NOTES:
+ *
+ * - For now, we won't try to interoperate with a real mmc/sd/sdio
+ *   controller, although some of them do have hardware support for
+ *   SPI protocol.  The main reason for such configs would be mmc-ish
+ *   cards like DataFlash, which don't support that "native" protocol.
+ *
+ *   We don't have a "DataFlash/MMC/SD/SDIO card slot" abstraction to
+ *   switch between driver stacks, and in any case if "native" mode
+ *   is available, it will be faster and hence preferable.
+ *
+ * - MMC depends on a different chipselect management policy than the
+ *   SPI interface currently supports for shared bus segments:  it needs
+ *   to issue multiple spi_message requests with the chipselect active,
+ *   using the results of one message to decide the next one to issue.
+ *
+ *   Pending updates to the programming interface, this driver expects
+ *   that it not share the bus with other drivers (precluding conflicts).
+ *
+ * - We tell the controller to keep the chipselect active from the
+ *   beginning of an mmc_host_ops.request until the end.  So beware
+ *   of SPI controller drivers that mis-handle the cs_change flag!
+ *
+ *   However, many cards seem OK with chipselect flapping up/down
+ *   during that time ... at least on unshared bus segments.
+ */
+
+
+/*
+ * Local protocol constants, internal to data block protocols.
+ */
+
+/* Response tokens used to ack each block written: */
+#define SPI_MMC_RESPONSE_CODE(x)       ((x) & 0x1f)
+#define SPI_RESPONSE_ACCEPTED          ((2 << 1)|1)
+#define SPI_RESPONSE_CRC_ERR           ((5 << 1)|1)
+#define SPI_RESPONSE_WRITE_ERR         ((6 << 1)|1)
+
+/* Read and write blocks start with these tokens and end with crc;
+ * on error, read tokens act like a subset of R2_SPI_* values.
+ */
+#define SPI_TOKEN_SINGLE       0xfe    /* single block r/w, multiblock read */
+#define SPI_TOKEN_MULTI_WRITE  0xfc    /* multiblock write */
+#define SPI_TOKEN_STOP_TRAN    0xfd    /* terminate multiblock write */
+
+#define MMC_SPI_BLOCKSIZE      512
+
+
+/* These fixed timeouts come from the latest SD specs, which say to ignore
+ * the CSD values.  The R1B value is for card erase (e.g. the "I forgot the
+ * card's password" scenario); it's mostly applied to STOP_TRANSMISSION after
+ * reads which takes nowhere near that long.  Older cards may be able to use
+ * shorter timeouts ... but why bother?
+ */
+#define readblock_timeout      ktime_set(0, 100 * 1000 * 1000)
+#define writeblock_timeout     ktime_set(0, 250 * 1000 * 1000)
+#define r1b_timeout            ktime_set(3, 0)
+
+
+/****************************************************************************/
+
+/*
+ * Local Data Structures
+ */
+
+/* "scratch" is per-{command,block} data exchanged with the card */
+struct scratch {
+       u8                      status[29];
+       u8                      data_token;
+       __be16                  crc_val;
+};
+
+struct mmc_spi_host {
+       struct mmc_host         *mmc;
+       struct spi_device       *spi;
+
+       unsigned char           power_mode;
+       u16                     powerup_msecs;
+
+       struct mmc_spi_platform_data    *pdata;
+
+       /* for bulk data transfers */
+       struct spi_transfer     token, t, crc, early_status;
+       struct spi_message      m;
+
+       /* for status readback */
+       struct spi_transfer     status;
+       struct spi_message      readback;
+
+       /* underlying DMA-aware controller, or null */
+       struct device           *dma_dev;
+
+       /* buffer used for commands and for message "overhead" */
+       struct scratch          *data;
+       dma_addr_t              data_dma;
+
+       /* Specs say to write ones most of the time, even when the card
+        * has no need to read its input data; and many cards won't care.
+        * This is our source of those ones.
+        */
+       void                    *ones;
+       dma_addr_t              ones_dma;
+};
+
+
+/****************************************************************************/
+
+/*
+ * MMC-over-SPI protocol glue, used by the MMC stack interface
+ */
+
+static inline int mmc_cs_off(struct mmc_spi_host *host)
+{
+       /* chipselect will always be inactive after setup() */
+       return spi_setup(host->spi);
+}
+
+static int
+mmc_spi_readbytes(struct mmc_spi_host *host, unsigned len)
+{
+       int status;
+
+       if (len > sizeof(*host->data)) {
+               WARN_ON(1);
+               return -EIO;
+       }
+
+       host->status.len = len;
+
+       if (host->dma_dev)
+               dma_sync_single_for_device(host->dma_dev,
+                               host->data_dma, sizeof(*host->data),
+                               DMA_FROM_DEVICE);
+
+       status = spi_sync(host->spi, &host->readback);
+
+       if (host->dma_dev)
+               dma_sync_single_for_cpu(host->dma_dev,
+                               host->data_dma, sizeof(*host->data),
+                               DMA_FROM_DEVICE);
+
+       return status;
+}
+
+static int
+mmc_spi_skip(struct mmc_spi_host *host, ktime_t timeout, unsigned n, u8 byte)
+{
+       u8              *cp = host->data->status;
+
+       timeout = ktime_add(timeout, ktime_get());
+
+       while (1) {
+               int             status;
+               unsigned        i;
+
+               status = mmc_spi_readbytes(host, n);
+               if (status < 0)
+                       return status;
+
+               for (i = 0; i < n; i++) {
+                       if (cp[i] != byte)
+                               return cp[i];
+               }
+
+               /* REVISIT investigate msleep() to avoid busy-wait I/O
+                * in at least some cases.
+                */
+               if (ktime_to_ns(ktime_sub(ktime_get(), timeout)) > 0)
+                       break;
+       }
+       return -ETIMEDOUT;
+}
+
+static inline int
+mmc_spi_wait_unbusy(struct mmc_spi_host *host, ktime_t timeout)
+{
+       return mmc_spi_skip(host, timeout, sizeof(host->data->status), 0);
+}
+
+static int mmc_spi_readtoken(struct mmc_spi_host *host)
+{
+       return mmc_spi_skip(host, readblock_timeout, 1, 0xff);
+}
+
+
+/*
+ * Note that for SPI, cmd->resp[0] is not the same data as "native" protocol
+ * hosts return!  The low byte holds R1_SPI bits.  The next byte may hold
+ * R2_SPI bits ... for SEND_STATUS, or after data read errors.
+ *
+ * cmd->resp[1] holds any four-byte response, for R3 (READ_OCR) and on
+ * newer cards R7 (IF_COND).
+ */
+
+static char *maptype(struct mmc_command *cmd)
+{
+       switch (mmc_spi_resp_type(cmd)) {
+       case MMC_RSP_SPI_R1:    return "R1";
+       case MMC_RSP_SPI_R1B:   return "R1B";
+       case MMC_RSP_SPI_R2:    return "R2/R5";
+       case MMC_RSP_SPI_R3:    return "R3/R4/R7";
+       default:                return "?";
+       }
+}
+
+/* return zero, else negative errno after setting cmd->error */
+static int mmc_spi_response_get(struct mmc_spi_host *host,
+               struct mmc_command *cmd, int cs_on)
+{
+       u8      *cp = host->data->status;
+       u8      *end = cp + host->t.len;
+       int     value = 0;
+       char    tag[32];
+
+       snprintf(tag, sizeof(tag), "  ... CMD%d response SPI_%s",
+               cmd->opcode, maptype(cmd));
+
+       /* Except for data block reads, the whole response will already
+        * be stored in the scratch buffer.  It's somewhere after the
+        * command and the first byte we read after it.  We ignore that
+        * first byte.  After STOP_TRANSMISSION command it may include
+        * two data bits, but otherwise it's all ones.
+        */
+       cp += 8;
+       while (cp < end && *cp == 0xff)
+               cp++;
+
+       /* Data block reads (R1 response types) may need more data... */
+       if (cp == end) {
+               unsigned        i;
+
+               cp = host->data->status;
+
+               /* Card sends N(CR) (== 1..8) bytes of all-ones then one
+                * status byte ... and we already scanned 2 bytes.
+                *
+                * REVISIT block read paths use nasty byte-at-a-time I/O
+                * so it can always DMA directly into the target buffer.
+                * It'd probably be better to memcpy() the first chunk and
+                * avoid extra i/o calls...
+                */
+               for (i = 2; i < 9; i++) {
+                       value = mmc_spi_readbytes(host, 1);
+                       if (value < 0)
+                               goto done;
+                       if (*cp != 0xff)
+                               goto checkstatus;
+               }
+               value = -ETIMEDOUT;
+               goto done;
+       }
+
+checkstatus:
+       if (*cp & 0x80) {
+               dev_dbg(&host->spi->dev, "%s: INVALID RESPONSE, %02x\n",
+                                       tag, *cp);
+               value = -EBADR;
+               goto done;
+       }
+
+       cmd->resp[0] = *cp++;
+       cmd->error = 0;
+
+       /* Status byte: the entire seven-bit R1 response.  */
+       if (cmd->resp[0] != 0) {
+               if ((R1_SPI_PARAMETER | R1_SPI_ADDRESS
+                                       | R1_SPI_ILLEGAL_COMMAND)
+                               & cmd->resp[0])
+                       value = -EINVAL;
+               else if (R1_SPI_COM_CRC & cmd->resp[0])
+                       value = -EILSEQ;
+               else if ((R1_SPI_ERASE_SEQ | R1_SPI_ERASE_RESET)
+                               & cmd->resp[0])
+                       value = -EIO;
+               /* else R1_SPI_IDLE, "it's resetting" */
+       }
+
+       switch (mmc_spi_resp_type(cmd)) {
+
+       /* SPI R1B == R1 + busy; STOP_TRANSMISSION (for multiblock reads)
+        * and less-common stuff like various erase operations.
+        */
+       case MMC_RSP_SPI_R1B:
+               /* maybe we read all the busy tokens already */
+               while (cp < end && *cp == 0)
+                       cp++;
+               if (cp == end)
+                       mmc_spi_wait_unbusy(host, r1b_timeout);
+               break;
+
+       /* SPI R2 == R1 + second status byte; SEND_STATUS
+        * SPI R5 == R1 + data byte; IO_RW_DIRECT
+        */
+       case MMC_RSP_SPI_R2:
+               cmd->resp[0] |= *cp << 8;
+               break;
+
+       /* SPI R3, R4, or R7 == R1 + 4 bytes */
+       case MMC_RSP_SPI_R3:
+               cmd->resp[1] = be32_to_cpu(get_unaligned((u32 *)cp));
+               break;
+
+       /* SPI R1 == just one status byte */
+       case MMC_RSP_SPI_R1:
+               break;
+
+       default:
+               dev_dbg(&host->spi->dev, "bad response type %04x\n",
+                               mmc_spi_resp_type(cmd));
+               if (value >= 0)
+                       value = -EINVAL;
+               goto done;
+       }
+
+       if (value < 0)
+               dev_dbg(&host->spi->dev, "%s: resp %04x %08x\n",
+                       tag, cmd->resp[0], cmd->resp[1]);
+
+       /* disable chipselect on errors and some success cases */
+       if (value >= 0 && cs_on)
+               return value;
+done:
+       if (value < 0)
+               cmd->error = value;
+       mmc_cs_off(host);
+       return value;
+}
+
+/* Issue command and read its response.
+ * Returns zero on success, negative for error.
+ *
+ * On error, caller must cope with mmc core retry mechanism.  That
+ * means immediate low-level resubmit, which affects the bus lock...
+ */
+static int
+mmc_spi_command_send(struct mmc_spi_host *host,
+               struct mmc_request *mrq,
+               struct mmc_command *cmd, int cs_on)
+{
+       struct scratch          *data = host->data;
+       u8                      *cp = data->status;
+       u32                     arg = cmd->arg;
+       int                     status;
+       struct spi_transfer     *t;
+
+       /* We can handle most commands (except block reads) in one full
+        * duplex I/O operation before either starting the next transfer
+        * (data block or command) or else deselecting the card.
+        *
+        * First, write 7 bytes:
+        *  - an all-ones byte to ensure the card is ready
+        *  - opcode byte (plus start and transmission bits)
+        *  - four bytes of big-endian argument
+        *  - crc7 (plus end bit) ... always computed, it's cheap
+        *
+        * We init the whole buffer to all-ones, which is what we need
+        * to write while we're reading (later) response data.
+        */
+       memset(cp++, 0xff, sizeof(data->status));
+
+       *cp++ = 0x40 | cmd->opcode;
+       *cp++ = (u8)(arg >> 24);
+       *cp++ = (u8)(arg >> 16);
+       *cp++ = (u8)(arg >> 8);
+       *cp++ = (u8)arg;
+       *cp++ = (crc7(0, &data->status[1], 5) << 1) | 0x01;
+
+       /* Then, read up to 13 bytes (while writing all-ones):
+        *  - N(CR) (== 1..8) bytes of all-ones
+        *  - status byte (for all response types)
+        *  - the rest of the response, either:
+        *      + nothing, for R1 or R1B responses
+        *      + second status byte, for R2 responses
+        *      + four data bytes, for R3 and R7 responses
+        *
+        * Finally, read some more bytes ... in the nice cases we know in
+        * advance how many, and reading 1 more is always OK:
+        *  - N(EC) (== 0..N) bytes of all-ones, before deselect/finish
+        *  - N(RC) (== 1..N) bytes of all-ones, before next command
+        *  - N(WR) (== 1..N) bytes of all-ones, before data write
+        *
+        * So in those cases one full duplex I/O of at most 21 bytes will
+        * handle the whole command, leaving the card ready to receive a
+        * data block or new command.  We do that whenever we can, shaving
+        * CPU and IRQ costs (especially when using DMA or FIFOs).
+        *
+        * There are two other cases, where it's not generally practical
+        * to rely on a single I/O:
+        *
+        *  - R1B responses need at least N(EC) bytes of all-zeroes.
+        *
+        *    In this case we can *try* to fit it into one I/O, then
+        *    maybe read more data later.
+        *
+        *  - Data block reads are more troublesome, since a variable
+        *    number of padding bytes precede the token and data.
+        *      + N(CX) (== 0..8) bytes of all-ones, before CSD or CID
+        *      + N(AC) (== 1..many) bytes of all-ones
+        *
+        *    In this case we currently only have minimal speedups here:
+        *    when N(CR) == 1 we can avoid I/O in response_get().
+        */
+       if (cs_on && (mrq->data->flags & MMC_DATA_READ)) {
+               cp += 2;        /* min(N(CR)) + status */
+               /* R1 */
+       } else {
+               cp += 10;       /* max(N(CR)) + status + min(N(RC),N(WR)) */
+               if (cmd->flags & MMC_RSP_SPI_S2)        /* R2/R5 */
+                       cp++;
+               else if (cmd->flags & MMC_RSP_SPI_B4)   /* R3/R4/R7 */
+                       cp += 4;
+               else if (cmd->flags & MMC_RSP_BUSY)     /* R1B */
+                       cp = data->status + sizeof(data->status);
+               /* else:  R1 (most commands) */
+       }
+
+       dev_dbg(&host->spi->dev, "  mmc_spi: CMD%d, resp %s\n",
+               cmd->opcode, maptype(cmd));
+
+       /* send command, leaving chipselect active */
+       spi_message_init(&host->m);
+
+       t = &host->t;
+       memset(t, 0, sizeof(*t));
+       t->tx_buf = t->rx_buf = data->status;
+       t->tx_dma = t->rx_dma = host->data_dma;
+       t->len = cp - data->status;
+       t->cs_change = 1;
+       spi_message_add_tail(t, &host->m);
+
+       if (host->dma_dev) {
+               host->m.is_dma_mapped = 1;
+               dma_sync_single_for_device(host->dma_dev,
+                               host->data_dma, sizeof(*host->data),
+                               DMA_BIDIRECTIONAL);
+       }
+       status = spi_sync(host->spi, &host->m);
+
+       if (host->dma_dev)
+               dma_sync_single_for_cpu(host->dma_dev,
+                               host->data_dma, sizeof(*host->data),
+                               DMA_BIDIRECTIONAL);
+       if (status < 0) {
+               dev_dbg(&host->spi->dev, "  ... write returned %d\n", status);
+               cmd->error = status;
+               return status;
+       }
+
+       /* after no-data commands and STOP_TRANSMISSION, chipselect off */
+       return mmc_spi_response_get(host, cmd, cs_on);
+}
+
+/* Build data message with up to four separate transfers.  For TX, we
+ * start by writing the data token.  And in most cases, we finish with
+ * a status transfer.
+ *
+ * We always provide TX data for data and CRC.  The MMC/SD protocol
+ * requires us to write ones; but Linux defaults to writing zeroes;
+ * so we explicitly initialize it to all ones on RX paths.
+ *
+ * We also handle DMA mapping, so the underlying SPI controller does
+ * not need to (re)do it for each message.
+ */
+static void
+mmc_spi_setup_data_message(
+       struct mmc_spi_host     *host,
+       int                     multiple,
+       enum dma_data_direction direction)
+{
+       struct spi_transfer     *t;
+       struct scratch          *scratch = host->data;
+       dma_addr_t              dma = host->data_dma;
+
+       spi_message_init(&host->m);
+       if (dma)
+               host->m.is_dma_mapped = 1;
+
+       /* for reads, readblock() skips 0xff bytes before finding
+        * the token; for writes, this transfer issues that token.
+        */
+       if (direction == DMA_TO_DEVICE) {
+               t = &host->token;
+               memset(t, 0, sizeof(*t));
+               t->len = 1;
+               if (multiple)
+                       scratch->data_token = SPI_TOKEN_MULTI_WRITE;
+               else
+                       scratch->data_token = SPI_TOKEN_SINGLE;
+               t->tx_buf = &scratch->data_token;
+               if (dma)
+                       t->tx_dma = dma + offsetof(struct scratch, data_token);
+               spi_message_add_tail(t, &host->m);
+       }
+
+       /* Body of transfer is buffer, then CRC ...
+        * either TX-only, or RX with TX-ones.
+        */
+       t = &host->t;
+       memset(t, 0, sizeof(*t));
+       t->tx_buf = host->ones;
+       t->tx_dma = host->ones_dma;
+       /* length and actual buffer info are written later */
+       spi_message_add_tail(t, &host->m);
+
+       t = &host->crc;
+       memset(t, 0, sizeof(*t));
+       t->len = 2;
+       if (direction == DMA_TO_DEVICE) {
+               /* the actual CRC may get written later */
+               t->tx_buf = &scratch->crc_val;
+               if (dma)
+                       t->tx_dma = dma + offsetof(struct scratch, crc_val);
+       } else {
+               t->tx_buf = host->ones;
+               t->tx_dma = host->ones_dma;
+               t->rx_buf = &scratch->crc_val;
+               if (dma)
+                       t->rx_dma = dma + offsetof(struct scratch, crc_val);
+       }
+       spi_message_add_tail(t, &host->m);
+
+       /*
+        * A single block read is followed by N(EC) [0+] all-ones bytes
+        * before deselect ... don't bother.
+        *
+        * Multiblock reads are followed by N(AC) [1+] all-ones bytes before
+        * the next block is read, or a STOP_TRANSMISSION is issued.  We'll
+        * collect that single byte, so readblock() doesn't need to.
+        *
+        * For a write, the one-byte data response follows immediately, then
+        * come zero or more busy bytes, then N(WR) [1+] all-ones bytes.
+        * Then single block reads may deselect, and multiblock ones issue
+        * the next token (next data block, or STOP_TRAN).  We can try to
+        * minimize I/O ops by using a single read to collect end-of-busy.
+        */
+       if (multiple || direction == DMA_TO_DEVICE) {
+               t = &host->early_status;
+               memset(t, 0, sizeof(*t));
+               t->len = (direction == DMA_TO_DEVICE)
+                               ? sizeof(scratch->status)
+                               : 1;
+               t->tx_buf = host->ones;
+               t->tx_dma = host->ones_dma;
+               t->rx_buf = scratch->status;
+               if (dma)
+                       t->rx_dma = dma + offsetof(struct scratch, status);
+               t->cs_change = 1;
+               spi_message_add_tail(t, &host->m);
+       }
+}
+
+/*
+ * Write one block:
+ *  - caller handled preceding N(WR) [1+] all-ones bytes
+ *  - data block
+ *     + token
+ *     + data bytes
+ *     + crc16
+ *  - an all-ones byte ... card writes a data-response byte
+ *  - followed by N(EC) [0+] all-ones bytes, card writes zero/'busy'
+ *
+ * Return negative errno, else success.
+ */
+static int
+mmc_spi_writeblock(struct mmc_spi_host *host, struct spi_transfer *t)
+{
+       struct spi_device       *spi = host->spi;
+       int                     status, i;
+       struct scratch          *scratch = host->data;
+
+       if (host->mmc->use_spi_crc)
+               scratch->crc_val = cpu_to_be16(
+                               crc_itu_t(0, t->tx_buf, t->len));
+       if (host->dma_dev)
+               dma_sync_single_for_device(host->dma_dev,
+                               host->data_dma, sizeof(*scratch),
+                               DMA_BIDIRECTIONAL);
+
+       status = spi_sync(spi, &host->m);
+
+       if (status != 0) {
+               dev_dbg(&spi->dev, "write error (%d)\n", status);
+               return status;
+       }
+
+       if (host->dma_dev)
+               dma_sync_single_for_cpu(host->dma_dev,
+                               host->data_dma, sizeof(*scratch),
+                               DMA_BIDIRECTIONAL);
+
+       /*
+        * Get the transmission data-response reply.  It must follow
+        * immediately after the data block we transferred.  This reply
+        * doesn't necessarily tell whether the write operation succeeded;
+        * it just says if the transmission was ok and whether *earlier*
+        * writes succeeded; see the standard.
+        */
+       switch (SPI_MMC_RESPONSE_CODE(scratch->status[0])) {
+       case SPI_RESPONSE_ACCEPTED:
+               status = 0;
+               break;
+       case SPI_RESPONSE_CRC_ERR:
+               /* host shall then issue MMC_STOP_TRANSMISSION */
+               status = -EILSEQ;
+               break;
+       case SPI_RESPONSE_WRITE_ERR:
+               /* host shall then issue MMC_STOP_TRANSMISSION,
+                * and should MMC_SEND_STATUS to sort it out
+                */
+               status = -EIO;
+               break;
+       default:
+               status = -EPROTO;
+               break;
+       }
+       if (status != 0) {
+               dev_dbg(&spi->dev, "write error %02x (%d)\n",
+                       scratch->status[0], status);
+               return status;
+       }
+
+       t->tx_buf += t->len;
+       if (host->dma_dev)
+               t->tx_dma += t->len;
+
+       /* Return when not busy.  If we didn't collect that status yet,
+        * we'll need some more I/O.
+        */
+       for (i = 1; i < sizeof(scratch->status); i++) {
+               if (scratch->status[i] != 0)
+                       return 0;
+       }
+       return mmc_spi_wait_unbusy(host, writeblock_timeout);
+}
+
+/*
+ * Read one block:
+ *  - skip leading all-ones bytes ... either
+ *      + N(AC) [1..f(clock,CSD)] usually, else
+ *      + N(CX) [0..8] when reading CSD or CID
+ *  - data block
+ *     + token ... if error token, no data or crc
+ *     + data bytes
+ *     + crc16
+ *
+ * After single block reads, we're done; N(EC) [0+] all-ones bytes follow
+ * before dropping chipselect.
+ *
+ * For multiblock reads, caller either reads the next block or issues a
+ * STOP_TRANSMISSION command.
+ */
+static int
+mmc_spi_readblock(struct mmc_spi_host *host, struct spi_transfer *t)
+{
+       struct spi_device       *spi = host->spi;
+       int                     status;
+       struct scratch          *scratch = host->data;
+
+       /* At least one SD card sends an all-zeroes byte when N(CX)
+        * applies, before the all-ones bytes ... just cope with that.
+        */
+       status = mmc_spi_readbytes(host, 1);
+       if (status < 0)
+               return status;
+       status = scratch->status[0];
+       if (status == 0xff || status == 0)
+               status = mmc_spi_readtoken(host);
+
+       if (status == SPI_TOKEN_SINGLE) {
+               if (host->dma_dev) {
+                       dma_sync_single_for_device(host->dma_dev,
+                                       host->data_dma, sizeof(*scratch),
+                                       DMA_BIDIRECTIONAL);
+                       dma_sync_single_for_device(host->dma_dev,
+                                       t->rx_dma, t->len,
+                                       DMA_FROM_DEVICE);
+               }
+
+               status = spi_sync(spi, &host->m);
+
+               if (host->dma_dev) {
+                       dma_sync_single_for_cpu(host->dma_dev,
+                                       host->data_dma, sizeof(*scratch),
+                                       DMA_BIDIRECTIONAL);
+                       dma_sync_single_for_cpu(host->dma_dev,
+                                       t->rx_dma, t->len,
+                                       DMA_FROM_DEVICE);
+               }
+
+       } else {
+               dev_dbg(&spi->dev, "read error %02x (%d)\n", status, status);
+
+               /* we've read extra garbage, timed out, etc */
+               if (status < 0)
+                       return status;
+
+               /* low four bits are an R2 subset, fifth seems to be
+                * vendor specific ... map them all to generic error..
+                */
+               return -EIO;
+       }
+
+       if (host->mmc->use_spi_crc) {
+               u16 crc = crc_itu_t(0, t->rx_buf, t->len);
+
+               be16_to_cpus(&scratch->crc_val);
+               if (scratch->crc_val != crc) {
+                       dev_dbg(&spi->dev, "read - crc error: crc_val=0x%04x, "
+                                       "computed=0x%04x len=%d\n",
+                                       scratch->crc_val, crc, t->len);
+                       return -EILSEQ;
+               }
+       }
+
+       t->rx_buf += t->len;
+       if (host->dma_dev)
+               t->rx_dma += t->len;
+
+       return 0;
+}
+
+/*
+ * An MMC/SD data stage includes one or more blocks, optional CRCs,
+ * and inline handshaking.  That handhaking makes it unlike most
+ * other SPI protocol stacks.
+ */
+static void
+mmc_spi_data_do(struct mmc_spi_host *host, struct mmc_command *cmd,
+               struct mmc_data *data, u32 blk_size)
+{
+       struct spi_device       *spi = host->spi;
+       struct device           *dma_dev = host->dma_dev;
+       struct spi_transfer     *t;
+       enum dma_data_direction direction;
+       struct scatterlist      *sg;
+       unsigned                n_sg;
+       int                     multiple = (data->blocks > 1);
+
+       if (data->flags & MMC_DATA_READ)
+               direction = DMA_FROM_DEVICE;
+       else
+               direction = DMA_TO_DEVICE;
+       mmc_spi_setup_data_message(host, multiple, direction);
+       t = &host->t;
+
+       /* Handle scatterlist segments one at a time, with synch for
+        * each 512-byte block
+        */
+       for (sg = data->sg, n_sg = data->sg_len; n_sg; n_sg--, sg++) {
+               int                     status = 0;
+               dma_addr_t              dma_addr = 0;
+               void                    *kmap_addr;
+               unsigned                length = sg->length;
+               enum dma_data_direction dir = direction;
+
+               /* set up dma mapping for controller drivers that might
+                * use DMA ... though they may fall back to PIO
+                */
+               if (dma_dev) {
+                       /* never invalidate whole *shared* pages ... */
+                       if ((sg->offset != 0 || length != PAGE_SIZE)
+                                       && dir == DMA_FROM_DEVICE)
+                               dir = DMA_BIDIRECTIONAL;
+
+                       dma_addr = dma_map_page(dma_dev, sg_page(sg), 0,
+                                               PAGE_SIZE, dir);
+                       if (direction == DMA_TO_DEVICE)
+                               t->tx_dma = dma_addr + sg->offset;
+                       else
+                               t->rx_dma = dma_addr + sg->offset;
+               }
+
+               /* allow pio too; we don't allow highmem */
+               kmap_addr = kmap(sg_page(sg));
+               if (direction == DMA_TO_DEVICE)
+                       t->tx_buf = kmap_addr + sg->offset;
+               else
+                       t->rx_buf = kmap_addr + sg->offset;
+
+               /* transfer each block, and update request status */
+               while (length) {
+                       t->len = min(length, blk_size);
+
+                       dev_dbg(&host->spi->dev,
+                               "    mmc_spi: %s block, %d bytes\n",
+                               (direction == DMA_TO_DEVICE)
+                               ? "write"
+                               : "read",
+                               t->len);
+
+                       if (direction == DMA_TO_DEVICE)
+                               status = mmc_spi_writeblock(host, t);
+                       else
+                               status = mmc_spi_readblock(host, t);
+                       if (status < 0)
+                               break;
+
+                       data->bytes_xfered += t->len;
+                       length -= t->len;
+
+                       if (!multiple)
+                               break;
+               }
+
+               /* discard mappings */
+               if (direction == DMA_FROM_DEVICE)
+                       flush_kernel_dcache_page(sg_page(sg));
+               kunmap(sg_page(sg));
+               if (dma_dev)
+                       dma_unmap_page(dma_dev, dma_addr, PAGE_SIZE, dir);
+
+               if (status < 0) {
+                       data->error = status;
+                       dev_dbg(&spi->dev, "%s status %d\n",
+                               (direction == DMA_TO_DEVICE)
+                                       ? "write" : "read",
+                               status);
+                       break;
+               }
+       }
+
+       /* NOTE some docs describe an MMC-only SET_BLOCK_COUNT (CMD23) that
+        * can be issued before multiblock writes.  Unlike its more widely
+        * documented analogue for SD cards (SET_WR_BLK_ERASE_COUNT, ACMD23),
+        * that can affect the STOP_TRAN logic.   Complete (and current)
+        * MMC specs should sort that out before Linux starts using CMD23.
+        */
+       if (direction == DMA_TO_DEVICE && multiple) {
+               struct scratch  *scratch = host->data;
+               int             tmp;
+               const unsigned  statlen = sizeof(scratch->status);
+
+               dev_dbg(&spi->dev, "    mmc_spi: STOP_TRAN\n");
+
+               /* Tweak the per-block message we set up earlier by morphing
+                * it to hold single buffer with the token followed by some
+                * all-ones bytes ... skip N(BR) (0..1), scan the rest for
+                * "not busy any longer" status, and leave chip selected.
+                */
+               INIT_LIST_HEAD(&host->m.transfers);
+               list_add(&host->early_status.transfer_list,
+                               &host->m.transfers);
+
+               memset(scratch->status, 0xff, statlen);
+               scratch->status[0] = SPI_TOKEN_STOP_TRAN;
+
+               host->early_status.tx_buf = host->early_status.rx_buf;
+               host->early_status.tx_dma = host->early_status.rx_dma;
+               host->early_status.len = statlen;
+
+               if (host->dma_dev)
+                       dma_sync_single_for_device(host->dma_dev,
+                                       host->data_dma, sizeof(*scratch),
+                                       DMA_BIDIRECTIONAL);
+
+               tmp = spi_sync(spi, &host->m);
+
+               if (host->dma_dev)
+                       dma_sync_single_for_cpu(host->dma_dev,
+                                       host->data_dma, sizeof(*scratch),
+                                       DMA_BIDIRECTIONAL);
+
+               if (tmp < 0) {
+                       if (!data->error)
+                               data->error = tmp;
+                       return;
+               }
+
+               /* Ideally we collected "not busy" status with one I/O,
+                * avoiding wasteful byte-at-a-time scanning... but more
+                * I/O is often needed.
+                */
+               for (tmp = 2; tmp < statlen; tmp++) {
+                       if (scratch->status[tmp] != 0)
+                               return;
+               }
+               tmp = mmc_spi_wait_unbusy(host, writeblock_timeout);
+               if (tmp < 0 && !data->error)
+                       data->error = tmp;
+       }
+}
+
+/****************************************************************************/
+
+/*
+ * MMC driver implementation -- the interface to the MMC stack
+ */
+
+static void mmc_spi_request(struct mmc_host *mmc, struct mmc_request *mrq)
+{
+       struct mmc_spi_host     *host = mmc_priv(mmc);
+       int                     status = -EINVAL;
+
+#ifdef DEBUG
+       /* MMC core and layered drivers *MUST* issue SPI-aware commands */
+       {
+               struct mmc_command      *cmd;
+               int                     invalid = 0;
+
+               cmd = mrq->cmd;
+               if (!mmc_spi_resp_type(cmd)) {
+                       dev_dbg(&host->spi->dev, "bogus command\n");
+                       cmd->error = -EINVAL;
+                       invalid = 1;
+               }
+
+               cmd = mrq->stop;
+               if (cmd && !mmc_spi_resp_type(cmd)) {
+                       dev_dbg(&host->spi->dev, "bogus STOP command\n");
+                       cmd->error = -EINVAL;
+                       invalid = 1;
+               }
+
+               if (invalid) {
+                       dump_stack();
+                       mmc_request_done(host->mmc, mrq);
+                       return;
+               }
+       }
+#endif
+
+       /* issue command; then optionally data and stop */
+       status = mmc_spi_command_send(host, mrq, mrq->cmd, mrq->data != NULL);
+       if (status == 0 && mrq->data) {
+               mmc_spi_data_do(host, mrq->cmd, mrq->data, mrq->data->blksz);
+               if (mrq->stop)
+                       status = mmc_spi_command_send(host, mrq, mrq->stop, 0);
+               else
+                       mmc_cs_off(host);
+       }
+
+       mmc_request_done(host->mmc, mrq);
+}
+
+/* See Section 6.4.1, in SD "Simplified Physical Layer Specification 2.0"
+ *
+ * NOTE that here we can't know that the card has just been powered up;
+ * not all MMC/SD sockets support power switching.
+ *
+ * FIXME when the card is still in SPI mode, e.g. from a previous kernel,
+ * this doesn't seem to do the right thing at all...
+ */
+static void mmc_spi_initsequence(struct mmc_spi_host *host)
+{
+       /* Try to be very sure any previous command has completed;
+        * wait till not-busy, skip debris from any old commands.
+        */
+       mmc_spi_wait_unbusy(host, r1b_timeout);
+       mmc_spi_readbytes(host, 10);
+
+       /*
+        * Do a burst with chipselect active-high.  We need to do this to
+        * meet the requirement of 74 clock cycles with both chipselect
+        * and CMD (MOSI) high before CMD0 ... after the card has been
+        * powered up to Vdd(min), and so is ready to take commands.
+        *
+        * Some cards are particularly needy of this (e.g. Viking "SD256")
+        * while most others don't seem to care.
+        *
+        * Note that this is one of the places MMC/SD plays games with the
+        * SPI protocol.  Another is that when chipselect is released while
+        * the card returns BUSY status, the clock must issue several cycles
+        * with chipselect high before the card will stop driving its output.
+        */
+       host->spi->mode |= SPI_CS_HIGH;
+       if (spi_setup(host->spi) != 0) {
+               /* Just warn; most cards work without it. */
+               dev_warn(&host->spi->dev,
+                               "can't change chip-select polarity\n");
+               host->spi->mode &= ~SPI_CS_HIGH;
+       } else {
+               mmc_spi_readbytes(host, 18);
+
+               host->spi->mode &= ~SPI_CS_HIGH;
+               if (spi_setup(host->spi) != 0) {
+                       /* Wot, we can't get the same setup we had before? */
+                       dev_err(&host->spi->dev,
+                                       "can't restore chip-select polarity\n");
+               }
+       }
+}
+
+static char *mmc_powerstring(u8 power_mode)
+{
+       switch (power_mode) {
+       case MMC_POWER_OFF: return "off";
+       case MMC_POWER_UP:  return "up";
+       case MMC_POWER_ON:  return "on";
+       }
+       return "?";
+}
+
+static void mmc_spi_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
+{
+       struct mmc_spi_host *host = mmc_priv(mmc);
+
+       if (host->power_mode != ios->power_mode) {
+               int             canpower;
+
+               canpower = host->pdata && host->pdata->setpower;
+
+               dev_dbg(&host->spi->dev, "mmc_spi: power %s (%d)%s\n",
+                               mmc_powerstring(ios->power_mode),
+                               ios->vdd,
+                               canpower ? ", can switch" : "");
+
+               /* switch power on/off if possible, accounting for
+                * max 250msec powerup time if needed.
+                */
+               if (canpower) {
+                       switch (ios->power_mode) {
+                       case MMC_POWER_OFF:
+                       case MMC_POWER_UP:
+                               host->pdata->setpower(&host->spi->dev,
+                                               ios->vdd);
+                               if (ios->power_mode == MMC_POWER_UP)
+                                       msleep(host->powerup_msecs);
+                       }
+               }
+
+               /* See 6.4.1 in the simplified SD card physical spec 2.0 */
+               if (ios->power_mode == MMC_POWER_ON)
+                       mmc_spi_initsequence(host);
+
+               /* If powering down, ground all card inputs to avoid power
+                * delivery from data lines!  On a shared SPI bus, this
+                * will probably be temporary; 6.4.2 of the simplified SD
+                * spec says this must last at least 1msec.
+                *
+                *   - Clock low means CPOL 0, e.g. mode 0
+                *   - MOSI low comes from writing zero
+                *   - Chipselect is usually active low...
+                */
+               if (canpower && ios->power_mode == MMC_POWER_OFF) {
+                       int mres;
+
+                       host->spi->mode &= ~(SPI_CPOL|SPI_CPHA);
+                       mres = spi_setup(host->spi);
+                       if (mres < 0)
+                               dev_dbg(&host->spi->dev,
+                                       "switch to SPI mode 0 failed\n");
+
+                       if (spi_w8r8(host->spi, 0x00) < 0)
+                               dev_dbg(&host->spi->dev,
+                                       "put spi signals to low failed\n");
+
+                       /*
+                        * Now clock should be low due to spi mode 0;
+                        * MOSI should be low because of written 0x00;
+                        * chipselect should be low (it is active low)
+                        * power supply is off, so now MMC is off too!
+                        *
+                        * FIXME no, chipselect can be high since the
+                        * device is inactive and SPI_CS_HIGH is clear...
+                        */
+                       msleep(10);
+                       if (mres == 0) {
+                               host->spi->mode |= (SPI_CPOL|SPI_CPHA);
+                               mres = spi_setup(host->spi);
+                               if (mres < 0)
+                                       dev_dbg(&host->spi->dev,
+                                               "switch back to SPI mode 3"
+                                               " failed\n");
+                       }
+               }
+
+               host->power_mode = ios->power_mode;
+       }
+
+       if (host->spi->max_speed_hz != ios->clock && ios->clock != 0) {
+               int             status;
+
+               host->spi->max_speed_hz = ios->clock;
+               status = spi_setup(host->spi);
+               dev_dbg(&host->spi->dev,
+                       "mmc_spi:  clock to %d Hz, %d\n",
+                       host->spi->max_speed_hz, status);
+       }
+}
+
+static int mmc_spi_get_ro(struct mmc_host *mmc)
+{
+       struct mmc_spi_host *host = mmc_priv(mmc);
+
+       if (host->pdata && host->pdata->get_ro)
+               return host->pdata->get_ro(mmc->parent);
+       /* board doesn't support read only detection; assume writeable */
+       return 0;
+}
+
+
+static const struct mmc_host_ops mmc_spi_ops = {
+       .request        = mmc_spi_request,
+       .set_ios        = mmc_spi_set_ios,
+       .get_ro         = mmc_spi_get_ro,
+};
+
+
+/****************************************************************************/
+
+/*
+ * SPI driver implementation
+ */
+
+static irqreturn_t
+mmc_spi_detect_irq(int irq, void *mmc)
+{
+       struct mmc_spi_host *host = mmc_priv(mmc);
+       u16 delay_msec = max(host->pdata->detect_delay, (u16)100);
+
+       mmc_detect_change(mmc, msecs_to_jiffies(delay_msec));
+       return IRQ_HANDLED;
+}
+
+struct count_children {
+       unsigned        n;
+       struct bus_type *bus;
+};
+
+static int maybe_count_child(struct device *dev, void *c)
+{
+       struct count_children *ccp = c;
+
+       if (dev->bus == ccp->bus) {
+               if (ccp->n)
+                       return -EBUSY;
+               ccp->n++;
+       }
+       return 0;
+}
+
+static int mmc_spi_probe(struct spi_device *spi)
+{
+       void                    *ones;
+       struct mmc_host         *mmc;
+       struct mmc_spi_host     *host;
+       int                     status;
+
+       /* MMC and SD specs only seem to care that sampling is on the
+        * rising edge ... meaning SPI modes 0 or 3.  So either SPI mode
+        * should be legit.  We'll use mode 0 since it seems to be a
+        * bit less troublesome on some hardware ... unclear why.
+        */
+       spi->mode = SPI_MODE_0;
+       spi->bits_per_word = 8;
+
+       status = spi_setup(spi);
+       if (status < 0) {
+               dev_dbg(&spi->dev, "needs SPI mode %02x, %d KHz; %d\n",
+                               spi->mode, spi->max_speed_hz / 1000,
+                               status);
+               return status;
+       }
+
+       /* We can use the bus safely iff nobody else will interfere with us.
+        * Most commands consist of one SPI message to issue a command, then
+        * several more to collect its response, then possibly more for data
+        * transfer.  Clocking access to other devices during that period will
+        * corrupt the command execution.
+        *
+        * Until we have software primitives which guarantee non-interference,
+        * we'll aim for a hardware-level guarantee.
+        *
+        * REVISIT we can't guarantee another device won't be added later...
+        */
+       if (spi->master->num_chipselect > 1) {
+               struct count_children cc;
+
+               cc.n = 0;
+               cc.bus = spi->dev.bus;
+               status = device_for_each_child(spi->dev.parent, &cc,
+                               maybe_count_child);
+               if (status < 0) {
+                       dev_err(&spi->dev, "can't share SPI bus\n");
+                       return status;
+               }
+
+               dev_warn(&spi->dev, "ASSUMING SPI bus stays unshared!\n");
+       }
+
+       /* We need a supply of ones to transmit.  This is the only time
+        * the CPU touches these, so cache coherency isn't a concern.
+        *
+        * NOTE if many systems use more than one MMC-over-SPI connector
+        * it'd save some memory to share this.  That's evidently rare.
+        */
+       status = -ENOMEM;
+       ones = kmalloc(MMC_SPI_BLOCKSIZE, GFP_KERNEL);
+       if (!ones)
+               goto nomem;
+       memset(ones, 0xff, MMC_SPI_BLOCKSIZE);
+
+       mmc = mmc_alloc_host(sizeof(*host), &spi->dev);
+       if (!mmc)
+               goto nomem;
+
+       mmc->ops = &mmc_spi_ops;
+       mmc->max_blk_size = MMC_SPI_BLOCKSIZE;
+
+       /* As long as we keep track of the number of successfully
+        * transmitted blocks, we're good for multiwrite.
+        */
+       mmc->caps = MMC_CAP_SPI | MMC_CAP_MULTIWRITE;
+
+       /* SPI doesn't need the lowspeed device identification thing for
+        * MMC or SD cards, since it never comes up in open drain mode.
+        * That's good; some SPI masters can't handle very low speeds!
+        *
+        * However, low speed SDIO cards need not handle over 400 KHz;
+        * that's the only reason not to use a few MHz for f_min (until
+        * the upper layer reads the target frequency from the CSD).
+        */
+       mmc->f_min = 400000;
+       mmc->f_max = spi->max_speed_hz;
+
+       host = mmc_priv(mmc);
+       host->mmc = mmc;
+       host->spi = spi;
+
+       host->ones = ones;
+
+       /* Platform data is used to hook up things like card sensing
+        * and power switching gpios.
+        */
+       host->pdata = spi->dev.platform_data;
+       if (host->pdata)
+               mmc->ocr_avail = host->pdata->ocr_mask;
+       if (!mmc->ocr_avail) {
+               dev_warn(&spi->dev, "ASSUMING 3.2-3.4 V slot power\n");
+               mmc->ocr_avail = MMC_VDD_32_33|MMC_VDD_33_34;
+       }
+       if (host->pdata && host->pdata->setpower) {
+               host->powerup_msecs = host->pdata->powerup_msecs;
+               if (!host->powerup_msecs || host->powerup_msecs > 250)
+                       host->powerup_msecs = 250;
+       }
+
+       dev_set_drvdata(&spi->dev, mmc);
+
+       /* preallocate dma buffers */
+       host->data = kmalloc(sizeof(*host->data), GFP_KERNEL);
+       if (!host->data)
+               goto fail_nobuf1;
+
+//FIXME
+#if 0
+       if (spi->master->dev.parent->dma_mask) {
+               struct device   *dev = spi->master->dev.parent;
+
+               host->dma_dev = dev;
+               host->ones_dma = dma_map_single(dev, ones,
+                               MMC_SPI_BLOCKSIZE, DMA_TO_DEVICE);
+               host->data_dma = dma_map_single(dev, host->data,
+                               sizeof(*host->data), DMA_BIDIRECTIONAL);
+
+               /* REVISIT in theory those map operations can fail... */
+
+               dma_sync_single_for_cpu(host->dma_dev,
+                               host->data_dma, sizeof(*host->data),
+                               DMA_BIDIRECTIONAL);
+       }
+#endif
+
+       /* setup message for status/busy readback */
+       spi_message_init(&host->readback);
+       host->readback.is_dma_mapped = (host->dma_dev != NULL);
+
+       spi_message_add_tail(&host->status, &host->readback);
+       host->status.tx_buf = host->ones;
+       host->status.tx_dma = host->ones_dma;
+       host->status.rx_buf = &host->data->status;
+       host->status.rx_dma = host->data_dma + offsetof(struct scratch, status);
+       host->status.cs_change = 1;
+
+       /* register card detect irq */
+       if (host->pdata && host->pdata->init) {
+               status = host->pdata->init(&spi->dev, mmc_spi_detect_irq, mmc);
+               if (status != 0)
+                       goto fail_glue_init;
+       }
+
+       status = mmc_add_host(mmc);
+       if (status != 0)
+               goto fail_add_host;
+
+       dev_info(&spi->dev, "SD/MMC host %s%s%s%s\n",
+                       mmc->class_dev.bus_id,
+                       host->dma_dev ? "" : ", no DMA",
+                       (host->pdata && host->pdata->get_ro)
+                               ? "" : ", no WP",
+                       (host->pdata && host->pdata->setpower)
+                               ? "" : ", no poweroff");
+       return 0;
+
+fail_add_host:
+       mmc_remove_host (mmc);
+fail_glue_init:
+       if (host->dma_dev)
+               dma_unmap_single(host->dma_dev, host->data_dma,
+                               sizeof(*host->data), DMA_BIDIRECTIONAL);
+       kfree(host->data);
+
+fail_nobuf1:
+       mmc_free_host(mmc);
+       dev_set_drvdata(&spi->dev, NULL);
+
+nomem:
+       kfree(ones);
+       return status;
+}
+
+
+static int __devexit mmc_spi_remove(struct spi_device *spi)
+{
+       struct mmc_host         *mmc = dev_get_drvdata(&spi->dev);
+       struct mmc_spi_host     *host;
+
+       if (mmc) {
+               host = mmc_priv(mmc);
+
+               /* prevent new mmc_detect_change() calls */
+               if (host->pdata && host->pdata->exit)
+                       host->pdata->exit(&spi->dev, mmc);
+
+               mmc_remove_host(mmc);
+
+               if (host->dma_dev) {
+                       dma_unmap_single(host->dma_dev, host->ones_dma,
+                               MMC_SPI_BLOCKSIZE, DMA_TO_DEVICE);
+                       dma_unmap_single(host->dma_dev, host->data_dma,
+                               sizeof(*host->data), DMA_BIDIRECTIONAL);
+               }
+
+               kfree(host->data);
+               kfree(host->ones);
+
+               spi->max_speed_hz = mmc->f_max;
+               mmc_free_host(mmc);
+               dev_set_drvdata(&spi->dev, NULL);
+       }
+       return 0;
+}
+
+
+static struct spi_driver mmc_spi_driver = {
+       .driver = {
+               .name =         "mmc_spi",
+               .bus =          &spi_bus_type,
+               .owner =        THIS_MODULE,
+       },
+       .probe =        mmc_spi_probe,
+       .remove =       __devexit_p(mmc_spi_remove),
+};
+
+
+static int __init mmc_spi_init(void)
+{
+       return spi_register_driver(&mmc_spi_driver);
+}
+module_init(mmc_spi_init);
+
+
+static void __exit mmc_spi_exit(void)
+{
+       spi_unregister_driver(&mmc_spi_driver);
+}
+module_exit(mmc_spi_exit);
+
+
+MODULE_AUTHOR("Mike Lavender, David Brownell, "
+               "Hans-Peter Nilsson, Jan Nikitenko");
+MODULE_DESCRIPTION("SPI SD/MMC host driver");
+MODULE_LICENSE("GPL");
--- /dev/null
+++ b/include/linux/spi/mmc_spi.h
@@ -0,0 +1,33 @@
+#ifndef __LINUX_SPI_MMC_SPI_H
+#define __LINUX_SPI_MMC_SPI_H
+
+struct device;
+struct mmc_host;
+
+/* Put this in platform_data of a device being used to manage an MMC/SD
+ * card slot.  (Modeled after PXA mmc glue; see that for usage examples.)
+ *
+ * REVISIT This is not a spi-specific notion.  Any card slot should be
+ * able to handle it.  If the MMC core doesn't adopt this kind of notion,
+ * switch the "struct device *" parameters over to "struct spi_device *".
+ */
+struct mmc_spi_platform_data {
+       /* driver activation and (optional) card detect irq hookup */
+       int (*init)(struct device *,
+               irqreturn_t (*)(int, void *),
+               void *);
+       void (*exit)(struct device *, void *);
+
+       /* sense switch on sd cards */
+       int (*get_ro)(struct device *);
+
+       /* how long to debounce card detect, in msecs */
+       u16 detect_delay;
+
+       /* power management */
+       u16 powerup_msecs;              /* delay of up to 250 msec */
+       u32 ocr_mask;                   /* available voltages */
+       void (*setpower)(struct device *, unsigned int maskval);
+};
+
+#endif /* __LINUX_SPI_MMC_SPI_H */
--- a/drivers/mmc/core/bus.c
+++ b/drivers/mmc/core/bus.c
@@ -19,6 +19,7 @@
 
 #include "sysfs.h"
 #include "core.h"
+#include "sdio_cis.h"
 #include "bus.h"
 
 #define dev_to_mmc_card(d)     container_of(d, struct mmc_card, dev)
@@ -34,6 +35,8 @@
                return sprintf(buf, "MMC\n");
        case MMC_TYPE_SD:
                return sprintf(buf, "SD\n");
+       case MMC_TYPE_SDIO:
+               return sprintf(buf, "SDIO\n");
        default:
                return -EFAULT;
        }
@@ -55,36 +58,37 @@
 }
 
 static int
-mmc_bus_uevent(struct device *dev, char **envp, int num_envp, char *buf,
-               int buf_size)
+mmc_bus_uevent(struct device *dev, char **envp,
+               int num_envp, char *buffer, int buffer_size)
 {
        struct mmc_card *card = dev_to_mmc_card(dev);
-       int retval = 0, i = 0, length = 0;
-
-#define add_env(fmt,val) do {                                  \
-       retval = add_uevent_var(envp, num_envp, &i,             \
-                               buf, buf_size, &length,         \
-                               fmt, val);                      \
-       if (retval)                                             \
-               return retval;                                  \
-} while (0);
+       const char *type;
+       int retval = 0;
+       int i = 0, len = 0;
 
        switch (card->type) {
        case MMC_TYPE_MMC:
-               add_env("MMC_TYPE=%s", "MMC");
+               type = "MMC";
                break;
        case MMC_TYPE_SD:
-               add_env("MMC_TYPE=%s", "SD");
+               type = "SD";
                break;
+       case MMC_TYPE_SDIO:
+               type = "SDIO";
+               break;
+       default:
+               type = NULL;
        }
 
-       add_env("MMC_NAME=%s", mmc_card_name(card));
-
-#undef add_env
+       if (type) {
+               retval = add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &len, "MMC_TYPE=%s", type);
+               if (retval)
+                       return retval;
+       }
 
-       envp[i] = NULL;
+       retval = add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &len, "MMC_NAME=%s", mmc_card_name(card));
 
-       return 0;
+       return retval;
 }
 
 static int mmc_bus_probe(struct device *dev)
@@ -176,6 +180,11 @@
 {
        struct mmc_card *card = dev_to_mmc_card(dev);
 
+       sdio_free_common_cis(card);
+
+       if (card->info)
+               kfree(card->info);
+
        kfree(card);
 }
 
@@ -221,15 +230,25 @@
                if (mmc_card_blockaddr(card))
                        type = "SDHC";
                break;
+       case MMC_TYPE_SDIO:
+               type = "SDIO";
+               break;
        default:
                type = "?";
                break;
        }
 
-       printk(KERN_INFO "%s: new %s%s card at address %04x\n",
-               mmc_hostname(card->host),
-               mmc_card_highspeed(card) ? "high speed " : "",
-               type, card->rca);
+       if (mmc_host_is_spi(card->host)) {
+               printk(KERN_INFO "%s: new %s%s card on SPI\n",
+                       mmc_hostname(card->host),
+                       mmc_card_highspeed(card) ? "high speed " : "",
+                       type);
+       } else {
+               printk(KERN_INFO "%s: new %s%s card at address %04x\n",
+                       mmc_hostname(card->host),
+                       mmc_card_highspeed(card) ? "high speed " : "",
+                       type, card->rca);
+       }
 
        card->dev.uevent_suppress = 1;
 
@@ -261,8 +280,13 @@
 void mmc_remove_card(struct mmc_card *card)
 {
        if (mmc_card_present(card)) {
-               printk(KERN_INFO "%s: card %04x removed\n",
-                       mmc_hostname(card->host), card->rca);
+               if (mmc_host_is_spi(card->host)) {
+                       printk(KERN_INFO "%s: SPI card removed\n",
+                               mmc_hostname(card->host));
+               } else {
+                       printk(KERN_INFO "%s: card %04x removed\n",
+                               mmc_hostname(card->host), card->rca);
+               }
 
                if (card->host->bus_ops->sysfs_remove)
                        card->host->bus_ops->sysfs_remove(card->host, card);
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -18,7 +18,7 @@
 #include <linux/delay.h>
 #include <linux/pagemap.h>
 #include <linux/err.h>
-#include <asm/scatterlist.h>
+#include <linux/leds.h>
 #include <linux/scatterlist.h>
 
 #include <linux/mmc/card.h>
@@ -29,16 +29,27 @@
 #include "core.h"
 #include "bus.h"
 #include "host.h"
+#include "sdio_bus.h"
 
 #include "mmc_ops.h"
 #include "sd_ops.h"
+#include "sdio_ops.h"
 
 extern int mmc_attach_mmc(struct mmc_host *host, u32 ocr);
 extern int mmc_attach_sd(struct mmc_host *host, u32 ocr);
+extern int mmc_attach_sdio(struct mmc_host *host, u32 ocr);
 
 static struct workqueue_struct *workqueue;
 
 /*
+ * Enabling software CRCs on the data blocks can be a significant (30%)
+ * performance cost, and for other reasons may not always be desired.
+ * So we allow it it to be disabled.
+ */
+int use_spi_crc = 1;
+module_param(use_spi_crc, bool, 0);
+
+/*
  * Internal function. Schedule delayed work in the MMC work queue.
  */
 static int mmc_schedule_delayed_work(struct delayed_work *work,
@@ -68,6 +79,11 @@
        struct mmc_command *cmd = mrq->cmd;
        int err = cmd->error;
 
+       if (err && cmd->retries && mmc_host_is_spi(host)) {
+               if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
+                       cmd->retries = 0;
+       }
+
        if (err && cmd->retries) {
                pr_debug("%s: req failed (CMD%u): %d, retrying...\n",
                        mmc_hostname(host), cmd->opcode, err);
@@ -76,6 +92,8 @@
                cmd->error = 0;
                host->ops->request(host, mrq);
        } else {
+               led_trigger_event(host->led, LED_OFF);
+
                pr_debug("%s: req done (CMD%u): %d: %08x %08x %08x %08x\n",
                        mmc_hostname(host), cmd->opcode, err,
                        cmd->resp[0], cmd->resp[1],
@@ -118,7 +136,7 @@
                        "tsac %d ms nsac %d\n",
                        mmc_hostname(host), mrq->data->blksz,
                        mrq->data->blocks, mrq->data->flags,
-                       mrq->data->timeout_ns / 10000000,
+                       mrq->data->timeout_ns / 1000000,
                        mrq->data->timeout_clks);
        }
 
@@ -130,6 +148,8 @@
 
        WARN_ON(!host->claimed);
 
+       led_trigger_event(host->led, LED_FULL);
+
        mrq->cmd->error = 0;
        mrq->cmd->mrq = mrq;
        if (mrq->data) {
@@ -199,7 +219,7 @@
 {
        struct mmc_request mrq;
 
-       BUG_ON(!host->claimed);
+       WARN_ON(!host->claimed);
 
        memset(&mrq, 0, sizeof(struct mmc_request));
 
@@ -220,17 +240,24 @@
  *     mmc_set_data_timeout - set the timeout for a data command
  *     @data: data phase for command
  *     @card: the MMC card associated with the data transfer
- *     @write: flag to differentiate reads from writes
  *
  *     Computes the data timeout parameters according to the
  *     correct algorithm given the card type.
  */
-void mmc_set_data_timeout(struct mmc_data *data, const struct mmc_card *card,
-                         int write)
+void mmc_set_data_timeout(struct mmc_data *data, const struct mmc_card *card)
 {
        unsigned int mult;
 
        /*
+        * SDIO cards only define an upper 1 s limit on access.
+        */
+       if (mmc_card_sdio(card)) {
+               data->timeout_ns = 1000000000;
+               data->timeout_clks = 0;
+               return;
+       }
+
+       /*
         * SD cards use a 100 multiplier rather than 10
         */
        mult = mmc_card_sd(card) ? 100 : 10;
@@ -239,7 +266,7 @@
         * Scale up the multiplier (and therefore the timeout) by
         * the r2w factor for writes.
         */
-       if (write)
+       if (data->flags & MMC_DATA_WRITE)
                mult <<= card->csd.r2w_factor;
 
        data->timeout_ns = card->csd.tacc_ns * mult;
@@ -255,7 +282,7 @@
                timeout_us += data->timeout_clks * 1000 /
                        (card->host->ios.clock / 1000);
 
-               if (write)
+               if (data->flags & MMC_DATA_WRITE)
                        limit_us = 250000;
                else
                        limit_us = 100000;
@@ -272,15 +299,20 @@
 EXPORT_SYMBOL(mmc_set_data_timeout);
 
 /**
- *     mmc_claim_host - exclusively claim a host
+ *     __mmc_claim_host - exclusively claim a host
  *     @host: mmc host to claim
+ *     @abort: whether or not the operation should be aborted
  *
- *     Claim a host for a set of operations.
+ *     Claim a host for a set of operations.  If @abort is non null and
+ *     dereference a non-zero value then this will return prematurely with
+ *     that non-zero value without acquiring the lock.  Returns zero
+ *     with the lock held otherwise.
  */
-void mmc_claim_host(struct mmc_host *host)
+int __mmc_claim_host(struct mmc_host *host, atomic_t *abort)
 {
        DECLARE_WAITQUEUE(wait, current);
        unsigned long flags;
+       int stop;
 
        might_sleep();
 
@@ -288,19 +320,24 @@
        spin_lock_irqsave(&host->lock, flags);
        while (1) {
                set_current_state(TASK_UNINTERRUPTIBLE);
-               if (!host->claimed)
+               stop = abort ? atomic_read(abort) : 0;
+               if (stop || !host->claimed)
                        break;
                spin_unlock_irqrestore(&host->lock, flags);
                schedule();
                spin_lock_irqsave(&host->lock, flags);
        }
        set_current_state(TASK_RUNNING);
-       host->claimed = 1;
+       if (!stop)
+               host->claimed = 1;
+       else
+               wake_up(&host->wq);
        spin_unlock_irqrestore(&host->lock, flags);
        remove_wait_queue(&host->wq, &wait);
+       return stop;
 }
 
-EXPORT_SYMBOL(mmc_claim_host);
+EXPORT_SYMBOL(__mmc_claim_host);
 
 /**
  *     mmc_release_host - release a host
@@ -313,7 +350,7 @@
 {
        unsigned long flags;
 
-       BUG_ON(!host->claimed);
+       WARN_ON(!host->claimed);
 
        spin_lock_irqsave(&host->lock, flags);
        host->claimed = 0;
@@ -433,19 +470,32 @@
        int bit = fls(host->ocr_avail) - 1;
 
        host->ios.vdd = bit;
-       host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
-       host->ios.chip_select = MMC_CS_DONTCARE;
+       if (mmc_host_is_spi(host)) {
+               host->ios.chip_select = MMC_CS_HIGH;
+               host->ios.bus_mode = MMC_BUSMODE_PUSHPULL;
+       } else {
+               host->ios.chip_select = MMC_CS_DONTCARE;
+               host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
+       }
        host->ios.power_mode = MMC_POWER_UP;
        host->ios.bus_width = MMC_BUS_WIDTH_1;
        host->ios.timing = MMC_TIMING_LEGACY;
        mmc_set_ios(host);
 
-       mmc_delay(1);
+       /*
+        * This delay should be sufficient to allow the power supply
+        * to reach the minimum voltage.
+        */
+       mmc_delay(2);
 
        host->ios.clock = host->f_min;
        host->ios.power_mode = MMC_POWER_ON;
        mmc_set_ios(host);
 
+       /*
+        * This delay must be at least 74 clock sizes, or 1 ms, or the
+        * time required to reach a stable voltage.
+        */
        mmc_delay(2);
 }
 
@@ -453,8 +503,10 @@
 {
        host->ios.clock = 0;
        host->ios.vdd = 0;
-       host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
-       host->ios.chip_select = MMC_CS_DONTCARE;
+       if (!mmc_host_is_spi(host)) {
+               host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
+               host->ios.chip_select = MMC_CS_DONTCARE;
+       }
        host->ios.power_mode = MMC_POWER_OFF;
        host->ios.bus_width = MMC_BUS_WIDTH_1;
        host->ios.timing = MMC_TIMING_LEGACY;
@@ -511,7 +563,7 @@
        BUG_ON(!host);
        BUG_ON(!ops);
 
-       BUG_ON(!host->claimed);
+       WARN_ON(!host->claimed);
 
        spin_lock_irqsave(&host->lock, flags);
 
@@ -535,8 +587,8 @@
 
        BUG_ON(!host);
 
-       BUG_ON(!host->claimed);
-       BUG_ON(!host->bus_ops);
+       WARN_ON(!host->claimed);
+       WARN_ON(!host->bus_ops);
 
        spin_lock_irqsave(&host->lock, flags);
 
@@ -564,7 +616,7 @@
 #ifdef CONFIG_MMC_DEBUG
        unsigned long flags;
        spin_lock_irqsave(&host->lock, flags);
-       BUG_ON(host->removed);
+       WARN_ON(host->removed);
        spin_unlock_irqrestore(&host->lock, flags);
 #endif
 
@@ -597,24 +649,38 @@
 
                mmc_send_if_cond(host, host->ocr_avail);
 
+               /*
+                * First we search for SDIO...
+                */
+               err = mmc_send_io_op_cond(host, 0, &ocr);
+               if (!err) {
+                       if (mmc_attach_sdio(host, ocr))
+                               mmc_power_off(host);
+                       return;
+               }
+
+               /*
+                * ...then normal SD...
+                */
                err = mmc_send_app_op_cond(host, 0, &ocr);
-               if (err == MMC_ERR_NONE) {
+               if (!err) {
                        if (mmc_attach_sd(host, ocr))
                                mmc_power_off(host);
-               } else {
-                       /*
-                        * If we fail to detect any SD cards then try
-                        * searching for MMC cards.
-                        */
-                       err = mmc_send_op_cond(host, 0, &ocr);
-                       if (err == MMC_ERR_NONE) {
-                               if (mmc_attach_mmc(host, ocr))
-                                       mmc_power_off(host);
-                       } else {
+                       return;
+               }
+
+               /*
+                * ...and finally MMC.
+                */
+               err = mmc_send_op_cond(host, 0, &ocr);
+               if (!err) {
+                       if (mmc_attach_mmc(host, ocr))
                                mmc_power_off(host);
-                               mmc_release_host(host);
-                       }
+                       return;
                }
+
+               mmc_release_host(host);
+               mmc_power_off(host);
        } else {
                if (host->bus_ops->detect && !host->bus_dead)
                        host->bus_ops->detect(host);
@@ -725,22 +791,38 @@
                return -ENOMEM;
 
        ret = mmc_register_bus();
-       if (ret == 0) {
-               ret = mmc_register_host_class();
-               if (ret)
-                       mmc_unregister_bus();
-       }
+       if (ret)
+               goto destroy_workqueue;
+
+       ret = mmc_register_host_class();
+       if (ret)
+               goto unregister_bus;
+
+       ret = sdio_register_bus();
+       if (ret)
+               goto unregister_host_class;
+
+       return 0;
+
+unregister_host_class:
+       mmc_unregister_host_class();
+unregister_bus:
+       mmc_unregister_bus();
+destroy_workqueue:
+       destroy_workqueue(workqueue);
+
        return ret;
 }
 
 static void __exit mmc_exit(void)
 {
+       sdio_unregister_bus();
        mmc_unregister_host_class();
        mmc_unregister_bus();
        destroy_workqueue(workqueue);
 }
 
-module_init(mmc_init);
+subsys_initcall(mmc_init);
 module_exit(mmc_exit);
 
 MODULE_LICENSE("GPL");
--- a/drivers/mmc/core/core.h
+++ b/drivers/mmc/core/core.h
@@ -48,5 +48,7 @@
 void mmc_start_host(struct mmc_host *host);
 void mmc_stop_host(struct mmc_host *host);
 
+extern int use_spi_crc;
+
 #endif
 
--- a/drivers/mmc/core/host.c
+++ b/drivers/mmc/core/host.c
@@ -15,6 +15,7 @@
 #include <linux/err.h>
 #include <linux/idr.h>
 #include <linux/pagemap.h>
+#include <linux/leds.h>
 
 #include <linux/mmc/host.h>
 
@@ -100,6 +101,9 @@
 {
        int err;
 
+       WARN_ON((host->caps & MMC_CAP_SDIO_IRQ) &&
+               !host->ops->enable_sdio_irq);
+
        if (!idr_pre_get(&mmc_host_idr, GFP_KERNEL))
                return -ENOMEM;
 
@@ -112,6 +116,8 @@
        snprintf(host->class_dev.bus_id, BUS_ID_SIZE,
                 "mmc%d", host->index);
 
+       led_trigger_register_simple(host->class_dev.bus_id, &host->led);
+
        err = device_add(&host->class_dev);
        if (err)
                return err;
@@ -137,6 +143,8 @@
 
        device_del(&host->class_dev);
 
+       led_trigger_unregister_simple(host->led);
+
        spin_lock(&mmc_host_lock);
        idr_remove(&mmc_host_idr, host->index);
        spin_unlock(&mmc_host_lock);
--- a/drivers/mmc/core/mmc.c
+++ b/drivers/mmc/core/mmc.c
@@ -161,13 +161,12 @@
 {
        int err;
        u8 *ext_csd;
+       unsigned int ext_csd_struct;
 
        BUG_ON(!card);
 
-       err = MMC_ERR_FAILED;
-
        if (card->csd.mmca_vsn < CSD_SPEC_VER_4)
-               return MMC_ERR_NONE;
+               return 0;
 
        /*
         * As the ext_csd is so large and mostly unused, we don't store the
@@ -176,13 +175,19 @@
        ext_csd = kmalloc(512, GFP_KERNEL);
        if (!ext_csd) {
                printk(KERN_ERR "%s: could not allocate a buffer to "
-                       "receive the ext_csd. mmc v4 cards will be "
-                       "treated as v3.\n", mmc_hostname(card->host));
-               return MMC_ERR_FAILED;
+                       "receive the ext_csd.\n", mmc_hostname(card->host));
+               return -ENOMEM;
        }
 
        err = mmc_send_ext_csd(card, ext_csd);
-       if (err != MMC_ERR_NONE) {
+       if (err) {
+               /*
+                * We all hosts that cannot perform the command
+                * to fail more gracefully
+                */
+               if (err != -EINVAL)
+                       goto out;
+
                /*
                 * High capacity cards should have this "magic" size
                 * stored in their CSD.
@@ -197,18 +202,30 @@
                                "EXT_CSD, performance might "
                                "suffer.\n",
                                mmc_hostname(card->host));
-                       err = MMC_ERR_NONE;
+                       err = 0;
                }
+
                goto out;
        }
 
-       card->ext_csd.sectors =
-               ext_csd[EXT_CSD_SEC_CNT + 0] << 0 |
-               ext_csd[EXT_CSD_SEC_CNT + 1] << 8 |
-               ext_csd[EXT_CSD_SEC_CNT + 2] << 16 |
-               ext_csd[EXT_CSD_SEC_CNT + 3] << 24;
-       if (card->ext_csd.sectors)
-               mmc_card_set_blockaddr(card);
+       ext_csd_struct = ext_csd[EXT_CSD_REV];
+       if (ext_csd_struct > 2) {
+               printk(KERN_ERR "%s: unrecognised EXT_CSD structure "
+                       "version %d\n", mmc_hostname(card->host),
+                       ext_csd_struct);
+               err = -EINVAL;
+               goto out;
+       }
+
+       if (ext_csd_struct >= 2) {
+               card->ext_csd.sectors =
+                       ext_csd[EXT_CSD_SEC_CNT + 0] << 0 |
+                       ext_csd[EXT_CSD_SEC_CNT + 1] << 8 |
+                       ext_csd[EXT_CSD_SEC_CNT + 2] << 16 |
+                       ext_csd[EXT_CSD_SEC_CNT + 3] << 24;
+               if (card->ext_csd.sectors)
+                       mmc_card_set_blockaddr(card);
+       }
 
        switch (ext_csd[EXT_CSD_CARD_TYPE]) {
        case EXT_CSD_CARD_TYPE_52 | EXT_CSD_CARD_TYPE_26:
@@ -246,7 +263,7 @@
        unsigned int max_dtr;
 
        BUG_ON(!host);
-       BUG_ON(!host->claimed);
+       WARN_ON(!host->claimed);
 
        /*
         * Since we're changing the OCR value, we seem to
@@ -258,19 +275,33 @@
 
        /* The extra bit indicates that we support high capacity */
        err = mmc_send_op_cond(host, ocr | (1 << 30), NULL);
-       if (err != MMC_ERR_NONE)
+       if (err)
                goto err;
 
        /*
+        * For SPI, enable CRC as appropriate.
+        */
+       if (mmc_host_is_spi(host)) {
+               err = mmc_spi_set_crc(host, use_spi_crc);
+               if (err)
+                       goto err;
+       }
+
+       /*
         * Fetch CID from card.
         */
-       err = mmc_all_send_cid(host, cid);
-       if (err != MMC_ERR_NONE)
+       if (mmc_host_is_spi(host))
+               err = mmc_send_cid(host, cid);
+       else
+               err = mmc_all_send_cid(host, cid);
+       if (err)
                goto err;
 
        if (oldcard) {
-               if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0)
+               if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) {
+                       err = -ENOENT;
                        goto err;
+               }
 
                card = oldcard;
        } else {
@@ -278,8 +309,10 @@
                 * Allocate card structure.
                 */
                card = mmc_alloc_card(host);
-               if (IS_ERR(card))
+               if (IS_ERR(card)) {
+                       err = PTR_ERR(card);
                        goto err;
+               }
 
                card->type = MMC_TYPE_MMC;
                card->rca = 1;
@@ -287,43 +320,47 @@
        }
 
        /*
-        * Set card RCA.
+        * For native busses:  set card RCA and quit open drain mode.
         */
-       err = mmc_set_relative_addr(card);
-       if (err != MMC_ERR_NONE)
-               goto free_card;
+       if (!mmc_host_is_spi(host)) {
+               err = mmc_set_relative_addr(card);
+               if (err)
+                       goto free_card;
 
-       mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
+               mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
+       }
 
        if (!oldcard) {
                /*
                 * Fetch CSD from card.
                 */
                err = mmc_send_csd(card, card->raw_csd);
-               if (err != MMC_ERR_NONE)
+               if (err)
                        goto free_card;
 
                err = mmc_decode_csd(card);
-               if (err < 0)
+               if (err)
                        goto free_card;
                err = mmc_decode_cid(card);
-               if (err < 0)
+               if (err)
                        goto free_card;
        }
 
        /*
         * Select card, as all following commands rely on that.
         */
-       err = mmc_select_card(card);
-       if (err != MMC_ERR_NONE)
-               goto free_card;
+       if (!mmc_host_is_spi(host)) {
+               err = mmc_select_card(card);
+               if (err)
+                       goto free_card;
+       }
 
        if (!oldcard) {
                /*
-                * Fetch and process extened CSD.
+                * Fetch and process extended CSD.
                 */
                err = mmc_read_ext_csd(card);
-               if (err != MMC_ERR_NONE)
+               if (err)
                        goto free_card;
        }
 
@@ -334,7 +371,7 @@
                (host->caps & MMC_CAP_MMC_HIGHSPEED)) {
                err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
                        EXT_CSD_HS_TIMING, 1);
-               if (err != MMC_ERR_NONE)
+               if (err)
                        goto free_card;
 
                mmc_card_set_highspeed(card);
@@ -363,7 +400,7 @@
                (host->caps & MMC_CAP_4_BIT_DATA)) {
                err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
                        EXT_CSD_BUS_WIDTH, EXT_CSD_BUS_WIDTH_4);
-               if (err != MMC_ERR_NONE)
+               if (err)
                        goto free_card;
 
                mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
@@ -372,14 +409,14 @@
        if (!oldcard)
                host->card = card;
 
-       return MMC_ERR_NONE;
+       return 0;
 
 free_card:
        if (!oldcard)
                mmc_remove_card(card);
 err:
 
-       return MMC_ERR_FAILED;
+       return err;
 }
 
 /*
@@ -413,7 +450,7 @@
 
        mmc_release_host(host);
 
-       if (err != MMC_ERR_NONE) {
+       if (err) {
                mmc_remove(host);
 
                mmc_claim_host(host);
@@ -480,7 +517,8 @@
        BUG_ON(!host->card);
 
        mmc_claim_host(host);
-       mmc_deselect_cards(host);
+       if (!mmc_host_is_spi(host))
+               mmc_deselect_cards(host);
        host->card->state &= ~MMC_STATE_HIGHSPEED;
        mmc_release_host(host);
 }
@@ -502,7 +540,7 @@
        err = mmc_init_card(host, host->ocr, host->card);
        mmc_release_host(host);
 
-       if (err != MMC_ERR_NONE) {
+       if (err) {
                mmc_remove(host);
 
                mmc_claim_host(host);
@@ -536,11 +574,20 @@
        int err;
 
        BUG_ON(!host);
-       BUG_ON(!host->claimed);
+       WARN_ON(!host->claimed);
 
        mmc_attach_bus(host, &mmc_ops);
 
        /*
+        * We need to get OCR a different way for SPI.
+        */
+       if (mmc_host_is_spi(host)) {
+               err = mmc_spi_read_ocr(host, 1, &ocr);
+               if (err)
+                       goto err;
+       }
+
+       /*
         * Sanity check the voltages that the card claims to
         * support.
         */
@@ -565,7 +612,7 @@
         * Detect and init the card.
         */
        err = mmc_init_card(host, host->ocr, NULL);
-       if (err != MMC_ERR_NONE)
+       if (err)
                goto err;
 
        mmc_release_host(host);
@@ -587,6 +634,6 @@
        printk(KERN_ERR "%s: error %d whilst initialising MMC card\n",
                mmc_hostname(host), err);
 
-       return 0;
+       return err;
 }
 
--- a/drivers/mmc/core/mmc_ops.c
+++ b/drivers/mmc/core/mmc_ops.c
@@ -10,7 +10,6 @@
  */
 
 #include <linux/types.h>
-#include <asm/scatterlist.h>
 #include <linux/scatterlist.h>
 
 #include <linux/mmc/host.h>
@@ -40,10 +39,10 @@
        }
 
        err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
-       if (err != MMC_ERR_NONE)
+       if (err)
                return err;
 
-       return MMC_ERR_NONE;
+       return 0;
 }
 
 int mmc_select_card(struct mmc_card *card)
@@ -63,23 +62,36 @@
        int err;
        struct mmc_command cmd;
 
-       mmc_set_chip_select(host, MMC_CS_HIGH);
-
-       mmc_delay(1);
+       /*
+        * Non-SPI hosts need to prevent chipselect going active during
+        * GO_IDLE; that would put chips into SPI mode.  Remind them of
+        * that in case of hardware that won't pull up DAT3/nCS otherwise.
+        *
+        * SPI hosts ignore ios.chip_select; it's managed according to
+        * rules that must accomodate non-MMC slaves which this layer
+        * won't even know about.
+        */
+       if (!mmc_host_is_spi(host)) {
+               mmc_set_chip_select(host, MMC_CS_HIGH);
+               mmc_delay(1);
+       }
 
        memset(&cmd, 0, sizeof(struct mmc_command));
 
        cmd.opcode = MMC_GO_IDLE_STATE;
        cmd.arg = 0;
-       cmd.flags = MMC_RSP_NONE | MMC_CMD_BC;
+       cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_NONE | MMC_CMD_BC;
 
        err = mmc_wait_for_cmd(host, &cmd, 0);
 
        mmc_delay(1);
 
-       mmc_set_chip_select(host, MMC_CS_DONTCARE);
+       if (!mmc_host_is_spi(host)) {
+               mmc_set_chip_select(host, MMC_CS_DONTCARE);
+               mmc_delay(1);
+       }
 
-       mmc_delay(1);
+       host->use_spi_crc = 0;
 
        return err;
 }
@@ -94,23 +106,33 @@
        memset(&cmd, 0, sizeof(struct mmc_command));
 
        cmd.opcode = MMC_SEND_OP_COND;
-       cmd.arg = ocr;
-       cmd.flags = MMC_RSP_R3 | MMC_CMD_BCR;
+       cmd.arg = mmc_host_is_spi(host) ? 0 : ocr;
+       cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R3 | MMC_CMD_BCR;
 
        for (i = 100; i; i--) {
                err = mmc_wait_for_cmd(host, &cmd, 0);
-               if (err != MMC_ERR_NONE)
+               if (err)
                        break;
 
-               if (cmd.resp[0] & MMC_CARD_BUSY || ocr == 0)
+               /* if we're just probing, do a single pass */
+               if (ocr == 0)
                        break;
 
-               err = MMC_ERR_TIMEOUT;
+               /* otherwise wait until reset completes */
+               if (mmc_host_is_spi(host)) {
+                       if (!(cmd.resp[0] & R1_SPI_IDLE))
+                               break;
+               } else {
+                       if (cmd.resp[0] & MMC_CARD_BUSY)
+                               break;
+               }
+
+               err = -ETIMEDOUT;
 
                mmc_delay(10);
        }
 
-       if (rocr)
+       if (rocr && !mmc_host_is_spi(host))
                *rocr = cmd.resp[0];
 
        return err;
@@ -131,12 +153,12 @@
        cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR;
 
        err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
-       if (err != MMC_ERR_NONE)
+       if (err)
                return err;
 
        memcpy(cid, cmd.resp, sizeof(u32) * 4);
 
-       return MMC_ERR_NONE;
+       return 0;
 }
 
 int mmc_set_relative_addr(struct mmc_card *card)
@@ -154,46 +176,52 @@
        cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
 
        err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
-       if (err != MMC_ERR_NONE)
+       if (err)
                return err;
 
-       return MMC_ERR_NONE;
+       return 0;
 }
 
-int mmc_send_csd(struct mmc_card *card, u32 *csd)
+static int
+mmc_send_cxd_native(struct mmc_host *host, u32 arg, u32 *cxd, int opcode)
 {
        int err;
        struct mmc_command cmd;
 
-       BUG_ON(!card);
-       BUG_ON(!card->host);
-       BUG_ON(!csd);
+       BUG_ON(!host);
+       BUG_ON(!cxd);
 
        memset(&cmd, 0, sizeof(struct mmc_command));
 
-       cmd.opcode = MMC_SEND_CSD;
-       cmd.arg = card->rca << 16;
+       cmd.opcode = opcode;
+       cmd.arg = arg;
        cmd.flags = MMC_RSP_R2 | MMC_CMD_AC;
 
-       err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
-       if (err != MMC_ERR_NONE)
+       err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
+       if (err)
                return err;
 
-       memcpy(csd, cmd.resp, sizeof(u32) * 4);
+       memcpy(cxd, cmd.resp, sizeof(u32) * 4);
 
-       return MMC_ERR_NONE;
+       return 0;
 }
 
-int mmc_send_ext_csd(struct mmc_card *card, u8 *ext_csd)
+static int
+mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host,
+               u32 opcode, void *buf, unsigned len)
 {
        struct mmc_request mrq;
        struct mmc_command cmd;
        struct mmc_data data;
        struct scatterlist sg;
+       void *data_buf;
 
-       BUG_ON(!card);
-       BUG_ON(!card->host);
-       BUG_ON(!ext_csd);
+       /* dma onto stack is unsafe/nonportable, but callers to this
+        * routine normally provide temporary on-stack buffers ...
+        */
+       data_buf = kmalloc(len, GFP_KERNEL);
+       if (data_buf == NULL)
+               return -ENOMEM;
 
        memset(&mrq, 0, sizeof(struct mmc_request));
        memset(&cmd, 0, sizeof(struct mmc_command));
@@ -202,28 +230,117 @@
        mrq.cmd = &cmd;
        mrq.data = &data;
 
-       cmd.opcode = MMC_SEND_EXT_CSD;
+       cmd.opcode = opcode;
        cmd.arg = 0;
-       cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
 
-       data.blksz = 512;
+       /* NOTE HACK:  the MMC_RSP_SPI_R1 is always correct here, but we
+        * rely on callers to never use this with "native" calls for reading
+        * CSD or CID.  Native versions of those commands use the R2 type,
+        * not R1 plus a data block.
+        */
+       cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
+
+       data.blksz = len;
        data.blocks = 1;
        data.flags = MMC_DATA_READ;
        data.sg = &sg;
        data.sg_len = 1;
 
-       sg_init_one(&sg, ext_csd, 512);
+       sg_init_one(&sg, data_buf, len);
+
+       if (card)
+               mmc_set_data_timeout(&data, card);
 
-       mmc_set_data_timeout(&data, card, 0);
+       mmc_wait_for_req(host, &mrq);
 
-       mmc_wait_for_req(card->host, &mrq);
+       memcpy(buf, data_buf, len);
+       kfree(data_buf);
 
-       if (cmd.error != MMC_ERR_NONE)
+       if (cmd.error)
                return cmd.error;
-       if (data.error != MMC_ERR_NONE)
+       if (data.error)
                return data.error;
 
-       return MMC_ERR_NONE;
+       return 0;
+}
+
+int mmc_send_csd(struct mmc_card *card, u32 *csd)
+{
+       int ret, i;
+
+       if (!mmc_host_is_spi(card->host))
+               return mmc_send_cxd_native(card->host, card->rca << 16,
+                               csd, MMC_SEND_CSD);
+
+       ret = mmc_send_cxd_data(card, card->host, MMC_SEND_CSD, csd, 16);
+       if (ret)
+               return ret;
+
+       for (i = 0;i < 4;i++)
+               csd[i] = be32_to_cpu(csd[i]);
+
+       return 0;
+}
+
+int mmc_send_cid(struct mmc_host *host, u32 *cid)
+{
+       int ret, i;
+
+       if (!mmc_host_is_spi(host)) {
+               if (!host->card)
+                       return -EINVAL;
+               return mmc_send_cxd_native(host, host->card->rca << 16,
+                               cid, MMC_SEND_CID);
+       }
+
+       ret = mmc_send_cxd_data(NULL, host, MMC_SEND_CID, cid, 16);
+       if (ret)
+               return ret;
+
+       for (i = 0;i < 4;i++)
+               cid[i] = be32_to_cpu(cid[i]);
+
+       return 0;
+}
+
+int mmc_send_ext_csd(struct mmc_card *card, u8 *ext_csd)
+{
+       return mmc_send_cxd_data(card, card->host, MMC_SEND_EXT_CSD,
+                       ext_csd, 512);
+}
+
+int mmc_spi_read_ocr(struct mmc_host *host, int highcap, u32 *ocrp)
+{
+       struct mmc_command cmd;
+       int err;
+
+       memset(&cmd, 0, sizeof(struct mmc_command));
+
+       cmd.opcode = MMC_SPI_READ_OCR;
+       cmd.arg = highcap ? (1 << 30) : 0;
+       cmd.flags = MMC_RSP_SPI_R3;
+
+       err = mmc_wait_for_cmd(host, &cmd, 0);
+
+       *ocrp = cmd.resp[1];
+       return err;
+}
+
+int mmc_spi_set_crc(struct mmc_host *host, int use_crc)
+{
+       struct mmc_command cmd;
+       int err;
+
+       memset(&cmd, 0, sizeof(struct mmc_command));
+
+       cmd.opcode = MMC_SPI_CRC_ON_OFF;
+       cmd.flags = MMC_RSP_SPI_R1;
+       cmd.arg = use_crc;
+
+       err = mmc_wait_for_cmd(host, &cmd, 0);
+       if (!err)
+               host->use_spi_crc = use_crc;
+       return err;
 }
 
 int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value)
@@ -241,13 +358,13 @@
                  (index << 16) |
                  (value << 8) |
                  set;
-       cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;
+       cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
 
        err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
-       if (err != MMC_ERR_NONE)
+       if (err)
                return err;
 
-       return MMC_ERR_NONE;
+       return 0;
 }
 
 int mmc_send_status(struct mmc_card *card, u32 *status)
@@ -261,16 +378,20 @@
        memset(&cmd, 0, sizeof(struct mmc_command));
 
        cmd.opcode = MMC_SEND_STATUS;
-       cmd.arg = card->rca << 16;
-       cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
+       if (!mmc_host_is_spi(card->host))
+               cmd.arg = card->rca << 16;
+       cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC;
 
        err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
-       if (err != MMC_ERR_NONE)
+       if (err)
                return err;
 
+       /* NOTE: callers are required to understand the difference
+        * between "native" and SPI format status words!
+        */
        if (status)
                *status = cmd.resp[0];
 
-       return MMC_ERR_NONE;
+       return 0;
 }
 
--- a/drivers/mmc/core/mmc_ops.h
+++ b/drivers/mmc/core/mmc_ops.h
@@ -22,6 +22,9 @@
 int mmc_send_ext_csd(struct mmc_card *card, u8 *ext_csd);
 int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value);
 int mmc_send_status(struct mmc_card *card, u32 *status);
+int mmc_send_cid(struct mmc_host *host, u32 *cid);
+int mmc_spi_read_ocr(struct mmc_host *host, int highcap, u32 *ocrp);
+int mmc_spi_set_crc(struct mmc_host *host, int use_crc);
 
 #endif
 
--- a/drivers/mmc/core/sd.c
+++ b/drivers/mmc/core/sd.c
@@ -166,8 +166,6 @@
        unsigned int scr_struct;
        u32 resp[4];
 
-       BUG_ON(!mmc_card_sd(card));
-
        resp[3] = card->raw_scr[1];
        resp[2] = card->raw_scr[0];
 
@@ -193,30 +191,38 @@
        u8 *status;
 
        if (card->scr.sda_vsn < SCR_SPEC_VER_1)
-               return MMC_ERR_NONE;
+               return 0;
 
        if (!(card->csd.cmdclass & CCC_SWITCH)) {
                printk(KERN_WARNING "%s: card lacks mandatory switch "
                        "function, performance might suffer.\n",
                        mmc_hostname(card->host));
-               return MMC_ERR_NONE;
+               return 0;
        }
 
-       err = MMC_ERR_FAILED;
+       err = -EIO;
 
        status = kmalloc(64, GFP_KERNEL);
        if (!status) {
                printk(KERN_ERR "%s: could not allocate a buffer for "
                        "switch capabilities.\n", mmc_hostname(card->host));
-               return err;
+               return -ENOMEM;
        }
 
        err = mmc_sd_switch(card, 0, 0, 1, status);
-       if (err != MMC_ERR_NONE) {
+       if (err) {
+               /*
+                * We all hosts that cannot perform the command
+                * to fail more gracefully
+                */
+               if (err != -EINVAL)
+                       goto out;
+
                printk(KERN_WARNING "%s: problem reading switch "
                        "capabilities, performance might suffer.\n",
                        mmc_hostname(card->host));
-               err = MMC_ERR_NONE;
+               err = 0;
+
                goto out;
        }
 
@@ -238,28 +244,28 @@
        u8 *status;
 
        if (card->scr.sda_vsn < SCR_SPEC_VER_1)
-               return MMC_ERR_NONE;
+               return 0;
 
        if (!(card->csd.cmdclass & CCC_SWITCH))
-               return MMC_ERR_NONE;
+               return 0;
 
        if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED))
-               return MMC_ERR_NONE;
+               return 0;
 
        if (card->sw_caps.hs_max_dtr == 0)
-               return MMC_ERR_NONE;
+               return 0;
 
-       err = MMC_ERR_FAILED;
+       err = -EIO;
 
        status = kmalloc(64, GFP_KERNEL);
        if (!status) {
                printk(KERN_ERR "%s: could not allocate a buffer for "
                        "switch capabilities.\n", mmc_hostname(card->host));
-               return err;
+               return -ENOMEM;
        }
 
        err = mmc_sd_switch(card, 1, 0, 1, status);
-       if (err != MMC_ERR_NONE)
+       if (err)
                goto out;
 
        if ((status[16] & 0xF) != 1) {
@@ -292,7 +298,7 @@
        unsigned int max_dtr;
 
        BUG_ON(!host);
-       BUG_ON(!host->claimed);
+       WARN_ON(!host->claimed);
 
        /*
         * Since we're changing the OCR value, we seem to
@@ -309,23 +315,37 @@
         * block-addressed SDHC cards.
         */
        err = mmc_send_if_cond(host, ocr);
-       if (err == MMC_ERR_NONE)
+       if (!err)
                ocr |= 1 << 30;
 
        err = mmc_send_app_op_cond(host, ocr, NULL);
-       if (err != MMC_ERR_NONE)
+       if (err)
                goto err;
 
        /*
+        * For SPI, enable CRC as appropriate.
+        */
+       if (mmc_host_is_spi(host)) {
+               err = mmc_spi_set_crc(host, use_spi_crc);
+               if (err)
+                       goto err;
+       }
+
+       /*
         * Fetch CID from card.
         */
-       err = mmc_all_send_cid(host, cid);
-       if (err != MMC_ERR_NONE)
+       if (mmc_host_is_spi(host))
+               err = mmc_send_cid(host, cid);
+       else
+               err = mmc_all_send_cid(host, cid);
+       if (err)
                goto err;
 
        if (oldcard) {
-               if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0)
+               if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) {
+                       err = -ENOENT;
                        goto err;
+               }
 
                card = oldcard;
        } else {
@@ -333,32 +353,36 @@
                 * Allocate card structure.
                 */
                card = mmc_alloc_card(host);
-               if (IS_ERR(card))
+               if (IS_ERR(card)) {
+                       err = PTR_ERR(card);
                        goto err;
+               }
 
                card->type = MMC_TYPE_SD;
                memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
        }
 
        /*
-        * Set card RCA.
+        * For native busses:  get card RCA and quit open drain mode.
         */
-       err = mmc_send_relative_addr(host, &card->rca);
-       if (err != MMC_ERR_NONE)
-               goto free_card;
+       if (!mmc_host_is_spi(host)) {
+               err = mmc_send_relative_addr(host, &card->rca);
+               if (err)
+                       goto free_card;
 
-       mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
+               mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
+       }
 
        if (!oldcard) {
                /*
                 * Fetch CSD from card.
                 */
                err = mmc_send_csd(card, card->raw_csd);
-               if (err != MMC_ERR_NONE)
+               if (err)
                        goto free_card;
 
                err = mmc_decode_csd(card);
-               if (err < 0)
+               if (err)
                        goto free_card;
 
                mmc_decode_cid(card);
@@ -367,16 +391,18 @@
        /*
         * Select card, as all following commands rely on that.
         */
-       err = mmc_select_card(card);
-       if (err != MMC_ERR_NONE)
-               goto free_card;
+       if (!mmc_host_is_spi(host)) {
+               err = mmc_select_card(card);
+               if (err)
+                       goto free_card;
+       }
 
        if (!oldcard) {
                /*
                 * Fetch SCR from card.
                 */
                err = mmc_app_send_scr(card, card->raw_scr);
-               if (err != MMC_ERR_NONE)
+               if (err)
                        goto free_card;
 
                err = mmc_decode_scr(card);
@@ -387,7 +413,7 @@
                 * Fetch switch information from card.
                 */
                err = mmc_read_switch(card);
-               if (err != MMC_ERR_NONE)
+               if (err)
                        goto free_card;
        }
 
@@ -395,7 +421,7 @@
         * Attempt to change to high-speed (if supported)
         */
        err = mmc_switch_hs(card);
-       if (err != MMC_ERR_NONE)
+       if (err)
                goto free_card;
 
        /*
@@ -418,7 +444,7 @@
        if ((host->caps & MMC_CAP_4_BIT_DATA) &&
                (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
                err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
-               if (err != MMC_ERR_NONE)
+               if (err)
                        goto free_card;
 
                mmc_set_bus_width(host, MMC_BUS_WIDTH_4);
@@ -442,14 +468,14 @@
        if (!oldcard)
                host->card = card;
 
-       return MMC_ERR_NONE;
+       return 0;
 
 free_card:
        if (!oldcard)
                mmc_remove_card(card);
 err:
 
-       return MMC_ERR_FAILED;
+       return err;
 }
 
 /*
@@ -483,7 +509,7 @@
 
        mmc_release_host(host);
 
-       if (err != MMC_ERR_NONE) {
+       if (err) {
                mmc_sd_remove(host);
 
                mmc_claim_host(host);
@@ -552,7 +578,8 @@
        BUG_ON(!host->card);
 
        mmc_claim_host(host);
-       mmc_deselect_cards(host);
+       if (!mmc_host_is_spi(host))
+               mmc_deselect_cards(host);
        host->card->state &= ~MMC_STATE_HIGHSPEED;
        mmc_release_host(host);
 }
@@ -574,7 +601,7 @@
        err = mmc_sd_init_card(host, host->ocr, host->card);
        mmc_release_host(host);
 
-       if (err != MMC_ERR_NONE) {
+       if (err) {
                mmc_sd_remove(host);
 
                mmc_claim_host(host);
@@ -608,11 +635,22 @@
        int err;
 
        BUG_ON(!host);
-       BUG_ON(!host->claimed);
+       WARN_ON(!host->claimed);
 
        mmc_attach_bus(host, &mmc_sd_ops);
 
        /*
+        * We need to get OCR a different way for SPI.
+        */
+       if (mmc_host_is_spi(host)) {
+               mmc_go_idle(host);
+
+               err = mmc_spi_read_ocr(host, 0, &ocr);
+               if (err)
+                       goto err;
+       }
+
+       /*
         * Sanity check the voltages that the card claims to
         * support.
         */
@@ -644,7 +682,7 @@
         * Detect and init the card.
         */
        err = mmc_sd_init_card(host, host->ocr, NULL);
-       if (err != MMC_ERR_NONE)
+       if (err)
                goto err;
 
        mmc_release_host(host);
@@ -666,6 +704,6 @@
        printk(KERN_ERR "%s: error %d whilst initialising SD card\n",
                mmc_hostname(host), err);
 
-       return 0;
+       return err;
 }
 
--- a/drivers/mmc/core/sd_ops.c
+++ b/drivers/mmc/core/sd_ops.c
@@ -10,7 +10,6 @@
  */
 
 #include <linux/types.h>
-#include <asm/scatterlist.h>
 #include <linux/scatterlist.h>
 
 #include <linux/mmc/host.h>
@@ -33,21 +32,21 @@
 
        if (card) {
                cmd.arg = card->rca << 16;
-               cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
+               cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
        } else {
                cmd.arg = 0;
-               cmd.flags = MMC_RSP_R1 | MMC_CMD_BCR;
+               cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_BCR;
        }
 
        err = mmc_wait_for_cmd(host, &cmd, 0);
-       if (err != MMC_ERR_NONE)
+       if (err)
                return err;
 
        /* Check that card supported application commands */
-       if (!(cmd.resp[0] & R1_APP_CMD))
-               return MMC_ERR_FAILED;
+       if (!mmc_host_is_spi(host) && !(cmd.resp[0] & R1_APP_CMD))
+               return -EOPNOTSUPP;
 
-       return MMC_ERR_NONE;
+       return 0;
 }
 
 /**
@@ -73,7 +72,7 @@
        BUG_ON(!cmd);
        BUG_ON(retries < 0);
 
-       err = MMC_ERR_INVALID;
+       err = -EIO;
 
        /*
         * We have to resend MMC_APP_CMD for each attempt so
@@ -83,8 +82,14 @@
                memset(&mrq, 0, sizeof(struct mmc_request));
 
                err = mmc_app_cmd(host, card);
-               if (err != MMC_ERR_NONE)
+               if (err) {
+                       /* no point in retrying; no APP commands allowed */
+                       if (mmc_host_is_spi(host)) {
+                               if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
+                                       break;
+                       }
                        continue;
+               }
 
                memset(&mrq, 0, sizeof(struct mmc_request));
 
@@ -97,8 +102,14 @@
                mmc_wait_for_req(host, &mrq);
 
                err = cmd->error;
-               if (cmd->error == MMC_ERR_NONE)
+               if (!cmd->error)
                        break;
+
+               /* no point in retrying illegal APP commands */
+               if (mmc_host_is_spi(host)) {
+                       if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
+                               break;
+               }
        }
 
        return err;
@@ -127,14 +138,14 @@
                cmd.arg = SD_BUS_WIDTH_4;
                break;
        default:
-               return MMC_ERR_INVALID;
+               return -EINVAL;
        }
 
        err = mmc_wait_for_app_cmd(card->host, card, &cmd, MMC_CMD_RETRIES);
-       if (err != MMC_ERR_NONE)
+       if (err)
                return err;
 
-       return MMC_ERR_NONE;
+       return 0;
 }
 
 int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
@@ -147,23 +158,36 @@
        memset(&cmd, 0, sizeof(struct mmc_command));
 
        cmd.opcode = SD_APP_OP_COND;
-       cmd.arg = ocr;
-       cmd.flags = MMC_RSP_R3 | MMC_CMD_BCR;
+       if (mmc_host_is_spi(host))
+               cmd.arg = ocr & (1 << 30); /* SPI only defines one bit */
+       else
+               cmd.arg = ocr;
+       cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R3 | MMC_CMD_BCR;
 
        for (i = 100; i; i--) {
                err = mmc_wait_for_app_cmd(host, NULL, &cmd, MMC_CMD_RETRIES);
-               if (err != MMC_ERR_NONE)
+               if (err)
                        break;
 
-               if (cmd.resp[0] & MMC_CARD_BUSY || ocr == 0)
+               /* if we're just probing, do a single pass */
+               if (ocr == 0)
                        break;
 
-               err = MMC_ERR_TIMEOUT;
+               /* otherwise wait until reset completes */
+               if (mmc_host_is_spi(host)) {
+                       if (!(cmd.resp[0] & R1_SPI_IDLE))
+                               break;
+               } else {
+                       if (cmd.resp[0] & MMC_CARD_BUSY)
+                               break;
+               }
+
+               err = -ETIMEDOUT;
 
                mmc_delay(10);
        }
 
-       if (rocr)
+       if (rocr && !mmc_host_is_spi(host))
                *rocr = cmd.resp[0];
 
        return err;
@@ -174,6 +198,7 @@
        struct mmc_command cmd;
        int err;
        static const u8 test_pattern = 0xAA;
+       u8 result_pattern;
 
        /*
         * To support SD 2.0 cards, we must always invoke SD_SEND_IF_COND
@@ -182,16 +207,21 @@
         */
        cmd.opcode = SD_SEND_IF_COND;
        cmd.arg = ((ocr & 0xFF8000) != 0) << 8 | test_pattern;
-       cmd.flags = MMC_RSP_R7 | MMC_CMD_BCR;
+       cmd.flags = MMC_RSP_SPI_R7 | MMC_RSP_R7 | MMC_CMD_BCR;
 
        err = mmc_wait_for_cmd(host, &cmd, 0);
-       if (err != MMC_ERR_NONE)
+       if (err)
                return err;
 
-       if ((cmd.resp[0] & 0xFF) != test_pattern)
-               return MMC_ERR_FAILED;
+       if (mmc_host_is_spi(host))
+               result_pattern = cmd.resp[1] & 0xFF;
+       else
+               result_pattern = cmd.resp[0] & 0xFF;
+
+       if (result_pattern != test_pattern)
+               return -EIO;
 
-       return MMC_ERR_NONE;
+       return 0;
 }
 
 int mmc_send_relative_addr(struct mmc_host *host, unsigned int *rca)
@@ -209,12 +239,12 @@
        cmd.flags = MMC_RSP_R6 | MMC_CMD_BCR;
 
        err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
-       if (err != MMC_ERR_NONE)
+       if (err)
                return err;
 
        *rca = cmd.resp[0] >> 16;
 
-       return MMC_ERR_NONE;
+       return 0;
 }
 
 int mmc_app_send_scr(struct mmc_card *card, u32 *scr)
@@ -229,8 +259,10 @@
        BUG_ON(!card->host);
        BUG_ON(!scr);
 
+       /* NOTE: caller guarantees scr is heap-allocated */
+
        err = mmc_app_cmd(card->host, card);
-       if (err != MMC_ERR_NONE)
+       if (err)
                return err;
 
        memset(&mrq, 0, sizeof(struct mmc_request));
@@ -242,7 +274,7 @@
 
        cmd.opcode = SD_APP_SEND_SCR;
        cmd.arg = 0;
-       cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
+       cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
 
        data.blksz = 8;
        data.blocks = 1;
@@ -252,19 +284,19 @@
 
        sg_init_one(&sg, scr, 8);
 
-       mmc_set_data_timeout(&data, card, 0);
+       mmc_set_data_timeout(&data, card);
 
        mmc_wait_for_req(card->host, &mrq);
 
-       if (cmd.error != MMC_ERR_NONE)
+       if (cmd.error)
                return cmd.error;
-       if (data.error != MMC_ERR_NONE)
+       if (data.error)
                return data.error;
 
-       scr[0] = ntohl(scr[0]);
-       scr[1] = ntohl(scr[1]);
+       scr[0] = be32_to_cpu(scr[0]);
+       scr[1] = be32_to_cpu(scr[1]);
 
-       return MMC_ERR_NONE;
+       return 0;
 }
 
 int mmc_sd_switch(struct mmc_card *card, int mode, int group,
@@ -278,6 +310,8 @@
        BUG_ON(!card);
        BUG_ON(!card->host);
 
+       /* NOTE: caller guarantees resp is heap-allocated */
+
        mode = !!mode;
        value &= 0xF;
 
@@ -292,7 +326,7 @@
        cmd.arg = mode << 31 | 0x00FFFFFF;
        cmd.arg &= ~(0xF << (group * 4));
        cmd.arg |= value << (group * 4);
-       cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
+       cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
 
        data.blksz = 64;
        data.blocks = 1;
@@ -302,15 +336,15 @@
 
        sg_init_one(&sg, resp, 64);
 
-       mmc_set_data_timeout(&data, card, 0);
+       mmc_set_data_timeout(&data, card);
 
        mmc_wait_for_req(card->host, &mrq);
 
-       if (cmd.error != MMC_ERR_NONE)
+       if (cmd.error)
                return cmd.error;
-       if (data.error != MMC_ERR_NONE)
+       if (data.error)
                return data.error;
 
-       return MMC_ERR_NONE;
+       return 0;
 }
 
--- /dev/null
+++ b/drivers/mmc/core/sdio.c
@@ -0,0 +1,395 @@
+/*
+ *  linux/drivers/mmc/sdio.c
+ *
+ *  Copyright 2006-2007 Pierre Ossman
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at
+ * your option) any later version.
+ */
+
+#include <linux/err.h>
+
+#include <linux/mmc/host.h>
+#include <linux/mmc/card.h>
+#include <linux/mmc/sdio.h>
+#include <linux/mmc/sdio_func.h>
+
+#include "core.h"
+#include "bus.h"
+#include "sdio_bus.h"
+#include "mmc_ops.h"
+#include "sd_ops.h"
+#include "sdio_ops.h"
+#include "sdio_cis.h"
+
+static int sdio_read_fbr(struct sdio_func *func)
+{
+       int ret;
+       unsigned char data;
+
+       ret = mmc_io_rw_direct(func->card, 0, 0,
+               SDIO_FBR_BASE(func->num) + SDIO_FBR_STD_IF, 0, &data);
+       if (ret)
+               goto out;
+
+       data &= 0x0f;
+
+       if (data == 0x0f) {
+               ret = mmc_io_rw_direct(func->card, 0, 0,
+                       SDIO_FBR_BASE(func->num) + SDIO_FBR_STD_IF_EXT, 0, &data);
+               if (ret)
+                       goto out;
+       }
+
+       func->class = data;
+
+out:
+       return ret;
+}
+
+static int sdio_init_func(struct mmc_card *card, unsigned int fn)
+{
+       int ret;
+       struct sdio_func *func;
+
+       BUG_ON(fn > SDIO_MAX_FUNCS);
+
+       func = sdio_alloc_func(card);
+       if (IS_ERR(func))
+               return PTR_ERR(func);
+
+       func->num = fn;
+
+       ret = sdio_read_fbr(func);
+       if (ret)
+               goto fail;
+
+       ret = sdio_read_func_cis(func);
+       if (ret)
+               goto fail;
+
+       card->sdio_func[fn - 1] = func;
+
+       return 0;
+
+fail:
+       /*
+        * It is okay to remove the function here even though we hold
+        * the host lock as we haven't registered the device yet.
+        */
+       sdio_remove_func(func);
+       return ret;
+}
+
+static int sdio_read_cccr(struct mmc_card *card)
+{
+       int ret;
+       int cccr_vsn;
+       unsigned char data;
+
+       memset(&card->cccr, 0, sizeof(struct sdio_cccr));
+
+       ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_CCCR, 0, &data);
+       if (ret)
+               goto out;
+
+       cccr_vsn = data & 0x0f;
+
+       if (cccr_vsn > SDIO_CCCR_REV_1_20) {
+               printk(KERN_ERR "%s: unrecognised CCCR structure version %d\n",
+                       mmc_hostname(card->host), cccr_vsn);
+               return -EINVAL;
+       }
+
+       card->cccr.sdio_vsn = (data & 0xf0) >> 4;
+
+       ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_CAPS, 0, &data);
+       if (ret)
+               goto out;
+
+       if (data & SDIO_CCCR_CAP_SMB)
+               card->cccr.multi_block = 1;
+       if (data & SDIO_CCCR_CAP_LSC)
+               card->cccr.low_speed = 1;
+       if (data & SDIO_CCCR_CAP_4BLS)
+               card->cccr.wide_bus = 1;
+
+       if (cccr_vsn >= SDIO_CCCR_REV_1_10) {
+               ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_POWER, 0, &data);
+               if (ret)
+                       goto out;
+
+               if (data & SDIO_POWER_SMPC)
+                       card->cccr.high_power = 1;
+       }
+
+       if (cccr_vsn >= SDIO_CCCR_REV_1_20) {
+               ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_SPEED, 0, &data);
+               if (ret)
+                       goto out;
+
+               if (data & SDIO_SPEED_SHS)
+                       card->cccr.high_speed = 1;
+       }
+
+out:
+       return ret;
+}
+
+static int sdio_enable_wide(struct mmc_card *card)
+{
+       int ret;
+       u8 ctrl;
+
+       if (!(card->host->caps & MMC_CAP_4_BIT_DATA))
+               return 0;
+
+       if (card->cccr.low_speed && !card->cccr.wide_bus)
+               return 0;
+
+       ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl);
+       if (ret)
+               return ret;
+
+       ctrl |= SDIO_BUS_WIDTH_4BIT;
+
+       ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL);
+       if (ret)
+               return ret;
+
+       mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
+
+       return 0;
+}
+
+/*
+ * Host is being removed. Free up the current card.
+ */
+static void mmc_sdio_remove(struct mmc_host *host)
+{
+       int i;
+
+       BUG_ON(!host);
+       BUG_ON(!host->card);
+
+       for (i = 0;i < host->card->sdio_funcs;i++) {
+               if (host->card->sdio_func[i]) {
+                       sdio_remove_func(host->card->sdio_func[i]);
+                       host->card->sdio_func[i] = NULL;
+               }
+       }
+
+       mmc_remove_card(host->card);
+       host->card = NULL;
+}
+
+/*
+ * Card detection callback from host.
+ */
+static void mmc_sdio_detect(struct mmc_host *host)
+{
+       int err;
+
+       BUG_ON(!host);
+       BUG_ON(!host->card);
+
+       mmc_claim_host(host);
+
+       /*
+        * Just check if our card has been removed.
+        */
+       err = mmc_select_card(host->card);
+
+       mmc_release_host(host);
+
+       if (err) {
+               mmc_sdio_remove(host);
+
+               mmc_claim_host(host);
+               mmc_detach_bus(host);
+               mmc_release_host(host);
+       }
+}
+
+
+static const struct mmc_bus_ops mmc_sdio_ops = {
+       .remove = mmc_sdio_remove,
+       .detect = mmc_sdio_detect,
+};
+
+
+/*
+ * Starting point for SDIO card init.
+ */
+int mmc_attach_sdio(struct mmc_host *host, u32 ocr)
+{
+       int err;
+       int i, funcs;
+       struct mmc_card *card;
+
+       BUG_ON(!host);
+       WARN_ON(!host->claimed);
+
+       mmc_attach_bus(host, &mmc_sdio_ops);
+
+       /*
+        * Sanity check the voltages that the card claims to
+        * support.
+        */
+       if (ocr & 0x7F) {
+               printk(KERN_WARNING "%s: card claims to support voltages "
+                      "below the defined range. These will be ignored.\n",
+                      mmc_hostname(host));
+               ocr &= ~0x7F;
+       }
+
+       if (ocr & MMC_VDD_165_195) {
+               printk(KERN_WARNING "%s: SDIO card claims to support the "
+                      "incompletely defined 'low voltage range'. This "
+                      "will be ignored.\n", mmc_hostname(host));
+               ocr &= ~MMC_VDD_165_195;
+       }
+
+       host->ocr = mmc_select_voltage(host, ocr);
+
+       /*
+        * Can we support the voltage(s) of the card(s)?
+        */
+       if (!host->ocr) {
+               err = -EINVAL;
+               goto err;
+       }
+
+       /*
+        * Inform the card of the voltage
+        */
+       err = mmc_send_io_op_cond(host, host->ocr, &ocr);
+       if (err)
+               goto err;
+
+       /*
+        * For SPI, enable CRC as appropriate.
+        */
+       if (mmc_host_is_spi(host)) {
+               err = mmc_spi_set_crc(host, use_spi_crc);
+               if (err)
+                       goto err;
+       }
+
+       /*
+        * The number of functions on the card is encoded inside
+        * the ocr.
+        */
+       funcs = (ocr & 0x70000000) >> 28;
+
+       /*
+        * Allocate card structure.
+        */
+       card = mmc_alloc_card(host);
+       if (IS_ERR(card)) {
+               err = PTR_ERR(card);
+               goto err;
+       }
+
+       card->type = MMC_TYPE_SDIO;
+       card->sdio_funcs = funcs;
+
+       host->card = card;
+
+       /*
+        * For native busses:  set card RCA and quit open drain mode.
+        */
+       if (!mmc_host_is_spi(host)) {
+               err = mmc_send_relative_addr(host, &card->rca);
+               if (err)
+                       goto remove;
+
+               mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
+       }
+
+       /*
+        * Select card, as all following commands rely on that.
+        */
+       if (!mmc_host_is_spi(host)) {
+               err = mmc_select_card(card);
+               if (err)
+                       goto remove;
+       }
+
+       /*
+        * Read the common registers.
+        */
+       err = sdio_read_cccr(card);
+       if (err)
+               goto remove;
+
+       /*
+        * Read the common CIS tuples.
+        */
+       err = sdio_read_common_cis(card);
+       if (err)
+               goto remove;
+
+       /*
+        * No support for high-speed yet, so just set
+        * the card's maximum speed.
+        */
+       mmc_set_clock(host, card->cis.max_dtr);
+
+       /*
+        * Switch to wider bus (if supported).
+        */
+       err = sdio_enable_wide(card);
+       if (err)
+               goto remove;
+
+       /*
+        * Initialize (but don't add) all present functions.
+        */
+       for (i = 0;i < funcs;i++) {
+               err = sdio_init_func(host->card, i + 1);
+               if (err)
+                       goto remove;
+       }
+
+       mmc_release_host(host);
+
+       /*
+        * First add the card to the driver model...
+        */
+       err = mmc_add_card(host->card);
+       if (err)
+               goto remove_added;
+
+       /*
+        * ...then the SDIO functions.
+        */
+       for (i = 0;i < funcs;i++) {
+               err = sdio_add_func(host->card->sdio_func[i]);
+               if (err)
+                       goto remove_added;
+       }
+
+       return 0;
+
+
+remove_added:
+       /* Remove without lock if the device has been added. */
+       mmc_sdio_remove(host);
+       mmc_claim_host(host);
+remove:
+       /* And with lock if it hasn't been added. */
+       if (host->card)
+               mmc_sdio_remove(host);
+err:
+       mmc_detach_bus(host);
+       mmc_release_host(host);
+
+       printk(KERN_ERR "%s: error %d whilst initialising SDIO card\n",
+               mmc_hostname(host), err);
+
+       return err;
+}
+
--- /dev/null
+++ b/drivers/mmc/core/sdio_bus.c
@@ -0,0 +1,265 @@
+/*
+ *  linux/drivers/mmc/core/sdio_bus.c
+ *
+ *  Copyright 2007 Pierre Ossman
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at
+ * your option) any later version.
+ *
+ * SDIO function driver model
+ */
+
+#include <linux/device.h>
+#include <linux/err.h>
+
+#include <linux/mmc/card.h>
+#include <linux/mmc/sdio_func.h>
+
+#include "sdio_cis.h"
+#include "sdio_bus.h"
+
+#define dev_to_sdio_func(d)    container_of(d, struct sdio_func, dev)
+#define to_sdio_driver(d)      container_of(d, struct sdio_driver, drv)
+
+/* show configuration fields */
+#define sdio_config_attr(field, format_string)                         \
+static ssize_t                                                         \
+field##_show(struct device *dev, struct device_attribute *attr, char *buf)                             \
+{                                                                      \
+       struct sdio_func *func;                                         \
+                                                                       \
+       func = dev_to_sdio_func (dev);                                  \
+       return sprintf (buf, format_string, func->field);               \
+}
+
+sdio_config_attr(class, "0x%02x\n");
+sdio_config_attr(vendor, "0x%04x\n");
+sdio_config_attr(device, "0x%04x\n");
+
+static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf)
+{
+       struct sdio_func *func = dev_to_sdio_func (dev);
+
+       return sprintf(buf, "sdio:c%02Xv%04Xd%04X\n",
+                       func->class, func->vendor, func->device);
+}
+
+static struct device_attribute sdio_dev_attrs[] = {
+       __ATTR_RO(class),
+       __ATTR_RO(vendor),
+       __ATTR_RO(device),
+       __ATTR_RO(modalias),
+       __ATTR_NULL,
+};
+
+static const struct sdio_device_id *sdio_match_one(struct sdio_func *func,
+       const struct sdio_device_id *id)
+{
+       if (id->class != (__u8)SDIO_ANY_ID && id->class != func->class)
+               return NULL;
+       if (id->vendor != (__u16)SDIO_ANY_ID && id->vendor != func->vendor)
+               return NULL;
+       if (id->device != (__u16)SDIO_ANY_ID && id->device != func->device)
+               return NULL;
+       return id;
+}
+
+static const struct sdio_device_id *sdio_match_device(struct sdio_func *func,
+       struct sdio_driver *sdrv)
+{
+       const struct sdio_device_id *ids;
+
+       ids = sdrv->id_table;
+
+       if (ids) {
+               while (ids->class || ids->vendor || ids->device) {
+                       if (sdio_match_one(func, ids))
+                               return ids;
+                       ids++;
+               }
+       }
+
+       return NULL;
+}
+
+static int sdio_bus_match(struct device *dev, struct device_driver *drv)
+{
+       struct sdio_func *func = dev_to_sdio_func(dev);
+       struct sdio_driver *sdrv = to_sdio_driver(drv);
+
+       if (sdio_match_device(func, sdrv))
+               return 1;
+
+       return 0;
+}
+
+static int
+sdio_bus_uevent(struct device *dev, char **envp,
+               int num_envp, char *buffer, int buffer_size)
+{
+       struct sdio_func *func = dev_to_sdio_func(dev);
+       int i = 0, len = 0;
+
+       if (add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &len,
+                       "SDIO_CLASS=%02X", func->class))
+               return -ENOMEM;
+
+       if (add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &len,
+                       "SDIO_ID=%04X:%04X", func->vendor, func->device))
+               return -ENOMEM;
+
+       if (add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &len,
+                       "MODALIAS=sdio:c%02Xv%04Xd%04X",
+                       func->class, func->vendor, func->device))
+               return -ENOMEM;
+
+       return 0;
+}
+
+static int sdio_bus_probe(struct device *dev)
+{
+       struct sdio_driver *drv = to_sdio_driver(dev->driver);
+       struct sdio_func *func = dev_to_sdio_func(dev);
+       const struct sdio_device_id *id;
+       int ret;
+
+       id = sdio_match_device(func, drv);
+       if (!id)
+               return -ENODEV;
+
+       /* Set the default block size so the driver is sure it's something
+        * sensible. */
+       sdio_claim_host(func);
+       ret = sdio_set_block_size(func, 0);
+       sdio_release_host(func);
+       if (ret)
+               return ret;
+
+       return drv->probe(func, id);
+}
+
+static int sdio_bus_remove(struct device *dev)
+{
+       struct sdio_driver *drv = to_sdio_driver(dev->driver);
+       struct sdio_func *func = dev_to_sdio_func(dev);
+
+       drv->remove(func);
+
+       if (func->irq_handler) {
+               printk(KERN_WARNING "WARNING: driver %s did not remove "
+                       "its interrupt handler!\n", drv->name);
+               sdio_claim_host(func);
+               sdio_release_irq(func);
+               sdio_release_host(func);
+       }
+
+       return 0;
+}
+
+static struct bus_type sdio_bus_type = {
+       .name           = "sdio",
+       .dev_attrs      = sdio_dev_attrs,
+       .match          = sdio_bus_match,
+       .uevent         = sdio_bus_uevent,
+       .probe          = sdio_bus_probe,
+       .remove         = sdio_bus_remove,
+};
+
+int sdio_register_bus(void)
+{
+       return bus_register(&sdio_bus_type);
+}
+
+void sdio_unregister_bus(void)
+{
+       bus_unregister(&sdio_bus_type);
+}
+
+/**
+ *     sdio_register_driver - register a function driver
+ *     @drv: SDIO function driver
+ */
+int sdio_register_driver(struct sdio_driver *drv)
+{
+       drv->drv.name = drv->name;
+       drv->drv.bus = &sdio_bus_type;
+       return driver_register(&drv->drv);
+}
+EXPORT_SYMBOL_GPL(sdio_register_driver);
+
+/**
+ *     sdio_unregister_driver - unregister a function driver
+ *     @drv: SDIO function driver
+ */
+void sdio_unregister_driver(struct sdio_driver *drv)
+{
+       drv->drv.bus = &sdio_bus_type;
+       driver_unregister(&drv->drv);
+}
+EXPORT_SYMBOL_GPL(sdio_unregister_driver);
+
+static void sdio_release_func(struct device *dev)
+{
+       struct sdio_func *func = dev_to_sdio_func(dev);
+
+       sdio_free_func_cis(func);
+
+       if (func->info)
+               kfree(func->info);
+
+       kfree(func);
+}
+
+/*
+ * Allocate and initialise a new SDIO function structure.
+ */
+struct sdio_func *sdio_alloc_func(struct mmc_card *card)
+{
+       struct sdio_func *func;
+
+       func = kzalloc(sizeof(struct sdio_func), GFP_KERNEL);
+       if (!func)
+               return ERR_PTR(-ENOMEM);
+
+       func->card = card;
+
+       device_initialize(&func->dev);
+
+       func->dev.parent = &card->dev;
+       func->dev.bus = &sdio_bus_type;
+       func->dev.release = sdio_release_func;
+
+       return func;
+}
+
+/*
+ * Register a new SDIO function with the driver model.
+ */
+int sdio_add_func(struct sdio_func *func)
+{
+       int ret;
+
+       snprintf(func->dev.bus_id, sizeof(func->dev.bus_id),
+                "%s:%d", mmc_card_id(func->card), func->num);
+
+       ret = device_add(&func->dev);
+       if (ret == 0)
+               sdio_func_set_present(func);
+
+       return ret;
+}
+
+/*
+ * Unregister a SDIO function with the driver model, and
+ * (eventually) free it.
+ */
+void sdio_remove_func(struct sdio_func *func)
+{
+       if (sdio_func_present(func))
+               device_del(&func->dev);
+
+       put_device(&func->dev);
+}
+
--- /dev/null
+++ b/drivers/mmc/core/sdio_bus.h
@@ -0,0 +1,22 @@
+/*
+ *  linux/drivers/mmc/core/sdio_bus.h
+ *
+ *  Copyright 2007 Pierre Ossman
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at
+ * your option) any later version.
+ */
+#ifndef _MMC_CORE_SDIO_BUS_H
+#define _MMC_CORE_SDIO_BUS_H
+
+struct sdio_func *sdio_alloc_func(struct mmc_card *card);
+int sdio_add_func(struct sdio_func *func);
+void sdio_remove_func(struct sdio_func *func);
+
+int sdio_register_bus(void);
+void sdio_unregister_bus(void);
+
+#endif
+
--- /dev/null
+++ b/drivers/mmc/core/sdio_cis.c
@@ -0,0 +1,346 @@
+/*
+ * linux/drivers/mmc/core/sdio_cis.c
+ *
+ * Author:     Nicolas Pitre
+ * Created:    June 11, 2007
+ * Copyright:  MontaVista Software Inc.
+ *
+ * Copyright 2007 Pierre Ossman
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at
+ * your option) any later version.
+ */
+
+#include <linux/kernel.h>
+
+#include <linux/mmc/host.h>
+#include <linux/mmc/card.h>
+#include <linux/mmc/sdio.h>
+#include <linux/mmc/sdio_func.h>
+
+#include "sdio_cis.h"
+#include "sdio_ops.h"
+
+static int cistpl_vers_1(struct mmc_card *card, struct sdio_func *func,
+                        const unsigned char *buf, unsigned size)
+{
+       unsigned i, nr_strings;
+       char **buffer, *string;
+
+       buf += 2;
+       size -= 2;
+
+       nr_strings = 0;
+       for (i = 0; i < size; i++) {
+               if (buf[i] == 0xff)
+                       break;
+               if (buf[i] == 0)
+                       nr_strings++;
+       }
+
+       if (buf[i-1] != '\0') {
+               printk(KERN_WARNING "SDIO: ignoring broken CISTPL_VERS_1\n");
+               return 0;
+       }
+
+       size = i;
+
+       buffer = kzalloc(sizeof(char*) * nr_strings + size, GFP_KERNEL);
+       if (!buffer)
+               return -ENOMEM;
+
+       string = (char*)(buffer + nr_strings);
+
+       for (i = 0; i < nr_strings; i++) {
+               buffer[i] = string;
+               strcpy(string, buf);
+               string += strlen(string) + 1;
+               buf += strlen(buf) + 1;
+       }
+
+       if (func) {
+               func->num_info = nr_strings;
+               func->info = (const char**)buffer;
+       } else {
+               card->num_info = nr_strings;
+               card->info = (const char**)buffer;
+       }
+
+       return 0;
+}
+
+static int cistpl_manfid(struct mmc_card *card, struct sdio_func *func,
+                        const unsigned char *buf, unsigned size)
+{
+       unsigned int vendor, device;
+
+       /* TPLMID_MANF */
+       vendor = buf[0] | (buf[1] << 8);
+
+       /* TPLMID_CARD */
+       device = buf[2] | (buf[3] << 8);
+
+       if (func) {
+               func->vendor = vendor;
+               func->device = device;
+       } else {
+               card->cis.vendor = vendor;
+               card->cis.device = device;
+       }
+
+       return 0;
+}
+
+static const unsigned char speed_val[16] =
+       { 0, 10, 12, 13, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 70, 80 };
+static const unsigned int speed_unit[8] =
+       { 10000, 100000, 1000000, 10000000, 0, 0, 0, 0 };
+
+static int cistpl_funce_common(struct mmc_card *card,
+                              const unsigned char *buf, unsigned size)
+{
+       if (size < 0x04 || buf[0] != 0)
+               return -EINVAL;
+
+       /* TPLFE_FN0_BLK_SIZE */
+       card->cis.blksize = buf[1] | (buf[2] << 8);
+
+       /* TPLFE_MAX_TRAN_SPEED */
+       card->cis.max_dtr = speed_val[(buf[3] >> 3) & 15] *
+                           speed_unit[buf[3] & 7];
+
+       return 0;
+}
+
+static int cistpl_funce_func(struct sdio_func *func,
+                            const unsigned char *buf, unsigned size)
+{
+       unsigned vsn;
+       unsigned min_size;
+
+       vsn = func->card->cccr.sdio_vsn;
+       min_size = (vsn == SDIO_SDIO_REV_1_00) ? 28 : 42;
+
+       if (size < min_size || buf[0] != 1)
+               return -EINVAL;
+
+       /* TPLFE_MAX_BLK_SIZE */
+       func->max_blksize = buf[12] | (buf[13] << 8);
+
+       return 0;
+}
+
+static int cistpl_funce(struct mmc_card *card, struct sdio_func *func,
+                       const unsigned char *buf, unsigned size)
+{
+       int ret;
+
+       /*
+        * There should be two versions of the CISTPL_FUNCE tuple,
+        * one for the common CIS (function 0) and a version used by
+        * the individual function's CIS (1-7). Yet, the later has a
+        * different length depending on the SDIO spec version.
+        */
+       if (func)
+               ret = cistpl_funce_func(func, buf, size);
+       else
+               ret = cistpl_funce_common(card, buf, size);
+
+       if (ret) {
+               printk(KERN_ERR "%s: bad CISTPL_FUNCE size %u "
+                      "type %u\n", mmc_hostname(card->host), size, buf[0]);
+               return ret;
+       }
+
+       return 0;
+}
+
+typedef int (tpl_parse_t)(struct mmc_card *, struct sdio_func *,
+                          const unsigned char *, unsigned);
+
+struct cis_tpl {
+       unsigned char code;
+       unsigned char min_size;
+       tpl_parse_t *parse;
+};
+
+static const struct cis_tpl cis_tpl_list[] = {
+       {       0x15,   3,      cistpl_vers_1           },
+       {       0x20,   4,      cistpl_manfid           },
+       {       0x21,   2,      /* cistpl_funcid */     },
+       {       0x22,   0,      cistpl_funce            },
+};
+
+static int sdio_read_cis(struct mmc_card *card, struct sdio_func *func)
+{
+       int ret;
+       struct sdio_func_tuple *this, **prev;
+       unsigned i, ptr = 0;
+
+       /*
+        * Note that this works for the common CIS (function number 0) as
+        * well as a function's CIS * since SDIO_CCCR_CIS and SDIO_FBR_CIS
+        * have the same offset.
+        */
+       for (i = 0; i < 3; i++) {
+               unsigned char x, fn;
+
+               if (func)
+                       fn = func->num;
+               else
+                       fn = 0;
+
+               ret = mmc_io_rw_direct(card, 0, 0,
+                       SDIO_FBR_BASE(fn) + SDIO_FBR_CIS + i, 0, &x);
+               if (ret)
+                       return ret;
+               ptr |= x << (i * 8);
+       }
+
+       if (func)
+               prev = &func->tuples;
+       else
+               prev = &card->tuples;
+
+       BUG_ON(*prev);
+
+       do {
+               unsigned char tpl_code, tpl_link;
+
+               ret = mmc_io_rw_direct(card, 0, 0, ptr++, 0, &tpl_code);
+               if (ret)
+                       break;
+
+               /* 0xff means we're done */
+               if (tpl_code == 0xff)
+                       break;
+
+               ret = mmc_io_rw_direct(card, 0, 0, ptr++, 0, &tpl_link);
+               if (ret)
+                       break;
+
+               this = kmalloc(sizeof(*this) + tpl_link, GFP_KERNEL);
+               if (!this)
+                       return -ENOMEM;
+
+               for (i = 0; i < tpl_link; i++) {
+                       ret = mmc_io_rw_direct(card, 0, 0,
+                                              ptr + i, 0, &this->data[i]);
+                       if (ret)
+                               break;
+               }
+               if (ret) {
+                       kfree(this);
+                       break;
+               }
+
+               for (i = 0; i < ARRAY_SIZE(cis_tpl_list); i++)
+                       if (cis_tpl_list[i].code == tpl_code)
+                               break;
+               if (i >= ARRAY_SIZE(cis_tpl_list)) {
+                       /* this tuple is unknown to the core */
+                       this->next = NULL;
+                       this->code = tpl_code;
+                       this->size = tpl_link;
+                       *prev = this;
+                       prev = &this->next;
+                       printk(KERN_DEBUG
+                              "%s: queuing CIS tuple 0x%02x length %u\n",
+                              mmc_hostname(card->host), tpl_code, tpl_link);
+               } else {
+                       const struct cis_tpl *tpl = cis_tpl_list + i;
+                       if (tpl_link < tpl->min_size) {
+                               printk(KERN_ERR
+                                      "%s: bad CIS tuple 0x%02x (length = %u, expected >= %u)\n",
+                                      mmc_hostname(card->host),
+                                      tpl_code, tpl_link, tpl->min_size);
+                               ret = -EINVAL;
+                       } else if (tpl->parse) {
+                               ret = tpl->parse(card, func,
+                                                this->data, tpl_link);
+                       }
+                       kfree(this);
+               }
+
+               ptr += tpl_link;
+       } while (!ret);
+
+       /*
+        * Link in all unknown tuples found in the common CIS so that
+        * drivers don't have to go digging in two places.
+        */
+       if (func)
+               *prev = card->tuples;
+
+       return ret;
+}
+
+int sdio_read_common_cis(struct mmc_card *card)
+{
+       return sdio_read_cis(card, NULL);
+}
+
+void sdio_free_common_cis(struct mmc_card *card)
+{
+       struct sdio_func_tuple *tuple, *victim;
+
+       tuple = card->tuples;
+
+       while (tuple) {
+               victim = tuple;
+               tuple = tuple->next;
+               kfree(victim);
+       }
+
+       card->tuples = NULL;
+}
+
+int sdio_read_func_cis(struct sdio_func *func)
+{
+       int ret;
+
+       ret = sdio_read_cis(func->card, func);
+       if (ret)
+               return ret;
+
+       /*
+        * Since we've linked to tuples in the card structure,
+        * we must make sure we have a reference to it.
+        */
+       get_device(&func->card->dev);
+
+       /*
+        * Vendor/device id is optional for function CIS, so
+        * copy it from the card structure as needed.
+        */
+       if (func->vendor == 0) {
+               func->vendor = func->card->cis.vendor;
+               func->device = func->card->cis.device;
+       }
+
+       return 0;
+}
+
+void sdio_free_func_cis(struct sdio_func *func)
+{
+       struct sdio_func_tuple *tuple, *victim;
+
+       tuple = func->tuples;
+
+       while (tuple && tuple != func->card->tuples) {
+               victim = tuple;
+               tuple = tuple->next;
+               kfree(victim);
+       }
+
+       func->tuples = NULL;
+
+       /*
+        * We have now removed the link to the tuples in the
+        * card structure, so remove the reference.
+        */
+       put_device(&func->card->dev);
+}
+
--- /dev/null
+++ b/drivers/mmc/core/sdio_cis.h
@@ -0,0 +1,23 @@
+/*
+ * linux/drivers/mmc/core/sdio_cis.h
+ *
+ * Author:     Nicolas Pitre
+ * Created:    June 11, 2007
+ * Copyright:  MontaVista Software Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at
+ * your option) any later version.
+ */
+
+#ifndef _MMC_SDIO_CIS_H
+#define _MMC_SDIO_CIS_H
+
+int sdio_read_common_cis(struct mmc_card *card);
+void sdio_free_common_cis(struct mmc_card *card);
+
+int sdio_read_func_cis(struct sdio_func *func);
+void sdio_free_func_cis(struct sdio_func *func);
+
+#endif
--- /dev/null
+++ b/drivers/mmc/core/sdio_io.c
@@ -0,0 +1,548 @@
+/*
+ *  linux/drivers/mmc/core/sdio_io.c
+ *
+ *  Copyright 2007 Pierre Ossman
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at
+ * your option) any later version.
+ */
+
+#include <linux/mmc/host.h>
+#include <linux/mmc/card.h>
+#include <linux/mmc/sdio.h>
+#include <linux/mmc/sdio_func.h>
+
+#include "sdio_ops.h"
+
+/**
+ *     sdio_claim_host - exclusively claim a bus for a certain SDIO function
+ *     @func: SDIO function that will be accessed
+ *
+ *     Claim a bus for a set of operations. The SDIO function given
+ *     is used to figure out which bus is relevant.
+ */
+void sdio_claim_host(struct sdio_func *func)
+{
+       BUG_ON(!func);
+       BUG_ON(!func->card);
+
+       mmc_claim_host(func->card->host);
+}
+EXPORT_SYMBOL_GPL(sdio_claim_host);
+
+/**
+ *     sdio_release_host - release a bus for a certain SDIO function
+ *     @func: SDIO function that was accessed
+ *
+ *     Release a bus, allowing others to claim the bus for their
+ *     operations.
+ */
+void sdio_release_host(struct sdio_func *func)
+{
+       BUG_ON(!func);
+       BUG_ON(!func->card);
+
+       mmc_release_host(func->card->host);
+}
+EXPORT_SYMBOL_GPL(sdio_release_host);
+
+/**
+ *     sdio_enable_func - enables a SDIO function for usage
+ *     @func: SDIO function to enable
+ *
+ *     Powers up and activates a SDIO function so that register
+ *     access is possible.
+ */
+int sdio_enable_func(struct sdio_func *func)
+{
+       int ret;
+       unsigned char reg;
+       unsigned long timeout;
+
+       BUG_ON(!func);
+       BUG_ON(!func->card);
+
+       pr_debug("SDIO: Enabling device %s...\n", sdio_func_id(func));
+
+       ret = mmc_io_rw_direct(func->card, 0, 0, SDIO_CCCR_IOEx, 0, &reg);
+       if (ret)
+               goto err;
+
+       reg |= 1 << func->num;
+
+       ret = mmc_io_rw_direct(func->card, 1, 0, SDIO_CCCR_IOEx, reg, NULL);
+       if (ret)
+               goto err;
+
+       /*
+        * FIXME: This should timeout based on information in the CIS,
+        * but we don't have card to parse that yet.
+        */
+       timeout = jiffies + HZ;
+
+       while (1) {
+               ret = mmc_io_rw_direct(func->card, 0, 0, SDIO_CCCR_IORx, 0, &reg);
+               if (ret)
+                       goto err;
+               if (reg & (1 << func->num))
+                       break;
+               ret = -ETIME;
+               if (time_after(jiffies, timeout))
+                       goto err;
+       }
+
+       pr_debug("SDIO: Enabled device %s\n", sdio_func_id(func));
+
+       return 0;
+
+err:
+       pr_debug("SDIO: Failed to enable device %s\n", sdio_func_id(func));
+       return ret;
+}
+EXPORT_SYMBOL_GPL(sdio_enable_func);
+
+/**
+ *     sdio_disable_func - disable a SDIO function
+ *     @func: SDIO function to disable
+ *
+ *     Powers down and deactivates a SDIO function. Register access
+ *     to this function will fail until the function is reenabled.
+ */
+int sdio_disable_func(struct sdio_func *func)
+{
+       int ret;
+       unsigned char reg;
+
+       BUG_ON(!func);
+       BUG_ON(!func->card);
+
+       pr_debug("SDIO: Disabling device %s...\n", sdio_func_id(func));
+
+       ret = mmc_io_rw_direct(func->card, 0, 0, SDIO_CCCR_IOEx, 0, &reg);
+       if (ret)
+               goto err;
+
+       reg &= ~(1 << func->num);
+
+       ret = mmc_io_rw_direct(func->card, 1, 0, SDIO_CCCR_IOEx, reg, NULL);
+       if (ret)
+               goto err;
+
+       pr_debug("SDIO: Disabled device %s\n", sdio_func_id(func));
+
+       return 0;
+
+err:
+       pr_debug("SDIO: Failed to disable device %s\n", sdio_func_id(func));
+       return -EIO;
+}
+EXPORT_SYMBOL_GPL(sdio_disable_func);
+
+/**
+ *     sdio_set_block_size - set the block size of an SDIO function
+ *     @func: SDIO function to change
+ *     @blksz: new block size or 0 to use the default.
+ *
+ *     The default block size is the largest supported by both the function
+ *     and the host, with a maximum of 512 to ensure that arbitrarily sized
+ *     data transfer use the optimal (least) number of commands.
+ *
+ *     A driver may call this to override the default block size set by the
+ *     core. This can be used to set a block size greater than the maximum
+ *     that reported by the card; it is the driver's responsibility to ensure
+ *     it uses a value that the card supports.
+ *
+ *     Returns 0 on success, -EINVAL if the host does not support the
+ *     requested block size, or -EIO (etc.) if one of the resultant FBR block
+ *     size register writes failed.
+ *
+ */
+int sdio_set_block_size(struct sdio_func *func, unsigned blksz)
+{
+       int ret;
+
+       if (blksz > func->card->host->max_blk_size)
+               return -EINVAL;
+
+       if (blksz == 0) {
+               blksz = min(min(
+                       func->max_blksize,
+                       func->card->host->max_blk_size),
+                       512u);
+       }
+
+       ret = mmc_io_rw_direct(func->card, 1, 0,
+               SDIO_FBR_BASE(func->num) + SDIO_FBR_BLKSIZE,
+               blksz & 0xff, NULL);
+       if (ret)
+               return ret;
+       ret = mmc_io_rw_direct(func->card, 1, 0,
+               SDIO_FBR_BASE(func->num) + SDIO_FBR_BLKSIZE + 1,
+               (blksz >> 8) & 0xff, NULL);
+       if (ret)
+               return ret;
+       func->cur_blksize = blksz;
+       return 0;
+}
+
+EXPORT_SYMBOL_GPL(sdio_set_block_size);
+
+/* Split an arbitrarily sized data transfer into several
+ * IO_RW_EXTENDED commands. */
+static int sdio_io_rw_ext_helper(struct sdio_func *func, int write,
+       unsigned addr, int incr_addr, u8 *buf, unsigned size)
+{
+       unsigned remainder = size;
+       unsigned max_blocks;
+       int ret;
+
+       /* Do the bulk of the transfer using block mode (if supported). */
+       if (func->card->cccr.multi_block) {
+               /* Blocks per command is limited by host count, host transfer
+                * size (we only use a single sg entry) and the maximum for
+                * IO_RW_EXTENDED of 511 blocks. */
+               max_blocks = min(min(
+                       func->card->host->max_blk_count,
+                       func->card->host->max_seg_size / func->cur_blksize),
+                       511u);
+
+               while (remainder > func->cur_blksize) {
+                       unsigned blocks;
+
+                       blocks = remainder / func->cur_blksize;
+                       if (blocks > max_blocks)
+                               blocks = max_blocks;
+                       size = blocks * func->cur_blksize;
+
+                       ret = mmc_io_rw_extended(func->card, write,
+                               func->num, addr, incr_addr, buf,
+                               blocks, func->cur_blksize);
+                       if (ret)
+                               return ret;
+
+                       remainder -= size;
+                       buf += size;
+                       if (incr_addr)
+                               addr += size;
+               }
+       }
+
+       /* Write the remainder using byte mode. */
+       while (remainder > 0) {
+               size = remainder;
+               if (size > func->cur_blksize)
+                       size = func->cur_blksize;
+               if (size > 512)
+                       size = 512; /* maximum size for byte mode */
+
+               ret = mmc_io_rw_extended(func->card, write, func->num, addr,
+                        incr_addr, buf, 1, size);
+               if (ret)
+                       return ret;
+
+               remainder -= size;
+               buf += size;
+               if (incr_addr)
+                       addr += size;
+       }
+       return 0;
+}
+
+/**
+ *     sdio_readb - read a single byte from a SDIO function
+ *     @func: SDIO function to access
+ *     @addr: address to read
+ *     @err_ret: optional status value from transfer
+ *
+ *     Reads a single byte from the address space of a given SDIO
+ *     function. If there is a problem reading the address, 0xff
+ *     is returned and @err_ret will contain the error code.
+ */
+unsigned char sdio_readb(struct sdio_func *func, unsigned int addr,
+       int *err_ret)
+{
+       int ret;
+       unsigned char val;
+
+       BUG_ON(!func);
+
+       if (err_ret)
+               *err_ret = 0;
+
+       ret = mmc_io_rw_direct(func->card, 0, func->num, addr, 0, &val);
+       if (ret) {
+               if (err_ret)
+                       *err_ret = ret;
+               return 0xFF;
+       }
+
+       return val;
+}
+EXPORT_SYMBOL_GPL(sdio_readb);
+
+/**
+ *     sdio_writeb - write a single byte to a SDIO function
+ *     @func: SDIO function to access
+ *     @b: byte to write
+ *     @addr: address to write to
+ *     @err_ret: optional status value from transfer
+ *
+ *     Writes a single byte to the address space of a given SDIO
+ *     function. @err_ret will contain the status of the actual
+ *     transfer.
+ */
+void sdio_writeb(struct sdio_func *func, unsigned char b, unsigned int addr,
+       int *err_ret)
+{
+       int ret;
+
+       BUG_ON(!func);
+
+       ret = mmc_io_rw_direct(func->card, 1, func->num, addr, b, NULL);
+       if (err_ret)
+               *err_ret = ret;
+}
+EXPORT_SYMBOL_GPL(sdio_writeb);
+
+/**
+ *     sdio_memcpy_fromio - read a chunk of memory from a SDIO function
+ *     @func: SDIO function to access
+ *     @dst: buffer to store the data
+ *     @addr: address to begin reading from
+ *     @count: number of bytes to read
+ *
+ *     Reads from the address space of a given SDIO function. Return
+ *     value indicates if the transfer succeeded or not.
+ */
+int sdio_memcpy_fromio(struct sdio_func *func, void *dst,
+       unsigned int addr, int count)
+{
+       return sdio_io_rw_ext_helper(func, 0, addr, 1, dst, count);
+}
+EXPORT_SYMBOL_GPL(sdio_memcpy_fromio);
+
+/**
+ *     sdio_memcpy_toio - write a chunk of memory to a SDIO function
+ *     @func: SDIO function to access
+ *     @addr: address to start writing to
+ *     @src: buffer that contains the data to write
+ *     @count: number of bytes to write
+ *
+ *     Writes to the address space of a given SDIO function. Return
+ *     value indicates if the transfer succeeded or not.
+ */
+int sdio_memcpy_toio(struct sdio_func *func, unsigned int addr,
+       void *src, int count)
+{
+       return sdio_io_rw_ext_helper(func, 1, addr, 1, src, count);
+}
+EXPORT_SYMBOL_GPL(sdio_memcpy_toio);
+
+/**
+ *     sdio_readsb - read from a FIFO on a SDIO function
+ *     @func: SDIO function to access
+ *     @dst: buffer to store the data
+ *     @addr: address of (single byte) FIFO
+ *     @count: number of bytes to read
+ *
+ *     Reads from the specified FIFO of a given SDIO function. Return
+ *     value indicates if the transfer succeeded or not.
+ */
+int sdio_readsb(struct sdio_func *func, void *dst, unsigned int addr,
+       int count)
+{
+       return sdio_io_rw_ext_helper(func, 0, addr, 0, dst, count);
+}
+
+EXPORT_SYMBOL_GPL(sdio_readsb);
+
+/**
+ *     sdio_writesb - write to a FIFO of a SDIO function
+ *     @func: SDIO function to access
+ *     @addr: address of (single byte) FIFO
+ *     @src: buffer that contains the data to write
+ *     @count: number of bytes to write
+ *
+ *     Writes to the specified FIFO of a given SDIO function. Return
+ *     value indicates if the transfer succeeded or not.
+ */
+int sdio_writesb(struct sdio_func *func, unsigned int addr, void *src,
+       int count)
+{
+       return sdio_io_rw_ext_helper(func, 1, addr, 0, src, count);
+}
+EXPORT_SYMBOL_GPL(sdio_writesb);
+
+/**
+ *     sdio_readw - read a 16 bit integer from a SDIO function
+ *     @func: SDIO function to access
+ *     @addr: address to read
+ *     @err_ret: optional status value from transfer
+ *
+ *     Reads a 16 bit integer from the address space of a given SDIO
+ *     function. If there is a problem reading the address, 0xffff
+ *     is returned and @err_ret will contain the error code.
+ */
+unsigned short sdio_readw(struct sdio_func *func, unsigned int addr,
+       int *err_ret)
+{
+       int ret;
+
+       if (err_ret)
+               *err_ret = 0;
+
+       ret = sdio_memcpy_fromio(func, func->tmpbuf, addr, 2);
+       if (ret) {
+               if (err_ret)
+                       *err_ret = ret;
+               return 0xFFFF;
+       }
+
+       return le16_to_cpu(*(u16*)func->tmpbuf);
+}
+EXPORT_SYMBOL_GPL(sdio_readw);
+
+/**
+ *     sdio_writew - write a 16 bit integer to a SDIO function
+ *     @func: SDIO function to access
+ *     @b: integer to write
+ *     @addr: address to write to
+ *     @err_ret: optional status value from transfer
+ *
+ *     Writes a 16 bit integer to the address space of a given SDIO
+ *     function. @err_ret will contain the status of the actual
+ *     transfer.
+ */
+void sdio_writew(struct sdio_func *func, unsigned short b, unsigned int addr,
+       int *err_ret)
+{
+       int ret;
+
+       *(u16*)func->tmpbuf = cpu_to_le16(b);
+
+       ret = sdio_memcpy_toio(func, addr, func->tmpbuf, 2);
+       if (err_ret)
+               *err_ret = ret;
+}
+EXPORT_SYMBOL_GPL(sdio_writew);
+
+/**
+ *     sdio_readl - read a 32 bit integer from a SDIO function
+ *     @func: SDIO function to access
+ *     @addr: address to read
+ *     @err_ret: optional status value from transfer
+ *
+ *     Reads a 32 bit integer from the address space of a given SDIO
+ *     function. If there is a problem reading the address,
+ *     0xffffffff is returned and @err_ret will contain the error
+ *     code.
+ */
+unsigned long sdio_readl(struct sdio_func *func, unsigned int addr,
+       int *err_ret)
+{
+       int ret;
+
+       if (err_ret)
+               *err_ret = 0;
+
+       ret = sdio_memcpy_fromio(func, func->tmpbuf, addr, 4);
+       if (ret) {
+               if (err_ret)
+                       *err_ret = ret;
+               return 0xFFFFFFFF;
+       }
+
+       return le32_to_cpu(*(u32*)func->tmpbuf);
+}
+EXPORT_SYMBOL_GPL(sdio_readl);
+
+/**
+ *     sdio_writel - write a 32 bit integer to a SDIO function
+ *     @func: SDIO function to access
+ *     @b: integer to write
+ *     @addr: address to write to
+ *     @err_ret: optional status value from transfer
+ *
+ *     Writes a 32 bit integer to the address space of a given SDIO
+ *     function. @err_ret will contain the status of the actual
+ *     transfer.
+ */
+void sdio_writel(struct sdio_func *func, unsigned long b, unsigned int addr,
+       int *err_ret)
+{
+       int ret;
+
+       *(u32*)func->tmpbuf = cpu_to_le32(b);
+
+       ret = sdio_memcpy_toio(func, addr, func->tmpbuf, 4);
+       if (err_ret)
+               *err_ret = ret;
+}
+EXPORT_SYMBOL_GPL(sdio_writel);
+
+/**
+ *     sdio_f0_readb - read a single byte from SDIO function 0
+ *     @func: an SDIO function of the card
+ *     @addr: address to read
+ *     @err_ret: optional status value from transfer
+ *
+ *     Reads a single byte from the address space of SDIO function 0.
+ *     If there is a problem reading the address, 0xff is returned
+ *     and @err_ret will contain the error code.
+ */
+unsigned char sdio_f0_readb(struct sdio_func *func, unsigned int addr,
+       int *err_ret)
+{
+       int ret;
+       unsigned char val;
+
+       BUG_ON(!func);
+
+       if (err_ret)
+               *err_ret = 0;
+
+       ret = mmc_io_rw_direct(func->card, 0, 0, addr, 0, &val);
+       if (ret) {
+               if (err_ret)
+                       *err_ret = ret;
+               return 0xFF;
+       }
+
+       return val;
+}
+EXPORT_SYMBOL_GPL(sdio_f0_readb);
+
+/**
+ *     sdio_f0_writeb - write a single byte to SDIO function 0
+ *     @func: an SDIO function of the card
+ *     @b: byte to write
+ *     @addr: address to write to
+ *     @err_ret: optional status value from transfer
+ *
+ *     Writes a single byte to the address space of SDIO function 0.
+ *     @err_ret will contain the status of the actual transfer.
+ *
+ *     Only writes to the vendor specific CCCR registers (0xF0 -
+ *     0xFF) are permiited; @err_ret will be set to -EINVAL for *
+ *     writes outside this range.
+ */
+void sdio_f0_writeb(struct sdio_func *func, unsigned char b, unsigned int addr,
+       int *err_ret)
+{
+       int ret;
+
+       BUG_ON(!func);
+
+       if (addr < 0xF0 || addr > 0xFF) {
+               if (err_ret)
+                       *err_ret = -EINVAL;
+               return;
+       }
+
+       ret = mmc_io_rw_direct(func->card, 1, 0, addr, b, NULL);
+       if (err_ret)
+               *err_ret = ret;
+}
+EXPORT_SYMBOL_GPL(sdio_f0_writeb);
--- /dev/null
+++ b/drivers/mmc/core/sdio_irq.c
@@ -0,0 +1,267 @@
+/*
+ * linux/drivers/mmc/core/sdio_irq.c
+ *
+ * Author:      Nicolas Pitre
+ * Created:     June 18, 2007
+ * Copyright:   MontaVista Software Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at
+ * your option) any later version.
+ */
+
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/kthread.h>
+#include <linux/wait.h>
+#include <linux/delay.h>
+
+#include <linux/mmc/core.h>
+#include <linux/mmc/host.h>
+#include <linux/mmc/card.h>
+#include <linux/mmc/sdio.h>
+#include <linux/mmc/sdio_func.h>
+
+#include "sdio_ops.h"
+
+static int process_sdio_pending_irqs(struct mmc_card *card)
+{
+       int i, ret, count;
+       unsigned char pending;
+
+       ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_INTx, 0, &pending);
+       if (ret) {
+               printk(KERN_DEBUG "%s: error %d reading SDIO_CCCR_INTx\n",
+                      mmc_card_id(card), ret);
+               return ret;
+       }
+
+       count = 0;
+       for (i = 1; i <= 7; i++) {
+               if (pending & (1 << i)) {
+                       struct sdio_func *func = card->sdio_func[i - 1];
+                       if (!func) {
+                               printk(KERN_WARNING "%s: pending IRQ for "
+                                       "non-existant function\n",
+                                       mmc_card_id(card));
+                               ret = -EINVAL;
+                       } else if (func->irq_handler) {
+                               func->irq_handler(func);
+                               count++;
+                       } else {
+                               printk(KERN_WARNING "%s: pending IRQ with no handler\n",
+                                      sdio_func_id(func));
+                               ret = -EINVAL;
+                       }
+               }
+       }
+
+       if (count)
+               return count;
+
+       return ret;
+}
+
+static int sdio_irq_thread(void *_host)
+{
+       struct mmc_host *host = _host;
+       struct sched_param param = { .sched_priority = 1 };
+       unsigned long period, idle_period;
+       int ret;
+
+       sched_setscheduler(current, SCHED_FIFO, &param);
+
+       /*
+        * We want to allow for SDIO cards to work even on non SDIO
+        * aware hosts.  One thing that non SDIO host cannot do is
+        * asynchronous notification of pending SDIO card interrupts
+        * hence we poll for them in that case.
+        */
+       idle_period = msecs_to_jiffies(10);
+       period = (host->caps & MMC_CAP_SDIO_IRQ) ?
+               MAX_SCHEDULE_TIMEOUT : idle_period;
+
+       pr_debug("%s: IRQ thread started (poll period = %lu jiffies)\n",
+                mmc_hostname(host), period);
+
+       do {
+               /*
+                * We claim the host here on drivers behalf for a couple
+                * reasons:
+                *
+                * 1) it is already needed to retrieve the CCCR_INTx;
+                * 2) we want the driver(s) to clear the IRQ condition ASAP;
+                * 3) we need to control the abort condition locally.
+                *
+                * Just like traditional hard IRQ handlers, we expect SDIO
+                * IRQ handlers to be quick and to the point, so that the
+                * holding of the host lock does not cover too much work
+                * that doesn't require that lock to be held.
+                */
+               ret = __mmc_claim_host(host, &host->sdio_irq_thread_abort);
+               if (ret)
+                       break;
+               ret = process_sdio_pending_irqs(host->card);
+               mmc_release_host(host);
+
+               /*
+                * Give other threads a chance to run in the presence of
+                * errors.  FIXME: determine if due to card removal and
+                * possibly exit this thread if so.
+                */
+               if (ret < 0)
+                       ssleep(1);
+
+               /*
+                * Adaptive polling frequency based on the assumption
+                * that an interrupt will be closely followed by more.
+                * This has a substantial benefit for network devices.
+                */
+               if (!(host->caps & MMC_CAP_SDIO_IRQ)) {
+                       if (ret > 0)
+                               period /= 2;
+                       else {
+                               period++;
+                               if (period > idle_period)
+                                       period = idle_period;
+                       }
+               }
+
+               set_task_state(current, TASK_INTERRUPTIBLE);
+               if (host->caps & MMC_CAP_SDIO_IRQ)
+                       host->ops->enable_sdio_irq(host, 1);
+               if (!kthread_should_stop())
+                       schedule_timeout(period);
+               set_task_state(current, TASK_RUNNING);
+       } while (!kthread_should_stop());
+
+       if (host->caps & MMC_CAP_SDIO_IRQ)
+               host->ops->enable_sdio_irq(host, 0);
+
+       pr_debug("%s: IRQ thread exiting with code %d\n",
+                mmc_hostname(host), ret);
+
+       return ret;
+}
+
+static int sdio_card_irq_get(struct mmc_card *card)
+{
+       struct mmc_host *host = card->host;
+
+       WARN_ON(!host->claimed);
+
+       if (!host->sdio_irqs++) {
+               atomic_set(&host->sdio_irq_thread_abort, 0);
+               host->sdio_irq_thread =
+                       kthread_run(sdio_irq_thread, host, "ksdiorqd");
+               if (IS_ERR(host->sdio_irq_thread)) {
+                       int err = PTR_ERR(host->sdio_irq_thread);
+                       host->sdio_irqs--;
+                       return err;
+               }
+       }
+
+       return 0;
+}
+
+static int sdio_card_irq_put(struct mmc_card *card)
+{
+       struct mmc_host *host = card->host;
+
+       WARN_ON(!host->claimed);
+       BUG_ON(host->sdio_irqs < 1);
+
+       if (!--host->sdio_irqs) {
+               atomic_set(&host->sdio_irq_thread_abort, 1);
+               kthread_stop(host->sdio_irq_thread);
+       }
+
+       return 0;
+}
+
+/**
+ *     sdio_claim_irq - claim the IRQ for a SDIO function
+ *     @func: SDIO function
+ *     @handler: IRQ handler callback
+ *
+ *     Claim and activate the IRQ for the given SDIO function. The provided
+ *     handler will be called when that IRQ is asserted.  The host is always
+ *     claimed already when the handler is called so the handler must not
+ *     call sdio_claim_host() nor sdio_release_host().
+ */
+int sdio_claim_irq(struct sdio_func *func, sdio_irq_handler_t *handler)
+{
+       int ret;
+       unsigned char reg;
+
+       BUG_ON(!func);
+       BUG_ON(!func->card);
+
+       pr_debug("SDIO: Enabling IRQ for %s...\n", sdio_func_id(func));
+
+       if (func->irq_handler) {
+               pr_debug("SDIO: IRQ for %s already in use.\n", sdio_func_id(func));
+               return -EBUSY;
+       }
+
+       ret = mmc_io_rw_direct(func->card, 0, 0, SDIO_CCCR_IENx, 0, &reg);
+       if (ret)
+               return ret;
+
+       reg |= 1 << func->num;
+
+       reg |= 1; /* Master interrupt enable */
+
+       ret = mmc_io_rw_direct(func->card, 1, 0, SDIO_CCCR_IENx, reg, NULL);
+       if (ret)
+               return ret;
+
+       func->irq_handler = handler;
+       ret = sdio_card_irq_get(func->card);
+       if (ret)
+               func->irq_handler = NULL;
+
+       return ret;
+}
+EXPORT_SYMBOL_GPL(sdio_claim_irq);
+
+/**
+ *     sdio_release_irq - release the IRQ for a SDIO function
+ *     @func: SDIO function
+ *
+ *     Disable and release the IRQ for the given SDIO function.
+ */
+int sdio_release_irq(struct sdio_func *func)
+{
+       int ret;
+       unsigned char reg;
+
+       BUG_ON(!func);
+       BUG_ON(!func->card);
+
+       pr_debug("SDIO: Disabling IRQ for %s...\n", sdio_func_id(func));
+
+       if (func->irq_handler) {
+               func->irq_handler = NULL;
+               sdio_card_irq_put(func->card);
+       }
+
+       ret = mmc_io_rw_direct(func->card, 0, 0, SDIO_CCCR_IENx, 0, &reg);
+       if (ret)
+               return ret;
+
+       reg &= ~(1 << func->num);
+
+       /* Disable master interrupt with the last function interrupt */
+       if (!(reg & 0xFE))
+               reg = 0;
+
+       ret = mmc_io_rw_direct(func->card, 1, 0, SDIO_CCCR_IENx, reg, NULL);
+       if (ret)
+               return ret;
+
+       return 0;
+}
+EXPORT_SYMBOL_GPL(sdio_release_irq);
+
--- /dev/null
+++ b/drivers/mmc/core/sdio_ops.c
@@ -0,0 +1,175 @@
+/*
+ *  linux/drivers/mmc/sdio_ops.c
+ *
+ *  Copyright 2006-2007 Pierre Ossman
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at
+ * your option) any later version.
+ */
+
+#include <linux/scatterlist.h>
+
+#include <linux/mmc/host.h>
+#include <linux/mmc/card.h>
+#include <linux/mmc/mmc.h>
+#include <linux/mmc/sdio.h>
+
+#include "core.h"
+
+int mmc_send_io_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
+{
+       struct mmc_command cmd;
+       int i, err = 0;
+
+       BUG_ON(!host);
+
+       memset(&cmd, 0, sizeof(struct mmc_command));
+
+       cmd.opcode = SD_IO_SEND_OP_COND;
+       cmd.arg = ocr;
+       cmd.flags = MMC_RSP_SPI_R4 | MMC_RSP_R4 | MMC_CMD_BCR;
+
+       for (i = 100; i; i--) {
+               err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
+               if (err)
+                       break;
+
+               /* if we're just probing, do a single pass */
+               if (ocr == 0)
+                       break;
+
+               /* otherwise wait until reset completes */
+               if (mmc_host_is_spi(host)) {
+                       /*
+                        * Both R1_SPI_IDLE and MMC_CARD_BUSY indicate
+                        * an initialized card under SPI, but some cards
+                        * (Marvell's) only behave when looking at this
+                        * one.
+                        */
+                       if (cmd.resp[1] & MMC_CARD_BUSY)
+                               break;
+               } else {
+                       if (cmd.resp[0] & MMC_CARD_BUSY)
+                               break;
+               }
+
+               err = -ETIMEDOUT;
+
+               mmc_delay(10);
+       }
+
+       if (rocr)
+               *rocr = cmd.resp[mmc_host_is_spi(host) ? 1 : 0];
+
+       return err;
+}
+
+int mmc_io_rw_direct(struct mmc_card *card, int write, unsigned fn,
+       unsigned addr, u8 in, u8* out)
+{
+       struct mmc_command cmd;
+       int err;
+
+       BUG_ON(!card);
+       BUG_ON(fn > 7);
+
+       memset(&cmd, 0, sizeof(struct mmc_command));
+
+       cmd.opcode = SD_IO_RW_DIRECT;
+       cmd.arg = write ? 0x80000000 : 0x00000000;
+       cmd.arg |= fn << 28;
+       cmd.arg |= (write && out) ? 0x08000000 : 0x00000000;
+       cmd.arg |= addr << 9;
+       cmd.arg |= in;
+       cmd.flags = MMC_RSP_SPI_R5 | MMC_RSP_R5 | MMC_CMD_AC;
+
+       err = mmc_wait_for_cmd(card->host, &cmd, 0);
+       if (err)
+               return err;
+
+       if (mmc_host_is_spi(card->host)) {
+               /* host driver already reported errors */
+       } else {
+               if (cmd.resp[0] & R5_ERROR)
+                       return -EIO;
+               if (cmd.resp[0] & R5_FUNCTION_NUMBER)
+                       return -EINVAL;
+               if (cmd.resp[0] & R5_OUT_OF_RANGE)
+                       return -ERANGE;
+       }
+
+       if (out) {
+               if (mmc_host_is_spi(card->host))
+                       *out = (cmd.resp[0] >> 8) & 0xFF;
+               else
+                       *out = cmd.resp[0] & 0xFF;
+       }
+
+       return 0;
+}
+
+int mmc_io_rw_extended(struct mmc_card *card, int write, unsigned fn,
+       unsigned addr, int incr_addr, u8 *buf, unsigned blocks, unsigned blksz)
+{
+       struct mmc_request mrq;
+       struct mmc_command cmd;
+       struct mmc_data data;
+       struct scatterlist sg;
+
+       BUG_ON(!card);
+       BUG_ON(fn > 7);
+       BUG_ON(blocks == 1 && blksz > 512);
+       WARN_ON(blocks == 0);
+       WARN_ON(blksz == 0);
+
+       memset(&mrq, 0, sizeof(struct mmc_request));
+       memset(&cmd, 0, sizeof(struct mmc_command));
+       memset(&data, 0, sizeof(struct mmc_data));
+
+       mrq.cmd = &cmd;
+       mrq.data = &data;
+
+       cmd.opcode = SD_IO_RW_EXTENDED;
+       cmd.arg = write ? 0x80000000 : 0x00000000;
+       cmd.arg |= fn << 28;
+       cmd.arg |= incr_addr ? 0x04000000 : 0x00000000;
+       cmd.arg |= addr << 9;
+       if (blocks == 1 && blksz <= 512)
+               cmd.arg |= (blksz == 512) ? 0 : blksz;  /* byte mode */
+       else
+               cmd.arg |= 0x08000000 | blocks;         /* block mode */
+       cmd.flags = MMC_RSP_SPI_R5 | MMC_RSP_R5 | MMC_CMD_ADTC;
+
+       data.blksz = blksz;
+       data.blocks = blocks;
+       data.flags = write ? MMC_DATA_WRITE : MMC_DATA_READ;
+       data.sg = &sg;
+       data.sg_len = 1;
+
+       sg_init_one(&sg, buf, blksz * blocks);
+
+       mmc_set_data_timeout(&data, card);
+
+       mmc_wait_for_req(card->host, &mrq);
+
+       if (cmd.error)
+               return cmd.error;
+       if (data.error)
+               return data.error;
+
+       if (mmc_host_is_spi(card->host)) {
+               /* host driver already reported errors */
+       } else {
+               if (cmd.resp[0] & R5_ERROR)
+                       return -EIO;
+               if (cmd.resp[0] & R5_FUNCTION_NUMBER)
+                       return -EINVAL;
+               if (cmd.resp[0] & R5_OUT_OF_RANGE)
+                       return -ERANGE;
+       }
+
+       return 0;
+}
+
--- /dev/null
+++ b/drivers/mmc/core/sdio_ops.h
@@ -0,0 +1,22 @@
+/*
+ *  linux/drivers/mmc/sdio_ops.c
+ *
+ *  Copyright 2006-2007 Pierre Ossman
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at
+ * your option) any later version.
+ */
+
+#ifndef _MMC_SDIO_OPS_H
+#define _MMC_SDIO_OPS_H
+
+int mmc_send_io_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr);
+int mmc_io_rw_direct(struct mmc_card *card, int write, unsigned fn,
+       unsigned addr, u8 in, u8* out);
+int mmc_io_rw_extended(struct mmc_card *card, int write, unsigned fn,
+       unsigned addr, int incr_addr, u8 *buf, unsigned blocks, unsigned blksz);
+
+#endif
+
--- a/include/linux/mmc/card.h
+++ b/include/linux/mmc/card.h
@@ -55,7 +55,28 @@
        unsigned int            hs_max_dtr;
 };
 
+struct sdio_cccr {
+       unsigned int            sdio_vsn;
+       unsigned int            sd_vsn;
+       unsigned int            multi_block:1,
+                               low_speed:1,
+                               wide_bus:1,
+                               high_power:1,
+                               high_speed:1;
+};
+
+struct sdio_cis {
+       unsigned short          vendor;
+       unsigned short          device;
+       unsigned short          blksize;
+       unsigned int            max_dtr;
+};
+
 struct mmc_host;
+struct sdio_func;
+struct sdio_func_tuple;
+
+#define SDIO_MAX_FUNCS         7
 
 /*
  * MMC device
@@ -67,11 +88,13 @@
        unsigned int            type;           /* card type */
 #define MMC_TYPE_MMC           0               /* MMC card */
 #define MMC_TYPE_SD            1               /* SD card */
+#define MMC_TYPE_SDIO          2               /* SDIO card */
        unsigned int            state;          /* (our) card state */
 #define MMC_STATE_PRESENT      (1<<0)          /* present in sysfs */
 #define MMC_STATE_READONLY     (1<<1)          /* card is read-only */
 #define MMC_STATE_HIGHSPEED    (1<<2)          /* card is in high speed mode */
 #define MMC_STATE_BLOCKADDR    (1<<3)          /* card uses block-addressing */
+
        u32                     raw_cid[4];     /* raw card CID */
        u32                     raw_csd[4];     /* raw card CSD */
        u32                     raw_scr[2];     /* raw card SCR */
@@ -80,10 +103,19 @@
        struct mmc_ext_csd      ext_csd;        /* mmc v4 extended card specific */
        struct sd_scr           scr;            /* extra SD information */
        struct sd_switch_caps   sw_caps;        /* switch (CMD6) caps */
+
+       unsigned int            sdio_funcs;     /* number of SDIO functions */
+       struct sdio_cccr        cccr;           /* common card info */
+       struct sdio_cis         cis;            /* common tuple info */
+       struct sdio_func        *sdio_func[SDIO_MAX_FUNCS]; /* SDIO functions (devices) */
+       unsigned                num_info;       /* number of info strings */
+       const char              **info;         /* info strings */
+       struct sdio_func_tuple  *tuples;        /* unknown common tuples */
 };
 
 #define mmc_card_mmc(c)                ((c)->type == MMC_TYPE_MMC)
 #define mmc_card_sd(c)         ((c)->type == MMC_TYPE_SD)
+#define mmc_card_sdio(c)       ((c)->type == MMC_TYPE_SDIO)
 
 #define mmc_card_present(c)    ((c)->state & MMC_STATE_PRESENT)
 #define mmc_card_readonly(c)   ((c)->state & MMC_STATE_READONLY)
--- a/include/linux/mmc/core.h
+++ b/include/linux/mmc/core.h
@@ -25,14 +25,20 @@
 #define MMC_RSP_CRC    (1 << 2)                /* expect valid crc */
 #define MMC_RSP_BUSY   (1 << 3)                /* card may send busy */
 #define MMC_RSP_OPCODE (1 << 4)                /* response contains opcode */
-#define MMC_CMD_MASK   (3 << 5)                /* command type */
+
+#define MMC_CMD_MASK   (3 << 5)                /* non-SPI command type */
 #define MMC_CMD_AC     (0 << 5)
 #define MMC_CMD_ADTC   (1 << 5)
 #define MMC_CMD_BC     (2 << 5)
 #define MMC_CMD_BCR    (3 << 5)
 
+#define MMC_RSP_SPI_S1 (1 << 7)                /* one status byte */
+#define MMC_RSP_SPI_S2 (1 << 8)                /* second byte */
+#define MMC_RSP_SPI_B4 (1 << 9)                /* four data bytes */
+#define MMC_RSP_SPI_BUSY (1 << 10)             /* card may send busy */
+
 /*
- * These are the response types, and correspond to valid bit
+ * These are the native response types, and correspond to valid bit
  * patterns of the above flags.  One additional valid pattern
  * is all zeros, which means we don't expect a response.
  */
@@ -41,12 +47,30 @@
 #define MMC_RSP_R1B    (MMC_RSP_PRESENT|MMC_RSP_CRC|MMC_RSP_OPCODE|MMC_RSP_BUSY)
 #define MMC_RSP_R2     (MMC_RSP_PRESENT|MMC_RSP_136|MMC_RSP_CRC)
 #define MMC_RSP_R3     (MMC_RSP_PRESENT)
+#define MMC_RSP_R4     (MMC_RSP_PRESENT)
+#define MMC_RSP_R5     (MMC_RSP_PRESENT|MMC_RSP_CRC|MMC_RSP_OPCODE)
 #define MMC_RSP_R6     (MMC_RSP_PRESENT|MMC_RSP_CRC|MMC_RSP_OPCODE)
 #define MMC_RSP_R7     (MMC_RSP_PRESENT|MMC_RSP_CRC|MMC_RSP_OPCODE)
 
 #define mmc_resp_type(cmd)     ((cmd)->flags & (MMC_RSP_PRESENT|MMC_RSP_136|MMC_RSP_CRC|MMC_RSP_BUSY|MMC_RSP_OPCODE))
 
 /*
+ * These are the SPI response types for MMC, SD, and SDIO cards.
+ * Commands return R1, with maybe more info.  Zero is an error type;
+ * callers must always provide the appropriate MMC_RSP_SPI_Rx flags.
+ */
+#define MMC_RSP_SPI_R1 (MMC_RSP_SPI_S1)
+#define MMC_RSP_SPI_R1B        (MMC_RSP_SPI_S1|MMC_RSP_SPI_BUSY)
+#define MMC_RSP_SPI_R2 (MMC_RSP_SPI_S1|MMC_RSP_SPI_S2)
+#define MMC_RSP_SPI_R3 (MMC_RSP_SPI_S1|MMC_RSP_SPI_B4)
+#define MMC_RSP_SPI_R4 (MMC_RSP_SPI_S1|MMC_RSP_SPI_B4)
+#define MMC_RSP_SPI_R5 (MMC_RSP_SPI_S1|MMC_RSP_SPI_S2)
+#define MMC_RSP_SPI_R7 (MMC_RSP_SPI_S1|MMC_RSP_SPI_B4)
+
+#define mmc_spi_resp_type(cmd) ((cmd)->flags & \
+               (MMC_RSP_SPI_S1|MMC_RSP_SPI_BUSY|MMC_RSP_SPI_S2|MMC_RSP_SPI_B4))
+
+/*
  * These are the command types.
  */
 #define mmc_cmd_type(cmd)      ((cmd)->flags & MMC_CMD_MASK)
@@ -54,12 +78,19 @@
        unsigned int            retries;        /* max number of retries */
        unsigned int            error;          /* command error */
 
-#define MMC_ERR_NONE   0
-#define MMC_ERR_TIMEOUT        1
-#define MMC_ERR_BADCRC 2
-#define MMC_ERR_FIFO   3
-#define MMC_ERR_FAILED 4
-#define MMC_ERR_INVALID        5
+/*
+ * Standard errno values are used for errors, but some have specific
+ * meaning in the MMC layer:
+ *
+ * ETIMEDOUT    Card took too long to respond
+ * EILSEQ       Basic format problem with the received or sent data
+ *              (e.g. CRC check failed, incorrect opcode in response
+ *              or bad end bit)
+ * EINVAL       Request cannot be performed because of restrictions
+ *              in hardware and/or the driver
+ * ENOMEDIUM    Host can determine that the slot is empty and is
+ *              actively failing requests
+ */
 
        struct mmc_data         *data;          /* data segment associated with cmd */
        struct mmc_request      *mrq;           /* associated request */
@@ -76,7 +107,6 @@
 #define MMC_DATA_WRITE (1 << 8)
 #define MMC_DATA_READ  (1 << 9)
 #define MMC_DATA_STREAM        (1 << 10)
-#define MMC_DATA_MULTI (1 << 11)
 
        unsigned int            bytes_xfered;
 
@@ -104,9 +134,20 @@
 extern int mmc_wait_for_app_cmd(struct mmc_host *, struct mmc_card *,
        struct mmc_command *, int);
 
-extern void mmc_set_data_timeout(struct mmc_data *, const struct mmc_card *, int);
+extern void mmc_set_data_timeout(struct mmc_data *, const struct mmc_card *);
 
-extern void mmc_claim_host(struct mmc_host *host);
+extern int __mmc_claim_host(struct mmc_host *host, atomic_t *abort);
 extern void mmc_release_host(struct mmc_host *host);
 
+/**
+ *     mmc_claim_host - exclusively claim a host
+ *     @host: mmc host to claim
+ *
+ *     Claim a host for a set of operations.
+ */
+static inline void mmc_claim_host(struct mmc_host *host)
+{
+       __mmc_claim_host(host, NULL);
+}
+
 #endif
--- a/include/linux/mmc/host.h
+++ b/include/linux/mmc/host.h
@@ -10,6 +10,8 @@
 #ifndef LINUX_MMC_HOST_H
 #define LINUX_MMC_HOST_H
 
+#include <linux/leds.h>
+
 #include <linux/mmc/core.h>
 
 struct mmc_ios {
@@ -51,6 +53,7 @@
        void    (*request)(struct mmc_host *host, struct mmc_request *req);
        void    (*set_ios)(struct mmc_host *host, struct mmc_ios *ios);
        int     (*get_ro)(struct mmc_host *host);
+       void    (*enable_sdio_irq)(struct mmc_host *host, int enable);
 };
 
 struct mmc_card;
@@ -87,9 +90,10 @@
 
 #define MMC_CAP_4_BIT_DATA     (1 << 0)        /* Can the host do 4 bit transfers */
 #define MMC_CAP_MULTIWRITE     (1 << 1)        /* Can accurately report bytes sent to card on error */
-#define MMC_CAP_BYTEBLOCK      (1 << 2)        /* Can do non-log2 block sizes */
-#define MMC_CAP_MMC_HIGHSPEED  (1 << 3)        /* Can do MMC high-speed timing */
-#define MMC_CAP_SD_HIGHSPEED   (1 << 4)        /* Can do SD high-speed timing */
+#define MMC_CAP_MMC_HIGHSPEED  (1 << 2)        /* Can do MMC high-speed timing */
+#define MMC_CAP_SD_HIGHSPEED   (1 << 3)        /* Can do SD high-speed timing */
+#define MMC_CAP_SDIO_IRQ       (1 << 4)        /* Can signal pending SDIO IRQs */
+#define MMC_CAP_SPI            (1 << 5)        /* Talks only SPI protocols */
 
        /* host specific block data */
        unsigned int            max_seg_size;   /* see blk_queue_max_segment_size */
@@ -106,23 +110,30 @@
        struct mmc_ios          ios;            /* current io bus settings */
        u32                     ocr;            /* the current OCR setting */
 
-       unsigned int            mode;           /* current card mode of host */
-#define MMC_MODE_MMC           0
-#define MMC_MODE_SD            1
+       /* group bitfields together to minimize padding */
+       unsigned int            use_spi_crc:1;
+       unsigned int            claimed:1;      /* host exclusively claimed */
+       unsigned int            bus_dead:1;     /* bus has been released */
+#ifdef CONFIG_MMC_DEBUG
+       unsigned int            removed:1;      /* host is being removed */
+#endif
 
        struct mmc_card         *card;          /* device attached to this host */
 
        wait_queue_head_t       wq;
-       unsigned int            claimed:1;      /* host exclusively claimed */
 
        struct delayed_work     detect;
-#ifdef CONFIG_MMC_DEBUG
-       unsigned int            removed:1;      /* host is being removed */
-#endif
 
        const struct mmc_bus_ops *bus_ops;      /* current bus driver */
        unsigned int            bus_refs;       /* reference counter */
-       unsigned int            bus_dead:1;     /* bus has been released */
+
+       unsigned int            sdio_irqs;
+       struct task_struct      *sdio_irq_thread;
+       atomic_t                sdio_irq_thread_abort;
+
+#ifdef CONFIG_LEDS_TRIGGERS
+       struct led_trigger      *led;           /* activity led */
+#endif
 
        unsigned long           private[0] ____cacheline_aligned;
 };
@@ -137,6 +148,8 @@
        return (void *)host->private;
 }
 
+#define mmc_host_is_spi(host)  ((host)->caps & MMC_CAP_SPI)
+
 #define mmc_dev(x)     ((x)->parent)
 #define mmc_classdev(x)        (&(x)->class_dev)
 #define mmc_hostname(x)        ((x)->class_dev.bus_id)
@@ -147,5 +160,11 @@
 extern void mmc_detect_change(struct mmc_host *, unsigned long delay);
 extern void mmc_request_done(struct mmc_host *, struct mmc_request *);
 
+static inline void mmc_signal_sdio_irq(struct mmc_host *host)
+{
+       host->ops->enable_sdio_irq(host, 0);
+       wake_up_process(host->sdio_irq_thread);
+}
+
 #endif
 
--- a/include/linux/mmc/mmc.h
+++ b/include/linux/mmc/mmc.h
@@ -27,7 +27,7 @@
 
 /* Standard MMC commands (4.1)           type  argument     response */
    /* class 1 */
-#define        MMC_GO_IDLE_STATE         0   /* bc                          */
+#define MMC_GO_IDLE_STATE         0   /* bc                          */
 #define MMC_SEND_OP_COND          1   /* bcr  [31:0] OCR         R3  */
 #define MMC_ALL_SEND_CID          2   /* bcr                     R2  */
 #define MMC_SET_RELATIVE_ADDR     3   /* ac   [31:16] RCA        R1  */
@@ -39,8 +39,10 @@
 #define MMC_SEND_CID             10   /* ac   [31:16] RCA        R2  */
 #define MMC_READ_DAT_UNTIL_STOP  11   /* adtc [31:0] dadr        R1  */
 #define MMC_STOP_TRANSMISSION    12   /* ac                      R1b */
-#define MMC_SEND_STATUS                 13   /* ac   [31:16] RCA        R1  */
+#define MMC_SEND_STATUS          13   /* ac   [31:16] RCA        R1  */
 #define MMC_GO_INACTIVE_STATE    15   /* ac   [31:16] RCA            */
+#define MMC_SPI_READ_OCR         58   /* spi                  spi_R3 */
+#define MMC_SPI_CRC_ON_OFF       59   /* spi  [0:0] flag      spi_R1 */
 
   /* class 2 */
 #define MMC_SET_BLOCKLEN         16   /* ac   [31:0] block len   R1  */
@@ -90,15 +92,15 @@
  */
 
 /*
-  MMC status in R1
+  MMC status in R1, for native mode (SPI bits are different)
   Type
-       e : error bit
+       e : error bit
        s : status bit
        r : detected and set for the actual command response
        x : detected and set during command execution. the host must poll
             the card by sending status command in order to read these bits.
   Clear condition
-       a : according to the card state
+       a : according to the card state
        b : always related to the previous command. Reception of
             a valid command will clear it (with a delay of one command)
        c : clear by read
@@ -124,10 +126,33 @@
 #define R1_CARD_ECC_DISABLED   (1 << 14)       /* sx, a */
 #define R1_ERASE_RESET         (1 << 13)       /* sr, c */
 #define R1_STATUS(x)            (x & 0xFFFFE000)
-#define R1_CURRENT_STATE(x)            ((x & 0x00001E00) >> 9) /* sx, b (4 bits) */
+#define R1_CURRENT_STATE(x)    ((x & 0x00001E00) >> 9) /* sx, b (4 bits) */
 #define R1_READY_FOR_DATA      (1 << 8)        /* sx, a */
 #define R1_APP_CMD             (1 << 5)        /* sr, c */
 
+/*
+ * MMC/SD in SPI mode reports R1 status always, and R2 for SEND_STATUS
+ * R1 is the low order byte; R2 is the next highest byte, when present.
+ */
+#define R1_SPI_IDLE            (1 << 0)
+#define R1_SPI_ERASE_RESET     (1 << 1)
+#define R1_SPI_ILLEGAL_COMMAND (1 << 2)
+#define R1_SPI_COM_CRC         (1 << 3)
+#define R1_SPI_ERASE_SEQ       (1 << 4)
+#define R1_SPI_ADDRESS         (1 << 5)
+#define R1_SPI_PARAMETER       (1 << 6)
+/* R1 bit 7 is always zero */
+#define R2_SPI_CARD_LOCKED     (1 << 8)
+#define R2_SPI_WP_ERASE_SKIP   (1 << 9)        /* or lock/unlock fail */
+#define R2_SPI_LOCK_UNLOCK_FAIL        R2_SPI_WP_ERASE_SKIP
+#define R2_SPI_ERROR           (1 << 10)
+#define R2_SPI_CC_ERROR                (1 << 11)
+#define R2_SPI_CARD_ECC_ERROR  (1 << 12)
+#define R2_SPI_WP_VIOLATION    (1 << 13)
+#define R2_SPI_ERASE_PARAM     (1 << 14)
+#define R2_SPI_OUT_OF_RANGE    (1 << 15)       /* or CSD overwrite */
+#define R2_SPI_CSD_OVERWRITE   R2_SPI_OUT_OF_RANGE
+
 /* These are unpacked versions of the actual responses */
 
 struct _mmc_csd {
@@ -182,6 +207,7 @@
  */
 #define CCC_BASIC              (1<<0)  /* (0) Basic protocol functions */
                                        /* (CMD0,1,2,3,4,7,9,10,12,13,15) */
+                                       /* (and for SPI, CMD58,59) */
 #define CCC_STREAM_READ                (1<<1)  /* (1) Stream read commands */
                                        /* (CMD11) */
 #define CCC_BLOCK_READ         (1<<2)  /* (2) Block read commands */
@@ -227,6 +253,7 @@
 #define EXT_CSD_BUS_WIDTH      183     /* R/W */
 #define EXT_CSD_HS_TIMING      185     /* R/W */
 #define EXT_CSD_CARD_TYPE      196     /* RO */
+#define EXT_CSD_REV            192     /* RO */
 #define EXT_CSD_SEC_CNT                212     /* RO, 4 bytes */
 
 /*
--- /dev/null
+++ b/include/linux/mmc/sdio.h
@@ -0,0 +1,159 @@
+/*
+ *  include/linux/mmc/sdio.h
+ *
+ *  Copyright 2006-2007 Pierre Ossman
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at
+ * your option) any later version.
+ */
+
+#ifndef MMC_SDIO_H
+#define MMC_SDIO_H
+
+/* SDIO commands                         type  argument     response */
+#define SD_IO_SEND_OP_COND          5 /* bcr  [23:0] OCR         R4  */
+#define SD_IO_RW_DIRECT            52 /* ac   [31:0] See below   R5  */
+#define SD_IO_RW_EXTENDED          53 /* adtc [31:0] See below   R5  */
+
+/*
+ * SD_IO_RW_DIRECT argument format:
+ *
+ *      [31] R/W flag
+ *      [30:28] Function number
+ *      [27] RAW flag
+ *      [25:9] Register address
+ *      [7:0] Data
+ */
+
+/*
+ * SD_IO_RW_EXTENDED argument format:
+ *
+ *      [31] R/W flag
+ *      [30:28] Function number
+ *      [27] Block mode
+ *      [26] Increment address
+ *      [25:9] Register address
+ *      [8:0] Byte/block count
+ */
+
+/*
+  SDIO status in R5
+  Type
+       e : error bit
+       s : status bit
+       r : detected and set for the actual command response
+       x : detected and set during command execution. the host must poll
+            the card by sending status command in order to read these bits.
+  Clear condition
+       a : according to the card state
+       b : always related to the previous command. Reception of
+            a valid command will clear it (with a delay of one command)
+       c : clear by read
+ */
+
+#define R5_COM_CRC_ERROR       (1 << 15)       /* er, b */
+#define R5_ILLEGAL_COMMAND     (1 << 14)       /* er, b */
+#define R5_ERROR               (1 << 11)       /* erx, c */
+#define R5_FUNCTION_NUMBER     (1 << 9)        /* er, c */
+#define R5_OUT_OF_RANGE                (1 << 8)        /* er, c */
+#define R5_STATUS(x)           (x & 0xCB00)
+#define R5_IO_CURRENT_STATE(x) ((x & 0x3000) >> 12) /* s, b */
+
+/*
+ * Card Common Control Registers (CCCR)
+ */
+
+#define SDIO_CCCR_CCCR         0x00
+
+#define  SDIO_CCCR_REV_1_00    0       /* CCCR/FBR Version 1.00 */
+#define  SDIO_CCCR_REV_1_10    1       /* CCCR/FBR Version 1.10 */
+#define  SDIO_CCCR_REV_1_20    2       /* CCCR/FBR Version 1.20 */
+
+#define  SDIO_SDIO_REV_1_00    0       /* SDIO Spec Version 1.00 */
+#define  SDIO_SDIO_REV_1_10    1       /* SDIO Spec Version 1.10 */
+#define  SDIO_SDIO_REV_1_20    2       /* SDIO Spec Version 1.20 */
+#define  SDIO_SDIO_REV_2_00    3       /* SDIO Spec Version 2.00 */
+
+#define SDIO_CCCR_SD           0x01
+
+#define  SDIO_SD_REV_1_01      0       /* SD Physical Spec Version 1.01 */
+#define  SDIO_SD_REV_1_10      1       /* SD Physical Spec Version 1.10 */
+#define  SDIO_SD_REV_2_00      2       /* SD Physical Spec Version 2.00 */
+
+#define SDIO_CCCR_IOEx         0x02
+#define SDIO_CCCR_IORx         0x03
+
+#define SDIO_CCCR_IENx         0x04    /* Function/Master Interrupt Enable */
+#define SDIO_CCCR_INTx         0x05    /* Function Interrupt Pending */
+
+#define SDIO_CCCR_ABORT                0x06    /* function abort/card reset */
+
+#define SDIO_CCCR_IF           0x07    /* bus interface controls */
+
+#define  SDIO_BUS_WIDTH_1BIT   0x00
+#define  SDIO_BUS_WIDTH_4BIT   0x02
+
+#define  SDIO_BUS_CD_DISABLE     0x80  /* disable pull-up on DAT3 (pin 1) */
+
+#define SDIO_CCCR_CAPS         0x08
+
+#define  SDIO_CCCR_CAP_SDC     0x01    /* can do CMD52 while data transfer */
+#define  SDIO_CCCR_CAP_SMB     0x02    /* can do multi-block xfers (CMD53) */
+#define  SDIO_CCCR_CAP_SRW     0x04    /* supports read-wait protocol */
+#define  SDIO_CCCR_CAP_SBS     0x08    /* supports suspend/resume */
+#define  SDIO_CCCR_CAP_S4MI    0x10    /* interrupt during 4-bit CMD53 */
+#define  SDIO_CCCR_CAP_E4MI    0x20    /* enable ints during 4-bit CMD53 */
+#define  SDIO_CCCR_CAP_LSC     0x40    /* low speed card */
+#define  SDIO_CCCR_CAP_4BLS    0x80    /* 4 bit low speed card */
+
+#define SDIO_CCCR_CIS          0x09    /* common CIS pointer (3 bytes) */
+
+/* Following 4 regs are valid only if SBS is set */
+#define SDIO_CCCR_SUSPEND      0x0c
+#define SDIO_CCCR_SELx         0x0d
+#define SDIO_CCCR_EXECx                0x0e
+#define SDIO_CCCR_READYx       0x0f
+
+#define SDIO_CCCR_BLKSIZE      0x10
+
+#define SDIO_CCCR_POWER                0x12
+
+#define  SDIO_POWER_SMPC       0x01    /* Supports Master Power Control */
+#define  SDIO_POWER_EMPC       0x02    /* Enable Master Power Control */
+
+#define SDIO_CCCR_SPEED                0x13
+
+#define  SDIO_SPEED_SHS                0x01    /* Supports High-Speed mode */
+#define  SDIO_SPEED_EHS                0x02    /* Enable High-Speed mode */
+
+/*
+ * Function Basic Registers (FBR)
+ */
+
+#define SDIO_FBR_BASE(f)       ((f) * 0x100) /* base of function f's FBRs */
+
+#define SDIO_FBR_STD_IF                0x00
+
+#define  SDIO_FBR_SUPPORTS_CSA 0x40    /* supports Code Storage Area */
+#define  SDIO_FBR_ENABLE_CSA   0x80    /* enable Code Storage Area */
+
+#define SDIO_FBR_STD_IF_EXT    0x01
+
+#define SDIO_FBR_POWER         0x02
+
+#define  SDIO_FBR_POWER_SPS    0x01    /* Supports Power Selection */
+#define  SDIO_FBR_POWER_EPS    0x02    /* Enable (low) Power Selection */
+
+#define SDIO_FBR_CIS           0x09    /* CIS pointer (3 bytes) */
+
+
+#define SDIO_FBR_CSA           0x0C    /* CSA pointer (3 bytes) */
+
+#define SDIO_FBR_CSA_DATA      0x0F
+
+#define SDIO_FBR_BLKSIZE       0x10    /* block size (2 bytes) */
+
+#endif
+
--- /dev/null
+++ b/include/linux/mmc/sdio_func.h
@@ -0,0 +1,153 @@
+/*
+ *  include/linux/mmc/sdio_func.h
+ *
+ *  Copyright 2007 Pierre Ossman
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at
+ * your option) any later version.
+ */
+
+#ifndef MMC_SDIO_FUNC_H
+#define MMC_SDIO_FUNC_H
+
+#include <linux/device.h>
+#include <linux/mod_devicetable.h>
+
+struct mmc_card;
+struct sdio_func;
+
+typedef void (sdio_irq_handler_t)(struct sdio_func *);
+
+/*
+ * SDIO function CIS tuple (unknown to the core)
+ */
+struct sdio_func_tuple {
+       struct sdio_func_tuple *next;
+       unsigned char code;
+       unsigned char size;
+       unsigned char data[0];
+};
+
+/*
+ * SDIO function devices
+ */
+struct sdio_func {
+       struct mmc_card         *card;          /* the card this device belongs to */
+       struct device           dev;            /* the device */
+       sdio_irq_handler_t      *irq_handler;   /* IRQ callback */
+       unsigned int            num;            /* function number */
+
+       unsigned char           class;          /* standard interface class */
+       unsigned short          vendor;         /* vendor id */
+       unsigned short          device;         /* device id */
+
+       unsigned                max_blksize;    /* maximum block size */
+       unsigned                cur_blksize;    /* current block size */
+
+       unsigned int            state;          /* function state */
+#define SDIO_STATE_PRESENT     (1<<0)          /* present in sysfs */
+
+       u8                      tmpbuf[4];      /* DMA:able scratch buffer */
+
+       unsigned                num_info;       /* number of info strings */
+       const char              **info;         /* info strings */
+
+       struct sdio_func_tuple *tuples;
+};
+
+#define sdio_func_present(f)   ((f)->state & SDIO_STATE_PRESENT)
+
+#define sdio_func_set_present(f) ((f)->state |= SDIO_STATE_PRESENT)
+
+#define sdio_func_id(f)                ((f)->dev.bus_id)
+
+#define sdio_get_drvdata(f)    dev_get_drvdata(&(f)->dev)
+#define sdio_set_drvdata(f,d)  dev_set_drvdata(&(f)->dev, d)
+
+/*
+ * SDIO function device driver
+ */
+struct sdio_driver {
+       char *name;
+       const struct sdio_device_id *id_table;
+
+       int (*probe)(struct sdio_func *, const struct sdio_device_id *);
+       void (*remove)(struct sdio_func *);
+
+       struct device_driver drv;
+};
+
+/**
+ * SDIO_DEVICE - macro used to describe a specific SDIO device
+ * @vend: the 16 bit manufacturer code
+ * @dev: the 16 bit function id
+ *
+ * This macro is used to create a struct sdio_device_id that matches a
+ * specific device. The class field will be set to SDIO_ANY_ID.
+ */
+#define SDIO_DEVICE(vend,dev) \
+       .class = SDIO_ANY_ID, \
+       .vendor = (vend), .device = (dev)
+
+/**
+ * SDIO_DEVICE_CLASS - macro used to describe a specific SDIO device class
+ * @dev_class: the 8 bit standard interface code
+ *
+ * This macro is used to create a struct sdio_device_id that matches a
+ * specific standard SDIO function type.  The vendor and device fields will
+ * be set to SDIO_ANY_ID.
+ */
+#define SDIO_DEVICE_CLASS(dev_class) \
+       .class = (dev_class), \
+       .vendor = SDIO_ANY_ID, .device = SDIO_ANY_ID
+
+extern int sdio_register_driver(struct sdio_driver *);
+extern void sdio_unregister_driver(struct sdio_driver *);
+
+/*
+ * SDIO I/O operations
+ */
+extern void sdio_claim_host(struct sdio_func *func);
+extern void sdio_release_host(struct sdio_func *func);
+
+extern int sdio_enable_func(struct sdio_func *func);
+extern int sdio_disable_func(struct sdio_func *func);
+
+extern int sdio_set_block_size(struct sdio_func *func, unsigned blksz);
+
+extern int sdio_claim_irq(struct sdio_func *func, sdio_irq_handler_t *handler);
+extern int sdio_release_irq(struct sdio_func *func);
+
+extern unsigned char sdio_readb(struct sdio_func *func,
+       unsigned int addr, int *err_ret);
+extern unsigned short sdio_readw(struct sdio_func *func,
+       unsigned int addr, int *err_ret);
+extern unsigned long sdio_readl(struct sdio_func *func,
+       unsigned int addr, int *err_ret);
+
+extern int sdio_memcpy_fromio(struct sdio_func *func, void *dst,
+       unsigned int addr, int count);
+extern int sdio_readsb(struct sdio_func *func, void *dst,
+       unsigned int addr, int count);
+
+extern void sdio_writeb(struct sdio_func *func, unsigned char b,
+       unsigned int addr, int *err_ret);
+extern void sdio_writew(struct sdio_func *func, unsigned short b,
+       unsigned int addr, int *err_ret);
+extern void sdio_writel(struct sdio_func *func, unsigned long b,
+       unsigned int addr, int *err_ret);
+
+extern int sdio_memcpy_toio(struct sdio_func *func, unsigned int addr,
+       void *src, int count);
+extern int sdio_writesb(struct sdio_func *func, unsigned int addr,
+       void *src, int count);
+
+extern unsigned char sdio_f0_readb(struct sdio_func *func,
+       unsigned int addr, int *err_ret);
+extern void sdio_f0_writeb(struct sdio_func *func, unsigned char b,
+       unsigned int addr, int *err_ret);
+
+#endif
+
--- /dev/null
+++ b/include/linux/mmc/sdio_ids.h
@@ -0,0 +1,29 @@
+/*
+ * SDIO Classes, Interface Types, Manufacturer IDs, etc.
+ */
+
+#ifndef MMC_SDIO_IDS_H
+#define MMC_SDIO_IDS_H
+
+/*
+ * Standard SDIO Function Interfaces
+ */
+
+#define SDIO_CLASS_NONE                0x00    /* Not a SDIO standard interface */
+#define SDIO_CLASS_UART                0x01    /* standard UART interface */
+#define SDIO_CLASS_BT_A                0x02    /* Type-A BlueTooth std interface */
+#define SDIO_CLASS_BT_B                0x03    /* Type-B BlueTooth std interface */
+#define SDIO_CLASS_GPS         0x04    /* GPS standard interface */
+#define SDIO_CLASS_CAMERA      0x05    /* Camera standard interface */
+#define SDIO_CLASS_PHS         0x06    /* PHS standard interface */
+#define SDIO_CLASS_WLAN                0x07    /* WLAN interface */
+#define SDIO_CLASS_ATA         0x08    /* Embedded SDIO-ATA std interface */
+
+/*
+ * Vendors and devices.  Sort key: vendor first, device next.
+ */
+
+#define SDIO_VENDOR_ID_MARVELL                 0x02df
+#define SDIO_DEVICE_ID_MARVELL_LIBERTAS                0x9103
+
+#endif
--- a/include/linux/mod_devicetable.h
+++ b/include/linux/mod_devicetable.h
@@ -22,6 +22,18 @@
 };
 
 
+/* SDIO */
+
+#define SDIO_ANY_ID (~0)
+
+struct sdio_device_id {
+       __u8    class;                  /* Standard interface or SDIO_ANY_ID */
+       __u16   vendor;                 /* Vendor or SDIO_ANY_ID */
+       __u16   device;                 /* Device ID or SDIO_ANY_ID */
+       kernel_ulong_t driver_data;     /* Data private to the driver */
+};
+
+
 #define IEEE1394_MATCH_VENDOR_ID       0x0001
 #define IEEE1394_MATCH_MODEL_ID                0x0002
 #define IEEE1394_MATCH_SPECIFIER_ID    0x0004
--- a/drivers/mmc/card/Kconfig
+++ b/drivers/mmc/card/Kconfig
@@ -32,3 +32,10 @@
 
          If unsure, say Y here.
 
+config SDIO_UART
+       tristate "SDIO UART/GPS class support"
+       depends on MMC
+       help
+         SDIO function driver for SDIO cards that implements the UART
+         class, as well as the GPS class which appears like a UART.
+
--- a/drivers/mmc/card/Makefile
+++ b/drivers/mmc/card/Makefile
@@ -9,3 +9,5 @@
 obj-$(CONFIG_MMC_BLOCK)                += mmc_block.o
 mmc_block-objs                 := block.o queue.o
 
+obj-$(CONFIG_SDIO_UART)                += sdio_uart.o
+
--- a/drivers/mmc/card/block.c
+++ b/drivers/mmc/card/block.c
@@ -44,6 +44,9 @@
  * max 8 partitions per card
  */
 #define MMC_SHIFT      3
+#define MMC_NUM_MINORS (256 >> MMC_SHIFT)
+
+static unsigned long dev_use[MMC_NUM_MINORS/(8*sizeof(unsigned long))];
 
 /*
  * There is one mmc_blk_data per slot.
@@ -80,6 +83,9 @@
        mutex_lock(&open_lock);
        md->usage--;
        if (md->usage == 0) {
+               int devidx = md->disk->first_minor >> MMC_SHIFT;
+               __clear_bit(devidx, dev_use);
+
                put_disk(md->disk);
                kfree(md);
        }
@@ -151,17 +157,19 @@
 
        cmd.opcode = MMC_APP_CMD;
        cmd.arg = card->rca << 16;
-       cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
+       cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
 
        err = mmc_wait_for_cmd(card->host, &cmd, 0);
-       if ((err != MMC_ERR_NONE) || !(cmd.resp[0] & R1_APP_CMD))
+       if (err)
+               return (u32)-1;
+       if (!mmc_host_is_spi(card->host) && !(cmd.resp[0] & R1_APP_CMD))
                return (u32)-1;
 
        memset(&cmd, 0, sizeof(struct mmc_command));
 
        cmd.opcode = SD_APP_SEND_NUM_WR_BLKS;
        cmd.arg = 0;
-       cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
+       cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
 
        memset(&data, 0, sizeof(struct mmc_data));
 
@@ -192,7 +200,7 @@
 
        mmc_wait_for_req(card->host, &mrq);
 
-       if (cmd.error != MMC_ERR_NONE || data.error != MMC_ERR_NONE)
+       if (cmd.error || data.error)
                return (u32)-1;
 
        blocks = ntohl(blocks);
@@ -220,17 +228,15 @@
                brq.cmd.arg = req->sector;
                if (!mmc_card_blockaddr(card))
                        brq.cmd.arg <<= 9;
-               brq.cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
+               brq.cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
                brq.data.blksz = 1 << md->block_bits;
                brq.stop.opcode = MMC_STOP_TRANSMISSION;
                brq.stop.arg = 0;
-               brq.stop.flags = MMC_RSP_R1B | MMC_CMD_AC;
+               brq.stop.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
                brq.data.blocks = req->nr_sectors >> (md->block_bits - 9);
                if (brq.data.blocks > card->host->max_blk_count)
                        brq.data.blocks = card->host->max_blk_count;
 
-               mmc_set_data_timeout(&brq.data, card, rq_data_dir(req) != READ);
-
                /*
                 * If the host doesn't support multiple block writes, force
                 * block writes to single block. SD cards are excepted from
@@ -243,8 +249,12 @@
                        brq.data.blocks = 1;
 
                if (brq.data.blocks > 1) {
-                       brq.data.flags |= MMC_DATA_MULTI;
-                       brq.mrq.stop = &brq.stop;
+                       /* SPI multiblock writes terminate using a special
+                        * token, not a STOP_TRANSMISSION request.
+                        */
+                       if (!mmc_host_is_spi(card->host)
+                                       || rq_data_dir(req) == READ)
+                               brq.mrq.stop = &brq.stop;
                        readcmd = MMC_READ_MULTIPLE_BLOCK;
                        writecmd = MMC_WRITE_MULTIPLE_BLOCK;
                } else {
@@ -261,6 +271,8 @@
                        brq.data.flags |= MMC_DATA_WRITE;
                }
 
+               mmc_set_data_timeout(&brq.data, card);
+
                brq.data.sg = mq->sg;
                brq.data.sg_len = mmc_queue_map_sg(mq);
 
@@ -302,7 +314,7 @@
                        goto cmd_err;
                }
 
-               if (rq_data_dir(req) != READ) {
+               if (!mmc_host_is_spi(card->host) && rq_data_dir(req) != READ) {
                        do {
                                int err;
 
@@ -315,7 +327,13 @@
                                               req->rq_disk->disk_name, err);
                                        goto cmd_err;
                                }
-                       } while (!(cmd.resp[0] & R1_READY_FOR_DATA));
+                               /*
+                                * Some cards mishandle the status bits,
+                                * so make sure to check both the busy
+                                * indication and the card state.
+                                */
+                       } while (!(cmd.resp[0] & R1_READY_FOR_DATA) ||
+                               (R1_CURRENT_STATE(cmd.resp[0]) == 7));
 
 #if 0
                        if (cmd.resp[0] & ~0x00000900)
@@ -394,9 +412,6 @@
        return 0;
 }
 
-#define MMC_NUM_MINORS (256 >> MMC_SHIFT)
-
-static unsigned long dev_use[MMC_NUM_MINORS/(8*sizeof(unsigned long))];
 
 static inline int mmc_blk_readonly(struct mmc_card *card)
 {
@@ -510,7 +525,7 @@
        mmc_claim_host(card->host);
        cmd.opcode = MMC_SET_BLOCKLEN;
        cmd.arg = 1 << md->block_bits;
-       cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
+       cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
        err = mmc_wait_for_cmd(card->host, &cmd, 5);
        mmc_release_host(card->host);
 
@@ -562,17 +577,12 @@
        struct mmc_blk_data *md = mmc_get_drvdata(card);
 
        if (md) {
-               int devidx;
-
                /* Stop new requests from getting into the queue */
                del_gendisk(md->disk);
 
                /* Then flush out any already in there */
                mmc_cleanup_queue(&md->queue);
 
-               devidx = md->disk->first_minor >> MMC_SHIFT;
-               __clear_bit(devidx, dev_use);
-
                mmc_blk_put(md);
        }
        mmc_set_drvdata(card, NULL);
--- a/drivers/mmc/card/queue.c
+++ b/drivers/mmc/card/queue.c
@@ -13,6 +13,7 @@
 #include <linux/blkdev.h>
 #include <linux/freezer.h>
 #include <linux/kthread.h>
+#include <linux/scatterlist.h>
 
 #include <linux/mmc/card.h>
 #include <linux/mmc/host.h>
@@ -22,6 +23,12 @@
 
 #define MMC_QUEUE_SUSPENDED    (1 << 0)
 
+#define sg_init_table(sg, n) do { \
+       memset(sg, 0, sizeof(*(sg)) * (n)); \
+} while (0)
+
+#define sg_virt(sg)    (page_address((sg)->page) + (sg)->offset)
+
 /*
  * Prepare a MMC request. This just filters out odd stuff.
  */
@@ -159,6 +166,7 @@
                                ret = -ENOMEM;
                                goto cleanup_queue;
                        }
+                       sg_init_table(mq->sg, 1);
 
                        mq->bounce_sg = kmalloc(sizeof(struct scatterlist) *
                                bouncesz / 512, GFP_KERNEL);
@@ -166,6 +174,7 @@
                                ret = -ENOMEM;
                                goto cleanup_queue;
                        }
+                       sg_init_table(mq->bounce_sg, bouncesz / 512);
                }
        }
 #endif
@@ -183,6 +192,7 @@
                        ret = -ENOMEM;
                        goto cleanup_queue;
                }
+               sg_init_table(mq->sg, host->max_phys_segs);
        }
 
        init_MUTEX(&mq->thread_sem);
@@ -302,12 +312,12 @@
                BUG_ON(dst_len == 0);
 
                if (dst_size == 0) {
-                       dst_buf = page_address(dst->page) + dst->offset;
+                       dst_buf = sg_virt(dst);
                        dst_size = dst->length;
                }
 
                if (src_size == 0) {
-                       src_buf = page_address(src->page) + src->offset;
+                       src_buf = sg_virt(src);
                        src_size = src->length;
                }
 
@@ -353,9 +363,7 @@
                return 1;
        }
 
-       mq->sg[0].page = virt_to_page(mq->bounce_buf);
-       mq->sg[0].offset = offset_in_page(mq->bounce_buf);
-       mq->sg[0].length = 0;
+       sg_init_one(mq->sg, mq->bounce_buf, 0);
 
        while (sg_len) {
                mq->sg[0].length += mq->bounce_sg[sg_len - 1].length;
--- /dev/null
+++ b/drivers/mmc/card/sdio_uart.c
@@ -0,0 +1,1158 @@
+/*
+ * linux/drivers/mmc/card/sdio_uart.c - SDIO UART/GPS driver
+ *
+ * Based on drivers/serial/8250.c and drivers/serial/serial_core.c
+ * by Russell King.
+ *
+ * Author:     Nicolas Pitre
+ * Created:    June 15, 2007
+ * Copyright:  MontaVista Software, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at
+ * your option) any later version.
+ */
+
+/*
+ * Note: Although this driver assumes a 16550A-like UART implementation,
+ * it is not possible to leverage the common 8250/16550 driver, nor the
+ * core UART infrastructure, as they assumes direct access to the hardware
+ * registers, often under a spinlock.  This is not possible in the SDIO
+ * context as SDIO access functions must be able to sleep.
+ *
+ * Because we need to lock the SDIO host to ensure an exclusive access to
+ * the card, we simply rely on that lock to also prevent and serialize
+ * concurrent access to the same port.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/mutex.h>
+#include <linux/serial_reg.h>
+#include <linux/circ_buf.h>
+#include <linux/gfp.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+
+#include <linux/mmc/core.h>
+#include <linux/mmc/card.h>
+#include <linux/mmc/sdio_func.h>
+#include <linux/mmc/sdio_ids.h>
+
+
+#define UART_NR                8       /* Number of UARTs this driver can handle */
+
+
+#define UART_XMIT_SIZE PAGE_SIZE
+#define WAKEUP_CHARS   256
+
+#define circ_empty(circ)       ((circ)->head == (circ)->tail)
+#define circ_clear(circ)       ((circ)->head = (circ)->tail = 0)
+
+#define circ_chars_pending(circ) \
+               (CIRC_CNT((circ)->head, (circ)->tail, UART_XMIT_SIZE))
+
+#define circ_chars_free(circ) \
+               (CIRC_SPACE((circ)->head, (circ)->tail, UART_XMIT_SIZE))
+
+
+struct uart_icount {
+       __u32   cts;
+       __u32   dsr;
+       __u32   rng;
+       __u32   dcd;
+       __u32   rx;
+       __u32   tx;
+       __u32   frame;
+       __u32   overrun;
+       __u32   parity;
+       __u32   brk;
+};
+
+struct sdio_uart_port {
+       struct kref             kref;
+       struct tty_struct       *tty;
+       unsigned int            index;
+       unsigned int            opened;
+       struct mutex            open_lock;
+       struct sdio_func        *func;
+       struct mutex            func_lock;
+       struct task_struct      *in_sdio_uart_irq;
+       unsigned int            regs_offset;
+       struct circ_buf         xmit;
+       spinlock_t              write_lock;
+       struct uart_icount      icount;
+       unsigned int            uartclk;
+       unsigned int            mctrl;
+       unsigned int            read_status_mask;
+       unsigned int            ignore_status_mask;
+       unsigned char           x_char;
+       unsigned char           ier;
+       unsigned char           lcr;
+};
+
+static struct sdio_uart_port *sdio_uart_table[UART_NR];
+static DEFINE_SPINLOCK(sdio_uart_table_lock);
+
+static int sdio_uart_add_port(struct sdio_uart_port *port)
+{
+       int index, ret = -EBUSY;
+
+       kref_init(&port->kref);
+       mutex_init(&port->open_lock);
+       mutex_init(&port->func_lock);
+       spin_lock_init(&port->write_lock);
+
+       spin_lock(&sdio_uart_table_lock);
+       for (index = 0; index < UART_NR; index++) {
+               if (!sdio_uart_table[index]) {
+                       port->index = index;
+                       sdio_uart_table[index] = port;
+                       ret = 0;
+                       break;
+               }
+       }
+       spin_unlock(&sdio_uart_table_lock);
+
+       return ret;
+}
+
+static struct sdio_uart_port *sdio_uart_port_get(unsigned index)
+{
+       struct sdio_uart_port *port;
+
+       if (index >= UART_NR)
+               return NULL;
+
+       spin_lock(&sdio_uart_table_lock);
+       port = sdio_uart_table[index];
+       if (port)
+               kref_get(&port->kref);
+       spin_unlock(&sdio_uart_table_lock);
+
+       return port;
+}
+
+static void sdio_uart_port_destroy(struct kref *kref)
+{
+       struct sdio_uart_port *port =
+               container_of(kref, struct sdio_uart_port, kref);
+       kfree(port);
+}
+
+static void sdio_uart_port_put(struct sdio_uart_port *port)
+{
+       kref_put(&port->kref, sdio_uart_port_destroy);
+}
+
+static void sdio_uart_port_remove(struct sdio_uart_port *port)
+{
+       struct sdio_func *func;
+
+       BUG_ON(sdio_uart_table[port->index] != port);
+
+       spin_lock(&sdio_uart_table_lock);
+       sdio_uart_table[port->index] = NULL;
+       spin_unlock(&sdio_uart_table_lock);
+
+       /*
+        * We're killing a port that potentially still is in use by
+        * the tty layer. Be careful to prevent any further access
+        * to the SDIO function and arrange for the tty layer to
+        * give up on that port ASAP.
+        * Beware: the lock ordering is critical.
+        */
+       mutex_lock(&port->open_lock);
+       mutex_lock(&port->func_lock);
+       func = port->func;
+       sdio_claim_host(func);
+       port->func = NULL;
+       mutex_unlock(&port->func_lock);
+       if (port->opened)
+               tty_hangup(port->tty);
+       mutex_unlock(&port->open_lock);
+       sdio_release_irq(func);
+       sdio_disable_func(func);
+       sdio_release_host(func);
+
+       sdio_uart_port_put(port);
+}
+
+static int sdio_uart_claim_func(struct sdio_uart_port *port)
+{
+       mutex_lock(&port->func_lock);
+       if (unlikely(!port->func)) {
+               mutex_unlock(&port->func_lock);
+               return -ENODEV;
+       }
+       if (likely(port->in_sdio_uart_irq != current))
+               sdio_claim_host(port->func);
+       mutex_unlock(&port->func_lock);
+       return 0;
+}
+
+static inline void sdio_uart_release_func(struct sdio_uart_port *port)
+{
+       if (likely(port->in_sdio_uart_irq != current))
+               sdio_release_host(port->func);
+}
+
+static inline unsigned int sdio_in(struct sdio_uart_port *port, int offset)
+{
+       unsigned char c;
+       c = sdio_readb(port->func, port->regs_offset + offset, NULL);
+       return c;
+}
+
+static inline void sdio_out(struct sdio_uart_port *port, int offset, int value)
+{
+       sdio_writeb(port->func, value, port->regs_offset + offset, NULL);
+}
+
+static unsigned int sdio_uart_get_mctrl(struct sdio_uart_port *port)
+{
+       unsigned char status;
+       unsigned int ret;
+
+       status = sdio_in(port, UART_MSR);
+
+       ret = 0;
+       if (status & UART_MSR_DCD)
+               ret |= TIOCM_CAR;
+       if (status & UART_MSR_RI)
+               ret |= TIOCM_RNG;
+       if (status & UART_MSR_DSR)
+               ret |= TIOCM_DSR;
+       if (status & UART_MSR_CTS)
+               ret |= TIOCM_CTS;
+       return ret;
+}
+
+static void sdio_uart_write_mctrl(struct sdio_uart_port *port, unsigned int mctrl)
+{
+       unsigned char mcr = 0;
+
+       if (mctrl & TIOCM_RTS)
+               mcr |= UART_MCR_RTS;
+       if (mctrl & TIOCM_DTR)
+               mcr |= UART_MCR_DTR;
+       if (mctrl & TIOCM_OUT1)
+               mcr |= UART_MCR_OUT1;
+       if (mctrl & TIOCM_OUT2)
+               mcr |= UART_MCR_OUT2;
+       if (mctrl & TIOCM_LOOP)
+               mcr |= UART_MCR_LOOP;
+
+       sdio_out(port, UART_MCR, mcr);
+}
+
+static inline void sdio_uart_update_mctrl(struct sdio_uart_port *port,
+                                         unsigned int set, unsigned int clear)
+{
+       unsigned int old;
+
+       old = port->mctrl;
+       port->mctrl = (old & ~clear) | set;
+       if (old != port->mctrl)
+               sdio_uart_write_mctrl(port, port->mctrl);
+}
+
+#define sdio_uart_set_mctrl(port, x)   sdio_uart_update_mctrl(port, x, 0)
+#define sdio_uart_clear_mctrl(port, x) sdio_uart_update_mctrl(port, 0, x)
+
+static void sdio_uart_change_speed(struct sdio_uart_port *port,
+                                  struct ktermios *termios,
+                                  struct ktermios *old)
+{
+       unsigned char cval, fcr = 0;
+       unsigned int baud, quot;
+
+       switch (termios->c_cflag & CSIZE) {
+       case CS5:
+               cval = UART_LCR_WLEN5;
+               break;
+       case CS6:
+               cval = UART_LCR_WLEN6;
+               break;
+       case CS7:
+               cval = UART_LCR_WLEN7;
+               break;
+       default:
+       case CS8:
+               cval = UART_LCR_WLEN8;
+               break;
+       }
+
+       if (termios->c_cflag & CSTOPB)
+               cval |= UART_LCR_STOP;
+       if (termios->c_cflag & PARENB)
+               cval |= UART_LCR_PARITY;
+       if (!(termios->c_cflag & PARODD))
+               cval |= UART_LCR_EPAR;
+
+       for (;;) {
+               baud = tty_termios_baud_rate(termios);
+               if (baud == 0)
+                       baud = 9600;  /* Special case: B0 rate. */
+               if (baud <= port->uartclk)
+                       break;
+               /*
+                * Oops, the quotient was zero.  Try again with the old
+                * baud rate if possible, otherwise default to 9600.
+                */
+               termios->c_cflag &= ~CBAUD;
+               if (old) {
+                       termios->c_cflag |= old->c_cflag & CBAUD;
+                       old = NULL;
+               } else
+                       termios->c_cflag |= B9600;
+       }
+       quot = (2 * port->uartclk + baud) / (2 * baud);
+
+       if (baud < 2400)
+               fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_1;
+       else
+               fcr = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10;
+
+       port->read_status_mask = UART_LSR_OE | UART_LSR_THRE | UART_LSR_DR;
+       if (termios->c_iflag & INPCK)
+               port->read_status_mask |= UART_LSR_FE | UART_LSR_PE;
+       if (termios->c_iflag & (BRKINT | PARMRK))
+               port->read_status_mask |= UART_LSR_BI;
+
+       /*
+        * Characters to ignore
+        */
+       port->ignore_status_mask = 0;
+       if (termios->c_iflag & IGNPAR)
+               port->ignore_status_mask |= UART_LSR_PE | UART_LSR_FE;
+       if (termios->c_iflag & IGNBRK) {
+               port->ignore_status_mask |= UART_LSR_BI;
+               /*
+                * If we're ignoring parity and break indicators,
+                * ignore overruns too (for real raw support).
+                */
+               if (termios->c_iflag & IGNPAR)
+                       port->ignore_status_mask |= UART_LSR_OE;
+       }
+
+       /*
+        * ignore all characters if CREAD is not set
+        */
+       if ((termios->c_cflag & CREAD) == 0)
+               port->ignore_status_mask |= UART_LSR_DR;
+
+       /*
+        * CTS flow control flag and modem status interrupts
+        */
+       port->ier &= ~UART_IER_MSI;
+       if ((termios->c_cflag & CRTSCTS) || !(termios->c_cflag & CLOCAL))
+               port->ier |= UART_IER_MSI;
+
+       port->lcr = cval;
+
+       sdio_out(port, UART_IER, port->ier);
+       sdio_out(port, UART_LCR, cval | UART_LCR_DLAB);
+       sdio_out(port, UART_DLL, quot & 0xff);
+       sdio_out(port, UART_DLM, quot >> 8);
+       sdio_out(port, UART_LCR, cval);
+       sdio_out(port, UART_FCR, fcr);
+
+       sdio_uart_write_mctrl(port, port->mctrl);
+}
+
+static void sdio_uart_start_tx(struct sdio_uart_port *port)
+{
+       if (!(port->ier & UART_IER_THRI)) {
+               port->ier |= UART_IER_THRI;
+               sdio_out(port, UART_IER, port->ier);
+       }
+}
+
+static void sdio_uart_stop_tx(struct sdio_uart_port *port)
+{
+       if (port->ier & UART_IER_THRI) {
+               port->ier &= ~UART_IER_THRI;
+               sdio_out(port, UART_IER, port->ier);
+       }
+}
+
+static void sdio_uart_stop_rx(struct sdio_uart_port *port)
+{
+       port->ier &= ~UART_IER_RLSI;
+       port->read_status_mask &= ~UART_LSR_DR;
+       sdio_out(port, UART_IER, port->ier);
+}
+
+static void sdio_uart_receive_chars(struct sdio_uart_port *port, unsigned int *status)
+{
+       struct tty_struct *tty = port->tty;
+       unsigned int ch, flag;
+       int max_count = 256;
+
+       do {
+               ch = sdio_in(port, UART_RX);
+               flag = TTY_NORMAL;
+               port->icount.rx++;
+
+               if (unlikely(*status & (UART_LSR_BI | UART_LSR_PE |
+                                       UART_LSR_FE | UART_LSR_OE))) {
+                       /*
+                        * For statistics only
+                        */
+                       if (*status & UART_LSR_BI) {
+                               *status &= ~(UART_LSR_FE | UART_LSR_PE);
+                               port->icount.brk++;
+                       } else if (*status & UART_LSR_PE)
+                               port->icount.parity++;
+                       else if (*status & UART_LSR_FE)
+                               port->icount.frame++;
+                       if (*status & UART_LSR_OE)
+                               port->icount.overrun++;
+
+                       /*
+                        * Mask off conditions which should be ignored.
+                        */
+                       *status &= port->read_status_mask;
+                       if (*status & UART_LSR_BI) {
+                               flag = TTY_BREAK;
+                       } else if (*status & UART_LSR_PE)
+                               flag = TTY_PARITY;
+                       else if (*status & UART_LSR_FE)
+                               flag = TTY_FRAME;
+               }
+
+               if ((*status & port->ignore_status_mask & ~UART_LSR_OE) == 0)
+                       tty_insert_flip_char(tty, ch, flag);
+
+               /*
+                * Overrun is special.  Since it's reported immediately,
+                * it doesn't affect the current character.
+                */
+               if (*status & ~port->ignore_status_mask & UART_LSR_OE)
+                       tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+
+               *status = sdio_in(port, UART_LSR);
+       } while ((*status & UART_LSR_DR) && (max_count-- > 0));
+       tty_flip_buffer_push(tty);
+}
+
+static void sdio_uart_transmit_chars(struct sdio_uart_port *port)
+{
+       struct circ_buf *xmit = &port->xmit;
+       int count;
+
+       if (port->x_char) {
+               sdio_out(port, UART_TX, port->x_char);
+               port->icount.tx++;
+               port->x_char = 0;
+               return;
+       }
+       if (circ_empty(xmit) || port->tty->stopped || port->tty->hw_stopped) {
+               sdio_uart_stop_tx(port);
+               return;
+       }
+
+       count = 16;
+       do {
+               sdio_out(port, UART_TX, xmit->buf[xmit->tail]);
+               xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
+               port->icount.tx++;
+               if (circ_empty(xmit))
+                       break;
+       } while (--count > 0);
+
+       if (circ_chars_pending(xmit) < WAKEUP_CHARS)
+               tty_wakeup(port->tty);
+
+       if (circ_empty(xmit))
+               sdio_uart_stop_tx(port);
+}
+
+static void sdio_uart_check_modem_status(struct sdio_uart_port *port)
+{
+       int status;
+
+       status = sdio_in(port, UART_MSR);
+
+       if ((status & UART_MSR_ANY_DELTA) == 0)
+               return;
+
+       if (status & UART_MSR_TERI)
+               port->icount.rng++;
+       if (status & UART_MSR_DDSR)
+               port->icount.dsr++;
+       if (status & UART_MSR_DDCD)
+               port->icount.dcd++;
+       if (status & UART_MSR_DCTS) {
+               port->icount.cts++;
+               if (port->tty->termios->c_cflag & CRTSCTS) {
+                       int cts = (status & UART_MSR_CTS);
+                       if (port->tty->hw_stopped) {
+                               if (cts) {
+                                       port->tty->hw_stopped = 0;
+                                       sdio_uart_start_tx(port);
+                                       tty_wakeup(port->tty);
+                               }
+                       } else {
+                               if (!cts) {
+                                       port->tty->hw_stopped = 1;
+                                       sdio_uart_stop_tx(port);
+                               }
+                       }
+               }
+       }
+}
+
+/*
+ * This handles the interrupt from one port.
+ */
+static void sdio_uart_irq(struct sdio_func *func)
+{
+       struct sdio_uart_port *port = sdio_get_drvdata(func);
+       unsigned int iir, lsr;
+
+       /*
+        * In a few places sdio_uart_irq() is called directly instead of
+        * waiting for the actual interrupt to be raised and the SDIO IRQ
+        * thread scheduled in order to reduce latency.  However, some
+        * interaction with the tty core may end up calling us back
+        * (serial echo, flow control, etc.) through those same places
+        * causing undesirable effects.  Let's stop the recursion here.
+        */
+       if (unlikely(port->in_sdio_uart_irq == current))
+               return;
+
+       iir = sdio_in(port, UART_IIR);
+       if (iir & UART_IIR_NO_INT)
+               return;
+
+       port->in_sdio_uart_irq = current;
+       lsr = sdio_in(port, UART_LSR);
+       if (lsr & UART_LSR_DR)
+               sdio_uart_receive_chars(port, &lsr);
+       sdio_uart_check_modem_status(port);
+       if (lsr & UART_LSR_THRE)
+               sdio_uart_transmit_chars(port);
+       port->in_sdio_uart_irq = NULL;
+}
+
+static int sdio_uart_startup(struct sdio_uart_port *port)
+{
+       unsigned long page;
+       int ret;
+
+       /*
+        * Set the TTY IO error marker - we will only clear this
+        * once we have successfully opened the port.
+        */
+       set_bit(TTY_IO_ERROR, &port->tty->flags);
+
+       /* Initialise and allocate the transmit buffer. */
+       page = __get_free_page(GFP_KERNEL);
+       if (!page)
+               return -ENOMEM;
+       port->xmit.buf = (unsigned char *)page;
+       circ_clear(&port->xmit);
+
+       ret = sdio_uart_claim_func(port);
+       if (ret)
+               goto err1;
+       ret = sdio_enable_func(port->func);
+       if (ret)
+               goto err2;
+       ret = sdio_claim_irq(port->func, sdio_uart_irq);
+       if (ret)
+               goto err3;
+
+       /*
+        * Clear the FIFO buffers and disable them.
+        * (they will be reenabled in sdio_change_speed())
+        */
+       sdio_out(port, UART_FCR, UART_FCR_ENABLE_FIFO);
+       sdio_out(port, UART_FCR, UART_FCR_ENABLE_FIFO |
+                       UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
+       sdio_out(port, UART_FCR, 0);
+
+       /*
+        * Clear the interrupt registers.
+        */
+       (void) sdio_in(port, UART_LSR);
+       (void) sdio_in(port, UART_RX);
+       (void) sdio_in(port, UART_IIR);
+       (void) sdio_in(port, UART_MSR);
+
+       /*
+        * Now, initialize the UART
+        */
+       sdio_out(port, UART_LCR, UART_LCR_WLEN8);
+
+       port->ier = UART_IER_RLSI | UART_IER_RDI | UART_IER_RTOIE | UART_IER_UUE;
+       port->mctrl = TIOCM_OUT2;
+
+       sdio_uart_change_speed(port, port->tty->termios, NULL);
+
+       if (port->tty->termios->c_cflag & CBAUD)
+               sdio_uart_set_mctrl(port, TIOCM_RTS | TIOCM_DTR);
+
+       if (port->tty->termios->c_cflag & CRTSCTS)
+               if (!(sdio_uart_get_mctrl(port) & TIOCM_CTS))
+                       port->tty->hw_stopped = 1;
+
+       clear_bit(TTY_IO_ERROR, &port->tty->flags);
+
+       /* Kick the IRQ handler once while we're still holding the host lock */
+       sdio_uart_irq(port->func);
+
+       sdio_uart_release_func(port);
+       return 0;
+
+err3:
+       sdio_disable_func(port->func);
+err2:
+       sdio_uart_release_func(port);
+err1:
+       free_page((unsigned long)port->xmit.buf);
+       return ret;
+}
+
+static void sdio_uart_shutdown(struct sdio_uart_port *port)
+{
+       int ret;
+
+       ret = sdio_uart_claim_func(port);
+       if (ret)
+               goto skip;
+
+       sdio_uart_stop_rx(port);
+
+       /* TODO: wait here for TX FIFO to drain */
+
+       /* Turn off DTR and RTS early. */
+       if (port->tty->termios->c_cflag & HUPCL)
+               sdio_uart_clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
+
+        /* Disable interrupts from this port */
+       sdio_release_irq(port->func);
+       port->ier = 0;
+       sdio_out(port, UART_IER, 0);
+
+       sdio_uart_clear_mctrl(port, TIOCM_OUT2);
+
+       /* Disable break condition and FIFOs. */
+       port->lcr &= ~UART_LCR_SBC;
+       sdio_out(port, UART_LCR, port->lcr);
+       sdio_out(port, UART_FCR, UART_FCR_ENABLE_FIFO |
+                                UART_FCR_CLEAR_RCVR |
+                                UART_FCR_CLEAR_XMIT);
+       sdio_out(port, UART_FCR, 0);
+
+       sdio_disable_func(port->func);
+
+       sdio_uart_release_func(port);
+
+skip:
+       /* Free the transmit buffer page. */
+       free_page((unsigned long)port->xmit.buf);
+}
+
+static int sdio_uart_open (struct tty_struct *tty, struct file * filp)
+{
+       struct sdio_uart_port *port;
+       int ret;
+
+       port = sdio_uart_port_get(tty->index);
+       if (!port)
+               return -ENODEV;
+
+       mutex_lock(&port->open_lock);
+
+       /*
+        * Make sure not to mess up with a dead port
+        * which has not been closed yet.
+        */
+       if (tty->driver_data && tty->driver_data != port) {
+               mutex_unlock(&port->open_lock);
+               sdio_uart_port_put(port);
+               return -EBUSY;
+       }
+
+       if (!port->opened) {
+               tty->driver_data = port;
+               port->tty = tty;
+               ret = sdio_uart_startup(port);
+               if (ret) {
+                       tty->driver_data = NULL;
+                       port->tty = NULL;
+                       mutex_unlock(&port->open_lock);
+                       sdio_uart_port_put(port);
+                       return ret;
+               }
+       }
+       port->opened++;
+       mutex_unlock(&port->open_lock);
+       return 0;
+}
+
+static void sdio_uart_close(struct tty_struct *tty, struct file * filp)
+{
+       struct sdio_uart_port *port = tty->driver_data;
+
+       if (!port)
+               return;
+
+       mutex_lock(&port->open_lock);
+       BUG_ON(!port->opened);
+
+       /*
+        * This is messy.  The tty layer calls us even when open()
+        * returned an error.  Ignore this close request if tty->count
+        * is larger than port->count.
+        */
+       if (tty->count > port->opened) {
+               mutex_unlock(&port->open_lock);
+               return;
+       }
+
+       if (--port->opened == 0) {
+               tty->closing = 1;
+               sdio_uart_shutdown(port);
+               tty_ldisc_flush(tty);
+               port->tty = NULL;
+               tty->driver_data = NULL;
+               tty->closing = 0;
+       }
+       mutex_unlock(&port->open_lock);
+       sdio_uart_port_put(port);
+}
+
+static int sdio_uart_write(struct tty_struct * tty, const unsigned char *buf,
+                          int count)
+{
+       struct sdio_uart_port *port = tty->driver_data;
+       struct circ_buf *circ = &port->xmit;
+       int c, ret = 0;
+
+       if (!port->func)
+               return -ENODEV;
+
+       spin_lock(&port->write_lock);
+       while (1) {
+               c = CIRC_SPACE_TO_END(circ->head, circ->tail, UART_XMIT_SIZE);
+               if (count < c)
+                       c = count;
+               if (c <= 0)
+                       break;
+               memcpy(circ->buf + circ->head, buf, c);
+               circ->head = (circ->head + c) & (UART_XMIT_SIZE - 1);
+               buf += c;
+               count -= c;
+               ret += c;
+       }
+       spin_unlock(&port->write_lock);
+
+       if ( !(port->ier & UART_IER_THRI)) {
+               int err = sdio_uart_claim_func(port);
+               if (!err) {
+                       sdio_uart_start_tx(port);
+                       sdio_uart_irq(port->func);
+                       sdio_uart_release_func(port);
+               } else
+                       ret = err;
+       }
+
+       return ret;
+}
+
+static int sdio_uart_write_room(struct tty_struct *tty)
+{
+       struct sdio_uart_port *port = tty->driver_data;
+       return port ? circ_chars_free(&port->xmit) : 0;
+}
+
+static int sdio_uart_chars_in_buffer(struct tty_struct *tty)
+{
+       struct sdio_uart_port *port = tty->driver_data;
+       return port ? circ_chars_pending(&port->xmit) : 0;
+}
+
+static void sdio_uart_send_xchar(struct tty_struct *tty, char ch)
+{
+       struct sdio_uart_port *port = tty->driver_data;
+
+       port->x_char = ch;
+       if (ch && !(port->ier & UART_IER_THRI)) {
+               if (sdio_uart_claim_func(port) != 0)
+                       return;
+               sdio_uart_start_tx(port);
+               sdio_uart_irq(port->func);
+               sdio_uart_release_func(port);
+       }
+}
+
+static void sdio_uart_throttle(struct tty_struct *tty)
+{
+       struct sdio_uart_port *port = tty->driver_data;
+
+       if (!I_IXOFF(tty) && !(tty->termios->c_cflag & CRTSCTS))
+               return;
+
+       if (sdio_uart_claim_func(port) != 0)
+               return;
+
+       if (I_IXOFF(tty)) {
+               port->x_char = STOP_CHAR(tty);
+               sdio_uart_start_tx(port);
+       }
+
+       if (tty->termios->c_cflag & CRTSCTS)
+               sdio_uart_clear_mctrl(port, TIOCM_RTS);
+
+       sdio_uart_irq(port->func);
+       sdio_uart_release_func(port);
+}
+
+static void sdio_uart_unthrottle(struct tty_struct *tty)
+{
+       struct sdio_uart_port *port = tty->driver_data;
+
+       if (!I_IXOFF(tty) && !(tty->termios->c_cflag & CRTSCTS))
+               return;
+
+       if (sdio_uart_claim_func(port) != 0)
+               return;
+
+       if (I_IXOFF(tty)) {
+               if (port->x_char) {
+                       port->x_char = 0;
+               } else {
+                       port->x_char = START_CHAR(tty);
+                       sdio_uart_start_tx(port);
+               }
+       }
+
+       if (tty->termios->c_cflag & CRTSCTS)
+               sdio_uart_set_mctrl(port, TIOCM_RTS);
+
+       sdio_uart_irq(port->func);
+       sdio_uart_release_func(port);
+}
+
+static void sdio_uart_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
+{
+       struct sdio_uart_port *port = tty->driver_data;
+       unsigned int cflag = tty->termios->c_cflag;
+
+#define RELEVANT_IFLAG(iflag)   ((iflag) & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
+
+       if ((cflag ^ old_termios->c_cflag) == 0 &&
+           RELEVANT_IFLAG(tty->termios->c_iflag ^ old_termios->c_iflag) == 0)
+               return;
+
+       if (sdio_uart_claim_func(port) != 0)
+               return;
+
+       sdio_uart_change_speed(port, tty->termios, old_termios);
+
+       /* Handle transition to B0 status */
+       if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD))
+               sdio_uart_clear_mctrl(port, TIOCM_RTS | TIOCM_DTR);
+
+       /* Handle transition away from B0 status */
+       if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) {
+               unsigned int mask = TIOCM_DTR;
+               if (!(cflag & CRTSCTS) || !test_bit(TTY_THROTTLED, &tty->flags))
+                       mask |= TIOCM_RTS;
+               sdio_uart_set_mctrl(port, mask);
+       }
+
+       /* Handle turning off CRTSCTS */
+       if ((old_termios->c_cflag & CRTSCTS) && !(cflag & CRTSCTS)) {
+               tty->hw_stopped = 0;
+               sdio_uart_start_tx(port);
+       }
+
+       /* Handle turning on CRTSCTS */
+       if (!(old_termios->c_cflag & CRTSCTS) && (cflag & CRTSCTS)) {
+               if (!(sdio_uart_get_mctrl(port) & TIOCM_CTS)) {
+                       tty->hw_stopped = 1;
+                       sdio_uart_stop_tx(port);
+               }
+       }
+
+       sdio_uart_release_func(port);
+}
+
+static void sdio_uart_break_ctl(struct tty_struct *tty, int break_state)
+{
+       struct sdio_uart_port *port = tty->driver_data;
+
+       if (sdio_uart_claim_func(port) != 0)
+               return;
+
+       if (break_state == -1)
+               port->lcr |= UART_LCR_SBC;
+       else
+               port->lcr &= ~UART_LCR_SBC;
+       sdio_out(port, UART_LCR, port->lcr);
+
+       sdio_uart_release_func(port);
+}
+
+static int sdio_uart_tiocmget(struct tty_struct *tty, struct file *file)
+{
+       struct sdio_uart_port *port = tty->driver_data;
+       int result;
+
+       result = sdio_uart_claim_func(port);
+       if (!result) {
+               result = port->mctrl | sdio_uart_get_mctrl(port);
+               sdio_uart_release_func(port);
+       }
+
+       return result;
+}
+
+static int sdio_uart_tiocmset(struct tty_struct *tty, struct file *file,
+                             unsigned int set, unsigned int clear)
+{
+       struct sdio_uart_port *port = tty->driver_data;
+       int result;
+
+       result =sdio_uart_claim_func(port);
+       if(!result) {
+               sdio_uart_update_mctrl(port, set, clear);
+               sdio_uart_release_func(port);
+       }
+
+       return result;
+}
+
+static int sdio_uart_read_proc(char *page, char **start, off_t off,
+                              int count, int *eof, void *data)
+{
+       int i, len = 0;
+       off_t begin = 0;
+
+       len += sprintf(page, "serinfo:1.0 driver%s%s revision:%s\n",
+                      "", "", "");
+       for (i = 0; i < UART_NR && len < PAGE_SIZE - 96; i++) {
+               struct sdio_uart_port *port = sdio_uart_port_get(i);
+               if (port) {
+                       len += sprintf(page+len, "%d: uart:SDIO", i);
+                       if(capable(CAP_SYS_ADMIN)) {
+                               len += sprintf(page + len, " tx:%d rx:%d",
+                                              port->icount.tx, port->icount.rx);
+                               if (port->icount.frame)
+                                       len += sprintf(page + len, " fe:%d",
+                                                      port->icount.frame);
+                               if (port->icount.parity)
+                                       len += sprintf(page + len, " pe:%d",
+                                                      port->icount.parity);
+                               if (port->icount.brk)
+                                       len += sprintf(page + len, " brk:%d",
+                                                      port->icount.brk);
+                               if (port->icount.overrun)
+                                       len += sprintf(page + len, " oe:%d",
+                                                      port->icount.overrun);
+                               if (port->icount.cts)
+                                       len += sprintf(page + len, " cts:%d",
+                                                      port->icount.cts);
+                               if (port->icount.dsr)
+                                       len += sprintf(page + len, " dsr:%d",
+                                                      port->icount.dsr);
+                               if (port->icount.rng)
+                                       len += sprintf(page + len, " rng:%d",
+                                                      port->icount.rng);
+                               if (port->icount.dcd)
+                                       len += sprintf(page + len, " dcd:%d",
+                                                      port->icount.dcd);
+                       }
+                       strcat(page, "\n");
+                       len++;
+                       sdio_uart_port_put(port);
+               }
+
+               if (len + begin > off + count)
+                       goto done;
+               if (len + begin < off) {
+                       begin += len;
+                       len = 0;
+               }
+       }
+       *eof = 1;
+
+done:
+       if (off >= len + begin)
+               return 0;
+       *start = page + (off - begin);
+       return (count < begin + len - off) ? count : (begin + len - off);
+}
+
+static const struct tty_operations sdio_uart_ops = {
+       .open                   = sdio_uart_open,
+       .close                  = sdio_uart_close,
+       .write                  = sdio_uart_write,
+       .write_room             = sdio_uart_write_room,
+       .chars_in_buffer        = sdio_uart_chars_in_buffer,
+       .send_xchar             = sdio_uart_send_xchar,
+       .throttle               = sdio_uart_throttle,
+       .unthrottle             = sdio_uart_unthrottle,
+       .set_termios            = sdio_uart_set_termios,
+       .break_ctl              = sdio_uart_break_ctl,
+       .tiocmget               = sdio_uart_tiocmget,
+       .tiocmset               = sdio_uart_tiocmset,
+       .read_proc              = sdio_uart_read_proc,
+};
+
+static struct tty_driver *sdio_uart_tty_driver;
+
+static int sdio_uart_probe(struct sdio_func *func,
+                          const struct sdio_device_id *id)
+{
+       struct sdio_uart_port *port;
+       int ret;
+
+       port = kzalloc(sizeof(struct sdio_uart_port), GFP_KERNEL);
+       if (!port)
+               return -ENOMEM;
+
+       if (func->class == SDIO_CLASS_UART) {
+               printk(KERN_WARNING "%s: need info on UART class basic setup\n",
+                      sdio_func_id(func));
+               kfree(port);
+               return -ENOSYS;
+       } else if (func->class == SDIO_CLASS_GPS) {
+               /*
+                * We need tuple 0x91.  It contains SUBTPL_SIOREG
+                * and SUBTPL_RCVCAPS.
+                */
+               struct sdio_func_tuple *tpl;
+               for (tpl = func->tuples; tpl; tpl = tpl->next) {
+                       if (tpl->code != 0x91)
+                               continue;
+                       if (tpl->size < 10)
+                               continue;
+                       if (tpl->data[1] == 0)  /* SUBTPL_SIOREG */
+                               break;
+               }
+               if (!tpl) {
+                       printk(KERN_WARNING
+                              "%s: can't find tuple 0x91 subtuple 0 (SUBTPL_SIOREG) for GPS class\n",
+                              sdio_func_id(func));
+                       kfree(port);
+                       return -EINVAL;
+               }
+               printk(KERN_DEBUG "%s: Register ID = 0x%02x, Exp ID = 0x%02x\n",
+                      sdio_func_id(func), tpl->data[2], tpl->data[3]);
+               port->regs_offset = (tpl->data[4] << 0) |
+                                   (tpl->data[5] << 8) |
+                                   (tpl->data[6] << 16);
+               printk(KERN_DEBUG "%s: regs offset = 0x%x\n",
+                      sdio_func_id(func), port->regs_offset);
+               port->uartclk = tpl->data[7] * 115200;
+               if (port->uartclk == 0)
+                       port->uartclk = 115200;
+               printk(KERN_DEBUG "%s: clk %d baudcode %u 4800-div %u\n",
+                      sdio_func_id(func), port->uartclk,
+                      tpl->data[7], tpl->data[8] | (tpl->data[9] << 8));
+       } else {
+               kfree(port);
+               return -EINVAL;
+       }
+
+       port->func = func;
+       sdio_set_drvdata(func, port);
+
+       ret = sdio_uart_add_port(port);
+       if (ret) {
+               kfree(port);
+       } else {
+               struct device *dev;
+               dev = tty_register_device(sdio_uart_tty_driver, port->index, &func->dev);
+               if (IS_ERR(dev)) {
+                       sdio_uart_port_remove(port);
+                       ret = PTR_ERR(dev);
+               }
+       }
+
+       return ret;
+}
+
+static void sdio_uart_remove(struct sdio_func *func)
+{
+       struct sdio_uart_port *port = sdio_get_drvdata(func);
+
+       tty_unregister_device(sdio_uart_tty_driver, port->index);
+       sdio_uart_port_remove(port);
+}
+
+static const struct sdio_device_id sdio_uart_ids[] = {
+       { SDIO_DEVICE_CLASS(SDIO_CLASS_UART)            },
+       { SDIO_DEVICE_CLASS(SDIO_CLASS_GPS)             },
+       { /* end: all zeroes */                         },
+};
+
+MODULE_DEVICE_TABLE(sdio, sdio_uart_ids);
+
+static struct sdio_driver sdio_uart_driver = {
+       .probe          = sdio_uart_probe,
+       .remove         = sdio_uart_remove,
+       .name           = "sdio_uart",
+       .id_table       = sdio_uart_ids,
+};
+
+static int __init sdio_uart_init(void)
+{
+       int ret;
+       struct tty_driver *tty_drv;
+
+       sdio_uart_tty_driver = tty_drv = alloc_tty_driver(UART_NR);
+       if (!tty_drv)
+               return -ENOMEM;
+
+       tty_drv->owner = THIS_MODULE;
+       tty_drv->driver_name = "sdio_uart";
+       tty_drv->name =   "ttySDIO";
+       tty_drv->major = 0;  /* dynamically allocated */
+       tty_drv->minor_start = 0;
+       tty_drv->type = TTY_DRIVER_TYPE_SERIAL;
+       tty_drv->subtype = SERIAL_TYPE_NORMAL;
+       tty_drv->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
+       tty_drv->init_termios = tty_std_termios;
+       tty_drv->init_termios.c_cflag = B4800 | CS8 | CREAD | HUPCL | CLOCAL;
+       tty_drv->init_termios.c_ispeed = 4800;
+       tty_drv->init_termios.c_ospeed = 4800;
+       tty_set_operations(tty_drv, &sdio_uart_ops);
+
+       ret = tty_register_driver(tty_drv);
+       if (ret)
+               goto err1;
+
+       ret = sdio_register_driver(&sdio_uart_driver);
+       if (ret)
+               goto err2;
+
+       return 0;
+
+err2:
+       tty_unregister_driver(tty_drv);
+err1:
+       put_tty_driver(tty_drv);
+       return ret;
+}
+
+static void __exit sdio_uart_exit(void)
+{
+       sdio_unregister_driver(&sdio_uart_driver);
+       tty_unregister_driver(sdio_uart_tty_driver);
+       put_tty_driver(sdio_uart_tty_driver);
+}
+
+module_init(sdio_uart_init);
+module_exit(sdio_uart_exit);
+
+MODULE_AUTHOR("Nicolas Pitre");
+MODULE_LICENSE("GPL");
--- a/drivers/mmc/core/Makefile
+++ b/drivers/mmc/core/Makefile
@@ -8,5 +8,7 @@
 
 obj-$(CONFIG_MMC)              += mmc_core.o
 mmc_core-y                     := core.o sysfs.o bus.o host.o \
-                                  mmc.o mmc_ops.o sd.o sd_ops.o
+                                  mmc.o mmc_ops.o sd.o sd_ops.o \
+                                  sdio.o sdio_ops.o sdio_bus.o \
+                                  sdio_cis.o sdio_io.o sdio_irq.o