git.oblomov.eu Git - linux-2.6/blob - drivers/mmc/host/at91_mci.c

   1 /*
   2  *  linux/drivers/mmc/host/at91_mci.c - ATMEL AT91 MCI Driver
   3  *
   4  *  Copyright (C) 2005 Cougar Creek Computing Devices Ltd, All Rights Reserved
   5  *
   6  *  Copyright (C) 2006 Malcolm Noyes
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  */
  12
  13 /*
  14    This is the AT91 MCI driver that has been tested with both MMC cards
  15    and SD-cards.  Boards that support write protect are now supported.
  16    The CCAT91SBC001 board does not support SD cards.
  17
  18    The three entry points are at91_mci_request, at91_mci_set_ios
  19    and at91_mci_get_ro.
  20
  21    SET IOS
  22      This configures the device to put it into the correct mode and clock speed
  23      required.
  24
  25    MCI REQUEST
  26      MCI request processes the commands sent in the mmc_request structure. This
  27      can consist of a processing command and a stop command in the case of
  28      multiple block transfers.
  29
  30      There are three main types of request, commands, reads and writes.
  31
  32      Commands are straight forward. The command is submitted to the controller and
  33      the request function returns. When the controller generates an interrupt to indicate
  34      the command is finished, the response to the command are read and the mmc_request_done
  35      function called to end the request.
  36
  37      Reads and writes work in a similar manner to normal commands but involve the PDC (DMA)
  38      controller to manage the transfers.
  39
  40      A read is done from the controller directly to the scatterlist passed in from the request.
  41      Due to a bug in the AT91RM9200 controller, when a read is completed, all the words are byte
  42      swapped in the scatterlist buffers.  AT91SAM926x are not affected by this bug.
  43
  44      The sequence of read interrupts is: ENDRX, RXBUFF, CMDRDY
  45
  46      A write is slightly different in that the bytes to write are read from the scatterlist
  47      into a dma memory buffer (this is in case the source buffer should be read only). The
  48      entire write buffer is then done from this single dma memory buffer.
  49
  50      The sequence of write interrupts is: ENDTX, TXBUFE, NOTBUSY, CMDRDY
  51
  52    GET RO
  53      Gets the status of the write protect pin, if available.
  54 */
  55
  56 #include <linux/module.h>
  57 #include <linux/moduleparam.h>
  58 #include <linux/init.h>
  59 #include <linux/ioport.h>
  60 #include <linux/platform_device.h>
  61 #include <linux/interrupt.h>
  62 #include <linux/blkdev.h>
  63 #include <linux/delay.h>
  64 #include <linux/err.h>
  65 #include <linux/dma-mapping.h>
  66 #include <linux/clk.h>
  67 #include <linux/atmel_pdc.h>
  68
  69 #include <linux/mmc/host.h>
  70
  71 #include <asm/io.h>
  72 #include <asm/irq.h>
  73 #include <asm/gpio.h>
  74
  75 #include <asm/mach/mmc.h>
  76 #include <asm/arch/board.h>
  77 #include <asm/arch/cpu.h>
  78 #include <asm/arch/at91_mci.h>
  79
  80 #define DRIVER_NAME "at91_mci"
  81
  82 #define FL_SENT_COMMAND (1 << 0)
  83 #define FL_SENT_STOP    (1 << 1)
  84
  85 #define AT91_MCI_ERRORS (AT91_MCI_RINDE | AT91_MCI_RDIRE | AT91_MCI_RCRCE       \
  86                 | AT91_MCI_RENDE | AT91_MCI_RTOE | AT91_MCI_DCRCE               \
  87                 | AT91_MCI_DTOE | AT91_MCI_OVRE | AT91_MCI_UNRE)
  88
  89 #define at91_mci_read(host, reg)        __raw_readl((host)->baseaddr + (reg))
  90 #define at91_mci_write(host, reg, val)  __raw_writel((val), (host)->baseaddr + (reg))
  91
  92
  93 /*
  94  * Low level type for this driver
  95  */
  96 struct at91mci_host
  97 {
  98         struct mmc_host *mmc;
  99         struct mmc_command *cmd;
 100         struct mmc_request *request;
 101
 102         void __iomem *baseaddr;
 103         int irq;
 104
 105         struct at91_mmc_data *board;
 106         int present;
 107
 108         struct clk *mci_clk;
 109
 110         /*
 111          * Flag indicating when the command has been sent. This is used to
 112          * work out whether or not to send the stop
 113          */
 114         unsigned int flags;
 115         /* flag for current bus settings */
 116         u32 bus_mode;
 117
 118         /* DMA buffer used for transmitting */
 119         unsigned int* buffer;
 120         dma_addr_t physical_address;
 121         unsigned int total_length;
 122
 123         /* Latest in the scatterlist that has been enabled for transfer, but not freed */
 124         int in_use_index;
 125
 126         /* Latest in the scatterlist that has been enabled for transfer */
 127         int transfer_index;
 128
 129         /* Timer for timeouts */
 130         struct timer_list timer;
 131 };
 132
 133 /*
 134  * Reset the controller and restore most of the state
 135  */
 136 static void at91_reset_host(struct at91mci_host *host)
 137 {
 138         unsigned long flags;
 139         u32 mr;
 140         u32 sdcr;
 141         u32 dtor;
 142         u32 imr;
 143
 144         local_irq_save(flags);
 145         imr = at91_mci_read(host, AT91_MCI_IMR);
 146
 147         at91_mci_write(host, AT91_MCI_IDR, 0xffffffff);
 148
 149         /* save current state */
 150         mr = at91_mci_read(host, AT91_MCI_MR) & 0x7fff;
 151         sdcr = at91_mci_read(host, AT91_MCI_SDCR);
 152         dtor = at91_mci_read(host, AT91_MCI_DTOR);
 153
 154         /* reset the controller */
 155         at91_mci_write(host, AT91_MCI_CR, AT91_MCI_MCIDIS | AT91_MCI_SWRST);
 156
 157         /* restore state */
 158         at91_mci_write(host, AT91_MCI_CR, AT91_MCI_MCIEN);
 159         at91_mci_write(host, AT91_MCI_MR, mr);
 160         at91_mci_write(host, AT91_MCI_SDCR, sdcr);
 161         at91_mci_write(host, AT91_MCI_DTOR, dtor);
 162         at91_mci_write(host, AT91_MCI_IER, imr);
 163
 164         /* make sure sdio interrupts will fire */
 165         at91_mci_read(host, AT91_MCI_SR);
 166
 167         local_irq_restore(flags);
 168 }
 169
 170 static void at91_timeout_timer(unsigned long data)
 171 {
 172         struct at91mci_host *host;
 173
 174         host = (struct at91mci_host *)data;
 175
 176         if (host->request) {
 177                 dev_err(host->mmc->parent, "Timeout waiting end of packet\n");
 178
 179                 if (host->cmd && host->cmd->data) {
 180                         host->cmd->data->error = -ETIMEDOUT;
 181                 } else {
 182                         if (host->cmd)
 183                                 host->cmd->error = -ETIMEDOUT;
 184                         else
 185                                 host->request->cmd->error = -ETIMEDOUT;
 186                 }
 187
 188                 at91_reset_host(host);
 189                 mmc_request_done(host->mmc, host->request);
 190         }
 191 }
 192
 193 /*
 194  * Copy from sg to a dma block - used for transfers
 195  */
 196 static inline void at91_mci_sg_to_dma(struct at91mci_host *host, struct mmc_data *data)
 197 {
 198         unsigned int len, i, size;
 199         unsigned *dmabuf = host->buffer;
 200
 201         size = data->blksz * data->blocks;
 202         len = data->sg_len;
 203
 204         /* AT91SAM926[0/3] Data Write Operation and number of bytes erratum */
 205         if (cpu_is_at91sam9260() || cpu_is_at91sam9263())
 206                 if (host->total_length == 12)
 207                         memset(dmabuf, 0, 12);
 208
 209         /*
 210          * Just loop through all entries. Size might not
 211          * be the entire list though so make sure that
 212          * we do not transfer too much.
 213          */
 214         for (i = 0; i < len; i++) {
 215                 struct scatterlist *sg;
 216                 int amount;
 217                 unsigned int *sgbuffer;
 218
 219                 sg = &data->sg[i];
 220
 221                 sgbuffer = kmap_atomic(sg_page(sg), KM_BIO_SRC_IRQ) + sg->offset;
 222                 amount = min(size, sg->length);
 223                 size -= amount;
 224
 225                 if (cpu_is_at91rm9200()) {      /* AT91RM9200 errata */
 226                         int index;
 227
 228                         for (index = 0; index < (amount / 4); index++)
 229                                 *dmabuf++ = swab32(sgbuffer[index]);
 230                 } else {
 231                         memcpy(dmabuf, sgbuffer, amount);
 232                         dmabuf += amount;
 233                 }
 234
 235                 kunmap_atomic(sgbuffer, KM_BIO_SRC_IRQ);
 236
 237                 if (size == 0)
 238                         break;
 239         }
 240
 241         /*
 242          * Check that we didn't get a request to transfer
 243          * more data than can fit into the SG list.
 244          */
 245         BUG_ON(size != 0);
 246 }
 247
 248 /*
 249  * Prepare a dma read
 250  */
 251 static void at91_mci_pre_dma_read(struct at91mci_host *host)
 252 {
 253         int i;
 254         struct scatterlist *sg;
 255         struct mmc_command *cmd;
 256         struct mmc_data *data;
 257
 258         pr_debug("pre dma read\n");
 259
 260         cmd = host->cmd;
 261         if (!cmd) {
 262                 pr_debug("no command\n");
 263                 return;
 264         }
 265
 266         data = cmd->data;
 267         if (!data) {
 268                 pr_debug("no data\n");
 269                 return;
 270         }
 271
 272         for (i = 0; i < 2; i++) {
 273                 /* nothing left to transfer */
 274                 if (host->transfer_index >= data->sg_len) {
 275                         pr_debug("Nothing left to transfer (index = %d)\n", host->transfer_index);
 276                         break;
 277                 }
 278
 279                 /* Check to see if this needs filling */
 280                 if (i == 0) {
 281                         if (at91_mci_read(host, ATMEL_PDC_RCR) != 0) {
 282                                 pr_debug("Transfer active in current\n");
 283                                 continue;
 284                         }
 285                 }
 286                 else {
 287                         if (at91_mci_read(host, ATMEL_PDC_RNCR) != 0) {
 288                                 pr_debug("Transfer active in next\n");
 289                                 continue;
 290                         }
 291                 }
 292
 293                 /* Setup the next transfer */
 294                 pr_debug("Using transfer index %d\n", host->transfer_index);
 295
 296                 sg = &data->sg[host->transfer_index++];
 297                 pr_debug("sg = %p\n", sg);
 298
 299                 sg->dma_address = dma_map_page(NULL, sg_page(sg), sg->offset, sg->length, DMA_FROM_DEVICE);
 300
 301                 pr_debug("dma address = %08X, length = %d\n", sg->dma_address, sg->length);
 302
 303                 if (i == 0) {
 304                         at91_mci_write(host, ATMEL_PDC_RPR, sg->dma_address);
 305                         at91_mci_write(host, ATMEL_PDC_RCR, (data->blksz & 0x3) ? sg->length : sg->length / 4);
 306                 }
 307                 else {
 308                         at91_mci_write(host, ATMEL_PDC_RNPR, sg->dma_address);
 309                         at91_mci_write(host, ATMEL_PDC_RNCR, (data->blksz & 0x3) ? sg->length : sg->length / 4);
 310                 }
 311         }
 312
 313         pr_debug("pre dma read done\n");
 314 }
 315
 316 /*
 317  * Handle after a dma read
 318  */
 319 static void at91_mci_post_dma_read(struct at91mci_host *host)
 320 {
 321         struct mmc_command *cmd;
 322         struct mmc_data *data;
 323
 324         pr_debug("post dma read\n");
 325
 326         cmd = host->cmd;
 327         if (!cmd) {
 328                 pr_debug("no command\n");
 329                 return;
 330         }
 331
 332         data = cmd->data;
 333         if (!data) {
 334                 pr_debug("no data\n");
 335                 return;
 336         }
 337
 338         while (host->in_use_index < host->transfer_index) {
 339                 struct scatterlist *sg;
 340
 341                 pr_debug("finishing index %d\n", host->in_use_index);
 342
 343                 sg = &data->sg[host->in_use_index++];
 344
 345                 pr_debug("Unmapping page %08X\n", sg->dma_address);
 346
 347                 dma_unmap_page(NULL, sg->dma_address, sg->length, DMA_FROM_DEVICE);
 348
 349                 if (cpu_is_at91rm9200()) {      /* AT91RM9200 errata */
 350                         unsigned int *buffer;
 351                         int index;
 352
 353                         /* Swap the contents of the buffer */
 354                         buffer = kmap_atomic(sg_page(sg), KM_BIO_SRC_IRQ) + sg->offset;
 355                         pr_debug("buffer = %p, length = %d\n", buffer, sg->length);
 356
 357                         for (index = 0; index < (sg->length / 4); index++)
 358                                 buffer[index] = swab32(buffer[index]);
 359
 360                         kunmap_atomic(buffer, KM_BIO_SRC_IRQ);
 361                 }
 362
 363                 flush_dcache_page(sg_page(sg));
 364
 365                 data->bytes_xfered += sg->length;
 366         }
 367
 368         /* Is there another transfer to trigger? */
 369         if (host->transfer_index < data->sg_len)
 370                 at91_mci_pre_dma_read(host);
 371         else {
 372                 at91_mci_write(host, AT91_MCI_IDR, AT91_MCI_ENDRX);
 373                 at91_mci_write(host, AT91_MCI_IER, AT91_MCI_RXBUFF);
 374         }
 375
 376         pr_debug("post dma read done\n");
 377 }
 378
 379 /*
 380  * Handle transmitted data
 381  */
 382 static void at91_mci_handle_transmitted(struct at91mci_host *host)
 383 {
 384         struct mmc_command *cmd;
 385         struct mmc_data *data;
 386
 387         pr_debug("Handling the transmit\n");
 388
 389         /* Disable the transfer */
 390         at91_mci_write(host, ATMEL_PDC_PTCR, ATMEL_PDC_RXTDIS | ATMEL_PDC_TXTDIS);
 391
 392         /* Now wait for cmd ready */
 393         at91_mci_write(host, AT91_MCI_IDR, AT91_MCI_TXBUFE);
 394
 395         cmd = host->cmd;
 396         if (!cmd) return;
 397
 398         data = cmd->data;
 399         if (!data) return;
 400
 401         if (cmd->data->blocks > 1) {
 402                 pr_debug("multiple write : wait for BLKE...\n");
 403                 at91_mci_write(host, AT91_MCI_IER, AT91_MCI_BLKE);
 404         } else
 405                 at91_mci_write(host, AT91_MCI_IER, AT91_MCI_NOTBUSY);
 406 }
 407
 408 /*
 409  * Update bytes tranfered count during a write operation
 410  */
 411 static void at91_mci_update_bytes_xfered(struct at91mci_host *host)
 412 {
 413         struct mmc_data *data;
 414
 415         /* always deal with the effective request (and not the current cmd) */
 416
 417         if (host->request->cmd && host->request->cmd->error != 0)
 418                 return;
 419
 420         if (host->request->data) {
 421                 data = host->request->data;
 422                 if (data->flags & MMC_DATA_WRITE) {
 423                         /* card is in IDLE mode now */
 424                         pr_debug("-> bytes_xfered %d, total_length = %d\n",
 425                                 data->bytes_xfered, host->total_length);
 426                         data->bytes_xfered = data->blksz * data->blocks;
 427                 }
 428         }
 429 }
 430
 431
 432 /*Handle after command sent ready*/
 433 static int at91_mci_handle_cmdrdy(struct at91mci_host *host)
 434 {
 435         if (!host->cmd)
 436                 return 1;
 437         else if (!host->cmd->data) {
 438                 if (host->flags & FL_SENT_STOP) {
 439                         /*After multi block write, we must wait for NOTBUSY*/
 440                         at91_mci_write(host, AT91_MCI_IER, AT91_MCI_NOTBUSY);
 441                 } else return 1;
 442         } else if (host->cmd->data->flags & MMC_DATA_WRITE) {
 443                 /*After sendding multi-block-write command, start DMA transfer*/
 444                 at91_mci_write(host, AT91_MCI_IER, AT91_MCI_TXBUFE | AT91_MCI_BLKE);
 445                 at91_mci_write(host, ATMEL_PDC_PTCR, ATMEL_PDC_TXTEN);
 446         }
 447
 448         /* command not completed, have to wait */
 449         return 0;
 450 }
 451
 452
 453 /*
 454  * Enable the controller
 455  */
 456 static void at91_mci_enable(struct at91mci_host *host)
 457 {
 458         unsigned int mr;
 459
 460         at91_mci_write(host, AT91_MCI_CR, AT91_MCI_MCIEN);
 461         at91_mci_write(host, AT91_MCI_IDR, 0xffffffff);
 462         at91_mci_write(host, AT91_MCI_DTOR, AT91_MCI_DTOMUL_1M | AT91_MCI_DTOCYC);
 463         mr = AT91_MCI_PDCMODE | 0x34a;
 464
 465         if (cpu_is_at91sam9260() || cpu_is_at91sam9263())
 466                 mr |= AT91_MCI_RDPROOF | AT91_MCI_WRPROOF;
 467
 468         at91_mci_write(host, AT91_MCI_MR, mr);
 469
 470         /* use Slot A or B (only one at same time) */
 471         at91_mci_write(host, AT91_MCI_SDCR, host->board->slot_b);
 472 }
 473
 474 /*
 475  * Disable the controller
 476  */
 477 static void at91_mci_disable(struct at91mci_host *host)
 478 {
 479         at91_mci_write(host, AT91_MCI_CR, AT91_MCI_MCIDIS | AT91_MCI_SWRST);
 480 }
 481
 482 /*
 483  * Send a command
 484  */
 485 static void at91_mci_send_command(struct at91mci_host *host, struct mmc_command *cmd)
 486 {
 487         unsigned int cmdr, mr;
 488         unsigned int block_length;
 489         struct mmc_data *data = cmd->data;
 490
 491         unsigned int blocks;
 492         unsigned int ier = 0;
 493
 494         host->cmd = cmd;
 495
 496         /* Needed for leaving busy state before CMD1 */
 497         if ((at91_mci_read(host, AT91_MCI_SR) & AT91_MCI_RTOE) && (cmd->opcode == 1)) {
 498                 pr_debug("Clearing timeout\n");
 499                 at91_mci_write(host, AT91_MCI_ARGR, 0);
 500                 at91_mci_write(host, AT91_MCI_CMDR, AT91_MCI_OPDCMD);
 501                 while (!(at91_mci_read(host, AT91_MCI_SR) & AT91_MCI_CMDRDY)) {
 502                         /* spin */
 503                         pr_debug("Clearing: SR = %08X\n", at91_mci_read(host, AT91_MCI_SR));
 504                 }
 505         }
 506
 507         cmdr = cmd->opcode;
 508
 509         if (mmc_resp_type(cmd) == MMC_RSP_NONE)
 510                 cmdr |= AT91_MCI_RSPTYP_NONE;
 511         else {
 512                 /* if a response is expected then allow maximum response latancy */
 513                 cmdr |= AT91_MCI_MAXLAT;
 514                 /* set 136 bit response for R2, 48 bit response otherwise */
 515                 if (mmc_resp_type(cmd) == MMC_RSP_R2)
 516                         cmdr |= AT91_MCI_RSPTYP_136;
 517                 else
 518                         cmdr |= AT91_MCI_RSPTYP_48;
 519         }
 520
 521         if (data) {
 522
 523                 if ( cpu_is_at91rm9200() && (data->blksz & 0x3) ) {
 524                         pr_debug("Unsupported block size\n");
 525                         cmd->error = -EINVAL;
 526                         mmc_request_done(host->mmc, host->request);
 527                         return;
 528                 }
 529
 530                 block_length = data->blksz;
 531                 blocks = data->blocks;
 532
 533                 /* always set data start - also set direction flag for read */
 534                 if (data->flags & MMC_DATA_READ)
 535                         cmdr |= (AT91_MCI_TRDIR | AT91_MCI_TRCMD_START);
 536                 else if (data->flags & MMC_DATA_WRITE)
 537                         cmdr |= AT91_MCI_TRCMD_START;
 538
 539                 if (data->flags & MMC_DATA_STREAM)
 540                         cmdr |= AT91_MCI_TRTYP_STREAM;
 541                 if (data->blocks > 1)
 542                         cmdr |= AT91_MCI_TRTYP_MULTIPLE;
 543         }
 544         else {
 545                 block_length = 0;
 546                 blocks = 0;
 547         }
 548
 549         if (host->flags & FL_SENT_STOP)
 550                 cmdr |= AT91_MCI_TRCMD_STOP;
 551
 552         if (host->bus_mode == MMC_BUSMODE_OPENDRAIN)
 553                 cmdr |= AT91_MCI_OPDCMD;
 554
 555         /*
 556          * Set the arguments and send the command
 557          */
 558         pr_debug("Sending command %d as %08X, arg = %08X, blocks = %d, length = %d (MR = %08X)\n",
 559                 cmd->opcode, cmdr, cmd->arg, blocks, block_length, at91_mci_read(host, AT91_MCI_MR));
 560
 561         if (!data) {
 562                 at91_mci_write(host, ATMEL_PDC_PTCR, ATMEL_PDC_TXTDIS | ATMEL_PDC_RXTDIS);
 563                 at91_mci_write(host, ATMEL_PDC_RPR, 0);
 564                 at91_mci_write(host, ATMEL_PDC_RCR, 0);
 565                 at91_mci_write(host, ATMEL_PDC_RNPR, 0);
 566                 at91_mci_write(host, ATMEL_PDC_RNCR, 0);
 567                 at91_mci_write(host, ATMEL_PDC_TPR, 0);
 568                 at91_mci_write(host, ATMEL_PDC_TCR, 0);
 569                 at91_mci_write(host, ATMEL_PDC_TNPR, 0);
 570                 at91_mci_write(host, ATMEL_PDC_TNCR, 0);
 571                 ier = AT91_MCI_CMDRDY;
 572         } else {
 573                 /* zero block length and PDC mode */
 574                 mr = at91_mci_read(host, AT91_MCI_MR) & 0x7fff;
 575                 mr |= (data->blksz & 0x3) ? AT91_MCI_PDCFBYTE : 0;
 576                 mr |= (block_length << 16);
 577                 mr |= AT91_MCI_PDCMODE;
 578                 at91_mci_write(host, AT91_MCI_MR, mr);
 579
 580                 if (!cpu_is_at91rm9200())
 581                         at91_mci_write(host, AT91_MCI_BLKR,
 582                                 AT91_MCI_BLKR_BCNT(blocks) |
 583                                 AT91_MCI_BLKR_BLKLEN(block_length));
 584
 585                 /*
 586                  * Disable the PDC controller
 587                  */
 588                 at91_mci_write(host, ATMEL_PDC_PTCR, ATMEL_PDC_RXTDIS | ATMEL_PDC_TXTDIS);
 589
 590                 if (cmdr & AT91_MCI_TRCMD_START) {
 591                         data->bytes_xfered = 0;
 592                         host->transfer_index = 0;
 593                         host->in_use_index = 0;
 594                         if (cmdr & AT91_MCI_TRDIR) {
 595                                 /*
 596                                  * Handle a read
 597                                  */
 598                                 host->buffer = NULL;
 599                                 host->total_length = 0;
 600
 601                                 at91_mci_pre_dma_read(host);
 602                                 ier = AT91_MCI_ENDRX /* | AT91_MCI_RXBUFF */;
 603                         }
 604                         else {
 605                                 /*
 606                                  * Handle a write
 607                                  */
 608                                 host->total_length = block_length * blocks;
 609                                 /*
 610                                  * AT91SAM926[0/3] Data Write Operation and
 611                                  * number of bytes erratum
 612                                  */
 613                                 if (cpu_is_at91sam9260 () || cpu_is_at91sam9263())
 614                                         if (host->total_length < 12)
 615                                                 host->total_length = 12;
 616                                 host->buffer = dma_alloc_coherent(NULL,
 617                                                 host->total_length,
 618                                                 &host->physical_address, GFP_KERNEL);
 619
 620                                 at91_mci_sg_to_dma(host, data);
 621
 622                                 pr_debug("Transmitting %d bytes\n", host->total_length);
 623
 624                                 at91_mci_write(host, ATMEL_PDC_TPR, host->physical_address);
 625                                 at91_mci_write(host, ATMEL_PDC_TCR, (data->blksz & 0x3) ?
 626                                                 host->total_length : host->total_length / 4);
 627
 628                                 ier = AT91_MCI_CMDRDY;
 629                         }
 630                 }
 631         }
 632
 633         /*
 634          * Send the command and then enable the PDC - not the other way round as
 635          * the data sheet says
 636          */
 637
 638         at91_mci_write(host, AT91_MCI_ARGR, cmd->arg);
 639         at91_mci_write(host, AT91_MCI_CMDR, cmdr);
 640
 641         if (cmdr & AT91_MCI_TRCMD_START) {
 642                 if (cmdr & AT91_MCI_TRDIR)
 643                         at91_mci_write(host, ATMEL_PDC_PTCR, ATMEL_PDC_RXTEN);
 644         }
 645
 646         /* Enable selected interrupts */
 647         at91_mci_write(host, AT91_MCI_IER, AT91_MCI_ERRORS | ier);
 648 }
 649
 650 /*
 651  * Process the next step in the request
 652  */
 653 static void at91_mci_process_next(struct at91mci_host *host)
 654 {
 655         if (!(host->flags & FL_SENT_COMMAND)) {
 656                 host->flags |= FL_SENT_COMMAND;
 657                 at91_mci_send_command(host, host->request->cmd);
 658         }
 659         else if ((!(host->flags & FL_SENT_STOP)) && host->request->stop) {
 660                 host->flags |= FL_SENT_STOP;
 661                 at91_mci_send_command(host, host->request->stop);
 662         } else {
 663                 del_timer(&host->timer);
 664                 /* the at91rm9200 mci controller hangs after some transfers,
 665                  * and the workaround is to reset it after each transfer.
 666                  */
 667                 if (cpu_is_at91rm9200())
 668                         at91_reset_host(host);
 669                 mmc_request_done(host->mmc, host->request);
 670         }
 671 }
 672
 673 /*
 674  * Handle a command that has been completed
 675  */
 676 static void at91_mci_completed_command(struct at91mci_host *host, unsigned int status)
 677 {
 678         struct mmc_command *cmd = host->cmd;
 679         struct mmc_data *data = cmd->data;
 680
 681         at91_mci_write(host, AT91_MCI_IDR, 0xffffffff & ~(AT91_MCI_SDIOIRQA | AT91_MCI_SDIOIRQB));
 682
 683         cmd->resp[0] = at91_mci_read(host, AT91_MCI_RSPR(0));
 684         cmd->resp[1] = at91_mci_read(host, AT91_MCI_RSPR(1));
 685         cmd->resp[2] = at91_mci_read(host, AT91_MCI_RSPR(2));
 686         cmd->resp[3] = at91_mci_read(host, AT91_MCI_RSPR(3));
 687
 688         if (host->buffer) {
 689                 dma_free_coherent(NULL, host->total_length, host->buffer, host->physical_address);
 690                 host->buffer = NULL;
 691         }
 692
 693         pr_debug("Status = %08X/%08x [%08X %08X %08X %08X]\n",
 694                  status, at91_mci_read(host, AT91_MCI_SR),
 695                  cmd->resp[0], cmd->resp[1], cmd->resp[2], cmd->resp[3]);
 696
 697         if (status & AT91_MCI_ERRORS) {
 698                 if ((status & AT91_MCI_RCRCE) && !(mmc_resp_type(cmd) & MMC_RSP_CRC)) {
 699                         cmd->error = 0;
 700                 }
 701                 else {
 702                         if (status & (AT91_MCI_DTOE | AT91_MCI_DCRCE)) {
 703                                 if (data) {
 704                                         if (status & AT91_MCI_DTOE)
 705                                                 data->error = -ETIMEDOUT;
 706                                         else if (status & AT91_MCI_DCRCE)
 707                                                 data->error = -EILSEQ;
 708                                 }
 709                         } else {
 710                                 if (status & AT91_MCI_RTOE)
 711                                         cmd->error = -ETIMEDOUT;
 712                                 else if (status & AT91_MCI_RCRCE)
 713                                         cmd->error = -EILSEQ;
 714                                 else
 715                                         cmd->error = -EIO;
 716                         }
 717
 718                         pr_debug("Error detected and set to %d/%d (cmd = %d, retries = %d)\n",
 719                                 cmd->error, data ? data->error : 0,
 720                                  cmd->opcode, cmd->retries);
 721                 }
 722         }
 723         else
 724                 cmd->error = 0;
 725
 726         at91_mci_process_next(host);
 727 }
 728
 729 /*
 730  * Handle an MMC request
 731  */
 732 static void at91_mci_request(struct mmc_host *mmc, struct mmc_request *mrq)
 733 {
 734         struct at91mci_host *host = mmc_priv(mmc);
 735         host->request = mrq;
 736         host->flags = 0;
 737
 738         mod_timer(&host->timer, jiffies +  HZ);
 739
 740         at91_mci_process_next(host);
 741 }
 742
 743 /*
 744  * Set the IOS
 745  */
 746 static void at91_mci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 747 {
 748         int clkdiv;
 749         struct at91mci_host *host = mmc_priv(mmc);
 750         unsigned long at91_master_clock = clk_get_rate(host->mci_clk);
 751
 752         host->bus_mode = ios->bus_mode;
 753
 754         if (ios->clock == 0) {
 755                 /* Disable the MCI controller */
 756                 at91_mci_write(host, AT91_MCI_CR, AT91_MCI_MCIDIS);
 757                 clkdiv = 0;
 758         }
 759         else {
 760                 /* Enable the MCI controller */
 761                 at91_mci_write(host, AT91_MCI_CR, AT91_MCI_MCIEN);
 762
 763                 if ((at91_master_clock % (ios->clock * 2)) == 0)
 764                         clkdiv = ((at91_master_clock / ios->clock) / 2) - 1;
 765                 else
 766                         clkdiv = (at91_master_clock / ios->clock) / 2;
 767
 768                 pr_debug("clkdiv = %d. mcck = %ld\n", clkdiv,
 769                         at91_master_clock / (2 * (clkdiv + 1)));
 770         }
 771         if (ios->bus_width == MMC_BUS_WIDTH_4 && host->board->wire4) {
 772                 pr_debug("MMC: Setting controller bus width to 4\n");
 773                 at91_mci_write(host, AT91_MCI_SDCR, at91_mci_read(host, AT91_MCI_SDCR) | AT91_MCI_SDCBUS);
 774         }
 775         else {
 776                 pr_debug("MMC: Setting controller bus width to 1\n");
 777                 at91_mci_write(host, AT91_MCI_SDCR, at91_mci_read(host, AT91_MCI_SDCR) & ~AT91_MCI_SDCBUS);
 778         }
 779
 780         /* Set the clock divider */
 781         at91_mci_write(host, AT91_MCI_MR, (at91_mci_read(host, AT91_MCI_MR) & ~AT91_MCI_CLKDIV) | clkdiv);
 782
 783         /* maybe switch power to the card */
 784         if (host->board->vcc_pin) {
 785                 switch (ios->power_mode) {
 786                         case MMC_POWER_OFF:
 787                                 gpio_set_value(host->board->vcc_pin, 0);
 788                                 break;
 789                         case MMC_POWER_UP:
 790                                 gpio_set_value(host->board->vcc_pin, 1);
 791                                 break;
 792                         case MMC_POWER_ON:
 793                                 break;
 794                         default:
 795                                 WARN_ON(1);
 796                 }
 797         }
 798 }
 799
 800 /*
 801  * Handle an interrupt
 802  */
 803 static irqreturn_t at91_mci_irq(int irq, void *devid)
 804 {
 805         struct at91mci_host *host = devid;
 806         int completed = 0;
 807         unsigned int int_status, int_mask;
 808
 809         int_status = at91_mci_read(host, AT91_MCI_SR);
 810         int_mask = at91_mci_read(host, AT91_MCI_IMR);
 811
 812         pr_debug("MCI irq: status = %08X, %08X, %08X\n", int_status, int_mask,
 813                 int_status & int_mask);
 814
 815         int_status = int_status & int_mask;
 816
 817         if (int_status & AT91_MCI_ERRORS) {
 818                 completed = 1;
 819
 820                 if (int_status & AT91_MCI_UNRE)
 821                         pr_debug("MMC: Underrun error\n");
 822                 if (int_status & AT91_MCI_OVRE)
 823                         pr_debug("MMC: Overrun error\n");
 824                 if (int_status & AT91_MCI_DTOE)
 825                         pr_debug("MMC: Data timeout\n");
 826                 if (int_status & AT91_MCI_DCRCE)
 827                         pr_debug("MMC: CRC error in data\n");
 828                 if (int_status & AT91_MCI_RTOE)
 829                         pr_debug("MMC: Response timeout\n");
 830                 if (int_status & AT91_MCI_RENDE)
 831                         pr_debug("MMC: Response end bit error\n");
 832                 if (int_status & AT91_MCI_RCRCE)
 833                         pr_debug("MMC: Response CRC error\n");
 834                 if (int_status & AT91_MCI_RDIRE)
 835                         pr_debug("MMC: Response direction error\n");
 836                 if (int_status & AT91_MCI_RINDE)
 837                         pr_debug("MMC: Response index error\n");
 838         } else {
 839                 /* Only continue processing if no errors */
 840
 841                 if (int_status & AT91_MCI_TXBUFE) {
 842                         pr_debug("TX buffer empty\n");
 843                         at91_mci_handle_transmitted(host);
 844                 }
 845
 846                 if (int_status & AT91_MCI_ENDRX) {
 847                         pr_debug("ENDRX\n");
 848                         at91_mci_post_dma_read(host);
 849                 }
 850
 851                 if (int_status & AT91_MCI_RXBUFF) {
 852                         pr_debug("RX buffer full\n");
 853                         at91_mci_write(host, ATMEL_PDC_PTCR, ATMEL_PDC_RXTDIS | ATMEL_PDC_TXTDIS);
 854                         at91_mci_write(host, AT91_MCI_IDR, AT91_MCI_RXBUFF | AT91_MCI_ENDRX);
 855                         completed = 1;
 856                 }
 857
 858                 if (int_status & AT91_MCI_ENDTX)
 859                         pr_debug("Transmit has ended\n");
 860
 861                 if (int_status & AT91_MCI_NOTBUSY) {
 862                         pr_debug("Card is ready\n");
 863                         at91_mci_update_bytes_xfered(host);
 864                         completed = 1;
 865                 }
 866
 867                 if (int_status & AT91_MCI_DTIP)
 868                         pr_debug("Data transfer in progress\n");
 869
 870                 if (int_status & AT91_MCI_BLKE) {
 871                         pr_debug("Block transfer has ended\n");
 872                         if (host->request->data && host->request->data->blocks > 1) {
 873                                 /* multi block write : complete multi write
 874                                  * command and send stop */
 875                                 completed = 1;
 876                         } else {
 877                                 at91_mci_write(host, AT91_MCI_IER, AT91_MCI_NOTBUSY);
 878                         }
 879                 }
 880
 881                 if (int_status & AT91_MCI_SDIOIRQA)
 882                         mmc_signal_sdio_irq(host->mmc);
 883
 884                 if (int_status & AT91_MCI_SDIOIRQB)
 885                         mmc_signal_sdio_irq(host->mmc);
 886
 887                 if (int_status & AT91_MCI_TXRDY)
 888                         pr_debug("Ready to transmit\n");
 889
 890                 if (int_status & AT91_MCI_RXRDY)
 891                         pr_debug("Ready to receive\n");
 892
 893                 if (int_status & AT91_MCI_CMDRDY) {
 894                         pr_debug("Command ready\n");
 895                         completed = at91_mci_handle_cmdrdy(host);
 896                 }
 897         }
 898
 899         if (completed) {
 900                 pr_debug("Completed command\n");
 901                 at91_mci_write(host, AT91_MCI_IDR, 0xffffffff & ~(AT91_MCI_SDIOIRQA | AT91_MCI_SDIOIRQB));
 902                 at91_mci_completed_command(host, int_status);
 903         } else
 904                 at91_mci_write(host, AT91_MCI_IDR, int_status & ~(AT91_MCI_SDIOIRQA | AT91_MCI_SDIOIRQB));
 905
 906         return IRQ_HANDLED;
 907 }
 908
 909 static irqreturn_t at91_mmc_det_irq(int irq, void *_host)
 910 {
 911         struct at91mci_host *host = _host;
 912         int present = !gpio_get_value(irq_to_gpio(irq));
 913
 914         /*
 915          * we expect this irq on both insert and remove,
 916          * and use a short delay to debounce.
 917          */
 918         if (present != host->present) {
 919                 host->present = present;
 920                 pr_debug("%s: card %s\n", mmc_hostname(host->mmc),
 921                         present ? "insert" : "remove");
 922                 if (!present) {
 923                         pr_debug("****** Resetting SD-card bus width ******\n");
 924                         at91_mci_write(host, AT91_MCI_SDCR, at91_mci_read(host, AT91_MCI_SDCR) & ~AT91_MCI_SDCBUS);
 925                 }
 926                 mmc_detect_change(host->mmc, msecs_to_jiffies(100));
 927         }
 928         return IRQ_HANDLED;
 929 }
 930
 931 static int at91_mci_get_ro(struct mmc_host *mmc)
 932 {
 933         struct at91mci_host *host = mmc_priv(mmc);
 934
 935         if (host->board->wp_pin)
 936                 return !!gpio_get_value(host->board->wp_pin);
 937         /*
 938          * Board doesn't support read only detection; let the mmc core
 939          * decide what to do.
 940          */
 941         return -ENOSYS;
 942 }
 943
 944 static void at91_mci_enable_sdio_irq(struct mmc_host *mmc, int enable)
 945 {
 946         struct at91mci_host *host = mmc_priv(mmc);
 947
 948         pr_debug("%s: sdio_irq %c : %s\n", mmc_hostname(host->mmc),
 949                 host->board->slot_b ? 'B':'A', enable ? "enable" : "disable");
 950         at91_mci_write(host, enable ? AT91_MCI_IER : AT91_MCI_IDR,
 951                 host->board->slot_b ? AT91_MCI_SDIOIRQB : AT91_MCI_SDIOIRQA);
 952
 953 }
 954
 955 static const struct mmc_host_ops at91_mci_ops = {
 956         .request        = at91_mci_request,
 957         .set_ios        = at91_mci_set_ios,
 958         .get_ro         = at91_mci_get_ro,
 959         .enable_sdio_irq = at91_mci_enable_sdio_irq,
 960 };
 961
 962 /*
 963  * Probe for the device
 964  */
 965 static int __init at91_mci_probe(struct platform_device *pdev)
 966 {
 967         struct mmc_host *mmc;
 968         struct at91mci_host *host;
 969         struct resource *res;
 970         int ret;
 971
 972         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 973         if (!res)
 974                 return -ENXIO;
 975
 976         if (!request_mem_region(res->start, res->end - res->start + 1, DRIVER_NAME))
 977                 return -EBUSY;
 978
 979         mmc = mmc_alloc_host(sizeof(struct at91mci_host), &pdev->dev);
 980         if (!mmc) {
 981                 ret = -ENOMEM;
 982                 dev_dbg(&pdev->dev, "couldn't allocate mmc host\n");
 983                 goto fail6;
 984         }
 985
 986         mmc->ops = &at91_mci_ops;
 987         mmc->f_min = 375000;
 988         mmc->f_max = 25000000;
 989         mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
 990         mmc->caps = MMC_CAP_MULTIWRITE | MMC_CAP_SDIO_IRQ;
 991
 992         mmc->max_blk_size = 4095;
 993         mmc->max_blk_count = mmc->max_req_size;
 994
 995         host = mmc_priv(mmc);
 996         host->mmc = mmc;
 997         host->buffer = NULL;
 998         host->bus_mode = 0;
 999         host->board = pdev->dev.platform_data;
1000         if (host->board->wire4) {
1001                 if (cpu_is_at91sam9260() || cpu_is_at91sam9263())
1002                         mmc->caps |= MMC_CAP_4_BIT_DATA;
1003                 else
1004                         dev_warn(&pdev->dev, "4 wire bus mode not supported"
1005                                 " - using 1 wire\n");
1006         }
1007
1008         /*
1009          * Reserve GPIOs ... board init code makes sure these pins are set
1010          * up as GPIOs with the right direction (input, except for vcc)
1011          */
1012         if (host->board->det_pin) {
1013                 ret = gpio_request(host->board->det_pin, "mmc_detect");
1014                 if (ret < 0) {
1015                         dev_dbg(&pdev->dev, "couldn't claim card detect pin\n");
1016                         goto fail5;
1017                 }
1018         }
1019         if (host->board->wp_pin) {
1020                 ret = gpio_request(host->board->wp_pin, "mmc_wp");
1021                 if (ret < 0) {
1022                         dev_dbg(&pdev->dev, "couldn't claim wp sense pin\n");
1023                         goto fail4;
1024                 }
1025         }
1026         if (host->board->vcc_pin) {
1027                 ret = gpio_request(host->board->vcc_pin, "mmc_vcc");
1028                 if (ret < 0) {
1029                         dev_dbg(&pdev->dev, "couldn't claim vcc switch pin\n");
1030                         goto fail3;
1031                 }
1032         }
1033
1034         /*
1035          * Get Clock
1036          */
1037         host->mci_clk = clk_get(&pdev->dev, "mci_clk");
1038         if (IS_ERR(host->mci_clk)) {
1039                 ret = -ENODEV;
1040                 dev_dbg(&pdev->dev, "no mci_clk?\n");
1041                 goto fail2;
1042         }
1043
1044         /*
1045          * Map I/O region
1046          */
1047         host->baseaddr = ioremap(res->start, res->end - res->start + 1);
1048         if (!host->baseaddr) {
1049                 ret = -ENOMEM;
1050                 goto fail1;
1051         }
1052
1053         /*
1054          * Reset hardware
1055          */
1056         clk_enable(host->mci_clk);              /* Enable the peripheral clock */
1057         at91_mci_disable(host);
1058         at91_mci_enable(host);
1059
1060         /*
1061          * Allocate the MCI interrupt
1062          */
1063         host->irq = platform_get_irq(pdev, 0);
1064         ret = request_irq(host->irq, at91_mci_irq, IRQF_SHARED,
1065                         mmc_hostname(mmc), host);
1066         if (ret) {
1067                 dev_dbg(&pdev->dev, "request MCI interrupt failed\n");
1068                 goto fail0;
1069         }
1070
1071         platform_set_drvdata(pdev, mmc);
1072
1073         /*
1074          * Add host to MMC layer
1075          */
1076         if (host->board->det_pin) {
1077                 host->present = !gpio_get_value(host->board->det_pin);
1078         }
1079         else
1080                 host->present = -1;
1081
1082         mmc_add_host(mmc);
1083
1084         setup_timer(&host->timer, at91_timeout_timer, (unsigned long)host);
1085
1086         /*
1087          * monitor card insertion/removal if we can
1088          */
1089         if (host->board->det_pin) {
1090                 ret = request_irq(gpio_to_irq(host->board->det_pin),
1091                                 at91_mmc_det_irq, 0, mmc_hostname(mmc), host);
1092                 if (ret)
1093                         dev_warn(&pdev->dev, "request MMC detect irq failed\n");
1094                 else
1095                         device_init_wakeup(&pdev->dev, 1);
1096         }
1097
1098         pr_debug("Added MCI driver\n");
1099
1100         return 0;
1101
1102 fail0:
1103         clk_disable(host->mci_clk);
1104         iounmap(host->baseaddr);
1105 fail1:
1106         clk_put(host->mci_clk);
1107 fail2:
1108         if (host->board->vcc_pin)
1109                 gpio_free(host->board->vcc_pin);
1110 fail3:
1111         if (host->board->wp_pin)
1112                 gpio_free(host->board->wp_pin);
1113 fail4:
1114         if (host->board->det_pin)
1115                 gpio_free(host->board->det_pin);
1116 fail5:
1117         mmc_free_host(mmc);
1118 fail6:
1119         release_mem_region(res->start, res->end - res->start + 1);
1120         dev_err(&pdev->dev, "probe failed, err %d\n", ret);
1121         return ret;
1122 }
1123
1124 /*
1125  * Remove a device
1126  */
1127 static int __exit at91_mci_remove(struct platform_device *pdev)
1128 {
1129         struct mmc_host *mmc = platform_get_drvdata(pdev);
1130         struct at91mci_host *host;
1131         struct resource *res;
1132
1133         if (!mmc)
1134                 return -1;
1135
1136         host = mmc_priv(mmc);
1137
1138         if (host->board->det_pin) {
1139                 if (device_can_wakeup(&pdev->dev))
1140                         free_irq(gpio_to_irq(host->board->det_pin), host);
1141                 device_init_wakeup(&pdev->dev, 0);
1142                 gpio_free(host->board->det_pin);
1143         }
1144
1145         at91_mci_disable(host);
1146         del_timer_sync(&host->timer);
1147         mmc_remove_host(mmc);
1148         free_irq(host->irq, host);
1149
1150         clk_disable(host->mci_clk);                     /* Disable the peripheral clock */
1151         clk_put(host->mci_clk);
1152
1153         if (host->board->vcc_pin)
1154                 gpio_free(host->board->vcc_pin);
1155         if (host->board->wp_pin)
1156                 gpio_free(host->board->wp_pin);
1157
1158         iounmap(host->baseaddr);
1159         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1160         release_mem_region(res->start, res->end - res->start + 1);
1161
1162         mmc_free_host(mmc);
1163         platform_set_drvdata(pdev, NULL);
1164         pr_debug("MCI Removed\n");
1165
1166         return 0;
1167 }
1168
1169 #ifdef CONFIG_PM
1170 static int at91_mci_suspend(struct platform_device *pdev, pm_message_t state)
1171 {
1172         struct mmc_host *mmc = platform_get_drvdata(pdev);
1173         struct at91mci_host *host = mmc_priv(mmc);
1174         int ret = 0;
1175
1176         if (host->board->det_pin && device_may_wakeup(&pdev->dev))
1177                 enable_irq_wake(host->board->det_pin);
1178
1179         if (mmc)
1180                 ret = mmc_suspend_host(mmc, state);
1181
1182         return ret;
1183 }
1184
1185 static int at91_mci_resume(struct platform_device *pdev)
1186 {
1187         struct mmc_host *mmc = platform_get_drvdata(pdev);
1188         struct at91mci_host *host = mmc_priv(mmc);
1189         int ret = 0;
1190
1191         if (host->board->det_pin && device_may_wakeup(&pdev->dev))
1192                 disable_irq_wake(host->board->det_pin);
1193
1194         if (mmc)
1195                 ret = mmc_resume_host(mmc);
1196
1197         return ret;
1198 }
1199 #else
1200 #define at91_mci_suspend        NULL
1201 #define at91_mci_resume         NULL
1202 #endif
1203
1204 static struct platform_driver at91_mci_driver = {
1205         .remove         = __exit_p(at91_mci_remove),
1206         .suspend        = at91_mci_suspend,
1207         .resume         = at91_mci_resume,
1208         .driver         = {
1209                 .name   = DRIVER_NAME,
1210                 .owner  = THIS_MODULE,
1211         },
1212 };
1213
1214 static int __init at91_mci_init(void)
1215 {
1216         return platform_driver_probe(&at91_mci_driver, at91_mci_probe);
1217 }
1218
1219 static void __exit at91_mci_exit(void)
1220 {
1221         platform_driver_unregister(&at91_mci_driver);
1222 }
1223
1224 module_init(at91_mci_init);
1225 module_exit(at91_mci_exit);
1226
1227 MODULE_DESCRIPTION("AT91 Multimedia Card Interface driver");
1228 MODULE_AUTHOR("Nick Randell");
1229 MODULE_LICENSE("GPL");
1230 MODULE_ALIAS("platform:at91_mci");