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