github
/
micropython
mirror of https://github.com/micropython/micropython.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6631 Commits
3 Branches
62 Tags
504 MiB
 
 
 
 
 
 
Tree: 5e22afce41
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5e22afce41'
${ noResults }
micropython/cc3200/hal/inc/hw_mmchs.h

1919 lines
131 KiB
Raw Blame History

//*****************************************************************************
//
// Copyright (C) 2014 Texas Instruments Incorporated - http://www.ti.com/
//
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the
// distribution.
//
// Neither the name of Texas Instruments Incorporated nor the names of
// its contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//*****************************************************************************
#ifndef __HW_MMCHS_H__
#define __HW_MMCHS_H__
//*****************************************************************************
//
// The following are defines for the MMCHS register offsets.
//
//*****************************************************************************
#define MMCHS_O_HL_REV 0x00000000 // IP Revision Identifier (X.Y.R)
// Used by software to track
// features bugs and compatibility
#define MMCHS_O_HL_HWINFO 0x00000004 // Information about the IP
// module's hardware configuration
// i.e. typically the module's HDL
// generics (if any). Actual field
// format and encoding is up to the
// module's designer to decide.
#define MMCHS_O_HL_SYSCONFIG 0x00000010 // Clock management configuration
#define MMCHS_O_SYSCONFIG 0x00000110 // System Configuration Register
// This register allows controlling
// various parameters of the OCP
// interface.
#define MMCHS_O_SYSSTATUS 0x00000114 // System Status Register This
// register provides status
// information about the module
// excluding the interrupt status
// information
#define MMCHS_O_CSRE 0x00000124 // Card status response error This
// register enables the host
// controller to detect card status
// errors of response type R1 R1b
// for all cards and of R5 R5b and
// R6 response for cards types SD or
// SDIO. When a bit MMCHS_CSRE[i] is
// set to 1 if the corresponding bit
// at the same position in the
// response MMCHS_RSP0[i] is set to
// 1 the host controller indicates a
// card error (MMCHS_STAT[CERR])
// interrupt status to avoid the
// host driver reading the response
// register (MMCHS_RSP0). Note: No
// automatic card error detection
// for autoCMD12 is implemented; the
// host system has to check
// autoCMD12 response register
// (MMCHS_RESP76) for possible card
// errors.
#define MMCHS_O_SYSTEST 0x00000128 // System Test register This
// register is used to control the
// signals that connect to I/O pins
// when the module is configured in
// system test (SYSTEST) mode for
// boundary connectivity
// verification. Note: In SYSTEST
// mode a write into MMCHS_CMD
// register will not start a
// transfer. The buffer behaves as a
// stack accessible only by the
// local host (push and pop
// operations). In this mode the
// Transfer Block Size
// (MMCHS_BLK[BLEN]) and the Blocks
// count for current transfer
// (MMCHS_BLK[NBLK]) are needed to
// generate a Buffer write ready
// interrupt (MMCHS_STAT[BWR]) or a
// Buffer read ready interrupt
// (MMCHS_STAT[BRR]) and DMA
// requests if enabled.
#define MMCHS_O_CON 0x0000012C // Configuration register This
// register is used: - to select the
// functional mode or the SYSTEST
// mode for any card. - to send an
// initialization sequence to any
// card. - to enable the detection
// on DAT[1] of a card interrupt for
// SDIO cards only. and also to
// configure : - specific data and
// command transfers for MMC cards
// only. - the parameters related to
// the card detect and write protect
// input signals.
#define MMCHS_O_PWCNT 0x00000130 // Power counter register This
// register is used to program a mmc
// counter to delay command
// transfers after activating the
// PAD power this value depends on
// PAD characteristics and voltage.
#define MMCHS_O_BLK 0x00000204 // Transfer Length Configuration
// register MMCHS_BLK[BLEN] is the
// block size register.
// MMCHS_BLK[NBLK] is the block
// count register. This register
// shall be used for any card.
#define MMCHS_O_ARG 0x00000208 // Command argument Register This
// register contains command
// argument specified as bit 39-8 of
// Command-Format These registers
// must be initialized prior to
// sending the command itself to the
// card (write action into the
// register MMCHS_CMD register).
// Only exception is for a command
// index specifying stuff bits in
// arguments making a write
// unnecessary.
#define MMCHS_O_CMD 0x0000020C // Command and transfer mode
// register MMCHS_CMD[31:16] = the
// command register MMCHS_CMD[15:0]
// = the transfer mode. This
// register configures the data and
// command transfers. A write into
// the most significant byte send
// the command. A write into
// MMCHS_CMD[15:0] registers during
// data transfer has no effect. This
// register shall be used for any
// card. Note: In SYSTEST mode a
// write into MMCHS_CMD register
// will not start a transfer.
#define MMCHS_O_RSP10 0x00000210 // Command response[31:0] Register
// This 32-bit register holds bits
// positions [31:0] of command
// response type
// R1/R1b/R2/R3/R4/R5/R5b/R6
#define MMCHS_O_RSP32 0x00000214 // Command response[63:32] Register
// This 32-bit register holds bits
// positions [63:32] of command
// response type R2
#define MMCHS_O_RSP54 0x00000218 // Command response[95:64] Register
// This 32-bit register holds bits
// positions [95:64] of command
// response type R2
#define MMCHS_O_RSP76 0x0000021C // Command response[127:96]
// Register This 32-bit register
// holds bits positions [127:96] of
// command response type R2
#define MMCHS_O_DATA 0x00000220 // Data Register This register is
// the 32-bit entry point of the
// buffer for read or write data
// transfers. The buffer size is
// 32bits x256(1024 bytes). Bytes
// within a word are stored and read
// in little endian format. This
// buffer can be used as two 512
// byte buffers to transfer data
// efficiently without reducing the
// throughput. Sequential and
// contiguous access is necessary to
// increment the pointer correctly.
// Random or skipped access is not
// allowed. In little endian if the
// local host accesses this register
// byte-wise or 16bit-wise the least
// significant byte (bits [7:0])
// must always be written/read
// first. The update of the buffer
// address is done on the most
// significant byte write for full
// 32-bit DATA register or on the
// most significant byte of the last
// word of block transfer. Example
// 1: Byte or 16-bit access
// Mbyteen[3:0]=0001 (1-byte) =>
// Mbyteen[3:0]=0010 (1-byte) =>
// Mbyteen[3:0]=1100 (2-bytes) OK
// Mbyteen[3:0]=0001 (1-byte) =>
// Mbyteen[3:0]=0010 (1-byte) =>
// Mbyteen[3:0]=0100 (1-byte) OK
// Mbyteen[3:0]=0001 (1-byte) =>
// Mbyteen[3:0]=0010 (1-byte) =>
// Mbyteen[3:0]=1000 (1-byte) Bad
#define MMCHS_O_PSTATE 0x00000224 // Present state register The Host
// can get status of the Host
// Controller from this 32-bit read
// only register.
#define MMCHS_O_HCTL 0x00000228 // Control register This register
// defines the host controls to set
// power wakeup and transfer
// parameters. MMCHS_HCTL[31:24] =
// Wakeup control MMCHS_HCTL[23:16]
// = Block gap control
// MMCHS_HCTL[15:8] = Power control
// MMCHS_HCTL[7:0] = Host control
#define MMCHS_O_SYSCTL 0x0000022C // SD system control register This
// register defines the system
// controls to set software resets
// clock frequency management and
// data timeout. MMCHS_SYSCTL[31:24]
// = Software resets
// MMCHS_SYSCTL[23:16] = Timeout
// control MMCHS_SYSCTL[15:0] =
// Clock control
#define MMCHS_O_STAT 0x00000230 // Interrupt status register The
// interrupt status regroups all the
// status of the module internal
// events that can generate an
// interrupt. MMCHS_STAT[31:16] =
// Error Interrupt Status
// MMCHS_STAT[15:0] = Normal
// Interrupt Status
#define MMCHS_O_IE 0x00000234 // Interrupt SD enable register
// This register allows to
// enable/disable the module to set
// status bits on an event-by-event
// basis. MMCHS_IE[31:16] = Error
// Interrupt Status Enable
// MMCHS_IE[15:0] = Normal Interrupt
// Status Enable
#define MMCHS_O_ISE 0x00000238 // Interrupt signal enable register
// This register allows to
// enable/disable the module
// internal sources of status on an
// event-by-event basis.
// MMCHS_ISE[31:16] = Error
// Interrupt Signal Enable
// MMCHS_ISE[15:0] = Normal
// Interrupt Signal Enable
#define MMCHS_O_AC12 0x0000023C // Auto CMD12 Error Status Register
// The host driver may determine
// which of the errors cases related
// to Auto CMD12 has occurred by
// checking this MMCHS_AC12 register
// when an Auto CMD12 Error
// interrupt occurs. This register
// is valid only when Auto CMD12 is
// enabled (MMCHS_CMD[ACEN]) and
// Auto CMD12Error (MMCHS_STAT[ACE])
// is set to 1. Note: These bits are
// automatically reset when starting
// a new adtc command with data.
#define MMCHS_O_CAPA 0x00000240 // Capabilities register This
// register lists the capabilities
// of the MMC/SD/SDIO host
// controller.
#define MMCHS_O_CUR_CAPA 0x00000248 // Maximum current capabilities
// Register This register indicates
// the maximum current capability
// for each voltage. The value is
// meaningful if the voltage support
// is set in the capabilities
// register (MMCHS_CAPA).
// Initialization of this register
// (via a write access to this
// register) depends on the system
// capabilities. The host driver
// shall not modify this register
// after the initilaization. This
// register is only reinitialized by
// a hard reset (via RESETN signal)
#define MMCHS_O_FE 0x00000250 // Force Event Register for Error
// Interrupt status The force Event
// Register is not a physically
// implemented register. Rather it
// is an address at which the Error
// Interrupt Status register can be
// written. The effect of a write to
// this address will be reflected in
// the Error Interrupt Status
// Register if corresponding bit of
// the Error Interrupt Status Enable
// Register is set.
#define MMCHS_O_ADMAES 0x00000254 // ADMA Error Status Register When
// ADMA Error Interrupt is occurred
// the ADMA Error States field in
// this register holds the ADMA
// state and the ADMA System Address
// Register holds the address around
// the error descriptor. For
// recovering the error the Host
// Driver requires the ADMA state to
// identify the error descriptor
// address as follows: ST_STOP:
// Previous location set in the ADMA
// System Address register is the
// error descriptor address ST_FDS:
// Current location set in the ADMA
// System Address register is the
// error descriptor address ST_CADR:
// This sate is never set because do
// not generate ADMA error in this
// state. ST_TFR: Previous location
// set in the ADMA System Address
// register is the error descriptor
// address In case of write
// operation the Host Driver should
// use ACMD22 to get the number of
// written block rather than using
// this information since unwritten
// data may exist in the Host
// Controller. The Host Controller
// generates the ADMA Error
// Interrupt when it detects invalid
// descriptor data (Valid=0) at the
// ST_FDS state. In this case ADMA
// Error State indicates that an
// error occurs at ST_FDS state. The
// Host Driver may find that the
// Valid bit is not set in the error
// descriptor.
#define MMCHS_O_ADMASAL 0x00000258 // ADMA System address Low bits
#define MMCHS_O_REV 0x000002FC // Versions Register This register
// contains the hard coded RTL
// vendor revision number the
// version number of SD
// specification compliancy and a
// slot status bit. MMCHS_REV[31:16]
// = Host controller version
// MMCHS_REV[15:0] = Slot Interrupt
// Status
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_HL_REV register.
//
//******************************************************************************
#define MMCHS_HL_REV_SCHEME_M 0xC0000000
#define MMCHS_HL_REV_SCHEME_S 30
#define MMCHS_HL_REV_FUNC_M 0x0FFF0000 // Function indicates a software
// compatible module family. If
// there is no level of software
// compatibility a new Func number
// (and hence REVISION) should be
// assigned.
#define MMCHS_HL_REV_FUNC_S 16
#define MMCHS_HL_REV_R_RTL_M 0x0000F800 // RTL Version (R) maintained by IP
// design owner. RTL follows a
// numbering such as X.Y.R.Z which
// are explained in this table. R
// changes ONLY when: (1) PDS
// uploads occur which may have been
// due to spec changes (2) Bug fixes
// occur (3) Resets to '0' when X or
// Y changes. Design team has an
// internal 'Z' (customer invisible)
// number which increments on every
// drop that happens due to DV and
// RTL updates. Z resets to 0 when R
// increments.
#define MMCHS_HL_REV_R_RTL_S 11
#define MMCHS_HL_REV_X_MAJOR_M 0x00000700 // Major Revision (X) maintained by
// IP specification owner. X changes
// ONLY when: (1) There is a major
// feature addition. An example
// would be adding Master Mode to
// Utopia Level2. The Func field (or
// Class/Type in old PID format)
// will remain the same. X does NOT
// change due to: (1) Bug fixes (2)
// Change in feature parameters.
#define MMCHS_HL_REV_X_MAJOR_S 8
#define MMCHS_HL_REV_CUSTOM_M 0x000000C0
#define MMCHS_HL_REV_CUSTOM_S 6
#define MMCHS_HL_REV_Y_MINOR_M 0x0000003F // Minor Revision (Y) maintained by
// IP specification owner. Y changes
// ONLY when: (1) Features are
// scaled (up or down). Flexibility
// exists in that this feature
// scalability may either be
// represented in the Y change or a
// specific register in the IP that
// indicates which features are
// exactly available. (2) When
// feature creeps from Is-Not list
// to Is list. But this may not be
// the case once it sees silicon; in
// which case X will change. Y does
// NOT change due to: (1) Bug fixes
// (2) Typos or clarifications (3)
// major functional/feature
// change/addition/deletion. Instead
// these changes may be reflected
// via R S X as applicable. Spec
// owner maintains a
// customer-invisible number 'S'
// which changes due to: (1)
// Typos/clarifications (2) Bug
// documentation. Note that this bug
// is not due to a spec change but
// due to implementation.
// Nevertheless the spec tracks the
// IP bugs. An RTL release (say for
// silicon PG1.1) that occurs due to
// bug fix should document the
// corresponding spec number (X.Y.S)
// in its release notes.
#define MMCHS_HL_REV_Y_MINOR_S 0
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_HL_HWINFO register.
//
//******************************************************************************
#define MMCHS_HL_HWINFO_RETMODE 0x00000040
#define MMCHS_HL_HWINFO_MEM_SIZE_M \
0x0000003C
#define MMCHS_HL_HWINFO_MEM_SIZE_S 2
#define MMCHS_HL_HWINFO_MERGE_MEM \
0x00000002
#define MMCHS_HL_HWINFO_MADMA_EN \
0x00000001
//******************************************************************************
//
// The following are defines for the bit fields in the
// MMCHS_O_HL_SYSCONFIG register.
//
//******************************************************************************
#define MMCHS_HL_SYSCONFIG_STANDBYMODE_M \
0x00000030 // Configuration of the local
// initiator state management mode.
// By definition initiator may
// generate read/write transaction
// as long as it is out of STANDBY
// state. 0x0 Force-standby mode:
// local initiator is
// unconditionally placed in standby
// state.Backup mode for debug only.
// 0x1 No-standby mode: local
// initiator is unconditionally
// placed out of standby
// state.Backup mode for debug only.
// 0x2 Smart-standby mode: local
// initiator standby status depends
// on local conditions i.e. the
// module's functional requirement
// from the initiator.IP module
// shall not generate
// (initiator-related) wakeup
// events. 0x3 "Smart-Standby
// wakeup-capable mode: local
// initiator standby status depends
// on local conditions i.e. the
// module's functional requirement
// from the initiator. IP module may
// generate (master-related) wakeup
// events when in standby state.Mode
// is only relevant if the
// appropriate IP module ""mwakeup""
// output is implemented."
#define MMCHS_HL_SYSCONFIG_STANDBYMODE_S 4
#define MMCHS_HL_SYSCONFIG_IDLEMODE_M \
0x0000000C // Configuration of the local
// target state management mode. By
// definition target can handle
// read/write transaction as long as
// it is out of IDLE state. 0x0
// Force-idle mode: local target's
// idle state follows (acknowledges)
// the system's idle requests
// unconditionally i.e. regardless
// of the IP module's internal
// requirements.Backup mode for
// debug only. 0x1 No-idle mode:
// local target never enters idle
// state.Backup mode for debug only.
// 0x2 Smart-idle mode: local
// target's idle state eventually
// follows (acknowledges) the
// system's idle requests depending
// on the IP module's internal
// requirements.IP module shall not
// generate (IRQ- or
// DMA-request-related) wakeup
// events. 0x3 "Smart-idle
// wakeup-capable mode: local
// target's idle state eventually
// follows (acknowledges) the
// system's idle requests depending
// on the IP module's internal
// requirements.IP module may
// generate (IRQ- or
// DMA-request-related) wakeup
// events when in idle state.Mode is
// only relevant if the appropriate
// IP module ""swakeup"" output(s)
// is (are) implemented."
#define MMCHS_HL_SYSCONFIG_IDLEMODE_S 2
#define MMCHS_HL_SYSCONFIG_FREEEMU \
0x00000002 // Sensitivity to emulation (debug)
// suspend input signal.
// Functionality NOT implemented in
// MMCHS. 0 IP module is sensitive
// to emulation suspend 1 IP module
// is not sensitive to emulation
// suspend
#define MMCHS_HL_SYSCONFIG_SOFTRESET \
0x00000001
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_SYSCONFIG register.
//
//******************************************************************************
#define MMCHS_SYSCONFIG_STANDBYMODE_M \
0x00003000 // Master interface power
// Management standby/wait control.
// The bit field is only useful when
// generic parameter MADMA_EN
// (Master ADMA enable) is set as
// active otherwise it is a read
// only register read a '0'. 0x0
// Force-standby. Mstandby is forced
// unconditionnaly. 0x1 No-standby.
// Mstandby is never asserted. 0x2
// Smart-standby mode: local
// initiator standby status depends
// on local conditions i.e. the
// module's functional requirement
// from the initiator.IP module
// shall not generate
// (initiator-related) wakeup
// events. 0x3 Smart-Standby
// wakeup-capable mode: "local
// initiator standby status depends
// on local conditions i.e. the
// module's functional requirement
// from the initiator. IP module may
// generate (master-related) wakeup
// events when in standby state.Mode
// is only relevant if the
// appropriate IP module ""mwakeup""
// output is implemented."
#define MMCHS_SYSCONFIG_STANDBYMODE_S 12
#define MMCHS_SYSCONFIG_CLOCKACTIVITY_M \
0x00000300 // Clocks activity during wake up
// mode period. Bit8: OCP interface
// clock Bit9: Functional clock 0x0
// OCP and Functional clock may be
// switched off. 0x1 OCP clock is
// maintained. Functional clock may
// be switched-off. 0x2 Functional
// clock is maintained. OCP clock
// may be switched-off. 0x3 OCP and
// Functional clocks are maintained.
#define MMCHS_SYSCONFIG_CLOCKACTIVITY_S 8
#define MMCHS_SYSCONFIG_SIDLEMODE_M \
0x00000018 // Power management 0x0 If an idle
// request is detected the MMCHS
// acknowledges it unconditionally
// and goes in Inactive mode.
// Interrupt and DMA requests are
// unconditionally de-asserted. 0x1
// If an idle request is detected
// the request is ignored and the
// module keeps on behaving
// normally. 0x2 Smart-idle mode:
// local target's idle state
// eventually follows (acknowledges)
// the system's idle requests
// depending on the IP module's
// internal requirements.IP module
// shall not generate (IRQ- or
// DMA-request-related) wakeup
// events. 0x3 Smart-idle
// wakeup-capable mode: "local
// target's idle state eventually
// follows (acknowledges) the
// system's idle requests depending
// on the IP module's internal
// requirements.IP module may
// generate (IRQ- or
// DMA-request-related) wakeup
// events when in idle state.Mode is
// only relevant if the appropriate
// IP module ""swakeup"" output(s)
// is (are) implemented."
#define MMCHS_SYSCONFIG_SIDLEMODE_S 3
#define MMCHS_SYSCONFIG_ENAWAKEUP \
0x00000004 // Wakeup feature control 0 Wakeup
// capability is disabled 1 Wakeup
// capability is enabled
#define MMCHS_SYSCONFIG_SOFTRESET \
0x00000002
#define MMCHS_SYSCONFIG_AUTOIDLE \
0x00000001 // Internal Clock gating strategy 0
// Clocks are free-running 1
// Automatic clock gating strategy
// is applied based on the OCP and
// MMC interface activity
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_SYSSTATUS register.
//
//******************************************************************************
#define MMCHS_SYSSTATUS_RESETDONE \
0x00000001
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_CSRE register.
//
//******************************************************************************
#define MMCHS_CSRE_CSRE_M 0xFFFFFFFF // Card status response error
#define MMCHS_CSRE_CSRE_S 0
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_SYSTEST register.
//
//******************************************************************************
#define MMCHS_SYSTEST_OBI 0x00010000
#define MMCHS_SYSTEST_SDCD 0x00008000
#define MMCHS_SYSTEST_SDWP 0x00004000
#define MMCHS_SYSTEST_WAKD 0x00002000
#define MMCHS_SYSTEST_SSB 0x00001000
#define MMCHS_SYSTEST_D7D 0x00000800
#define MMCHS_SYSTEST_D6D 0x00000400
#define MMCHS_SYSTEST_D5D 0x00000200
#define MMCHS_SYSTEST_D4D 0x00000100
#define MMCHS_SYSTEST_D3D 0x00000080
#define MMCHS_SYSTEST_D2D 0x00000040
#define MMCHS_SYSTEST_D1D 0x00000020
#define MMCHS_SYSTEST_D0D 0x00000010
#define MMCHS_SYSTEST_DDIR 0x00000008
#define MMCHS_SYSTEST_CDAT 0x00000004
#define MMCHS_SYSTEST_CDIR 0x00000002
#define MMCHS_SYSTEST_MCKD 0x00000001
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_CON register.
//
//******************************************************************************
#define MMCHS_CON_SDMA_LNE 0x00200000 // Slave DMA Level/Edge Request:
// The waveform of the DMA request
// can be configured either edge
// sensitive with early de-assertion
// on first access to MMCHS_DATA
// register or late de-assertion
// request remains active until last
// allowed data written into
// MMCHS_DATA. 0 Slave DMA edge
// sensitive Early DMA de-assertion
// 1 Slave DMA level sensitive Late
// DMA de-assertion
#define MMCHS_CON_DMA_MNS 0x00100000 // DMA Master or Slave selection:
// When this bit is set and the
// controller is configured to use
// the DMA Ocp master interface is
// used to get datas from system
// using ADMA2 procedure (direct
// access to the memory).This option
// is only available if generic
// parameter MADMA_EN is asserted to
// '1'. 0 The controller is slave on
// data transfers with system. 1 The
// controller is master on data
// exchange with system controller
// must be configured as using DMA.
#define MMCHS_CON_DDR 0x00080000 // Dual Data Rate mode: When this
// register is set the controller
// uses both clock edge to emit or
// receive data. Odd bytes are
// transmitted on falling edges and
// even bytes are transmitted on
// rise edges. It only applies on
// Data bytes and CRC Start end bits
// and CRC status are kept full
// cycle. This bit field is only
// meaningful and active for even
// clock divider ratio of
// MMCHS_SYSCTL[CLKD] it is
// insensitive to MMCHS_HCTL[HSPE]
// setting. 0 Standard mode : data
// are transmitted on a single edge
// depending on MMCHS_HCTRL[HSPE]. 1
// Data Bytes and CRC are
// transmitted on both edge.
#define MMCHS_CON_BOOT_CF0 0x00040000
#define MMCHS_CON_BOOT_ACK 0x00020000 // Book acknowledge received: When
// this bit is set the controller
// should receive a boot status on
// DAT0 line after next command
// issued. If no status is received
// a data timeout will be generated.
// 0 No acknowledge to be received 1
// A boot status will be received on
// DAT0 line after issuing a
// command.
#define MMCHS_CON_CLKEXTFREE 0x00010000 // External clock free running:
// This register is used to maintain
// card clock out of transfer
// transaction to enable slave
// module for example to generate a
// synchronous interrupt on DAT[1].
// The Clock will be maintain only
// if MMCHS_SYSCTL[CEN] is set. 0
// External card clock is cut off
// outside active transaction
// period. 1 External card clock is
// maintain even out of active
// transaction period only if
// MMCHS_SYSCTL[CEN] is set.
#define MMCHS_CON_PADEN 0x00008000 // Control Power for MMC Lines:
// This register is only useful when
// MMC PADs contain power saving
// mechanism to minimize its leakage
// power. It works as a GPIO that
// directly control the ACTIVE pin
// of PADs. Excepted for DAT[1] the
// signal is also combine outside
// the module with the dedicated
// power control MMCHS_CON[CTPL]
// bit. 0 ADPIDLE module pin is not
// forced it is automatically
// generated by the MMC fsms. 1
// ADPIDLE module pin is forced to
// active state.
#define MMCHS_CON_OBIE 0x00004000 // Out-of-Band Interrupt Enable MMC
// cards only: This bit enables the
// detection of Out-of-Band
// Interrupt on MMCOBI input pin.
// The usage of the Out-of-Band
// signal (OBI) is optional and
// depends on the system
// integration. 0 Out-of-Band
// interrupt detection disabled 1
// Out-of-Band interrupt detection
// enabled
#define MMCHS_CON_OBIP 0x00002000 // Out-of-Band Interrupt Polarity
// MMC cards only: This bit selects
// the active level of the
// out-of-band interrupt coming from
// MMC cards. The usage of the
// Out-of-Band signal (OBI) is
// optional and depends on the
// system integration. 0 active high
// level 1 active low level
#define MMCHS_CON_CEATA 0x00001000 // CE-ATA control mode MMC cards
// compliant with CE-ATA:By default
// this bit is set to 0. It is use
// to indicate that next commands
// are considered as specific CE-ATA
// commands that potentially use
// 'command completion' features. 0
// Standard MMC/SD/SDIO mode. 1
// CE-ATA mode next commands are
// considered as CE-ATA commands.
#define MMCHS_CON_CTPL 0x00000800 // Control Power for DAT[1] line
// MMC and SD cards: By default this
// bit is set to 0 and the host
// controller automatically disables
// all the input buffers outside of
// a transaction to minimize the
// leakage current. SDIO cards: When
// this bit is set to 1 the host
// controller automatically disables
// all the input buffers except the
// buffer of DAT[1] outside of a
// transaction in order to detect
// asynchronous card interrupt on
// DAT[1] line and minimize the
// leakage current of the buffers. 0
// Disable all the input buffers
// outside of a transaction. 1
// Disable all the input buffers
// except the buffer of DAT[1]
// outside of a transaction.
#define MMCHS_CON_DVAL_M 0x00000600 // Debounce filter value All cards
// This register is used to define a
// debounce period to filter the
// card detect input signal (SDCD).
// The usage of the card detect
// input signal (SDCD) is optional
// and depends on the system
// integration and the type of the
// connector housing that
// accommodates the card. 0x0 33 us
// debounce period 0x1 231 us
// debounce period 0x2 1 ms debounce
// period 0x3 84 ms debounce period
#define MMCHS_CON_DVAL_S 9
#define MMCHS_CON_WPP 0x00000100 // Write protect polarity For SD
// and SDIO cards only This bit
// selects the active level of the
// write protect input signal
// (SDWP). The usage of the write
// protect input signal (SDWP) is
// optional and depends on the
// system integration and the type
// of the connector housing that
// accommodates the card. 0 active
// high level 1 active low level
#define MMCHS_CON_CDP 0x00000080 // Card detect polarity All cards
// This bit selects the active level
// of the card detect input signal
// (SDCD). The usage of the card
// detect input signal (SDCD) is
// optional and depends on the
// system integration and the type
// of the connector housing that
// accommodates the card. 0 active
// high level 1 active low level
#define MMCHS_CON_MIT 0x00000040 // MMC interrupt command Only for
// MMC cards. This bit must be set
// to 1 when the next write access
// to the command register
// (MMCHS_CMD) is for writing a MMC
// interrupt command (CMD40)
// requiring the command timeout
// detection to be disabled for the
// command response. 0 Command
// timeout enabled 1 Command timeout
// disabled
#define MMCHS_CON_DW8 0x00000020 // 8-bit mode MMC select For
// SD/SDIO cards this bit must be
// set to 0. For MMC card this bit
// must be set following a valid
// SWITCH command (CMD6) with the
// correct value and extend CSD
// index written in the argument.
// Prior to this command the MMC
// card configuration register (CSD
// and EXT_CSD) must be verified for
// compliancy with MMC standard
// specification 4.x (see section
// 3.6). 0 1-bit or 4-bit Data width
// (DAT[0] used MMC SD cards) 1
// 8-bit Data width (DAT[7:0] used
// MMC cards)
#define MMCHS_CON_MODE 0x00000010 // Mode select All cards These bits
// select between Functional mode
// and SYSTEST mode. 0 Functional
// mode. Transfers to the
// MMC/SD/SDIO cards follow the card
// protocol. MMC clock is enabled.
// MMC/SD transfers are operated
// under the control of the CMD
// register. 1 SYSTEST mode The
// signal pins are configured as
// general-purpose input/output and
// the 1024-byte buffer is
// configured as a stack memory
// accessible only by the local host
// or system DMA. The pins retain
// their default type (input output
// or in-out). SYSTEST mode is
// operated under the control of the
// SYSTEST register.
#define MMCHS_CON_STR 0x00000008 // Stream command Only for MMC
// cards. This bit must be set to 1
// only for the stream data
// transfers (read or write) of the
// adtc commands. Stream read is a
// class 1 command (CMD11:
// READ_DAT_UNTIL_STOP). Stream
// write is a class 3 command
// (CMD20: WRITE_DAT_UNTIL_STOP). 0
// Block oriented data transfer 1
// Stream oriented data transfer
#define MMCHS_CON_HR 0x00000004 // Broadcast host response Only for
// MMC cards. This register is used
// to force the host to generate a
// 48-bit response for bc command
// type. "It can be used to
// terminate the interrupt mode by
// generating a CMD40 response by
// the core (see section 4.3
// ""Interrupt Mode"" in the MMC [1]
// specification). In order to have
// the host response to be generated
// in open drain mode the register
// MMCHS_CON[OD] must be set to 1."
// When MMCHS_CON[CEATA] is set to 1
// and MMCHS_ARG set to 0x00000000
// when writing 0x00000000 into
// MMCHS_CMD register the host
// controller performs a 'command
// completion signal disable' token
// i.e. CMD line held to '0' during
// 47 cycles followed by a 1. 0 The
// host does not generate a 48-bit
// response instead of a command. 1
// The host generates a 48-bit
// response instead of a command or
// a command completion signal
// disable token.
#define MMCHS_CON_INIT 0x00000002 // Send initialization stream All
// cards. When this bit is set to 1
// and the card is idle an
// initialization sequence is sent
// to the card. "An initialization
// sequence consists of setting the
// CMD line to 1 during 80 clock
// cycles. The initialisation
// sequence is mandatory - but it is
// not required to do it through
// this bit - this bit makes it
// easier. Clock divider
// (MMCHS_SYSCTL[CLKD]) should be
// set to ensure that 80 clock
// periods are greater than 1ms.
// (see section 9.3 ""Power-Up"" in
// the MMC card specification [1] or
// section 6.4 in the SD card
// specification [2])." Note: in
// this mode there is no command
// sent to the card and no response
// is expected 0 The host does not
// send an initialization sequence.
// 1 The host sends an
// initialization sequence.
#define MMCHS_CON_OD 0x00000001 // Card open drain mode. Only for
// MMC cards. This bit must be set
// to 1 for MMC card commands 1 2 3
// and 40 and if the MMC card bus is
// operating in open-drain mode
// during the response phase to the
// command sent. Typically during
// card identification mode when the
// card is either in idle ready or
// ident state. It is also necessary
// to set this bit to 1 for a
// broadcast host response (see
// Broadcast host response register
// MMCHS_CON[HR]) 0 No Open Drain 1
// Open Drain or Broadcast host
// response
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_PWCNT register.
//
//******************************************************************************
#define MMCHS_PWCNT_PWRCNT_M 0x0000FFFF // Power counter register. This
// register is used to introduce a
// delay between the PAD ACTIVE pin
// assertion and the command issued.
// 0x0000 No additional delay added
// 0x0001 TCF delay (card clock
// period) 0x0002 TCF x 2 delay
// (card clock period) 0xFFFE TCF x
// 65534 delay (card clock period)
// 0xFFFF TCF x 65535 delay (card
// clock period)
#define MMCHS_PWCNT_PWRCNT_S 0
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_BLK register.
//
//******************************************************************************
#define MMCHS_BLK_NBLK_M 0xFFFF0000 // Blocks count for current
// transfer This register is enabled
// when Block count Enable
// (MMCHS_CMD[BCE]) is set to 1 and
// is valid only for multiple block
// transfers. Setting the block
// count to 0 results no data blocks
// being transferred. Note: The host
// controller decrements the block
// count after each block transfer
// and stops when the count reaches
// zero. This register can be
// accessed only if no transaction
// is executing (i.e after a
// transaction has stopped). Read
// operations during transfers may
// return an invalid value and write
// operation will be ignored. In
// suspend context the number of
// blocks yet to be transferred can
// be determined by reading this
// register. When restoring transfer
// context prior to issuing a Resume
// command The local host shall
// restore the previously saved
// block count. 0x0000 Stop count
// 0x0001 1 block 0x0002 2 blocks
// 0xFFFF 65535 blocks
#define MMCHS_BLK_NBLK_S 16
#define MMCHS_BLK_BLEN_M 0x00000FFF // Transfer Block Size. This
// register specifies the block size
// for block data transfers. Read
// operations during transfers may
// return an invalid value and write
// operations are ignored. When a
// CMD12 command is issued to stop
// the transfer a read of the BLEN
// field after transfer completion
// (MMCHS_STAT[TC] set to 1) will
// not return the true byte number
// of data length while the stop
// occurs but the value written in
// this register before transfer is
// launched. 0x000 No data transfer
// 0x001 1 byte block length 0x002 2
// bytes block length 0x003 3 bytes
// block length 0x1FF 511 bytes
// block length 0x200 512 bytes
// block length 0x7FF 2047 bytes
// block length 0x800 2048 bytes
// block length
#define MMCHS_BLK_BLEN_S 0
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_ARG register.
//
//******************************************************************************
#define MMCHS_ARG_ARG_M 0xFFFFFFFF // Command argument bits [31:0]
#define MMCHS_ARG_ARG_S 0
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_CMD register.
//
//******************************************************************************
#define MMCHS_CMD_INDX_M 0x3F000000 // Command index Binary encoded
// value from 0 to 63 specifying the
// command number send to card 0x00
// CMD0 or ACMD0 0x01 CMD1 or ACMD1
// 0x02 CMD2 or ACMD2 0x03 CMD3 or
// ACMD3 0x04 CMD4 or ACMD4 0x05
// CMD5 or ACMD5 0x06 CMD6 or ACMD6
// 0x07 CMD7 or ACMD7 0x08 CMD8 or
// ACMD8 0x09 CMD9 or ACMD9 0x0A
// CMD10 or ACMD10 0x0B CMD11 or
// ACMD11 0x0C CMD12 or ACMD12 0x0D
// CMD13 or ACMD13 0x0E CMD14 or
// ACMD14 0x0F CMD15 or ACMD15 0x10
// CMD16 or ACMD16 0x11 CMD17 or
// ACMD17 0x12 CMD18 or ACMD18 0x13
// CMD19 or ACMD19 0x14 CMD20 or
// ACMD20 0x15 CMD21 or ACMD21 0x16
// CMD22 or ACMD22 0x17 CMD23 or
// ACMD23 0x18 CMD24 or ACMD24 0x19
// CMD25 or ACMD25 0x1A CMD26 or
// ACMD26 0x1B CMD27 or ACMD27 0x1C
// CMD28 or ACMD28 0x1D CMD29 or
// ACMD29 0x1E CMD30 or ACMD30 0x1F
// CMD31 or ACMD31 0x20 CMD32 or
// ACMD32 0x21 CMD33 or ACMD33 0x22
// CMD34 or ACMD34 0x23 CMD35 or
// ACMD35 0x24 CMD36 or ACMD36 0x25
// CMD37 or ACMD37 0x26 CMD38 or
// ACMD38 0x27 CMD39 or ACMD39 0x28
// CMD40 or ACMD40 0x29 CMD41 or
// ACMD41 0x2A CMD42 or ACMD42 0x2B
// CMD43 or ACMD43 0x2C CMD44 or
// ACMD44 0x2D CMD45 or ACMD45 0x2E
// CMD46 or ACMD46 0x2F CMD47 or
// ACMD47 0x30 CMD48 or ACMD48 0x31
// CMD49 or ACMD49 0x32 CMD50 or
// ACMD50 0x33 CMD51 or ACMD51 0x34
// CMD52 or ACMD52 0x35 CMD53 or
// ACMD53 0x36 CMD54 or ACMD54 0x37
// CMD55 or ACMD55 0x38 CMD56 or
// ACMD56 0x39 CMD57 or ACMD57 0x3A
// CMD58 or ACMD58 0x3B CMD59 or
// ACMD59 0x3C CMD60 or ACMD60 0x3D
// CMD61 or ACMD61 0x3E CMD62 or
// ACMD62 0x3F CMD63 or ACMD63
#define MMCHS_CMD_INDX_S 24
#define MMCHS_CMD_CMD_TYPE_M 0x00C00000 // Command type This register
// specifies three types of special
// command: Suspend Resume and
// Abort. These bits shall be set to
// 00b for all other commands. 0x0
// Others Commands 0x1 "CMD52 for
// writing ""Bus Suspend"" in CCCR"
// 0x2 "CMD52 for writing ""Function
// Select"" in CCCR" 0x3 "Abort
// command CMD12 CMD52 for writing
// "" I/O Abort"" in CCCR"
#define MMCHS_CMD_CMD_TYPE_S 22
#define MMCHS_CMD_DP 0x00200000 // Data present select This
// register indicates that data is
// present and DAT line shall be
// used. It must be set to 0 in the
// following conditions: - command
// using only CMD line - command
// with no data transfer but using
// busy signal on DAT[0] - Resume
// command 0 Command with no data
// transfer 1 Command with data
// transfer
#define MMCHS_CMD_CICE 0x00100000 // Command Index check enable This
// bit must be set to 1 to enable
// index check on command response
// to compare the index field in the
// response against the index of the
// command. If the index is not the
// same in the response as in the
// command it is reported as a
// command index error
// (MMCHS_STAT[CIE] set to1) Note:
// The register CICE cannot be
// configured for an Auto CMD12 then
// index check is automatically
// checked when this command is
// issued. 0 Index check disable 1
// Index check enable
#define MMCHS_CMD_CCCE 0x00080000 // Command CRC check enable This
// bit must be set to 1 to enable
// CRC7 check on command response to
// protect the response against
// transmission errors on the bus.
// If an error is detected it is
// reported as a command CRC error
// (MMCHS_STAT[CCRC] set to 1).
// Note: The register CCCE cannot be
// configured for an Auto CMD12 and
// then CRC check is automatically
// checked when this command is
// issued. 0 CRC7 check disable 1
// CRC7 check enable
#define MMCHS_CMD_RSP_TYPE_M 0x00030000 // Response type This bits defines
// the response type of the command
// 0x0 No response 0x1 Response
// Length 136 bits 0x2 Response
// Length 48 bits 0x3 Response
// Length 48 bits with busy after
// response
#define MMCHS_CMD_RSP_TYPE_S 16
#define MMCHS_CMD_MSBS 0x00000020 // Multi/Single block select This
// bit must be set to 1 for data
// transfer in case of multi block
// command. For any others command
// this bit shall be set to 0. 0
// Single block. If this bit is 0 it
// is not necessary to set the
// register MMCHS_BLK[NBLK]. 1 Multi
// block. When Block Count is
// disabled (MMCHS_CMD[BCE] is set
// to 0) in Multiple block transfers
// (MMCHS_CMD[MSBS] is set to 1) the
// module can perform infinite
// transfer.
#define MMCHS_CMD_DDIR 0x00000010 // Data transfer Direction Select
// This bit defines either data
// transfer will be a read or a
// write. 0 Data Write (host to
// card) 1 Data Read (card to host)
#define MMCHS_CMD_ACEN 0x00000004 // Auto CMD12 Enable SD card only.
// When this bit is set to 1 the
// host controller issues a CMD12
// automatically after the transfer
// completion of the last block. The
// Host Driver shall not set this
// bit to issue commands that do not
// require CMD12 to stop data
// transfer. In particular secure
// commands do not require CMD12. 0
// Auto CMD12 disable 1 Auto CMD12
// enable or CCS detection enabled.
#define MMCHS_CMD_BCE 0x00000002 // Block Count Enable Multiple
// block transfers only. This bit is
// used to enable the block count
// register (MMCHS_BLK[NBLK]). When
// Block Count is disabled
// (MMCHS_CMD[BCE] is set to 0) in
// Multiple block transfers
// (MMCHS_CMD[MSBS] is set to 1) the
// module can perform infinite
// transfer. 0 Block count disabled
// for infinite transfer. 1 Block
// count enabled for multiple block
// transfer with known number of
// blocks
#define MMCHS_CMD_DE 0x00000001 // DMA Enable This bit is used to
// enable DMA mode for host data
// access. 0 DMA mode disable 1 DMA
// mode enable
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_RSP10 register.
//
//******************************************************************************
#define MMCHS_RSP10_RSP1_M 0xFFFF0000 // Command Response [31:16]
#define MMCHS_RSP10_RSP1_S 16
#define MMCHS_RSP10_RSP0_M 0x0000FFFF // Command Response [15:0]
#define MMCHS_RSP10_RSP0_S 0
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_RSP32 register.
//
//******************************************************************************
#define MMCHS_RSP32_RSP3_M 0xFFFF0000 // Command Response [63:48]
#define MMCHS_RSP32_RSP3_S 16
#define MMCHS_RSP32_RSP2_M 0x0000FFFF // Command Response [47:32]
#define MMCHS_RSP32_RSP2_S 0
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_RSP54 register.
//
//******************************************************************************
#define MMCHS_RSP54_RSP5_M 0xFFFF0000 // Command Response [95:80]
#define MMCHS_RSP54_RSP5_S 16
#define MMCHS_RSP54_RSP4_M 0x0000FFFF // Command Response [79:64]
#define MMCHS_RSP54_RSP4_S 0
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_RSP76 register.
//
//******************************************************************************
#define MMCHS_RSP76_RSP7_M 0xFFFF0000 // Command Response [127:112]
#define MMCHS_RSP76_RSP7_S 16
#define MMCHS_RSP76_RSP6_M 0x0000FFFF // Command Response [111:96]
#define MMCHS_RSP76_RSP6_S 0
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_DATA register.
//
//******************************************************************************
#define MMCHS_DATA_DATA_M 0xFFFFFFFF // Data Register [31:0] In
// functional mode (MMCHS_CON[MODE]
// set to the default value 0) A
// read access to this register is
// allowed only when the buffer read
// enable status is set to 1
// (MMCHS_PSTATE[BRE]) otherwise a
// bad access (MMCHS_STAT[BADA]) is
// signaled. A write access to this
// register is allowed only when the
// buffer write enable status is set
// to 1(MMCHS_STATE[BWE]) otherwise
// a bad access (MMCHS_STAT[BADA])
// is signaled and the data is not
// written.
#define MMCHS_DATA_DATA_S 0
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_PSTATE register.
//
//******************************************************************************
#define MMCHS_PSTATE_CLEV 0x01000000
#define MMCHS_PSTATE_DLEV_M 0x00F00000 // DAT[3:0] line signal level
// DAT[3] => bit 23 DAT[2] => bit 22
// DAT[1] => bit 21 DAT[0] => bit 20
// This status is used to check DAT
// line level to recover from errors
// and for debugging. This is
// especially useful in detecting
// the busy signal level from
// DAT[0]. The value of these
// registers after reset depends on
// the DAT lines level at that time.
#define MMCHS_PSTATE_DLEV_S 20
#define MMCHS_PSTATE_WP 0x00080000
#define MMCHS_PSTATE_CDPL 0x00040000
#define MMCHS_PSTATE_CSS 0x00020000
#define MMCHS_PSTATE_CINS 0x00010000
#define MMCHS_PSTATE_BRE 0x00000800
#define MMCHS_PSTATE_BWE 0x00000400
#define MMCHS_PSTATE_RTA 0x00000200
#define MMCHS_PSTATE_WTA 0x00000100
#define MMCHS_PSTATE_DLA 0x00000004
#define MMCHS_PSTATE_DATI 0x00000002
#define MMCHS_PSTATE_CMDI 0x00000001
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_HCTL register.
//
//******************************************************************************
#define MMCHS_HCTL_OBWE 0x08000000 // Wakeup event enable for
// 'Out-of-Band' Interrupt. This bit
// enables wakeup events for
// 'Out-of-Band' assertion. Wakeup
// is generated if the wakeup
// feature is enabled
// (MMCHS_SYSCONFIG[ENAWAKEUP]). The
// write to this register is ignored
// when MMCHS_CON[OBIE] is not set.
// 0 Disable wakeup on 'Out-of-Band'
// Interrupt 1 Enable wakeup on
// 'Out-of-Band' Interrupt
#define MMCHS_HCTL_REM 0x04000000 // Wakeup event enable on SD card
// removal This bit enables wakeup
// events for card removal
// assertion. Wakeup is generated if
// the wakeup feature is enabled
// (MMCHS_SYSCONFIG[ENAWAKEUP]). 0
// Disable wakeup on card removal 1
// Enable wakeup on card removal
#define MMCHS_HCTL_INS 0x02000000 // Wakeup event enable on SD card
// insertion This bit enables wakeup
// events for card insertion
// assertion. Wakeup is generated if
// the wakeup feature is enabled
// (MMCHS_SYSCONFIG[ENAWAKEUP]). 0
// Disable wakeup on card insertion
// 1 Enable wakeup on card insertion
#define MMCHS_HCTL_IWE 0x01000000 // Wakeup event enable on SD card
// interrupt This bit enables wakeup
// events for card interrupt
// assertion. Wakeup is generated if
// the wakeup feature is enabled
// (MMCHS_SYSCONFIG[ENAWAKEUP]). 0
// Disable wakeup on card interrupt
// 1 Enable wakeup on card interrupt
#define MMCHS_HCTL_IBG 0x00080000 // Interrupt block at gap This bit
// is valid only in 4-bit mode of
// SDIO card to enable interrupt
// detection in the interrupt cycle
// at block gap for a multiple block
// transfer. For MMC cards and for
// SD card this bit should be set to
// 0. 0 Disable interrupt detection
// at the block gap in 4-bit mode 1
// Enable interrupt detection at the
// block gap in 4-bit mode
#define MMCHS_HCTL_RWC 0x00040000 // Read wait control The read wait
// function is optional only for
// SDIO cards. If the card supports
// read wait this bit must be
// enabled then requesting a stop at
// block gap (MMCHS_HCTL[SBGR])
// generates a read wait period
// after the current end of block.
// Be careful if read wait is not
// supported it may cause a conflict
// on DAT line. 0 Disable Read Wait
// Control. Suspend/Resume cannot be
// supported. 1 Enable Read Wait
// Control
#define MMCHS_HCTL_CR 0x00020000 // Continue request This bit is
// used to restart a transaction
// that was stopped by requesting a
// stop at block gap
// (MMCHS_HCTL[SBGR]). Set this bit
// to 1 restarts the transfer. The
// bit is automatically set to 0 by
// the host controller when transfer
// has restarted i.e DAT line is
// active (MMCHS_PSTATE[DLA]) or
// transferring data
// (MMCHS_PSTATE[WTA]). The Stop at
// block gap request must be
// disabled (MMCHS_HCTL[SBGR]=0)
// before setting this bit. 0 No
// affect 1 transfer restart
#define MMCHS_HCTL_SBGR 0x00010000 // Stop at block gap request This
// bit is used to stop executing a
// transaction at the next block
// gap. The transfer can restart
// with a continue request
// (MMHS_HCTL[CR]) or during a
// suspend/resume sequence. In case
// of read transfer the card must
// support read wait control. In
// case of write transfer the host
// driver shall set this bit after
// all block data written. Until the
// transfer completion
// (MMCHS_STAT[TC] set to 1) the
// host driver shall leave this bit
// set to 1. If this bit is set the
// local host shall not write to the
// data register (MMCHS_DATA). 0
// Transfer mode 1 Stop at block gap
#define MMCHS_HCTL_SDVS_M 0x00000E00 // SD bus voltage select All cards.
// The host driver should set to
// these bits to select the voltage
// level for the card according to
// the voltage supported by the
// system (MMCHS_CAPA[VS18VS30VS33])
// before starting a transfer. 0x5
// 1.8V (Typical) 0x6 3.0V (Typical)
// 0x7 3.3V (Typical)
#define MMCHS_HCTL_SDVS_S 9
#define MMCHS_HCTL_SDBP 0x00000100 // SD bus power Before setting this
// bit the host driver shall select
// the SD bus voltage
// (MMCHS_HCTL[SDVS]). If the host
// controller detects the No card
// state this bit is automatically
// set to 0. If the module is power
// off a write in the command
// register (MMCHS_CMD) will not
// start the transfer. A write to
// this bit has no effect if the
// selected SD bus voltage
// MMCHS_HCTL[SDVS] is not supported
// according to capability register
// (MMCHS_CAPA[VS*]). 0 Power off 1
// Power on
#define MMCHS_HCTL_CDSS 0x00000080 // Card Detect Signal Selection
// This bit selects source for the
// card detection.When the source
// for the card detection is
// switched the interrupt should be
// disabled during the switching
// period by clearing the Interrupt
// Status/Signal Enable register in
// order to mask unexpected
// interrupt being caused by the
// glitch. The Interrupt
// Status/Signal Enable should be
// disabled during over the period
// of debouncing. 0 SDCD# is
// selected (for normal use) 1 The
// Card Detect Test Level is
// selected (for test purpose)
#define MMCHS_HCTL_CDTL 0x00000040 // Card Detect Test Level: This bit
// is enabled while the Card Detect
// Signal Selection is set to 1 and
// it indicates card inserted or
// not. 0 No Card 1 Card Inserted
#define MMCHS_HCTL_DMAS_M 0x00000018 // DMA Select Mode: One of
// supported DMA modes can be
// selected. The host driver shall
// check support of DMA modes by
// referring the Capabilities
// register. Use of selected DMA is
// determined by DMA Enable of the
// Transfer Mode register. This
// register is only meaningful when
// MADMA_EN is set to 1. When
// MADMA_EN is set to 0 the bit
// field is read only and returned
// value is 0. 0x0 Reserved 0x1
// Reserved 0x2 32-bit Address ADMA2
// is selected 0x3 Reserved
#define MMCHS_HCTL_DMAS_S 3
#define MMCHS_HCTL_HSPE 0x00000004 // High Speed Enable: Before
// setting this bit the Host Driver
// shall check the High Speed
// Support in the Capabilities
// register. If this bit is set to 0
// (default) the Host Controller
// outputs CMD line and DAT lines at
// the falling edge of the SD Clock.
// If this bit is set to 1 the Host
// Controller outputs CMD line and
// DAT lines at the rising edge of
// the SD Clock.This bit shall not
// be set when dual data rate mode
// is activated in MMCHS_CON[DDR]. 0
// Normal speed mode 1 High speed
// mode
#define MMCHS_HCTL_DTW 0x00000002 // Data transfer width For MMC card
// this bit must be set following a
// valid SWITCH command (CMD6) with
// the correct value and extend CSD
// index written in the argument.
// Prior to this command the MMC
// card configuration register (CSD
// and EXT_CSD) must be verified for
// compliance with MMC standard
// specification 4.x (see section
// 3.6). This register has no effect
// when the MMC 8-bit mode is
// selected (register MMCHS_CON[DW8]
// set to1 ) For SD/SDIO cards this
// bit must be set following a valid
// SET_BUS_WIDTH command (ACMD6)
// with the value written in bit 1
// of the argument. Prior to this
// command the SD card configuration
// register (SCR) must be verified
// for the supported bus width by
// the SD card. 0 1-bit Data width
// (DAT[0] used) 1 4-bit Data width
// (DAT[3:0] used)
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_SYSCTL register.
//
//******************************************************************************
#define MMCHS_SYSCTL_SRD 0x04000000 // Software reset for DAT line This
// bit is set to 1 for reset and
// released to 0 when completed. DAT
// finite state machine in both
// clock domain are also reset. Here
// below are the registers cleared
// by MMCHS_SYSCTL[SRD]: #VALUE! -
// MMCHS_PSTATE: BRE BWE RTA WTA DLA
// and DATI - MMCHS_HCTL: SBGR and
// CR - MMCHS_STAT: BRR BWR BGE and
// TC OCP and MMC buffer data
// management is reinitialized. 0
// Reset completed 1 Software reset
// for DAT line
#define MMCHS_SYSCTL_SRC 0x02000000 // Software reset for CMD line This
// bit is set to 1 for reset and
// released to 0 when completed. CMD
// finite state machine in both
// clock domain are also reset. Here
// below the registers cleared by
// MMCHS_SYSCTL[SRC]: -
// MMCHS_PSTATE: CMDI - MMCHS_STAT:
// CC OCP and MMC command status
// management is reinitialized. 0
// Reset completed 1 Software reset
// for CMD line
#define MMCHS_SYSCTL_SRA 0x01000000 // Software reset for all This bit
// is set to 1 for reset and
// released to 0 when completed.
// This reset affects the entire
// host controller except for the
// card detection circuit and
// capabilities registers. 0 Reset
// completed 1 Software reset for
// all the design
#define MMCHS_SYSCTL_DTO_M 0x000F0000 // Data timeout counter value and
// busy timeout. This value
// determines the interval by which
// DAT lines timeouts are detected.
// The host driver needs to set this
// bitfield based on - the maximum
// read access time (NAC) (Refer to
// the SD Specification Part1
// Physical Layer) - the data read
// access time values (TAAC and
// NSAC) in the card specific data
// register (CSD) of the card - the
// timeout clock base frequency
// (MMCHS_CAPA[TCF]). If the card
// does not respond within the
// specified number of cycles a data
// timeout error occurs
// (MMCHS_STA[DTO]). The
// MMCHS_SYSCTL[DTO] register is
// also used to check busy duration
// to generate busy timeout for
// commands with busy response or
// for busy programming during a
// write command. Timeout on CRC
// status is generated if no CRC
// token is present after a block
// write. 0x0 TCF x 2^13 0x1 TCF x
// 2^14 0xE TCF x 2^27 0xF Reserved
#define MMCHS_SYSCTL_DTO_S 16
#define MMCHS_SYSCTL_CLKD_M 0x0000FFC0 // Clock frequency select These
// bits define the ratio between a
// reference clock frequency (system
// dependant) and the output clock
// frequency on the CLK pin of
// either the memory card (MMC SD or
// SDIO). 0x000 Clock Ref bypass
// 0x001 Clock Ref bypass 0x002
// Clock Ref / 2 0x003 Clock Ref / 3
// 0x3FF Clock Ref / 1023
#define MMCHS_SYSCTL_CLKD_S 6
#define MMCHS_SYSCTL_CEN 0x00000004 // Clock enable This bit controls
// if the clock is provided to the
// card or not. 0 The clock is not
// provided to the card . Clock
// frequency can be changed . 1 The
// clock is provided to the card and
// can be automatically gated when
// MMCHS_SYSCONFIG[AUTOIDLE] is set
// to 1 (default value) . The host
// driver shall wait to set this bit
// to 1 until the Internal clock is
// stable (MMCHS_SYSCTL[ICS]).
#define MMCHS_SYSCTL_ICS 0x00000002
#define MMCHS_SYSCTL_ICE 0x00000001 // Internal clock enable This
// register controls the internal
// clock activity. In very low power
// state the internal clock is
// stopped. Note: The activity of
// the debounce clock (used for
// wakeup events) and the OCP clock
// (used for reads and writes to the
// module register map) are not
// affected by this register. 0 The
// internal clock is stopped (very
// low power state). 1 The internal
// clock oscillates and can be
// automatically gated when
// MMCHS_SYSCONFIG[AUTOIDLE] is set
// to 1 (default value) .
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_STAT register.
//
//******************************************************************************
#define MMCHS_STAT_BADA 0x20000000
#define MMCHS_STAT_CERR 0x10000000
#define MMCHS_STAT_ADMAE 0x02000000
#define MMCHS_STAT_ACE 0x01000000
#define MMCHS_STAT_DEB 0x00400000
#define MMCHS_STAT_DCRC 0x00200000
#define MMCHS_STAT_DTO 0x00100000
#define MMCHS_STAT_CIE 0x00080000
#define MMCHS_STAT_CEB 0x00040000
#define MMCHS_STAT_CCRC 0x00020000
#define MMCHS_STAT_CTO 0x00010000
#define MMCHS_STAT_ERRI 0x00008000
#define MMCHS_STAT_BSR 0x00000400
#define MMCHS_STAT_OBI 0x00000200
#define MMCHS_STAT_CIRQ 0x00000100
#define MMCHS_STAT_CREM 0x00000080
#define MMCHS_STAT_CINS 0x00000040
#define MMCHS_STAT_BRR 0x00000020
#define MMCHS_STAT_BWR 0x00000010
#define MMCHS_STAT_DMA 0x00000008
#define MMCHS_STAT_BGE 0x00000004
#define MMCHS_STAT_TC 0x00000002
#define MMCHS_STAT_CC 0x00000001
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_IE register.
//
//******************************************************************************
#define MMCHS_IE_BADA_ENABLE 0x20000000 // Bad access to data space
// Interrupt Enable 0 Masked 1
// Enabled
#define MMCHS_IE_CERR_ENABLE 0x10000000 // Card error interrupt Enable 0
// Masked 1 Enabled
#define MMCHS_IE_ADMAE_ENABLE 0x02000000 // ADMA error Interrupt Enable 0
// Masked 1 Enabled
#define MMCHS_IE_ACE_ENABLE 0x01000000 // Auto CMD12 error Interrupt
// Enable 0 Masked 1 Enabled
#define MMCHS_IE_DEB_ENABLE 0x00400000 // Data end bit error Interrupt
// Enable 0 Masked 1 Enabled
#define MMCHS_IE_DCRC_ENABLE 0x00200000 // Data CRC error Interrupt Enable
// 0 Masked 1 Enabled
#define MMCHS_IE_DTO_ENABLE 0x00100000 // Data timeout error Interrupt
// Enable 0 The data timeout
// detection is deactivated. The
// host controller provides the
// clock to the card until the card
// sends the data or the transfer is
// aborted. 1 The data timeout
// detection is enabled.
#define MMCHS_IE_CIE_ENABLE 0x00080000 // Command index error Interrupt
// Enable 0 Masked 1 Enabled
#define MMCHS_IE_CEB_ENABLE 0x00040000 // Command end bit error Interrupt
// Enable 0 Masked 1 Enabled
#define MMCHS_IE_CCRC_ENABLE 0x00020000 // Command CRC error Interrupt
// Enable 0 Masked 1 Enabled
#define MMCHS_IE_CTO_ENABLE 0x00010000 // Command timeout error Interrupt
// Enable 0 Masked 1 Enabled
#define MMCHS_IE_NULL 0x00008000 // Fixed to 0 The host driver shall
// control error interrupts using
// the Error Interrupt Signal Enable
// register. Writes to this bit are
// ignored
#define MMCHS_IE_BSR_ENABLE 0x00000400 // Boot status interrupt Enable A
// write to this register when
// MMCHS_CON[BOOT_ACK] is set to 0x0
// is ignored. 0 Masked 1 Enabled
#define MMCHS_IE_OBI_ENABLE 0x00000200 // Out-of-Band interrupt Enable A
// write to this register when
// MMCHS_CON[OBIE] is set to '0' is
// ignored. 0 Masked 1 Enabled
#define MMCHS_IE_CIRQ_ENABLE 0x00000100 // Card interrupt Enable A clear of
// this bit also clears the
// corresponding status bit. During
// 1-bit mode if the interrupt
// routine doesn't remove the source
// of a card interrupt in the SDIO
// card the status bit is reasserted
// when this bit is set to 1. 0
// Masked 1 Enabled
#define MMCHS_IE_CREM_ENABLE 0x00000080 // Card removal Interrupt Enable 0
// Masked 1 Enabled
#define MMCHS_IE_CINS_ENABLE 0x00000040 // Card insertion Interrupt Enable
// 0 Masked 1 Enabled
#define MMCHS_IE_BRR_ENABLE 0x00000020 // Buffer Read Ready Interrupt
// Enable 0 Masked 1 Enabled
#define MMCHS_IE_BWR_ENABLE 0x00000010 // Buffer Write Ready Interrupt
// Enable 0 Masked 1 Enabled
#define MMCHS_IE_DMA_ENABLE 0x00000008 // DMA interrupt Enable 0 Masked 1
// Enabled
#define MMCHS_IE_BGE_ENABLE 0x00000004 // Block Gap Event Interrupt Enable
// 0 Masked 1 Enabled
#define MMCHS_IE_TC_ENABLE 0x00000002 // Transfer completed Interrupt
// Enable 0 Masked 1 Enabled
#define MMCHS_IE_CC_ENABLE 0x00000001 // Command completed Interrupt
// Enable 0 Masked 1 Enabled
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_ISE register.
//
//******************************************************************************
#define MMCHS_ISE_BADA_SIGEN 0x20000000 // Bad access to data space signal
// status Enable 0 Masked 1 Enabled
#define MMCHS_ISE_CERR_SIGEN 0x10000000 // Card error interrupt signal
// status Enable 0 Masked 1 Enabled
#define MMCHS_ISE_ADMAE_SIGEN 0x02000000 // ADMA error signal status Enable
// 0 Masked 1 Enabled
#define MMCHS_ISE_ACE_SIGEN 0x01000000 // Auto CMD12 error signal status
// Enable 0 Masked 1 Enabled
#define MMCHS_ISE_DEB_SIGEN 0x00400000 // Data end bit error signal status
// Enable 0 Masked 1 Enabled
#define MMCHS_ISE_DCRC_SIGEN 0x00200000 // Data CRC error signal status
// Enable 0 Masked 1 Enabled
#define MMCHS_ISE_DTO_SIGEN 0x00100000 // Data timeout error signal status
// Enable 0 Masked 1 Enabled
#define MMCHS_ISE_CIE_SIGEN 0x00080000 // Command index error signal
// status Enable 0 Masked 1 Enabled
#define MMCHS_ISE_CEB_SIGEN 0x00040000 // Command end bit error signal
// status Enable 0 Masked 1 Enabled
#define MMCHS_ISE_CCRC_SIGEN 0x00020000 // Command CRC error signal status
// Enable 0 Masked 1 Enabled
#define MMCHS_ISE_CTO_SIGEN 0x00010000 // Command timeout error signal
// status Enable 0 Masked 1 Enabled
#define MMCHS_ISE_NULL 0x00008000 // Fixed to 0 The host driver shall
// control error interrupts using
// the Error Interrupt Signal Enable
// register. Writes to this bit are
// ignored
#define MMCHS_ISE_BSR_SIGEN 0x00000400 // Boot status signal status
// EnableA write to this register
// when MMCHS_CON[BOOT_ACK] is set
// to 0x0 is ignored. 0 Masked 1
// Enabled
#define MMCHS_ISE_OBI_SIGEN 0x00000200 // Out-Of-Band Interrupt signal
// status Enable A write to this
// register when MMCHS_CON[OBIE] is
// set to '0' is ignored. 0 Masked 1
// Enabled
#define MMCHS_ISE_CIRQ_SIGEN 0x00000100 // Card interrupt signal status
// Enable 0 Masked 1 Enabled
#define MMCHS_ISE_CREM_SIGEN 0x00000080 // Card removal signal status
// Enable 0 Masked 1 Enabled
#define MMCHS_ISE_CINS_SIGEN 0x00000040 // Card insertion signal status
// Enable 0 Masked 1 Enabled
#define MMCHS_ISE_BRR_SIGEN 0x00000020 // Buffer Read Ready signal status
// Enable 0 Masked 1 Enabled
#define MMCHS_ISE_BWR_SIGEN 0x00000010 // Buffer Write Ready signal status
// Enable 0 Masked 1 Enabled
#define MMCHS_ISE_DMA_SIGEN 0x00000008 // DMA interrupt Signal status
// enable 0 Masked 1 Enabled
#define MMCHS_ISE_BGE_SIGEN 0x00000004 // Black Gap Event signal status
// Enable 0 Masked 1 Enabled
#define MMCHS_ISE_TC_SIGEN 0x00000002 // Transfer completed signal status
// Enable 0 Masked 1 Enabled
#define MMCHS_ISE_CC_SIGEN 0x00000001 // Command completed signal status
// Enable 0 Masked 1 Enabled
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_AC12 register.
//
//******************************************************************************
#define MMCHS_AC12_CNI 0x00000080
#define MMCHS_AC12_ACIE 0x00000010
#define MMCHS_AC12_ACEB 0x00000008
#define MMCHS_AC12_ACCE 0x00000004
#define MMCHS_AC12_ACTO 0x00000002
#define MMCHS_AC12_ACNE 0x00000001
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_CAPA register.
//
//******************************************************************************
#define MMCHS_CAPA_BIT64 0x10000000
#define MMCHS_CAPA_VS18 0x04000000
#define MMCHS_CAPA_VS30 0x02000000
#define MMCHS_CAPA_VS33 0x01000000
#define MMCHS_CAPA_SRS 0x00800000
#define MMCHS_CAPA_DS 0x00400000
#define MMCHS_CAPA_HSS 0x00200000
#define MMCHS_CAPA_AD2S 0x00080000
#define MMCHS_CAPA_MBL_M 0x00030000
#define MMCHS_CAPA_MBL_S 16
#define MMCHS_CAPA_BCF_M 0x00003F00
#define MMCHS_CAPA_BCF_S 8
#define MMCHS_CAPA_TCU 0x00000080
#define MMCHS_CAPA_TCF_M 0x0000003F
#define MMCHS_CAPA_TCF_S 0
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_CUR_CAPA register.
//
//******************************************************************************
#define MMCHS_CUR_CAPA_CUR_1V8_M \
0x00FF0000
#define MMCHS_CUR_CAPA_CUR_1V8_S 16
#define MMCHS_CUR_CAPA_CUR_3V0_M \
0x0000FF00
#define MMCHS_CUR_CAPA_CUR_3V0_S 8
#define MMCHS_CUR_CAPA_CUR_3V3_M \
0x000000FF
#define MMCHS_CUR_CAPA_CUR_3V3_S 0
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_FE register.
//
//******************************************************************************
#define MMCHS_FE_FE_BADA 0x20000000
#define MMCHS_FE_FE_CERR 0x10000000
#define MMCHS_FE_FE_ADMAE 0x02000000
#define MMCHS_FE_FE_ACE 0x01000000
#define MMCHS_FE_FE_DEB 0x00400000
#define MMCHS_FE_FE_DCRC 0x00200000
#define MMCHS_FE_FE_DTO 0x00100000
#define MMCHS_FE_FE_CIE 0x00080000
#define MMCHS_FE_FE_CEB 0x00040000
#define MMCHS_FE_FE_CCRC 0x00020000
#define MMCHS_FE_FE_CTO 0x00010000
#define MMCHS_FE_FE_CNI 0x00000080
#define MMCHS_FE_FE_ACIE 0x00000010
#define MMCHS_FE_FE_ACEB 0x00000008
#define MMCHS_FE_FE_ACCE 0x00000004
#define MMCHS_FE_FE_ACTO 0x00000002
#define MMCHS_FE_FE_ACNE 0x00000001
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_ADMAES register.
//
//******************************************************************************
#define MMCHS_ADMAES_LME 0x00000004 // ADMA Length Mismatch Error: (1)
// While Block Count Enable being
// set the total data length
// specified by the Descriptor table
// is different from that specified
// by the Block Count and Block
// Length. (2) Total data length can
// not be divided by the block
// length. 0 No Error 1 Error
#define MMCHS_ADMAES_AES_M 0x00000003 // ADMA Error State his field
// indicates the state of ADMA when
// error is occurred during ADMA
// data transfer. "This field never
// indicates ""10"" because ADMA
// never stops in this state." 0x0
// ST_STOP (Stop DMA)Contents of
// SYS_SDR register 0x1 ST_STOP
// (Stop DMA)Points the error
// descriptor 0x2 Never set this
// state(Not used) 0x3 ST_TFR
// (Transfer Data)Points the next of
// the error descriptor
#define MMCHS_ADMAES_AES_S 0
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_ADMASAL register.
//
//******************************************************************************
#define MMCHS_ADMASAL_ADMA_A32B_M \
0xFFFFFFFF // ADMA System address 32 bits.This
// register holds byte address of
// executing command of the
// Descriptor table. 32-bit Address
// Descriptor uses lower 32-bit of
// this register. At the start of
// ADMA the Host Driver shall set
// start address of the Descriptor
// table. The ADMA increments this
// register address which points to
// next line when every fetching a
// Descriptor line. When the ADMA
// Error Interrupt is generated this
// register shall hold valid
// Descriptor address depending on
// the ADMA state. The Host Driver
// shall program Descriptor Table on
// 32-bit boundary and set 32-bit
// boundary address to this
// register. ADMA2 ignores lower
// 2-bit of this register and
// assumes it to be 00b.
#define MMCHS_ADMASAL_ADMA_A32B_S 0
//******************************************************************************
//
// The following are defines for the bit fields in the MMCHS_O_REV register.
//
//******************************************************************************
#define MMCHS_REV_VREV_M 0xFF000000 // Vendor Version Number: IP
// revision [7:4] Major revision
// [3:0] Minor revision Examples:
// 0x10 for 1.0 0x21 for 2.1
#define MMCHS_REV_VREV_S 24
#define MMCHS_REV_SREV_M 0x00FF0000
#define MMCHS_REV_SREV_S 16
#define MMCHS_REV_SIS 0x00000001 // Slot Interrupt Status This
// status bit indicates the inverted
// state of interrupt signal for the
// module. By a power on reset or by
// setting a software reset for all
// (MMCHS_HCTL[SRA]) the interrupt
// signal shall be de-asserted and
// this status shall read 0.
#endif // __HW_MMCHS_H__