[MMC] Move set_ios debugging into mmc.c
[linux-2.6] / drivers / mmc / at91_mci.c
1 /*
2  *  linux/drivers/mmc/at91_mci.c - ATMEL AT91RM9200 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 AT91RM9200 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 controller, when a read is completed, all the words are byte
42      swapped in the scatterlist buffers.
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/config.h>
57 #include <linux/module.h>
58 #include <linux/moduleparam.h>
59 #include <linux/init.h>
60 #include <linux/ioport.h>
61 #include <linux/platform_device.h>
62 #include <linux/interrupt.h>
63 #include <linux/blkdev.h>
64 #include <linux/delay.h>
65 #include <linux/err.h>
66 #include <linux/dma-mapping.h>
67 #include <linux/clk.h>
68
69 #include <linux/mmc/host.h>
70 #include <linux/mmc/protocol.h>
71
72 #include <asm/io.h>
73 #include <asm/irq.h>
74 #include <asm/mach/mmc.h>
75 #include <asm/arch/board.h>
76 #include <asm/arch/gpio.h>
77 #include <asm/arch/at91rm9200_mci.h>
78 #include <asm/arch/at91rm9200_pdc.h>
79
80 #define DRIVER_NAME "at91_mci"
81
82 #undef  SUPPORT_4WIRE
83
84 #ifdef CONFIG_MMC_DEBUG
85 #define DBG(fmt...)     \
86         printk(fmt)
87 #else
88 #define DBG(fmt...)     do { } while (0)
89 #endif
90
91 static struct clk *mci_clk;
92
93 #define FL_SENT_COMMAND (1 << 0)
94 #define FL_SENT_STOP (1 << 1)
95
96
97
98 /*
99  * Read from a MCI register.
100  */
101 static inline unsigned long at91_mci_read(unsigned int reg)
102 {
103         void __iomem *mci_base = (void __iomem *)AT91_VA_BASE_MCI;
104
105         return __raw_readl(mci_base + reg);
106 }
107
108 /*
109  * Write to a MCI register.
110  */
111 static inline void at91_mci_write(unsigned int reg, unsigned long value)
112 {
113         void __iomem *mci_base = (void __iomem *)AT91_VA_BASE_MCI;
114
115         __raw_writel(value, mci_base + reg);
116 }
117
118 /*
119  * Low level type for this driver
120  */
121 struct at91mci_host
122 {
123         struct mmc_host *mmc;
124         struct mmc_command *cmd;
125         struct mmc_request *request;
126
127         struct at91_mmc_data *board;
128         int present;
129
130         /*
131          * Flag indicating when the command has been sent. This is used to
132          * work out whether or not to send the stop
133          */
134         unsigned int flags;
135         /* flag for current bus settings */
136         u32 bus_mode;
137
138         /* DMA buffer used for transmitting */
139         unsigned int* buffer;
140         dma_addr_t physical_address;
141         unsigned int total_length;
142
143         /* Latest in the scatterlist that has been enabled for transfer, but not freed */
144         int in_use_index;
145
146         /* Latest in the scatterlist that has been enabled for transfer */
147         int transfer_index;
148 };
149
150 /*
151  * Copy from sg to a dma block - used for transfers
152  */
153 static inline void at91mci_sg_to_dma(struct at91mci_host *host, struct mmc_data *data)
154 {
155         unsigned int len, i, size;
156         unsigned *dmabuf = host->buffer;
157
158         size = host->total_length;
159         len = data->sg_len;
160
161         /*
162          * Just loop through all entries. Size might not
163          * be the entire list though so make sure that
164          * we do not transfer too much.
165          */
166         for (i = 0; i < len; i++) {
167                 struct scatterlist *sg;
168                 int amount;
169                 int index;
170                 unsigned int *sgbuffer;
171
172                 sg = &data->sg[i];
173
174                 sgbuffer = kmap_atomic(sg->page, KM_BIO_SRC_IRQ) + sg->offset;
175                 amount = min(size, sg->length);
176                 size -= amount;
177                 amount /= 4;
178
179                 for (index = 0; index < amount; index++)
180                         *dmabuf++ = swab32(sgbuffer[index]);
181
182                 kunmap_atomic(sgbuffer, KM_BIO_SRC_IRQ);
183
184                 if (size == 0)
185                         break;
186         }
187
188         /*
189          * Check that we didn't get a request to transfer
190          * more data than can fit into the SG list.
191          */
192         BUG_ON(size != 0);
193 }
194
195 /*
196  * Prepare a dma read
197  */
198 static void at91mci_pre_dma_read(struct at91mci_host *host)
199 {
200         int i;
201         struct scatterlist *sg;
202         struct mmc_command *cmd;
203         struct mmc_data *data;
204
205         DBG("pre dma read\n");
206
207         cmd = host->cmd;
208         if (!cmd) {
209                 DBG("no command\n");
210                 return;
211         }
212
213         data = cmd->data;
214         if (!data) {
215                 DBG("no data\n");
216                 return;
217         }
218
219         for (i = 0; i < 2; i++) {
220                 /* nothing left to transfer */
221                 if (host->transfer_index >= data->sg_len) {
222                         DBG("Nothing left to transfer (index = %d)\n", host->transfer_index);
223                         break;
224                 }
225
226                 /* Check to see if this needs filling */
227                 if (i == 0) {
228                         if (at91_mci_read(AT91_PDC_RCR) != 0) {
229                                 DBG("Transfer active in current\n");
230                                 continue;
231                         }
232                 }
233                 else {
234                         if (at91_mci_read(AT91_PDC_RNCR) != 0) {
235                                 DBG("Transfer active in next\n");
236                                 continue;
237                         }
238                 }
239
240                 /* Setup the next transfer */
241                 DBG("Using transfer index %d\n", host->transfer_index);
242
243                 sg = &data->sg[host->transfer_index++];
244                 DBG("sg = %p\n", sg);
245
246                 sg->dma_address = dma_map_page(NULL, sg->page, sg->offset, sg->length, DMA_FROM_DEVICE);
247
248                 DBG("dma address = %08X, length = %d\n", sg->dma_address, sg->length);
249
250                 if (i == 0) {
251                         at91_mci_write(AT91_PDC_RPR, sg->dma_address);
252                         at91_mci_write(AT91_PDC_RCR, sg->length / 4);
253                 }
254                 else {
255                         at91_mci_write(AT91_PDC_RNPR, sg->dma_address);
256                         at91_mci_write(AT91_PDC_RNCR, sg->length / 4);
257                 }
258         }
259
260         DBG("pre dma read done\n");
261 }
262
263 /*
264  * Handle after a dma read
265  */
266 static void at91mci_post_dma_read(struct at91mci_host *host)
267 {
268         struct mmc_command *cmd;
269         struct mmc_data *data;
270
271         DBG("post dma read\n");
272
273         cmd = host->cmd;
274         if (!cmd) {
275                 DBG("no command\n");
276                 return;
277         }
278
279         data = cmd->data;
280         if (!data) {
281                 DBG("no data\n");
282                 return;
283         }
284
285         while (host->in_use_index < host->transfer_index) {
286                 unsigned int *buffer;
287                 int index;
288                 int len;
289
290                 struct scatterlist *sg;
291
292                 DBG("finishing index %d\n", host->in_use_index);
293
294                 sg = &data->sg[host->in_use_index++];
295
296                 DBG("Unmapping page %08X\n", sg->dma_address);
297
298                 dma_unmap_page(NULL, sg->dma_address, sg->length, DMA_FROM_DEVICE);
299
300                 /* Swap the contents of the buffer */
301                 buffer = kmap_atomic(sg->page, KM_BIO_SRC_IRQ) + sg->offset;
302                 DBG("buffer = %p, length = %d\n", buffer, sg->length);
303
304                 data->bytes_xfered += sg->length;
305
306                 len = sg->length / 4;
307
308                 for (index = 0; index < len; index++) {
309                         buffer[index] = swab32(buffer[index]);
310                 }
311                 kunmap_atomic(buffer, KM_BIO_SRC_IRQ);
312                 flush_dcache_page(sg->page);
313         }
314
315         /* Is there another transfer to trigger? */
316         if (host->transfer_index < data->sg_len)
317                 at91mci_pre_dma_read(host);
318         else {
319                 at91_mci_write(AT91_MCI_IER, AT91_MCI_RXBUFF);
320                 at91_mci_write(AT91_PDC_PTCR, AT91_PDC_RXTDIS | AT91_PDC_TXTDIS);
321         }
322
323         DBG("post dma read done\n");
324 }
325
326 /*
327  * Handle transmitted data
328  */
329 static void at91_mci_handle_transmitted(struct at91mci_host *host)
330 {
331         struct mmc_command *cmd;
332         struct mmc_data *data;
333
334         DBG("Handling the transmit\n");
335
336         /* Disable the transfer */
337         at91_mci_write(AT91_PDC_PTCR, AT91_PDC_RXTDIS | AT91_PDC_TXTDIS);
338
339         /* Now wait for cmd ready */
340         at91_mci_write(AT91_MCI_IDR, AT91_MCI_TXBUFE);
341         at91_mci_write(AT91_MCI_IER, AT91_MCI_NOTBUSY);
342
343         cmd = host->cmd;
344         if (!cmd) return;
345
346         data = cmd->data;
347         if (!data) return;
348
349         data->bytes_xfered = host->total_length;
350 }
351
352 /*
353  * Enable the controller
354  */
355 static void at91_mci_enable(void)
356 {
357         at91_mci_write(AT91_MCI_CR, AT91_MCI_MCIEN);
358         at91_mci_write(AT91_MCI_IDR, 0xFFFFFFFF);
359         at91_mci_write(AT91_MCI_DTOR, AT91_MCI_DTOMUL_1M | AT91_MCI_DTOCYC);
360         at91_mci_write(AT91_MCI_MR, 0x834A);
361         at91_mci_write(AT91_MCI_SDCR, 0x0);
362 }
363
364 /*
365  * Disable the controller
366  */
367 static void at91_mci_disable(void)
368 {
369         at91_mci_write(AT91_MCI_CR, AT91_MCI_MCIDIS | AT91_MCI_SWRST);
370 }
371
372 /*
373  * Send a command
374  * return the interrupts to enable
375  */
376 static unsigned int at91_mci_send_command(struct at91mci_host *host, struct mmc_command *cmd)
377 {
378         unsigned int cmdr, mr;
379         unsigned int block_length;
380         struct mmc_data *data = cmd->data;
381
382         unsigned int blocks;
383         unsigned int ier = 0;
384
385         host->cmd = cmd;
386
387         /* Not sure if this is needed */
388 #if 0
389         if ((at91_mci_read(AT91_MCI_SR) & AT91_MCI_RTOE) && (cmd->opcode == 1)) {
390                 DBG("Clearing timeout\n");
391                 at91_mci_write(AT91_MCI_ARGR, 0);
392                 at91_mci_write(AT91_MCI_CMDR, AT91_MCI_OPDCMD);
393                 while (!(at91_mci_read(AT91_MCI_SR) & AT91_MCI_CMDRDY)) {
394                         /* spin */
395                         DBG("Clearing: SR = %08X\n", at91_mci_read(AT91_MCI_SR));
396                 }
397         }
398 #endif
399         cmdr = cmd->opcode;
400
401         if (mmc_resp_type(cmd) == MMC_RSP_NONE)
402                 cmdr |= AT91_MCI_RSPTYP_NONE;
403         else {
404                 /* if a response is expected then allow maximum response latancy */
405                 cmdr |= AT91_MCI_MAXLAT;
406                 /* set 136 bit response for R2, 48 bit response otherwise */
407                 if (mmc_resp_type(cmd) == MMC_RSP_R2)
408                         cmdr |= AT91_MCI_RSPTYP_136;
409                 else
410                         cmdr |= AT91_MCI_RSPTYP_48;
411         }
412
413         if (data) {
414                 block_length = 1 << data->blksz_bits;
415                 blocks = data->blocks;
416
417                 /* always set data start - also set direction flag for read */
418                 if (data->flags & MMC_DATA_READ)
419                         cmdr |= (AT91_MCI_TRDIR | AT91_MCI_TRCMD_START);
420                 else if (data->flags & MMC_DATA_WRITE)
421                         cmdr |= AT91_MCI_TRCMD_START;
422
423                 if (data->flags & MMC_DATA_STREAM)
424                         cmdr |= AT91_MCI_TRTYP_STREAM;
425                 if (data->flags & MMC_DATA_MULTI)
426                         cmdr |= AT91_MCI_TRTYP_MULTIPLE;
427         }
428         else {
429                 block_length = 0;
430                 blocks = 0;
431         }
432
433         if (cmd->opcode == MMC_STOP_TRANSMISSION)
434                 cmdr |= AT91_MCI_TRCMD_STOP;
435
436         if (host->bus_mode == MMC_BUSMODE_OPENDRAIN)
437                 cmdr |= AT91_MCI_OPDCMD;
438
439         /*
440          * Set the arguments and send the command
441          */
442         DBG("Sending command %d as %08X, arg = %08X, blocks = %d, length = %d (MR = %08lX)\n",
443                 cmd->opcode, cmdr, cmd->arg, blocks, block_length, at91_mci_read(AT91_MCI_MR));
444
445         if (!data) {
446                 at91_mci_write(AT91_PDC_PTCR, AT91_PDC_TXTDIS | AT91_PDC_RXTDIS);
447                 at91_mci_write(AT91_PDC_RPR, 0);
448                 at91_mci_write(AT91_PDC_RCR, 0);
449                 at91_mci_write(AT91_PDC_RNPR, 0);
450                 at91_mci_write(AT91_PDC_RNCR, 0);
451                 at91_mci_write(AT91_PDC_TPR, 0);
452                 at91_mci_write(AT91_PDC_TCR, 0);
453                 at91_mci_write(AT91_PDC_TNPR, 0);
454                 at91_mci_write(AT91_PDC_TNCR, 0);
455
456                 at91_mci_write(AT91_MCI_ARGR, cmd->arg);
457                 at91_mci_write(AT91_MCI_CMDR, cmdr);
458                 return AT91_MCI_CMDRDY;
459         }
460
461         mr = at91_mci_read(AT91_MCI_MR) & 0x7fff;       /* zero block length and PDC mode */
462         at91_mci_write(AT91_MCI_MR, mr | (block_length << 16) | AT91_MCI_PDCMODE);
463
464         /*
465          * Disable the PDC controller
466          */
467         at91_mci_write(AT91_PDC_PTCR, AT91_PDC_RXTDIS | AT91_PDC_TXTDIS);
468
469         if (cmdr & AT91_MCI_TRCMD_START) {
470                 data->bytes_xfered = 0;
471                 host->transfer_index = 0;
472                 host->in_use_index = 0;
473                 if (cmdr & AT91_MCI_TRDIR) {
474                         /*
475                          * Handle a read
476                          */
477                         host->buffer = NULL;
478                         host->total_length = 0;
479
480                         at91mci_pre_dma_read(host);
481                         ier = AT91_MCI_ENDRX /* | AT91_MCI_RXBUFF */;
482                 }
483                 else {
484                         /*
485                          * Handle a write
486                          */
487                         host->total_length = block_length * blocks;
488                         host->buffer = dma_alloc_coherent(NULL,
489                                                   host->total_length,
490                                                   &host->physical_address, GFP_KERNEL);
491
492                         at91mci_sg_to_dma(host, data);
493
494                         DBG("Transmitting %d bytes\n", host->total_length);
495
496                         at91_mci_write(AT91_PDC_TPR, host->physical_address);
497                         at91_mci_write(AT91_PDC_TCR, host->total_length / 4);
498                         ier = AT91_MCI_TXBUFE;
499                 }
500         }
501
502         /*
503          * Send the command and then enable the PDC - not the other way round as
504          * the data sheet says
505          */
506
507         at91_mci_write(AT91_MCI_ARGR, cmd->arg);
508         at91_mci_write(AT91_MCI_CMDR, cmdr);
509
510         if (cmdr & AT91_MCI_TRCMD_START) {
511                 if (cmdr & AT91_MCI_TRDIR)
512                         at91_mci_write(AT91_PDC_PTCR, AT91_PDC_RXTEN);
513                 else
514                         at91_mci_write(AT91_PDC_PTCR, AT91_PDC_TXTEN);
515         }
516         return ier;
517 }
518
519 /*
520  * Wait for a command to complete
521  */
522 static void at91mci_process_command(struct at91mci_host *host, struct mmc_command *cmd)
523 {
524         unsigned int ier;
525
526         ier = at91_mci_send_command(host, cmd);
527
528         DBG("setting ier to %08X\n", ier);
529
530         /* Stop on errors or the required value */
531         at91_mci_write(AT91_MCI_IER, 0xffff0000 | ier);
532 }
533
534 /*
535  * Process the next step in the request
536  */
537 static void at91mci_process_next(struct at91mci_host *host)
538 {
539         if (!(host->flags & FL_SENT_COMMAND)) {
540                 host->flags |= FL_SENT_COMMAND;
541                 at91mci_process_command(host, host->request->cmd);
542         }
543         else if ((!(host->flags & FL_SENT_STOP)) && host->request->stop) {
544                 host->flags |= FL_SENT_STOP;
545                 at91mci_process_command(host, host->request->stop);
546         }
547         else
548                 mmc_request_done(host->mmc, host->request);
549 }
550
551 /*
552  * Handle a command that has been completed
553  */
554 static void at91mci_completed_command(struct at91mci_host *host)
555 {
556         struct mmc_command *cmd = host->cmd;
557         unsigned int status;
558
559         at91_mci_write(AT91_MCI_IDR, 0xffffffff);
560
561         cmd->resp[0] = at91_mci_read(AT91_MCI_RSPR(0));
562         cmd->resp[1] = at91_mci_read(AT91_MCI_RSPR(1));
563         cmd->resp[2] = at91_mci_read(AT91_MCI_RSPR(2));
564         cmd->resp[3] = at91_mci_read(AT91_MCI_RSPR(3));
565
566         if (host->buffer) {
567                 dma_free_coherent(NULL, host->total_length, host->buffer, host->physical_address);
568                 host->buffer = NULL;
569         }
570
571         status = at91_mci_read(AT91_MCI_SR);
572
573         DBG("Status = %08X [%08X %08X %08X %08X]\n",
574                  status, cmd->resp[0], cmd->resp[1], cmd->resp[2], cmd->resp[3]);
575
576         if (status & (AT91_MCI_RINDE | AT91_MCI_RDIRE | AT91_MCI_RCRCE |
577                         AT91_MCI_RENDE | AT91_MCI_RTOE | AT91_MCI_DCRCE |
578                         AT91_MCI_DTOE | AT91_MCI_OVRE | AT91_MCI_UNRE)) {
579                 if ((status & AT91_MCI_RCRCE) &&
580                         ((cmd->opcode == MMC_SEND_OP_COND) || (cmd->opcode == SD_APP_OP_COND))) {
581                         cmd->error = MMC_ERR_NONE;
582                 }
583                 else {
584                         if (status & (AT91_MCI_RTOE | AT91_MCI_DTOE))
585                                 cmd->error = MMC_ERR_TIMEOUT;
586                         else if (status & (AT91_MCI_RCRCE | AT91_MCI_DCRCE))
587                                 cmd->error = MMC_ERR_BADCRC;
588                         else if (status & (AT91_MCI_OVRE | AT91_MCI_UNRE))
589                                 cmd->error = MMC_ERR_FIFO;
590                         else
591                                 cmd->error = MMC_ERR_FAILED;
592
593                         DBG("Error detected and set to %d (cmd = %d, retries = %d)\n",
594                                  cmd->error, cmd->opcode, cmd->retries);
595                 }
596         }
597         else
598                 cmd->error = MMC_ERR_NONE;
599
600         at91mci_process_next(host);
601 }
602
603 /*
604  * Handle an MMC request
605  */
606 static void at91_mci_request(struct mmc_host *mmc, struct mmc_request *mrq)
607 {
608         struct at91mci_host *host = mmc_priv(mmc);
609         host->request = mrq;
610         host->flags = 0;
611
612         at91mci_process_next(host);
613 }
614
615 /*
616  * Set the IOS
617  */
618 static void at91_mci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
619 {
620         int clkdiv;
621         struct at91mci_host *host = mmc_priv(mmc);
622         unsigned long at91_master_clock = clk_get_rate(mci_clk);
623
624         if (host)
625                 host->bus_mode = ios->bus_mode;
626         else
627                 printk("MMC: No host for bus_mode\n");
628
629         if (ios->clock == 0) {
630                 /* Disable the MCI controller */
631                 at91_mci_write(AT91_MCI_CR, AT91_MCI_MCIDIS);
632                 clkdiv = 0;
633         }
634         else {
635                 /* Enable the MCI controller */
636                 at91_mci_write(AT91_MCI_CR, AT91_MCI_MCIEN);
637
638                 if ((at91_master_clock % (ios->clock * 2)) == 0)
639                         clkdiv = ((at91_master_clock / ios->clock) / 2) - 1;
640                 else
641                         clkdiv = (at91_master_clock / ios->clock) / 2;
642
643                 DBG("clkdiv = %d. mcck = %ld\n", clkdiv,
644                         at91_master_clock / (2 * (clkdiv + 1)));
645         }
646         if (ios->bus_width == MMC_BUS_WIDTH_4 && host->board->wire4) {
647                 DBG("MMC: Setting controller bus width to 4\n");
648                 at91_mci_write(AT91_MCI_SDCR, at91_mci_read(AT91_MCI_SDCR) | AT91_MCI_SDCBUS);
649         }
650         else {
651                 DBG("MMC: Setting controller bus width to 1\n");
652                 at91_mci_write(AT91_MCI_SDCR, at91_mci_read(AT91_MCI_SDCR) & ~AT91_MCI_SDCBUS);
653         }
654
655         /* Set the clock divider */
656         at91_mci_write(AT91_MCI_MR, (at91_mci_read(AT91_MCI_MR) & ~AT91_MCI_CLKDIV) | clkdiv);
657
658         /* maybe switch power to the card */
659         if (host && host->board->vcc_pin) {
660                 switch (ios->power_mode) {
661                         case MMC_POWER_OFF:
662                                 at91_set_gpio_output(host->board->vcc_pin, 0);
663                                 break;
664                         case MMC_POWER_UP:
665                         case MMC_POWER_ON:
666                                 at91_set_gpio_output(host->board->vcc_pin, 1);
667                                 break;
668                 }
669         }
670 }
671
672 /*
673  * Handle an interrupt
674  */
675 static irqreturn_t at91_mci_irq(int irq, void *devid, struct pt_regs *regs)
676 {
677         struct at91mci_host *host = devid;
678         int completed = 0;
679
680         unsigned int int_status;
681
682         if (host == NULL)
683                 return IRQ_HANDLED;
684
685         int_status = at91_mci_read(AT91_MCI_SR);
686         DBG("MCI irq: status = %08X, %08lX, %08lX\n", int_status, at91_mci_read(AT91_MCI_IMR),
687                 int_status & at91_mci_read(AT91_MCI_IMR));
688
689         if ((int_status & at91_mci_read(AT91_MCI_IMR)) & 0xffff0000)
690                 completed = 1;
691
692         int_status &= at91_mci_read(AT91_MCI_IMR);
693
694         if (int_status & AT91_MCI_UNRE)
695                 DBG("MMC: Underrun error\n");
696         if (int_status & AT91_MCI_OVRE)
697                 DBG("MMC: Overrun error\n");
698         if (int_status & AT91_MCI_DTOE)
699                 DBG("MMC: Data timeout\n");
700         if (int_status & AT91_MCI_DCRCE)
701                 DBG("MMC: CRC error in data\n");
702         if (int_status & AT91_MCI_RTOE)
703                 DBG("MMC: Response timeout\n");
704         if (int_status & AT91_MCI_RENDE)
705                 DBG("MMC: Response end bit error\n");
706         if (int_status & AT91_MCI_RCRCE)
707                 DBG("MMC: Response CRC error\n");
708         if (int_status & AT91_MCI_RDIRE)
709                 DBG("MMC: Response direction error\n");
710         if (int_status & AT91_MCI_RINDE)
711                 DBG("MMC: Response index error\n");
712
713         /* Only continue processing if no errors */
714         if (!completed) {
715                 if (int_status & AT91_MCI_TXBUFE) {
716                         DBG("TX buffer empty\n");
717                         at91_mci_handle_transmitted(host);
718                 }
719
720                 if (int_status & AT91_MCI_RXBUFF) {
721                         DBG("RX buffer full\n");
722                         at91_mci_write(AT91_MCI_IER, AT91_MCI_CMDRDY);
723                 }
724
725                 if (int_status & AT91_MCI_ENDTX) {
726                         DBG("Transmit has ended\n");
727                 }
728
729                 if (int_status & AT91_MCI_ENDRX) {
730                         DBG("Receive has ended\n");
731                         at91mci_post_dma_read(host);
732                 }
733
734                 if (int_status & AT91_MCI_NOTBUSY) {
735                         DBG("Card is ready\n");
736                         at91_mci_write(AT91_MCI_IER, AT91_MCI_CMDRDY);
737                 }
738
739                 if (int_status & AT91_MCI_DTIP) {
740                         DBG("Data transfer in progress\n");
741                 }
742
743                 if (int_status & AT91_MCI_BLKE) {
744                         DBG("Block transfer has ended\n");
745                 }
746
747                 if (int_status & AT91_MCI_TXRDY) {
748                         DBG("Ready to transmit\n");
749                 }
750
751                 if (int_status & AT91_MCI_RXRDY) {
752                         DBG("Ready to receive\n");
753                 }
754
755                 if (int_status & AT91_MCI_CMDRDY) {
756                         DBG("Command ready\n");
757                         completed = 1;
758                 }
759         }
760         at91_mci_write(AT91_MCI_IDR, int_status);
761
762         if (completed) {
763                 DBG("Completed command\n");
764                 at91_mci_write(AT91_MCI_IDR, 0xffffffff);
765                 at91mci_completed_command(host);
766         }
767
768         return IRQ_HANDLED;
769 }
770
771 static irqreturn_t at91_mmc_det_irq(int irq, void *_host, struct pt_regs *regs)
772 {
773         struct at91mci_host *host = _host;
774         int present = !at91_get_gpio_value(irq);
775
776         /*
777          * we expect this irq on both insert and remove,
778          * and use a short delay to debounce.
779          */
780         if (present != host->present) {
781                 host->present = present;
782                 DBG("%s: card %s\n", mmc_hostname(host->mmc),
783                         present ? "insert" : "remove");
784                 if (!present) {
785                         DBG("****** Resetting SD-card bus width ******\n");
786                         at91_mci_write(AT91_MCI_SDCR, 0);
787                 }
788                 mmc_detect_change(host->mmc, msecs_to_jiffies(100));
789         }
790         return IRQ_HANDLED;
791 }
792
793 int at91_mci_get_ro(struct mmc_host *mmc)
794 {
795         int read_only = 0;
796         struct at91mci_host *host = mmc_priv(mmc);
797
798         if (host->board->wp_pin) {
799                 read_only = at91_get_gpio_value(host->board->wp_pin);
800                 printk(KERN_WARNING "%s: card is %s\n", mmc_hostname(mmc),
801                                 (read_only ? "read-only" : "read-write") );
802         }
803         else {
804                 printk(KERN_WARNING "%s: host does not support reading read-only "
805                                 "switch.  Assuming write-enable.\n", mmc_hostname(mmc));
806         }
807         return read_only;
808 }
809
810 static struct mmc_host_ops at91_mci_ops = {
811         .request        = at91_mci_request,
812         .set_ios        = at91_mci_set_ios,
813         .get_ro         = at91_mci_get_ro,
814 };
815
816 /*
817  * Probe for the device
818  */
819 static int at91_mci_probe(struct platform_device *pdev)
820 {
821         struct mmc_host *mmc;
822         struct at91mci_host *host;
823         int ret;
824
825         DBG("Probe MCI devices\n");
826         at91_mci_disable();
827         at91_mci_enable();
828
829         mmc = mmc_alloc_host(sizeof(struct at91mci_host), &pdev->dev);
830         if (!mmc) {
831                 DBG("Failed to allocate mmc host\n");
832                 return -ENOMEM;
833         }
834
835         mmc->ops = &at91_mci_ops;
836         mmc->f_min = 375000;
837         mmc->f_max = 25000000;
838         mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
839
840         host = mmc_priv(mmc);
841         host->mmc = mmc;
842         host->buffer = NULL;
843         host->bus_mode = 0;
844         host->board = pdev->dev.platform_data;
845         if (host->board->wire4) {
846 #ifdef SUPPORT_4WIRE
847                 mmc->caps |= MMC_CAP_4_BIT_DATA;
848 #else
849                 printk("MMC: 4 wire bus mode not supported by this driver - using 1 wire\n");
850 #endif
851         }
852
853         /*
854          * Get Clock
855          */
856         mci_clk = clk_get(&pdev->dev, "mci_clk");
857         if (!mci_clk) {
858                 printk(KERN_ERR "AT91 MMC: no clock defined.\n");
859                 return -ENODEV;
860         }
861         clk_enable(mci_clk);                    /* Enable the peripheral clock */
862
863         /*
864          * Allocate the MCI interrupt
865          */
866         ret = request_irq(AT91_ID_MCI, at91_mci_irq, SA_SHIRQ, DRIVER_NAME, host);
867         if (ret) {
868                 DBG("Failed to request MCI interrupt\n");
869                 return ret;
870         }
871
872         platform_set_drvdata(pdev, mmc);
873
874         /*
875          * Add host to MMC layer
876          */
877         if (host->board->det_pin)
878                 host->present = !at91_get_gpio_value(host->board->det_pin);
879         else
880                 host->present = -1;
881
882         mmc_add_host(mmc);
883
884         /*
885          * monitor card insertion/removal if we can
886          */
887         if (host->board->det_pin) {
888                 ret = request_irq(host->board->det_pin, at91_mmc_det_irq,
889                                 SA_SAMPLE_RANDOM, DRIVER_NAME, host);
890                 if (ret)
891                         DBG("couldn't allocate MMC detect irq\n");
892         }
893
894         DBG(KERN_INFO "Added MCI driver\n");
895
896         return 0;
897 }
898
899 /*
900  * Remove a device
901  */
902 static int at91_mci_remove(struct platform_device *pdev)
903 {
904         struct mmc_host *mmc = platform_get_drvdata(pdev);
905         struct at91mci_host *host;
906
907         if (!mmc)
908                 return -1;
909
910         host = mmc_priv(mmc);
911
912         if (host->present != -1) {
913                 free_irq(host->board->det_pin, host);
914                 cancel_delayed_work(&host->mmc->detect);
915         }
916
917         mmc_remove_host(mmc);
918         at91_mci_disable();
919         free_irq(AT91_ID_MCI, host);
920         mmc_free_host(mmc);
921
922         clk_disable(mci_clk);                           /* Disable the peripheral clock */
923         clk_put(mci_clk);
924
925         platform_set_drvdata(pdev, NULL);
926
927         DBG("Removed\n");
928
929         return 0;
930 }
931
932 #ifdef CONFIG_PM
933 static int at91_mci_suspend(struct platform_device *pdev, pm_message_t state)
934 {
935         struct mmc_host *mmc = platform_get_drvdata(pdev);
936         int ret = 0;
937
938         if (mmc)
939                 ret = mmc_suspend_host(mmc, state);
940
941         return ret;
942 }
943
944 static int at91_mci_resume(struct platform_device *pdev)
945 {
946         struct mmc_host *mmc = platform_get_drvdata(pdev);
947         int ret = 0;
948
949         if (mmc)
950                 ret = mmc_resume_host(mmc);
951
952         return ret;
953 }
954 #else
955 #define at91_mci_suspend        NULL
956 #define at91_mci_resume         NULL
957 #endif
958
959 static struct platform_driver at91_mci_driver = {
960         .probe          = at91_mci_probe,
961         .remove         = at91_mci_remove,
962         .suspend        = at91_mci_suspend,
963         .resume         = at91_mci_resume,
964         .driver         = {
965                 .name   = DRIVER_NAME,
966                 .owner  = THIS_MODULE,
967         },
968 };
969
970 static int __init at91_mci_init(void)
971 {
972         return platform_driver_register(&at91_mci_driver);
973 }
974
975 static void __exit at91_mci_exit(void)
976 {
977         platform_driver_unregister(&at91_mci_driver);
978 }
979
980 module_init(at91_mci_init);
981 module_exit(at91_mci_exit);
982
983 MODULE_DESCRIPTION("AT91 Multimedia Card Interface driver");
984 MODULE_AUTHOR("Nick Randell");
985 MODULE_LICENSE("GPL");