/** * * Initializes a specific XSpiPs instance such that the driver is ready to use. * * The state of the device after initialization is: * - Device is disabled * - Slave mode * - Active high clock polarity * - Clock phase 0 * * @param InstancePtr is a pointer to the XSpiPs instance. * @param ConfigPtr is a reference to a structure containing information * about a specific SPI device. This function initializes an * InstancePtr object for a specific device specified by the * contents of Config. This function can initialize multiple * instance objects with the use of multiple calls giving different * Config information on each call. * @param EffectiveAddr is the device base address in the virtual memory * address space. The caller is responsible for keeping the address * mapping from EffectiveAddr to the device physical base address * unchanged once this function is invoked. Unexpected errors may * occur if the address mapping changes after this function is * called. If address translation is not used, use * ConfigPtr->Config.BaseAddress for this device. * * @return * - XST_SUCCESS if successful. * - XST_DEVICE_IS_STARTED if the device is already started. * It must be stopped to re-initialize. * * @note None. * ******************************************************************************/ s32 XSpiPs_CfgInitialize(XSpiPs *InstancePtr, XSpiPs_Config *ConfigPtr, u32 EffectiveAddr) { s32 Status; Xil_AssertNonvoid(InstancePtr != NULL); Xil_AssertNonvoid(ConfigPtr != NULL); /* * If the device is busy, disallow the initialize and return a status * indicating it is already started. This allows the user to stop the * device and re-initialize, but prevents a user from inadvertently * initializing. This assumes the busy flag is cleared at startup. */ if (InstancePtr->IsBusy == TRUE) { Status = (s32)XST_DEVICE_IS_STARTED; } else { /* * Set some default values. */ InstancePtr->IsBusy = FALSE; InstancePtr->Config.BaseAddress = EffectiveAddr; InstancePtr->StatusHandler = StubStatusHandler; InstancePtr->SendBufferPtr = NULL; InstancePtr->RecvBufferPtr = NULL; InstancePtr->RequestedBytes = 0U; InstancePtr->RemainingBytes = 0U; InstancePtr->IsReady = XIL_COMPONENT_IS_READY; /* * Reset the SPI device to get it into its initial state. It is * expected that device configuration will take place after this * initialization is done, but before the device is started. */ XSpiPs_Reset(InstancePtr); Status = (s32)XST_SUCCESS; } return Status; }
/** * * Runs a self-test on the driver/device. The self-test is destructive in that * a reset of the device is performed in order to check the reset values of * the registers and to get the device into a known state. * * Upon successful return from the self-test, the device is reset. * * @param InstancePtr is a pointer to the XSpiPs instance. * * @return * - XST_SUCCESS if successful * - XST_REGISTER_ERROR indicates a register did not read or write * correctly. * * @note None. * ******************************************************************************/ s32 XSpiPs_SelfTest(XSpiPs *InstancePtr) { s32 Status; u32 Register; u8 DelayTestNss; u8 DelayTestBtwn; u8 DelayTestAfter; u8 DelayTestInit; Xil_AssertNonvoid(InstancePtr != NULL); Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY); /* * Reset the SPI device to leave it in a known good state */ XSpiPs_Reset(InstancePtr); /* * All the SPI registers should be in their default state right now. */ Register = XSpiPs_ReadReg(InstancePtr->Config.BaseAddress, XSPIPS_CR_OFFSET); if (Register != XSPIPS_CR_RESET_STATE) { return (s32)XST_REGISTER_ERROR; } Register = XSpiPs_ReadReg(InstancePtr->Config.BaseAddress, XSPIPS_SR_OFFSET); if (Register != XSPIPS_ISR_RESET_STATE) { return (s32)XST_REGISTER_ERROR; } DelayTestNss = 0x5AU; DelayTestBtwn = 0xA5U; DelayTestAfter = 0xAAU; DelayTestInit = 0x55U; /* * Write and read the delay register, just to be sure there is some * hardware out there. */ Status = XSpiPs_SetDelays(InstancePtr, DelayTestNss, DelayTestBtwn, DelayTestAfter, DelayTestInit); if (Status != (s32)XST_SUCCESS) { return Status; } XSpiPs_GetDelays(InstancePtr, &DelayTestNss, &DelayTestBtwn, &DelayTestAfter, &DelayTestInit); if ((0x5AU != DelayTestNss) || (0xA5U != DelayTestBtwn) || (0xAAU != DelayTestAfter) || (0x55U != DelayTestInit)) { return (s32)XST_REGISTER_ERROR; } Status = XSpiPs_SetDelays(InstancePtr, 0U, 0U, 0U, 0U); if (Status != (s32)XST_SUCCESS) { return Status; } /* * Reset the SPI device to leave it in a known good state */ XSpiPs_Reset(InstancePtr); return (s32)XST_SUCCESS; }