Ejemplo n.º 1
0
int main(void) {
	remove_pcap();
	static XHwIcap HwIcap;

	XHwIcap_Config *CfgPtr = XHwIcap_LookupConfig(HWICAP_DEVICEID);
	if (CfgPtr == NULL) {
		return XST_FAILURE;
	}

	int Status = XHwIcap_custom_CfgInitialize(&HwIcap, CfgPtr, CfgPtr->BaseAddress);
	if (Status != XST_SUCCESS) {
		return XST_FAILURE;
	}

	/*
	 * Perform a self-test to ensure that the hardware was built correctly.
	 */
	Status = XHwIcap_SelfTest(&HwIcap);
	if (Status != XST_SUCCESS) {
		return XST_FAILURE;
	}

    test(&HwIcap);

	xil_printf("End ROM test.\n\r\n\r");
	return 0;
}
/**
*
* This function reads a frame from the device as an example using polled mode.
*
* @param	DeviceId is the XPAR_<HWICAP_INSTANCE>_DEVICE_ID value from
*		xparameters.h
*
* @return	XST_SUCCESS if successful, otherwise XST_FAILURE
*
* @note		None
*
****************************************************************************/
int HwIcapReadFramePolledExample(u16 DeviceId)
{
	int Status;
	u32 Index;
	XHwIcap_Config *CfgPtr;
	u32  FrameData[XHI_NUM_WORDS_FRAME_INCL_NULL_FRAME];

	/*
	 * Initialize the HwIcap instance.
	 */
	CfgPtr = XHwIcap_LookupConfig(DeviceId);
	if (CfgPtr == NULL) {
		return XST_FAILURE;
	}

	Status = XHwIcap_CfgInitialize(&HwIcap, CfgPtr, CfgPtr->BaseAddress);
	if (Status != XST_SUCCESS) {
		return XST_FAILURE;
	}

	/*
	 * Perform a self-test to ensure that the hardware was built correctly.
	 */
	Status = XHwIcap_SelfTest(&HwIcap);
	if (Status != XST_SUCCESS) {
		return XST_FAILURE;
	}

	/*
	 * Read the Frame
	 */
	Status = XHwIcap_DeviceReadFrame(&HwIcap,
					 HWICAP_EXAMPLE_TOP,
					 HWICAP_EXAMPLE_BLOCK,
					 HWICAP_EXAMPLE_HCLK,
					 HWICAP_EXAMPLE_MAJOR,
					 HWICAP_EXAMPLE_MINOR,
					 (u32 *) &FrameData[0]);
	if (Status != XST_SUCCESS) {
		printf("Failed to Read Frame: %d \r\n", Status);
		return XST_FAILURE;
	}

	/*
	 * Print Frame contents
	 */
	for (Index = XHI_NUM_FRAME_WORDS;
		Index < (XHI_NUM_FRAME_WORDS << 1) ; Index++) {

		printf("Frame Word %d -> \t %x \r\n",
			(Index - XHI_NUM_FRAME_WORDS) , FrameData[Index]);
	}

	printf("\r\nHwIcapReadFramePolledExample Passed Successfully.\r\n\r\n");
	return  XST_SUCCESS;
}
Ejemplo n.º 3
0
static void
remove_head_inst(void)
{
	struct xhwicap_instance *inst;
	XHwIcap_Config *cfg;

	/* Pull the head off of inst_list. */
	inst = inst_list;
	inst_list = inst->next_inst;

	cfg = XHwIcap_LookupConfig(inst->index);
	iounmap((void *) cfg->BaseAddress);
	cfg->BaseAddress = inst->save_BaseAddress;
}
Ejemplo n.º 4
0
static int __init
probe(int index)
{
	static const unsigned long remap_size
	    = CONFIG_XILINX_HWICAP_0_HIGHADDR - CONFIG_XILINX_HWICAP_0_BASEADDR + 1;
	struct xhwicap_instance *inst;
	XHwIcap_Config *cfg;

	/* Find the config for our instance. */
	cfg = XHwIcap_LookupConfig(index);
	if (!cfg)
		return -ENODEV;

	/* Allocate the inst and zero it out. */
	inst = (struct xhwicap_instance *) kmalloc(sizeof (struct xhwicap_instance),
						 GFP_KERNEL);
	if (!inst) {
		printk(KERN_ERR "%s #%d: Could not allocate instance.\n",
		       miscdev.name, index);
		return -ENOMEM;
	}
	memset(inst, 0, sizeof (struct xhwicap_instance));
	inst->index = index;

	/* Make it the head of inst_list. */
	inst->next_inst = inst_list;
	inst_list = inst;

	/* Change the addresses to be virtual; save the old ones to restore. */
	inst->save_BaseAddress = cfg->BaseAddress;
	cfg->BaseAddress = (u32) ioremap(inst->save_BaseAddress, remap_size);

	/* Tell the Xilinx code to bring this HWICAP interface up. */
	/* REALLY FIXME - XC2V1000 is hard coded - bleugh! */
	if (XHwIcap_Initialize(&inst->HwIcap, cfg->DeviceId, 
				XHI_XC2V1000) != XST_SUCCESS) {
		printk(KERN_ERR "%s #%d: Could not initialize instance.\n",
		       miscdev.name, inst->index);
		remove_head_inst();
		return -ENODEV;
	}

	printk(KERN_INFO "%s #%d at 0x%08X mapped to 0x%08X\n",
	       miscdev.name, inst->index,
	       inst->save_BaseAddress, cfg->BaseAddress);

	return 0;
}
Ejemplo n.º 5
0
/**
*
* The purpose of this function is to illustrate the usage of the HwIcap driver.
*
* @param	HwIcapDeviceId is device ID of the XHwIcap Device, typically
*		XPAR_<HWICAP_instance>_DEVICE_ID value from xparameters.h
*
* @return	XST_SUCCESS to indicate success, otherwise XST_FAILURE.
*
* @note		None.
*
****************************************************************************/
int HwIcapTestAppExample(u16 HwIcapDeviceId)
{
	int Status;

	XHwIcap_Config *ConfigPtr;
	u32 ConfigRegData;

	/*
	 * Initialize the HwIcap driver.
	 */
	ConfigPtr = XHwIcap_LookupConfig(HwIcapDeviceId);
	if (ConfigPtr == NULL) {
		return XST_FAILURE;
	}

	Status = XHwIcap_CfgInitialize(&HwIcap, ConfigPtr,
				ConfigPtr->BaseAddress);
	if (Status != XST_SUCCESS) {
		return XST_FAILURE;
	}


	/*
	 * Perform a self-test to ensure that the hardware was built correctly.
	 */
	Status = XHwIcap_SelfTest(&HwIcap);
	if (Status != XST_SUCCESS) {
		return XST_FAILURE;
	}


	/*
	 * Read the ID Code register inside the FPGA.
	 */
	Status = XHwIcap_GetConfigReg(&HwIcap, XHI_IDCODE, &ConfigRegData);
	if (Status != XST_SUCCESS) {
		return XST_FAILURE;
	}


	return XST_SUCCESS;
}
Ejemplo n.º 6
0
///
/// Initialize the ICAP
///
void icap_init(void){
        CYG_REPORT_FUNCTION();

        XStatus Status;

        icap_config = XHwIcap_LookupConfig(HWICAP_DEVICEID);
        Status = XHwIcap_CfgInitialize(&HwIcap, &icap_config, icap_config->BaseAddress);

        if (Status != XST_SUCCESS)
        {
            switch (Status) {
                case XST_INVALID_PARAM:
                    diag_printf("HWICAP: invalid parameter\n");
                    break;
                case XST_FAILURE:
                    diag_printf("HWICAP: failure\n");
                    break;
                case XST_DEVICE_IS_STARTED:
                    diag_printf("HWICAP: device already started\n");
                    break;
                case XST_DEVICE_NOT_FOUND:
                    diag_printf("HWICAP: device not found\n");
                    break;
                default:
                    diag_printf("HWICAP: failed with return value %d\n", Status);
            }
            CYG_FAIL("failed to initialize icap\naborting\n");
        }

        // Run self test
        Status = XHwIcap_SelfTest(&HwIcap);
        if (Status != XST_SUCCESS) {
            CYG_FAIL("HWICAP: self-test failed\n");
        }

        cyg_mutex_init(&icap_mutex);

        CYG_REPORT_RETURN();
}
Ejemplo n.º 7
0
/**
*
* This function does a minimal test on the HwIcap device and driver as a
* design example. The purpose of this function is to illustrate how to use
* the XHwIcap component using the interrupt mode.
*
* This function sends data and expects to receive the same data.
*
*
* @param	IntcInstancePtr is a pointer to the instance of the INTC component.
* @param	HwIcapInstancePtr is a pointer to the instance of HwIcap component.
* @param	HwIcapDeviceId is the Device ID of the HwIcap Device and is the
*		XPAR_<HWICAP_instance>_DEVICE_ID value from xparameters.h.
* @param	HwIcapIntrId is the interrupt Id and is typically
*		XPAR_<INTC_instance>_<HWICAP_instance>_IP2INTC_IRPT_INTR
*		value from xparameters.h .
*
* @return	XST_SUCCESS if successful, otherwise XST_FAILURE.
*
* @note
*
* This function contains an infinite loop such that if interrupts are not
* working it may never return.
*
******************************************************************************/
int HwIcapIntrExample(XIntc *IntcInstancePtr, XHwIcap *HwIcapInstancePtr,
			u16 HwIcapDeviceId, u16 HwIcapIntrId)
{
	int Status;
	u32 Count;
	u8 Test;
	XHwIcap_Config *ConfigPtr;

	/*
	 * Initialize the HwIcap driver.
	 */
	ConfigPtr = XHwIcap_LookupConfig(HwIcapDeviceId);
	if (ConfigPtr == NULL) {
		return XST_FAILURE;
	}
	Status = XHwIcap_CfgInitialize(HwIcapInstancePtr,
					ConfigPtr,
					ConfigPtr->BaseAddress);
	if (Status != XST_SUCCESS) {
		return XST_FAILURE;
	}

	/*
	 * Perform a self-test to ensure that the hardware was built correctly.
	 */
	Status = XHwIcap_SelfTest(HwIcapInstancePtr);

	if (Status != XST_SUCCESS) {
		return XST_FAILURE;
	}

	/*
	 * Connect the HwIcap device to the interrupt subsystem such that
	 * interrupts can occur. This function is application specific.
	 */
	Status = HwIcapSetupInterruptSystem(IntcInstancePtr,
					HwIcapInstancePtr,
					HwIcapIntrId);
	if (Status != XST_SUCCESS) {
		return XST_FAILURE;
	}

	/*
	 * Setup the handler for the HwIcap that will be called from the
	 * interrupt context when an HwIcap status occurs, specify a pointer
	 * to the HwIcap driver instance as the callback reference so the
	 * handler is able to access the instance data.
	 */
	XHwIcap_SetInterruptHandler(HwIcapInstancePtr, HwIcapInstancePtr,
			 (XHwIcap_StatusHandler)HwIcapIntrHandler);

	/*
	 * Initialize the write buffer with pattern to write.
	 */
	for (Count = 0; Count < TEST_WRITE_BUFFER_SIZE;) {

		WriteBuffer[Count++] = XHI_DUMMY_PACKET;
		WriteBuffer[Count++] = XHI_SYNC_PACKET;
		WriteBuffer[Count++] = XHwIcap_Type1Read(XHI_IDCODE) | 1;
		WriteBuffer[Count++] = XHI_NOOP_PACKET;
		WriteBuffer[Count++] = XHI_NOOP_PACKET;
		WriteBuffer[Count++] = XHI_DUMMY_PACKET;
		WriteBuffer[Count++] = XHI_SYNC_PACKET;
		WriteBuffer[Count++] = XHwIcap_Type1Read(XHI_COR) | 1;
		WriteBuffer[Count++] = XHI_NOOP_PACKET;
		WriteBuffer[Count++] = XHI_NOOP_PACKET;
	}

	/*
	 * Enable the Write FIFO Half Full Interrupt.
	 */
	XHwIcap_IntrEnable(HwIcapInstancePtr, XHI_IPIXR_WRP_MASK);

	/*
	 * Write the the data to the device.
	 */
	TransferInProgress = TRUE;
	Status = XHwIcap_DeviceWrite(HwIcapInstancePtr,
					(u32 *) &WriteBuffer[0],
					TEST_WRITE_BUFFER_SIZE);
	if (Status != XST_SUCCESS)  {
		return XST_FAILURE;
	}

	/*
	 * Wait for the data to be written to the device.
	 */
	while (TransferInProgress);

	return XST_SUCCESS;
}
/**
*
* This function reads the configuration  registers inside the FPGA.
*
* @param	DeviceId is the XPAR_<HWICAP_INSTANCE>_DEVICE_ID value from
*		xparameters.h.
*
* @return	XST_SUCCESS if successful, otherwise XST_FAILURE.
*
* @note		None.
*
******************************************************************************/
int HwIcapReadConfigRegExample(u16 DeviceId)
{
	int Status;
	XHwIcap_Config *CfgPtr;
	u32 ConfigRegData;

	/*
	 * Initialize the HwIcap instance.
	 */
	CfgPtr = XHwIcap_LookupConfig(DeviceId);
	if (CfgPtr == NULL) {
		return XST_FAILURE;
	}

	Status = XHwIcap_CfgInitialize(&HwIcap, CfgPtr, CfgPtr->BaseAddress);
	if (Status != XST_SUCCESS) {
		return XST_FAILURE;
	}


	/*
	 * Run the Self test.
	 */
	Status = XHwIcap_SelfTest(&HwIcap);
	if (Status != XST_SUCCESS) {
		return XST_FAILURE;
	}

	printf("Value of the Configuration Registers. \r\n\r\n");

	if (XHwIcap_GetConfigReg(&HwIcap, XHI_CRC, (u32 *)&ConfigRegData) ==
		XST_SUCCESS) {
		printf(" CRC -> \t %x \t\r\n", ConfigRegData);
	}

	if (XHwIcap_GetConfigReg(&HwIcap, XHI_FAR, (u32 *)&ConfigRegData) ==
		XST_SUCCESS) {
		printf(" FAR -> \t %x \t\r\n", ConfigRegData);
	}

	if (XHwIcap_GetConfigReg(&HwIcap, XHI_FDRI, (u32 *)&ConfigRegData) ==
		XST_SUCCESS) {
		printf(" FDRI -> \t %x \t\r\n", ConfigRegData);
	}

	if (XHwIcap_GetConfigReg(&HwIcap, XHI_FDRO, (u32 *)&ConfigRegData) ==
		XST_SUCCESS) {
		printf(" FDRO -> \t %x \t\r\n", ConfigRegData);
	}

	if (XHwIcap_GetConfigReg(&HwIcap, XHI_CMD, (u32 *)&ConfigRegData) ==
		XST_SUCCESS) {
		printf(" CMD -> \t %x \t\r\n", ConfigRegData);
	}

	if (XHwIcap_GetConfigReg(&HwIcap, XHI_CTL, (u32 *)&ConfigRegData) ==
		XST_SUCCESS) {
		printf(" CTL -> \t %x \t\r\n", ConfigRegData);
	}

	if (XHwIcap_GetConfigReg(&HwIcap, XHI_MASK, (u32 *)&ConfigRegData) ==
		XST_SUCCESS) {
		printf(" MASK -> \t %x \t\r\n", ConfigRegData);
	}

	if (XHwIcap_GetConfigReg(&HwIcap, XHI_STAT, (u32 *)&ConfigRegData) ==
		XST_SUCCESS) {
		printf(" STAT -> \t %x \t\r\n", ConfigRegData);
	}

	if (XHwIcap_GetConfigReg(&HwIcap, XHI_LOUT, (u32 *)&ConfigRegData) ==
		XST_SUCCESS) {
		printf(" LOUT -> \t %x \t\r\n", ConfigRegData);
	}

	if (XHwIcap_GetConfigReg(&HwIcap, XHI_COR, (u32 *)&ConfigRegData) ==
		XST_SUCCESS) {
		printf(" COR -> \t %x \t\r\n", ConfigRegData);
	}
	if (XHwIcap_GetConfigReg(&HwIcap, XHI_MFWR, (u32 *)&ConfigRegData) ==
		XST_SUCCESS) {
		printf(" MFWR -> \t %x \t\r\n", ConfigRegData);
	}

	if (XHwIcap_GetConfigReg(&HwIcap, XHI_CBC, (u32 *)&ConfigRegData) ==
		XST_SUCCESS) {
		printf(" CBC -> \t %x \t\r\n", ConfigRegData);
	}

	if (XHwIcap_GetConfigReg(&HwIcap, XHI_AXSS, (u32 *)&ConfigRegData) ==
		XST_SUCCESS) {
		printf(" AXSS -> \t %x \t\r\n", ConfigRegData);
	}

	if (XHwIcap_GetConfigReg(&HwIcap, XHI_IDCODE, (u32 *)&ConfigRegData) ==
		XST_SUCCESS) {
		printf(" IDCODE -> \t %x \t\r\n", ConfigRegData);
	}

	if (XHwIcap_GetConfigReg(&HwIcap, XHI_COR_1, (u32 *)&ConfigRegData) ==
		XST_SUCCESS) {
		printf(" COR_1 -> \t %x \t\r\n", ConfigRegData);
	}

	if (XHwIcap_GetConfigReg(&HwIcap, XHI_CSOB, (u32 *)&ConfigRegData) ==
		XST_SUCCESS) {
		printf(" CSOB -> \t %x \t\r\n", ConfigRegData);
	}

	if (XHwIcap_GetConfigReg(&HwIcap, XHI_WBSTAR, (u32 *)&ConfigRegData) ==
		XST_SUCCESS) {
		printf(" WBSTAR -> \t %x \t\r\n", ConfigRegData);
	}

	if (XHwIcap_GetConfigReg(&HwIcap, XHI_TIMER, (u32 *)&ConfigRegData) ==
		XST_SUCCESS) {
		printf(" TIMER -> \t %x \t\r\n", ConfigRegData);
	}
	if (XHwIcap_GetConfigReg(&HwIcap, XHI_BOOTSTS, (u32 *)&ConfigRegData) ==
		XST_SUCCESS) {
		printf(" BOOTSTS -> \t %x \t\r\n", ConfigRegData);
	}

	if (XHwIcap_GetConfigReg(&HwIcap, XHI_CTL_1, (u32 *)&ConfigRegData) ==
		XST_SUCCESS) {
		printf(" CTL_1 -> \t %x \t\r\n", ConfigRegData);
	}

	printf("\r\n HwIcapReadConfigRegExample Passed Successfully.\r\n\r\n");

	return XST_SUCCESS;
}
Ejemplo n.º 9
0
/**
*
* This function does a test on the BRAM FF as an  example.
*
* @param	DeviceId is the XPAR_<HWICAP_INSTANCE>_DEVICE_ID value from
*		xparameters.h
*
* @return	XST_SUCCESS if successful, otherwise XST_FAILURE
*
* @note		None
*
****************************************************************************/
int HwIcapBramFfExample(u16 DeviceId)
{
	u32 SrMode=0;
	int Status;
	u32 Row;
	u32 Col;
	u32 Slice;
	u32 Loop;
	u32 Value;
	u8 Contents[1];
	XHwIcap_Config *CfgPtr;

	/*
	 * Initialize the HwIcap instance.
	 */
	CfgPtr = XHwIcap_LookupConfig(DeviceId);
	if (CfgPtr == NULL) {
		return XST_FAILURE;
	}

	Status = XHwIcap_CfgInitialize(&HwIcap, CfgPtr, CfgPtr->BaseAddress);
	if (Status != XST_SUCCESS) {
		return XST_FAILURE;
	}

	/*
	 * Identify the FF to change: FFX in SLICE_X0Y0.
	 */
	Col = XHwIcap_SliceX2Col(HWICAP_EXAMPLE_TEST_COL);
	Row = XHwIcap_SliceY2Row(&HwIcap, HWICAP_EXAMPLE_TEST_ROW);
	Slice = XHwIcap_SliceXY2Slice(HWICAP_EXAMPLE_TEST_COL,
						HWICAP_EXAMPLE_TEST_ROW);

	printf("Setting the SRMODE -> SRHIGH. \r\n");
	Status = XHwIcap_SetClbBits(&HwIcap, Row, Col,
		XHI_CLB_FF.SRMODE[Slice][XHI_CLB_XQ], XHI_CLB_FF.SRHIGH, 1);
	if (Status != XST_SUCCESS) {
		printf("Failed to Set SRMODE->SRHIGH: %d \r\n", Status);
		return XST_FAILURE;
	}

	printf("Setting the SRMODE -> SRLOW. \r\n");
	Status = XHwIcap_SetClbBits(&HwIcap, Row, Col,
	XHI_CLB_FF.SRMODE[Slice][XHI_CLB_XQ], XHI_CLB_FF.SRLOW, 1);
	if (Status != XST_SUCCESS) {
		printf("Failed to Set SRMODE->SRLOW: %d \r\n", Status);
		return XST_FAILURE;
	}


	printf("Set SRINV to SR \r\n");
	Status = XHwIcap_SetClbBits(&HwIcap, Row, Col,
		 XHI_CLB_SRINV.RES[Slice], XHI_CLB_SRINV.SR, 1);
	if (Status != XST_SUCCESS) {
		printf("Failed to Set SRINV->SR: %d \r\n", Status);
		return XST_FAILURE;
	}

	/*
	 * Set it back
	 */
	printf("Set SRINV to SR_B \r\n");
	Status = XHwIcap_SetClbBits(&HwIcap, Row, Col,
		 XHI_CLB_SRINV.RES[Slice], XHI_CLB_SRINV.SR_B, 1);
	if (Status != XST_SUCCESS) {
		printf("Failed to Set SRINV->SR_B: %d \r\n", Status);
		return XST_FAILURE;
	}

	/*
	 * Capture the FF states. If the CAPTURE block is instantiated in
	 * the design then the XHwIcap_CommandCapture() is not necessary.
	 */
	printf("Capture the FF state. \r\n");
	Status = XHwIcap_CommandCapture(&HwIcap);
	if (Status != XST_SUCCESS) {
		printf("Failed to capture FF states: %d \r\n", Status);
		return XST_FAILURE;
	}

	/*
	 * Read the FF Contents
	 */
	Status = XHwIcap_GetClbBits(&HwIcap, Row, Col,
					XHI_CLB_FF.CONTENTS[Slice][XHI_CLB_XQ],
					Contents, 1);
	if (Status != XST_SUCCESS) {
		printf("Failed to Get FF Contents: %d \r\n", Status);
		return XST_FAILURE;
	}

	/*
	 * The readback value of the FF is inverted from its true value.
	 */
	Value = ~Contents[0] & 0x1;
	printf("FF Contents: %d \r\n", Value);


	printf("HwicapBramFFExample Passed Successfully ... \r\n\r\n");
	return XST_SUCCESS;
}