sdio

package
v0.0.0-...-3d984ba Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 29, 2018 License: BSD-3-Clause Imports: 4 Imported by: 0

Documentation

Overview

Package sdio provides interface to SD host Interface.

Peripheral: SDIO_Periph SD host Interface. Instances: 

SDIO  mmap.SDIO_BASE

Registers: 

0x00 32  POWER
0x04 32  CLKCR
0x08 32  ARG
0x0C 32  CMD
0x10 32  RESPCMD
0x14 32  RESP[4] Response registers.
0x24 32  DTIMER
0x28 32  DLEN
0x2C 32  DCTRL
0x30 32  DCOUNT
0x34 32  STA
0x38 32  ICR
0x3C 32  MASK
0x48 32  FIFOCNT
0x80 32  FIFO

Import: 

stm32/o/f10x_md/mmap

Index

Constants

View Source 
const (
	CLKDIVn  = 0
	CLKENn   = 8
	PWRSAVn  = 9
	BYPASSn  = 10
	WIDBUSn  = 11
	NEGEDGEn = 13
	HWFC_ENn = 14
)
View Source 
const (
	CMDINDEXn    = 0
	WAITRESPn    = 6
	WAITINTn     = 8
	WAITPENDn    = 9
	CPSMENn      = 10
	SDIOSUSPENDn = 11
	ENCMDCOMPLn  = 12
	NIENn        = 13
	CEATACMDn    = 14
)
View Source 
const (
	DTENn       = 0
	DTDIRn      = 1
	DTMODEn     = 2
	DMAENn      = 3
	DBLOCKSIZEn = 4
	RWSTARTn    = 8
	RWSTOPn     = 9
	RWMODn      = 10
	SDIOENn     = 11
)
View Source 
const (
	CCRCFAILn = 0
	DCRCFAILn = 1
	CTIMEOUTn = 2
	DTIMEOUTn = 3
	TXUNDERRn = 4
	RXOVERRn  = 5
	CMDRENDn  = 6
	CMDSENTn  = 7
	DATAENDn  = 8
	STBITERRn = 9
	DBCKENDn  = 10
	CMDACTn   = 11
	TXACTn    = 12
	RXACTn    = 13
	TXFIFOHEn = 14
	RXFIFOHFn = 15
	TXFIFOFn  = 16
	RXFIFOFn  = 17
	TXFIFOEn  = 18
	RXFIFOEn  = 19
	TXDAVLn   = 20
	RXDAVLn   = 21
	SDIOITn   = 22
	CEATAENDn = 23
)
View Source 
const (
	CCRCFAILCn = 0
	DCRCFAILCn = 1
	CTIMEOUTCn = 2
	DTIMEOUTCn = 3
	TXUNDERRCn = 4
	RXOVERRCn  = 5
	CMDRENDCn  = 6
	CMDSENTCn  = 7
	DATAENDCn  = 8
	STBITERRCn = 9
	DBCKENDCn  = 10
	SDIOITCn   = 22
	CEATAENDCn = 23
)
View Source 
const (
	CCRCFAILIEn = 0
	DCRCFAILIEn = 1
	CTIMEOUTIEn = 2
	DTIMEOUTIEn = 3
	TXUNDERRIEn = 4
	RXOVERRIEn  = 5
	CMDRENDIEn  = 6
	CMDSENTIEn  = 7
	DATAENDIEn  = 8
	STBITERRIEn = 9
	DBCKENDIEn  = 10
	CMDACTIEn   = 11
	TXACTIEn    = 12
	RXACTIEn    = 13
	TXFIFOHEIEn = 14
	RXFIFOHFIEn = 15
	TXFIFOFIEn  = 16
	RXFIFOFIEn  = 17
	TXFIFOEIEn  = 18
	RXFIFOEIEn  = 19
	TXDAVLIEn   = 20
	RXDAVLIEn   = 21
	SDIOITIEn   = 22
	CEATAENDIEn = 23
)
View Source 
const (
	CARDSTATUS1n = 0
)
View Source 
const (
	CMDARGn = 0
)
View Source 
const (
	DATACOUNTn = 0
)
View Source 
const (
	DATALENGTHn = 0
)
View Source 
const (
	DATATIMEn = 0
)
View Source 
const (
	FIFOCOUNTn = 0
)
View Source 
const (
	FIFODATAn = 0
)
View Source 
const (
	PWRCTRLn = 0
)

Variables

View Source 
var SDIO = (*SDIO_Periph)(unsafe.Pointer(uintptr(mmap.SDIO_BASE)))

Functions

This section is empty.

Types

type ARG 

type ARG uint32
const (
	CMDARG ARG = 0xFFFFFFFF << 0 //+ Command argument.
)

func (ARG) Field 

func (b ARG) Field(mask ARG) int

func (ARG) J 

func (mask ARG) J(v int) ARG

type CLKCR 

type CLKCR uint32
const (
	CLKDIV   CLKCR = 0xFF << 0  //+ Clock divide factor.
	CLKEN    CLKCR = 0x01 << 8  //+ Clock enable bit.
	PWRSAV   CLKCR = 0x01 << 9  //+ Power saving configuration bit.
	BYPASS   CLKCR = 0x01 << 10 //+ Clock divider bypass enable bit.
	WIDBUS   CLKCR = 0x03 << 11 //+ WIDBUS[1:0] bits (Wide bus mode enable bit).
	WIDBUS_0 CLKCR = 0x01 << 11 //  Bit 0.
	WIDBUS_1 CLKCR = 0x02 << 11 //  Bit 1.
	NEGEDGE  CLKCR = 0x01 << 13 //+ SDIO_CK dephasing selection bit.
	HWFC_EN  CLKCR = 0x01 << 14 //+ HW Flow Control enable.
)

func (CLKCR) Field 

func (b CLKCR) Field(mask CLKCR) int

func (CLKCR) J 

func (mask CLKCR) J(v int) CLKCR

type CMD 

