Subversion Repositories xenie

/******************************************************************************

*

* Copyright (C) 2006 - 2014 Xilinx, Inc.  All rights reserved.

*

* Permission is hereby granted, free of charge, to any person obtaining a copy

* of this software and associated documentation files (the "Software"), to deal

* in the Software without restriction, including without limitation the rights

* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

* copies of the Software, and to permit persons to whom the Software is

* furnished to do so, subject to the following conditions:

*

* The above copyright notice and this permission notice shall be included in

* all copies or substantial portions of the Software.

*

* Use of the Software is limited solely to applications:

* (a) running on a Xilinx device, or

* (b) that interact with a Xilinx device through a bus or interconnect.

*

* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

* XILINX  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF

* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

* SOFTWARE.

*

* Except as contained in this notice, the name of the Xilinx shall not be used

* in advertising or otherwise to promote the sale, use or other dealings in

* this Software without prior written authorization from Xilinx.

*

******************************************************************************/

/*****************************************************************************/

/**

* @file xiic_slave_example.c

*

* This file consists of a Interrupt mode design example which uses the Xilinx

* IIC device and XIic driver to exercise the slave functionality of the IIC

* device.

*

* The XIic_SlaveSend() API is used to transmit the data and

* XIic_SlaveRecv() API is used to receive the data.

*

* The example is tested on ML300/ML310/ML403/ML501 Xilinx boards.

*

* The IIC devices that are present on the Xilinx boards donot support the Master

* functionality. This example has been tested with an off board external IIC

* Master device and the IIC device configured as a Slave.

*

* This code assumes that no Operating System is being used.

*

* @note

*

* None.

*

* <pre>

* MODIFICATION HISTORY:

*

* Ver   Who  Date        Changes

* ----- ---- -------- -----------------------------------------------

* 1.00a mta  03/01/06 Created.

* 2.00a ktn  11/17/09 Updated to use the HAL APIs and replaced call to

*                     XIic_Initialize API with XIic_LookupConfig and

*                     XIic_CfgInitialize. Some of the macros have been

*                     renamed in the IIC driver and some renamed macros are

*                     used in this example.

* </pre>

*

******************************************************************************/

/***************************** Include Files *********************************/

#include "xparameters.h"

#include "xiic.h"

#include "xintc.h"

#include "xil_exception.h"

/************************** Constant Definitions *****************************/

/*

 * The following constants map to the XPAR parameters created in the

 * xparameters.h file. They are defined here such that a user can easily

 * change all the needed parameters in one place.

 */

#define IIC_DEVICE_ID           XPAR_IIC_0_DEVICE_ID

#define INTC_DEVICE_ID          XPAR_INTC_0_DEVICE_ID

#define IIC_INTR_ID             XPAR_INTC_0_IIC_0_VEC_ID

/*

 * The following constant defines the address of the IIC device on the IIC bus.

 * Since the address is only 7 bits, this constant is the address divided by 2.

 */

#define SLAVE_ADDRESS           0x70    /* 0xE0 as an 8 bit number. */

#define RECEIVE_COUNT           25

#define SEND_COUNT              25

/**************************** Type Definitions *******************************/

/***************** Macros (Inline Functions) Definitions *********************/

/************************** Function Prototypes ******************************/

int IicSlaveExample();

int SlaveWriteData(u16 ByteCount);

int SlaveReadData(u8 *BufferPtr, u16 ByteCount);

static int SetupInterruptSystem(XIic * IicInstPtr);

static void StatusHandler(XIic *InstancePtr, int Event);

static void SendHandler(XIic *InstancePtr);

static void ReceiveHandler(XIic *InstancePtr);

/************************** Variable Definitions *****************************/

XIic IicInstance;               /* The instance of the IIC device. */

XIntc InterruptController;      /* The instance of the Interrupt Controller */

u8 WriteBuffer[SEND_COUNT];     /* Write buffer for writing a page. */

u8 ReadBuffer[RECEIVE_COUNT];   /* Read buffer for reading a page. */

volatile u8 TransmitComplete;

volatile u8 ReceiveComplete;

volatile u8 SlaveRead;

volatile u8 SlaveWrite;

/************************** Function Definitions *****************************/

/*****************************************************************************/

/**

* Main function to call the IIC Slave example.

*

* @param        None.

*

* @return       XST_SUCCESS if successful else XST_FAILURE.

*

* @note         None.

*

******************************************************************************/

int main(void)

{

        int Status;

        /*

         * Run the IIC Slave example.

         */

        Status = IicSlaveExample();

        if (Status != XST_SUCCESS) {

                return XST_FAILURE;

        }

        return XST_SUCCESS;

}

