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