type CMD uint32
const (
	CMDINDEX    CMD = 0x3F << 0  //+ Command Index.
	WAITRESP    CMD = 0x03 << 6  //+ WAITRESP[1:0] bits (Wait for response bits).
	WAITRESP_0  CMD = 0x01 << 6  //  Bit 0.
	WAITRESP_1  CMD = 0x02 << 6  //  Bit 1.
	WAITINT     CMD = 0x01 << 8  //+ CPSM Waits for Interrupt Request.
	WAITPEND    CMD = 0x01 << 9  //+ CPSM Waits for ends of data transfer (CmdPend internal signal).
	CPSMEN      CMD = 0x01 << 10 //+ Command path state machine (CPSM) Enable bit.
	SDIOSUSPEND CMD = 0x01 << 11 //+ SD I/O suspend command.
	ENCMDCOMPL  CMD = 0x01 << 12 //+ Enable CMD completion.
	NIEN        CMD = 0x01 << 13 //+ Not Interrupt Enable.
	CEATACMD    CMD = 0x01 << 14 //+ CE-ATA command.
)

func (CMD) Field 

func (b CMD) Field(mask CMD) int

func (CMD) J 

func (mask CMD) J(v int) CMD

type DCOUNT 

type DCOUNT uint32
const (
	DATACOUNT DCOUNT = 0x1FFFFFF << 0 //+ Data count value.
)

func (DCOUNT) Field 

func (b DCOUNT) Field(mask DCOUNT) int

func (DCOUNT) J 

func (mask DCOUNT) J(v int) DCOUNT

type DCTRL 

type DCTRL uint32
const (
	DTEN         DCTRL = 0x01 << 0  //+ Data transfer enabled bit.
	DTDIR        DCTRL = 0x01 << 1  //+ Data transfer direction selection.
	DTMODE       DCTRL = 0x01 << 2  //+ Data transfer mode selection.
	DMAEN        DCTRL = 0x01 << 3  //+ DMA enabled bit.
	DBLOCKSIZE   DCTRL = 0x0F << 4  //+ DBLOCKSIZE[3:0] bits (Data block size).
	DBLOCKSIZE_0 DCTRL = 0x01 << 4  //  Bit 0.
	DBLOCKSIZE_1 DCTRL = 0x02 << 4  //  Bit 1.
	DBLOCKSIZE_2 DCTRL = 0x04 << 4  //  Bit 2.
	DBLOCKSIZE_3 DCTRL = 0x08 << 4  //  Bit 3.
	RWSTART      DCTRL = 0x01 << 8  //+ Read wait start.
	RWSTOP       DCTRL = 0x01 << 9  //+ Read wait stop.
	RWMOD        DCTRL = 0x01 << 10 //+ Read wait mode.
	SDIOEN       DCTRL = 0x01 << 11 //+ SD I/O enable functions.
)

func (DCTRL) Field 

func (b DCTRL) Field(mask DCTRL) int

func (DCTRL) J 

func (mask DCTRL) J(v int) DCTRL

type DLEN 

type DLEN uint32
const (
	DATALENGTH DLEN = 0x1FFFFFF << 0 //+ Data length value.
)

func (DLEN) Field 

func (b DLEN) Field(mask DLEN) int

func (DLEN) J 

func (mask DLEN) J(v int) DLEN

type DTIMER 

type DTIMER uint32
const (
	DATATIME DTIMER = 0xFFFFFFFF << 0 //+ Data timeout period..
)

func (DTIMER) Field 

func (b DTIMER) Field(mask DTIMER) int

func (DTIMER) J 

func (mask DTIMER) J(v int) DTIMER

type FIFO 

type FIFO uint32
const (
	FIFODATA FIFO = 0xFFFFFFFF << 0 //+ Receive and transmit FIFO data.
)

func (FIFO) Field 

func (b FIFO) Field(mask FIFO) int

func (FIFO) J 

func (mask FIFO) J(v int) FIFO

type FIFOCNT 

type FIFOCNT uint32
const (
	FIFOCOUNT FIFOCNT = 0xFFFFFF << 0 //+ Remaining number of words to be written to or read from the FIFO.
)

func (FIFOCNT) Field 

func (b FIFOCNT) Field(mask FIFOCNT) int

func (FIFOCNT) J 

func (mask FIFOCNT) J(v int) FIFOCNT

type ICR 

type ICR uint32
const (
	CCRCFAILC ICR = 0x01 << 0  //+ CCRCFAIL flag clear bit.
	DCRCFAILC ICR = 0x01 << 1  //+ DCRCFAIL flag clear bit.
	CTIMEOUTC ICR = 0x01 << 2  //+ CTIMEOUT flag clear bit.
	DTIMEOUTC ICR = 0x01 << 3  //+ DTIMEOUT flag clear bit.
	TXUNDERRC ICR = 0x01 << 4  //+ TXUNDERR flag clear bit.
	RXOVERRC  ICR = 0x01 << 5  //+ RXOVERR flag clear bit.
	CMDRENDC  ICR = 0x01 << 6  //+ CMDREND flag clear bit.
	CMDSENTC  ICR = 0x01 << 7  //+ CMDSENT flag clear bit.
	DATAENDC  ICR = 0x01 << 8  //+ DATAEND flag clear bit.
	STBITERRC ICR = 0x01 << 9  //+ STBITERR flag clear bit.
	DBCKENDC  ICR = 0x01 << 10 //+ DBCKEND flag clear bit.
	SDIOITC   ICR = 0x01 << 22 //+ SDIOIT flag clear bit.
	CEATAENDC ICR = 0x01 << 23 //+ CEATAEND flag clear bit.
)

func (ICR) Field 

func (b ICR) Field(mask ICR) int

func (ICR) J 

func (mask ICR) J(v int) ICR

type MASK 

