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