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