type MASK uint32
const (
	CCRCFAILIE MASK = 0x01 << 0  //+ Command CRC Fail Interrupt Enable.
	DCRCFAILIE MASK = 0x01 << 1  //+ Data CRC Fail Interrupt Enable.
	CTIMEOUTIE MASK = 0x01 << 2  //+ Command TimeOut Interrupt Enable.
	DTIMEOUTIE MASK = 0x01 << 3  //+ Data TimeOut Interrupt Enable.
	TXUNDERRIE MASK = 0x01 << 4  //+ Tx FIFO UnderRun Error Interrupt Enable.
	RXOVERRIE  MASK = 0x01 << 5  //+ Rx FIFO OverRun Error Interrupt Enable.
	CMDRENDIE  MASK = 0x01 << 6  //+ Command Response Received Interrupt Enable.
	CMDSENTIE  MASK = 0x01 << 7  //+ Command Sent Interrupt Enable.
	DATAENDIE  MASK = 0x01 << 8  //+ Data End Interrupt Enable.
	STBITERRIE MASK = 0x01 << 9  //+ Start Bit Error Interrupt Enable.
	DBCKENDIE  MASK = 0x01 << 10 //+ Data Block End Interrupt Enable.
	CMDACTIE   MASK = 0x01 << 11 //+ Command Acting Interrupt Enable.
	TXACTIE    MASK = 0x01 << 12 //+ Data Transmit Acting Interrupt Enable.
	RXACTIE    MASK = 0x01 << 13 //+ Data receive acting interrupt enabled.
	TXFIFOHEIE MASK = 0x01 << 14 //+ Tx FIFO Half Empty interrupt Enable.
	RXFIFOHFIE MASK = 0x01 << 15 //+ Rx FIFO Half Full interrupt Enable.
	TXFIFOFIE  MASK = 0x01 << 16 //+ Tx FIFO Full interrupt Enable.
	RXFIFOFIE  MASK = 0x01 << 17 //+ Rx FIFO Full interrupt Enable.
	TXFIFOEIE  MASK = 0x01 << 18 //+ Tx FIFO Empty interrupt Enable.
	RXFIFOEIE  MASK = 0x01 << 19 //+ Rx FIFO Empty interrupt Enable.
	TXDAVLIE   MASK = 0x01 << 20 //+ Data available in Tx FIFO interrupt Enable.
	RXDAVLIE   MASK = 0x01 << 21 //+ Data available in Rx FIFO interrupt Enable.
	SDIOITIE   MASK = 0x01 << 22 //+ SDIO Mode Interrupt Received interrupt Enable.
	CEATAENDIE MASK = 0x01 << 23 //+ CE-ATA command completion signal received Interrupt Enable.
)

func (MASK) Field 

func (b MASK) Field(mask MASK) int

func (MASK) J 

func (mask MASK) J(v int) MASK

type POWER 

type POWER uint32
const (
	PWRCTRL   POWER = 0x03 << 0 //+ PWRCTRL[1:0] bits (Power supply control bits).
	PWRCTRL_0 POWER = 0x01 << 0 //  Bit 0.
	PWRCTRL_1 POWER = 0x02 << 0 //  Bit 1.
)

func (POWER) Field 

func (b POWER) Field(mask POWER) int

func (POWER) J 

func (mask POWER) J(v int) POWER

type RARG 

type RARG struct{ mmio.U32 }

func (*RARG) AtomicClearBits 

func (r *RARG) AtomicClearBits(mask ARG)

func (*RARG) AtomicSetBits 

func (r *RARG) AtomicSetBits(mask ARG)

func (*RARG) AtomicStoreBits 

func (r *RARG) AtomicStoreBits(mask, b ARG)

func (*RARG) Bits 

func (r *RARG) Bits(mask ARG) ARG

func (*RARG) ClearBits 

func (r *RARG) ClearBits(mask ARG)

func (*RARG) Load 

func (r *RARG) Load() ARG

func (*RARG) SetBits 

func (r *RARG) SetBits(mask ARG)

func (*RARG) Store 

func (r *RARG) Store(b ARG)

func (*RARG) StoreBits 

func (r *RARG) StoreBits(mask, b ARG)

type RCLKCR 

type RCLKCR struct{ mmio.U32 }

func (*RCLKCR) AtomicClearBits 

func (r *RCLKCR) AtomicClearBits(mask CLKCR)

func (*RCLKCR) AtomicSetBits 

func (r *RCLKCR) AtomicSetBits(mask CLKCR)

func (*RCLKCR) AtomicStoreBits 

func (r *RCLKCR) AtomicStoreBits(mask, b CLKCR)

func (*RCLKCR) Bits 

func (r *RCLKCR) Bits(mask CLKCR) CLKCR

func (*RCLKCR) ClearBits 

func (r *RCLKCR) ClearBits(mask CLKCR)

func (*RCLKCR) Load 

func (r *RCLKCR) Load() CLKCR

func (*RCLKCR) SetBits 

func (r *RCLKCR) SetBits(mask CLKCR)

func (*RCLKCR) Store 

func (r *RCLKCR) Store(b CLKCR)

func (*RCLKCR) StoreBits 

func (r *RCLKCR) StoreBits(mask, b CLKCR)

type RCMD 

type RCMD struct{ mmio.U32 }

func (*RCMD) AtomicClearBits 

func (r *RCMD) AtomicClearBits(mask CMD)

func (*RCMD) AtomicSetBits 

func (r *RCMD) AtomicSetBits(mask CMD)

func (*RCMD) AtomicStoreBits 

func (r *RCMD) AtomicStoreBits(mask, b CMD)

func (*RCMD) Bits 

func (r *RCMD) Bits(mask CMD) CMD

func (*RCMD) ClearBits 

func (r *RCMD) ClearBits(mask CMD)

func (*RCMD) Load 

func (r *RCMD) Load() CMD

func (*RCMD) SetBits 

func (r *RCMD) SetBits(mask CMD)

func (*RCMD) Store 

func (r *RCMD) Store(b CMD)

func (*RCMD) StoreBits 

func (r *RCMD) StoreBits(mask, b CMD)

type RDCOUNT 

type RDCOUNT struct{ mmio.U32 }

func (*RDCOUNT) AtomicClearBits 

func (r *RDCOUNT) AtomicClearBits(mask DCOUNT)

func (*RDCOUNT) AtomicSetBits 

func (r *RDCOUNT) AtomicSetBits(mask DCOUNT)

