2 * linux/drivers/mmc/wbsd.c - Winbond W83L51xD SD/MMC driver
4 * Copyright (C) 2004-2007 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 as published by
8 * the Free Software Foundation; either version 2 of the License, or (at
9 * your option) any later version.
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:
17 * - FIFO size field in FSR is always zero.
19 * - FIFO interrupts tend not to work as they should. Interrupts are
20 * triggered only for full/empty events, not for threshold values.
22 * - On APIC systems the FIFO empty interrupt is sometimes lost.
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>
39 #include <asm/scatterlist.h>
43 #define DRIVER_NAME "wbsd"
46 pr_debug(DRIVER_NAME ": " x)
47 #define DBGF(f, x...) \
48 pr_debug(DRIVER_NAME " [%s()]: " f, __func__ , ##x)
56 static const struct pnp_device_id pnp_dev_table[] = {
62 MODULE_DEVICE_TABLE(pnp, pnp_dev_table);
64 #endif /* CONFIG_PNP */
66 static const int config_ports[] = { 0x2E, 0x4E };
67 static const int unlock_codes[] = { 0x83, 0x87 };
69 static const int valid_ids[] = {
74 static unsigned int nopnp = 0;
76 static const unsigned int nopnp = 1;
78 static unsigned int io = 0x248;
79 static unsigned int irq = 6;
86 static inline void wbsd_unlock_config(struct wbsd_host *host)
88 BUG_ON(host->config == 0);
90 outb(host->unlock_code, host->config);
91 outb(host->unlock_code, host->config);
94 static inline void wbsd_lock_config(struct wbsd_host *host)
96 BUG_ON(host->config == 0);
98 outb(LOCK_CODE, host->config);
101 static inline void wbsd_write_config(struct wbsd_host *host, u8 reg, u8 value)
103 BUG_ON(host->config == 0);
105 outb(reg, host->config);
106 outb(value, host->config + 1);
109 static inline u8 wbsd_read_config(struct wbsd_host *host, u8 reg)
111 BUG_ON(host->config == 0);
113 outb(reg, host->config);
114 return inb(host->config + 1);
117 static inline void wbsd_write_index(struct wbsd_host *host, u8 index, u8 value)
119 outb(index, host->base + WBSD_IDXR);
120 outb(value, host->base + WBSD_DATAR);
123 static inline u8 wbsd_read_index(struct wbsd_host *host, u8 index)
125 outb(index, host->base + WBSD_IDXR);
126 return inb(host->base + WBSD_DATAR);
133 static void wbsd_init_device(struct wbsd_host *host)
138 * Reset chip (SD/MMC part) and fifo.
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);
147 setup &= ~WBSD_DAT3_H;
148 wbsd_write_index(host, WBSD_IDX_SETUP, setup);
149 host->flags &= ~WBSD_FIGNORE_DETECT;
152 * Read back default clock.
154 host->clk = wbsd_read_index(host, WBSD_IDX_CLK);
159 outb(WBSD_POWER_N, host->base + WBSD_CSR);
162 * Set maximum timeout.
164 wbsd_write_index(host, WBSD_IDX_TAAC, 0x7F);
167 * Test for card presence
169 if (inb(host->base + WBSD_CSR) & WBSD_CARDPRESENT)
170 host->flags |= WBSD_FCARD_PRESENT;
172 host->flags &= ~WBSD_FCARD_PRESENT;
175 * Enable interesting interrupts.
178 ier |= WBSD_EINT_CARD;
179 ier |= WBSD_EINT_FIFO_THRE;
180 ier |= WBSD_EINT_CRC;
181 ier |= WBSD_EINT_TIMEOUT;
184 outb(ier, host->base + WBSD_EIR);
189 inb(host->base + WBSD_ISR);
192 static void wbsd_reset(struct wbsd_host *host)
196 printk(KERN_ERR "%s: Resetting chip\n", mmc_hostname(host->mmc));
199 * Soft reset of chip (SD/MMC part).
201 setup = wbsd_read_index(host, WBSD_IDX_SETUP);
202 setup |= WBSD_SOFT_RESET;
203 wbsd_write_index(host, WBSD_IDX_SETUP, setup);
206 static void wbsd_request_end(struct wbsd_host *host, struct mmc_request *mrq)
208 unsigned long dmaflags;
210 DBGF("Ending request, cmd (%x)\n", mrq->cmd->opcode);
212 if (host->dma >= 0) {
214 * Release ISA DMA controller.
216 dmaflags = claim_dma_lock();
217 disable_dma(host->dma);
218 clear_dma_ff(host->dma);
219 release_dma_lock(dmaflags);
222 * Disable DMA on host.
224 wbsd_write_index(host, WBSD_IDX_DMA, 0);
230 * MMC layer might call back into the driver so first unlock.
232 spin_unlock(&host->lock);
233 mmc_request_done(host->mmc, mrq);
234 spin_lock(&host->lock);
238 * Scatter/gather functions
241 static inline void wbsd_init_sg(struct wbsd_host *host, struct mmc_data *data)
244 * Get info. about SG list from data structure.
246 host->cur_sg = data->sg;
247 host->num_sg = data->sg_len;
250 host->remain = host->cur_sg->length;
253 static inline int wbsd_next_sg(struct wbsd_host *host)
256 * Skip to next SG entry.
264 if (host->num_sg > 0) {
266 host->remain = host->cur_sg->length;
272 static inline char *wbsd_sg_to_buffer(struct wbsd_host *host)
274 return page_address(host->cur_sg->page) + host->cur_sg->offset;
277 static inline void wbsd_sg_to_dma(struct wbsd_host *host, struct mmc_data *data)
280 struct scatterlist *sg;
281 char *dmabuf = host->dma_buffer;
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;
294 static inline void wbsd_dma_to_sg(struct wbsd_host *host, struct mmc_data *data)
297 struct scatterlist *sg;
298 char *dmabuf = host->dma_buffer;
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;
315 static inline void wbsd_get_short_reply(struct wbsd_host *host,
316 struct mmc_command *cmd)
319 * Correct response type?
321 if (wbsd_read_index(host, WBSD_IDX_RSPLEN) != WBSD_RSP_SHORT) {
322 cmd->error = MMC_ERR_INVALID;
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;
333 static inline void wbsd_get_long_reply(struct wbsd_host *host,
334 struct mmc_command *cmd)
339 * Correct response type?
341 if (wbsd_read_index(host, WBSD_IDX_RSPLEN) != WBSD_RSP_LONG) {
342 cmd->error = MMC_ERR_INVALID;
346 for (i = 0; i < 4; i++) {
348 wbsd_read_index(host, WBSD_IDX_RESP1 + i * 4) << 24;
350 wbsd_read_index(host, WBSD_IDX_RESP2 + i * 4) << 16;
352 wbsd_read_index(host, WBSD_IDX_RESP3 + i * 4) << 8;
354 wbsd_read_index(host, WBSD_IDX_RESP4 + i * 4) << 0;
358 static void wbsd_send_command(struct wbsd_host *host, struct mmc_command *cmd)
363 DBGF("Sending cmd (%x)\n", cmd->opcode);
366 * Clear accumulated ISR. The interrupt routine
367 * will fill this one with events that occur during
373 * Send the command (CRC calculated by host).
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);
379 cmd->error = MMC_ERR_NONE;
382 * Wait for the request to complete.
385 status = wbsd_read_index(host, WBSD_IDX_STATUS);
386 } while (status & WBSD_CARDTRAFFIC);
389 * Do we expect a reply?
391 if (cmd->flags & MMC_RSP_PRESENT) {
398 if (isr & WBSD_INT_CARD)
399 cmd->error = MMC_ERR_TIMEOUT;
401 else if (isr & WBSD_INT_TIMEOUT)
402 cmd->error = MMC_ERR_TIMEOUT;
404 else if ((cmd->flags & MMC_RSP_CRC) && (isr & WBSD_INT_CRC))
405 cmd->error = MMC_ERR_BADCRC;
408 if (cmd->flags & MMC_RSP_136)
409 wbsd_get_long_reply(host, cmd);
411 wbsd_get_short_reply(host, cmd);
415 DBGF("Sent cmd (%x), res %d\n", cmd->opcode, cmd->error);
422 static void wbsd_empty_fifo(struct wbsd_host *host)
424 struct mmc_data *data = host->mrq->cmd->data;
429 * Handle excessive data.
431 if (host->num_sg == 0)
434 buffer = wbsd_sg_to_buffer(host) + host->offset;
437 * Drain the fifo. This has a tendency to loop longer
438 * than the FIFO length (usually one block).
440 while (!((fsr = inb(host->base + WBSD_FSR)) & WBSD_FIFO_EMPTY)) {
442 * The size field in the FSR is broken so we have to
445 if (fsr & WBSD_FIFO_FULL)
447 else if (fsr & WBSD_FIFO_FUTHRE)
452 for (i = 0; i < fifo; i++) {
453 *buffer = inb(host->base + WBSD_DFR);
458 data->bytes_xfered++;
461 * End of scatter list entry?
463 if (host->remain == 0) {
465 * Get next entry. Check if last.
467 if (!wbsd_next_sg(host))
470 buffer = wbsd_sg_to_buffer(host);
476 * This is a very dirty hack to solve a
477 * hardware problem. The chip doesn't trigger
478 * FIFO threshold interrupts properly.
480 if ((data->blocks * data->blksz - data->bytes_xfered) < 16)
481 tasklet_schedule(&host->fifo_tasklet);
484 static void wbsd_fill_fifo(struct wbsd_host *host)
486 struct mmc_data *data = host->mrq->cmd->data;
491 * Check that we aren't being called after the
492 * entire buffer has been transfered.
494 if (host->num_sg == 0)
497 buffer = wbsd_sg_to_buffer(host) + host->offset;
500 * Fill the fifo. This has a tendency to loop longer
501 * than the FIFO length (usually one block).
503 while (!((fsr = inb(host->base + WBSD_FSR)) & WBSD_FIFO_FULL)) {
505 * The size field in the FSR is broken so we have to
508 if (fsr & WBSD_FIFO_EMPTY)
510 else if (fsr & WBSD_FIFO_EMTHRE)
515 for (i = 16; i > fifo; i--) {
516 outb(*buffer, host->base + WBSD_DFR);
521 data->bytes_xfered++;
524 * End of scatter list entry?
526 if (host->remain == 0) {
528 * Get next entry. Check if last.
530 if (!wbsd_next_sg(host))
533 buffer = wbsd_sg_to_buffer(host);
539 * The controller stops sending interrupts for
540 * 'FIFO empty' under certain conditions. So we
541 * need to be a bit more pro-active.
543 tasklet_schedule(&host->fifo_tasklet);
546 static void wbsd_prepare_data(struct wbsd_host *host, struct mmc_data *data)
550 unsigned long dmaflags;
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);
561 size = data->blocks * data->blksz;
564 * Check timeout values for overflow.
565 * (Yes, some cards cause this value to overflow).
567 if (data->timeout_ns > 127000000)
568 wbsd_write_index(host, WBSD_IDX_TAAC, 127);
570 wbsd_write_index(host, WBSD_IDX_TAAC,
571 data->timeout_ns / 1000000);
574 if (data->timeout_clks > 255)
575 wbsd_write_index(host, WBSD_IDX_NSAC, 255);
577 wbsd_write_index(host, WBSD_IDX_NSAC, data->timeout_clks);
580 * Inform the chip of how large blocks will be
581 * sent. It needs this to determine when to
584 * Space for CRC must be included in the size.
585 * Two bytes are needed for each data line.
587 if (host->bus_width == MMC_BUS_WIDTH_1) {
588 blksize = data->blksz + 2;
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;
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);
599 data->error = MMC_ERR_INVALID;
604 * Clear the FIFO. This is needed even for DMA
605 * transfers since the chip still uses the FIFO
608 setup = wbsd_read_index(host, WBSD_IDX_SETUP);
609 setup |= WBSD_FIFO_RESET;
610 wbsd_write_index(host, WBSD_IDX_SETUP, setup);
615 if (host->dma >= 0) {
617 * The buffer for DMA is only 64 kB.
619 BUG_ON(size > 0x10000);
620 if (size > 0x10000) {
621 data->error = MMC_ERR_INVALID;
626 * Transfer data from the SG list to
629 if (data->flags & MMC_DATA_WRITE)
630 wbsd_sg_to_dma(host, data);
633 * Initialise the ISA DMA controller.
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);
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);
645 enable_dma(host->dma);
646 release_dma_lock(dmaflags);
649 * Enable DMA on the host.
651 wbsd_write_index(host, WBSD_IDX_DMA, WBSD_DMA_ENABLE);
654 * This flag is used to keep printk
655 * output to a minimum.
660 * Initialise the SG list.
662 wbsd_init_sg(host, data);
667 wbsd_write_index(host, WBSD_IDX_DMA, 0);
670 * Set up FIFO threshold levels (and fill
671 * buffer if doing a write).
673 if (data->flags & MMC_DATA_READ) {
674 wbsd_write_index(host, WBSD_IDX_FIFOEN,
675 WBSD_FIFOEN_FULL | 8);
677 wbsd_write_index(host, WBSD_IDX_FIFOEN,
678 WBSD_FIFOEN_EMPTY | 8);
679 wbsd_fill_fifo(host);
683 data->error = MMC_ERR_NONE;
686 static void wbsd_finish_data(struct wbsd_host *host, struct mmc_data *data)
688 unsigned long dmaflags;
692 WARN_ON(host->mrq == NULL);
695 * Send a stop command if needed.
698 wbsd_send_command(host, data->stop);
701 * Wait for the controller to leave data
705 status = wbsd_read_index(host, WBSD_IDX_STATUS);
706 } while (status & (WBSD_BLOCK_READ | WBSD_BLOCK_WRITE));
711 if (host->dma >= 0) {
713 * Disable DMA on the host.
715 wbsd_write_index(host, WBSD_IDX_DMA, 0);
718 * Turn of ISA DMA controller.
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);
726 data->bytes_xfered = host->mrq->data->blocks *
727 host->mrq->data->blksz - count;
728 data->bytes_xfered -= data->bytes_xfered % data->blksz;
734 printk(KERN_ERR "%s: Incomplete DMA transfer. "
736 mmc_hostname(host->mmc), count);
738 if (data->error == MMC_ERR_NONE)
739 data->error = MMC_ERR_FAILED;
742 * Transfer data from DMA buffer to
745 if (data->flags & MMC_DATA_READ)
746 wbsd_dma_to_sg(host, data);
749 if (data->error != MMC_ERR_NONE) {
750 if (data->bytes_xfered)
751 data->bytes_xfered -= data->blksz;
755 DBGF("Ending data transfer (%d bytes)\n", data->bytes_xfered);
757 wbsd_request_end(host, host->mrq);
760 /*****************************************************************************\
762 * MMC layer callbacks *
764 \*****************************************************************************/
766 static void wbsd_request(struct mmc_host *mmc, struct mmc_request *mrq)
768 struct wbsd_host *host = mmc_priv(mmc);
769 struct mmc_command *cmd;
772 * Disable tasklets to avoid a deadlock.
774 spin_lock_bh(&host->lock);
776 BUG_ON(host->mrq != NULL);
783 * If there is no card in the slot then
784 * timeout immediatly.
786 if (!(host->flags & WBSD_FCARD_PRESENT)) {
787 cmd->error = MMC_ERR_TIMEOUT;
792 * Does the request include data?
795 wbsd_prepare_data(host, cmd->data);
797 if (cmd->data->error != MMC_ERR_NONE)
801 wbsd_send_command(host, cmd);
804 * If this is a data transfer the request
805 * will be finished after the data has
808 if (cmd->data && (cmd->error == MMC_ERR_NONE)) {
810 * The hardware is so delightfully stupid that it has a list
811 * of "data" commands. If a command isn't on this list, it'll
812 * just go back to the idle state and won't send any data
815 switch (cmd->opcode) {
829 /* ACMDs. We don't keep track of state, so we just treat them
830 * like any other command. */
835 #ifdef CONFIG_MMC_DEBUG
836 printk(KERN_WARNING "%s: Data command %d is not "
837 "supported by this controller.\n",
838 mmc_hostname(host->mmc), cmd->opcode);
840 cmd->data->error = MMC_ERR_INVALID;
843 wbsd_send_command(host, cmd->data->stop);
849 * Dirty fix for hardware bug.
852 tasklet_schedule(&host->fifo_tasklet);
854 spin_unlock_bh(&host->lock);
860 wbsd_request_end(host, mrq);
862 spin_unlock_bh(&host->lock);
865 static void wbsd_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
867 struct wbsd_host *host = mmc_priv(mmc);
870 spin_lock_bh(&host->lock);
873 * Reset the chip on each power off.
874 * Should clear out any weird states.
876 if (ios->power_mode == MMC_POWER_OFF)
877 wbsd_init_device(host);
879 if (ios->clock >= 24000000)
881 else if (ios->clock >= 16000000)
883 else if (ios->clock >= 12000000)
889 * Only write to the clock register when
890 * there is an actual change.
892 if (clk != host->clk) {
893 wbsd_write_index(host, WBSD_IDX_CLK, clk);
900 if (ios->power_mode != MMC_POWER_OFF) {
901 pwr = inb(host->base + WBSD_CSR);
902 pwr &= ~WBSD_POWER_N;
903 outb(pwr, host->base + WBSD_CSR);
907 * MMC cards need to have pin 1 high during init.
908 * It wreaks havoc with the card detection though so
909 * that needs to be disabled.
911 setup = wbsd_read_index(host, WBSD_IDX_SETUP);
912 if (ios->chip_select == MMC_CS_HIGH) {
913 BUG_ON(ios->bus_width != MMC_BUS_WIDTH_1);
914 setup |= WBSD_DAT3_H;
915 host->flags |= WBSD_FIGNORE_DETECT;
917 if (setup & WBSD_DAT3_H) {
918 setup &= ~WBSD_DAT3_H;
921 * We cannot resume card detection immediatly
922 * because of capacitance and delays in the chip.
924 mod_timer(&host->ignore_timer, jiffies + HZ / 100);
927 wbsd_write_index(host, WBSD_IDX_SETUP, setup);
930 * Store bus width for later. Will be used when
931 * setting up the data transfer.
933 host->bus_width = ios->bus_width;
935 spin_unlock_bh(&host->lock);
938 static int wbsd_get_ro(struct mmc_host *mmc)
940 struct wbsd_host *host = mmc_priv(mmc);
943 spin_lock_bh(&host->lock);
945 csr = inb(host->base + WBSD_CSR);
947 outb(csr, host->base + WBSD_CSR);
951 csr = inb(host->base + WBSD_CSR);
953 outb(csr, host->base + WBSD_CSR);
955 spin_unlock_bh(&host->lock);
957 return csr & WBSD_WRPT;
960 static const struct mmc_host_ops wbsd_ops = {
961 .request = wbsd_request,
962 .set_ios = wbsd_set_ios,
963 .get_ro = wbsd_get_ro,
966 /*****************************************************************************\
968 * Interrupt handling *
970 \*****************************************************************************/
973 * Helper function to reset detection ignore
976 static void wbsd_reset_ignore(unsigned long data)
978 struct wbsd_host *host = (struct wbsd_host *)data;
980 BUG_ON(host == NULL);
982 DBG("Resetting card detection ignore\n");
984 spin_lock_bh(&host->lock);
986 host->flags &= ~WBSD_FIGNORE_DETECT;
989 * Card status might have changed during the
992 tasklet_schedule(&host->card_tasklet);
994 spin_unlock_bh(&host->lock);
1001 static inline struct mmc_data *wbsd_get_data(struct wbsd_host *host)
1003 WARN_ON(!host->mrq);
1007 WARN_ON(!host->mrq->cmd);
1008 if (!host->mrq->cmd)
1011 WARN_ON(!host->mrq->cmd->data);
1012 if (!host->mrq->cmd->data)
1015 return host->mrq->cmd->data;
1018 static void wbsd_tasklet_card(unsigned long param)
1020 struct wbsd_host *host = (struct wbsd_host *)param;
1024 spin_lock(&host->lock);
1026 if (host->flags & WBSD_FIGNORE_DETECT) {
1027 spin_unlock(&host->lock);
1031 csr = inb(host->base + WBSD_CSR);
1032 WARN_ON(csr == 0xff);
1034 if (csr & WBSD_CARDPRESENT) {
1035 if (!(host->flags & WBSD_FCARD_PRESENT)) {
1036 DBG("Card inserted\n");
1037 host->flags |= WBSD_FCARD_PRESENT;
1041 } else if (host->flags & WBSD_FCARD_PRESENT) {
1042 DBG("Card removed\n");
1043 host->flags &= ~WBSD_FCARD_PRESENT;
1046 printk(KERN_ERR "%s: Card removed during transfer!\n",
1047 mmc_hostname(host->mmc));
1050 host->mrq->cmd->error = MMC_ERR_FAILED;
1051 tasklet_schedule(&host->finish_tasklet);
1058 * Unlock first since we might get a call back.
1061 spin_unlock(&host->lock);
1064 mmc_detect_change(host->mmc, msecs_to_jiffies(delay));
1067 static void wbsd_tasklet_fifo(unsigned long param)
1069 struct wbsd_host *host = (struct wbsd_host *)param;
1070 struct mmc_data *data;
1072 spin_lock(&host->lock);
1077 data = wbsd_get_data(host);
1081 if (data->flags & MMC_DATA_WRITE)
1082 wbsd_fill_fifo(host);
1084 wbsd_empty_fifo(host);
1089 if (host->num_sg == 0) {
1090 wbsd_write_index(host, WBSD_IDX_FIFOEN, 0);
1091 tasklet_schedule(&host->finish_tasklet);
1095 spin_unlock(&host->lock);
1098 static void wbsd_tasklet_crc(unsigned long param)
1100 struct wbsd_host *host = (struct wbsd_host *)param;
1101 struct mmc_data *data;
1103 spin_lock(&host->lock);
1108 data = wbsd_get_data(host);
1112 DBGF("CRC error\n");
1114 data->error = MMC_ERR_BADCRC;
1116 tasklet_schedule(&host->finish_tasklet);
1119 spin_unlock(&host->lock);
1122 static void wbsd_tasklet_timeout(unsigned long param)
1124 struct wbsd_host *host = (struct wbsd_host *)param;
1125 struct mmc_data *data;
1127 spin_lock(&host->lock);
1132 data = wbsd_get_data(host);
1138 data->error = MMC_ERR_TIMEOUT;
1140 tasklet_schedule(&host->finish_tasklet);
1143 spin_unlock(&host->lock);
1146 static void wbsd_tasklet_finish(unsigned long param)
1148 struct wbsd_host *host = (struct wbsd_host *)param;
1149 struct mmc_data *data;
1151 spin_lock(&host->lock);
1153 WARN_ON(!host->mrq);
1157 data = wbsd_get_data(host);
1161 wbsd_finish_data(host, data);
1164 spin_unlock(&host->lock);
1168 * Interrupt handling
1171 static irqreturn_t wbsd_irq(int irq, void *dev_id)
1173 struct wbsd_host *host = dev_id;
1176 isr = inb(host->base + WBSD_ISR);
1179 * Was it actually our hardware that caused the interrupt?
1181 if (isr == 0xff || isr == 0x00)
1187 * Schedule tasklets as needed.
1189 if (isr & WBSD_INT_CARD)
1190 tasklet_schedule(&host->card_tasklet);
1191 if (isr & WBSD_INT_FIFO_THRE)
1192 tasklet_schedule(&host->fifo_tasklet);
1193 if (isr & WBSD_INT_CRC)
1194 tasklet_hi_schedule(&host->crc_tasklet);
1195 if (isr & WBSD_INT_TIMEOUT)
1196 tasklet_hi_schedule(&host->timeout_tasklet);
1197 if (isr & WBSD_INT_TC)
1198 tasklet_schedule(&host->finish_tasklet);
1203 /*****************************************************************************\
1205 * Device initialisation and shutdown *
1207 \*****************************************************************************/
1210 * Allocate/free MMC structure.
1213 static int __devinit wbsd_alloc_mmc(struct device *dev)
1215 struct mmc_host *mmc;
1216 struct wbsd_host *host;
1219 * Allocate MMC structure.
1221 mmc = mmc_alloc_host(sizeof(struct wbsd_host), dev);
1225 host = mmc_priv(mmc);
1231 * Set host parameters.
1233 mmc->ops = &wbsd_ops;
1234 mmc->f_min = 375000;
1235 mmc->f_max = 24000000;
1236 mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
1237 mmc->caps = MMC_CAP_4_BIT_DATA | MMC_CAP_MULTIWRITE | MMC_CAP_BYTEBLOCK;
1239 spin_lock_init(&host->lock);
1244 init_timer(&host->ignore_timer);
1245 host->ignore_timer.data = (unsigned long)host;
1246 host->ignore_timer.function = wbsd_reset_ignore;
1249 * Maximum number of segments. Worst case is one sector per segment
1250 * so this will be 64kB/512.
1252 mmc->max_hw_segs = 128;
1253 mmc->max_phys_segs = 128;
1256 * Maximum request size. Also limited by 64KiB buffer.
1258 mmc->max_req_size = 65536;
1261 * Maximum segment size. Could be one segment with the maximum number
1264 mmc->max_seg_size = mmc->max_req_size;
1267 * Maximum block size. We have 12 bits (= 4095) but have to subtract
1268 * space for CRC. So the maximum is 4095 - 4*2 = 4087.
1270 mmc->max_blk_size = 4087;
1273 * Maximum block count. There is no real limit so the maximum
1274 * request size will be the only restriction.
1276 mmc->max_blk_count = mmc->max_req_size;
1278 dev_set_drvdata(dev, mmc);
1283 static void __devexit wbsd_free_mmc(struct device *dev)
1285 struct mmc_host *mmc;
1286 struct wbsd_host *host;
1288 mmc = dev_get_drvdata(dev);
1292 host = mmc_priv(mmc);
1293 BUG_ON(host == NULL);
1295 del_timer_sync(&host->ignore_timer);
1299 dev_set_drvdata(dev, NULL);
1303 * Scan for known chip id:s
1306 static int __devinit wbsd_scan(struct wbsd_host *host)
1312 * Iterate through all ports, all codes to
1313 * find hardware that is in our known list.
1315 for (i = 0; i < ARRAY_SIZE(config_ports); i++) {
1316 if (!request_region(config_ports[i], 2, DRIVER_NAME))
1319 for (j = 0; j < ARRAY_SIZE(unlock_codes); j++) {
1322 host->config = config_ports[i];
1323 host->unlock_code = unlock_codes[j];
1325 wbsd_unlock_config(host);
1327 outb(WBSD_CONF_ID_HI, config_ports[i]);
1328 id = inb(config_ports[i] + 1) << 8;
1330 outb(WBSD_CONF_ID_LO, config_ports[i]);
1331 id |= inb(config_ports[i] + 1);
1333 wbsd_lock_config(host);
1335 for (k = 0; k < ARRAY_SIZE(valid_ids); k++) {
1336 if (id == valid_ids[k]) {
1344 DBG("Unknown hardware (id %x) found at %x\n",
1345 id, config_ports[i]);
1349 release_region(config_ports[i], 2);
1353 host->unlock_code = 0;
1359 * Allocate/free io port ranges
1362 static int __devinit wbsd_request_region(struct wbsd_host *host, int base)
1367 if (!request_region(base, 8, DRIVER_NAME))
1375 static void __devexit wbsd_release_regions(struct wbsd_host *host)
1378 release_region(host->base, 8);
1383 release_region(host->config, 2);
1389 * Allocate/free DMA port and buffer
1392 static void __devinit wbsd_request_dma(struct wbsd_host *host, int dma)
1397 if (request_dma(dma, DRIVER_NAME))
1401 * We need to allocate a special buffer in
1402 * order for ISA to be able to DMA to it.
1404 host->dma_buffer = kmalloc(WBSD_DMA_SIZE,
1405 GFP_NOIO | GFP_DMA | __GFP_REPEAT | __GFP_NOWARN);
1406 if (!host->dma_buffer)
1410 * Translate the address to a physical address.
1412 host->dma_addr = dma_map_single(mmc_dev(host->mmc), host->dma_buffer,
1413 WBSD_DMA_SIZE, DMA_BIDIRECTIONAL);
1416 * ISA DMA must be aligned on a 64k basis.
1418 if ((host->dma_addr & 0xffff) != 0)
1421 * ISA cannot access memory above 16 MB.
1423 else if (host->dma_addr >= 0x1000000)
1432 * If we've gotten here then there is some kind of alignment bug
1436 dma_unmap_single(mmc_dev(host->mmc), host->dma_addr,
1437 WBSD_DMA_SIZE, DMA_BIDIRECTIONAL);
1438 host->dma_addr = (dma_addr_t)NULL;
1440 kfree(host->dma_buffer);
1441 host->dma_buffer = NULL;
1447 printk(KERN_WARNING DRIVER_NAME ": Unable to allocate DMA %d. "
1448 "Falling back on FIFO.\n", dma);
1451 static void __devexit wbsd_release_dma(struct wbsd_host *host)
1453 if (host->dma_addr) {
1454 dma_unmap_single(mmc_dev(host->mmc), host->dma_addr,
1455 WBSD_DMA_SIZE, DMA_BIDIRECTIONAL);
1457 kfree(host->dma_buffer);
1459 free_dma(host->dma);
1462 host->dma_buffer = NULL;
1463 host->dma_addr = (dma_addr_t)NULL;
1467 * Allocate/free IRQ.
1470 static int __devinit wbsd_request_irq(struct wbsd_host *host, int irq)
1475 * Allocate interrupt.
1478 ret = request_irq(irq, wbsd_irq, IRQF_SHARED, DRIVER_NAME, host);
1487 tasklet_init(&host->card_tasklet, wbsd_tasklet_card,
1488 (unsigned long)host);
1489 tasklet_init(&host->fifo_tasklet, wbsd_tasklet_fifo,
1490 (unsigned long)host);
1491 tasklet_init(&host->crc_tasklet, wbsd_tasklet_crc,
1492 (unsigned long)host);
1493 tasklet_init(&host->timeout_tasklet, wbsd_tasklet_timeout,
1494 (unsigned long)host);
1495 tasklet_init(&host->finish_tasklet, wbsd_tasklet_finish,
1496 (unsigned long)host);
1501 static void __devexit wbsd_release_irq(struct wbsd_host *host)
1506 free_irq(host->irq, host);
1510 tasklet_kill(&host->card_tasklet);
1511 tasklet_kill(&host->fifo_tasklet);
1512 tasklet_kill(&host->crc_tasklet);
1513 tasklet_kill(&host->timeout_tasklet);
1514 tasklet_kill(&host->finish_tasklet);
1518 * Allocate all resources for the host.
1521 static int __devinit wbsd_request_resources(struct wbsd_host *host,
1522 int base, int irq, int dma)
1527 * Allocate I/O ports.
1529 ret = wbsd_request_region(host, base);
1534 * Allocate interrupt.
1536 ret = wbsd_request_irq(host, irq);
1543 wbsd_request_dma(host, dma);
1549 * Release all resources for the host.
1552 static void __devexit wbsd_release_resources(struct wbsd_host *host)
1554 wbsd_release_dma(host);
1555 wbsd_release_irq(host);
1556 wbsd_release_regions(host);
1560 * Configure the resources the chip should use.
1563 static void wbsd_chip_config(struct wbsd_host *host)
1565 wbsd_unlock_config(host);
1570 wbsd_write_config(host, WBSD_CONF_SWRST, 1);
1571 wbsd_write_config(host, WBSD_CONF_SWRST, 0);
1574 * Select SD/MMC function.
1576 wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
1579 * Set up card detection.
1581 wbsd_write_config(host, WBSD_CONF_PINS, WBSD_PINS_DETECT_GP11);
1586 wbsd_write_config(host, WBSD_CONF_PORT_HI, host->base >> 8);
1587 wbsd_write_config(host, WBSD_CONF_PORT_LO, host->base & 0xff);
1589 wbsd_write_config(host, WBSD_CONF_IRQ, host->irq);
1592 wbsd_write_config(host, WBSD_CONF_DRQ, host->dma);
1595 * Enable and power up chip.
1597 wbsd_write_config(host, WBSD_CONF_ENABLE, 1);
1598 wbsd_write_config(host, WBSD_CONF_POWER, 0x20);
1600 wbsd_lock_config(host);
1604 * Check that configured resources are correct.
1607 static int wbsd_chip_validate(struct wbsd_host *host)
1611 wbsd_unlock_config(host);
1614 * Select SD/MMC function.
1616 wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
1619 * Read configuration.
1621 base = wbsd_read_config(host, WBSD_CONF_PORT_HI) << 8;
1622 base |= wbsd_read_config(host, WBSD_CONF_PORT_LO);
1624 irq = wbsd_read_config(host, WBSD_CONF_IRQ);
1626 dma = wbsd_read_config(host, WBSD_CONF_DRQ);
1628 wbsd_lock_config(host);
1631 * Validate against given configuration.
1633 if (base != host->base)
1635 if (irq != host->irq)
1637 if ((dma != host->dma) && (host->dma != -1))
1644 * Powers down the SD function
1647 static void wbsd_chip_poweroff(struct wbsd_host *host)
1649 wbsd_unlock_config(host);
1651 wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
1652 wbsd_write_config(host, WBSD_CONF_ENABLE, 0);
1654 wbsd_lock_config(host);
1657 /*****************************************************************************\
1659 * Devices setup and shutdown *
1661 \*****************************************************************************/
1663 static int __devinit wbsd_init(struct device *dev, int base, int irq, int dma,
1666 struct wbsd_host *host = NULL;
1667 struct mmc_host *mmc = NULL;
1670 ret = wbsd_alloc_mmc(dev);
1674 mmc = dev_get_drvdata(dev);
1675 host = mmc_priv(mmc);
1678 * Scan for hardware.
1680 ret = wbsd_scan(host);
1682 if (pnp && (ret == -ENODEV)) {
1683 printk(KERN_WARNING DRIVER_NAME
1684 ": Unable to confirm device presence. You may "
1685 "experience lock-ups.\n");
1693 * Request resources.
1695 ret = wbsd_request_resources(host, base, irq, dma);
1697 wbsd_release_resources(host);
1703 * See if chip needs to be configured.
1706 if ((host->config != 0) && !wbsd_chip_validate(host)) {
1707 printk(KERN_WARNING DRIVER_NAME
1708 ": PnP active but chip not configured! "
1709 "You probably have a buggy BIOS. "
1710 "Configuring chip manually.\n");
1711 wbsd_chip_config(host);
1714 wbsd_chip_config(host);
1717 * Power Management stuff. No idea how this works.
1722 wbsd_unlock_config(host);
1723 wbsd_write_config(host, WBSD_CONF_PME, 0xA0);
1724 wbsd_lock_config(host);
1728 * Allow device to initialise itself properly.
1733 * Reset the chip into a known state.
1735 wbsd_init_device(host);
1739 printk(KERN_INFO "%s: W83L51xD", mmc_hostname(mmc));
1740 if (host->chip_id != 0)
1741 printk(" id %x", (int)host->chip_id);
1742 printk(" at 0x%x irq %d", (int)host->base, (int)host->irq);
1744 printk(" dma %d", (int)host->dma);
1754 static void __devexit wbsd_shutdown(struct device *dev, int pnp)
1756 struct mmc_host *mmc = dev_get_drvdata(dev);
1757 struct wbsd_host *host;
1762 host = mmc_priv(mmc);
1764 mmc_remove_host(mmc);
1767 * Power down the SD/MMC function.
1770 wbsd_chip_poweroff(host);
1772 wbsd_release_resources(host);
1781 static int __devinit wbsd_probe(struct platform_device *dev)
1783 /* Use the module parameters for resources */
1784 return wbsd_init(&dev->dev, io, irq, dma, 0);
1787 static int __devexit wbsd_remove(struct platform_device *dev)
1789 wbsd_shutdown(&dev->dev, 0);
1800 static int __devinit
1801 wbsd_pnp_probe(struct pnp_dev *pnpdev, const struct pnp_device_id *dev_id)
1806 * Get resources from PnP layer.
1808 io = pnp_port_start(pnpdev, 0);
1809 irq = pnp_irq(pnpdev, 0);
1810 if (pnp_dma_valid(pnpdev, 0))
1811 dma = pnp_dma(pnpdev, 0);
1815 DBGF("PnP resources: port %3x irq %d dma %d\n", io, irq, dma);
1817 return wbsd_init(&pnpdev->dev, io, irq, dma, 1);
1820 static void __devexit wbsd_pnp_remove(struct pnp_dev *dev)
1822 wbsd_shutdown(&dev->dev, 1);
1825 #endif /* CONFIG_PNP */
1833 static int wbsd_suspend(struct wbsd_host *host, pm_message_t state)
1835 BUG_ON(host == NULL);
1837 return mmc_suspend_host(host->mmc, state);
1840 static int wbsd_resume(struct wbsd_host *host)
1842 BUG_ON(host == NULL);
1844 wbsd_init_device(host);
1846 return mmc_resume_host(host->mmc);
1849 static int wbsd_platform_suspend(struct platform_device *dev,
1852 struct mmc_host *mmc = platform_get_drvdata(dev);
1853 struct wbsd_host *host;
1859 DBGF("Suspending...\n");
1861 host = mmc_priv(mmc);
1863 ret = wbsd_suspend(host, state);
1867 wbsd_chip_poweroff(host);
1872 static int wbsd_platform_resume(struct platform_device *dev)
1874 struct mmc_host *mmc = platform_get_drvdata(dev);
1875 struct wbsd_host *host;
1880 DBGF("Resuming...\n");
1882 host = mmc_priv(mmc);
1884 wbsd_chip_config(host);
1887 * Allow device to initialise itself properly.
1891 return wbsd_resume(host);
1896 static int wbsd_pnp_suspend(struct pnp_dev *pnp_dev, pm_message_t state)
1898 struct mmc_host *mmc = dev_get_drvdata(&pnp_dev->dev);
1899 struct wbsd_host *host;
1904 DBGF("Suspending...\n");
1906 host = mmc_priv(mmc);
1908 return wbsd_suspend(host, state);
1911 static int wbsd_pnp_resume(struct pnp_dev *pnp_dev)
1913 struct mmc_host *mmc = dev_get_drvdata(&pnp_dev->dev);
1914 struct wbsd_host *host;
1919 DBGF("Resuming...\n");
1921 host = mmc_priv(mmc);
1924 * See if chip needs to be configured.
1926 if (host->config != 0) {
1927 if (!wbsd_chip_validate(host)) {
1928 printk(KERN_WARNING DRIVER_NAME
1929 ": PnP active but chip not configured! "
1930 "You probably have a buggy BIOS. "
1931 "Configuring chip manually.\n");
1932 wbsd_chip_config(host);
1937 * Allow device to initialise itself properly.
1941 return wbsd_resume(host);
1944 #endif /* CONFIG_PNP */
1946 #else /* CONFIG_PM */
1948 #define wbsd_platform_suspend NULL
1949 #define wbsd_platform_resume NULL
1951 #define wbsd_pnp_suspend NULL
1952 #define wbsd_pnp_resume NULL
1954 #endif /* CONFIG_PM */
1956 static struct platform_device *wbsd_device;
1958 static struct platform_driver wbsd_driver = {
1959 .probe = wbsd_probe,
1960 .remove = __devexit_p(wbsd_remove),
1962 .suspend = wbsd_platform_suspend,
1963 .resume = wbsd_platform_resume,
1965 .name = DRIVER_NAME,
1971 static struct pnp_driver wbsd_pnp_driver = {
1972 .name = DRIVER_NAME,
1973 .id_table = pnp_dev_table,
1974 .probe = wbsd_pnp_probe,
1975 .remove = __devexit_p(wbsd_pnp_remove),
1977 .suspend = wbsd_pnp_suspend,
1978 .resume = wbsd_pnp_resume,
1981 #endif /* CONFIG_PNP */
1984 * Module loading/unloading
1987 static int __init wbsd_drv_init(void)
1991 printk(KERN_INFO DRIVER_NAME
1992 ": Winbond W83L51xD SD/MMC card interface driver\n");
1993 printk(KERN_INFO DRIVER_NAME ": Copyright(c) Pierre Ossman\n");
1998 result = pnp_register_driver(&wbsd_pnp_driver);
2002 #endif /* CONFIG_PNP */
2005 result = platform_driver_register(&wbsd_driver);
2009 wbsd_device = platform_device_alloc(DRIVER_NAME, -1);
2011 platform_driver_unregister(&wbsd_driver);
2015 result = platform_device_add(wbsd_device);
2017 platform_device_put(wbsd_device);
2018 platform_driver_unregister(&wbsd_driver);
2026 static void __exit wbsd_drv_exit(void)
2031 pnp_unregister_driver(&wbsd_pnp_driver);
2033 #endif /* CONFIG_PNP */
2036 platform_device_unregister(wbsd_device);
2038 platform_driver_unregister(&wbsd_driver);
2044 module_init(wbsd_drv_init);
2045 module_exit(wbsd_drv_exit);
2047 module_param(nopnp, uint, 0444);
2049 module_param(io, uint, 0444);
2050 module_param(irq, uint, 0444);
2051 module_param(dma, int, 0444);
2053 MODULE_LICENSE("GPL");
2054 MODULE_AUTHOR("Pierre Ossman <drzeus@drzeus.cx>");
2055 MODULE_DESCRIPTION("Winbond W83L51xD SD/MMC card interface driver");
2058 MODULE_PARM_DESC(nopnp, "Scan for device instead of relying on PNP. (default 0)");
2060 MODULE_PARM_DESC(io, "I/O base to allocate. Must be 8 byte aligned. (default 0x248)");
2061 MODULE_PARM_DESC(irq, "IRQ to allocate. (default 6)");
2062 MODULE_PARM_DESC(dma, "DMA channel to allocate. -1 for no DMA. (default 2)");