?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
atmel-mci: debugfs support
[linux-2.6/mini2440.git] / drivers / mmc / host / atmel-mci.c
blobb68381f7bfdd504e3f786675be6930626eb33ed2
1 /*
2 * Atmel MultiMedia Card Interface driver
3 *
4 * Copyright (C) 2004-2008 Atmel Corporation
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 */
10 #include <linux/blkdev.h>
11 #include <linux/clk.h>
12 #include <linux/debugfs.h>
13 #include <linux/device.h>
14 #include <linux/init.h>
15 #include <linux/interrupt.h>
16 #include <linux/ioport.h>
17 #include <linux/module.h>
18 #include <linux/platform_device.h>
19 #include <linux/scatterlist.h>
20 #include <linux/seq_file.h>
21 #include <linux/stat.h>
22
23 #include <linux/mmc/host.h>
24
25 #include <asm/atmel-mci.h>
26 #include <asm/io.h>
27 #include <asm/unaligned.h>
28
29 #include <asm/arch/board.h>
30 #include <asm/arch/gpio.h>
31
32 #include "atmel-mci-regs.h"
33
34 #define ATMCI_DATA_ERROR_FLAGS (MCI_DCRCE | MCI_DTOE | MCI_OVRE | MCI_UNRE)
35
36 enum {
37 EVENT_CMD_COMPLETE = 0,
38 EVENT_DATA_ERROR,
39 EVENT_DATA_COMPLETE,
40 EVENT_STOP_SENT,
41 EVENT_STOP_COMPLETE,
42 EVENT_XFER_COMPLETE,
43 };
44
45 struct atmel_mci {
46 struct mmc_host *mmc;
47 void __iomem *regs;
48
49 struct scatterlist *sg;
50 unsigned int pio_offset;
51
52 struct mmc_request *mrq;
53 struct mmc_command *cmd;
54 struct mmc_data *data;
55
56 u32 cmd_status;
57 u32 data_status;
58 u32 stop_status;
59 u32 stop_cmdr;
60
61 u32 mode_reg;
62 u32 sdc_reg;
63
64 struct tasklet_struct tasklet;
65 unsigned long pending_events;
66 unsigned long completed_events;
67
68 int present;
69 int detect_pin;
70 int wp_pin;
71
72 /* For detect pin debouncing */
73 struct timer_list detect_timer;
74
75 unsigned long bus_hz;
76 unsigned long mapbase;
77 struct clk *mck;
78 struct platform_device *pdev;
79 };
80
81 #define atmci_is_completed(host, event) \
82 test_bit(event, &host->completed_events)
83 #define atmci_test_and_clear_pending(host, event) \
84 test_and_clear_bit(event, &host->pending_events)
85 #define atmci_test_and_set_completed(host, event) \
86 test_and_set_bit(event, &host->completed_events)
87 #define atmci_set_completed(host, event) \
88 set_bit(event, &host->completed_events)
89 #define atmci_set_pending(host, event) \
90 set_bit(event, &host->pending_events)
91 #define atmci_clear_pending(host, event) \
92 clear_bit(event, &host->pending_events)
93
94 /*
95 * The debugfs stuff below is mostly optimized away when
96 * CONFIG_DEBUG_FS is not set.
97 */
98 static int atmci_req_show(struct seq_file *s, void *v)
99 {
100 struct atmel_mci *host = s->private;
101 struct mmc_request *mrq = host->mrq;
102 struct mmc_command *cmd;
103 struct mmc_command *stop;
104 struct mmc_data *data;
105
106 /* Make sure we get a consistent snapshot */
107 spin_lock_irq(&host->mmc->lock);
108
109 if (mrq) {
110 cmd = mrq->cmd;
111 data = mrq->data;
112 stop = mrq->stop;
113
114 if (cmd)
115 seq_printf(s,
116 "CMD%u(0x%x) flg %x rsp %x %x %x %x err %d\n",
117 cmd->opcode, cmd->arg, cmd->flags,
118 cmd->resp[0], cmd->resp[1], cmd->resp[2],
119 cmd->resp[2], cmd->error);
120 if (data)
121 seq_printf(s, "DATA %u / %u * %u flg %x err %d\n",
122 data->bytes_xfered, data->blocks,
123 data->blksz, data->flags, data->error);
124 if (stop)
125 seq_printf(s,
126 "CMD%u(0x%x) flg %x rsp %x %x %x %x err %d\n",
127 stop->opcode, stop->arg, stop->flags,
128 stop->resp[0], stop->resp[1], stop->resp[2],
129 stop->resp[2], stop->error);
130 }
131
132 spin_unlock_irq(&host->mmc->lock);
133
134 return 0;
135 }
136
137 static int atmci_req_open(struct inode *inode, struct file *file)
138 {
139 return single_open(file, atmci_req_show, inode->i_private);
140 }
141
142 static const struct file_operations atmci_req_fops = {
143 .owner = THIS_MODULE,
144 .open = atmci_req_open,
145 .read = seq_read,
146 .llseek = seq_lseek,
147 .release = single_release,
148 };
149
150 static void atmci_show_status_reg(struct seq_file *s,
151 const char *regname, u32 value)
152 {
153 static const char *sr_bit[] = {
154 [0] = "CMDRDY",
155 [1] = "RXRDY",
156 [2] = "TXRDY",
157 [3] = "BLKE",
158 [4] = "DTIP",
159 [5] = "NOTBUSY",
160 [8] = "SDIOIRQA",
161 [9] = "SDIOIRQB",
162 [16] = "RINDE",
163 [17] = "RDIRE",
164 [18] = "RCRCE",
165 [19] = "RENDE",
166 [20] = "RTOE",
167 [21] = "DCRCE",
168 [22] = "DTOE",
169 [30] = "OVRE",
170 [31] = "UNRE",
171 };
172 unsigned int i;
173
174 seq_printf(s, "%s:\t0x%08x", regname, value);
175 for (i = 0; i < ARRAY_SIZE(sr_bit); i++) {
176 if (value & (1 << i)) {
177 if (sr_bit[i])
178 seq_printf(s, " %s", sr_bit[i]);
179 else
180 seq_puts(s, " UNKNOWN");
181 }
182 }
183 seq_putc(s, '\n');
184 }
185
186 static int atmci_regs_show(struct seq_file *s, void *v)
187 {
188 struct atmel_mci *host = s->private;
189 u32 *buf;
190
191 buf = kmalloc(MCI_REGS_SIZE, GFP_KERNEL);
192 if (!buf)
193 return -ENOMEM;
194
195 /* Grab a more or less consistent snapshot */
196 spin_lock_irq(&host->mmc->lock);
197 memcpy_fromio(buf, host->regs, MCI_REGS_SIZE);
198 spin_unlock_irq(&host->mmc->lock);
199
200 seq_printf(s, "MR:\t0x%08x%s%s CLKDIV=%u\n",
201 buf[MCI_MR / 4],
202 buf[MCI_MR / 4] & MCI_MR_RDPROOF ? " RDPROOF" : "",
203 buf[MCI_MR / 4] & MCI_MR_WRPROOF ? " WRPROOF" : "",
204 buf[MCI_MR / 4] & 0xff);
205 seq_printf(s, "DTOR:\t0x%08x\n", buf[MCI_DTOR / 4]);
206 seq_printf(s, "SDCR:\t0x%08x\n", buf[MCI_SDCR / 4]);
207 seq_printf(s, "ARGR:\t0x%08x\n", buf[MCI_ARGR / 4]);
208 seq_printf(s, "BLKR:\t0x%08x BCNT=%u BLKLEN=%u\n",
209 buf[MCI_BLKR / 4],
210 buf[MCI_BLKR / 4] & 0xffff,
211 (buf[MCI_BLKR / 4] >> 16) & 0xffff);
212
213 /* Don't read RSPR and RDR; it will consume the data there */
214
215 atmci_show_status_reg(s, "SR", buf[MCI_SR / 4]);
216 atmci_show_status_reg(s, "IMR", buf[MCI_IMR / 4]);
217
218 return 0;
219 }
220
221 static int atmci_regs_open(struct inode *inode, struct file *file)
222 {
223 return single_open(file, atmci_regs_show, inode->i_private);
224 }
225
226 static const struct file_operations atmci_regs_fops = {
227 .owner = THIS_MODULE,
228 .open = atmci_regs_open,
229 .read = seq_read,
230 .llseek = seq_lseek,
231 .release = single_release,
232 };
233
234 static void atmci_init_debugfs(struct atmel_mci *host)
235 {
236 struct mmc_host *mmc;
237 struct dentry *root;
238 struct dentry *node;
239 struct resource *res;
240
241 mmc = host->mmc;
242 root = mmc->debugfs_root;
243 if (!root)
244 return;
245
246 node = debugfs_create_file("regs", S_IRUSR, root, host,
247 &atmci_regs_fops);
248 if (IS_ERR(node))
249 return;
250 if (!node)
251 goto err;
252
253 res = platform_get_resource(host->pdev, IORESOURCE_MEM, 0);
254 node->d_inode->i_size = res->end - res->start + 1;
255
256 node = debugfs_create_file("req", S_IRUSR, root, host, &atmci_req_fops);
257 if (!node)
258 goto err;
259
260 node = debugfs_create_x32("pending_events", S_IRUSR, root,
261 (u32 *)&host->pending_events);
262 if (!node)
263 goto err;
264
265 node = debugfs_create_x32("completed_events", S_IRUSR, root,
266 (u32 *)&host->completed_events);
267 if (!node)
268 goto err;
269
270 return;
271
272 err:
273 dev_err(&host->pdev->dev,
274 "failed to initialize debugfs for controller\n");
275 }
276
277 static void atmci_enable(struct atmel_mci *host)
278 {
279 clk_enable(host->mck);
280 mci_writel(host, CR, MCI_CR_MCIEN);
281 mci_writel(host, MR, host->mode_reg);
282 mci_writel(host, SDCR, host->sdc_reg);
283 }
284
285 static void atmci_disable(struct atmel_mci *host)
286 {
287 mci_writel(host, CR, MCI_CR_SWRST);
288
289 /* Stall until write is complete, then disable the bus clock */
290 mci_readl(host, SR);
291 clk_disable(host->mck);
292 }
293
294 static inline unsigned int ns_to_clocks(struct atmel_mci *host,
295 unsigned int ns)
296 {
297 return (ns * (host->bus_hz / 1000000) + 999) / 1000;
298 }
299
300 static void atmci_set_timeout(struct atmel_mci *host,
301 struct mmc_data *data)
302 {
303 static unsigned dtomul_to_shift[] = {
304 0, 4, 7, 8, 10, 12, 16, 20
305 };
306 unsigned timeout;
307 unsigned dtocyc;
308 unsigned dtomul;
309
310 timeout = ns_to_clocks(host, data->timeout_ns) + data->timeout_clks;
311
312 for (dtomul = 0; dtomul < 8; dtomul++) {
313 unsigned shift = dtomul_to_shift[dtomul];
314 dtocyc = (timeout + (1 << shift) - 1) >> shift;
315 if (dtocyc < 15)
316 break;
317 }
318
319 if (dtomul >= 8) {
320 dtomul = 7;
321 dtocyc = 15;
322 }
323
324 dev_vdbg(&host->mmc->class_dev, "setting timeout to %u cycles\n",
325 dtocyc << dtomul_to_shift[dtomul]);
326 mci_writel(host, DTOR, (MCI_DTOMUL(dtomul) | MCI_DTOCYC(dtocyc)));
327 }
328
329 /*
330 * Return mask with command flags to be enabled for this command.
331 */
332 static u32 atmci_prepare_command(struct mmc_host *mmc,
333 struct mmc_command *cmd)
334 {
335 struct mmc_data *data;
336 u32 cmdr;
337
338 cmd->error = -EINPROGRESS;
339
340 cmdr = MCI_CMDR_CMDNB(cmd->opcode);
341
342 if (cmd->flags & MMC_RSP_PRESENT) {
343 if (cmd->flags & MMC_RSP_136)
344 cmdr |= MCI_CMDR_RSPTYP_136BIT;
345 else
346 cmdr |= MCI_CMDR_RSPTYP_48BIT;
347 }
348
349 /*
350 * This should really be MAXLAT_5 for CMD2 and ACMD41, but
351 * it's too difficult to determine whether this is an ACMD or
352 * not. Better make it 64.
353 */
354 cmdr |= MCI_CMDR_MAXLAT_64CYC;
355
356 if (mmc->ios.bus_mode == MMC_BUSMODE_OPENDRAIN)
357 cmdr |= MCI_CMDR_OPDCMD;
358
359 data = cmd->data;
360 if (data) {
361 cmdr |= MCI_CMDR_START_XFER;
362 if (data->flags & MMC_DATA_STREAM)
363 cmdr |= MCI_CMDR_STREAM;
364 else if (data->blocks > 1)
365 cmdr |= MCI_CMDR_MULTI_BLOCK;
366 else
367 cmdr |= MCI_CMDR_BLOCK;
368
369 if (data->flags & MMC_DATA_READ)
370 cmdr |= MCI_CMDR_TRDIR_READ;
371 }
372
373 return cmdr;
374 }
375
376 static void atmci_start_command(struct atmel_mci *host,
377 struct mmc_command *cmd,
378 u32 cmd_flags)
379 {
380 /* Must read host->cmd after testing event flags */
381 smp_rmb();
382 WARN_ON(host->cmd);
383 host->cmd = cmd;
384
385 dev_vdbg(&host->mmc->class_dev,
386 "start command: ARGR=0x%08x CMDR=0x%08x\n",
387 cmd->arg, cmd_flags);
388
389 mci_writel(host, ARGR, cmd->arg);
390 mci_writel(host, CMDR, cmd_flags);
391 }
392
393 static void send_stop_cmd(struct mmc_host *mmc, struct mmc_data *data)
394 {
395 struct atmel_mci *host = mmc_priv(mmc);
396
397 atmci_start_command(host, data->stop, host->stop_cmdr);
398 mci_writel(host, IER, MCI_CMDRDY);
399 }
400
401 static void atmci_request_end(struct mmc_host *mmc, struct mmc_request *mrq)
402 {
403 struct atmel_mci *host = mmc_priv(mmc);
404
405 WARN_ON(host->cmd || host->data);
406 host->mrq = NULL;
407
408 atmci_disable(host);
409
410 mmc_request_done(mmc, mrq);
411 }
412
413 /*
414 * Returns a mask of interrupt flags to be enabled after the whole
415 * request has been prepared.
416 */
417 static u32 atmci_submit_data(struct mmc_host *mmc, struct mmc_data *data)
418 {
419 struct atmel_mci *host = mmc_priv(mmc);
420 u32 iflags;
421
422 data->error = -EINPROGRESS;
423
424 WARN_ON(host->data);
425 host->sg = NULL;
426 host->data = data;
427
428 mci_writel(host, BLKR, MCI_BCNT(data->blocks)
429 | MCI_BLKLEN(data->blksz));
430 dev_vdbg(&mmc->class_dev, "BLKR=0x%08x\n",
431 MCI_BCNT(data->blocks) | MCI_BLKLEN(data->blksz));
432
433 iflags = ATMCI_DATA_ERROR_FLAGS;
434 host->sg = data->sg;
435 host->pio_offset = 0;
436 if (data->flags & MMC_DATA_READ)
437 iflags |= MCI_RXRDY;
438 else
439 iflags |= MCI_TXRDY;
440
441 return iflags;
442 }
443
444 static void atmci_request(struct mmc_host *mmc, struct mmc_request *mrq)
445 {
446 struct atmel_mci *host = mmc_priv(mmc);
447 struct mmc_data *data;
448 struct mmc_command *cmd;
449 u32 iflags;
450 u32 cmdflags = 0;
451
452 iflags = mci_readl(host, IMR);
453 if (iflags)
454 dev_warn(&mmc->class_dev, "WARNING: IMR=0x%08x\n",
455 mci_readl(host, IMR));
456
457 WARN_ON(host->mrq != NULL);
458
459 /*
460 * We may "know" the card is gone even though there's still an
461 * electrical connection. If so, we really need to communicate
462 * this to the MMC core since there won't be any more
463 * interrupts as the card is completely removed. Otherwise,
464 * the MMC core might believe the card is still there even
465 * though the card was just removed very slowly.
466 */
467 if (!host->present) {
468 mrq->cmd->error = -ENOMEDIUM;
469 mmc_request_done(mmc, mrq);
470 return;
471 }
472
473 host->mrq = mrq;
474 host->pending_events = 0;
475 host->completed_events = 0;
476
477 atmci_enable(host);
478
479 /* We don't support multiple blocks of weird lengths. */
480 data = mrq->data;
481 if (data) {
482 if (data->blocks > 1 && data->blksz & 3)
483 goto fail;
484 atmci_set_timeout(host, data);
485 }
486
487 iflags = MCI_CMDRDY;
488 cmd = mrq->cmd;
489 cmdflags = atmci_prepare_command(mmc, cmd);
490 atmci_start_command(host, cmd, cmdflags);
491
492 if (data)
493 iflags |= atmci_submit_data(mmc, data);
494
495 if (mrq->stop) {
496 host->stop_cmdr = atmci_prepare_command(mmc, mrq->stop);
497 host->stop_cmdr |= MCI_CMDR_STOP_XFER;
498 if (!(data->flags & MMC_DATA_WRITE))
499 host->stop_cmdr |= MCI_CMDR_TRDIR_READ;
500 if (data->flags & MMC_DATA_STREAM)
501 host->stop_cmdr |= MCI_CMDR_STREAM;
502 else
503 host->stop_cmdr |= MCI_CMDR_MULTI_BLOCK;
504 }
505
506 /*
507 * We could have enabled interrupts earlier, but I suspect
508 * that would open up a nice can of interesting race
509 * conditions (e.g. command and data complete, but stop not
510 * prepared yet.)
511 */
512 mci_writel(host, IER, iflags);
513
514 return;
515
516 fail:
517 atmci_disable(host);
518 host->mrq = NULL;
519 mrq->cmd->error = -EINVAL;
520 mmc_request_done(mmc, mrq);
521 }
522
523 static void atmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
524 {
525 struct atmel_mci *host = mmc_priv(mmc);
526
527 if (ios->clock) {
528 u32 clkdiv;
529
530 /* Set clock rate */
531 clkdiv = DIV_ROUND_UP(host->bus_hz, 2 * ios->clock) - 1;
532 if (clkdiv > 255) {
533 dev_warn(&mmc->class_dev,
534 "clock %u too slow; using %lu\n",
535 ios->clock, host->bus_hz / (2 * 256));
536 clkdiv = 255;
537 }
538
539 host->mode_reg = MCI_MR_CLKDIV(clkdiv) | MCI_MR_WRPROOF
540 | MCI_MR_RDPROOF;
541 }
542
543 switch (ios->bus_width) {
544 case MMC_BUS_WIDTH_1:
545 host->sdc_reg = 0;
546 break;
547 case MMC_BUS_WIDTH_4:
548 host->sdc_reg = MCI_SDCBUS_4BIT;
549 break;
550 }
551
552 switch (ios->power_mode) {
553 case MMC_POWER_ON:
554 /* Send init sequence (74 clock cycles) */
555 atmci_enable(host);
556 mci_writel(host, CMDR, MCI_CMDR_SPCMD_INIT);
557 while (!(mci_readl(host, SR) & MCI_CMDRDY))
558 cpu_relax();
559 atmci_disable(host);
560 break;
561 default:
562 /*
563 * TODO: None of the currently available AVR32-based
564 * boards allow MMC power to be turned off. Implement
565 * power control when this can be tested properly.
566 */
567 break;
568 }
569 }
570
571 static int atmci_get_ro(struct mmc_host *mmc)
572 {
573 int read_only = 0;
574 struct atmel_mci *host = mmc_priv(mmc);
575
576 if (host->wp_pin >= 0) {
577 read_only = gpio_get_value(host->wp_pin);
578 dev_dbg(&mmc->class_dev, "card is %s\n",
579 read_only ? "read-only" : "read-write");
580 } else {
581 dev_dbg(&mmc->class_dev,
582 "no pin for checking read-only switch."
583 " Assuming write-enable.\n");
584 }
585
586 return read_only;
587 }
588
589 static struct mmc_host_ops atmci_ops = {
590 .request = atmci_request,
591 .set_ios = atmci_set_ios,
592 .get_ro = atmci_get_ro,
593 };
594
595 static void atmci_command_complete(struct atmel_mci *host,
596 struct mmc_command *cmd, u32 status)
597 {
598 /* Read the response from the card (up to 16 bytes) */
599 cmd->resp[0] = mci_readl(host, RSPR);
600 cmd->resp[1] = mci_readl(host, RSPR);
601 cmd->resp[2] = mci_readl(host, RSPR);
602 cmd->resp[3] = mci_readl(host, RSPR);
603
604 if (status & MCI_RTOE)
605 cmd->error = -ETIMEDOUT;
606 else if ((cmd->flags & MMC_RSP_CRC) && (status & MCI_RCRCE))
607 cmd->error = -EILSEQ;
608 else if (status & (MCI_RINDE | MCI_RDIRE | MCI_RENDE))
609 cmd->error = -EIO;
610 else
611 cmd->error = 0;
612
613 if (cmd->error) {
614 dev_dbg(&host->mmc->class_dev,
615 "command error: status=0x%08x\n", status);
616
617 if (cmd->data) {
618 host->data = NULL;
619 mci_writel(host, IDR, MCI_NOTBUSY
620 | MCI_TXRDY | MCI_RXRDY
621 | ATMCI_DATA_ERROR_FLAGS);
622 }
623 }
624 }
625
626 static void atmci_detect_change(unsigned long data)
627 {
628 struct atmel_mci *host = (struct atmel_mci *)data;
629 struct mmc_request *mrq = host->mrq;
630 int present;
631
632 /*
633 * atmci_remove() sets detect_pin to -1 before freeing the
634 * interrupt. We must not re-enable the interrupt if it has
635 * been freed.
636 */
637 smp_rmb();
638 if (host->detect_pin < 0)
639 return;
640
641 enable_irq(gpio_to_irq(host->detect_pin));
642 present = !gpio_get_value(host->detect_pin);
643
644 dev_vdbg(&host->pdev->dev, "detect change: %d (was %d)\n",
645 present, host->present);
646
647 if (present != host->present) {
648 dev_dbg(&host->mmc->class_dev, "card %s\n",
649 present ? "inserted" : "removed");
650 host->present = present;
651
652 /* Reset controller if card is gone */
653 if (!present) {
654 mci_writel(host, CR, MCI_CR_SWRST);
655 mci_writel(host, IDR, ~0UL);
656 mci_writel(host, CR, MCI_CR_MCIEN);
657 }
658
659 /* Clean up queue if present */
660 if (mrq) {
661 /*
662 * Reset controller to terminate any ongoing
663 * commands or data transfers.
664 */
665 mci_writel(host, CR, MCI_CR_SWRST);
666
667 if (!atmci_is_completed(host, EVENT_CMD_COMPLETE))
668 mrq->cmd->error = -ENOMEDIUM;
669
670 if (mrq->data && !atmci_is_completed(host,
671 EVENT_DATA_COMPLETE)) {
672 host->data = NULL;
673 mrq->data->error = -ENOMEDIUM;
674 }
675 if (mrq->stop && !atmci_is_completed(host,
676 EVENT_STOP_COMPLETE))
677 mrq->stop->error = -ENOMEDIUM;
678
679 host->cmd = NULL;
680 atmci_request_end(host->mmc, mrq);
681 }
682
683 mmc_detect_change(host->mmc, 0);
684 }
685 }
686
687 static void atmci_tasklet_func(unsigned long priv)
688 {
689 struct mmc_host *mmc = (struct mmc_host *)priv;
690 struct atmel_mci *host = mmc_priv(mmc);
691 struct mmc_request *mrq = host->mrq;
692 struct mmc_data *data = host->data;
693
694 dev_vdbg(&mmc->class_dev,
695 "tasklet: pending/completed/mask %lx/%lx/%x\n",
696 host->pending_events, host->completed_events,
697 mci_readl(host, IMR));
698
699 if (atmci_test_and_clear_pending(host, EVENT_CMD_COMPLETE)) {
700 /*
701 * host->cmd must be set to NULL before the interrupt
702 * handler sees EVENT_CMD_COMPLETE
703 */
704 host->cmd = NULL;
705 smp_wmb();
706 atmci_set_completed(host, EVENT_CMD_COMPLETE);
707 atmci_command_complete(host, mrq->cmd, host->cmd_status);
708
709 if (!mrq->cmd->error && mrq->stop
710 && atmci_is_completed(host, EVENT_XFER_COMPLETE)
711 && !atmci_test_and_set_completed(host,
712 EVENT_STOP_SENT))
713 send_stop_cmd(host->mmc, mrq->data);
714 }
715 if (atmci_test_and_clear_pending(host, EVENT_STOP_COMPLETE)) {
716 /*
717 * host->cmd must be set to NULL before the interrupt
718 * handler sees EVENT_STOP_COMPLETE
719 */
720 host->cmd = NULL;
721 smp_wmb();
722 atmci_set_completed(host, EVENT_STOP_COMPLETE);
723 atmci_command_complete(host, mrq->stop, host->stop_status);
724 }
725 if (atmci_test_and_clear_pending(host, EVENT_DATA_ERROR)) {
726 u32 status = host->data_status;
727
728 dev_vdbg(&mmc->class_dev, "data error: status=%08x\n", status);
729
730 atmci_set_completed(host, EVENT_DATA_ERROR);
731 atmci_set_completed(host, EVENT_DATA_COMPLETE);
732
733 if (status & MCI_DTOE) {
734 dev_dbg(&mmc->class_dev,
735 "data timeout error\n");
736 data->error = -ETIMEDOUT;
737 } else if (status & MCI_DCRCE) {
738 dev_dbg(&mmc->class_dev, "data CRC error\n");
739 data->error = -EILSEQ;
740 } else {
741 dev_dbg(&mmc->class_dev,
742 "data FIFO error (status=%08x)\n",
743 status);
744 data->error = -EIO;
745 }
746
747 if (host->present && data->stop
748 && atmci_is_completed(host, EVENT_CMD_COMPLETE)
749 && !atmci_test_and_set_completed(
750 host, EVENT_STOP_SENT))
751 send_stop_cmd(host->mmc, data);
752
753 host->data = NULL;
754 }
755 if (atmci_test_and_clear_pending(host, EVENT_DATA_COMPLETE)) {
756 atmci_set_completed(host, EVENT_DATA_COMPLETE);
757
758 if (!atmci_is_completed(host, EVENT_DATA_ERROR)) {
759 data->bytes_xfered = data->blocks * data->blksz;
760 data->error = 0;
761 }
762
763 host->data = NULL;
764 }
765
766 if (host->mrq && !host->cmd && !host->data)
767 atmci_request_end(mmc, host->mrq);
768 }
769
770 static void atmci_read_data_pio(struct atmel_mci *host)
771 {
772 struct scatterlist *sg = host->sg;
773 void *buf = sg_virt(sg);
774 unsigned int offset = host->pio_offset;
775 struct mmc_data *data = host->data;
776 u32 value;
777 u32 status;
778 unsigned int nbytes = 0;
779
780 do {
781 value = mci_readl(host, RDR);
782 if (likely(offset + 4 <= sg->length)) {
783 put_unaligned(value, (u32 *)(buf + offset));
784
785 offset += 4;
786 nbytes += 4;
787
788 if (offset == sg->length) {
789 host->sg = sg = sg_next(sg);
790 if (!sg)
791 goto done;
792
793 offset = 0;
794 buf = sg_virt(sg);
795 }
796 } else {
797 unsigned int remaining = sg->length - offset;
798 memcpy(buf + offset, &value, remaining);
799 nbytes += remaining;
800
801 flush_dcache_page(sg_page(sg));
802 host->sg = sg = sg_next(sg);
803 if (!sg)
804 goto done;
805
806 offset = 4 - remaining;
807 buf = sg_virt(sg);
808 memcpy(buf, (u8 *)&value + remaining, offset);
809 nbytes += offset;
810 }
811
812 status = mci_readl(host, SR);
813 if (status & ATMCI_DATA_ERROR_FLAGS) {
814 mci_writel(host, IDR, (MCI_NOTBUSY | MCI_RXRDY
815 | ATMCI_DATA_ERROR_FLAGS));
816 host->data_status = status;
817 atmci_set_pending(host, EVENT_DATA_ERROR);
818 tasklet_schedule(&host->tasklet);
819 break;
820 }
821 } while (status & MCI_RXRDY);
822
823 host->pio_offset = offset;
824 data->bytes_xfered += nbytes;
825
826 return;
827
828 done:
829 mci_writel(host, IDR, MCI_RXRDY);
830 mci_writel(host, IER, MCI_NOTBUSY);
831 data->bytes_xfered += nbytes;
832 atmci_set_completed(host, EVENT_XFER_COMPLETE);
833 if (data->stop && atmci_is_completed(host, EVENT_CMD_COMPLETE)
834 && !atmci_test_and_set_completed(host, EVENT_STOP_SENT))
835 send_stop_cmd(host->mmc, data);
836 }
837
838 static void atmci_write_data_pio(struct atmel_mci *host)
839 {
840 struct scatterlist *sg = host->sg;
841 void *buf = sg_virt(sg);
842 unsigned int offset = host->pio_offset;
843 struct mmc_data *data = host->data;
844 u32 value;
845 u32 status;
846 unsigned int nbytes = 0;
847
848 do {
849 if (likely(offset + 4 <= sg->length)) {
850 value = get_unaligned((u32 *)(buf + offset));
851 mci_writel(host, TDR, value);
852
853 offset += 4;
854 nbytes += 4;
855 if (offset == sg->length) {
856 host->sg = sg = sg_next(sg);
857 if (!sg)
858 goto done;
859
860 offset = 0;
861 buf = sg_virt(sg);
862 }
863 } else {
864 unsigned int remaining = sg->length - offset;
865
866 value = 0;
867 memcpy(&value, buf + offset, remaining);
868 nbytes += remaining;
869
870 host->sg = sg = sg_next(sg);
871 if (!sg) {
872 mci_writel(host, TDR, value);
873 goto done;
874 }
875
876 offset = 4 - remaining;
877 buf = sg_virt(sg);
878 memcpy((u8 *)&value + remaining, buf, offset);
879 mci_writel(host, TDR, value);
880 nbytes += offset;
881 }
882
883 status = mci_readl(host, SR);
884 if (status & ATMCI_DATA_ERROR_FLAGS) {
885 mci_writel(host, IDR, (MCI_NOTBUSY | MCI_TXRDY
886 | ATMCI_DATA_ERROR_FLAGS));
887 host->data_status = status;
888 atmci_set_pending(host, EVENT_DATA_ERROR);
889 tasklet_schedule(&host->tasklet);
890 break;
891 }
892 } while (status & MCI_TXRDY);
893
894 host->pio_offset = offset;
895 data->bytes_xfered += nbytes;
896
897 return;
898
899 done:
900 mci_writel(host, IDR, MCI_TXRDY);
901 mci_writel(host, IER, MCI_NOTBUSY);
902 data->bytes_xfered += nbytes;
903 atmci_set_completed(host, EVENT_XFER_COMPLETE);
904 if (data->stop && atmci_is_completed(host, EVENT_CMD_COMPLETE)
905 && !atmci_test_and_set_completed(host, EVENT_STOP_SENT))
906 send_stop_cmd(host->mmc, data);
907 }
908
909 static void atmci_cmd_interrupt(struct mmc_host *mmc, u32 status)
910 {
911 struct atmel_mci *host = mmc_priv(mmc);
912
913 mci_writel(host, IDR, MCI_CMDRDY);
914
915 if (atmci_is_completed(host, EVENT_STOP_SENT)) {
916 host->stop_status = status;
917 atmci_set_pending(host, EVENT_STOP_COMPLETE);
918 } else {
919 host->cmd_status = status;
920 atmci_set_pending(host, EVENT_CMD_COMPLETE);
921 }
922
923 tasklet_schedule(&host->tasklet);
924 }
925
926 static irqreturn_t atmci_interrupt(int irq, void *dev_id)
927 {
928 struct mmc_host *mmc = dev_id;
929 struct atmel_mci *host = mmc_priv(mmc);
930 u32 status, mask, pending;
931 unsigned int pass_count = 0;
932
933 spin_lock(&mmc->lock);
934
935 do {
936 status = mci_readl(host, SR);
937 mask = mci_readl(host, IMR);
938 pending = status & mask;
939 if (!pending)
940 break;
941
942 if (pending & ATMCI_DATA_ERROR_FLAGS) {
943 mci_writel(host, IDR, ATMCI_DATA_ERROR_FLAGS
944 | MCI_RXRDY | MCI_TXRDY);
945 pending &= mci_readl(host, IMR);
946 host->data_status = status;
947 atmci_set_pending(host, EVENT_DATA_ERROR);
948 tasklet_schedule(&host->tasklet);
949 }
950 if (pending & MCI_NOTBUSY) {
951 mci_writel(host, IDR, (MCI_NOTBUSY
952 | ATMCI_DATA_ERROR_FLAGS));
953 atmci_set_pending(host, EVENT_DATA_COMPLETE);
954 tasklet_schedule(&host->tasklet);
955 }
956 if (pending & MCI_RXRDY)
957 atmci_read_data_pio(host);
958 if (pending & MCI_TXRDY)
959 atmci_write_data_pio(host);
960
961 if (pending & MCI_CMDRDY)
962 atmci_cmd_interrupt(mmc, status);
963 } while (pass_count++ < 5);
964
965 spin_unlock(&mmc->lock);
966
967 return pass_count ? IRQ_HANDLED : IRQ_NONE;
968 }
969
970 static irqreturn_t atmci_detect_interrupt(int irq, void *dev_id)
971 {
972 struct mmc_host *mmc = dev_id;
973 struct atmel_mci *host = mmc_priv(mmc);
974
975 /*
976 * Disable interrupts until the pin has stabilized and check
977 * the state then. Use mod_timer() since we may be in the
978 * middle of the timer routine when this interrupt triggers.
979 */
980 disable_irq_nosync(irq);
981 mod_timer(&host->detect_timer, jiffies + msecs_to_jiffies(20));
982
983 return IRQ_HANDLED;
984 }
985
986 static int __init atmci_probe(struct platform_device *pdev)
987 {
988 struct mci_platform_data *pdata;
989 struct atmel_mci *host;
990 struct mmc_host *mmc;
991 struct resource *regs;
992 int irq;
993 int ret;
994
995 regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
996 if (!regs)
997 return -ENXIO;
998 pdata = pdev->dev.platform_data;
999 if (!pdata)
1000 return -ENXIO;
1001 irq = platform_get_irq(pdev, 0);
1002 if (irq < 0)
1003 return irq;
1004
1005 mmc = mmc_alloc_host(sizeof(struct atmel_mci), &pdev->dev);
1006 if (!mmc)
1007 return -ENOMEM;
1008
1009 host = mmc_priv(mmc);
1010 host->pdev = pdev;
1011 host->mmc = mmc;
1012 host->detect_pin = pdata->detect_pin;
1013 host->wp_pin = pdata->wp_pin;
1014
1015 host->mck = clk_get(&pdev->dev, "mci_clk");
1016 if (IS_ERR(host->mck)) {
1017 ret = PTR_ERR(host->mck);
1018 goto err_clk_get;
1019 }
1020
1021 ret = -ENOMEM;
1022 host->regs = ioremap(regs->start, regs->end - regs->start + 1);
1023 if (!host->regs)
1024 goto err_ioremap;
1025
1026 clk_enable(host->mck);
1027 mci_writel(host, CR, MCI_CR_SWRST);
1028 host->bus_hz = clk_get_rate(host->mck);
1029 clk_disable(host->mck);
1030
1031 host->mapbase = regs->start;
1032
1033 mmc->ops = &atmci_ops;
1034 mmc->f_min = (host->bus_hz + 511) / 512;
1035 mmc->f_max = host->bus_hz / 2;
1036 mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
1037 mmc->caps |= MMC_CAP_4_BIT_DATA;
1038
1039 mmc->max_hw_segs = 64;
1040 mmc->max_phys_segs = 64;
1041 mmc->max_req_size = 32768 * 512;
1042 mmc->max_blk_size = 32768;
1043 mmc->max_blk_count = 512;
1044
1045 tasklet_init(&host->tasklet, atmci_tasklet_func, (unsigned long)mmc);
1046
1047 ret = request_irq(irq, atmci_interrupt, 0, pdev->dev.bus_id, mmc);
1048 if (ret)
1049 goto err_request_irq;
1050
1051 /* Assume card is present if we don't have a detect pin */
1052 host->present = 1;
1053 if (host->detect_pin >= 0) {
1054 if (gpio_request(host->detect_pin, "mmc_detect")) {
1055 dev_dbg(&mmc->class_dev, "no detect pin available\n");
1056 host->detect_pin = -1;
1057 } else {
1058 host->present = !gpio_get_value(host->detect_pin);
1059 }
1060 }
1061 if (host->wp_pin >= 0) {
1062 if (gpio_request(host->wp_pin, "mmc_wp")) {
1063 dev_dbg(&mmc->class_dev, "no WP pin available\n");
1064 host->wp_pin = -1;
1065 }
1066 }
1067
1068 platform_set_drvdata(pdev, host);
1069
1070 mmc_add_host(mmc);
1071
1072 if (host->detect_pin >= 0) {
1073 setup_timer(&host->detect_timer, atmci_detect_change,
1074 (unsigned long)host);
1075
1076 ret = request_irq(gpio_to_irq(host->detect_pin),
1077 atmci_detect_interrupt,
1078 IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
1079 "mmc-detect", mmc);
1080 if (ret) {
1081 dev_dbg(&mmc->class_dev,
1082 "could not request IRQ %d for detect pin\n",
1083 gpio_to_irq(host->detect_pin));
1084 gpio_free(host->detect_pin);
1085 host->detect_pin = -1;
1086 }
1087 }
1088
1089 dev_info(&mmc->class_dev,
1090 "Atmel MCI controller at 0x%08lx irq %d\n",
1091 host->mapbase, irq);
1092
1093 atmci_init_debugfs(host);
1094
1095 return 0;
1096
1097 err_request_irq:
1098 iounmap(host->regs);
1099 err_ioremap:
1100 clk_put(host->mck);
1101 err_clk_get:
1102 mmc_free_host(mmc);
1103 return ret;
1104 }
1105
1106 static int __exit atmci_remove(struct platform_device *pdev)
1107 {
1108 struct atmel_mci *host = platform_get_drvdata(pdev);
1109
1110 platform_set_drvdata(pdev, NULL);
1111
1112 if (host) {
1113 /* Debugfs stuff is cleaned up by mmc core */
1114
1115 if (host->detect_pin >= 0) {
1116 int pin = host->detect_pin;
1117
1118 /* Make sure the timer doesn't enable the interrupt */
1119 host->detect_pin = -1;
1120 smp_wmb();
1121
1122 free_irq(gpio_to_irq(pin), host->mmc);
1123 del_timer_sync(&host->detect_timer);
1124 gpio_free(pin);
1125 }
1126
1127 mmc_remove_host(host->mmc);
1128
1129 clk_enable(host->mck);
1130 mci_writel(host, IDR, ~0UL);
1131 mci_writel(host, CR, MCI_CR_MCIDIS);
1132 mci_readl(host, SR);
1133 clk_disable(host->mck);
1134
1135 if (host->wp_pin >= 0)
1136 gpio_free(host->wp_pin);
1137
1138 free_irq(platform_get_irq(pdev, 0), host->mmc);
1139 iounmap(host->regs);
1140
1141 clk_put(host->mck);
1142
1143 mmc_free_host(host->mmc);
1144 }
1145 return 0;
1146 }
1147
1148 static struct platform_driver atmci_driver = {
1149 .remove = __exit_p(atmci_remove),
1150 .driver = {
1151 .name = "atmel_mci",
1152 },
1153 };
1154
1155 static int __init atmci_init(void)
1156 {
1157 return platform_driver_probe(&atmci_driver, atmci_probe);
1158 }
1159
1160 static void __exit atmci_exit(void)
1161 {
1162 platform_driver_unregister(&atmci_driver);
1163 }
1164
1165 module_init(atmci_init);
1166 module_exit(atmci_exit);
1167
1168 MODULE_DESCRIPTION("Atmel Multimedia Card Interface driver");
1169 MODULE_AUTHOR("Haavard Skinnemoen <haavard.skinnemoen@atmel.com>");
1170 MODULE_LICENSE("GPL v2");
Support for the Chinese Samsung S3C2440 based development boards