func (*RDCOUNT) AtomicStoreBits 

func (r *RDCOUNT) AtomicStoreBits(mask, b DCOUNT)

func (*RDCOUNT) Bits 

func (r *RDCOUNT) Bits(mask DCOUNT) DCOUNT

func (*RDCOUNT) ClearBits 

func (r *RDCOUNT) ClearBits(mask DCOUNT)

func (*RDCOUNT) Load 

func (r *RDCOUNT) Load() DCOUNT

func (*RDCOUNT) SetBits 

func (r *RDCOUNT) SetBits(mask DCOUNT)

func (*RDCOUNT) Store 

func (r *RDCOUNT) Store(b DCOUNT)

func (*RDCOUNT) StoreBits 

func (r *RDCOUNT) StoreBits(mask, b DCOUNT)

type RDCTRL 

type RDCTRL struct{ mmio.U32 }

func (*RDCTRL) AtomicClearBits 

func (r *RDCTRL) AtomicClearBits(mask DCTRL)

func (*RDCTRL) AtomicSetBits 

func (r *RDCTRL) AtomicSetBits(mask DCTRL)

func (*RDCTRL) AtomicStoreBits 

func (r *RDCTRL) AtomicStoreBits(mask, b DCTRL)

func (*RDCTRL) Bits 

func (r *RDCTRL) Bits(mask DCTRL) DCTRL

func (*RDCTRL) ClearBits 

func (r *RDCTRL) ClearBits(mask DCTRL)

func (*RDCTRL) Load 

func (r *RDCTRL) Load() DCTRL

func (*RDCTRL) SetBits 

func (r *RDCTRL) SetBits(mask DCTRL)

func (*RDCTRL) Store 

func (r *RDCTRL) Store(b DCTRL)

func (*RDCTRL) StoreBits 

func (r *RDCTRL) StoreBits(mask, b DCTRL)

type RDLEN 

type RDLEN struct{ mmio.U32 }

func (*RDLEN) AtomicClearBits 

func (r *RDLEN) AtomicClearBits(mask DLEN)

func (*RDLEN) AtomicSetBits 

func (r *RDLEN) AtomicSetBits(mask DLEN)

func (*RDLEN) AtomicStoreBits 

func (r *RDLEN) AtomicStoreBits(mask, b DLEN)

func (*RDLEN) Bits 

func (r *RDLEN) Bits(mask DLEN) DLEN

func (*RDLEN) ClearBits 

func (r *RDLEN) ClearBits(mask DLEN)

func (*RDLEN) Load 

func (r *RDLEN) Load() DLEN

func (*RDLEN) SetBits 

func (r *RDLEN) SetBits(mask DLEN)

func (*RDLEN) Store 

func (r *RDLEN) Store(b DLEN)

func (*RDLEN) StoreBits 

func (r *RDLEN) StoreBits(mask, b DLEN)

type RDTIMER 

type RDTIMER struct{ mmio.U32 }

func (*RDTIMER) AtomicClearBits 

func (r *RDTIMER) AtomicClearBits(mask DTIMER)

func (*RDTIMER) AtomicSetBits 

func (r *RDTIMER) AtomicSetBits(mask DTIMER)

func (*RDTIMER) AtomicStoreBits 

func (r *RDTIMER) AtomicStoreBits(mask, b DTIMER)

func (*RDTIMER) Bits 

func (r *RDTIMER) Bits(mask DTIMER) DTIMER

func (*RDTIMER) ClearBits 

func (r *RDTIMER) ClearBits(mask DTIMER)

func (*RDTIMER) Load 

func (r *RDTIMER) Load() DTIMER

func (*RDTIMER) SetBits 

func (r *RDTIMER) SetBits(mask DTIMER)

func (*RDTIMER) Store 

func (r *RDTIMER) Store(b DTIMER)

func (*RDTIMER) StoreBits 

func (r *RDTIMER) StoreBits(mask, b DTIMER)

type RESP 

type RESP uint32
const (
	CARDSTATUS1 RESP = 0xFFFFFFFF << 0 //+ Card Status.
)

func (RESP) Field 

func (b RESP) Field(mask RESP) int

func (RESP) J 

func (mask RESP) J(v int) RESP

type RESPCMD 

type RESPCMD uint32

func (RESPCMD) Field 

func (b RESPCMD) Field(mask RESPCMD) int

func (RESPCMD) J 

func (mask RESPCMD) J(v int) RESPCMD

type RFIFO 

type RFIFO struct{ mmio.U32 }

func (*RFIFO) AtomicClearBits 

func (r *RFIFO) AtomicClearBits(mask FIFO)

func (*RFIFO) AtomicSetBits 

func (r *RFIFO) AtomicSetBits(mask FIFO)

func (*RFIFO) AtomicStoreBits 

func (r *RFIFO) AtomicStoreBits(mask, b FIFO)

func (*RFIFO) Bits 

func (r *RFIFO) Bits(mask FIFO) FIFO

func (*RFIFO) ClearBits 

func (r *RFIFO) ClearBits(mask FIFO)

func (*RFIFO) Load 

func (r *RFIFO) Load() FIFO

func (*RFIFO) SetBits 

func (r *RFIFO) SetBits(mask FIFO)

func (*RFIFO) Store 

func (r *RFIFO) Store(b FIFO)

func (*RFIFO) StoreBits 

func (r *RFIFO) StoreBits(mask, b FIFO)

type RFIFOCNT 

type RFIFOCNT struct{ mmio.U32 }

func (*RFIFOCNT) AtomicClearBits 

func (r *RFIFOCNT) AtomicClearBits(mask FIFOCNT)

func (*RFIFOCNT) AtomicSetBits 

func (r *RFIFOCNT) AtomicSetBits(mask FIFOCNT)

func (*RFIFOCNT) AtomicStoreBits 

func (r *RFIFOCNT) AtomicStoreBits(mask, b FIFOCNT)

func (*RFIFOCNT) Bits 

func (r *RFIFOCNT) Bits(mask FIFOCNT) FIFOCNT

func (*RFIFOCNT) ClearBits 

