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