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