func (r *RFIFOCNT) ClearBits(mask FIFOCNT)

func (*RFIFOCNT) Load 

func (r *RFIFOCNT) Load() FIFOCNT

func (*RFIFOCNT) SetBits 

func (r *RFIFOCNT) SetBits(mask FIFOCNT)

func (*RFIFOCNT) Store 

func (r *RFIFOCNT) Store(b FIFOCNT)

func (*RFIFOCNT) StoreBits 

func (r *RFIFOCNT) StoreBits(mask, b FIFOCNT)

type RICR 

type RICR struct{ mmio.U32 }

func (*RICR) AtomicClearBits 

func (r *RICR) AtomicClearBits(mask ICR)

func (*RICR) AtomicSetBits 

func (r *RICR) AtomicSetBits(mask ICR)

func (*RICR) AtomicStoreBits 

func (r *RICR) AtomicStoreBits(mask, b ICR)

func (*RICR) Bits 

func (r *RICR) Bits(mask ICR) ICR

func (*RICR) ClearBits 

func (r *RICR) ClearBits(mask ICR)

func (*RICR) Load 

func (r *RICR) Load() ICR

func (*RICR) SetBits 

func (r *RICR) SetBits(mask ICR)

func (*RICR) Store 

func (r *RICR) Store(b ICR)

func (*RICR) StoreBits 

func (r *RICR) StoreBits(mask, b ICR)

type RMARG 

type RMARG struct{ mmio.UM32 }

func (RMARG) Load 

func (rm RMARG) Load() ARG

func (RMARG) Store 

func (rm RMARG) Store(b ARG)

type RMASK 

type RMASK struct{ mmio.U32 }

func (*RMASK) AtomicClearBits 

func (r *RMASK) AtomicClearBits(mask MASK)

func (*RMASK) AtomicSetBits 

func (r *RMASK) AtomicSetBits(mask MASK)

func (*RMASK) AtomicStoreBits 

func (r *RMASK) AtomicStoreBits(mask, b MASK)

func (*RMASK) Bits 

func (r *RMASK) Bits(mask MASK) MASK

func (*RMASK) ClearBits 

func (r *RMASK) ClearBits(mask MASK)

func (*RMASK) Load 

func (r *RMASK) Load() MASK

func (*RMASK) SetBits 

func (r *RMASK) SetBits(mask MASK)

func (*RMASK) Store 

func (r *RMASK) Store(b MASK)

func (*RMASK) StoreBits 

func (r *RMASK) StoreBits(mask, b MASK)

type RMCLKCR 

type RMCLKCR struct{ mmio.UM32 }

func (RMCLKCR) Load 

func (rm RMCLKCR) Load() CLKCR

func (RMCLKCR) Store 

func (rm RMCLKCR) Store(b CLKCR)

type RMCMD 

type RMCMD struct{ mmio.UM32 }

func (RMCMD) Load 

func (rm RMCMD) Load() CMD

func (RMCMD) Store 

func (rm RMCMD) Store(b CMD)

type RMDCOUNT 

type RMDCOUNT struct{ mmio.UM32 }

func (RMDCOUNT) Load 

func (rm RMDCOUNT) Load() DCOUNT

func (RMDCOUNT) Store 

func (rm RMDCOUNT) Store(b DCOUNT)

type RMDCTRL 

type RMDCTRL struct{ mmio.UM32 }

func (RMDCTRL) Load 

func (rm RMDCTRL) Load() DCTRL

func (RMDCTRL) Store 

func (rm RMDCTRL) Store(b DCTRL)

type RMDLEN 

type RMDLEN struct{ mmio.UM32 }

func (RMDLEN) Load 

func (rm RMDLEN) Load() DLEN

func (RMDLEN) Store 

func (rm RMDLEN) Store(b DLEN)

type RMDTIMER 

type RMDTIMER struct{ mmio.UM32 }

func (RMDTIMER) Load 

func (rm RMDTIMER) Load() DTIMER

func (RMDTIMER) Store 

func (rm RMDTIMER) Store(b DTIMER)

type RMFIFO 

type RMFIFO struct{ mmio.UM32 }

func (RMFIFO) Load 

func (rm RMFIFO) Load() FIFO

func (RMFIFO) Store 

func (rm RMFIFO) Store(b FIFO)

type RMFIFOCNT 

type RMFIFOCNT struct{ mmio.UM32 }

func (RMFIFOCNT) Load 

func (rm RMFIFOCNT) Load() FIFOCNT

func (RMFIFOCNT) Store 

func (rm RMFIFOCNT) Store(b FIFOCNT)

type RMICR 

type RMICR struct{ mmio.UM32 }

func (RMICR) Load 

func (rm RMICR) Load() ICR

func (RMICR) Store 

func (rm RMICR) Store(b ICR)

type RMMASK 

type RMMASK struct{ mmio.UM32 }

func (RMMASK) Load 

func (rm RMMASK) Load() MASK

func (RMMASK) Store 

func (rm RMMASK) Store(b MASK)

type RMPOWER 

type RMPOWER struct{ mmio.UM32 }

func (RMPOWER) Load 

func (rm RMPOWER) Load() POWER

func (RMPOWER) Store 

func (rm RMPOWER) Store(b POWER)

type RMRESP 

type RMRESP struct{ mmio.UM32 }

func (RMRESP) Load 

func (rm RMRESP) Load() RESP

func (RMRESP) Store 

func (rm RMRESP) Store(b RESP)

type RMRESPCMD 

type RMRESPCMD struct{ mmio.UM32 }

func (RMRESPCMD) Load 

func (rm RMRESPCMD) Load() RESPCMD

func (RMRESPCMD) Store 

func (rm RMRESPCMD) Store(b RESPCMD)

type RMSTA 

type RMSTA struct{ mmio.UM32 }

func (RMSTA) Load 

func (rm RMSTA) Load() STA

func (RMSTA) Store 

func (rm RMSTA) Store(b STA)

type RPOWER 

type RPOWER struct{ mmio.U32 }

func (*RPOWER) AtomicClearBits 

