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"
47 #ifdef CONFIG_MMC_DEBUG
49 printk(KERN_DEBUG DRIVER_NAME ": " x)
50 #define DBGF(f, x...) \
51 printk(KERN_DEBUG DRIVER_NAME " [%s()]: " f, __func__ , ##x)
53 #define DBG(x...) do { } while (0)
54 #define DBGF(x...) do { } while (0)
63 static const struct pnp_device_id pnp_dev_table
[] = {
69 MODULE_DEVICE_TABLE(pnp
, pnp_dev_table
);
71 #endif /* CONFIG_PNP */
73 static const int config_ports
[] = { 0x2E, 0x4E };
74 static const int unlock_codes
[] = { 0x83, 0x87 };
76 static const int valid_ids
[] = {
81 static unsigned int nopnp
= 0;
83 static const unsigned int nopnp
= 1;
85 static unsigned int io
= 0x248;
86 static unsigned int irq
= 6;
93 static inline void wbsd_unlock_config(struct wbsd_host
* host
)
95 BUG_ON(host
->config
== 0);
97 outb(host
->unlock_code
, host
->config
);
98 outb(host
->unlock_code
, host
->config
);
101 static inline void wbsd_lock_config(struct wbsd_host
* host
)
103 BUG_ON(host
->config
== 0);
105 outb(LOCK_CODE
, host
->config
);
108 static inline void wbsd_write_config(struct wbsd_host
* host
, u8 reg
, u8 value
)
110 BUG_ON(host
->config
== 0);
112 outb(reg
, host
->config
);
113 outb(value
, host
->config
+ 1);
116 static inline u8
wbsd_read_config(struct wbsd_host
* host
, u8 reg
)
118 BUG_ON(host
->config
== 0);
120 outb(reg
, host
->config
);
121 return inb(host
->config
+ 1);
124 static inline void wbsd_write_index(struct wbsd_host
* host
, u8 index
, u8 value
)
126 outb(index
, host
->base
+ WBSD_IDXR
);
127 outb(value
, host
->base
+ WBSD_DATAR
);
130 static inline u8
wbsd_read_index(struct wbsd_host
* host
, u8 index
)
132 outb(index
, host
->base
+ WBSD_IDXR
);
133 return inb(host
->base
+ WBSD_DATAR
);
140 static void wbsd_init_device(struct wbsd_host
* host
)
145 * Reset chip (SD/MMC part) and fifo.
147 setup
= wbsd_read_index(host
, WBSD_IDX_SETUP
);
148 setup
|= WBSD_FIFO_RESET
| WBSD_SOFT_RESET
;
149 wbsd_write_index(host
, WBSD_IDX_SETUP
, setup
);
154 setup
&= ~WBSD_DAT3_H
;
155 wbsd_write_index(host
, WBSD_IDX_SETUP
, setup
);
156 host
->flags
&= ~WBSD_FIGNORE_DETECT
;
159 * Read back default clock.
161 host
->clk
= wbsd_read_index(host
, WBSD_IDX_CLK
);
166 outb(WBSD_POWER_N
, host
->base
+ WBSD_CSR
);
169 * Set maximum timeout.
171 wbsd_write_index(host
, WBSD_IDX_TAAC
, 0x7F);
174 * Test for card presence
176 if (inb(host
->base
+ WBSD_CSR
) & WBSD_CARDPRESENT
)
177 host
->flags
|= WBSD_FCARD_PRESENT
;
179 host
->flags
&= ~WBSD_FCARD_PRESENT
;
182 * Enable interesting interrupts.
185 ier
|= WBSD_EINT_CARD
;
186 ier
|= WBSD_EINT_FIFO_THRE
;
187 ier
|= WBSD_EINT_CCRC
;
188 ier
|= WBSD_EINT_TIMEOUT
;
189 ier
|= WBSD_EINT_CRC
;
192 outb(ier
, host
->base
+ WBSD_EIR
);
197 inb(host
->base
+ WBSD_ISR
);
200 static void wbsd_reset(struct wbsd_host
* host
)
204 printk(KERN_ERR
"%s: Resetting chip\n", mmc_hostname(host
->mmc
));
207 * Soft reset of chip (SD/MMC part).
209 setup
= wbsd_read_index(host
, WBSD_IDX_SETUP
);
210 setup
|= WBSD_SOFT_RESET
;
211 wbsd_write_index(host
, WBSD_IDX_SETUP
, setup
);
214 static void wbsd_request_end(struct wbsd_host
* host
, struct mmc_request
* mrq
)
216 unsigned long dmaflags
;
218 DBGF("Ending request, cmd (%x)\n", mrq
->cmd
->opcode
);
223 * Release ISA DMA controller.
225 dmaflags
= claim_dma_lock();
226 disable_dma(host
->dma
);
227 clear_dma_ff(host
->dma
);
228 release_dma_lock(dmaflags
);
231 * Disable DMA on host.
233 wbsd_write_index(host
, WBSD_IDX_DMA
, 0);
239 * MMC layer might call back into the driver so first unlock.
241 spin_unlock(&host
->lock
);
242 mmc_request_done(host
->mmc
, mrq
);
243 spin_lock(&host
->lock
);
247 * Scatter/gather functions
250 static inline void wbsd_init_sg(struct wbsd_host
* host
, struct mmc_data
* data
)
253 * Get info. about SG list from data structure.
255 host
->cur_sg
= data
->sg
;
256 host
->num_sg
= data
->sg_len
;
259 host
->remain
= host
->cur_sg
->length
;
262 static inline int wbsd_next_sg(struct wbsd_host
* host
)
265 * Skip to next SG entry.
273 if (host
->num_sg
> 0)
276 host
->remain
= host
->cur_sg
->length
;
282 static inline char* wbsd_kmap_sg(struct wbsd_host
* host
)
284 host
->mapped_sg
= kmap_atomic(host
->cur_sg
->page
, KM_BIO_SRC_IRQ
) +
285 host
->cur_sg
->offset
;
286 return host
->mapped_sg
;
289 static inline void wbsd_kunmap_sg(struct wbsd_host
* host
)
291 kunmap_atomic(host
->mapped_sg
, KM_BIO_SRC_IRQ
);
294 static inline void wbsd_sg_to_dma(struct wbsd_host
* host
, struct mmc_data
* data
)
296 unsigned int len
, i
, size
;
297 struct scatterlist
* sg
;
298 char* dmabuf
= host
->dma_buffer
;
307 * Just loop through all entries. Size might not
308 * be the entire list though so make sure that
309 * we do not transfer too much.
311 for (i
= 0;i
< len
;i
++)
313 sgbuf
= kmap_atomic(sg
[i
].page
, KM_BIO_SRC_IRQ
) + sg
[i
].offset
;
314 if (size
< sg
[i
].length
)
315 memcpy(dmabuf
, sgbuf
, size
);
317 memcpy(dmabuf
, sgbuf
, sg
[i
].length
);
318 kunmap_atomic(sgbuf
, KM_BIO_SRC_IRQ
);
319 dmabuf
+= sg
[i
].length
;
321 if (size
< sg
[i
].length
)
324 size
-= sg
[i
].length
;
331 * Check that we didn't get a request to transfer
332 * more data than can fit into the SG list.
340 static inline void wbsd_dma_to_sg(struct wbsd_host
* host
, struct mmc_data
* data
)
342 unsigned int len
, i
, size
;
343 struct scatterlist
* sg
;
344 char* dmabuf
= host
->dma_buffer
;
353 * Just loop through all entries. Size might not
354 * be the entire list though so make sure that
355 * we do not transfer too much.
357 for (i
= 0;i
< len
;i
++)
359 sgbuf
= kmap_atomic(sg
[i
].page
, KM_BIO_SRC_IRQ
) + sg
[i
].offset
;
360 if (size
< sg
[i
].length
)
361 memcpy(sgbuf
, dmabuf
, size
);
363 memcpy(sgbuf
, dmabuf
, sg
[i
].length
);
364 kunmap_atomic(sgbuf
, KM_BIO_SRC_IRQ
);
365 dmabuf
+= sg
[i
].length
;
367 if (size
< sg
[i
].length
)
370 size
-= sg
[i
].length
;
377 * Check that we didn't get a request to transfer
378 * more data than can fit into the SG list.
390 static inline void wbsd_get_short_reply(struct wbsd_host
* host
,
391 struct mmc_command
* cmd
)
394 * Correct response type?
396 if (wbsd_read_index(host
, WBSD_IDX_RSPLEN
) != WBSD_RSP_SHORT
)
398 cmd
->error
= MMC_ERR_INVALID
;
403 wbsd_read_index(host
, WBSD_IDX_RESP12
) << 24;
405 wbsd_read_index(host
, WBSD_IDX_RESP13
) << 16;
407 wbsd_read_index(host
, WBSD_IDX_RESP14
) << 8;
409 wbsd_read_index(host
, WBSD_IDX_RESP15
) << 0;
411 wbsd_read_index(host
, WBSD_IDX_RESP16
) << 24;
414 static inline void wbsd_get_long_reply(struct wbsd_host
* host
,
415 struct mmc_command
* cmd
)
420 * Correct response type?
422 if (wbsd_read_index(host
, WBSD_IDX_RSPLEN
) != WBSD_RSP_LONG
)
424 cmd
->error
= MMC_ERR_INVALID
;
428 for (i
= 0;i
< 4;i
++)
431 wbsd_read_index(host
, WBSD_IDX_RESP1
+ i
* 4) << 24;
433 wbsd_read_index(host
, WBSD_IDX_RESP2
+ i
* 4) << 16;
435 wbsd_read_index(host
, WBSD_IDX_RESP3
+ i
* 4) << 8;
437 wbsd_read_index(host
, WBSD_IDX_RESP4
+ i
* 4) << 0;
441 static void wbsd_send_command(struct wbsd_host
* host
, struct mmc_command
* cmd
)
446 DBGF("Sending cmd (%x)\n", cmd
->opcode
);
449 * Clear accumulated ISR. The interrupt routine
450 * will fill this one with events that occur during
456 * Send the command (CRC calculated by host).
458 outb(cmd
->opcode
, host
->base
+ WBSD_CMDR
);
459 for (i
= 3;i
>= 0;i
--)
460 outb((cmd
->arg
>> (i
* 8)) & 0xff, host
->base
+ WBSD_CMDR
);
462 cmd
->error
= MMC_ERR_NONE
;
465 * Wait for the request to complete.
468 status
= wbsd_read_index(host
, WBSD_IDX_STATUS
);
469 } while (status
& WBSD_CARDTRAFFIC
);
472 * Do we expect a reply?
474 if ((cmd
->flags
& MMC_RSP_MASK
) != MMC_RSP_NONE
)
482 if (isr
& WBSD_INT_CARD
)
483 cmd
->error
= MMC_ERR_TIMEOUT
;
485 else if (isr
& WBSD_INT_TIMEOUT
)
486 cmd
->error
= MMC_ERR_TIMEOUT
;
488 else if ((cmd
->flags
& MMC_RSP_CRC
) && (isr
& WBSD_INT_CRC
))
489 cmd
->error
= MMC_ERR_BADCRC
;
493 if ((cmd
->flags
& MMC_RSP_MASK
) == MMC_RSP_SHORT
)
494 wbsd_get_short_reply(host
, cmd
);
496 wbsd_get_long_reply(host
, cmd
);
500 DBGF("Sent cmd (%x), res %d\n", cmd
->opcode
, cmd
->error
);
507 static void wbsd_empty_fifo(struct wbsd_host
* host
)
509 struct mmc_data
* data
= host
->mrq
->cmd
->data
;
514 * Handle excessive data.
516 if (data
->bytes_xfered
== host
->size
)
519 buffer
= wbsd_kmap_sg(host
) + host
->offset
;
522 * Drain the fifo. This has a tendency to loop longer
523 * than the FIFO length (usually one block).
525 while (!((fsr
= inb(host
->base
+ WBSD_FSR
)) & WBSD_FIFO_EMPTY
))
528 * The size field in the FSR is broken so we have to
531 if (fsr
& WBSD_FIFO_FULL
)
533 else if (fsr
& WBSD_FIFO_FUTHRE
)
538 for (i
= 0;i
< fifo
;i
++)
540 *buffer
= inb(host
->base
+ WBSD_DFR
);
545 data
->bytes_xfered
++;
550 if (data
->bytes_xfered
== host
->size
)
552 wbsd_kunmap_sg(host
);
557 * End of scatter list entry?
559 if (host
->remain
== 0)
561 wbsd_kunmap_sg(host
);
564 * Get next entry. Check if last.
566 if (!wbsd_next_sg(host
))
569 * We should never reach this point.
570 * It means that we're trying to
571 * transfer more blocks than can fit
572 * into the scatter list.
576 host
->size
= data
->bytes_xfered
;
581 buffer
= wbsd_kmap_sg(host
);
586 wbsd_kunmap_sg(host
);
589 * This is a very dirty hack to solve a
590 * hardware problem. The chip doesn't trigger
591 * FIFO threshold interrupts properly.
593 if ((host
->size
- data
->bytes_xfered
) < 16)
594 tasklet_schedule(&host
->fifo_tasklet
);
597 static void wbsd_fill_fifo(struct wbsd_host
* host
)
599 struct mmc_data
* data
= host
->mrq
->cmd
->data
;
604 * Check that we aren't being called after the
605 * entire buffer has been transfered.
607 if (data
->bytes_xfered
== host
->size
)
610 buffer
= wbsd_kmap_sg(host
) + host
->offset
;
613 * Fill the fifo. This has a tendency to loop longer
614 * than the FIFO length (usually one block).
616 while (!((fsr
= inb(host
->base
+ WBSD_FSR
)) & WBSD_FIFO_FULL
))
619 * The size field in the FSR is broken so we have to
622 if (fsr
& WBSD_FIFO_EMPTY
)
624 else if (fsr
& WBSD_FIFO_EMTHRE
)
629 for (i
= 16;i
> fifo
;i
--)
631 outb(*buffer
, host
->base
+ WBSD_DFR
);
636 data
->bytes_xfered
++;
641 if (data
->bytes_xfered
== host
->size
)
643 wbsd_kunmap_sg(host
);
648 * End of scatter list entry?
650 if (host
->remain
== 0)
652 wbsd_kunmap_sg(host
);
655 * Get next entry. Check if last.
657 if (!wbsd_next_sg(host
))
660 * We should never reach this point.
661 * It means that we're trying to
662 * transfer more blocks than can fit
663 * into the scatter list.
667 host
->size
= data
->bytes_xfered
;
672 buffer
= wbsd_kmap_sg(host
);
677 wbsd_kunmap_sg(host
);
680 * The controller stops sending interrupts for
681 * 'FIFO empty' under certain conditions. So we
682 * need to be a bit more pro-active.
684 tasklet_schedule(&host
->fifo_tasklet
);
687 static void wbsd_prepare_data(struct wbsd_host
* host
, struct mmc_data
* data
)
691 unsigned long dmaflags
;
693 DBGF("blksz %04x blks %04x flags %08x\n",
694 1 << data
->blksz_bits
, data
->blocks
, data
->flags
);
695 DBGF("tsac %d ms nsac %d clk\n",
696 data
->timeout_ns
/ 1000000, data
->timeout_clks
);
701 host
->size
= data
->blocks
<< data
->blksz_bits
;
704 * Check timeout values for overflow.
705 * (Yes, some cards cause this value to overflow).
707 if (data
->timeout_ns
> 127000000)
708 wbsd_write_index(host
, WBSD_IDX_TAAC
, 127);
710 wbsd_write_index(host
, WBSD_IDX_TAAC
, data
->timeout_ns
/1000000);
712 if (data
->timeout_clks
> 255)
713 wbsd_write_index(host
, WBSD_IDX_NSAC
, 255);
715 wbsd_write_index(host
, WBSD_IDX_NSAC
, data
->timeout_clks
);
718 * Inform the chip of how large blocks will be
719 * sent. It needs this to determine when to
722 * Space for CRC must be included in the size.
723 * Two bytes are needed for each data line.
725 if (host
->bus_width
== MMC_BUS_WIDTH_1
)
727 blksize
= (1 << data
->blksz_bits
) + 2;
729 wbsd_write_index(host
, WBSD_IDX_PBSMSB
, (blksize
>> 4) & 0xF0);
730 wbsd_write_index(host
, WBSD_IDX_PBSLSB
, blksize
& 0xFF);
732 else if (host
->bus_width
== MMC_BUS_WIDTH_4
)
734 blksize
= (1 << data
->blksz_bits
) + 2 * 4;
736 wbsd_write_index(host
, WBSD_IDX_PBSMSB
, ((blksize
>> 4) & 0xF0)
738 wbsd_write_index(host
, WBSD_IDX_PBSLSB
, blksize
& 0xFF);
742 data
->error
= MMC_ERR_INVALID
;
747 * Clear the FIFO. This is needed even for DMA
748 * transfers since the chip still uses the FIFO
751 setup
= wbsd_read_index(host
, WBSD_IDX_SETUP
);
752 setup
|= WBSD_FIFO_RESET
;
753 wbsd_write_index(host
, WBSD_IDX_SETUP
, setup
);
761 * The buffer for DMA is only 64 kB.
763 BUG_ON(host
->size
> 0x10000);
764 if (host
->size
> 0x10000)
766 data
->error
= MMC_ERR_INVALID
;
771 * Transfer data from the SG list to
774 if (data
->flags
& MMC_DATA_WRITE
)
775 wbsd_sg_to_dma(host
, data
);
778 * Initialise the ISA DMA controller.
780 dmaflags
= claim_dma_lock();
781 disable_dma(host
->dma
);
782 clear_dma_ff(host
->dma
);
783 if (data
->flags
& MMC_DATA_READ
)
784 set_dma_mode(host
->dma
, DMA_MODE_READ
& ~0x40);
786 set_dma_mode(host
->dma
, DMA_MODE_WRITE
& ~0x40);
787 set_dma_addr(host
->dma
, host
->dma_addr
);
788 set_dma_count(host
->dma
, host
->size
);
790 enable_dma(host
->dma
);
791 release_dma_lock(dmaflags
);
794 * Enable DMA on the host.
796 wbsd_write_index(host
, WBSD_IDX_DMA
, WBSD_DMA_ENABLE
);
801 * This flag is used to keep printk
802 * output to a minimum.
807 * Initialise the SG list.
809 wbsd_init_sg(host
, data
);
814 wbsd_write_index(host
, WBSD_IDX_DMA
, 0);
817 * Set up FIFO threshold levels (and fill
818 * buffer if doing a write).
820 if (data
->flags
& MMC_DATA_READ
)
822 wbsd_write_index(host
, WBSD_IDX_FIFOEN
,
823 WBSD_FIFOEN_FULL
| 8);
827 wbsd_write_index(host
, WBSD_IDX_FIFOEN
,
828 WBSD_FIFOEN_EMPTY
| 8);
829 wbsd_fill_fifo(host
);
833 data
->error
= MMC_ERR_NONE
;
836 static void wbsd_finish_data(struct wbsd_host
* host
, struct mmc_data
* data
)
838 unsigned long dmaflags
;
842 WARN_ON(host
->mrq
== NULL
);
845 * Send a stop command if needed.
848 wbsd_send_command(host
, data
->stop
);
851 * Wait for the controller to leave data
856 status
= wbsd_read_index(host
, WBSD_IDX_STATUS
);
857 } while (status
& (WBSD_BLOCK_READ
| WBSD_BLOCK_WRITE
));
865 * Disable DMA on the host.
867 wbsd_write_index(host
, WBSD_IDX_DMA
, 0);
870 * Turn of ISA DMA controller.
872 dmaflags
= claim_dma_lock();
873 disable_dma(host
->dma
);
874 clear_dma_ff(host
->dma
);
875 count
= get_dma_residue(host
->dma
);
876 release_dma_lock(dmaflags
);
883 printk(KERN_ERR
"%s: Incomplete DMA transfer. "
885 mmc_hostname(host
->mmc
), count
);
887 data
->error
= MMC_ERR_FAILED
;
892 * Transfer data from DMA buffer to
895 if (data
->flags
& MMC_DATA_READ
)
896 wbsd_dma_to_sg(host
, data
);
898 data
->bytes_xfered
= host
->size
;
902 DBGF("Ending data transfer (%d bytes)\n", data
->bytes_xfered
);
904 wbsd_request_end(host
, host
->mrq
);
907 /*****************************************************************************\
909 * MMC layer callbacks *
911 \*****************************************************************************/
913 static void wbsd_request(struct mmc_host
* mmc
, struct mmc_request
* mrq
)
915 struct wbsd_host
* host
= mmc_priv(mmc
);
916 struct mmc_command
* cmd
;
919 * Disable tasklets to avoid a deadlock.
921 spin_lock_bh(&host
->lock
);
923 BUG_ON(host
->mrq
!= NULL
);
930 * If there is no card in the slot then
931 * timeout immediatly.
933 if (!(host
->flags
& WBSD_FCARD_PRESENT
))
935 cmd
->error
= MMC_ERR_TIMEOUT
;
940 * Does the request include data?
944 wbsd_prepare_data(host
, cmd
->data
);
946 if (cmd
->data
->error
!= MMC_ERR_NONE
)
950 wbsd_send_command(host
, cmd
);
953 * If this is a data transfer the request
954 * will be finished after the data has
957 if (cmd
->data
&& (cmd
->error
== MMC_ERR_NONE
))
960 * Dirty fix for hardware bug.
963 tasklet_schedule(&host
->fifo_tasklet
);
965 spin_unlock_bh(&host
->lock
);
971 wbsd_request_end(host
, mrq
);
973 spin_unlock_bh(&host
->lock
);
976 static void wbsd_set_ios(struct mmc_host
* mmc
, struct mmc_ios
* ios
)
978 struct wbsd_host
* host
= mmc_priv(mmc
);
981 DBGF("clock %uHz busmode %u powermode %u cs %u Vdd %u width %u\n",
982 ios
->clock
, ios
->bus_mode
, ios
->power_mode
, ios
->chip_select
,
983 ios
->vdd
, ios
->bus_width
);
985 spin_lock_bh(&host
->lock
);
988 * Reset the chip on each power off.
989 * Should clear out any weird states.
991 if (ios
->power_mode
== MMC_POWER_OFF
)
992 wbsd_init_device(host
);
994 if (ios
->clock
>= 24000000)
996 else if (ios
->clock
>= 16000000)
998 else if (ios
->clock
>= 12000000)
1001 clk
= WBSD_CLK_375K
;
1004 * Only write to the clock register when
1005 * there is an actual change.
1007 if (clk
!= host
->clk
)
1009 wbsd_write_index(host
, WBSD_IDX_CLK
, clk
);
1016 if (ios
->power_mode
!= MMC_POWER_OFF
)
1018 pwr
= inb(host
->base
+ WBSD_CSR
);
1019 pwr
&= ~WBSD_POWER_N
;
1020 outb(pwr
, host
->base
+ WBSD_CSR
);
1024 * MMC cards need to have pin 1 high during init.
1025 * It wreaks havoc with the card detection though so
1026 * that needs to be disabled.
1028 setup
= wbsd_read_index(host
, WBSD_IDX_SETUP
);
1029 if (ios
->chip_select
== MMC_CS_HIGH
)
1031 BUG_ON(ios
->bus_width
!= MMC_BUS_WIDTH_1
);
1032 setup
|= WBSD_DAT3_H
;
1033 host
->flags
|= WBSD_FIGNORE_DETECT
;
1037 if (setup
& WBSD_DAT3_H
)
1039 setup
&= ~WBSD_DAT3_H
;
1042 * We cannot resume card detection immediatly
1043 * because of capacitance and delays in the chip.
1045 mod_timer(&host
->ignore_timer
, jiffies
+ HZ
/100);
1048 wbsd_write_index(host
, WBSD_IDX_SETUP
, setup
);
1051 * Store bus width for later. Will be used when
1052 * setting up the data transfer.
1054 host
->bus_width
= ios
->bus_width
;
1056 spin_unlock_bh(&host
->lock
);
1059 static int wbsd_get_ro(struct mmc_host
* mmc
)
1061 struct wbsd_host
* host
= mmc_priv(mmc
);
1064 spin_lock_bh(&host
->lock
);
1066 csr
= inb(host
->base
+ WBSD_CSR
);
1068 outb(csr
, host
->base
+ WBSD_CSR
);
1072 csr
= inb(host
->base
+ WBSD_CSR
);
1074 outb(csr
, host
->base
+ WBSD_CSR
);
1076 spin_unlock_bh(&host
->lock
);
1078 return csr
& WBSD_WRPT
;
1081 static struct mmc_host_ops wbsd_ops
= {
1082 .request
= wbsd_request
,
1083 .set_ios
= wbsd_set_ios
,
1084 .get_ro
= wbsd_get_ro
,
1087 /*****************************************************************************\
1089 * Interrupt handling *
1091 \*****************************************************************************/
1094 * Helper function to reset detection ignore
1097 static void wbsd_reset_ignore(unsigned long data
)
1099 struct wbsd_host
*host
= (struct wbsd_host
*)data
;
1101 BUG_ON(host
== NULL
);
1103 DBG("Resetting card detection ignore\n");
1105 spin_lock_bh(&host
->lock
);
1107 host
->flags
&= ~WBSD_FIGNORE_DETECT
;
1110 * Card status might have changed during the
1113 tasklet_schedule(&host
->card_tasklet
);
1115 spin_unlock_bh(&host
->lock
);
1122 static inline struct mmc_data
* wbsd_get_data(struct wbsd_host
* host
)
1124 WARN_ON(!host
->mrq
);
1128 WARN_ON(!host
->mrq
->cmd
);
1129 if (!host
->mrq
->cmd
)
1132 WARN_ON(!host
->mrq
->cmd
->data
);
1133 if (!host
->mrq
->cmd
->data
)
1136 return host
->mrq
->cmd
->data
;
1139 static void wbsd_tasklet_card(unsigned long param
)
1141 struct wbsd_host
* host
= (struct wbsd_host
*)param
;
1145 spin_lock(&host
->lock
);
1147 if (host
->flags
& WBSD_FIGNORE_DETECT
)
1149 spin_unlock(&host
->lock
);
1153 csr
= inb(host
->base
+ WBSD_CSR
);
1154 WARN_ON(csr
== 0xff);
1156 if (csr
& WBSD_CARDPRESENT
)
1158 if (!(host
->flags
& WBSD_FCARD_PRESENT
))
1160 DBG("Card inserted\n");
1161 host
->flags
|= WBSD_FCARD_PRESENT
;
1166 else if (host
->flags
& WBSD_FCARD_PRESENT
)
1168 DBG("Card removed\n");
1169 host
->flags
&= ~WBSD_FCARD_PRESENT
;
1173 printk(KERN_ERR
"%s: Card removed during transfer!\n",
1174 mmc_hostname(host
->mmc
));
1177 host
->mrq
->cmd
->error
= MMC_ERR_FAILED
;
1178 tasklet_schedule(&host
->finish_tasklet
);
1185 * Unlock first since we might get a call back.
1188 spin_unlock(&host
->lock
);
1191 mmc_detect_change(host
->mmc
, msecs_to_jiffies(delay
));
1194 static void wbsd_tasklet_fifo(unsigned long param
)
1196 struct wbsd_host
* host
= (struct wbsd_host
*)param
;
1197 struct mmc_data
* data
;
1199 spin_lock(&host
->lock
);
1204 data
= wbsd_get_data(host
);
1208 if (data
->flags
& MMC_DATA_WRITE
)
1209 wbsd_fill_fifo(host
);
1211 wbsd_empty_fifo(host
);
1216 if (host
->size
== data
->bytes_xfered
)
1218 wbsd_write_index(host
, WBSD_IDX_FIFOEN
, 0);
1219 tasklet_schedule(&host
->finish_tasklet
);
1223 spin_unlock(&host
->lock
);
1226 static void wbsd_tasklet_crc(unsigned long param
)
1228 struct wbsd_host
* host
= (struct wbsd_host
*)param
;
1229 struct mmc_data
* data
;
1231 spin_lock(&host
->lock
);
1236 data
= wbsd_get_data(host
);
1240 DBGF("CRC error\n");
1242 data
->error
= MMC_ERR_BADCRC
;
1244 tasklet_schedule(&host
->finish_tasklet
);
1247 spin_unlock(&host
->lock
);
1250 static void wbsd_tasklet_timeout(unsigned long param
)
1252 struct wbsd_host
* host
= (struct wbsd_host
*)param
;
1253 struct mmc_data
* data
;
1255 spin_lock(&host
->lock
);
1260 data
= wbsd_get_data(host
);
1266 data
->error
= MMC_ERR_TIMEOUT
;
1268 tasklet_schedule(&host
->finish_tasklet
);
1271 spin_unlock(&host
->lock
);
1274 static void wbsd_tasklet_finish(unsigned long param
)
1276 struct wbsd_host
* host
= (struct wbsd_host
*)param
;
1277 struct mmc_data
* data
;
1279 spin_lock(&host
->lock
);
1281 WARN_ON(!host
->mrq
);
1285 data
= wbsd_get_data(host
);
1289 wbsd_finish_data(host
, data
);
1292 spin_unlock(&host
->lock
);
1295 static void wbsd_tasklet_block(unsigned long param
)
1297 struct wbsd_host
* host
= (struct wbsd_host
*)param
;
1298 struct mmc_data
* data
;
1300 spin_lock(&host
->lock
);
1302 if ((wbsd_read_index(host
, WBSD_IDX_CRCSTATUS
) & WBSD_CRC_MASK
) !=
1305 data
= wbsd_get_data(host
);
1309 DBGF("CRC error\n");
1311 data
->error
= MMC_ERR_BADCRC
;
1313 tasklet_schedule(&host
->finish_tasklet
);
1317 spin_unlock(&host
->lock
);
1321 * Interrupt handling
1324 static irqreturn_t
wbsd_irq(int irq
, void *dev_id
, struct pt_regs
*regs
)
1326 struct wbsd_host
* host
= dev_id
;
1329 isr
= inb(host
->base
+ WBSD_ISR
);
1332 * Was it actually our hardware that caused the interrupt?
1334 if (isr
== 0xff || isr
== 0x00)
1340 * Schedule tasklets as needed.
1342 if (isr
& WBSD_INT_CARD
)
1343 tasklet_schedule(&host
->card_tasklet
);
1344 if (isr
& WBSD_INT_FIFO_THRE
)
1345 tasklet_schedule(&host
->fifo_tasklet
);
1346 if (isr
& WBSD_INT_CRC
)
1347 tasklet_hi_schedule(&host
->crc_tasklet
);
1348 if (isr
& WBSD_INT_TIMEOUT
)
1349 tasklet_hi_schedule(&host
->timeout_tasklet
);
1350 if (isr
& WBSD_INT_BUSYEND
)
1351 tasklet_hi_schedule(&host
->block_tasklet
);
1352 if (isr
& WBSD_INT_TC
)
1353 tasklet_schedule(&host
->finish_tasklet
);
1358 /*****************************************************************************\
1360 * Device initialisation and shutdown *
1362 \*****************************************************************************/
1365 * Allocate/free MMC structure.
1368 static int __devinit
wbsd_alloc_mmc(struct device
* dev
)
1370 struct mmc_host
* mmc
;
1371 struct wbsd_host
* host
;
1374 * Allocate MMC structure.
1376 mmc
= mmc_alloc_host(sizeof(struct wbsd_host
), dev
);
1380 host
= mmc_priv(mmc
);
1386 * Set host parameters.
1388 mmc
->ops
= &wbsd_ops
;
1389 mmc
->f_min
= 375000;
1390 mmc
->f_max
= 24000000;
1391 mmc
->ocr_avail
= MMC_VDD_32_33
|MMC_VDD_33_34
;
1392 mmc
->caps
= MMC_CAP_4_BIT_DATA
;
1394 spin_lock_init(&host
->lock
);
1399 init_timer(&host
->ignore_timer
);
1400 host
->ignore_timer
.data
= (unsigned long)host
;
1401 host
->ignore_timer
.function
= wbsd_reset_ignore
;
1404 * Maximum number of segments. Worst case is one sector per segment
1405 * so this will be 64kB/512.
1407 mmc
->max_hw_segs
= 128;
1408 mmc
->max_phys_segs
= 128;
1411 * Maximum number of sectors in one transfer. Also limited by 64kB
1414 mmc
->max_sectors
= 128;
1417 * Maximum segment size. Could be one segment with the maximum number
1420 mmc
->max_seg_size
= mmc
->max_sectors
* 512;
1422 dev_set_drvdata(dev
, mmc
);
1427 static void __devexit
wbsd_free_mmc(struct device
* dev
)
1429 struct mmc_host
* mmc
;
1430 struct wbsd_host
* host
;
1432 mmc
= dev_get_drvdata(dev
);
1436 host
= mmc_priv(mmc
);
1437 BUG_ON(host
== NULL
);
1439 del_timer_sync(&host
->ignore_timer
);
1443 dev_set_drvdata(dev
, NULL
);
1447 * Scan for known chip id:s
1450 static int __devinit
wbsd_scan(struct wbsd_host
* host
)
1456 * Iterate through all ports, all codes to
1457 * find hardware that is in our known list.
1459 for (i
= 0; i
< ARRAY_SIZE(config_ports
); i
++) {
1460 if (!request_region(config_ports
[i
], 2, DRIVER_NAME
))
1463 for (j
= 0; j
< ARRAY_SIZE(unlock_codes
); j
++) {
1466 host
->config
= config_ports
[i
];
1467 host
->unlock_code
= unlock_codes
[j
];
1469 wbsd_unlock_config(host
);
1471 outb(WBSD_CONF_ID_HI
, config_ports
[i
]);
1472 id
= inb(config_ports
[i
] + 1) << 8;
1474 outb(WBSD_CONF_ID_LO
, config_ports
[i
]);
1475 id
|= inb(config_ports
[i
] + 1);
1477 wbsd_lock_config(host
);
1479 for (k
= 0; k
< ARRAY_SIZE(valid_ids
); k
++) {
1480 if (id
== valid_ids
[k
])
1490 DBG("Unknown hardware (id %x) found at %x\n",
1491 id
, config_ports
[i
]);
1495 release_region(config_ports
[i
], 2);
1499 host
->unlock_code
= 0;
1505 * Allocate/free io port ranges
1508 static int __devinit
wbsd_request_region(struct wbsd_host
* host
, int base
)
1513 if (!request_region(base
, 8, DRIVER_NAME
))
1521 static void __devexit
wbsd_release_regions(struct wbsd_host
* host
)
1524 release_region(host
->base
, 8);
1529 release_region(host
->config
, 2);
1535 * Allocate/free DMA port and buffer
1538 static void __devinit
wbsd_request_dma(struct wbsd_host
* host
, int dma
)
1543 if (request_dma(dma
, DRIVER_NAME
))
1547 * We need to allocate a special buffer in
1548 * order for ISA to be able to DMA to it.
1550 host
->dma_buffer
= kmalloc(WBSD_DMA_SIZE
,
1551 GFP_NOIO
| GFP_DMA
| __GFP_REPEAT
| __GFP_NOWARN
);
1552 if (!host
->dma_buffer
)
1556 * Translate the address to a physical address.
1558 host
->dma_addr
= dma_map_single(host
->mmc
->dev
, host
->dma_buffer
,
1559 WBSD_DMA_SIZE
, DMA_BIDIRECTIONAL
);
1562 * ISA DMA must be aligned on a 64k basis.
1564 if ((host
->dma_addr
& 0xffff) != 0)
1567 * ISA cannot access memory above 16 MB.
1569 else if (host
->dma_addr
>= 0x1000000)
1578 * If we've gotten here then there is some kind of alignment bug
1582 dma_unmap_single(host
->mmc
->dev
, host
->dma_addr
, WBSD_DMA_SIZE
,
1584 host
->dma_addr
= (dma_addr_t
)NULL
;
1586 kfree(host
->dma_buffer
);
1587 host
->dma_buffer
= NULL
;
1593 printk(KERN_WARNING DRIVER_NAME
": Unable to allocate DMA %d. "
1594 "Falling back on FIFO.\n", dma
);
1597 static void __devexit
wbsd_release_dma(struct wbsd_host
* host
)
1600 dma_unmap_single(host
->mmc
->dev
, host
->dma_addr
, WBSD_DMA_SIZE
,
1602 kfree(host
->dma_buffer
);
1604 free_dma(host
->dma
);
1607 host
->dma_buffer
= NULL
;
1608 host
->dma_addr
= (dma_addr_t
)NULL
;
1612 * Allocate/free IRQ.
1615 static int __devinit
wbsd_request_irq(struct wbsd_host
* host
, int irq
)
1620 * Allocate interrupt.
1623 ret
= request_irq(irq
, wbsd_irq
, SA_SHIRQ
, DRIVER_NAME
, host
);
1632 tasklet_init(&host
->card_tasklet
, wbsd_tasklet_card
, (unsigned long)host
);
1633 tasklet_init(&host
->fifo_tasklet
, wbsd_tasklet_fifo
, (unsigned long)host
);
1634 tasklet_init(&host
->crc_tasklet
, wbsd_tasklet_crc
, (unsigned long)host
);
1635 tasklet_init(&host
->timeout_tasklet
, wbsd_tasklet_timeout
, (unsigned long)host
);
1636 tasklet_init(&host
->finish_tasklet
, wbsd_tasklet_finish
, (unsigned long)host
);
1637 tasklet_init(&host
->block_tasklet
, wbsd_tasklet_block
, (unsigned long)host
);
1642 static void __devexit
wbsd_release_irq(struct wbsd_host
* host
)
1647 free_irq(host
->irq
, host
);
1651 tasklet_kill(&host
->card_tasklet
);
1652 tasklet_kill(&host
->fifo_tasklet
);
1653 tasklet_kill(&host
->crc_tasklet
);
1654 tasklet_kill(&host
->timeout_tasklet
);
1655 tasklet_kill(&host
->finish_tasklet
);
1656 tasklet_kill(&host
->block_tasklet
);
1660 * Allocate all resources for the host.
1663 static int __devinit
wbsd_request_resources(struct wbsd_host
* host
,
1664 int base
, int irq
, int dma
)
1669 * Allocate I/O ports.
1671 ret
= wbsd_request_region(host
, base
);
1676 * Allocate interrupt.
1678 ret
= wbsd_request_irq(host
, irq
);
1685 wbsd_request_dma(host
, dma
);
1691 * Release all resources for the host.
1694 static void __devexit
wbsd_release_resources(struct wbsd_host
* host
)
1696 wbsd_release_dma(host
);
1697 wbsd_release_irq(host
);
1698 wbsd_release_regions(host
);
1702 * Configure the resources the chip should use.
1705 static void wbsd_chip_config(struct wbsd_host
* host
)
1707 wbsd_unlock_config(host
);
1712 wbsd_write_config(host
, WBSD_CONF_SWRST
, 1);
1713 wbsd_write_config(host
, WBSD_CONF_SWRST
, 0);
1716 * Select SD/MMC function.
1718 wbsd_write_config(host
, WBSD_CONF_DEVICE
, DEVICE_SD
);
1721 * Set up card detection.
1723 wbsd_write_config(host
, WBSD_CONF_PINS
, WBSD_PINS_DETECT_GP11
);
1728 wbsd_write_config(host
, WBSD_CONF_PORT_HI
, host
->base
>> 8);
1729 wbsd_write_config(host
, WBSD_CONF_PORT_LO
, host
->base
& 0xff);
1731 wbsd_write_config(host
, WBSD_CONF_IRQ
, host
->irq
);
1734 wbsd_write_config(host
, WBSD_CONF_DRQ
, host
->dma
);
1737 * Enable and power up chip.
1739 wbsd_write_config(host
, WBSD_CONF_ENABLE
, 1);
1740 wbsd_write_config(host
, WBSD_CONF_POWER
, 0x20);
1742 wbsd_lock_config(host
);
1746 * Check that configured resources are correct.
1749 static int wbsd_chip_validate(struct wbsd_host
* host
)
1753 wbsd_unlock_config(host
);
1756 * Select SD/MMC function.
1758 wbsd_write_config(host
, WBSD_CONF_DEVICE
, DEVICE_SD
);
1761 * Read configuration.
1763 base
= wbsd_read_config(host
, WBSD_CONF_PORT_HI
) << 8;
1764 base
|= wbsd_read_config(host
, WBSD_CONF_PORT_LO
);
1766 irq
= wbsd_read_config(host
, WBSD_CONF_IRQ
);
1768 dma
= wbsd_read_config(host
, WBSD_CONF_DRQ
);
1770 wbsd_lock_config(host
);
1773 * Validate against given configuration.
1775 if (base
!= host
->base
)
1777 if (irq
!= host
->irq
)
1779 if ((dma
!= host
->dma
) && (host
->dma
!= -1))
1786 * Powers down the SD function
1789 static void wbsd_chip_poweroff(struct wbsd_host
* host
)
1791 wbsd_unlock_config(host
);
1793 wbsd_write_config(host
, WBSD_CONF_DEVICE
, DEVICE_SD
);
1794 wbsd_write_config(host
, WBSD_CONF_ENABLE
, 0);
1796 wbsd_lock_config(host
);
1799 /*****************************************************************************\
1801 * Devices setup and shutdown *
1803 \*****************************************************************************/
1805 static int __devinit
wbsd_init(struct device
* dev
, int base
, int irq
, int dma
,
1808 struct wbsd_host
* host
= NULL
;
1809 struct mmc_host
* mmc
= NULL
;
1812 ret
= wbsd_alloc_mmc(dev
);
1816 mmc
= dev_get_drvdata(dev
);
1817 host
= mmc_priv(mmc
);
1820 * Scan for hardware.
1822 ret
= wbsd_scan(host
);
1825 if (pnp
&& (ret
== -ENODEV
))
1827 printk(KERN_WARNING DRIVER_NAME
1828 ": Unable to confirm device presence. You may "
1829 "experience lock-ups.\n");
1839 * Request resources.
1841 ret
= wbsd_request_resources(host
, io
, irq
, dma
);
1844 wbsd_release_resources(host
);
1850 * See if chip needs to be configured.
1854 if ((host
->config
!= 0) && !wbsd_chip_validate(host
))
1856 printk(KERN_WARNING DRIVER_NAME
1857 ": PnP active but chip not configured! "
1858 "You probably have a buggy BIOS. "
1859 "Configuring chip manually.\n");
1860 wbsd_chip_config(host
);
1864 wbsd_chip_config(host
);
1867 * Power Management stuff. No idea how this works.
1873 wbsd_unlock_config(host
);
1874 wbsd_write_config(host
, WBSD_CONF_PME
, 0xA0);
1875 wbsd_lock_config(host
);
1879 * Allow device to initialise itself properly.
1884 * Reset the chip into a known state.
1886 wbsd_init_device(host
);
1890 printk(KERN_INFO
"%s: W83L51xD", mmc_hostname(mmc
));
1891 if (host
->chip_id
!= 0)
1892 printk(" id %x", (int)host
->chip_id
);
1893 printk(" at 0x%x irq %d", (int)host
->base
, (int)host
->irq
);
1895 printk(" dma %d", (int)host
->dma
);
1905 static void __devexit
wbsd_shutdown(struct device
* dev
, int pnp
)
1907 struct mmc_host
* mmc
= dev_get_drvdata(dev
);
1908 struct wbsd_host
* host
;
1913 host
= mmc_priv(mmc
);
1915 mmc_remove_host(mmc
);
1918 * Power down the SD/MMC function.
1921 wbsd_chip_poweroff(host
);
1923 wbsd_release_resources(host
);
1932 static int __devinit
wbsd_probe(struct platform_device
* dev
)
1934 return wbsd_init(&dev
->dev
, io
, irq
, dma
, 0);
1937 static int __devexit
wbsd_remove(struct platform_device
* dev
)
1939 wbsd_shutdown(&dev
->dev
, 0);
1950 static int __devinit
1951 wbsd_pnp_probe(struct pnp_dev
* pnpdev
, const struct pnp_device_id
*dev_id
)
1956 * Get resources from PnP layer.
1958 io
= pnp_port_start(pnpdev
, 0);
1959 irq
= pnp_irq(pnpdev
, 0);
1960 if (pnp_dma_valid(pnpdev
, 0))
1961 dma
= pnp_dma(pnpdev
, 0);
1965 DBGF("PnP resources: port %3x irq %d dma %d\n", io
, irq
, dma
);
1967 return wbsd_init(&pnpdev
->dev
, io
, irq
, dma
, 1);
1970 static void __devexit
wbsd_pnp_remove(struct pnp_dev
* dev
)
1972 wbsd_shutdown(&dev
->dev
, 1);
1975 #endif /* CONFIG_PNP */
1983 static int wbsd_suspend(struct platform_device
*dev
, pm_message_t state
)
1985 struct mmc_host
*mmc
= platform_get_drvdata(dev
);
1986 struct wbsd_host
*host
;
1992 DBG("Suspending...\n");
1994 ret
= mmc_suspend_host(mmc
, state
);
1998 host
= mmc_priv(mmc
);
2000 wbsd_chip_poweroff(host
);
2005 static int wbsd_resume(struct platform_device
*dev
)
2007 struct mmc_host
*mmc
= platform_get_drvdata(dev
);
2008 struct wbsd_host
*host
;
2013 DBG("Resuming...\n");
2015 host
= mmc_priv(mmc
);
2017 wbsd_chip_config(host
);
2020 * Allow device to initialise itself properly.
2024 wbsd_init_device(host
);
2026 return mmc_resume_host(mmc
);
2029 #else /* CONFIG_PM */
2031 #define wbsd_suspend NULL
2032 #define wbsd_resume NULL
2034 #endif /* CONFIG_PM */
2036 static struct platform_device
*wbsd_device
;
2038 static struct platform_driver wbsd_driver
= {
2039 .probe
= wbsd_probe
,
2040 .remove
= __devexit_p(wbsd_remove
),
2042 .suspend
= wbsd_suspend
,
2043 .resume
= wbsd_resume
,
2045 .name
= DRIVER_NAME
,
2051 static struct pnp_driver wbsd_pnp_driver
= {
2052 .name
= DRIVER_NAME
,
2053 .id_table
= pnp_dev_table
,
2054 .probe
= wbsd_pnp_probe
,
2055 .remove
= __devexit_p(wbsd_pnp_remove
),
2058 #endif /* CONFIG_PNP */
2061 * Module loading/unloading
2064 static int __init
wbsd_drv_init(void)
2068 printk(KERN_INFO DRIVER_NAME
2069 ": Winbond W83L51xD SD/MMC card interface driver, "
2070 DRIVER_VERSION
"\n");
2071 printk(KERN_INFO DRIVER_NAME
": Copyright(c) Pierre Ossman\n");
2077 result
= pnp_register_driver(&wbsd_pnp_driver
);
2082 #endif /* CONFIG_PNP */
2086 result
= platform_driver_register(&wbsd_driver
);
2090 wbsd_device
= platform_device_alloc(DRIVER_NAME
, -1);
2093 platform_driver_unregister(&wbsd_driver
);
2097 result
= platform_device_add(wbsd_device
);
2100 platform_device_put(wbsd_device
);
2101 platform_driver_unregister(&wbsd_driver
);
2109 static void __exit
wbsd_drv_exit(void)
2114 pnp_unregister_driver(&wbsd_pnp_driver
);
2116 #endif /* CONFIG_PNP */
2120 platform_device_unregister(wbsd_device
);
2122 platform_driver_unregister(&wbsd_driver
);
2128 module_init(wbsd_drv_init
);
2129 module_exit(wbsd_drv_exit
);
2131 module_param(nopnp
, uint
, 0444);
2133 module_param(io
, uint
, 0444);
2134 module_param(irq
, uint
, 0444);
2135 module_param(dma
, int, 0444);
2137 MODULE_LICENSE("GPL");
2138 MODULE_AUTHOR("Pierre Ossman <drzeus@drzeus.cx>");
2139 MODULE_DESCRIPTION("Winbond W83L51xD SD/MMC card interface driver");
2140 MODULE_VERSION(DRIVER_VERSION
);
2143 MODULE_PARM_DESC(nopnp
, "Scan for device instead of relying on PNP. (default 0)");
2145 MODULE_PARM_DESC(io
, "I/O base to allocate. Must be 8 byte aligned. (default 0x248)");
2146 MODULE_PARM_DESC(irq
, "IRQ to allocate. (default 6)");
2147 MODULE_PARM_DESC(dma
, "DMA channel to allocate. -1 for no DMA. (default 2)");