\r
PAD_CONFIGURATION PadConfigurationTable[NUM_PINS] = {\r
//Pin, MuxMode, PullConfig, InputEnable\r
- { SDRC_D0, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D1, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D2, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D3, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D4, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D5, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D6, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D7, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D8, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D9, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D10, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D11, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D12, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D13, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D14, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D15, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D16, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D17, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D18, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D19, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D20, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D21, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D22, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D23, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D24, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D25, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D26, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D27, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D28, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D29, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D30, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_D31, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_CLK, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_DQS0, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_CKE0, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { SDRC_CKE1, MUXMODE7, PULLTYPENOSELECT, INPUT },\r
- { SDRC_DQS1, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_DQS2, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { SDRC_DQS3, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { GPMC_A1, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { GPMC_A2, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { GPMC_A3, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { GPMC_A4, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { GPMC_A5, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { GPMC_A6, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { GPMC_A7, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { GPMC_A8, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { GPMC_A9, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { GPMC_A10, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { GPMC_D0, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { GPMC_D1, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { GPMC_D2, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { GPMC_D3, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { GPMC_D4, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { GPMC_D5, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { GPMC_D6, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { GPMC_D7, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { GPMC_D8, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { GPMC_D9, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { GPMC_D10, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { GPMC_D11, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { GPMC_D12, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { GPMC_D13, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { GPMC_D14, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { GPMC_D15, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { GPMC_NCS0, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { GPMC_NCS1, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), OUTPUT },\r
- { GPMC_NCS2, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), OUTPUT },\r
- { GPMC_NCS3, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), OUTPUT },\r
- { GPMC_NCS4, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), OUTPUT },\r
- { GPMC_NCS5, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { GPMC_NCS6, MUXMODE1, PULLTYPENOSELECT, INPUT },\r
- { GPMC_NCS7, MUXMODE1, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { GPMC_CLK, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { GPMC_NADV_ALE, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { GPMC_NOE, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { GPMC_NWE, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { GPMC_NBE0_CLE, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { GPMC_NBE1, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { GPMC_NWP, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { GPMC_WAIT0, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { GPMC_WAIT1, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { GPMC_WAIT2, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { GPMC_WAIT3, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { DSS_PCLK, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { DSS_HSYNC, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { DSS_PSYNC, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { DSS_ACBIAS, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { DSS_DATA0, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { DSS_DATA1, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { DSS_DATA2, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { DSS_DATA3, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { DSS_DATA4, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { DSS_DATA5, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { DSS_DATA6, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { DSS_DATA7, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { DSS_DATA8, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { DSS_DATA9, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { DSS_DATA10, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { DSS_DATA11, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { DSS_DATA12, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { DSS_DATA13, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { DSS_DATA14, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { DSS_DATA15, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { DSS_DATA16, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { DSS_DATA17, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { DSS_DATA18, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { DSS_DATA19, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { DSS_DATA20, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { DSS_DATA21, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { DSS_DATA22, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { DSS_DATA23, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { CAM_HS, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { CAM_VS, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { CAM_XCLKA, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { CAM_PCLK, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { CAM_FLD, MUXMODE4, PULLTYPENOSELECT, OUTPUT },\r
- { CAM_D0, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { CAM_D1, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { CAM_D2, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { CAM_D3, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { CAM_D4, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { CAM_D5, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { CAM_D6, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { CAM_D7, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { CAM_D8, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { CAM_D9, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { CAM_D10, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { CAM_D11, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { CAM_XCLKB, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { CAM_WEN, MUXMODE4, PULLTYPENOSELECT, INPUT },\r
- { CAM_STROBE, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { CSI2_DX0, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { CSI2_DY0, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { CSI2_DX1, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { CSI2_DY1, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { MCBSP2_FSX, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { MCBSP2_CLKX, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { MCBSP2_DR, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { MCBSP2_DX, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { MMC1_CLK, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), OUTPUT },\r
- { MMC1_CMD, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { MMC1_DAT0, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { MMC1_DAT1, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { MMC1_DAT2, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { MMC1_DAT3, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { MMC1_DAT4, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { MMC1_DAT5, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { MMC1_DAT6, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { MMC1_DAT7, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { MMC2_CLK, MUXMODE4, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { MMC2_CMD, MUXMODE4, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { MMC2_DAT0, MUXMODE4, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { MMC2_DAT1, MUXMODE4, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { MMC2_DAT2, MUXMODE4, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { MMC2_DAT3, MUXMODE4, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { MMC2_DAT4, MUXMODE4, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { MMC2_DAT5, MUXMODE4, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { MMC2_DAT6, MUXMODE4, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { MMC2_DAT7, MUXMODE4, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { MCBSP3_DX, MUXMODE4, PULLTYPENOSELECT, OUTPUT },\r
- { MCBSP3_DR, MUXMODE4, PULLTYPENOSELECT, OUTPUT },\r
- { MCBSP3_CLKX, MUXMODE4, PULLTYPENOSELECT, OUTPUT },\r
- { MCBSP3_FSX, MUXMODE4, PULLTYPENOSELECT, OUTPUT },\r
- { UART2_CTS, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { UART2_RTS, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { UART2_TX, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { UART2_RX, MUXMODE4, PULLTYPENOSELECT, OUTPUT },\r
- { UART1_TX, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { UART1_RTS, MUXMODE4, PULLTYPENOSELECT, OUTPUT },\r
- { UART1_CTS, MUXMODE4, PULLTYPENOSELECT, OUTPUT },\r
- { UART1_RX, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { MCBSP4_CLKX, MUXMODE1, PULLTYPENOSELECT, INPUT },\r
- { MCBSP4_DR, MUXMODE1, PULLTYPENOSELECT, INPUT },\r
- { MCBSP4_DX, MUXMODE1, PULLTYPENOSELECT, INPUT },\r
- { MCBSP4_FSX, MUXMODE1, PULLTYPENOSELECT, INPUT },\r
- { MCBSP1_CLKR, MUXMODE4, PULLTYPENOSELECT, OUTPUT },\r
- { MCBSP1_FSR, MUXMODE4, (PULLTYPESELECT | PULLUDENABLE), OUTPUT },\r
- { MCBSP1_DX, MUXMODE4, PULLTYPENOSELECT, OUTPUT },\r
- { MCBSP1_DR, MUXMODE4, PULLTYPENOSELECT, OUTPUT },\r
- { MCBSP1_CLKS, MUXMODE0, PULLTYPESELECT, INPUT },\r
- { MCBSP1_FSX, MUXMODE4, PULLTYPENOSELECT, OUTPUT },\r
- { MCBSP1_CLKX, MUXMODE4, PULLTYPENOSELECT, OUTPUT },\r
- { UART3_CTS_RCTX,MUXMODE0, PULLUDENABLE, INPUT },\r
- { UART3_RTS_SD, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { UART3_RX_IRRX, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { UART3_TX_IRTX, MUXMODE0, PULLTYPENOSELECT, OUTPUT },\r
- { HSUSB0_CLK, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { HSUSB0_STP, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), OUTPUT },\r
- { HSUSB0_DIR, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { HSUSB0_NXT, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { HSUSB0_DATA0, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { HSUSB0_DATA1, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { HSUSB0_DATA2, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { HSUSB0_DATA3, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { HSUSB0_DATA4, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { HSUSB0_DATA5, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { HSUSB0_DATA6, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { HSUSB0_DATA7, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { I2C1_SCL, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { I2C1_SDA, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { I2C2_SCL, MUXMODE4, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { I2C2_SDA, MUXMODE4, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { I2C3_SCL, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { I2C3_SDA, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { HDQ_SIO, MUXMODE4, (PULLTYPESELECT | PULLUDENABLE), OUTPUT },\r
- { MCSPI1_CLK, MUXMODE4, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { MCSPI1_SIMO, MUXMODE4, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { MCSPI1_SOMI, MUXMODE0, PULLTYPENOSELECT, INPUT },\r
- { MCSPI1_CS0, MUXMODE0, PULLUDENABLE, INPUT },\r
- { MCSPI1_CS1, MUXMODE0, PULLUDENABLE, OUTPUT },\r
- { MCSPI1_CS2, MUXMODE4, PULLTYPENOSELECT, OUTPUT },\r
- { MCSPI1_CS3, MUXMODE3, PULLTYPESELECT, INPUT },\r
- { MCSPI2_CLK, MUXMODE3, PULLTYPESELECT, INPUT },\r
- { MCSPI2_SIMO, MUXMODE3, PULLTYPESELECT, INPUT },\r
- { MCSPI2_SOMI, MUXMODE3, PULLTYPESELECT, INPUT },\r
- { MCSPI2_CS0, MUXMODE3, PULLTYPESELECT, INPUT },\r
- { MCSPI2_CS1, MUXMODE3, PULLTYPESELECT, INPUT },\r
- { SYS_NIRQ, MUXMODE0, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { SYS_CLKOUT2, MUXMODE4, (PULLTYPESELECT | PULLUDENABLE), INPUT },\r
- { ETK_CLK, MUXMODE3, (PULLTYPESELECT | PULLUDENABLE), OUTPUT },\r
- { ETK_CTL, MUXMODE3, PULLTYPESELECT, OUTPUT },\r
- { ETK_D0, MUXMODE3, PULLTYPESELECT, INPUT },\r
- { ETK_D1, MUXMODE3, PULLTYPESELECT, INPUT },\r
- { ETK_D2, MUXMODE3, PULLTYPESELECT, INPUT },\r
- { ETK_D3, MUXMODE3, PULLTYPESELECT, INPUT },\r
- { ETK_D4, MUXMODE3, PULLTYPESELECT, INPUT },\r
- { ETK_D5, MUXMODE3, PULLTYPESELECT, INPUT },\r
- { ETK_D6, MUXMODE3, PULLTYPESELECT, INPUT },\r
- { ETK_D7, MUXMODE3, PULLTYPESELECT, INPUT },\r
- { ETK_D8, MUXMODE3, PULLTYPESELECT, INPUT },\r
- { ETK_D9, MUXMODE3, PULLTYPESELECT, INPUT },\r
- { ETK_D10, MUXMODE3, PULLTYPESELECT, OUTPUT },\r
- { ETK_D11, MUXMODE3, PULLTYPESELECT, OUTPUT },\r
- { ETK_D12, MUXMODE3, PULLTYPESELECT, INPUT },\r
- { ETK_D13, MUXMODE3, PULLTYPESELECT, INPUT },\r
- { ETK_D14, MUXMODE3, PULLTYPESELECT, INPUT },\r
- { ETK_D15, MUXMODE3, PULLTYPESELECT, INPUT }\r
+ { SDRC_D0, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D1, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D2, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D3, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D4, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D5, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D6, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D7, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D8, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D9, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D10, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D11, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D12, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D13, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D14, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D15, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D16, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D17, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D18, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D19, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D20, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D21, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D22, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D23, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D24, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D25, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D26, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D27, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D28, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D29, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D30, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_D31, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_CLK, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_DQS0, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_CKE0, MUXMODE0, PULL_UP_SELECTED, INPUT },\r
+ { SDRC_CKE1, MUXMODE7, PULL_DISABLED, INPUT },\r
+ { SDRC_DQS1, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_DQS2, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { SDRC_DQS3, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { GPMC_A1, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { GPMC_A2, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { GPMC_A3, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { GPMC_A4, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { GPMC_A5, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { GPMC_A6, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { GPMC_A7, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { GPMC_A8, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { GPMC_A9, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { GPMC_A10, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { GPMC_D0, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { GPMC_D1, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { GPMC_D2, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { GPMC_D3, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { GPMC_D4, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { GPMC_D5, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { GPMC_D6, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { GPMC_D7, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { GPMC_D8, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { GPMC_D9, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { GPMC_D10, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { GPMC_D11, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { GPMC_D12, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { GPMC_D13, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { GPMC_D14, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { GPMC_D15, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { GPMC_NCS0, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { GPMC_NCS1, MUXMODE0, PULL_UP_SELECTED, OUTPUT },\r
+ { GPMC_NCS2, MUXMODE0, PULL_UP_SELECTED, OUTPUT },\r
+ { GPMC_NCS3, MUXMODE0, PULL_UP_SELECTED, OUTPUT },\r
+ { GPMC_NCS4, MUXMODE0, PULL_UP_SELECTED, OUTPUT },\r
+ { GPMC_NCS5, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { GPMC_NCS6, MUXMODE1, PULL_DISABLED, INPUT },\r
+ { GPMC_NCS7, MUXMODE1, PULL_UP_SELECTED, INPUT },\r
+ { GPMC_CLK, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { GPMC_NADV_ALE, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { GPMC_NOE, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { GPMC_NWE, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { GPMC_NBE0_CLE, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { GPMC_NBE1, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { GPMC_NWP, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { GPMC_WAIT0, MUXMODE0, PULL_UP_SELECTED, INPUT },\r
+ { GPMC_WAIT1, MUXMODE0, PULL_UP_SELECTED, INPUT },\r
+ { GPMC_WAIT2, MUXMODE0, PULL_UP_SELECTED, INPUT },\r
+ { GPMC_WAIT3, MUXMODE0, PULL_UP_SELECTED, INPUT },\r
+ { DSS_PCLK, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { DSS_HSYNC, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { DSS_PSYNC, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { DSS_ACBIAS, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { DSS_DATA0, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { DSS_DATA1, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { DSS_DATA2, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { DSS_DATA3, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { DSS_DATA4, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { DSS_DATA5, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { DSS_DATA6, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { DSS_DATA7, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { DSS_DATA8, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { DSS_DATA9, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { DSS_DATA10, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { DSS_DATA11, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { DSS_DATA12, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { DSS_DATA13, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { DSS_DATA14, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { DSS_DATA15, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { DSS_DATA16, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { DSS_DATA17, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { DSS_DATA18, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { DSS_DATA19, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { DSS_DATA20, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { DSS_DATA21, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { DSS_DATA22, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { DSS_DATA23, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { CAM_HS, MUXMODE0, PULL_UP_SELECTED, INPUT },\r
+ { CAM_VS, MUXMODE0, PULL_UP_SELECTED, INPUT },\r
+ { CAM_XCLKA, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { CAM_PCLK, MUXMODE0, PULL_UP_SELECTED, INPUT },\r
+ { CAM_FLD, MUXMODE4, PULL_DISABLED, OUTPUT },\r
+ { CAM_D0, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { CAM_D1, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { CAM_D2, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { CAM_D3, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { CAM_D4, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { CAM_D5, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { CAM_D6, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { CAM_D7, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { CAM_D8, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { CAM_D9, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { CAM_D10, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { CAM_D11, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { CAM_XCLKB, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { CAM_WEN, MUXMODE4, PULL_DISABLED, INPUT },\r
+ { CAM_STROBE, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { CSI2_DX0, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { CSI2_DY0, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { CSI2_DX1, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { CSI2_DY1, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { MCBSP2_FSX, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { MCBSP2_CLKX, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { MCBSP2_DR, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { MCBSP2_DX, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { MMC1_CLK, MUXMODE0, PULL_UP_SELECTED, OUTPUT },\r
+ { MMC1_CMD, MUXMODE0, PULL_UP_SELECTED, INPUT },\r
+ { MMC1_DAT0, MUXMODE0, PULL_UP_SELECTED, INPUT },\r
+ { MMC1_DAT1, MUXMODE0, PULL_UP_SELECTED, INPUT },\r
+ { MMC1_DAT2, MUXMODE0, PULL_UP_SELECTED, INPUT },\r
+ { MMC1_DAT3, MUXMODE0, PULL_UP_SELECTED, INPUT },\r
+ { MMC1_DAT4, MUXMODE0, PULL_UP_SELECTED, INPUT },\r
+ { MMC1_DAT5, MUXMODE0, PULL_UP_SELECTED, INPUT },\r
+ { MMC1_DAT6, MUXMODE0, PULL_UP_SELECTED, INPUT },\r
+ { MMC1_DAT7, MUXMODE0, PULL_UP_SELECTED, INPUT },\r
+ { MMC2_CLK, MUXMODE4, PULL_UP_SELECTED, INPUT },\r
+ { MMC2_CMD, MUXMODE4, PULL_UP_SELECTED, INPUT },\r
+ { MMC2_DAT0, MUXMODE4, PULL_UP_SELECTED, INPUT },\r
+ { MMC2_DAT1, MUXMODE4, PULL_UP_SELECTED, INPUT },\r
+ { MMC2_DAT2, MUXMODE4, PULL_UP_SELECTED, INPUT },\r
+ { MMC2_DAT3, MUXMODE4, PULL_UP_SELECTED, INPUT },\r
+ { MMC2_DAT4, MUXMODE4, PULL_UP_SELECTED, INPUT },\r
+ { MMC2_DAT5, MUXMODE4, PULL_UP_SELECTED, INPUT },\r
+ { MMC2_DAT6, MUXMODE4, PULL_UP_SELECTED, INPUT },\r
+ { MMC2_DAT7, MUXMODE4, PULL_UP_SELECTED, INPUT },\r
+ { MCBSP3_DX, MUXMODE4, PULL_DISABLED, OUTPUT },\r
+ { MCBSP3_DR, MUXMODE4, PULL_DISABLED, OUTPUT },\r
+ { MCBSP3_CLKX, MUXMODE4, PULL_DISABLED, OUTPUT },\r
+ { MCBSP3_FSX, MUXMODE4, PULL_DISABLED, OUTPUT },\r
+ { UART2_CTS, MUXMODE0, PULL_UP_SELECTED, INPUT },\r
+ { UART2_RTS, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { UART2_TX, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { UART2_RX, MUXMODE4, PULL_DISABLED, OUTPUT },\r
+ { UART1_TX, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { UART1_RTS, MUXMODE4, PULL_DISABLED, OUTPUT },\r
+ { UART1_CTS, MUXMODE4, PULL_DISABLED, OUTPUT },\r
+ { UART1_RX, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { MCBSP4_CLKX, MUXMODE1, PULL_DISABLED, INPUT },\r
+ { MCBSP4_DR, MUXMODE1, PULL_DISABLED, INPUT },\r
+ { MCBSP4_DX, MUXMODE1, PULL_DISABLED, INPUT },\r
+ { MCBSP4_FSX, MUXMODE1, PULL_DISABLED, INPUT },\r
+ { MCBSP1_CLKR, MUXMODE4, PULL_DISABLED, OUTPUT },\r
+ { MCBSP1_FSR, MUXMODE4, PULL_UP_SELECTED, OUTPUT },\r
+ { MCBSP1_DX, MUXMODE4, PULL_DISABLED, OUTPUT },\r
+ { MCBSP1_DR, MUXMODE4, PULL_DISABLED, OUTPUT },\r
+ { MCBSP1_CLKS, MUXMODE0, PULL_UP_SELECTED, INPUT },\r
+ { MCBSP1_FSX, MUXMODE4, PULL_DISABLED, OUTPUT },\r
+ { MCBSP1_CLKX, MUXMODE4, PULL_DISABLED, OUTPUT },\r
+ { UART3_CTS_RCTX,MUXMODE0, PULL_UP_SELECTED, INPUT },\r
+ { UART3_RTS_SD, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { UART3_RX_IRRX, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { UART3_TX_IRTX, MUXMODE0, PULL_DISABLED, OUTPUT },\r
+ { HSUSB0_CLK, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { HSUSB0_STP, MUXMODE0, PULL_UP_SELECTED, OUTPUT },\r
+ { HSUSB0_DIR, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { HSUSB0_NXT, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { HSUSB0_DATA0, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { HSUSB0_DATA1, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { HSUSB0_DATA2, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { HSUSB0_DATA3, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { HSUSB0_DATA4, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { HSUSB0_DATA5, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { HSUSB0_DATA6, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { HSUSB0_DATA7, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { I2C1_SCL, MUXMODE0, PULL_UP_SELECTED, INPUT },\r
+ { I2C1_SDA, MUXMODE0, PULL_UP_SELECTED, INPUT },\r
+ { I2C2_SCL, MUXMODE4, PULL_UP_SELECTED, INPUT },\r
+ { I2C2_SDA, MUXMODE4, PULL_UP_SELECTED, INPUT },\r
+ { I2C3_SCL, MUXMODE0, PULL_UP_SELECTED, INPUT },\r
+ { I2C3_SDA, MUXMODE0, PULL_UP_SELECTED, INPUT },\r
+ { HDQ_SIO, MUXMODE4, PULL_UP_SELECTED, OUTPUT },\r
+ { MCSPI1_CLK, MUXMODE4, PULL_UP_SELECTED, INPUT },\r
+ { MCSPI1_SIMO, MUXMODE4, PULL_UP_SELECTED, INPUT },\r
+ { MCSPI1_SOMI, MUXMODE0, PULL_DISABLED, INPUT },\r
+ { MCSPI1_CS0, MUXMODE0, PULL_UP_SELECTED, INPUT },\r
+ { MCSPI1_CS1, MUXMODE0, PULL_UP_SELECTED, OUTPUT },\r
+ { MCSPI1_CS2, MUXMODE4, PULL_DISABLED, OUTPUT },\r
+ { MCSPI1_CS3, MUXMODE3, PULL_UP_SELECTED, INPUT },\r
+ { MCSPI2_CLK, MUXMODE3, PULL_UP_SELECTED, INPUT },\r
+ { MCSPI2_SIMO, MUXMODE3, PULL_UP_SELECTED, INPUT },\r
+ { MCSPI2_SOMI, MUXMODE3, PULL_UP_SELECTED, INPUT },\r
+ { MCSPI2_CS0, MUXMODE3, PULL_UP_SELECTED, INPUT },\r
+ { MCSPI2_CS1, MUXMODE3, PULL_UP_SELECTED, INPUT },\r
+ { SYS_NIRQ, MUXMODE0, PULL_UP_SELECTED, INPUT },\r
+ { SYS_CLKOUT2, MUXMODE4, PULL_UP_SELECTED, INPUT },\r
+ { ETK_CLK, MUXMODE3, PULL_UP_SELECTED, OUTPUT },\r
+ { ETK_CTL, MUXMODE3, PULL_UP_SELECTED, OUTPUT },\r
+ { ETK_D0, MUXMODE3, PULL_UP_SELECTED, INPUT },\r
+ { ETK_D1, MUXMODE3, PULL_UP_SELECTED, INPUT },\r
+ { ETK_D2, MUXMODE3, PULL_UP_SELECTED, INPUT },\r
+ { ETK_D3, MUXMODE3, PULL_UP_SELECTED, INPUT },\r
+ { ETK_D4, MUXMODE3, PULL_UP_SELECTED, INPUT },\r
+ { ETK_D5, MUXMODE3, PULL_UP_SELECTED, INPUT },\r
+ { ETK_D6, MUXMODE3, PULL_UP_SELECTED, INPUT },\r
+ { ETK_D7, MUXMODE3, PULL_UP_SELECTED, INPUT },\r
+ { ETK_D8, MUXMODE3, PULL_UP_SELECTED, INPUT },\r
+ { ETK_D9, MUXMODE4, PULL_UP_SELECTED, INPUT },\r
+ { ETK_D10, MUXMODE3, PULL_UP_SELECTED, OUTPUT },\r
+ { ETK_D11, MUXMODE3, PULL_UP_SELECTED, OUTPUT },\r
+ { ETK_D12, MUXMODE3, PULL_UP_SELECTED, INPUT },\r
+ { ETK_D13, MUXMODE3, PULL_UP_SELECTED, INPUT },\r
+ { ETK_D14, MUXMODE3, PULL_UP_SELECTED, INPUT },\r
+ { ETK_D15, MUXMODE3, PULL_UP_SELECTED, INPUT }\r
};\r
\r
VOID\r
/** @file
+ MMC/SD Card driver for OMAP 35xx (SDIO not supported)
+
+ This driver always produces a BlockIo protocol but it starts off with no Media
+ present. A TimerCallBack detects when media is inserted or removed and after
+ a media change event a call to BlockIo ReadBlocks/WriteBlocks will cause the
+ media to be detected (or removed) and the BlockIo Media structure will get
+ updated. No MMC/SD Card harward registers are updated until the first BlockIo
+ ReadBlocks/WriteBlocks after media has been insterted (booting with a card
+ plugged in counts as an insertion event).
Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
#include "MMCHS.h"
-EFI_BLOCK_IO_MEDIA MMCHSMedia = {
+EFI_BLOCK_IO_MEDIA gMMCHSMedia = {
SIGNATURE_32('s','d','i','o'), // MediaId
TRUE, // RemovableMedia
- TRUE, // MediaPresent
+ FALSE, // MediaPresent
FALSE, // LogicalPartition
FALSE, // ReadOnly
FALSE, // WriteCaching
EFI_DEVICE_PATH End;
} MMCHS_DEVICE_PATH;
-MMCHS_DEVICE_PATH gMmcHsDevicePath =
-{
+MMCHS_DEVICE_PATH gMmcHsDevicePath = {
{
HARDWARE_DEVICE_PATH,
HW_VENDOR_DP,
}
};
-CARD_INFO *gCardInfo;
+CARD_INFO gCardInfo;
EMBEDDED_EXTERNAL_DEVICE *gTPS65950;
+EFI_EVENT gTimerEvent;
+BOOLEAN gMediaChange = FALSE;
//
// Internal Functions
//
-STATIC
+
VOID
ParseCardCIDData (
UINT32 Response0,
UINT32 Response3
)
{
- gCardInfo->CIDData.MDT = ((Response0 >> 8) & 0xFFF);
- gCardInfo->CIDData.PSN = (((Response0 >> 24) & 0xFF) | ((Response1 & 0xFFFFFF) << 8));
- gCardInfo->CIDData.PRV = ((Response1 >> 24) & 0xFF);
- gCardInfo->CIDData.PNM[4] = ((Response2) & 0xFF);
- gCardInfo->CIDData.PNM[3] = ((Response2 >> 8) & 0xFF);
- gCardInfo->CIDData.PNM[2] = ((Response2 >> 16) & 0xFF);
- gCardInfo->CIDData.PNM[1] = ((Response2 >> 24) & 0xFF);
- gCardInfo->CIDData.PNM[0] = ((Response3) & 0xFF);
- gCardInfo->CIDData.OID = ((Response3 >> 8) & 0xFFFF);
- gCardInfo->CIDData.MID = ((Response3 >> 24) & 0xFF);
+ gCardInfo.CIDData.MDT = ((Response0 >> 8) & 0xFFF);
+ gCardInfo.CIDData.PSN = (((Response0 >> 24) & 0xFF) | ((Response1 & 0xFFFFFF) << 8));
+ gCardInfo.CIDData.PRV = ((Response1 >> 24) & 0xFF);
+ gCardInfo.CIDData.PNM[4] = ((Response2) & 0xFF);
+ gCardInfo.CIDData.PNM[3] = ((Response2 >> 8) & 0xFF);
+ gCardInfo.CIDData.PNM[2] = ((Response2 >> 16) & 0xFF);
+ gCardInfo.CIDData.PNM[1] = ((Response2 >> 24) & 0xFF);
+ gCardInfo.CIDData.PNM[0] = ((Response3) & 0xFF);
+ gCardInfo.CIDData.OID = ((Response3 >> 8) & 0xFFFF);
+ gCardInfo.CIDData.MID = ((Response3 >> 24) & 0xFF);
}
-STATIC
+
VOID
UpdateMMCHSClkFrequency (
UINTN NewCLKD
)
{
//Set Clock enable to 0x0 to not provide the clock to the card
- MmioAnd32(MMCHS_SYSCTL, ~CEN);
+ MmioAnd32 (MMCHS_SYSCTL, ~CEN);
//Set new clock frequency.
- MmioAndThenOr32(MMCHS_SYSCTL, ~CLKD_MASK, NewCLKD << 6);
+ MmioAndThenOr32 (MMCHS_SYSCTL, ~CLKD_MASK, NewCLKD << 6);
//Poll till Internal Clock Stable
while ((MmioRead32 (MMCHS_SYSCTL) & ICS_MASK) != ICS);
MmioOr32 (MMCHS_SYSCTL, CEN);
}
-STATIC
+
EFI_STATUS
SendCmd (
UINTN Cmd,
MmioWrite32 (MMCHS_BLK, BLEN_512BYTES);
//Setting Data timeout counter value to max value.
- MmioAndThenOr32(MMCHS_SYSCTL, ~DTO_MASK, DTO_VAL);
+ MmioAndThenOr32 (MMCHS_SYSCTL, ~DTO_MASK, DTO_VAL);
//Clear Status register.
MmioWrite32 (MMCHS_STAT, 0xFFFFFFFF);
return EFI_SUCCESS;
}
-STATIC
+
VOID
GetBlockInformation (
UINTN *BlockSize,
CSD_SDV2 *CsdSDV2Data;
UINTN CardSize;
- if (gCardInfo->CardType == SD_CARD_2_HIGH) {
- CsdSDV2Data = (CSD_SDV2 *)&gCardInfo->CSDData;
+ if (gCardInfo.CardType == SD_CARD_2_HIGH) {
+ CsdSDV2Data = (CSD_SDV2 *)&gCardInfo.CSDData;
//Populate BlockSize.
*BlockSize = (0x1UL << CsdSDV2Data->READ_BL_LEN);
*NumBlocks = ((CardSize + 1) * 1024);
} else {
//Populate BlockSize.
- *BlockSize = (0x1UL << gCardInfo->CSDData.READ_BL_LEN);
+ *BlockSize = (0x1UL << gCardInfo.CSDData.READ_BL_LEN);
//Calculate Total number of blocks.
- CardSize = gCardInfo->CSDData.C_SIZELow2 | (gCardInfo->CSDData.C_SIZEHigh10 << 2);
- *NumBlocks = (CardSize + 1) * (1 << (gCardInfo->CSDData.C_SIZE_MULT + 2));
+ CardSize = gCardInfo.CSDData.C_SIZELow2 | (gCardInfo.CSDData.C_SIZEHigh10 << 2);
+ *NumBlocks = (CardSize + 1) * (1 << (gCardInfo.CSDData.C_SIZE_MULT + 2));
}
//For >=2G card, BlockSize may be 1K, but the transfer size is 512 bytes.
*BlockSize = 512;
}
- DEBUG ((EFI_D_INFO, "Card type: %x, BlockSize: %x, NumBlocks: %x\n", gCardInfo->CardType, *BlockSize, *NumBlocks));
+ DEBUG ((EFI_D_INFO, "Card type: %x, BlockSize: %x, NumBlocks: %x\n", gCardInfo.CardType, *BlockSize, *NumBlocks));
}
-STATIC
+
VOID
CalculateCardCLKD (
UINTN *ClockFrequencySelect
UINTN TimeValue = 0 ;
UINTN Frequency = 0;
- MaxDataTransferRate = gCardInfo->CSDData.TRAN_SPEED;
+ MaxDataTransferRate = gCardInfo.CSDData.TRAN_SPEED;
//Calculate Transfer rate unit (Bits 2:0 of TRAN_SPEED)
switch (MaxDataTransferRate & 0x7) {
DEBUG ((EFI_D_INFO, "MaxDataTransferRate: 0x%x, Frequency: %d KHz, ClockFrequencySelect: %x\n", MaxDataTransferRate, Frequency/1000, *ClockFrequencySelect));
}
-STATIC
+
VOID
GetCardConfigurationData (
VOID
//Calculate BlockSize and Total number of blocks in the detected card.
GetBlockInformation(&BlockSize, &NumBlocks);
- gCardInfo->BlockSize = BlockSize;
- gCardInfo->NumBlocks = NumBlocks;
+ gCardInfo.BlockSize = BlockSize;
+ gCardInfo.NumBlocks = NumBlocks;
//Calculate Card clock divider value.
CalculateCardCLKD(&ClockFrequencySelect);
- gCardInfo->ClockFrequencySelect = ClockFrequencySelect;
+ gCardInfo.ClockFrequencySelect = ClockFrequencySelect;
}
-STATIC
+
EFI_STATUS
InitializeMMCHS (
VOID
//Select Device group to belong to P1 device group in Power IC.
Data = DEV_GRP_P1;
- Status = gTPS65950->Write(gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VMMC1_DEV_GRP), 1, &Data);
+ Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VMMC1_DEV_GRP), 1, &Data);
ASSERT_EFI_ERROR(Status);
//Configure voltage regulator for MMC1 in Power IC to output 3.0 voltage.
Data = VSEL_3_00V;
- Status = gTPS65950->Write(gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VMMC1_DEDICATED_REG), 1, &Data);
+ Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VMMC1_DEDICATED_REG), 1, &Data);
ASSERT_EFI_ERROR(Status);
//After ramping up voltage, set VDDS stable bit to indicate that voltage level is stable.
MmioOr32 (CONTROL_PBIAS_LITE, (PBIASLITEVMODE0 | PBIASLITEPWRDNZ0 | PBIASSPEEDCTRL0 | PBIASLITEVMODE1 | PBIASLITEWRDNZ1));
- //Software reset of the MMCHS host controller.
- MmioWrite32 (MMCHS_SYSCONFIG, SOFTRESET);
- gBS->Stall(1000);
- while ((MmioRead32 (MMCHS_SYSSTATUS) & RESETDONE_MASK) != RESETDONE);
+ // Enable WP GPIO
+ MmioAndThenOr32 (GPIO1_BASE + GPIO_OE, ~BIT23, BIT23);
- //Soft reset for all.
- MmioWrite32 (MMCHS_SYSCTL, SRA);
- gBS->Stall(1000);
- while ((MmioRead32 (MMCHS_SYSCTL) & SRA) != 0x0);
-
- //Voltage capabilities initialization. Activate VS18 and VS30.
- MmioOr32 (MMCHS_CAPA, (VS30 | VS18));
-
- //Wakeup configuration
- MmioOr32 (MMCHS_SYSCONFIG, ENAWAKEUP);
- MmioOr32 (MMCHS_HCTL, IWE);
+ // Enable Card Detect
+ Data = CARD_DETECT_ENABLE;
+ gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2, TPS65950_GPIO_CTRL), 1, &Data);
- //MMCHS Controller default initialization
- MmioOr32 (MMCHS_CON, (OD | DW8_1_4_BIT | CEATA_OFF));
-
- MmioWrite32 (MMCHS_HCTL, (SDVS_3_0_V | DTW_1_BIT | SDBP_OFF));
-
- //Enable internal clock
- MmioOr32 (MMCHS_SYSCTL, ICE);
-
- //Set the clock frequency to 80KHz.
- UpdateMMCHSClkFrequency(CLKD_80KHZ);
-
- //Enable SD bus power.
- MmioOr32 (MMCHS_HCTL, (SDBP_ON));
-
- //Poll till SD bus power bit is set.
- while ((MmioRead32 (MMCHS_HCTL) & SDBP_MASK) != SDBP_ON);
return Status;
}
-STATIC
+
EFI_STATUS
PerformCardIdenfication (
VOID
BOOLEAN SDCmd8Supported = FALSE;
//Enable interrupts.
- MmioWrite32 (MMCHS_IE, (BADA_EN | CERR_EN | DEB_EN | DCRC_EN | DTO_EN | CIE_EN |
+ MmioWrite32 (MMCHS_IE, (BADA_EN | CERR_EN | DEB_EN | DCRC_EN | DTO_EN | CIE_EN |
CEB_EN | CCRC_EN | CTO_EN | BRR_EN | BWR_EN | TC_EN | CC_EN));
//Controller INIT procedure start.
while (!(MmioRead32 (MMCHS_STAT) & CC));
//End initialization sequence
- MmioAnd32(MMCHS_CON, ~INIT);
+ MmioAnd32 (MMCHS_CON, ~INIT);
MmioOr32 (MMCHS_HCTL, (SDVS_3_0_V | DTW_1_BIT | SDBP_ON));
MmioOr32 (MMCHS_CON, OD);
//Send CMD0 command.
- Status = SendCmd(CMD0, CMD0_INT_EN, CmdArgument);
+ Status = SendCmd (CMD0, CMD0_INT_EN, CmdArgument);
if (EFI_ERROR(Status)) {
DEBUG ((EFI_D_ERROR, "Cmd0 fails.\n"));
return Status;
DEBUG ((EFI_D_INFO, "CMD0 response: %x\n", MmioRead32 (MMCHS_RSP10)));
//Send CMD5 command.
- Status = SendCmd(CMD5, CMD5_INT_EN, CmdArgument);
+ Status = SendCmd (CMD5, CMD5_INT_EN, CmdArgument);
if (Status == EFI_SUCCESS) {
DEBUG ((EFI_D_ERROR, "CMD5 Success. SDIO card. Follow SDIO card specification.\n"));
DEBUG ((EFI_D_INFO, "CMD5 response: %x\n", MmioRead32 (MMCHS_RSP10)));
//Only 2.7V - 3.6V is supported for SD2.0, only SD 2.0 card can pass.
//MMC & SD1.1 card will fail this command.
CmdArgument = CMD8_ARG;
- Status = SendCmd(CMD8, CMD8_INT_EN, CmdArgument);
+ Status = SendCmd (CMD8, CMD8_INT_EN, CmdArgument);
if (Status == EFI_SUCCESS) {
Response = MmioRead32 (MMCHS_RSP10);
DEBUG ((EFI_D_INFO, "CMD8 success. CMD8 response: %x\n", Response));
while (RetryCount < MAX_RETRY_COUNT) {
//Send CMD55 command.
CmdArgument = 0;
- Status = SendCmd(CMD55, CMD55_INT_EN, CmdArgument);
+ Status = SendCmd (CMD55, CMD55_INT_EN, CmdArgument);
if (Status == EFI_SUCCESS) {
DEBUG ((EFI_D_INFO, "CMD55 success. CMD55 response: %x\n", MmioRead32 (MMCHS_RSP10)));
- gCardInfo->CardType = SD_CARD;
+ gCardInfo.CardType = SD_CARD;
} else {
DEBUG ((EFI_D_INFO, "CMD55 fails.\n"));
- gCardInfo->CardType = MMC_CARD;
+ gCardInfo.CardType = MMC_CARD;
}
//Send appropriate command for the card type which got detected.
- if (gCardInfo->CardType == SD_CARD) {
- CmdArgument = ((UINTN *) &(gCardInfo->OCRData))[0];
+ if (gCardInfo.CardType == SD_CARD) {
+ CmdArgument = ((UINTN *) &(gCardInfo.OCRData))[0];
//Set HCS bit.
if (SDCmd8Supported) {
CmdArgument |= HCS;
}
- Status = SendCmd(ACMD41, ACMD41_INT_EN, CmdArgument);
+ Status = SendCmd (ACMD41, ACMD41_INT_EN, CmdArgument);
if (EFI_ERROR(Status)) {
DEBUG ((EFI_D_INFO, "ACMD41 fails.\n"));
return Status;
}
- ((UINT32 *) &(gCardInfo->OCRData))[0] = MmioRead32 (MMCHS_RSP10);
- DEBUG ((EFI_D_INFO, "SD card detected. ACMD41 OCR: %x\n", ((UINT32 *) &(gCardInfo->OCRData))[0]));
- } else if (gCardInfo->CardType == MMC_CARD) {
+ ((UINT32 *) &(gCardInfo.OCRData))[0] = MmioRead32 (MMCHS_RSP10);
+ DEBUG ((EFI_D_INFO, "SD card detected. ACMD41 OCR: %x\n", ((UINT32 *) &(gCardInfo.OCRData))[0]));
+ } else if (gCardInfo.CardType == MMC_CARD) {
CmdArgument = 0;
- Status = SendCmd(CMD1, CMD1_INT_EN, CmdArgument);
+ Status = SendCmd (CMD1, CMD1_INT_EN, CmdArgument);
if (EFI_ERROR(Status)) {
DEBUG ((EFI_D_INFO, "CMD1 fails.\n"));
return Status;
}
//Poll the card until it is out of its power-up sequence.
- if (gCardInfo->OCRData.Busy == 1) {
+ if (gCardInfo.OCRData.Busy == 1) {
if (SDCmd8Supported) {
- gCardInfo->CardType = SD_CARD_2;
+ gCardInfo.CardType = SD_CARD_2;
}
//Card is ready. Check CCS (Card capacity status) bit (bit#30).
//SD 2.0 standard card will response with CCS 0, SD high capacity card will respond with CCS 1.
- if (gCardInfo->OCRData.AccessMode & BIT1) {
- gCardInfo->CardType = SD_CARD_2_HIGH;
+ if (gCardInfo.OCRData.AccessMode & BIT1) {
+ gCardInfo.CardType = SD_CARD_2_HIGH;
DEBUG ((EFI_D_INFO, "High capacity card.\n"));
} else {
DEBUG ((EFI_D_INFO, "Standard capacity card.\n"));
//Read CID data.
CmdArgument = 0;
- Status = SendCmd(CMD2, CMD2_INT_EN, CmdArgument);
+ Status = SendCmd (CMD2, CMD2_INT_EN, CmdArgument);
if (EFI_ERROR(Status)) {
DEBUG ((EFI_D_ERROR, "CMD2 fails. Status: %x\n", Status));
return Status;
//Read RCA
CmdArgument = 0;
- Status = SendCmd(CMD3, CMD3_INT_EN, CmdArgument);
+ Status = SendCmd (CMD3, CMD3_INT_EN, CmdArgument);
if (EFI_ERROR(Status)) {
DEBUG ((EFI_D_ERROR, "CMD3 fails. Status: %x\n", Status));
return Status;
}
//Set RCA for the detected card. RCA is CMD3 response.
- gCardInfo->RCA = (MmioRead32 (MMCHS_RSP10) >> 16);
- DEBUG ((EFI_D_INFO, "CMD3 response: RCA %x\n", gCardInfo->RCA));
+ gCardInfo.RCA = (MmioRead32 (MMCHS_RSP10) >> 16);
+ DEBUG ((EFI_D_INFO, "CMD3 response: RCA %x\n", gCardInfo.RCA));
//MMC Bus setting change after card identification.
- MmioAnd32(MMCHS_CON, ~OD);
+ MmioAnd32 (MMCHS_CON, ~OD);
MmioOr32 (MMCHS_HCTL, SDVS_3_0_V);
UpdateMMCHSClkFrequency(CLKD_400KHZ); //Set the clock frequency to 400KHz.
return EFI_SUCCESS;
}
-STATIC
+
EFI_STATUS
GetCardSpecificData (
VOID
UINTN CmdArgument;
//Send CMD9 to retrieve CSD.
- CmdArgument = gCardInfo->RCA << 16;
- Status = SendCmd(CMD9, CMD9_INT_EN, CmdArgument);
+ CmdArgument = gCardInfo.RCA << 16;
+ Status = SendCmd (CMD9, CMD9_INT_EN, CmdArgument);
if (EFI_ERROR(Status)) {
DEBUG ((EFI_D_ERROR, "CMD9 fails. Status: %x\n", Status));
return Status;
}
//Populate 128-bit CSD register data.
- ((UINT32 *)&(gCardInfo->CSDData))[0] = MmioRead32 (MMCHS_RSP10);
- ((UINT32 *)&(gCardInfo->CSDData))[1] = MmioRead32 (MMCHS_RSP32);
- ((UINT32 *)&(gCardInfo->CSDData))[2] = MmioRead32 (MMCHS_RSP54);
- ((UINT32 *)&(gCardInfo->CSDData))[3] = MmioRead32 (MMCHS_RSP76);
+ ((UINT32 *)&(gCardInfo.CSDData))[0] = MmioRead32 (MMCHS_RSP10);
+ ((UINT32 *)&(gCardInfo.CSDData))[1] = MmioRead32 (MMCHS_RSP32);
+ ((UINT32 *)&(gCardInfo.CSDData))[2] = MmioRead32 (MMCHS_RSP54);
+ ((UINT32 *)&(gCardInfo.CSDData))[3] = MmioRead32 (MMCHS_RSP76);
DEBUG ((EFI_D_INFO, "CMD9 response: %x %x %x %x\n", MmioRead32 (MMCHS_RSP10), MmioRead32 (MMCHS_RSP32), MmioRead32 (MMCHS_RSP54), MmioRead32 (MMCHS_RSP76)));
GetCardConfigurationData();
//Change MMCHS clock frequency to what detected card can support.
- UpdateMMCHSClkFrequency(gCardInfo->ClockFrequencySelect);
+ UpdateMMCHSClkFrequency(gCardInfo.ClockFrequencySelect);
return Status;
}
-STATIC
+
EFI_STATUS
PerformCardConfiguration (
VOID
EFI_STATUS Status;
//Send CMD7
- CmdArgument = gCardInfo->RCA << 16;
- Status = SendCmd(CMD7, CMD7_INT_EN, CmdArgument);
+ CmdArgument = gCardInfo.RCA << 16;
+ Status = SendCmd (CMD7, CMD7_INT_EN, CmdArgument);
if (EFI_ERROR(Status)) {
DEBUG ((EFI_D_ERROR, "CMD7 fails. Status: %x\n", Status));
return Status;
}
//Send CMD16 to set the block length
- CmdArgument = gCardInfo->BlockSize;
- Status = SendCmd(CMD16, CMD16_INT_EN, CmdArgument);
+ CmdArgument = gCardInfo.BlockSize;
+ Status = SendCmd (CMD16, CMD16_INT_EN, CmdArgument);
if (EFI_ERROR(Status)) {
DEBUG ((EFI_D_ERROR, "CMD16 fails. Status: %x\n", Status));
return Status;
return EFI_SUCCESS;
}
-STATIC
+
EFI_STATUS
-ReadBlockData(
+ReadBlockData (
IN EFI_BLOCK_IO_PROTOCOL *This,
OUT VOID *Buffer
)
return EFI_SUCCESS;
}
-STATIC
+
EFI_STATUS
-WriteBlockData(
+WriteBlockData (
IN EFI_BLOCK_IO_PROTOCOL *This,
OUT VOID *Buffer
)
return EFI_SUCCESS;
}
-STATIC
+
EFI_STATUS
-TransferBlockData(
+TransferBlockData (
IN EFI_BLOCK_IO_PROTOCOL *This,
OUT VOID *Buffer,
IN OPERATION_TYPE OperationType
return EFI_SUCCESS;
}
-STATIC
+BOOLEAN
+CardPresent (
+ VOID
+ )
+{
+ EFI_STATUS Status;
+ UINT8 Data;
+
+ //
+ // Card detect is a GPIO0 on the TPS65950
+ //
+ Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2, GPIODATAIN1), 1, &Data);
+ if (EFI_ERROR (Status)) {
+ return FALSE;
+ }
+
+ if ((Data & CARD_DETECT_BIT) == CARD_DETECT_BIT) {
+ // No Card present
+ return FALSE;
+ } else {
+ return TRUE;
+ }
+}
+
+EFI_STATUS
+DetectCard (
+ VOID
+ )
+{
+ EFI_STATUS Status;
+
+ if (!CardPresent ()) {
+ return EFI_NO_MEDIA;
+ }
+
+ //Initialize MMC host controller clocks.
+ Status = InitializeMMCHS ();
+ if (EFI_ERROR(Status)) {
+ DEBUG ((EFI_D_ERROR, "Initialize MMC host controller fails. Status: %x\n", Status));
+ return Status;
+ }
+
+ //Software reset of the MMCHS host controller.
+ MmioWrite32 (MMCHS_SYSCONFIG, SOFTRESET);
+ gBS->Stall(1000);
+ while ((MmioRead32 (MMCHS_SYSSTATUS) & RESETDONE_MASK) != RESETDONE);
+
+ //Soft reset for all.
+ MmioWrite32 (MMCHS_SYSCTL, SRA);
+ gBS->Stall(1000);
+ while ((MmioRead32 (MMCHS_SYSCTL) & SRA) != 0x0);
+
+ //Voltage capabilities initialization. Activate VS18 and VS30.
+ MmioOr32 (MMCHS_CAPA, (VS30 | VS18));
+
+ //Wakeup configuration
+ MmioOr32 (MMCHS_SYSCONFIG, ENAWAKEUP);
+ MmioOr32 (MMCHS_HCTL, IWE);
+
+ //MMCHS Controller default initialization
+ MmioOr32 (MMCHS_CON, (OD | DW8_1_4_BIT | CEATA_OFF));
+
+ MmioWrite32 (MMCHS_HCTL, (SDVS_3_0_V | DTW_1_BIT | SDBP_OFF));
+
+ //Enable internal clock
+ MmioOr32 (MMCHS_SYSCTL, ICE);
+
+ //Set the clock frequency to 80KHz.
+ UpdateMMCHSClkFrequency (CLKD_80KHZ);
+
+ //Enable SD bus power.
+ MmioOr32 (MMCHS_HCTL, (SDBP_ON));
+
+ //Poll till SD bus power bit is set.
+ while ((MmioRead32 (MMCHS_HCTL) & SDBP_MASK) != SDBP_ON);
+
+ //Card idenfication
+ Status = PerformCardIdenfication ();
+ if (EFI_ERROR(Status)) {
+ DEBUG ((EFI_D_ERROR, "No MMC/SD card detected.\n"));
+ return Status;
+ }
+
+ //Get CSD (Card specific data) for the detected card.
+ Status = GetCardSpecificData();
+ if (EFI_ERROR(Status)) {
+ return Status;
+ }
+
+ //Configure the card in data transfer mode.
+ Status = PerformCardConfiguration();
+ if (EFI_ERROR(Status)) {
+ return Status;
+ }
+
+ //Patch the Media structure.
+ gMMCHSMedia.LastBlock = (gCardInfo.NumBlocks - 1);
+ gMMCHSMedia.BlockSize = gCardInfo.BlockSize;
+ gMMCHSMedia.ReadOnly = (MmioRead32 (GPIO1_BASE + GPIO_DATAIN) & BIT23) == BIT23;
+ gMMCHSMedia.MediaPresent = TRUE;
+ gMMCHSMedia.MediaId++;
+ gMediaChange = FALSE;
+
+ return Status;
+}
+
+
EFI_STATUS
SdReadWrite (
IN EFI_BLOCK_IO_PROTOCOL *This,
IN OPERATION_TYPE OperationType
)
{
- EFI_STATUS Status;
+ EFI_STATUS Status = EFI_SUCCESS;
UINTN RetryCount = 0;
UINTN NumBlocks;
UINTN Cmd = 0;
UINTN CmdInterruptEnable = 0;
UINTN CmdArgument = 0;
+ EFI_TPL OldTpl;\r
+ BOOLEAN MediaPresentLastTime;\r
+ BOOLEAN Update;\r
+
+ OldTpl = gBS->RaiseTPL (TPL_NOTIFY);\r
+
+
+ if (Buffer == NULL) {
+ Status = EFI_INVALID_PARAMETER;
+ goto Done;
+ }
+
+ Update = FALSE;
+ MediaPresentLastTime = gMMCHSMedia.MediaPresent;
+
+ if (gMediaChange) {
+ Status = DetectCard ();
+ if (EFI_ERROR (Status)) {
+ // We detected a removal
+ gMMCHSMedia.MediaPresent = FALSE;
+ gMMCHSMedia.LastBlock = 0;
+ gMMCHSMedia.BlockSize = 512; // Should be zero but there is a bug in DiskIo
+ gMMCHSMedia.ReadOnly = FALSE;
+ } else {
+ Update = TRUE;
+ }
+ gMediaChange = FALSE;
+ } else if (!gMMCHSMedia.MediaPresent) {
+ Status = EFI_NO_MEDIA;
+ goto Done;
+ }
+
+ if ((MediaPresentLastTime != gMMCHSMedia.MediaPresent) || Update) {
+ gBS->ReinstallProtocolInterface (\r
+ gImageHandle,\r
+ &gEfiBlockIoProtocolGuid,\r
+ &gBlockIo,\r
+ &gBlockIo\r
+ );\r
+ }
+
+ if (EFI_ERROR (Status)) {
+ goto Done;
+ }
+
+ if (Lba > This->Media->LastBlock) {
+ Status = EFI_INVALID_PARAMETER;
+ goto Done;
+ }
+
+ if ((BufferSize % This->Media->BlockSize) != 0) {
+ Status = EFI_BAD_BUFFER_SIZE;
+ goto Done;
+ }
//Check if the data lines are not in use.
while ((RetryCount++ < MAX_RETRY_COUNT) && ((MmioRead32 (MMCHS_PSTATE) & DATI_MASK) != DATI_ALLOWED));
if (RetryCount == MAX_RETRY_COUNT) {
- return EFI_TIMEOUT;
+ Status = EFI_TIMEOUT;
+ goto Done;
}
//Populate the command information based on the operation type.
if (OperationType == READ) {
Cmd = CMD17; //Single block read
CmdInterruptEnable = CMD17_INT_EN;
- } else if (OperationType == WRITE) {
+ } else if (OperationType == WRITE) {
Cmd = CMD24; //Single block write
CmdInterruptEnable = CMD24_INT_EN;
}
NumBlocks = (BufferSize + (This->Media->BlockSize - 1))/This->Media->BlockSize;
//Set command argument based on the card access mode (Byte mode or Block mode)
- if (gCardInfo->OCRData.AccessMode & BIT1) {
+ if (gCardInfo.OCRData.AccessMode & BIT1) {
CmdArgument = (UINTN)Lba;
} else {
CmdArgument = (UINTN)Lba * This->Media->BlockSize;
while(NumBlocks) {
//Send Command.
- Status = SendCmd(Cmd, CmdInterruptEnable, CmdArgument);
+ Status = SendCmd (Cmd, CmdInterruptEnable, CmdArgument);
if (EFI_ERROR(Status)) {
DEBUG ((EFI_D_ERROR, "CMD fails. Status: %x\n", Status));
- return Status;
+ goto Done;
}
//Transfer a block worth of data.
Status = TransferBlockData(This, Buffer, OperationType);
if (EFI_ERROR(Status)) {
DEBUG ((EFI_D_ERROR, "TransferBlockData fails. %x\n", Status));
- return Status;
+ goto Done;
}
//Adjust command argument.
- if (gCardInfo->OCRData.AccessMode & BIT1) {
+ if (gCardInfo.OCRData.AccessMode & BIT1) {
CmdArgument++; //Increase BlockIndex by one.
} else {
CmdArgument += This->Media->BlockSize; //Increase BlockIndex by BlockSize
NumBlocks--;
}
- return EFI_SUCCESS;
+Done:\r
+ gBS->RestoreTPL (OldTpl);\r
+ return Status;\r
}
+
+/**\r
+ Reset the Block Device.\r
+\r
+ @param This Indicates a pointer to the calling context.\r
+ @param ExtendedVerification Driver may perform diagnostics on reset.\r
+\r
+ @retval EFI_SUCCESS The device was reset.\r
+ @retval EFI_DEVICE_ERROR The device is not functioning properly and could\r
+ not be reset.\r
+\r
+**/
EFI_STATUS
EFIAPI
MMCHSReset (
IN BOOLEAN ExtendedVerification
)
{
- return EFI_SUCCESS;
+ return EFI_SUCCESS;
}
+
+/**\r
+ Read BufferSize bytes from Lba into Buffer.\r
+\r
+ @param This Indicates a pointer to the calling context.\r
+ @param MediaId Id of the media, changes every time the media is replaced.\r
+ @param Lba The starting Logical Block Address to read from\r
+ @param BufferSize Size of Buffer, must be a multiple of device block size.\r
+ @param Buffer A pointer to the destination buffer for the data. The caller is\r
+ responsible for either having implicit or explicit ownership of the buffer.\r
+\r
+ @retval EFI_SUCCESS The data was read correctly from the device.\r
+ @retval EFI_DEVICE_ERROR The device reported an error while performing the read.\r
+ @retval EFI_NO_MEDIA There is no media in the device.\r
+ @retval EFI_MEDIA_CHANGED The MediaId does not matched the current device.\r
+ @retval EFI_BAD_BUFFER_SIZE The Buffer was not a multiple of the block size of the device.\r
+ @retval EFI_INVALID_PARAMETER The read request contains LBAs that are not valid, \r
+ or the buffer is not on proper alignment.\r
+EFI_STATUS
+
+**/
EFI_STATUS
EFIAPI
MMCHSReadBlocks (
{
EFI_STATUS Status;
- if (Buffer == NULL)
- {
- return EFI_INVALID_PARAMETER;
- }
-
- if (Lba > This->Media->LastBlock)
- {
- return EFI_INVALID_PARAMETER;
- }
-
- if ((BufferSize % This->Media->BlockSize) != 0)
- {
- return EFI_BAD_BUFFER_SIZE;
- }
-
//Perform Read operation.
- Status = SdReadWrite(This, (UINTN)Lba, Buffer, BufferSize, READ);
- if (EFI_ERROR(Status)) {
- DEBUG ((EFI_D_ERROR, "Read operation fails.\n"));
- }
+ Status = SdReadWrite (This, (UINTN)Lba, Buffer, BufferSize, READ);
- return Status;
+ return Status;\r
}
+
+/**\r
+ Write BufferSize bytes from Lba into Buffer.\r
+\r
+ @param This Indicates a pointer to the calling context.\r
+ @param MediaId The media ID that the write request is for.\r
+ @param Lba The starting logical block address to be written. The caller is\r
+ responsible for writing to only legitimate locations.\r
+ @param BufferSize Size of Buffer, must be a multiple of device block size.\r
+ @param Buffer A pointer to the source buffer for the data.\r
+\r
+ @retval EFI_SUCCESS The data was written correctly to the device.\r
+ @retval EFI_WRITE_PROTECTED The device can not be written to.\r
+ @retval EFI_DEVICE_ERROR The device reported an error while performing the write.\r
+ @retval EFI_NO_MEDIA There is no media in the device.\r
+ @retval EFI_MEDIA_CHNAGED The MediaId does not matched the current device.\r
+ @retval EFI_BAD_BUFFER_SIZE The Buffer was not a multiple of the block size of the device.\r
+ @retval EFI_INVALID_PARAMETER The write request contains LBAs that are not valid, \r
+ or the buffer is not on proper alignment.\r
+\r
+**/
EFI_STATUS
EFIAPI
MMCHSWriteBlocks (
IN VOID *Buffer
)
{
- EFI_STATUS Status;
-
- if (Buffer == NULL) {
- return EFI_INVALID_PARAMETER;
- }
-
- if (Lba > This->Media->LastBlock) {
- return EFI_INVALID_PARAMETER;
- }
-
- if ((BufferSize % This->Media->BlockSize) != 0) {
- return EFI_BAD_BUFFER_SIZE;
- }
-
- if (This->Media->ReadOnly) {
- return EFI_WRITE_PROTECTED;
- }
+ EFI_STATUS Status;
//Perform write operation.
- Status = SdReadWrite(This, (UINTN)Lba, Buffer, BufferSize, WRITE);
- if (EFI_ERROR(Status)) {
- DEBUG ((EFI_D_ERROR, "Write operation fails.\n"));
- }
-
- return Status;
+ Status = SdReadWrite (This, (UINTN)Lba, Buffer, BufferSize, WRITE);
+\r
+ return Status;\r
}
+
+/**\r
+ Flush the Block Device.\r
+\r
+ @param This Indicates a pointer to the calling context.\r
+\r
+ @retval EFI_SUCCESS All outstanding data was written to the device\r
+ @retval EFI_DEVICE_ERROR The device reported an error while writting back the data\r
+ @retval EFI_NO_MEDIA There is no media in the device.\r
+\r
+**/
EFI_STATUS
EFIAPI
MMCHSFlushBlocks (
return EFI_SUCCESS;
}
-EFI_BLOCK_IO_PROTOCOL BlockIo =
-{
+
+EFI_BLOCK_IO_PROTOCOL gBlockIo = {
EFI_BLOCK_IO_INTERFACE_REVISION, // Revision
- &MMCHSMedia, // *Media
+ &gMMCHSMedia, // *Media
MMCHSReset, // Reset
MMCHSReadBlocks, // ReadBlocks
MMCHSWriteBlocks, // WriteBlocks
MMCHSFlushBlocks // FlushBlocks
};
+
+/**\r
+ Timer callback to convert card present hardware into a boolean that indicates\r
+ a media change event has happened. If you just check the GPIO you could see \r
+ card 1 and then check again after card 1 was removed and card 2 was inserted\r
+ and you would still see media present. Thus you need the timer tick to catch\r
+ the toggle event.\r
+\r
+ @param Event Event whose notification function is being invoked.\r
+ @param Context The pointer to the notification function's context,\r
+ which is implementation-dependent. Not used.\r
+\r
+**/
+VOID
+EFIAPI
+TimerCallback (
+ IN EFI_EVENT Event,
+ IN VOID *Context
+ )
+{
+ BOOLEAN Present;
+
+ Present = CardPresent ();
+ if (gMMCHSMedia.MediaPresent) {
+ if (!Present && !gMediaChange) {
+ gMediaChange = TRUE;
+ }
+ } else {
+ if (Present && !gMediaChange) {
+ gMediaChange = TRUE;
+ }
+ }
+}
+
+
EFI_STATUS
+EFIAPI
MMCHSInitialize (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
{
EFI_STATUS Status;
- Status = gBS->LocateProtocol(&gEmbeddedExternalDeviceProtocolGuid, NULL, (VOID **)&gTPS65950);
+ Status = gBS->LocateProtocol (&gEmbeddedExternalDeviceProtocolGuid, NULL, (VOID **)&gTPS65950);
ASSERT_EFI_ERROR(Status);
- gCardInfo = (CARD_INFO *)AllocateZeroPool(sizeof(CARD_INFO));
- if (gCardInfo == NULL) {
- return EFI_OUT_OF_RESOURCES;
- }
-
- //Initialize MMC host controller.
- Status = InitializeMMCHS();
- if (EFI_ERROR(Status)) {
- DEBUG ((EFI_D_ERROR, "Initialize MMC host controller fails. Status: %x\n", Status));
- return Status;
- }
-
- //Card idenfication
- Status = PerformCardIdenfication();
- if (EFI_ERROR(Status)) {
- DEBUG ((EFI_D_ERROR, "No MMC/SD card detected.\n"));
- return EFI_SUCCESS; //NOTE: Check if this is correct..
- }
-
- //Get CSD (Card specific data) for the detected card.
- Status = GetCardSpecificData();
- if (EFI_ERROR(Status)) {
- return Status;
- }
-
- //Configure the card in data transfer mode.
- Status = PerformCardConfiguration();
- if (EFI_ERROR(Status)) {
- return Status;
- }
-
- //Patch the Media structure.
- MMCHSMedia.LastBlock = (gCardInfo->NumBlocks - 1);
- MMCHSMedia.BlockSize = gCardInfo->BlockSize;
+ ZeroMem (&gCardInfo, sizeof (CARD_INFO));
+
+ Status = gBS->CreateEvent (EVT_TIMER | EVT_NOTIFY_SIGNAL, TPL_CALLBACK, TimerCallback, NULL, &gTimerEvent);
+ ASSERT_EFI_ERROR (Status);
+
+ Status = gBS->SetTimer (gTimerEvent, TimerPeriodic, 1000000); // make me a PCD
+ ASSERT_EFI_ERROR (Status);
//Publish BlockIO.
- Status = gBS->InstallMultipleProtocolInterfaces(&ImageHandle,
- &gEfiBlockIoProtocolGuid, &BlockIo,
- &gEfiDevicePathProtocolGuid, &gMmcHsDevicePath,
- NULL);
+ Status = gBS->InstallMultipleProtocolInterfaces (
+ &ImageHandle,
+ &gEfiBlockIoProtocolGuid, &gBlockIo,
+ &gEfiDevicePathProtocolGuid, &gMmcHsDevicePath,
+ NULL
+ );
return Status;
}
projects / mirror_edk2.git / commitdiff