func (r *RPOWER) AtomicClearBits(mask POWER)

func (*RPOWER) AtomicSetBits 

func (r *RPOWER) AtomicSetBits(mask POWER)

func (*RPOWER) AtomicStoreBits 

func (r *RPOWER) AtomicStoreBits(mask, b POWER)

func (*RPOWER) Bits 

func (r *RPOWER) Bits(mask POWER) POWER

func (*RPOWER) ClearBits 

func (r *RPOWER) ClearBits(mask POWER)

func (*RPOWER) Load 

func (r *RPOWER) Load() POWER

func (*RPOWER) SetBits 

func (r *RPOWER) SetBits(mask POWER)

func (*RPOWER) Store 

func (r *RPOWER) Store(b POWER)

func (*RPOWER) StoreBits 

func (r *RPOWER) StoreBits(mask, b POWER)

type RRESP 

type RRESP struct{ mmio.U32 }

func (*RRESP) AtomicClearBits 

func (r *RRESP) AtomicClearBits(mask RESP)

func (*RRESP) AtomicSetBits 

func (r *RRESP) AtomicSetBits(mask RESP)

func (*RRESP) AtomicStoreBits 

func (r *RRESP) AtomicStoreBits(mask, b RESP)

func (*RRESP) Bits 

func (r *RRESP) Bits(mask RESP) RESP

func (*RRESP) ClearBits 

func (r *RRESP) ClearBits(mask RESP)

func (*RRESP) Load 

func (r *RRESP) Load() RESP

func (*RRESP) SetBits 

func (r *RRESP) SetBits(mask RESP)

func (*RRESP) Store 

func (r *RRESP) Store(b RESP)

func (*RRESP) StoreBits 

func (r *RRESP) StoreBits(mask, b RESP)

type RRESPCMD 

type RRESPCMD struct{ mmio.U32 }

func (*RRESPCMD) AtomicClearBits 

func (r *RRESPCMD) AtomicClearBits(mask RESPCMD)

func (*RRESPCMD) AtomicSetBits 

func (r *RRESPCMD) AtomicSetBits(mask RESPCMD)

func (*RRESPCMD) AtomicStoreBits 

func (r *RRESPCMD) AtomicStoreBits(mask, b RESPCMD)

func (*RRESPCMD) Bits 

func (r *RRESPCMD) Bits(mask RESPCMD) RESPCMD

func (*RRESPCMD) ClearBits 

func (r *RRESPCMD) ClearBits(mask RESPCMD)

func (*RRESPCMD) Load 

func (r *RRESPCMD) Load() RESPCMD

func (*RRESPCMD) SetBits 

func (r *RRESPCMD) SetBits(mask RESPCMD)

func (*RRESPCMD) Store 

func (r *RRESPCMD) Store(b RESPCMD)

func (*RRESPCMD) StoreBits 

func (r *RRESPCMD) StoreBits(mask, b RESPCMD)

type RSTA 

type RSTA struct{ mmio.U32 }

func (*RSTA) AtomicClearBits 

func (r *RSTA) AtomicClearBits(mask STA)

func (*RSTA) AtomicSetBits 

func (r *RSTA) AtomicSetBits(mask STA)

func (*RSTA) AtomicStoreBits 

func (r *RSTA) AtomicStoreBits(mask, b STA)

func (*RSTA) Bits 

func (r *RSTA) Bits(mask STA) STA

func (*RSTA) ClearBits 

func (r *RSTA) ClearBits(mask STA)

func (*RSTA) Load 

func (r *RSTA) Load() STA

func (*RSTA) SetBits 

func (r *RSTA) SetBits(mask STA)

func (*RSTA) Store 

func (r *RSTA) Store(b STA)

func (*RSTA) StoreBits 

func (r *RSTA) StoreBits(mask, b STA)

type SDIO_Periph 

type SDIO_Periph struct {
	POWER   RPOWER
	CLKCR   RCLKCR
	ARG     RARG
	CMD     RCMD
	RESPCMD RRESPCMD
	RESP    [4]RRESP
	DTIMER  RDTIMER
	DLEN    RDLEN
	DCTRL   RDCTRL
	DCOUNT  RDCOUNT
	STA     RSTA
	ICR     RICR
	MASK    RMASK

	FIFOCNT RFIFOCNT

	FIFO RFIFO
	// contains filtered or unexported fields
}

func (*SDIO_Periph) BYPASS 

func (p *SDIO_Periph) BYPASS() RMCLKCR

func (*SDIO_Periph) BaseAddr 

func (p *SDIO_Periph) BaseAddr() uintptr

func (*SDIO_Periph) CARDSTATUS1 

func (p *SDIO_Periph) CARDSTATUS1(n int) RMRESP

func (*SDIO_Periph) CCRCFAIL 

func (p *SDIO_Periph) CCRCFAIL() RMSTA

func (*SDIO_Periph) CCRCFAILC 

func (p *SDIO_Periph) CCRCFAILC() RMICR

func (*SDIO_Periph) CCRCFAILIE 

func (p *SDIO_Periph) CCRCFAILIE() RMMASK

func (*SDIO_Periph) CEATACMD 

func (p *SDIO_Periph) CEATACMD() RMCMD

func (*SDIO_Periph) CEATAEND 

func (p *SDIO_Periph) CEATAEND() RMSTA

func (*SDIO_Periph) CEATAENDC 

func (p *SDIO_Periph) CEATAENDC() RMICR

func (*SDIO_Periph) CEATAENDIE 

func (p *SDIO_Periph) CEATAENDIE() RMMASK

func (*SDIO_Periph) CLKDIV 

func (p *SDIO_Periph) CLKDIV() RMCLKCR

func (*SDIO_Periph) CLKEN 

func (p *SDIO_Periph) CLKEN() RMCLKCR

func (*SDIO_Periph) CMDACT 

func (p *SDIO_Periph) CMDACT() RMSTA

func (*SDIO_Periph) CMDACTIE 

func (p *SDIO_Periph) CMDACTIE() RMMASK

func (*SDIO_Periph) CMDARG 