/*****************************************************************************/

/**

* This function writes and reads the data as a slave. The IIC master on the bus

* initiates the transfers.

*

* @param        None.

*

* @return       XST_SUCCESS if successful else XST_FAILURE.

*

* @note         None.

*

******************************************************************************/

int IicSlaveExample()

{

        int Status;

        u8 Index;

        XIic_Config *ConfigPtr; /* Pointer to configuration data */

        /*

         * Initialize the IIC driver so that it is ready to use.

         */

        ConfigPtr = XIic_LookupConfig(IIC_DEVICE_ID);

        if (ConfigPtr == NULL) {

                return XST_FAILURE;

        }

        Status = XIic_CfgInitialize(&IicInstance, ConfigPtr,

                                        ConfigPtr->BaseAddress);

        if (Status != XST_SUCCESS) {

                return XST_FAILURE;

        }

        /*

         * Setup the Interrupt System.

         */

        Status = SetupInterruptSystem(&IicInstance);

        if (Status != XST_SUCCESS) {

                return XST_FAILURE;

        }

        /*

         * Include the Slave functions.

         */

        XIic_SlaveInclude();

        /*

         * Set the Transmit, Receive and Status Handlers.

         */

        XIic_SetStatusHandler(&IicInstance, &IicInstance,

                                  (XIic_StatusHandler) StatusHandler);

        XIic_SetSendHandler(&IicInstance, &IicInstance,

                                (XIic_Handler) SendHandler);

        XIic_SetRecvHandler(&IicInstance, &IicInstance,

                                (XIic_Handler) ReceiveHandler);

        /*

         * Set the Address as a RESPOND type.

         */

        Status = XIic_SetAddress(&IicInstance, XII_ADDR_TO_RESPOND_TYPE,

                                 SLAVE_ADDRESS);

        if (Status != XST_SUCCESS) {

                return XST_FAILURE;

        }

        /*

         * The IIC Master on this bus should initiate the transfer

         * and write data to the slave at this instance.

         */

        SlaveReadData(ReadBuffer, RECEIVE_COUNT);

        for (Index = 0; Index < SEND_COUNT; Index++) {

                WriteBuffer[Index] = Index;

        }

        /*

         * The IIC Master on this bus should initiate the transfer

         * and read data from the slave.

         */

        SlaveWriteData(SEND_COUNT);

        return XST_SUCCESS;

}

/*****************************************************************************/

/**

* This function reads a buffer of bytes  when the IIC Master on the bus writes

* data to the slave device.

*

* @param        BufferPtr contains the address of the data buffer to be filled.

* @param        ByteCount contains the number of bytes in the buffer to be read.

*

* @return       XST_SUCCESS if successful else XST_FAILURE.

*

* @note         None

*

******************************************************************************/

int SlaveReadData(u8 *BufferPtr, u16 ByteCount)

{

        int Status;

        /*

         * Set the defaults.

         */

        ReceiveComplete = 1;

        /*

         * Start the IIC device.

         */

        Status = XIic_Start(&IicInstance);

        if (Status != XST_SUCCESS) {

                return XST_FAILURE;

        }

        /*

         * Set the Global Interrupt Enable.

         */

        XIic_IntrGlobalEnable(IicInstance.BaseAddress);

        /*

         * Wait for AAS interrupt and completion of data reception.

         */

        while ((ReceiveComplete) || (XIic_IsIicBusy(&IicInstance) == TRUE)) {

                if (SlaveRead) {

                        XIic_SlaveRecv(&IicInstance, ReadBuffer, RECEIVE_COUNT);

                        SlaveRead = 0;

                }

        }

        /*

         * Disable the Global Interrupt Enable.

         */

        XIic_IntrGlobalDisable(IicInstance.BaseAddress);

        /*

         * Stop the IIC device.

         */

        Status = XIic_Stop(&IicInstance);

        if (Status != XST_SUCCESS) {

                return XST_FAILURE;

        }

        return XST_SUCCESS;

}

/*****************************************************************************/

/**

* This function writes a buffer of bytes to the IIC bus when the IIC master

* initiates a read operation.

*

* @param        ByteCount contains the number of bytes in the buffer to be

*               written.

*

* @return       XST_SUCCESS if successful else XST_FAILURE.

*

* @note         None.

*

******************************************************************************/

int SlaveWriteData(u16 ByteCount)

