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)");