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