{

        int Status;

        /*

         * Set the defaults.

         */

        TransmitComplete = 1;

        /*

         * Start the IIC device.

         */

        Status = XIic_Start(&IicInstance);

        if (Status != XST_SUCCESS) {

                return XST_FAILURE;

        }

        /*

         * Set the Global Interrupt Enable.

         */

        XIic_IntrGlobalEnable(IicInstance.BaseAddress);

        /*

         * Wait for AAS interrupt and transmission to complete.

         */

        while ((TransmitComplete) || (XIic_IsIicBusy(&IicInstance) == TRUE)) {

                if (SlaveWrite) {

                        XIic_SlaveSend(&IicInstance, WriteBuffer, SEND_COUNT);

                        SlaveWrite = 0;

                }

        }

        /*

         * Disable the Global Interrupt Enable bit.

         */

        XIic_IntrGlobalDisable(IicInstance.BaseAddress);

        /*

         * Stop the IIC device.

         */

        Status = XIic_Stop(&IicInstance);

        if (Status != XST_SUCCESS) {

                return XST_FAILURE;

        }

        return XST_SUCCESS;

}

/****************************************************************************/

/**

* This Status handler is called asynchronously from an interrupt context and

* indicates the events that have occurred.

*

* @param        InstancePtr is not used, but contains a pointer to the IIC

*               device driver instance which the handler is being called for.

* @param        Event indicates whether it is a request for a write or read.

*

* @return       None.

*

* @note         None.

*

****************************************************************************/

static void StatusHandler(XIic *InstancePtr, int Event)

{

        /*

         * Check whether the Event is to write or read the data from the slave.

         */

        if (Event == XII_MASTER_WRITE_EVENT) {

                /*

                 * Its a Write request from Master.

                 */

                SlaveRead = 1;

        } else {

                /*

                 * Its a Read request from the master.

                 */

                SlaveWrite = 1;

        }

}

/****************************************************************************/

/**

* This Send handler is called asynchronously from an interrupt

* context and indicates that data in the specified buffer has been sent.

*

* @param        InstancePtr is a pointer to the IIC driver instance for which

*               the handler is being called for.

*

* @return       None.

*

* @note         None.

*

****************************************************************************/

static void SendHandler(XIic *InstancePtr)

{

        TransmitComplete = 0;

}

/****************************************************************************/

/**

* This Receive handler is called asynchronously from an interrupt

* context and indicates that data in the specified buffer has been Received.

*

* @param        InstancePtr is a pointer to the IIC driver instance for which

*               the handler is being called for.

*

* @return       None.

*

* @note         None.

*

****************************************************************************/

static void ReceiveHandler(XIic *InstancePtr)

{

        ReceiveComplete = 0;

}

/****************************************************************************/

/**

* This function setups the interrupt system so interrupts can occur for the

* IIC. The function is application-specific since the actual system may or

* may not have an interrupt controller. The IIC device could be directly

* connected to a processor without an interrupt controller. The user should

* modify this function to fit the application.

*

* @param        IicInstPtr contains a pointer to the instance of the IIC  which

*               is going to be connected to the interrupt controller.

*

* @return       XST_SUCCESS if successful else XST_FAILURE.

*

* @note         None.

*

****************************************************************************/

static int SetupInterruptSystem(XIic * IicInstPtr)

{

        int Status;

        if (InterruptController.IsStarted == XIL_COMPONENT_IS_STARTED) {

                return XST_SUCCESS;

        }

        /*

         * Initialize the interrupt controller driver so that it's ready to use.

         */

        Status = XIntc_Initialize(&InterruptController, INTC_DEVICE_ID);

        if (Status != XST_SUCCESS) {

                return XST_FAILURE;

        }

        /*

         * Connect the device driver handler that will be called when an

         * interrupt for the device occurs, the handler defined above

         * performs the specific interrupt processing for the device.

         */

        Status = XIntc_Connect(&InterruptController, IIC_INTR_ID,

                                   (XInterruptHandler) XIic_InterruptHandler,

                                   IicInstPtr);

        if (Status != XST_SUCCESS) {

                return XST_FAILURE;

        }

        /*

         * Start the interrupt controller so interrupts are enabled for all

         * devices that cause interrupts.

         */

        Status = XIntc_Start(&InterruptController, XIN_REAL_MODE);

        if (Status != XST_SUCCESS) {

                return XST_FAILURE;

        }

        /*

         * Enable the interrupts for the IIC device.

         */

        XIntc_Enable(&InterruptController, IIC_INTR_ID);

        /*

         * Initialize the exception table.

         */

        Xil_ExceptionInit();

        /*

         * Register the interrupt controller handler with the exception table.

         */

        Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT,

                                 (Xil_ExceptionHandler) XIntc_InterruptHandler,

                                 &InterruptController);

        /*

         * Enable non-critical exceptions.

         */

        Xil_ExceptionEnable();

        return XST_SUCCESS;

}