1 /* 2 * linux/drivers/mmc/wbsd.c - Winbond W83L51xD SD/MMC driver 3 * 4 * Copyright (C) 2004-2007 Pierre Ossman, All Rights Reserved. 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 as published by 8 * the Free Software Foundation; either version 2 of the License, or (at 9 * your option) any later version. 10 * 11 * 12 * Warning! 13 * 14 * Changes to the FIFO system should be done with extreme care since 15 * the hardware is full of bugs related to the FIFO. Known issues are: 16 * 17 * - FIFO size field in FSR is always zero. 18 * 19 * - FIFO interrupts tend not to work as they should. Interrupts are 20 * triggered only for full/empty events, not for threshold values. 21 * 22 * - On APIC systems the FIFO empty interrupt is sometimes lost. 23 */ 24 25 #include <linux/module.h> 26 #include <linux/moduleparam.h> 27 #include <linux/init.h> 28 #include <linux/ioport.h> 29 #include <linux/platform_device.h> 30 #include <linux/interrupt.h> 31 #include <linux/dma-mapping.h> 32 #include <linux/delay.h> 33 #include <linux/pnp.h> 34 #include <linux/highmem.h> 35 #include <linux/mmc/host.h> 36 37 #include <asm/io.h> 38 #include <asm/dma.h> 39 #include <asm/scatterlist.h> 40 41 #include "wbsd.h" 42 43 #define DRIVER_NAME "wbsd" 44 45 #define DBG(x...) \ 46 pr_debug(DRIVER_NAME ": " x) 47 #define DBGF(f, x...) \ 48 pr_debug(DRIVER_NAME " [%s()]: " f, __func__ , ##x) 49 50 /* 51 * Device resources 52 */ 53 54 #ifdef CONFIG_PNP 55 56 static const struct pnp_device_id pnp_dev_table[] = { 57 { "WEC0517", 0 }, 58 { "WEC0518", 0 }, 59 { "", 0 }, 60 }; 61 62 MODULE_DEVICE_TABLE(pnp, pnp_dev_table); 63 64 #endif /* CONFIG_PNP */ 65 66 static const int config_ports[] = { 0x2E, 0x4E }; 67 static const int unlock_codes[] = { 0x83, 0x87 }; 68 69 static const int valid_ids[] = { 70 0x7112, 71 }; 72 73 #ifdef CONFIG_PNP 74 static unsigned int nopnp = 0; 75 #else 76 static const unsigned int nopnp = 1; 77 #endif 78 static unsigned int io = 0x248; 79 static unsigned int irq = 6; 80 static int dma = 2; 81 82 /* 83 * Basic functions 84 */ 85 86 static inline void wbsd_unlock_config(struct wbsd_host *host) 87 { 88 BUG_ON(host->config == 0); 89 90 outb(host->unlock_code, host->config); 91 outb(host->unlock_code, host->config); 92 } 93 94 static inline void wbsd_lock_config(struct wbsd_host *host) 95 { 96 BUG_ON(host->config == 0); 97 98 outb(LOCK_CODE, host->config); 99 } 100 101 static inline void wbsd_write_config(struct wbsd_host *host, u8 reg, u8 value) 102 { 103 BUG_ON(host->config == 0); 104 105 outb(reg, host->config); 106 outb(value, host->config + 1); 107 } 108 109 static inline u8 wbsd_read_config(struct wbsd_host *host, u8 reg) 110 { 111 BUG_ON(host->config == 0); 112 113 outb(reg, host->config); 114 return inb(host->config + 1); 115 } 116 117 static inline void wbsd_write_index(struct wbsd_host *host, u8 index, u8 value) 118 { 119 outb(index, host->base + WBSD_IDXR); 120 outb(value, host->base + WBSD_DATAR); 121 } 122 123 static inline u8 wbsd_read_index(struct wbsd_host *host, u8 index) 124 { 125 outb(index, host->base + WBSD_IDXR); 126 return inb(host->base + WBSD_DATAR); 127 } 128 129 /* 130 * Common routines 131 */ 132 133 static void wbsd_init_device(struct wbsd_host *host) 134 { 135 u8 setup, ier; 136 137 /* 138 * Reset chip (SD/MMC part) and fifo. 139 */ 140 setup = wbsd_read_index(host, WBSD_IDX_SETUP); 141 setup |= WBSD_FIFO_RESET | WBSD_SOFT_RESET; 142 wbsd_write_index(host, WBSD_IDX_SETUP, setup); 143 144 /* 145 * Set DAT3 to input 146 */ 147 setup &= ~WBSD_DAT3_H; 148 wbsd_write_index(host, WBSD_IDX_SETUP, setup); 149 host->flags &= ~WBSD_FIGNORE_DETECT; 150 151 /* 152 * Read back default clock. 153 */ 154 host->clk = wbsd_read_index(host, WBSD_IDX_CLK); 155 156 /* 157 * Power down port. 158 */ 159 outb(WBSD_POWER_N, host->base + WBSD_CSR); 160 161 /* 162 * Set maximum timeout. 163 */ 164 wbsd_write_index(host, WBSD_IDX_TAAC, 0x7F); 165 166 /* 167 * Test for card presence 168 */ 169 if (inb(host->base + WBSD_CSR) & WBSD_CARDPRESENT) 170 host->flags |= WBSD_FCARD_PRESENT; 171 else 172 host->flags &= ~WBSD_FCARD_PRESENT; 173 174 /* 175 * Enable interesting interrupts. 176 */ 177 ier = 0; 178 ier |= WBSD_EINT_CARD; 179 ier |= WBSD_EINT_FIFO_THRE; 180 ier |= WBSD_EINT_CRC; 181 ier |= WBSD_EINT_TIMEOUT; 182 ier |= WBSD_EINT_TC; 183 184 outb(ier, host->base + WBSD_EIR); 185 186 /* 187 * Clear interrupts. 188 */ 189 inb(host->base + WBSD_ISR); 190 } 191 192 static void wbsd_reset(struct wbsd_host *host) 193 { 194 u8 setup; 195 196 printk(KERN_ERR "%s: Resetting chip\n", mmc_hostname(host->mmc)); 197 198 /* 199 * Soft reset of chip (SD/MMC part). 200 */ 201 setup = wbsd_read_index(host, WBSD_IDX_SETUP); 202 setup |= WBSD_SOFT_RESET; 203 wbsd_write_index(host, WBSD_IDX_SETUP, setup); 204 } 205 206 static void wbsd_request_end(struct wbsd_host *host, struct mmc_request *mrq) 207 { 208 unsigned long dmaflags; 209 210 DBGF("Ending request, cmd (%x)\n", mrq->cmd->opcode); 211 212 if (host->dma >= 0) { 213 /* 214 * Release ISA DMA controller. 215 */ 216 dmaflags = claim_dma_lock(); 217 disable_dma(host->dma); 218 clear_dma_ff(host->dma); 219 release_dma_lock(dmaflags); 220 221 /* 222 * Disable DMA on host. 223 */ 224 wbsd_write_index(host, WBSD_IDX_DMA, 0); 225 } 226 227 host->mrq = NULL; 228 229 /* 230 * MMC layer might call back into the driver so first unlock. 231 */ 232 spin_unlock(&host->lock); 233 mmc_request_done(host->mmc, mrq); 234 spin_lock(&host->lock); 235 } 236 237 /* 238 * Scatter/gather functions 239 */ 240 241 static inline void wbsd_init_sg(struct wbsd_host *host, struct mmc_data *data) 242 { 243 /* 244 * Get info. about SG list from data structure. 245 */ 246 host->cur_sg = data->sg; 247 host->num_sg = data->sg_len; 248 249 host->offset = 0; 250 host->remain = host->cur_sg->length; 251 } 252 253 static inline int wbsd_next_sg(struct wbsd_host *host) 254 { 255 /* 256 * Skip to next SG entry. 257 */ 258 host->cur_sg++; 259 host->num_sg--; 260 261 /* 262 * Any entries left? 263 */ 264 if (host->num_sg > 0) { 265 host->offset = 0; 266 host->remain = host->cur_sg->length; 267 } 268 269 return host->num_sg; 270 } 271 272 static inline char *wbsd_sg_to_buffer(struct wbsd_host *host) 273 { 274 return page_address(host->cur_sg->page) + host->cur_sg->offset; 275 } 276 277 static inline void wbsd_sg_to_dma(struct wbsd_host *host, struct mmc_data *data) 278 { 279 unsigned int len, i; 280 struct scatterlist *sg; 281 char *dmabuf = host->dma_buffer; 282 char *sgbuf; 283 284 sg = data->sg; 285 len = data->sg_len; 286 287 for (i = 0; i < len; i++) { 288 sgbuf = page_address(sg[i].page) + sg[i].offset; 289 memcpy(dmabuf, sgbuf, sg[i].length); 290 dmabuf += sg[i].length; 291 } 292 } 293 294 static inline void wbsd_dma_to_sg(struct wbsd_host *host, struct mmc_data *data) 295 { 296 unsigned int len, i; 297 struct scatterlist *sg; 298 char *dmabuf = host->dma_buffer; 299 char *sgbuf; 300 301 sg = data->sg; 302 len = data->sg_len; 303 304 for (i = 0; i < len; i++) { 305 sgbuf = page_address(sg[i].page) + sg[i].offset; 306 memcpy(sgbuf, dmabuf, sg[i].length); 307 dmabuf += sg[i].length; 308 } 309 } 310 311 /* 312 * Command handling 313 */ 314 315 static inline void wbsd_get_short_reply(struct wbsd_host *host, 316 struct mmc_command *cmd) 317 { 318 /* 319 * Correct response type? 320 */ 321 if (wbsd_read_index(host, WBSD_IDX_RSPLEN) != WBSD_RSP_SHORT) { 322 cmd->error = MMC_ERR_INVALID; 323 return; 324 } 325 326 cmd->resp[0] = wbsd_read_index(host, WBSD_IDX_RESP12) << 24; 327 cmd->resp[0] |= wbsd_read_index(host, WBSD_IDX_RESP13) << 16; 328 cmd->resp[0] |= wbsd_read_index(host, WBSD_IDX_RESP14) << 8; 329 cmd->resp[0] |= wbsd_read_index(host, WBSD_IDX_RESP15) << 0; 330 cmd->resp[1] = wbsd_read_index(host, WBSD_IDX_RESP16) << 24; 331 } 332 333 static inline void wbsd_get_long_reply(struct wbsd_host *host, 334 struct mmc_command *cmd) 335 { 336 int i; 337 338 /* 339 * Correct response type? 340 */ 341 if (wbsd_read_index(host, WBSD_IDX_RSPLEN) != WBSD_RSP_LONG) { 342 cmd->error = MMC_ERR_INVALID; 343 return; 344 } 345 346 for (i = 0; i < 4; i++) { 347 cmd->resp[i] = 348 wbsd_read_index(host, WBSD_IDX_RESP1 + i * 4) << 24; 349 cmd->resp[i] |= 350 wbsd_read_index(host, WBSD_IDX_RESP2 + i * 4) << 16; 351 cmd->resp[i] |= 352 wbsd_read_index(host, WBSD_IDX_RESP3 + i * 4) << 8; 353 cmd->resp[i] |= 354 wbsd_read_index(host, WBSD_IDX_RESP4 + i * 4) << 0; 355 } 356 } 357 358 static void wbsd_send_command(struct wbsd_host *host, struct mmc_command *cmd) 359 { 360 int i; 361 u8 status, isr; 362 363 DBGF("Sending cmd (%x)\n", cmd->opcode); 364 365 /* 366 * Clear accumulated ISR. The interrupt routine 367 * will fill this one with events that occur during 368 * transfer. 369 */ 370 host->isr = 0; 371 372 /* 373 * Send the command (CRC calculated by host). 374 */ 375 outb(cmd->opcode, host->base + WBSD_CMDR); 376 for (i = 3; i >= 0; i--) 377 outb((cmd->arg >> (i * 8)) & 0xff, host->base + WBSD_CMDR); 378 379 cmd->error = MMC_ERR_NONE; 380 381 /* 382 * Wait for the request to complete. 383 */ 384 do { 385 status = wbsd_read_index(host, WBSD_IDX_STATUS); 386 } while (status & WBSD_CARDTRAFFIC); 387 388 /* 389 * Do we expect a reply? 390 */ 391 if (cmd->flags & MMC_RSP_PRESENT) { 392 /* 393 * Read back status. 394 */ 395 isr = host->isr; 396 397 /* Card removed? */ 398 if (isr & WBSD_INT_CARD) 399 cmd->error = MMC_ERR_TIMEOUT; 400 /* Timeout? */ 401 else if (isr & WBSD_INT_TIMEOUT) 402 cmd->error = MMC_ERR_TIMEOUT; 403 /* CRC? */ 404 else if ((cmd->flags & MMC_RSP_CRC) && (isr & WBSD_INT_CRC)) 405 cmd->error = MMC_ERR_BADCRC; 406 /* All ok */ 407 else { 408 if (cmd->flags & MMC_RSP_136) 409 wbsd_get_long_reply(host, cmd); 410 else 411 wbsd_get_short_reply(host, cmd); 412 } 413 } 414 415 DBGF("Sent cmd (%x), res %d\n", cmd->opcode, cmd->error); 416 } 417 418 /* 419 * Data functions 420 */ 421 422 static void wbsd_empty_fifo(struct wbsd_host *host) 423 { 424 struct mmc_data *data = host->mrq->cmd->data; 425 char *buffer; 426 int i, fsr, fifo; 427 428 /* 429 * Handle excessive data. 430 */ 431 if (host->num_sg == 0) 432 return; 433 434 buffer = wbsd_sg_to_buffer(host) + host->offset; 435 436 /* 437 * Drain the fifo. This has a tendency to loop longer 438 * than the FIFO length (usually one block). 439 */ 440 while (!((fsr = inb(host->base + WBSD_FSR)) & WBSD_FIFO_EMPTY)) { 441 /* 442 * The size field in the FSR is broken so we have to 443 * do some guessing. 444 */ 445 if (fsr & WBSD_FIFO_FULL) 446 fifo = 16; 447 else if (fsr & WBSD_FIFO_FUTHRE) 448 fifo = 8; 449 else 450 fifo = 1; 451 452 for (i = 0; i < fifo; i++) { 453 *buffer = inb(host->base + WBSD_DFR); 454 buffer++; 455 host->offset++; 456 host->remain--; 457 458 data->bytes_xfered++; 459 460 /* 461 * End of scatter list entry? 462 */ 463 if (host->remain == 0) { 464 /* 465 * Get next entry. Check if last. 466 */ 467 if (!wbsd_next_sg(host)) 468 return; 469 470 buffer = wbsd_sg_to_buffer(host); 471 } 472 } 473 } 474 475 /* 476 * This is a very dirty hack to solve a 477 * hardware problem. The chip doesn't trigger 478 * FIFO threshold interrupts properly. 479 */ 480 if ((data->blocks * data->blksz - data->bytes_xfered) < 16) 481 tasklet_schedule(&host->fifo_tasklet); 482 } 483 484 static void wbsd_fill_fifo(struct wbsd_host *host) 485 { 486 struct mmc_data *data = host->mrq->cmd->data; 487 char *buffer; 488 int i, fsr, fifo; 489 490 /* 491 * Check that we aren't being called after the 492 * entire buffer has been transfered. 493 */ 494 if (host->num_sg == 0) 495 return; 496 497 buffer = wbsd_sg_to_buffer(host) + host->offset; 498 499 /* 500 * Fill the fifo. This has a tendency to loop longer 501 * than the FIFO length (usually one block). 502 */ 503 while (!((fsr = inb(host->base + WBSD_FSR)) & WBSD_FIFO_FULL)) { 504 /* 505 * The size field in the FSR is broken so we have to 506 * do some guessing. 507 */ 508 if (fsr & WBSD_FIFO_EMPTY) 509 fifo = 0; 510 else if (fsr & WBSD_FIFO_EMTHRE) 511 fifo = 8; 512 else 513 fifo = 15; 514 515 for (i = 16; i > fifo; i--) { 516 outb(*buffer, host->base + WBSD_DFR); 517 buffer++; 518 host->offset++; 519 host->remain--; 520 521 data->bytes_xfered++; 522 523 /* 524 * End of scatter list entry? 525 */ 526 if (host->remain == 0) { 527 /* 528 * Get next entry. Check if last. 529 */ 530 if (!wbsd_next_sg(host)) 531 return; 532 533 buffer = wbsd_sg_to_buffer(host); 534 } 535 } 536 } 537 538 /* 539 * The controller stops sending interrupts for 540 * 'FIFO empty' under certain conditions. So we 541 * need to be a bit more pro-active. 542 */ 543 tasklet_schedule(&host->fifo_tasklet); 544 } 545 546 static void wbsd_prepare_data(struct wbsd_host *host, struct mmc_data *data) 547 { 548 u16 blksize; 549 u8 setup; 550 unsigned long dmaflags; 551 unsigned int size; 552 553 DBGF("blksz %04x blks %04x flags %08x\n", 554 data->blksz, data->blocks, data->flags); 555 DBGF("tsac %d ms nsac %d clk\n", 556 data->timeout_ns / 1000000, data->timeout_clks); 557 558 /* 559 * Calculate size. 560 */ 561 size = data->blocks * data->blksz; 562 563 /* 564 * Check timeout values for overflow. 565 * (Yes, some cards cause this value to overflow). 566 */ 567 if (data->timeout_ns > 127000000) 568 wbsd_write_index(host, WBSD_IDX_TAAC, 127); 569 else { 570 wbsd_write_index(host, WBSD_IDX_TAAC, 571 data->timeout_ns / 1000000); 572 } 573 574 if (data->timeout_clks > 255) 575 wbsd_write_index(host, WBSD_IDX_NSAC, 255); 576 else 577 wbsd_write_index(host, WBSD_IDX_NSAC, data->timeout_clks); 578 579 /* 580 * Inform the chip of how large blocks will be 581 * sent. It needs this to determine when to 582 * calculate CRC. 583 * 584 * Space for CRC must be included in the size. 585 * Two bytes are needed for each data line. 586 */ 587 if (host->bus_width == MMC_BUS_WIDTH_1) { 588 blksize = data->blksz + 2; 589 590 wbsd_write_index(host, WBSD_IDX_PBSMSB, (blksize >> 4) & 0xF0); 591 wbsd_write_index(host, WBSD_IDX_PBSLSB, blksize & 0xFF); 592 } else if (host->bus_width == MMC_BUS_WIDTH_4) { 593 blksize = data->blksz + 2 * 4; 594 595 wbsd_write_index(host, WBSD_IDX_PBSMSB, 596 ((blksize >> 4) & 0xF0) | WBSD_DATA_WIDTH); 597 wbsd_write_index(host, WBSD_IDX_PBSLSB, blksize & 0xFF); 598 } else { 599 data->error = MMC_ERR_INVALID; 600 return; 601 } 602 603 /* 604 * Clear the FIFO. This is needed even for DMA 605 * transfers since the chip still uses the FIFO 606 * internally. 607 */ 608 setup = wbsd_read_index(host, WBSD_IDX_SETUP); 609 setup |= WBSD_FIFO_RESET; 610 wbsd_write_index(host, WBSD_IDX_SETUP, setup); 611 612 /* 613 * DMA transfer? 614 */ 615 if (host->dma >= 0) { 616 /* 617 * The buffer for DMA is only 64 kB. 618 */ 619 BUG_ON(size > 0x10000); 620 if (size > 0x10000) { 621 data->error = MMC_ERR_INVALID; 622 return; 623 } 624 625 /* 626 * Transfer data from the SG list to 627 * the DMA buffer. 628 */ 629 if (data->flags & MMC_DATA_WRITE) 630 wbsd_sg_to_dma(host, data); 631 632 /* 633 * Initialise the ISA DMA controller. 634 */ 635 dmaflags = claim_dma_lock(); 636 disable_dma(host->dma); 637 clear_dma_ff(host->dma); 638 if (data->flags & MMC_DATA_READ) 639 set_dma_mode(host->dma, DMA_MODE_READ & ~0x40); 640 else 641 set_dma_mode(host->dma, DMA_MODE_WRITE & ~0x40); 642 set_dma_addr(host->dma, host->dma_addr); 643 set_dma_count(host->dma, size); 644 645 enable_dma(host->dma); 646 release_dma_lock(dmaflags); 647 648 /* 649 * Enable DMA on the host. 650 */ 651 wbsd_write_index(host, WBSD_IDX_DMA, WBSD_DMA_ENABLE); 652 } else { 653 /* 654 * This flag is used to keep printk 655 * output to a minimum. 656 */ 657 host->firsterr = 1; 658 659 /* 660 * Initialise the SG list. 661 */ 662 wbsd_init_sg(host, data); 663 664 /* 665 * Turn off DMA. 666 */ 667 wbsd_write_index(host, WBSD_IDX_DMA, 0); 668 669 /* 670 * Set up FIFO threshold levels (and fill 671 * buffer if doing a write). 672 */ 673 if (data->flags & MMC_DATA_READ) { 674 wbsd_write_index(host, WBSD_IDX_FIFOEN, 675 WBSD_FIFOEN_FULL | 8); 676 } else { 677 wbsd_write_index(host, WBSD_IDX_FIFOEN, 678 WBSD_FIFOEN_EMPTY | 8); 679 wbsd_fill_fifo(host); 680 } 681 } 682 683 data->error = MMC_ERR_NONE; 684 } 685 686 static void wbsd_finish_data(struct wbsd_host *host, struct mmc_data *data) 687 { 688 unsigned long dmaflags; 689 int count; 690 u8 status; 691 692 WARN_ON(host->mrq == NULL); 693 694 /* 695 * Send a stop command if needed. 696 */ 697 if (data->stop) 698 wbsd_send_command(host, data->stop); 699 700 /* 701 * Wait for the controller to leave data 702 * transfer state. 703 */ 704 do { 705 status = wbsd_read_index(host, WBSD_IDX_STATUS); 706 } while (status & (WBSD_BLOCK_READ | WBSD_BLOCK_WRITE)); 707 708 /* 709 * DMA transfer? 710 */ 711 if (host->dma >= 0) { 712 /* 713 * Disable DMA on the host. 714 */ 715 wbsd_write_index(host, WBSD_IDX_DMA, 0); 716 717 /* 718 * Turn of ISA DMA controller. 719 */ 720 dmaflags = claim_dma_lock(); 721 disable_dma(host->dma); 722 clear_dma_ff(host->dma); 723 count = get_dma_residue(host->dma); 724 release_dma_lock(dmaflags); 725 726 data->bytes_xfered = host->mrq->data->blocks * 727 host->mrq->data->blksz - count; 728 data->bytes_xfered -= data->bytes_xfered % data->blksz; 729 730 /* 731 * Any leftover data? 732 */ 733 if (count) { 734 printk(KERN_ERR "%s: Incomplete DMA transfer. " 735 "%d bytes left.\n", 736 mmc_hostname(host->mmc), count); 737 738 if (data->error == MMC_ERR_NONE) 739 data->error = MMC_ERR_FAILED; 740 } else { 741 /* 742 * Transfer data from DMA buffer to 743 * SG list. 744 */ 745 if (data->flags & MMC_DATA_READ) 746 wbsd_dma_to_sg(host, data); 747 } 748 749 if (data->error != MMC_ERR_NONE) { 750 if (data->bytes_xfered) 751 data->bytes_xfered -= data->blksz; 752 } 753 } 754 755 DBGF("Ending data transfer (%d bytes)\n", data->bytes_xfered); 756 757 wbsd_request_end(host, host->mrq); 758 } 759 760 /*****************************************************************************\ 761 * * 762 * MMC layer callbacks * 763 * * 764 \*****************************************************************************/ 765 766 static void wbsd_request(struct mmc_host *mmc, struct mmc_request *mrq) 767 { 768 struct wbsd_host *host = mmc_priv(mmc); 769 struct mmc_command *cmd; 770 771 /* 772 * Disable tasklets to avoid a deadlock. 773 */ 774 spin_lock_bh(&host->lock); 775 776 BUG_ON(host->mrq != NULL); 777 778 cmd = mrq->cmd; 779 780 host->mrq = mrq; 781 782 /* 783 * If there is no card in the slot then 784 * timeout immediatly. 785 */ 786 if (!(host->flags & WBSD_FCARD_PRESENT)) { 787 cmd->error = MMC_ERR_TIMEOUT; 788 goto done; 789 } 790 791 if (cmd->data) { 792 /* 793 * The hardware is so delightfully stupid that it has a list 794 * of "data" commands. If a command isn't on this list, it'll 795 * just go back to the idle state and won't send any data 796 * interrupts. 797 */ 798 switch (cmd->opcode) { 799 case 11: 800 case 17: 801 case 18: 802 case 20: 803 case 24: 804 case 25: 805 case 26: 806 case 27: 807 case 30: 808 case 42: 809 case 56: 810 break; 811 812 /* ACMDs. We don't keep track of state, so we just treat them 813 * like any other command. */ 814 case 51: 815 break; 816 817 default: 818 #ifdef CONFIG_MMC_DEBUG 819 printk(KERN_WARNING "%s: Data command %d is not " 820 "supported by this controller.\n", 821 mmc_hostname(host->mmc), cmd->opcode); 822 #endif 823 cmd->error = MMC_ERR_INVALID; 824 825 goto done; 826 }; 827 } 828 829 /* 830 * Does the request include data? 831 */ 832 if (cmd->data) { 833 wbsd_prepare_data(host, cmd->data); 834 835 if (cmd->data->error != MMC_ERR_NONE) 836 goto done; 837 } 838 839 wbsd_send_command(host, cmd); 840 841 /* 842 * If this is a data transfer the request 843 * will be finished after the data has 844 * transfered. 845 */ 846 if (cmd->data && (cmd->error == MMC_ERR_NONE)) { 847 /* 848 * Dirty fix for hardware bug. 849 */ 850 if (host->dma == -1) 851 tasklet_schedule(&host->fifo_tasklet); 852 853 spin_unlock_bh(&host->lock); 854 855 return; 856 } 857 858 done: 859 wbsd_request_end(host, mrq); 860 861 spin_unlock_bh(&host->lock); 862 } 863 864 static void wbsd_set_ios(struct mmc_host *mmc, struct mmc_ios *ios) 865 { 866 struct wbsd_host *host = mmc_priv(mmc); 867 u8 clk, setup, pwr; 868 869 spin_lock_bh(&host->lock); 870 871 /* 872 * Reset the chip on each power off. 873 * Should clear out any weird states. 874 */ 875 if (ios->power_mode == MMC_POWER_OFF) 876 wbsd_init_device(host); 877 878 if (ios->clock >= 24000000) 879 clk = WBSD_CLK_24M; 880 else if (ios->clock >= 16000000) 881 clk = WBSD_CLK_16M; 882 else if (ios->clock >= 12000000) 883 clk = WBSD_CLK_12M; 884 else 885 clk = WBSD_CLK_375K; 886 887 /* 888 * Only write to the clock register when 889 * there is an actual change. 890 */ 891 if (clk != host->clk) { 892 wbsd_write_index(host, WBSD_IDX_CLK, clk); 893 host->clk = clk; 894 } 895 896 /* 897 * Power up card. 898 */ 899 if (ios->power_mode != MMC_POWER_OFF) { 900 pwr = inb(host->base + WBSD_CSR); 901 pwr &= ~WBSD_POWER_N; 902 outb(pwr, host->base + WBSD_CSR); 903 } 904 905 /* 906 * MMC cards need to have pin 1 high during init. 907 * It wreaks havoc with the card detection though so 908 * that needs to be disabled. 909 */ 910 setup = wbsd_read_index(host, WBSD_IDX_SETUP); 911 if (ios->chip_select == MMC_CS_HIGH) { 912 BUG_ON(ios->bus_width != MMC_BUS_WIDTH_1); 913 setup |= WBSD_DAT3_H; 914 host->flags |= WBSD_FIGNORE_DETECT; 915 } else { 916 if (setup & WBSD_DAT3_H) { 917 setup &= ~WBSD_DAT3_H; 918 919 /* 920 * We cannot resume card detection immediatly 921 * because of capacitance and delays in the chip. 922 */ 923 mod_timer(&host->ignore_timer, jiffies + HZ / 100); 924 } 925 } 926 wbsd_write_index(host, WBSD_IDX_SETUP, setup); 927 928 /* 929 * Store bus width for later. Will be used when 930 * setting up the data transfer. 931 */ 932 host->bus_width = ios->bus_width; 933 934 spin_unlock_bh(&host->lock); 935 } 936 937 static int wbsd_get_ro(struct mmc_host *mmc) 938 { 939 struct wbsd_host *host = mmc_priv(mmc); 940 u8 csr; 941 942 spin_lock_bh(&host->lock); 943 944 csr = inb(host->base + WBSD_CSR); 945 csr |= WBSD_MSLED; 946 outb(csr, host->base + WBSD_CSR); 947 948 mdelay(1); 949 950 csr = inb(host->base + WBSD_CSR); 951 csr &= ~WBSD_MSLED; 952 outb(csr, host->base + WBSD_CSR); 953 954 spin_unlock_bh(&host->lock); 955 956 return csr & WBSD_WRPT; 957 } 958 959 static const struct mmc_host_ops wbsd_ops = { 960 .request = wbsd_request, 961 .set_ios = wbsd_set_ios, 962 .get_ro = wbsd_get_ro, 963 }; 964 965 /*****************************************************************************\ 966 * * 967 * Interrupt handling * 968 * * 969 \*****************************************************************************/ 970 971 /* 972 * Helper function to reset detection ignore 973 */ 974 975 static void wbsd_reset_ignore(unsigned long data) 976 { 977 struct wbsd_host *host = (struct wbsd_host *)data; 978 979 BUG_ON(host == NULL); 980 981 DBG("Resetting card detection ignore\n"); 982 983 spin_lock_bh(&host->lock); 984 985 host->flags &= ~WBSD_FIGNORE_DETECT; 986 987 /* 988 * Card status might have changed during the 989 * blackout. 990 */ 991 tasklet_schedule(&host->card_tasklet); 992 993 spin_unlock_bh(&host->lock); 994 } 995 996 /* 997 * Tasklets 998 */ 999 1000 static inline struct mmc_data *wbsd_get_data(struct wbsd_host *host) 1001 { 1002 WARN_ON(!host->mrq); 1003 if (!host->mrq) 1004 return NULL; 1005 1006 WARN_ON(!host->mrq->cmd); 1007 if (!host->mrq->cmd) 1008 return NULL; 1009 1010 WARN_ON(!host->mrq->cmd->data); 1011 if (!host->mrq->cmd->data) 1012 return NULL; 1013 1014 return host->mrq->cmd->data; 1015 } 1016 1017 static void wbsd_tasklet_card(unsigned long param) 1018 { 1019 struct wbsd_host *host = (struct wbsd_host *)param; 1020 u8 csr; 1021 int delay = -1; 1022 1023 spin_lock(&host->lock); 1024 1025 if (host->flags & WBSD_FIGNORE_DETECT) { 1026 spin_unlock(&host->lock); 1027 return; 1028 } 1029 1030 csr = inb(host->base + WBSD_CSR); 1031 WARN_ON(csr == 0xff); 1032 1033 if (csr & WBSD_CARDPRESENT) { 1034 if (!(host->flags & WBSD_FCARD_PRESENT)) { 1035 DBG("Card inserted\n"); 1036 host->flags |= WBSD_FCARD_PRESENT; 1037 1038 delay = 500; 1039 } 1040 } else if (host->flags & WBSD_FCARD_PRESENT) { 1041 DBG("Card removed\n"); 1042 host->flags &= ~WBSD_FCARD_PRESENT; 1043 1044 if (host->mrq) { 1045 printk(KERN_ERR "%s: Card removed during transfer!\n", 1046 mmc_hostname(host->mmc)); 1047 wbsd_reset(host); 1048 1049 host->mrq->cmd->error = MMC_ERR_FAILED; 1050 tasklet_schedule(&host->finish_tasklet); 1051 } 1052 1053 delay = 0; 1054 } 1055 1056 /* 1057 * Unlock first since we might get a call back. 1058 */ 1059 1060 spin_unlock(&host->lock); 1061 1062 if (delay != -1) 1063 mmc_detect_change(host->mmc, msecs_to_jiffies(delay)); 1064 } 1065 1066 static void wbsd_tasklet_fifo(unsigned long param) 1067 { 1068 struct wbsd_host *host = (struct wbsd_host *)param; 1069 struct mmc_data *data; 1070 1071 spin_lock(&host->lock); 1072 1073 if (!host->mrq) 1074 goto end; 1075 1076 data = wbsd_get_data(host); 1077 if (!data) 1078 goto end; 1079 1080 if (data->flags & MMC_DATA_WRITE) 1081 wbsd_fill_fifo(host); 1082 else 1083 wbsd_empty_fifo(host); 1084 1085 /* 1086 * Done? 1087 */ 1088 if (host->num_sg == 0) { 1089 wbsd_write_index(host, WBSD_IDX_FIFOEN, 0); 1090 tasklet_schedule(&host->finish_tasklet); 1091 } 1092 1093 end: 1094 spin_unlock(&host->lock); 1095 } 1096 1097 static void wbsd_tasklet_crc(unsigned long param) 1098 { 1099 struct wbsd_host *host = (struct wbsd_host *)param; 1100 struct mmc_data *data; 1101 1102 spin_lock(&host->lock); 1103 1104 if (!host->mrq) 1105 goto end; 1106 1107 data = wbsd_get_data(host); 1108 if (!data) 1109 goto end; 1110 1111 DBGF("CRC error\n"); 1112 1113 data->error = MMC_ERR_BADCRC; 1114 1115 tasklet_schedule(&host->finish_tasklet); 1116 1117 end: 1118 spin_unlock(&host->lock); 1119 } 1120 1121 static void wbsd_tasklet_timeout(unsigned long param) 1122 { 1123 struct wbsd_host *host = (struct wbsd_host *)param; 1124 struct mmc_data *data; 1125 1126 spin_lock(&host->lock); 1127 1128 if (!host->mrq) 1129 goto end; 1130 1131 data = wbsd_get_data(host); 1132 if (!data) 1133 goto end; 1134 1135 DBGF("Timeout\n"); 1136 1137 data->error = MMC_ERR_TIMEOUT; 1138 1139 tasklet_schedule(&host->finish_tasklet); 1140 1141 end: 1142 spin_unlock(&host->lock); 1143 } 1144 1145 static void wbsd_tasklet_finish(unsigned long param) 1146 { 1147 struct wbsd_host *host = (struct wbsd_host *)param; 1148 struct mmc_data *data; 1149 1150 spin_lock(&host->lock); 1151 1152 WARN_ON(!host->mrq); 1153 if (!host->mrq) 1154 goto end; 1155 1156 data = wbsd_get_data(host); 1157 if (!data) 1158 goto end; 1159 1160 wbsd_finish_data(host, data); 1161 1162 end: 1163 spin_unlock(&host->lock); 1164 } 1165 1166 /* 1167 * Interrupt handling 1168 */ 1169 1170 static irqreturn_t wbsd_irq(int irq, void *dev_id) 1171 { 1172 struct wbsd_host *host = dev_id; 1173 int isr; 1174 1175 isr = inb(host->base + WBSD_ISR); 1176 1177 /* 1178 * Was it actually our hardware that caused the interrupt? 1179 */ 1180 if (isr == 0xff || isr == 0x00) 1181 return IRQ_NONE; 1182 1183 host->isr |= isr; 1184 1185 /* 1186 * Schedule tasklets as needed. 1187 */ 1188 if (isr & WBSD_INT_CARD) 1189 tasklet_schedule(&host->card_tasklet); 1190 if (isr & WBSD_INT_FIFO_THRE) 1191 tasklet_schedule(&host->fifo_tasklet); 1192 if (isr & WBSD_INT_CRC) 1193 tasklet_hi_schedule(&host->crc_tasklet); 1194 if (isr & WBSD_INT_TIMEOUT) 1195 tasklet_hi_schedule(&host->timeout_tasklet); 1196 if (isr & WBSD_INT_TC) 1197 tasklet_schedule(&host->finish_tasklet); 1198 1199 return IRQ_HANDLED; 1200 } 1201 1202 /*****************************************************************************\ 1203 * * 1204 * Device initialisation and shutdown * 1205 * * 1206 \*****************************************************************************/ 1207 1208 /* 1209 * Allocate/free MMC structure. 1210 */ 1211 1212 static int __devinit wbsd_alloc_mmc(struct device *dev) 1213 { 1214 struct mmc_host *mmc; 1215 struct wbsd_host *host; 1216 1217 /* 1218 * Allocate MMC structure. 1219 */ 1220 mmc = mmc_alloc_host(sizeof(struct wbsd_host), dev); 1221 if (!mmc) 1222 return -ENOMEM; 1223 1224 host = mmc_priv(mmc); 1225 host->mmc = mmc; 1226 1227 host->dma = -1; 1228 1229 /* 1230 * Set host parameters. 1231 */ 1232 mmc->ops = &wbsd_ops; 1233 mmc->f_min = 375000; 1234 mmc->f_max = 24000000; 1235 mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34; 1236 mmc->caps = MMC_CAP_4_BIT_DATA | MMC_CAP_MULTIWRITE | MMC_CAP_BYTEBLOCK; 1237 1238 spin_lock_init(&host->lock); 1239 1240 /* 1241 * Set up timers 1242 */ 1243 init_timer(&host->ignore_timer); 1244 host->ignore_timer.data = (unsigned long)host; 1245 host->ignore_timer.function = wbsd_reset_ignore; 1246 1247 /* 1248 * Maximum number of segments. Worst case is one sector per segment 1249 * so this will be 64kB/512. 1250 */ 1251 mmc->max_hw_segs = 128; 1252 mmc->max_phys_segs = 128; 1253 1254 /* 1255 * Maximum request size. Also limited by 64KiB buffer. 1256 */ 1257 mmc->max_req_size = 65536; 1258 1259 /* 1260 * Maximum segment size. Could be one segment with the maximum number 1261 * of bytes. 1262 */ 1263 mmc->max_seg_size = mmc->max_req_size; 1264 1265 /* 1266 * Maximum block size. We have 12 bits (= 4095) but have to subtract 1267 * space for CRC. So the maximum is 4095 - 4*2 = 4087. 1268 */ 1269 mmc->max_blk_size = 4087; 1270 1271 /* 1272 * Maximum block count. There is no real limit so the maximum 1273 * request size will be the only restriction. 1274 */ 1275 mmc->max_blk_count = mmc->max_req_size; 1276 1277 dev_set_drvdata(dev, mmc); 1278 1279 return 0; 1280 } 1281 1282 static void __devexit wbsd_free_mmc(struct device *dev) 1283 { 1284 struct mmc_host *mmc; 1285 struct wbsd_host *host; 1286 1287 mmc = dev_get_drvdata(dev); 1288 if (!mmc) 1289 return; 1290 1291 host = mmc_priv(mmc); 1292 BUG_ON(host == NULL); 1293 1294 del_timer_sync(&host->ignore_timer); 1295 1296 mmc_free_host(mmc); 1297 1298 dev_set_drvdata(dev, NULL); 1299 } 1300 1301 /* 1302 * Scan for known chip id:s 1303 */ 1304 1305 static int __devinit wbsd_scan(struct wbsd_host *host) 1306 { 1307 int i, j, k; 1308 int id; 1309 1310 /* 1311 * Iterate through all ports, all codes to 1312 * find hardware that is in our known list. 1313 */ 1314 for (i = 0; i < ARRAY_SIZE(config_ports); i++) { 1315 if (!request_region(config_ports[i], 2, DRIVER_NAME)) 1316 continue; 1317 1318 for (j = 0; j < ARRAY_SIZE(unlock_codes); j++) { 1319 id = 0xFFFF; 1320 1321 host->config = config_ports[i]; 1322 host->unlock_code = unlock_codes[j]; 1323 1324 wbsd_unlock_config(host); 1325 1326 outb(WBSD_CONF_ID_HI, config_ports[i]); 1327 id = inb(config_ports[i] + 1) << 8; 1328 1329 outb(WBSD_CONF_ID_LO, config_ports[i]); 1330 id |= inb(config_ports[i] + 1); 1331 1332 wbsd_lock_config(host); 1333 1334 for (k = 0; k < ARRAY_SIZE(valid_ids); k++) { 1335 if (id == valid_ids[k]) { 1336 host->chip_id = id; 1337 1338 return 0; 1339 } 1340 } 1341 1342 if (id != 0xFFFF) { 1343 DBG("Unknown hardware (id %x) found at %x\n", 1344 id, config_ports[i]); 1345 } 1346 } 1347 1348 release_region(config_ports[i], 2); 1349 } 1350 1351 host->config = 0; 1352 host->unlock_code = 0; 1353 1354 return -ENODEV; 1355 } 1356 1357 /* 1358 * Allocate/free io port ranges 1359 */ 1360 1361 static int __devinit wbsd_request_region(struct wbsd_host *host, int base) 1362 { 1363 if (base & 0x7) 1364 return -EINVAL; 1365 1366 if (!request_region(base, 8, DRIVER_NAME)) 1367 return -EIO; 1368 1369 host->base = base; 1370 1371 return 0; 1372 } 1373 1374 static void __devexit wbsd_release_regions(struct wbsd_host *host) 1375 { 1376 if (host->base) 1377 release_region(host->base, 8); 1378 1379 host->base = 0; 1380 1381 if (host->config) 1382 release_region(host->config, 2); 1383 1384 host->config = 0; 1385 } 1386 1387 /* 1388 * Allocate/free DMA port and buffer 1389 */ 1390 1391 static void __devinit wbsd_request_dma(struct wbsd_host *host, int dma) 1392 { 1393 if (dma < 0) 1394 return; 1395 1396 if (request_dma(dma, DRIVER_NAME)) 1397 goto err; 1398 1399 /* 1400 * We need to allocate a special buffer in 1401 * order for ISA to be able to DMA to it. 1402 */ 1403 host->dma_buffer = kmalloc(WBSD_DMA_SIZE, 1404 GFP_NOIO | GFP_DMA | __GFP_REPEAT | __GFP_NOWARN); 1405 if (!host->dma_buffer) 1406 goto free; 1407 1408 /* 1409 * Translate the address to a physical address. 1410 */ 1411 host->dma_addr = dma_map_single(mmc_dev(host->mmc), host->dma_buffer, 1412 WBSD_DMA_SIZE, DMA_BIDIRECTIONAL); 1413 1414 /* 1415 * ISA DMA must be aligned on a 64k basis. 1416 */ 1417 if ((host->dma_addr & 0xffff) != 0) 1418 goto kfree; 1419 /* 1420 * ISA cannot access memory above 16 MB. 1421 */ 1422 else if (host->dma_addr >= 0x1000000) 1423 goto kfree; 1424 1425 host->dma = dma; 1426 1427 return; 1428 1429 kfree: 1430 /* 1431 * If we've gotten here then there is some kind of alignment bug 1432 */ 1433 BUG_ON(1); 1434 1435 dma_unmap_single(mmc_dev(host->mmc), host->dma_addr, 1436 WBSD_DMA_SIZE, DMA_BIDIRECTIONAL); 1437 host->dma_addr = (dma_addr_t)NULL; 1438 1439 kfree(host->dma_buffer); 1440 host->dma_buffer = NULL; 1441 1442 free: 1443 free_dma(dma); 1444 1445 err: 1446 printk(KERN_WARNING DRIVER_NAME ": Unable to allocate DMA %d. " 1447 "Falling back on FIFO.\n", dma); 1448 } 1449 1450 static void __devexit wbsd_release_dma(struct wbsd_host *host) 1451 { 1452 if (host->dma_addr) { 1453 dma_unmap_single(mmc_dev(host->mmc), host->dma_addr, 1454 WBSD_DMA_SIZE, DMA_BIDIRECTIONAL); 1455 } 1456 kfree(host->dma_buffer); 1457 if (host->dma >= 0) 1458 free_dma(host->dma); 1459 1460 host->dma = -1; 1461 host->dma_buffer = NULL; 1462 host->dma_addr = (dma_addr_t)NULL; 1463 } 1464 1465 /* 1466 * Allocate/free IRQ. 1467 */ 1468 1469 static int __devinit wbsd_request_irq(struct wbsd_host *host, int irq) 1470 { 1471 int ret; 1472 1473 /* 1474 * Allocate interrupt. 1475 */ 1476 1477 ret = request_irq(irq, wbsd_irq, IRQF_SHARED, DRIVER_NAME, host); 1478 if (ret) 1479 return ret; 1480 1481 host->irq = irq; 1482 1483 /* 1484 * Set up tasklets. 1485 */ 1486 tasklet_init(&host->card_tasklet, wbsd_tasklet_card, 1487 (unsigned long)host); 1488 tasklet_init(&host->fifo_tasklet, wbsd_tasklet_fifo, 1489 (unsigned long)host); 1490 tasklet_init(&host->crc_tasklet, wbsd_tasklet_crc, 1491 (unsigned long)host); 1492 tasklet_init(&host->timeout_tasklet, wbsd_tasklet_timeout, 1493 (unsigned long)host); 1494 tasklet_init(&host->finish_tasklet, wbsd_tasklet_finish, 1495 (unsigned long)host); 1496 1497 return 0; 1498 } 1499 1500 static void __devexit wbsd_release_irq(struct wbsd_host *host) 1501 { 1502 if (!host->irq) 1503 return; 1504 1505 free_irq(host->irq, host); 1506 1507 host->irq = 0; 1508 1509 tasklet_kill(&host->card_tasklet); 1510 tasklet_kill(&host->fifo_tasklet); 1511 tasklet_kill(&host->crc_tasklet); 1512 tasklet_kill(&host->timeout_tasklet); 1513 tasklet_kill(&host->finish_tasklet); 1514 } 1515 1516 /* 1517 * Allocate all resources for the host. 1518 */ 1519 1520 static int __devinit wbsd_request_resources(struct wbsd_host *host, 1521 int base, int irq, int dma) 1522 { 1523 int ret; 1524 1525 /* 1526 * Allocate I/O ports. 1527 */ 1528 ret = wbsd_request_region(host, base); 1529 if (ret) 1530 return ret; 1531 1532 /* 1533 * Allocate interrupt. 1534 */ 1535 ret = wbsd_request_irq(host, irq); 1536 if (ret) 1537 return ret; 1538 1539 /* 1540 * Allocate DMA. 1541 */ 1542 wbsd_request_dma(host, dma); 1543 1544 return 0; 1545 } 1546 1547 /* 1548 * Release all resources for the host. 1549 */ 1550 1551 static void __devexit wbsd_release_resources(struct wbsd_host *host) 1552 { 1553 wbsd_release_dma(host); 1554 wbsd_release_irq(host); 1555 wbsd_release_regions(host); 1556 } 1557 1558 /* 1559 * Configure the resources the chip should use. 1560 */ 1561 1562 static void wbsd_chip_config(struct wbsd_host *host) 1563 { 1564 wbsd_unlock_config(host); 1565 1566 /* 1567 * Reset the chip. 1568 */ 1569 wbsd_write_config(host, WBSD_CONF_SWRST, 1); 1570 wbsd_write_config(host, WBSD_CONF_SWRST, 0); 1571 1572 /* 1573 * Select SD/MMC function. 1574 */ 1575 wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD); 1576 1577 /* 1578 * Set up card detection. 1579 */ 1580 wbsd_write_config(host, WBSD_CONF_PINS, WBSD_PINS_DETECT_GP11); 1581 1582 /* 1583 * Configure chip 1584 */ 1585 wbsd_write_config(host, WBSD_CONF_PORT_HI, host->base >> 8); 1586 wbsd_write_config(host, WBSD_CONF_PORT_LO, host->base & 0xff); 1587 1588 wbsd_write_config(host, WBSD_CONF_IRQ, host->irq); 1589 1590 if (host->dma >= 0) 1591 wbsd_write_config(host, WBSD_CONF_DRQ, host->dma); 1592 1593 /* 1594 * Enable and power up chip. 1595 */ 1596 wbsd_write_config(host, WBSD_CONF_ENABLE, 1); 1597 wbsd_write_config(host, WBSD_CONF_POWER, 0x20); 1598 1599 wbsd_lock_config(host); 1600 } 1601 1602 /* 1603 * Check that configured resources are correct. 1604 */ 1605 1606 static int wbsd_chip_validate(struct wbsd_host *host) 1607 { 1608 int base, irq, dma; 1609 1610 wbsd_unlock_config(host); 1611 1612 /* 1613 * Select SD/MMC function. 1614 */ 1615 wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD); 1616 1617 /* 1618 * Read configuration. 1619 */ 1620 base = wbsd_read_config(host, WBSD_CONF_PORT_HI) << 8; 1621 base |= wbsd_read_config(host, WBSD_CONF_PORT_LO); 1622 1623 irq = wbsd_read_config(host, WBSD_CONF_IRQ); 1624 1625 dma = wbsd_read_config(host, WBSD_CONF_DRQ); 1626 1627 wbsd_lock_config(host); 1628 1629 /* 1630 * Validate against given configuration. 1631 */ 1632 if (base != host->base) 1633 return 0; 1634 if (irq != host->irq) 1635 return 0; 1636 if ((dma != host->dma) && (host->dma != -1)) 1637 return 0; 1638 1639 return 1; 1640 } 1641 1642 /* 1643 * Powers down the SD function 1644 */ 1645 1646 static void wbsd_chip_poweroff(struct wbsd_host *host) 1647 { 1648 wbsd_unlock_config(host); 1649 1650 wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD); 1651 wbsd_write_config(host, WBSD_CONF_ENABLE, 0); 1652 1653 wbsd_lock_config(host); 1654 } 1655 1656 /*****************************************************************************\ 1657 * * 1658 * Devices setup and shutdown * 1659 * * 1660 \*****************************************************************************/ 1661 1662 static int __devinit wbsd_init(struct device *dev, int base, int irq, int dma, 1663 int pnp) 1664 { 1665 struct wbsd_host *host = NULL; 1666 struct mmc_host *mmc = NULL; 1667 int ret; 1668 1669 ret = wbsd_alloc_mmc(dev); 1670 if (ret) 1671 return ret; 1672 1673 mmc = dev_get_drvdata(dev); 1674 host = mmc_priv(mmc); 1675 1676 /* 1677 * Scan for hardware. 1678 */ 1679 ret = wbsd_scan(host); 1680 if (ret) { 1681 if (pnp && (ret == -ENODEV)) { 1682 printk(KERN_WARNING DRIVER_NAME 1683 ": Unable to confirm device presence. You may " 1684 "experience lock-ups.\n"); 1685 } else { 1686 wbsd_free_mmc(dev); 1687 return ret; 1688 } 1689 } 1690 1691 /* 1692 * Request resources. 1693 */ 1694 ret = wbsd_request_resources(host, base, irq, dma); 1695 if (ret) { 1696 wbsd_release_resources(host); 1697 wbsd_free_mmc(dev); 1698 return ret; 1699 } 1700 1701 /* 1702 * See if chip needs to be configured. 1703 */ 1704 if (pnp) { 1705 if ((host->config != 0) && !wbsd_chip_validate(host)) { 1706 printk(KERN_WARNING DRIVER_NAME 1707 ": PnP active but chip not configured! " 1708 "You probably have a buggy BIOS. " 1709 "Configuring chip manually.\n"); 1710 wbsd_chip_config(host); 1711 } 1712 } else 1713 wbsd_chip_config(host); 1714 1715 /* 1716 * Power Management stuff. No idea how this works. 1717 * Not tested. 1718 */ 1719 #ifdef CONFIG_PM 1720 if (host->config) { 1721 wbsd_unlock_config(host); 1722 wbsd_write_config(host, WBSD_CONF_PME, 0xA0); 1723 wbsd_lock_config(host); 1724 } 1725 #endif 1726 /* 1727 * Allow device to initialise itself properly. 1728 */ 1729 mdelay(5); 1730 1731 /* 1732 * Reset the chip into a known state. 1733 */ 1734 wbsd_init_device(host); 1735 1736 mmc_add_host(mmc); 1737 1738 printk(KERN_INFO "%s: W83L51xD", mmc_hostname(mmc)); 1739 if (host->chip_id != 0) 1740 printk(" id %x", (int)host->chip_id); 1741 printk(" at 0x%x irq %d", (int)host->base, (int)host->irq); 1742 if (host->dma >= 0) 1743 printk(" dma %d", (int)host->dma); 1744 else 1745 printk(" FIFO"); 1746 if (pnp) 1747 printk(" PnP"); 1748 printk("\n"); 1749 1750 return 0; 1751 } 1752 1753 static void __devexit wbsd_shutdown(struct device *dev, int pnp) 1754 { 1755 struct mmc_host *mmc = dev_get_drvdata(dev); 1756 struct wbsd_host *host; 1757 1758 if (!mmc) 1759 return; 1760 1761 host = mmc_priv(mmc); 1762 1763 mmc_remove_host(mmc); 1764 1765 /* 1766 * Power down the SD/MMC function. 1767 */ 1768 if (!pnp) 1769 wbsd_chip_poweroff(host); 1770 1771 wbsd_release_resources(host); 1772 1773 wbsd_free_mmc(dev); 1774 } 1775 1776 /* 1777 * Non-PnP 1778 */ 1779 1780 static int __devinit wbsd_probe(struct platform_device *dev) 1781 { 1782 /* Use the module parameters for resources */ 1783 return wbsd_init(&dev->dev, io, irq, dma, 0); 1784 } 1785 1786 static int __devexit wbsd_remove(struct platform_device *dev) 1787 { 1788 wbsd_shutdown(&dev->dev, 0); 1789 1790 return 0; 1791 } 1792 1793 /* 1794 * PnP 1795 */ 1796 1797 #ifdef CONFIG_PNP 1798 1799 static int __devinit 1800 wbsd_pnp_probe(struct pnp_dev *pnpdev, const struct pnp_device_id *dev_id) 1801 { 1802 int io, irq, dma; 1803 1804 /* 1805 * Get resources from PnP layer. 1806 */ 1807 io = pnp_port_start(pnpdev, 0); 1808 irq = pnp_irq(pnpdev, 0); 1809 if (pnp_dma_valid(pnpdev, 0)) 1810 dma = pnp_dma(pnpdev, 0); 1811 else 1812 dma = -1; 1813 1814 DBGF("PnP resources: port %3x irq %d dma %d\n", io, irq, dma); 1815 1816 return wbsd_init(&pnpdev->dev, io, irq, dma, 1); 1817 } 1818 1819 static void __devexit wbsd_pnp_remove(struct pnp_dev *dev) 1820 { 1821 wbsd_shutdown(&dev->dev, 1); 1822 } 1823 1824 #endif /* CONFIG_PNP */ 1825 1826 /* 1827 * Power management 1828 */ 1829 1830 #ifdef CONFIG_PM 1831 1832 static int wbsd_suspend(struct wbsd_host *host, pm_message_t state) 1833 { 1834 BUG_ON(host == NULL); 1835 1836 return mmc_suspend_host(host->mmc, state); 1837 } 1838 1839 static int wbsd_resume(struct wbsd_host *host) 1840 { 1841 BUG_ON(host == NULL); 1842 1843 wbsd_init_device(host); 1844 1845 return mmc_resume_host(host->mmc); 1846 } 1847 1848 static int wbsd_platform_suspend(struct platform_device *dev, 1849 pm_message_t state) 1850 { 1851 struct mmc_host *mmc = platform_get_drvdata(dev); 1852 struct wbsd_host *host; 1853 int ret; 1854 1855 if (mmc == NULL) 1856 return 0; 1857 1858 DBGF("Suspending...\n"); 1859 1860 host = mmc_priv(mmc); 1861 1862 ret = wbsd_suspend(host, state); 1863 if (ret) 1864 return ret; 1865 1866 wbsd_chip_poweroff(host); 1867 1868 return 0; 1869 } 1870 1871 static int wbsd_platform_resume(struct platform_device *dev) 1872 { 1873 struct mmc_host *mmc = platform_get_drvdata(dev); 1874 struct wbsd_host *host; 1875 1876 if (mmc == NULL) 1877 return 0; 1878 1879 DBGF("Resuming...\n"); 1880 1881 host = mmc_priv(mmc); 1882 1883 wbsd_chip_config(host); 1884 1885 /* 1886 * Allow device to initialise itself properly. 1887 */ 1888 mdelay(5); 1889 1890 return wbsd_resume(host); 1891 } 1892 1893 #ifdef CONFIG_PNP 1894 1895 static int wbsd_pnp_suspend(struct pnp_dev *pnp_dev, pm_message_t state) 1896 { 1897 struct mmc_host *mmc = dev_get_drvdata(&pnp_dev->dev); 1898 struct wbsd_host *host; 1899 1900 if (mmc == NULL) 1901 return 0; 1902 1903 DBGF("Suspending...\n"); 1904 1905 host = mmc_priv(mmc); 1906 1907 return wbsd_suspend(host, state); 1908 } 1909 1910 static int wbsd_pnp_resume(struct pnp_dev *pnp_dev) 1911 { 1912 struct mmc_host *mmc = dev_get_drvdata(&pnp_dev->dev); 1913 struct wbsd_host *host; 1914 1915 if (mmc == NULL) 1916 return 0; 1917 1918 DBGF("Resuming...\n"); 1919 1920 host = mmc_priv(mmc); 1921 1922 /* 1923 * See if chip needs to be configured. 1924 */ 1925 if (host->config != 0) { 1926 if (!wbsd_chip_validate(host)) { 1927 printk(KERN_WARNING DRIVER_NAME 1928 ": PnP active but chip not configured! " 1929 "You probably have a buggy BIOS. " 1930 "Configuring chip manually.\n"); 1931 wbsd_chip_config(host); 1932 } 1933 } 1934 1935 /* 1936 * Allow device to initialise itself properly. 1937 */ 1938 mdelay(5); 1939 1940 return wbsd_resume(host); 1941 } 1942 1943 #endif /* CONFIG_PNP */ 1944 1945 #else /* CONFIG_PM */ 1946 1947 #define wbsd_platform_suspend NULL 1948 #define wbsd_platform_resume NULL 1949 1950 #define wbsd_pnp_suspend NULL 1951 #define wbsd_pnp_resume NULL 1952 1953 #endif /* CONFIG_PM */ 1954 1955 static struct platform_device *wbsd_device; 1956 1957 static struct platform_driver wbsd_driver = { 1958 .probe = wbsd_probe, 1959 .remove = __devexit_p(wbsd_remove), 1960 1961 .suspend = wbsd_platform_suspend, 1962 .resume = wbsd_platform_resume, 1963 .driver = { 1964 .name = DRIVER_NAME, 1965 }, 1966 }; 1967 1968 #ifdef CONFIG_PNP 1969 1970 static struct pnp_driver wbsd_pnp_driver = { 1971 .name = DRIVER_NAME, 1972 .id_table = pnp_dev_table, 1973 .probe = wbsd_pnp_probe, 1974 .remove = __devexit_p(wbsd_pnp_remove), 1975 1976 .suspend = wbsd_pnp_suspend, 1977 .resume = wbsd_pnp_resume, 1978 }; 1979 1980 #endif /* CONFIG_PNP */ 1981 1982 /* 1983 * Module loading/unloading 1984 */ 1985 1986 static int __init wbsd_drv_init(void) 1987 { 1988 int result; 1989 1990 printk(KERN_INFO DRIVER_NAME 1991 ": Winbond W83L51xD SD/MMC card interface driver\n"); 1992 printk(KERN_INFO DRIVER_NAME ": Copyright(c) Pierre Ossman\n"); 1993 1994 #ifdef CONFIG_PNP 1995 1996 if (!nopnp) { 1997 result = pnp_register_driver(&wbsd_pnp_driver); 1998 if (result < 0) 1999 return result; 2000 } 2001 #endif /* CONFIG_PNP */ 2002 2003 if (nopnp) { 2004 result = platform_driver_register(&wbsd_driver); 2005 if (result < 0) 2006 return result; 2007 2008 wbsd_device = platform_device_alloc(DRIVER_NAME, -1); 2009 if (!wbsd_device) { 2010 platform_driver_unregister(&wbsd_driver); 2011 return -ENOMEM; 2012 } 2013 2014 result = platform_device_add(wbsd_device); 2015 if (result) { 2016 platform_device_put(wbsd_device); 2017 platform_driver_unregister(&wbsd_driver); 2018 return result; 2019 } 2020 } 2021 2022 return 0; 2023 } 2024 2025 static void __exit wbsd_drv_exit(void) 2026 { 2027 #ifdef CONFIG_PNP 2028 2029 if (!nopnp) 2030 pnp_unregister_driver(&wbsd_pnp_driver); 2031 2032 #endif /* CONFIG_PNP */ 2033 2034 if (nopnp) { 2035 platform_device_unregister(wbsd_device); 2036 2037 platform_driver_unregister(&wbsd_driver); 2038 } 2039 2040 DBG("unloaded\n"); 2041 } 2042 2043 module_init(wbsd_drv_init); 2044 module_exit(wbsd_drv_exit); 2045 #ifdef CONFIG_PNP 2046 module_param(nopnp, uint, 0444); 2047 #endif 2048 module_param(io, uint, 0444); 2049 module_param(irq, uint, 0444); 2050 module_param(dma, int, 0444); 2051 2052 MODULE_LICENSE("GPL"); 2053 MODULE_AUTHOR("Pierre Ossman <drzeus@drzeus.cx>"); 2054 MODULE_DESCRIPTION("Winbond W83L51xD SD/MMC card interface driver"); 2055 2056 #ifdef CONFIG_PNP 2057 MODULE_PARM_DESC(nopnp, "Scan for device instead of relying on PNP. (default 0)"); 2058 #endif 2059 MODULE_PARM_DESC(io, "I/O base to allocate. Must be 8 byte aligned. (default 0x248)"); 2060 MODULE_PARM_DESC(irq, "IRQ to allocate. (default 6)"); 2061 MODULE_PARM_DESC(dma, "DMA channel to allocate. -1 for no DMA. (default 2)"); 2062