func (p *SDIO_Periph) CMDARG() RMARG

func (*SDIO_Periph) CMDINDEX 

func (p *SDIO_Periph) CMDINDEX() RMCMD

func (*SDIO_Periph) CMDREND 

func (p *SDIO_Periph) CMDREND() RMSTA

func (*SDIO_Periph) CMDRENDC 

func (p *SDIO_Periph) CMDRENDC() RMICR

func (*SDIO_Periph) CMDRENDIE 

func (p *SDIO_Periph) CMDRENDIE() RMMASK

func (*SDIO_Periph) CMDSENT 

func (p *SDIO_Periph) CMDSENT() RMSTA

func (*SDIO_Periph) CMDSENTC 

func (p *SDIO_Periph) CMDSENTC() RMICR

func (*SDIO_Periph) CMDSENTIE 

func (p *SDIO_Periph) CMDSENTIE() RMMASK

func (*SDIO_Periph) CPSMEN 

func (p *SDIO_Periph) CPSMEN() RMCMD

func (*SDIO_Periph) CTIMEOUT 

func (p *SDIO_Periph) CTIMEOUT() RMSTA

func (*SDIO_Periph) CTIMEOUTC 

func (p *SDIO_Periph) CTIMEOUTC() RMICR

func (*SDIO_Periph) CTIMEOUTIE 

func (p *SDIO_Periph) CTIMEOUTIE() RMMASK

func (*SDIO_Periph) DATACOUNT 

func (p *SDIO_Periph) DATACOUNT() RMDCOUNT

func (*SDIO_Periph) DATAEND 

func (p *SDIO_Periph) DATAEND() RMSTA

func (*SDIO_Periph) DATAENDC 

func (p *SDIO_Periph) DATAENDC() RMICR

func (*SDIO_Periph) DATAENDIE 

func (p *SDIO_Periph) DATAENDIE() RMMASK

func (*SDIO_Periph) DATALENGTH 

func (p *SDIO_Periph) DATALENGTH() RMDLEN

func (*SDIO_Periph) DATATIME 

func (p *SDIO_Periph) DATATIME() RMDTIMER

func (*SDIO_Periph) DBCKEND 

func (p *SDIO_Periph) DBCKEND() RMSTA

func (*SDIO_Periph) DBCKENDC 

func (p *SDIO_Periph) DBCKENDC() RMICR

func (*SDIO_Periph) DBCKENDIE 

func (p *SDIO_Periph) DBCKENDIE() RMMASK

func (*SDIO_Periph) DBLOCKSIZE 

func (p *SDIO_Periph) DBLOCKSIZE() RMDCTRL

func (*SDIO_Periph) DCRCFAIL 

func (p *SDIO_Periph) DCRCFAIL() RMSTA

func (*SDIO_Periph) DCRCFAILC 

func (p *SDIO_Periph) DCRCFAILC() RMICR

func (*SDIO_Periph) DCRCFAILIE 

func (p *SDIO_Periph) DCRCFAILIE() RMMASK

func (*SDIO_Periph) DMAEN 

func (p *SDIO_Periph) DMAEN() RMDCTRL

func (*SDIO_Periph) DTDIR 

func (p *SDIO_Periph) DTDIR() RMDCTRL

func (*SDIO_Periph) DTEN 

func (p *SDIO_Periph) DTEN() RMDCTRL

func (*SDIO_Periph) DTIMEOUT 

func (p *SDIO_Periph) DTIMEOUT() RMSTA

func (*SDIO_Periph) DTIMEOUTC 

func (p *SDIO_Periph) DTIMEOUTC() RMICR

func (*SDIO_Periph) DTIMEOUTIE 

func (p *SDIO_Periph) DTIMEOUTIE() RMMASK

func (*SDIO_Periph) DTMODE 

func (p *SDIO_Periph) DTMODE() RMDCTRL

func (*SDIO_Periph) ENCMDCOMPL 

func (p *SDIO_Periph) ENCMDCOMPL() RMCMD

func (*SDIO_Periph) FIFOCOUNT 

func (p *SDIO_Periph) FIFOCOUNT() RMFIFOCNT

func (*SDIO_Periph) FIFODATA 

func (p *SDIO_Periph) FIFODATA() RMFIFO

func (*SDIO_Periph) HWFC_EN 

func (p *SDIO_Periph) HWFC_EN() RMCLKCR

func (*SDIO_Periph) NEGEDGE 

func (p *SDIO_Periph) NEGEDGE() RMCLKCR

func (*SDIO_Periph) NIEN 

func (p *SDIO_Periph) NIEN() RMCMD

func (*SDIO_Periph) PWRCTRL 

func (p *SDIO_Periph) PWRCTRL() RMPOWER

func (*SDIO_Periph) PWRSAV 

func (p *SDIO_Periph) PWRSAV() RMCLKCR

func (*SDIO_Periph) RWMOD 

func (p *SDIO_Periph) RWMOD() RMDCTRL

func (*SDIO_Periph) RWSTART 

func (p *SDIO_Periph) RWSTART() RMDCTRL

func (*SDIO_Periph) RWSTOP 

func (p *SDIO_Periph) RWSTOP() RMDCTRL

func (*SDIO_Periph) RXACT 

func (p *SDIO_Periph) RXACT() RMSTA

func (*SDIO_Periph) RXACTIE 

func (p *SDIO_Periph) RXACTIE() RMMASK

func (*SDIO_Periph) RXDAVL 

func (p *SDIO_Periph) RXDAVL() RMSTA

func (*SDIO_Periph) RXDAVLIE 

func (p *SDIO_Periph) RXDAVLIE() RMMASK

func (*SDIO_Periph) RXFIFOE 

func (p *SDIO_Periph) RXFIFOE() RMSTA

func (*SDIO_Periph) RXFIFOEIE 

func (p *SDIO_Periph) RXFIFOEIE() RMMASK

func (*SDIO_Periph) RXFIFOF 

func (p *SDIO_Periph) RXFIFOF() RMSTA

func (*SDIO_Periph) RXFIFOFIE 

