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