2 * linux/drivers/mmc/wbsd.c - Winbond W83L51xD SD/MMC driver
4 * Copyright (C) 2004-2005 Pierre Ossman, All Rights Reserved.
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.
13 * Changes to the FIFO system should be done with extreme care since
14 * the hardware is full of bugs related to the FIFO. Known issues are:
16 * - FIFO size field in FSR is always zero.
18 * - FIFO interrupts tend not to work as they should. Interrupts are
19 * triggered only for full/empty events, not for threshold values.
21 * - On APIC systems the FIFO empty interrupt is sometimes lost.
24 #include <linux/config.h>
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 #include <linux/mmc/protocol.h>
40 #include <asm/scatterlist.h>
44 #define DRIVER_NAME "wbsd"
45 #define DRIVER_VERSION "1.5"
48 pr_debug(DRIVER_NAME ": " x)
49 #define DBGF(f, x...) \
50 pr_debug(DRIVER_NAME " [%s()]: " f, __func__ , ##x)
58 static const struct pnp_device_id pnp_dev_table[] = {
64 MODULE_DEVICE_TABLE(pnp, pnp_dev_table);
66 #endif /* CONFIG_PNP */
68 static const int config_ports[] = { 0x2E, 0x4E };
69 static const int unlock_codes[] = { 0x83, 0x87 };
71 static const int valid_ids[] = {
76 static unsigned int nopnp = 0;
78 static const unsigned int nopnp = 1;
80 static unsigned int io = 0x248;
81 static unsigned int irq = 6;
88 static inline void wbsd_unlock_config(struct wbsd_host *host)
90 BUG_ON(host->config == 0);
92 outb(host->unlock_code, host->config);
93 outb(host->unlock_code, host->config);
96 static inline void wbsd_lock_config(struct wbsd_host *host)
98 BUG_ON(host->config == 0);
100 outb(LOCK_CODE, host->config);
103 static inline void wbsd_write_config(struct wbsd_host *host, u8 reg, u8 value)
105 BUG_ON(host->config == 0);
107 outb(reg, host->config);
108 outb(value, host->config + 1);
111 static inline u8 wbsd_read_config(struct wbsd_host *host, u8 reg)
113 BUG_ON(host->config == 0);
115 outb(reg, host->config);
116 return inb(host->config + 1);
119 static inline void wbsd_write_index(struct wbsd_host *host, u8 index, u8 value)
121 outb(index, host->base + WBSD_IDXR);
122 outb(value, host->base + WBSD_DATAR);
125 static inline u8 wbsd_read_index(struct wbsd_host *host, u8 index)
127 outb(index, host->base + WBSD_IDXR);
128 return inb(host->base + WBSD_DATAR);
135 static void wbsd_init_device(struct wbsd_host *host)
140 * Reset chip (SD/MMC part) and fifo.
142 setup = wbsd_read_index(host, WBSD_IDX_SETUP);
143 setup |= WBSD_FIFO_RESET | WBSD_SOFT_RESET;
144 wbsd_write_index(host, WBSD_IDX_SETUP, setup);
149 setup &= ~WBSD_DAT3_H;
150 wbsd_write_index(host, WBSD_IDX_SETUP, setup);
151 host->flags &= ~WBSD_FIGNORE_DETECT;
154 * Read back default clock.
156 host->clk = wbsd_read_index(host, WBSD_IDX_CLK);
161 outb(WBSD_POWER_N, host->base + WBSD_CSR);
164 * Set maximum timeout.
166 wbsd_write_index(host, WBSD_IDX_TAAC, 0x7F);
169 * Test for card presence
171 if (inb(host->base + WBSD_CSR) & WBSD_CARDPRESENT)
172 host->flags |= WBSD_FCARD_PRESENT;
174 host->flags &= ~WBSD_FCARD_PRESENT;
177 * Enable interesting interrupts.
180 ier |= WBSD_EINT_CARD;
181 ier |= WBSD_EINT_FIFO_THRE;
182 ier |= WBSD_EINT_CCRC;
183 ier |= WBSD_EINT_TIMEOUT;
184 ier |= WBSD_EINT_CRC;
187 outb(ier, host->base + WBSD_EIR);
192 inb(host->base + WBSD_ISR);
195 static void wbsd_reset(struct wbsd_host *host)
199 printk(KERN_ERR "%s: Resetting chip\n", mmc_hostname(host->mmc));
202 * Soft reset of chip (SD/MMC part).
204 setup = wbsd_read_index(host, WBSD_IDX_SETUP);
205 setup |= WBSD_SOFT_RESET;
206 wbsd_write_index(host, WBSD_IDX_SETUP, setup);
209 static void wbsd_request_end(struct wbsd_host *host, struct mmc_request *mrq)
211 unsigned long dmaflags;
213 DBGF("Ending request, cmd (%x)\n", mrq->cmd->opcode);
215 if (host->dma >= 0) {
217 * Release ISA DMA controller.
219 dmaflags = claim_dma_lock();
220 disable_dma(host->dma);
221 clear_dma_ff(host->dma);
222 release_dma_lock(dmaflags);
225 * Disable DMA on host.
227 wbsd_write_index(host, WBSD_IDX_DMA, 0);
233 * MMC layer might call back into the driver so first unlock.
235 spin_unlock(&host->lock);
236 mmc_request_done(host->mmc, mrq);
237 spin_lock(&host->lock);
241 * Scatter/gather functions
244 static inline void wbsd_init_sg(struct wbsd_host *host, struct mmc_data *data)
247 * Get info. about SG list from data structure.
249 host->cur_sg = data->sg;
250 host->num_sg = data->sg_len;
253 host->remain = host->cur_sg->length;
256 static inline int wbsd_next_sg(struct wbsd_host *host)
259 * Skip to next SG entry.
267 if (host->num_sg > 0) {
269 host->remain = host->cur_sg->length;
275 static inline char *wbsd_kmap_sg(struct wbsd_host *host)
277 host->mapped_sg = kmap_atomic(host->cur_sg->page, KM_BIO_SRC_IRQ) +
278 host->cur_sg->offset;
279 return host->mapped_sg;
282 static inline void wbsd_kunmap_sg(struct wbsd_host *host)
284 kunmap_atomic(host->mapped_sg, KM_BIO_SRC_IRQ);
287 static inline void wbsd_sg_to_dma(struct wbsd_host *host, struct mmc_data *data)
289 unsigned int len, i, size;
290 struct scatterlist *sg;
291 char *dmabuf = host->dma_buffer;
300 * Just loop through all entries. Size might not
301 * be the entire list though so make sure that
302 * we do not transfer too much.
304 for (i = 0; i < len; i++) {
305 sgbuf = kmap_atomic(sg[i].page, KM_BIO_SRC_IRQ) + sg[i].offset;
306 if (size < sg[i].length)
307 memcpy(dmabuf, sgbuf, size);
309 memcpy(dmabuf, sgbuf, sg[i].length);
310 kunmap_atomic(sgbuf, KM_BIO_SRC_IRQ);
311 dmabuf += sg[i].length;
313 if (size < sg[i].length)
316 size -= sg[i].length;
323 * Check that we didn't get a request to transfer
324 * more data than can fit into the SG list.
332 static inline void wbsd_dma_to_sg(struct wbsd_host *host, struct mmc_data *data)
334 unsigned int len, i, size;
335 struct scatterlist *sg;
336 char *dmabuf = host->dma_buffer;
345 * Just loop through all entries. Size might not
346 * be the entire list though so make sure that
347 * we do not transfer too much.
349 for (i = 0; i < len; i++) {
350 sgbuf = kmap_atomic(sg[i].page, KM_BIO_SRC_IRQ) + sg[i].offset;
351 if (size < sg[i].length)
352 memcpy(sgbuf, dmabuf, size);
354 memcpy(sgbuf, dmabuf, sg[i].length);
355 kunmap_atomic(sgbuf, KM_BIO_SRC_IRQ);
356 dmabuf += sg[i].length;
358 if (size < sg[i].length)
361 size -= sg[i].length;
368 * Check that we didn't get a request to transfer
369 * more data than can fit into the SG list.
381 static inline void wbsd_get_short_reply(struct wbsd_host *host,
382 struct mmc_command *cmd)
385 * Correct response type?
387 if (wbsd_read_index(host, WBSD_IDX_RSPLEN) != WBSD_RSP_SHORT) {
388 cmd->error = MMC_ERR_INVALID;
392 cmd->resp[0] = wbsd_read_index(host, WBSD_IDX_RESP12) << 24;
393 cmd->resp[0] |= wbsd_read_index(host, WBSD_IDX_RESP13) << 16;
394 cmd->resp[0] |= wbsd_read_index(host, WBSD_IDX_RESP14) << 8;
395 cmd->resp[0] |= wbsd_read_index(host, WBSD_IDX_RESP15) << 0;
396 cmd->resp[1] = wbsd_read_index(host, WBSD_IDX_RESP16) << 24;
399 static inline void wbsd_get_long_reply(struct wbsd_host *host,
400 struct mmc_command *cmd)
405 * Correct response type?
407 if (wbsd_read_index(host, WBSD_IDX_RSPLEN) != WBSD_RSP_LONG) {
408 cmd->error = MMC_ERR_INVALID;
412 for (i = 0; i < 4; i++) {
414 wbsd_read_index(host, WBSD_IDX_RESP1 + i * 4) << 24;
416 wbsd_read_index(host, WBSD_IDX_RESP2 + i * 4) << 16;
418 wbsd_read_index(host, WBSD_IDX_RESP3 + i * 4) << 8;
420 wbsd_read_index(host, WBSD_IDX_RESP4 + i * 4) << 0;
424 static void wbsd_send_command(struct wbsd_host *host, struct mmc_command *cmd)
429 DBGF("Sending cmd (%x)\n", cmd->opcode);
432 * Clear accumulated ISR. The interrupt routine
433 * will fill this one with events that occur during
439 * Send the command (CRC calculated by host).
441 outb(cmd->opcode, host->base + WBSD_CMDR);
442 for (i = 3; i >= 0; i--)
443 outb((cmd->arg >> (i * 8)) & 0xff, host->base + WBSD_CMDR);
445 cmd->error = MMC_ERR_NONE;
448 * Wait for the request to complete.
451 status = wbsd_read_index(host, WBSD_IDX_STATUS);
452 } while (status & WBSD_CARDTRAFFIC);
455 * Do we expect a reply?
457 if (cmd->flags & MMC_RSP_PRESENT) {
464 if (isr & WBSD_INT_CARD)
465 cmd->error = MMC_ERR_TIMEOUT;
467 else if (isr & WBSD_INT_TIMEOUT)
468 cmd->error = MMC_ERR_TIMEOUT;
470 else if ((cmd->flags & MMC_RSP_CRC) && (isr & WBSD_INT_CRC))
471 cmd->error = MMC_ERR_BADCRC;
474 if (cmd->flags & MMC_RSP_136)
475 wbsd_get_long_reply(host, cmd);
477 wbsd_get_short_reply(host, cmd);
481 DBGF("Sent cmd (%x), res %d\n", cmd->opcode, cmd->error);
488 static void wbsd_empty_fifo(struct wbsd_host *host)
490 struct mmc_data *data = host->mrq->cmd->data;
495 * Handle excessive data.
497 if (data->bytes_xfered == host->size)
500 buffer = wbsd_kmap_sg(host) + host->offset;
503 * Drain the fifo. This has a tendency to loop longer
504 * than the FIFO length (usually one block).
506 while (!((fsr = inb(host->base + WBSD_FSR)) & WBSD_FIFO_EMPTY)) {
508 * The size field in the FSR is broken so we have to
511 if (fsr & WBSD_FIFO_FULL)
513 else if (fsr & WBSD_FIFO_FUTHRE)
518 for (i = 0; i < fifo; i++) {
519 *buffer = inb(host->base + WBSD_DFR);
524 data->bytes_xfered++;
529 if (data->bytes_xfered == host->size) {
530 wbsd_kunmap_sg(host);
535 * End of scatter list entry?
537 if (host->remain == 0) {
538 wbsd_kunmap_sg(host);
541 * Get next entry. Check if last.
543 if (!wbsd_next_sg(host)) {
545 * We should never reach this point.
546 * It means that we're trying to
547 * transfer more blocks than can fit
548 * into the scatter list.
552 host->size = data->bytes_xfered;
557 buffer = wbsd_kmap_sg(host);
562 wbsd_kunmap_sg(host);
565 * This is a very dirty hack to solve a
566 * hardware problem. The chip doesn't trigger
567 * FIFO threshold interrupts properly.
569 if ((host->size - data->bytes_xfered) < 16)
570 tasklet_schedule(&host->fifo_tasklet);
573 static void wbsd_fill_fifo(struct wbsd_host *host)
575 struct mmc_data *data = host->mrq->cmd->data;
580 * Check that we aren't being called after the
581 * entire buffer has been transfered.
583 if (data->bytes_xfered == host->size)
586 buffer = wbsd_kmap_sg(host) + host->offset;
589 * Fill the fifo. This has a tendency to loop longer
590 * than the FIFO length (usually one block).
592 while (!((fsr = inb(host->base + WBSD_FSR)) & WBSD_FIFO_FULL)) {
594 * The size field in the FSR is broken so we have to
597 if (fsr & WBSD_FIFO_EMPTY)
599 else if (fsr & WBSD_FIFO_EMTHRE)
604 for (i = 16; i > fifo; i--) {
605 outb(*buffer, host->base + WBSD_DFR);
610 data->bytes_xfered++;
615 if (data->bytes_xfered == host->size) {
616 wbsd_kunmap_sg(host);
621 * End of scatter list entry?
623 if (host->remain == 0) {
624 wbsd_kunmap_sg(host);
627 * Get next entry. Check if last.
629 if (!wbsd_next_sg(host)) {
631 * We should never reach this point.
632 * It means that we're trying to
633 * transfer more blocks than can fit
634 * into the scatter list.
638 host->size = data->bytes_xfered;
643 buffer = wbsd_kmap_sg(host);
648 wbsd_kunmap_sg(host);
651 * The controller stops sending interrupts for
652 * 'FIFO empty' under certain conditions. So we
653 * need to be a bit more pro-active.
655 tasklet_schedule(&host->fifo_tasklet);
658 static void wbsd_prepare_data(struct wbsd_host *host, struct mmc_data *data)
662 unsigned long dmaflags;
664 DBGF("blksz %04x blks %04x flags %08x\n",
665 1 << data->blksz_bits, data->blocks, data->flags);
666 DBGF("tsac %d ms nsac %d clk\n",
667 data->timeout_ns / 1000000, data->timeout_clks);
672 host->size = data->blocks << data->blksz_bits;
675 * Check timeout values for overflow.
676 * (Yes, some cards cause this value to overflow).
678 if (data->timeout_ns > 127000000)
679 wbsd_write_index(host, WBSD_IDX_TAAC, 127);
681 wbsd_write_index(host, WBSD_IDX_TAAC,
682 data->timeout_ns / 1000000);
685 if (data->timeout_clks > 255)
686 wbsd_write_index(host, WBSD_IDX_NSAC, 255);
688 wbsd_write_index(host, WBSD_IDX_NSAC, data->timeout_clks);
691 * Inform the chip of how large blocks will be
692 * sent. It needs this to determine when to
695 * Space for CRC must be included in the size.
696 * Two bytes are needed for each data line.
698 if (host->bus_width == MMC_BUS_WIDTH_1) {
699 blksize = (1 << data->blksz_bits) + 2;
701 wbsd_write_index(host, WBSD_IDX_PBSMSB, (blksize >> 4) & 0xF0);
702 wbsd_write_index(host, WBSD_IDX_PBSLSB, blksize & 0xFF);
703 } else if (host->bus_width == MMC_BUS_WIDTH_4) {
704 blksize = (1 << data->blksz_bits) + 2 * 4;
706 wbsd_write_index(host, WBSD_IDX_PBSMSB,
707 ((blksize >> 4) & 0xF0) | WBSD_DATA_WIDTH);
708 wbsd_write_index(host, WBSD_IDX_PBSLSB, blksize & 0xFF);
710 data->error = MMC_ERR_INVALID;
715 * Clear the FIFO. This is needed even for DMA
716 * transfers since the chip still uses the FIFO
719 setup = wbsd_read_index(host, WBSD_IDX_SETUP);
720 setup |= WBSD_FIFO_RESET;
721 wbsd_write_index(host, WBSD_IDX_SETUP, setup);
726 if (host->dma >= 0) {
728 * The buffer for DMA is only 64 kB.
730 BUG_ON(host->size > 0x10000);
731 if (host->size > 0x10000) {
732 data->error = MMC_ERR_INVALID;
737 * Transfer data from the SG list to
740 if (data->flags & MMC_DATA_WRITE)
741 wbsd_sg_to_dma(host, data);
744 * Initialise the ISA DMA controller.
746 dmaflags = claim_dma_lock();
747 disable_dma(host->dma);
748 clear_dma_ff(host->dma);
749 if (data->flags & MMC_DATA_READ)
750 set_dma_mode(host->dma, DMA_MODE_READ & ~0x40);
752 set_dma_mode(host->dma, DMA_MODE_WRITE & ~0x40);
753 set_dma_addr(host->dma, host->dma_addr);
754 set_dma_count(host->dma, host->size);
756 enable_dma(host->dma);
757 release_dma_lock(dmaflags);
760 * Enable DMA on the host.
762 wbsd_write_index(host, WBSD_IDX_DMA, WBSD_DMA_ENABLE);
765 * This flag is used to keep printk
766 * output to a minimum.
771 * Initialise the SG list.
773 wbsd_init_sg(host, data);
778 wbsd_write_index(host, WBSD_IDX_DMA, 0);
781 * Set up FIFO threshold levels (and fill
782 * buffer if doing a write).
784 if (data->flags & MMC_DATA_READ) {
785 wbsd_write_index(host, WBSD_IDX_FIFOEN,
786 WBSD_FIFOEN_FULL | 8);
788 wbsd_write_index(host, WBSD_IDX_FIFOEN,
789 WBSD_FIFOEN_EMPTY | 8);
790 wbsd_fill_fifo(host);
794 data->error = MMC_ERR_NONE;
797 static void wbsd_finish_data(struct wbsd_host *host, struct mmc_data *data)
799 unsigned long dmaflags;
803 WARN_ON(host->mrq == NULL);
806 * Send a stop command if needed.
809 wbsd_send_command(host, data->stop);
812 * Wait for the controller to leave data
816 status = wbsd_read_index(host, WBSD_IDX_STATUS);
817 } while (status & (WBSD_BLOCK_READ | WBSD_BLOCK_WRITE));
822 if (host->dma >= 0) {
824 * Disable DMA on the host.
826 wbsd_write_index(host, WBSD_IDX_DMA, 0);
829 * Turn of ISA DMA controller.
831 dmaflags = claim_dma_lock();
832 disable_dma(host->dma);
833 clear_dma_ff(host->dma);
834 count = get_dma_residue(host->dma);
835 release_dma_lock(dmaflags);
841 printk(KERN_ERR "%s: Incomplete DMA transfer. "
843 mmc_hostname(host->mmc), count);
845 data->error = MMC_ERR_FAILED;
848 * Transfer data from DMA buffer to
851 if (data->flags & MMC_DATA_READ)
852 wbsd_dma_to_sg(host, data);
854 data->bytes_xfered = host->size;
858 DBGF("Ending data transfer (%d bytes)\n", data->bytes_xfered);
860 wbsd_request_end(host, host->mrq);
863 /*****************************************************************************\
865 * MMC layer callbacks *
867 \*****************************************************************************/
869 static void wbsd_request(struct mmc_host *mmc, struct mmc_request *mrq)
871 struct wbsd_host *host = mmc_priv(mmc);
872 struct mmc_command *cmd;
875 * Disable tasklets to avoid a deadlock.
877 spin_lock_bh(&host->lock);
879 BUG_ON(host->mrq != NULL);
886 * If there is no card in the slot then
887 * timeout immediatly.
889 if (!(host->flags & WBSD_FCARD_PRESENT)) {
890 cmd->error = MMC_ERR_TIMEOUT;
895 * Does the request include data?
898 wbsd_prepare_data(host, cmd->data);
900 if (cmd->data->error != MMC_ERR_NONE)
904 wbsd_send_command(host, cmd);
907 * If this is a data transfer the request
908 * will be finished after the data has
911 if (cmd->data && (cmd->error == MMC_ERR_NONE)) {
913 * Dirty fix for hardware bug.
916 tasklet_schedule(&host->fifo_tasklet);
918 spin_unlock_bh(&host->lock);
924 wbsd_request_end(host, mrq);
926 spin_unlock_bh(&host->lock);
929 static void wbsd_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
931 struct wbsd_host *host = mmc_priv(mmc);
934 DBGF("clock %uHz busmode %u powermode %u cs %u Vdd %u width %u\n",
935 ios->clock, ios->bus_mode, ios->power_mode, ios->chip_select,
936 ios->vdd, ios->bus_width);
938 spin_lock_bh(&host->lock);
941 * Reset the chip on each power off.
942 * Should clear out any weird states.
944 if (ios->power_mode == MMC_POWER_OFF)
945 wbsd_init_device(host);
947 if (ios->clock >= 24000000)
949 else if (ios->clock >= 16000000)
951 else if (ios->clock >= 12000000)
957 * Only write to the clock register when
958 * there is an actual change.
960 if (clk != host->clk) {
961 wbsd_write_index(host, WBSD_IDX_CLK, clk);
968 if (ios->power_mode != MMC_POWER_OFF) {
969 pwr = inb(host->base + WBSD_CSR);
970 pwr &= ~WBSD_POWER_N;
971 outb(pwr, host->base + WBSD_CSR);
975 * MMC cards need to have pin 1 high during init.
976 * It wreaks havoc with the card detection though so
977 * that needs to be disabled.
979 setup = wbsd_read_index(host, WBSD_IDX_SETUP);
980 if (ios->chip_select == MMC_CS_HIGH) {
981 BUG_ON(ios->bus_width != MMC_BUS_WIDTH_1);
982 setup |= WBSD_DAT3_H;
983 host->flags |= WBSD_FIGNORE_DETECT;
985 if (setup & WBSD_DAT3_H) {
986 setup &= ~WBSD_DAT3_H;
989 * We cannot resume card detection immediatly
990 * because of capacitance and delays in the chip.
992 mod_timer(&host->ignore_timer, jiffies + HZ / 100);
995 wbsd_write_index(host, WBSD_IDX_SETUP, setup);
998 * Store bus width for later. Will be used when
999 * setting up the data transfer.
1001 host->bus_width = ios->bus_width;
1003 spin_unlock_bh(&host->lock);
1006 static int wbsd_get_ro(struct mmc_host *mmc)
1008 struct wbsd_host *host = mmc_priv(mmc);
1011 spin_lock_bh(&host->lock);
1013 csr = inb(host->base + WBSD_CSR);
1015 outb(csr, host->base + WBSD_CSR);
1019 csr = inb(host->base + WBSD_CSR);
1021 outb(csr, host->base + WBSD_CSR);
1023 spin_unlock_bh(&host->lock);
1025 return csr & WBSD_WRPT;
1028 static struct mmc_host_ops wbsd_ops = {
1029 .request = wbsd_request,
1030 .set_ios = wbsd_set_ios,
1031 .get_ro = wbsd_get_ro,
1034 /*****************************************************************************\
1036 * Interrupt handling *
1038 \*****************************************************************************/
1041 * Helper function to reset detection ignore
1044 static void wbsd_reset_ignore(unsigned long data)
1046 struct wbsd_host *host = (struct wbsd_host *)data;
1048 BUG_ON(host == NULL);
1050 DBG("Resetting card detection ignore\n");
1052 spin_lock_bh(&host->lock);
1054 host->flags &= ~WBSD_FIGNORE_DETECT;
1057 * Card status might have changed during the
1060 tasklet_schedule(&host->card_tasklet);
1062 spin_unlock_bh(&host->lock);
1069 static inline struct mmc_data *wbsd_get_data(struct wbsd_host *host)
1071 WARN_ON(!host->mrq);
1075 WARN_ON(!host->mrq->cmd);
1076 if (!host->mrq->cmd)
1079 WARN_ON(!host->mrq->cmd->data);
1080 if (!host->mrq->cmd->data)
1083 return host->mrq->cmd->data;
1086 static void wbsd_tasklet_card(unsigned long param)
1088 struct wbsd_host *host = (struct wbsd_host *)param;
1092 spin_lock(&host->lock);
1094 if (host->flags & WBSD_FIGNORE_DETECT) {
1095 spin_unlock(&host->lock);
1099 csr = inb(host->base + WBSD_CSR);
1100 WARN_ON(csr == 0xff);
1102 if (csr & WBSD_CARDPRESENT) {
1103 if (!(host->flags & WBSD_FCARD_PRESENT)) {
1104 DBG("Card inserted\n");
1105 host->flags |= WBSD_FCARD_PRESENT;
1109 } else if (host->flags & WBSD_FCARD_PRESENT) {
1110 DBG("Card removed\n");
1111 host->flags &= ~WBSD_FCARD_PRESENT;
1114 printk(KERN_ERR "%s: Card removed during transfer!\n",
1115 mmc_hostname(host->mmc));
1118 host->mrq->cmd->error = MMC_ERR_FAILED;
1119 tasklet_schedule(&host->finish_tasklet);
1126 * Unlock first since we might get a call back.
1129 spin_unlock(&host->lock);
1132 mmc_detect_change(host->mmc, msecs_to_jiffies(delay));
1135 static void wbsd_tasklet_fifo(unsigned long param)
1137 struct wbsd_host *host = (struct wbsd_host *)param;
1138 struct mmc_data *data;
1140 spin_lock(&host->lock);
1145 data = wbsd_get_data(host);
1149 if (data->flags & MMC_DATA_WRITE)
1150 wbsd_fill_fifo(host);
1152 wbsd_empty_fifo(host);
1157 if (host->size == data->bytes_xfered) {
1158 wbsd_write_index(host, WBSD_IDX_FIFOEN, 0);
1159 tasklet_schedule(&host->finish_tasklet);
1163 spin_unlock(&host->lock);
1166 static void wbsd_tasklet_crc(unsigned long param)
1168 struct wbsd_host *host = (struct wbsd_host *)param;
1169 struct mmc_data *data;
1171 spin_lock(&host->lock);
1176 data = wbsd_get_data(host);
1180 DBGF("CRC error\n");
1182 data->error = MMC_ERR_BADCRC;
1184 tasklet_schedule(&host->finish_tasklet);
1187 spin_unlock(&host->lock);
1190 static void wbsd_tasklet_timeout(unsigned long param)
1192 struct wbsd_host *host = (struct wbsd_host *)param;
1193 struct mmc_data *data;
1195 spin_lock(&host->lock);
1200 data = wbsd_get_data(host);
1206 data->error = MMC_ERR_TIMEOUT;
1208 tasklet_schedule(&host->finish_tasklet);
1211 spin_unlock(&host->lock);
1214 static void wbsd_tasklet_finish(unsigned long param)
1216 struct wbsd_host *host = (struct wbsd_host *)param;
1217 struct mmc_data *data;
1219 spin_lock(&host->lock);
1221 WARN_ON(!host->mrq);
1225 data = wbsd_get_data(host);
1229 wbsd_finish_data(host, data);
1232 spin_unlock(&host->lock);
1235 static void wbsd_tasklet_block(unsigned long param)
1237 struct wbsd_host *host = (struct wbsd_host *)param;
1238 struct mmc_data *data;
1240 spin_lock(&host->lock);
1242 if ((wbsd_read_index(host, WBSD_IDX_CRCSTATUS) & WBSD_CRC_MASK) !=
1244 data = wbsd_get_data(host);
1248 DBGF("CRC error\n");
1250 data->error = MMC_ERR_BADCRC;
1252 tasklet_schedule(&host->finish_tasklet);
1256 spin_unlock(&host->lock);
1260 * Interrupt handling
1263 static irqreturn_t wbsd_irq(int irq, void *dev_id, struct pt_regs *regs)
1265 struct wbsd_host *host = dev_id;
1268 isr = inb(host->base + WBSD_ISR);
1271 * Was it actually our hardware that caused the interrupt?
1273 if (isr == 0xff || isr == 0x00)
1279 * Schedule tasklets as needed.
1281 if (isr & WBSD_INT_CARD)
1282 tasklet_schedule(&host->card_tasklet);
1283 if (isr & WBSD_INT_FIFO_THRE)
1284 tasklet_schedule(&host->fifo_tasklet);
1285 if (isr & WBSD_INT_CRC)
1286 tasklet_hi_schedule(&host->crc_tasklet);
1287 if (isr & WBSD_INT_TIMEOUT)
1288 tasklet_hi_schedule(&host->timeout_tasklet);
1289 if (isr & WBSD_INT_BUSYEND)
1290 tasklet_hi_schedule(&host->block_tasklet);
1291 if (isr & WBSD_INT_TC)
1292 tasklet_schedule(&host->finish_tasklet);
1297 /*****************************************************************************\
1299 * Device initialisation and shutdown *
1301 \*****************************************************************************/
1304 * Allocate/free MMC structure.
1307 static int __devinit wbsd_alloc_mmc(struct device *dev)
1309 struct mmc_host *mmc;
1310 struct wbsd_host *host;
1313 * Allocate MMC structure.
1315 mmc = mmc_alloc_host(sizeof(struct wbsd_host), dev);
1319 host = mmc_priv(mmc);
1325 * Set host parameters.
1327 mmc->ops = &wbsd_ops;
1328 mmc->f_min = 375000;
1329 mmc->f_max = 24000000;
1330 mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
1331 mmc->caps = MMC_CAP_4_BIT_DATA;
1333 spin_lock_init(&host->lock);
1338 init_timer(&host->ignore_timer);
1339 host->ignore_timer.data = (unsigned long)host;
1340 host->ignore_timer.function = wbsd_reset_ignore;
1343 * Maximum number of segments. Worst case is one sector per segment
1344 * so this will be 64kB/512.
1346 mmc->max_hw_segs = 128;
1347 mmc->max_phys_segs = 128;
1350 * Maximum number of sectors in one transfer. Also limited by 64kB
1353 mmc->max_sectors = 128;
1356 * Maximum segment size. Could be one segment with the maximum number
1359 mmc->max_seg_size = mmc->max_sectors * 512;
1361 dev_set_drvdata(dev, mmc);
1366 static void __devexit wbsd_free_mmc(struct device *dev)
1368 struct mmc_host *mmc;
1369 struct wbsd_host *host;
1371 mmc = dev_get_drvdata(dev);
1375 host = mmc_priv(mmc);
1376 BUG_ON(host == NULL);
1378 del_timer_sync(&host->ignore_timer);
1382 dev_set_drvdata(dev, NULL);
1386 * Scan for known chip id:s
1389 static int __devinit wbsd_scan(struct wbsd_host *host)
1395 * Iterate through all ports, all codes to
1396 * find hardware that is in our known list.
1398 for (i = 0; i < ARRAY_SIZE(config_ports); i++) {
1399 if (!request_region(config_ports[i], 2, DRIVER_NAME))
1402 for (j = 0; j < ARRAY_SIZE(unlock_codes); j++) {
1405 host->config = config_ports[i];
1406 host->unlock_code = unlock_codes[j];
1408 wbsd_unlock_config(host);
1410 outb(WBSD_CONF_ID_HI, config_ports[i]);
1411 id = inb(config_ports[i] + 1) << 8;
1413 outb(WBSD_CONF_ID_LO, config_ports[i]);
1414 id |= inb(config_ports[i] + 1);
1416 wbsd_lock_config(host);
1418 for (k = 0; k < ARRAY_SIZE(valid_ids); k++) {
1419 if (id == valid_ids[k]) {
1427 DBG("Unknown hardware (id %x) found at %x\n",
1428 id, config_ports[i]);
1432 release_region(config_ports[i], 2);
1436 host->unlock_code = 0;
1442 * Allocate/free io port ranges
1445 static int __devinit wbsd_request_region(struct wbsd_host *host, int base)
1450 if (!request_region(base, 8, DRIVER_NAME))
1458 static void __devexit wbsd_release_regions(struct wbsd_host *host)
1461 release_region(host->base, 8);
1466 release_region(host->config, 2);
1472 * Allocate/free DMA port and buffer
1475 static void __devinit wbsd_request_dma(struct wbsd_host *host, int dma)
1480 if (request_dma(dma, DRIVER_NAME))
1484 * We need to allocate a special buffer in
1485 * order for ISA to be able to DMA to it.
1487 host->dma_buffer = kmalloc(WBSD_DMA_SIZE,
1488 GFP_NOIO | GFP_DMA | __GFP_REPEAT | __GFP_NOWARN);
1489 if (!host->dma_buffer)
1493 * Translate the address to a physical address.
1495 host->dma_addr = dma_map_single(host->mmc->dev, host->dma_buffer,
1496 WBSD_DMA_SIZE, DMA_BIDIRECTIONAL);
1499 * ISA DMA must be aligned on a 64k basis.
1501 if ((host->dma_addr & 0xffff) != 0)
1504 * ISA cannot access memory above 16 MB.
1506 else if (host->dma_addr >= 0x1000000)
1515 * If we've gotten here then there is some kind of alignment bug
1519 dma_unmap_single(host->mmc->dev, host->dma_addr,
1520 WBSD_DMA_SIZE, DMA_BIDIRECTIONAL);
1521 host->dma_addr = (dma_addr_t)NULL;
1523 kfree(host->dma_buffer);
1524 host->dma_buffer = NULL;
1530 printk(KERN_WARNING DRIVER_NAME ": Unable to allocate DMA %d. "
1531 "Falling back on FIFO.\n", dma);
1534 static void __devexit wbsd_release_dma(struct wbsd_host *host)
1536 if (host->dma_addr) {
1537 dma_unmap_single(host->mmc->dev, host->dma_addr,
1538 WBSD_DMA_SIZE, DMA_BIDIRECTIONAL);
1540 kfree(host->dma_buffer);
1542 free_dma(host->dma);
1545 host->dma_buffer = NULL;
1546 host->dma_addr = (dma_addr_t)NULL;
1550 * Allocate/free IRQ.
1553 static int __devinit wbsd_request_irq(struct wbsd_host *host, int irq)
1558 * Allocate interrupt.
1561 ret = request_irq(irq, wbsd_irq, SA_SHIRQ, DRIVER_NAME, host);
1570 tasklet_init(&host->card_tasklet, wbsd_tasklet_card,
1571 (unsigned long)host);
1572 tasklet_init(&host->fifo_tasklet, wbsd_tasklet_fifo,
1573 (unsigned long)host);
1574 tasklet_init(&host->crc_tasklet, wbsd_tasklet_crc,
1575 (unsigned long)host);
1576 tasklet_init(&host->timeout_tasklet, wbsd_tasklet_timeout,
1577 (unsigned long)host);
1578 tasklet_init(&host->finish_tasklet, wbsd_tasklet_finish,
1579 (unsigned long)host);
1580 tasklet_init(&host->block_tasklet, wbsd_tasklet_block,
1581 (unsigned long)host);
1586 static void __devexit wbsd_release_irq(struct wbsd_host *host)
1591 free_irq(host->irq, host);
1595 tasklet_kill(&host->card_tasklet);
1596 tasklet_kill(&host->fifo_tasklet);
1597 tasklet_kill(&host->crc_tasklet);
1598 tasklet_kill(&host->timeout_tasklet);
1599 tasklet_kill(&host->finish_tasklet);
1600 tasklet_kill(&host->block_tasklet);
1604 * Allocate all resources for the host.
1607 static int __devinit wbsd_request_resources(struct wbsd_host *host,
1608 int base, int irq, int dma)
1613 * Allocate I/O ports.
1615 ret = wbsd_request_region(host, base);
1620 * Allocate interrupt.
1622 ret = wbsd_request_irq(host, irq);
1629 wbsd_request_dma(host, dma);
1635 * Release all resources for the host.
1638 static void __devexit wbsd_release_resources(struct wbsd_host *host)
1640 wbsd_release_dma(host);
1641 wbsd_release_irq(host);
1642 wbsd_release_regions(host);
1646 * Configure the resources the chip should use.
1649 static void wbsd_chip_config(struct wbsd_host *host)
1651 wbsd_unlock_config(host);
1656 wbsd_write_config(host, WBSD_CONF_SWRST, 1);
1657 wbsd_write_config(host, WBSD_CONF_SWRST, 0);
1660 * Select SD/MMC function.
1662 wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
1665 * Set up card detection.
1667 wbsd_write_config(host, WBSD_CONF_PINS, WBSD_PINS_DETECT_GP11);
1672 wbsd_write_config(host, WBSD_CONF_PORT_HI, host->base >> 8);
1673 wbsd_write_config(host, WBSD_CONF_PORT_LO, host->base & 0xff);
1675 wbsd_write_config(host, WBSD_CONF_IRQ, host->irq);
1678 wbsd_write_config(host, WBSD_CONF_DRQ, host->dma);
1681 * Enable and power up chip.
1683 wbsd_write_config(host, WBSD_CONF_ENABLE, 1);
1684 wbsd_write_config(host, WBSD_CONF_POWER, 0x20);
1686 wbsd_lock_config(host);
1690 * Check that configured resources are correct.
1693 static int wbsd_chip_validate(struct wbsd_host *host)
1697 wbsd_unlock_config(host);
1700 * Select SD/MMC function.
1702 wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
1705 * Read configuration.
1707 base = wbsd_read_config(host, WBSD_CONF_PORT_HI) << 8;
1708 base |= wbsd_read_config(host, WBSD_CONF_PORT_LO);
1710 irq = wbsd_read_config(host, WBSD_CONF_IRQ);
1712 dma = wbsd_read_config(host, WBSD_CONF_DRQ);
1714 wbsd_lock_config(host);
1717 * Validate against given configuration.
1719 if (base != host->base)
1721 if (irq != host->irq)
1723 if ((dma != host->dma) && (host->dma != -1))
1730 * Powers down the SD function
1733 static void wbsd_chip_poweroff(struct wbsd_host *host)
1735 wbsd_unlock_config(host);
1737 wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
1738 wbsd_write_config(host, WBSD_CONF_ENABLE, 0);
1740 wbsd_lock_config(host);
1743 /*****************************************************************************\
1745 * Devices setup and shutdown *
1747 \*****************************************************************************/
1749 static int __devinit wbsd_init(struct device *dev, int base, int irq, int dma,
1752 struct wbsd_host *host = NULL;
1753 struct mmc_host *mmc = NULL;
1756 ret = wbsd_alloc_mmc(dev);
1760 mmc = dev_get_drvdata(dev);
1761 host = mmc_priv(mmc);
1764 * Scan for hardware.
1766 ret = wbsd_scan(host);
1768 if (pnp && (ret == -ENODEV)) {
1769 printk(KERN_WARNING DRIVER_NAME
1770 ": Unable to confirm device presence. You may "
1771 "experience lock-ups.\n");
1779 * Request resources.
1781 ret = wbsd_request_resources(host, io, irq, dma);
1783 wbsd_release_resources(host);
1789 * See if chip needs to be configured.
1792 if ((host->config != 0) && !wbsd_chip_validate(host)) {
1793 printk(KERN_WARNING DRIVER_NAME
1794 ": PnP active but chip not configured! "
1795 "You probably have a buggy BIOS. "
1796 "Configuring chip manually.\n");
1797 wbsd_chip_config(host);
1800 wbsd_chip_config(host);
1803 * Power Management stuff. No idea how this works.
1808 wbsd_unlock_config(host);
1809 wbsd_write_config(host, WBSD_CONF_PME, 0xA0);
1810 wbsd_lock_config(host);
1814 * Allow device to initialise itself properly.
1819 * Reset the chip into a known state.
1821 wbsd_init_device(host);
1825 printk(KERN_INFO "%s: W83L51xD", mmc_hostname(mmc));
1826 if (host->chip_id != 0)
1827 printk(" id %x", (int)host->chip_id);
1828 printk(" at 0x%x irq %d", (int)host->base, (int)host->irq);
1830 printk(" dma %d", (int)host->dma);
1840 static void __devexit wbsd_shutdown(struct device *dev, int pnp)
1842 struct mmc_host *mmc = dev_get_drvdata(dev);
1843 struct wbsd_host *host;
1848 host = mmc_priv(mmc);
1850 mmc_remove_host(mmc);
1853 * Power down the SD/MMC function.
1856 wbsd_chip_poweroff(host);
1858 wbsd_release_resources(host);
1867 static int __devinit wbsd_probe(struct platform_device *dev)
1869 return wbsd_init(&dev->dev, io, irq, dma, 0);
1872 static int __devexit wbsd_remove(struct platform_device *dev)
1874 wbsd_shutdown(&dev->dev, 0);
1885 static int __devinit
1886 wbsd_pnp_probe(struct pnp_dev *pnpdev, const struct pnp_device_id *dev_id)
1891 * Get resources from PnP layer.
1893 io = pnp_port_start(pnpdev, 0);
1894 irq = pnp_irq(pnpdev, 0);
1895 if (pnp_dma_valid(pnpdev, 0))
1896 dma = pnp_dma(pnpdev, 0);
1900 DBGF("PnP resources: port %3x irq %d dma %d\n", io, irq, dma);
1902 return wbsd_init(&pnpdev->dev, io, irq, dma, 1);
1905 static void __devexit wbsd_pnp_remove(struct pnp_dev *dev)
1907 wbsd_shutdown(&dev->dev, 1);
1910 #endif /* CONFIG_PNP */
1918 static int wbsd_suspend(struct wbsd_host *host, pm_message_t state)
1920 BUG_ON(host == NULL);
1922 return mmc_suspend_host(host->mmc, state);
1925 static int wbsd_resume(struct wbsd_host *host)
1927 BUG_ON(host == NULL);
1929 wbsd_init_device(host);
1931 return mmc_resume_host(host->mmc);
1934 static int wbsd_platform_suspend(struct platform_device *dev,
1937 struct mmc_host *mmc = platform_get_drvdata(dev);
1938 struct wbsd_host *host;
1944 DBGF("Suspending...\n");
1946 host = mmc_priv(mmc);
1948 ret = wbsd_suspend(host, state);
1952 wbsd_chip_poweroff(host);
1957 static int wbsd_platform_resume(struct platform_device *dev)
1959 struct mmc_host *mmc = platform_get_drvdata(dev);
1960 struct wbsd_host *host;
1965 DBGF("Resuming...\n");
1967 host = mmc_priv(mmc);
1969 wbsd_chip_config(host);
1972 * Allow device to initialise itself properly.
1976 return wbsd_resume(host);
1981 static int wbsd_pnp_suspend(struct pnp_dev *pnp_dev, pm_message_t state)
1983 struct mmc_host *mmc = dev_get_drvdata(&pnp_dev->dev);
1984 struct wbsd_host *host;
1989 DBGF("Suspending...\n");
1991 host = mmc_priv(mmc);
1993 return wbsd_suspend(host, state);
1996 static int wbsd_pnp_resume(struct pnp_dev *pnp_dev)
1998 struct mmc_host *mmc = dev_get_drvdata(&pnp_dev->dev);
1999 struct wbsd_host *host;
2004 DBGF("Resuming...\n");
2006 host = mmc_priv(mmc);
2009 * See if chip needs to be configured.
2011 if (host->config != 0) {
2012 if (!wbsd_chip_validate(host)) {
2013 printk(KERN_WARNING DRIVER_NAME
2014 ": PnP active but chip not configured! "
2015 "You probably have a buggy BIOS. "
2016 "Configuring chip manually.\n");
2017 wbsd_chip_config(host);
2022 * Allow device to initialise itself properly.
2026 return wbsd_resume(host);
2029 #endif /* CONFIG_PNP */
2031 #else /* CONFIG_PM */
2033 #define wbsd_platform_suspend NULL
2034 #define wbsd_platform_resume NULL
2036 #define wbsd_pnp_suspend NULL
2037 #define wbsd_pnp_resume NULL
2039 #endif /* CONFIG_PM */
2041 static struct platform_device *wbsd_device;
2043 static struct platform_driver wbsd_driver = {
2044 .probe = wbsd_probe,
2045 .remove = __devexit_p(wbsd_remove),
2047 .suspend = wbsd_platform_suspend,
2048 .resume = wbsd_platform_resume,
2050 .name = DRIVER_NAME,
2056 static struct pnp_driver wbsd_pnp_driver = {
2057 .name = DRIVER_NAME,
2058 .id_table = pnp_dev_table,
2059 .probe = wbsd_pnp_probe,
2060 .remove = __devexit_p(wbsd_pnp_remove),
2062 .suspend = wbsd_pnp_suspend,
2063 .resume = wbsd_pnp_resume,
2066 #endif /* CONFIG_PNP */
2069 * Module loading/unloading
2072 static int __init wbsd_drv_init(void)
2076 printk(KERN_INFO DRIVER_NAME
2077 ": Winbond W83L51xD SD/MMC card interface driver, "
2078 DRIVER_VERSION "\n");
2079 printk(KERN_INFO DRIVER_NAME ": Copyright(c) Pierre Ossman\n");
2084 result = pnp_register_driver(&wbsd_pnp_driver);
2088 #endif /* CONFIG_PNP */
2091 result = platform_driver_register(&wbsd_driver);
2095 wbsd_device = platform_device_alloc(DRIVER_NAME, -1);
2097 platform_driver_unregister(&wbsd_driver);
2101 result = platform_device_add(wbsd_device);
2103 platform_device_put(wbsd_device);
2104 platform_driver_unregister(&wbsd_driver);
2112 static void __exit wbsd_drv_exit(void)
2117 pnp_unregister_driver(&wbsd_pnp_driver);
2119 #endif /* CONFIG_PNP */
2122 platform_device_unregister(wbsd_device);
2124 platform_driver_unregister(&wbsd_driver);
2130 module_init(wbsd_drv_init);
2131 module_exit(wbsd_drv_exit);
2133 module_param(nopnp, uint, 0444);
2135 module_param(io, uint, 0444);
2136 module_param(irq, uint, 0444);
2137 module_param(dma, int, 0444);
2139 MODULE_LICENSE("GPL");
2140 MODULE_AUTHOR("Pierre Ossman <drzeus@drzeus.cx>");
2141 MODULE_DESCRIPTION("Winbond W83L51xD SD/MMC card interface driver");
2142 MODULE_VERSION(DRIVER_VERSION);
2145 MODULE_PARM_DESC(nopnp, "Scan for device instead of relying on PNP. (default 0)");
2147 MODULE_PARM_DESC(io, "I/O base to allocate. Must be 8 byte aligned. (default 0x248)");
2148 MODULE_PARM_DESC(irq, "IRQ to allocate. (default 6)");
2149 MODULE_PARM_DESC(dma, "DMA channel to allocate. -1 for no DMA. (default 2)");