func (p *SDIO_Periph) RXFIFOFIE() RMMASK

func (*SDIO_Periph) RXFIFOHF 

func (p *SDIO_Periph) RXFIFOHF() RMSTA

func (*SDIO_Periph) RXFIFOHFIE 

func (p *SDIO_Periph) RXFIFOHFIE() RMMASK

func (*SDIO_Periph) RXOVERR 

func (p *SDIO_Periph) RXOVERR() RMSTA

func (*SDIO_Periph) RXOVERRC 

func (p *SDIO_Periph) RXOVERRC() RMICR

func (*SDIO_Periph) RXOVERRIE 

func (p *SDIO_Periph) RXOVERRIE() RMMASK

func (*SDIO_Periph) SDIOEN 

func (p *SDIO_Periph) SDIOEN() RMDCTRL

func (*SDIO_Periph) SDIOIT 

func (p *SDIO_Periph) SDIOIT() RMSTA

func (*SDIO_Periph) SDIOITC 

func (p *SDIO_Periph) SDIOITC() RMICR

func (*SDIO_Periph) SDIOITIE 

func (p *SDIO_Periph) SDIOITIE() RMMASK

func (*SDIO_Periph) SDIOSUSPEND 

func (p *SDIO_Periph) SDIOSUSPEND() RMCMD

func (*SDIO_Periph) STBITERR 

func (p *SDIO_Periph) STBITERR() RMSTA

func (*SDIO_Periph) STBITERRC 

func (p *SDIO_Periph) STBITERRC() RMICR

func (*SDIO_Periph) STBITERRIE 

func (p *SDIO_Periph) STBITERRIE() RMMASK

func (*SDIO_Periph) TXACT 

func (p *SDIO_Periph) TXACT() RMSTA

func (*SDIO_Periph) TXACTIE 

func (p *SDIO_Periph) TXACTIE() RMMASK

func (*SDIO_Periph) TXDAVL 

func (p *SDIO_Periph) TXDAVL() RMSTA

func (*SDIO_Periph) TXDAVLIE 

func (p *SDIO_Periph) TXDAVLIE() RMMASK

func (*SDIO_Periph) TXFIFOE 

func (p *SDIO_Periph) TXFIFOE() RMSTA

func (*SDIO_Periph) TXFIFOEIE 

func (p *SDIO_Periph) TXFIFOEIE() RMMASK

func (*SDIO_Periph) TXFIFOF 

func (p *SDIO_Periph) TXFIFOF() RMSTA

func (*SDIO_Periph) TXFIFOFIE 

func (p *SDIO_Periph) TXFIFOFIE() RMMASK

func (*SDIO_Periph) TXFIFOHE 

func (p *SDIO_Periph) TXFIFOHE() RMSTA

func (*SDIO_Periph) TXFIFOHEIE 

func (p *SDIO_Periph) TXFIFOHEIE() RMMASK

func (*SDIO_Periph) TXUNDERR 

func (p *SDIO_Periph) TXUNDERR() RMSTA

func (*SDIO_Periph) TXUNDERRC 

func (p *SDIO_Periph) TXUNDERRC() RMICR

func (*SDIO_Periph) TXUNDERRIE 

func (p *SDIO_Periph) TXUNDERRIE() RMMASK

func (*SDIO_Periph) WAITINT 

func (p *SDIO_Periph) WAITINT() RMCMD

func (*SDIO_Periph) WAITPEND 

func (p *SDIO_Periph) WAITPEND() RMCMD

func (*SDIO_Periph) WAITRESP 

func (p *SDIO_Periph) WAITRESP() RMCMD

func (*SDIO_Periph) WIDBUS 

func (p *SDIO_Periph) WIDBUS() RMCLKCR

type STA 

type STA uint32
const (
	CCRCFAIL STA = 0x01 << 0  //+ Command response received (CRC check failed).
	DCRCFAIL STA = 0x01 << 1  //+ Data block sent/received (CRC check failed).
	CTIMEOUT STA = 0x01 << 2  //+ Command response timeout.
	DTIMEOUT STA = 0x01 << 3  //+ Data timeout.
	TXUNDERR STA = 0x01 << 4  //+ Transmit FIFO underrun error.
	RXOVERR  STA = 0x01 << 5  //+ Received FIFO overrun error.
	CMDREND  STA = 0x01 << 6  //+ Command response received (CRC check passed).
	CMDSENT  STA = 0x01 << 7  //+ Command sent (no response required).
	DATAEND  STA = 0x01 << 8  //+ Data end (data counter, SDIDCOUNT, is zero).
	STBITERR STA = 0x01 << 9  //+ Start bit not detected on all data signals in wide bus mode.
	DBCKEND  STA = 0x01 << 10 //+ Data block sent/received (CRC check passed).
	CMDACT   STA = 0x01 << 11 //+ Command transfer in progress.
	TXACT    STA = 0x01 << 12 //+ Data transmit in progress.
	RXACT    STA = 0x01 << 13 //+ Data receive in progress.
	TXFIFOHE STA = 0x01 << 14 //+ Transmit FIFO Half Empty: at least 8 words can be written into the FIFO.
	RXFIFOHF STA = 0x01 << 15 //+ Receive FIFO Half Full: there are at least 8 words in the FIFO.
	TXFIFOF  STA = 0x01 << 16 //+ Transmit FIFO full.
	RXFIFOF  STA = 0x01 << 17 //+ Receive FIFO full.
	TXFIFOE  STA = 0x01 << 18 //+ Transmit FIFO empty.
	RXFIFOE  STA = 0x01 << 19 //+ Receive FIFO empty.
	TXDAVL   STA = 0x01 << 20 //+ Data available in transmit FIFO.
	RXDAVL   STA = 0x01 << 21 //+ Data available in receive FIFO.
	SDIOIT   STA = 0x01 << 22 //+ SDIO interrupt received.
	CEATAEND STA = 0x01 << 23 //+ CE-ATA command completion signal received for CMD61.
)

func (STA) Field 

func (b STA) Field(mask STA) int

func (STA) J 

func (mask STA) J(v int) STA

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.