3.5 I3C Target Driver

• Clock Control: Configure 64 MHz system clock

• Add I3C_Target_DMA Driver from the I3C Driver to the project

  1. Select I3C PLIB.

  2. Configure the Custom Name as I3C_Target

  3. Configure the respective DMA channels for transmit and receive operation.

• Configure any other settings as needed by the example

• Generate the code

• Add the code snippet(s) to the application code. Call the application API in the main function as shown in the snippet below. If the interrupts are enabled in the example, then enable the Global Interrupt (GIE).

• In case of DMA-based transmit and receive operation, the DMA priority regarding the CPU execution can be set based on the application requirement using the DMA_I3C1_TX_DMAPrioritySet API for the transmit DMA and the DMA_I3C1_RX_DMAPrioritySet API for the receive DMA.

#include "mcc_generated_files/system/system.h"
/*
    Main application
*/
int main(void)
{
    SYSTEM_Initialize();

    // If using interrupts in PIC18 High/Low Priority Mode you need to enable the Global High and Low Interrupts 
    // If using interrupts in PIC Mid-Range Compatibility Mode you need to enable the Global Interrupts 
    // Use the following macros to: 

    // Enable the Global High Interrupts 
    //INTERRUPT_GlobalInterruptHighEnable(); 

    // Disable the Global High Interrupts 
    //INTERRUPT_GlobalInterruptHighDisable(); 

    // Enable the Global Low Interrupts 
    //INTERRUPT_GlobalInterruptLowEnable(); 

    // Disable the Global Low Interrupts 
    //INTERRUPT_GlobalInterruptLowDisable(); 
    
    I3CUseCase_API();

    while(1)
    {
        
    }  
     
}

• Program the board

1. I3C Target Module must be operating in I3C mode.

uint8_t sendData[20] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
 
void I3CUseCase_TransmitData(void)
{
    enum I3C_TARGET_BUFFER_TRANSMIT_ERROR sendError;
     
    //Register user callback for Transaction complete interrupt. This will be used to
    //know the status of data transmit operation.
    I3C_Target_TransactionCompleteCallbackRegister(TransactionCompleteCallback); 
     
    //Setup to transmit 20 bytes of data
    sendError = I3C_Target_BufferTransmit(sendData, 20);
     
    if(sendError == I3C_TARGET_BUFFER_TRANSMIT_BUFFER_SIZE_EXCEEDED)
    {
        //software buffer size exceeded
    }
    else if(sendError == I3C_TARGET_BUFFER_TRANSMIT_NO_ERROR)
    {
        //No error during transmit setup
    }
     
}
 
void TransactionCompleteCallback(struct I3C_TARGET_TRANSACTION_COMPLETE_STATUS *transactionCompleteStatus)
{
    if(transactionCompleteStatus->dataFlowDirection == I3C_TARGET_DATA_TRANSMITTED)
    {
        //Data is transmitted
         
        //Check the error flags for error conditions occurred during last transaction
    }
}

1. I3C Target Module must be operating in I3C mode.

2. I3C Transaction Complete (module level interrupt), I3C General Interrupt (system level interrupt) and Global Interrupt must be enabled.

uint8_t receivedData[40]; //buffer to store received data
uint16_t numberOfBytesReceived;
 
void I3CUseCase_ReceiveData(void)
{
    enum I3C_TARGET_BUFFER_RECEIVE_ERROR receiveError;
     
    //Register user callback for Transaction Complete interrupt. This will be used to
    //know the status of data receive operation.
    I3C_Target_TransactionCompleteCallbackRegister(TransactionCompleteCallback);
 
    //Setup to receive 20 bytes of data
    receiveError = I3C_Target_BufferReceive(receivedData, 20);
 
    if (receiveError == I3C_TARGET_BUFFER_RECEIVE_BUFFER_SIZE_EXCEEDED)
    {
        //software buffer size exceeded
    }
    else if (receiveError == I3C_TARGET_BUFFER_RECEIVE_NO_ERROR)
    {
        //No error during receive setup
    }
     
    I3C_Target_NextPrivateTransactionACK();
}
 
void TransactionCompleteCallback(struct I3C_TARGET_TRANSACTION_COMPLETE_STATUS *transactionCompleteStatus)
{
    if(transactionCompleteStatus->dataFlowDirection == I3C_TARGET_DATA_RECEIVED)
    {
        //Data is received
         
        //Get number of bytes received during last transaction
        numberOfBytesReceived = transactionCompleteStatus->numOfBytesReceived;
         
        //Check the Receive Overrun and Buffer Overflow Error flags for error conditions occurred during last transaction
         
        //User can call I3C_Target_BufferReceive() here for next private write transaction
    }
}

1. I3C Target Module must be operating in I3C mode.

void I3CUseCase_IBI(void)
{
    enum I3C_TARGET_IBI_REQUEST_ERROR ibiError;
    uint8_t mandatoryByte = 0xAA;
    uint8_t payload[20] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20}; //Without Mandatory Data Byte
     
    //Register user callback for IBI done interrupt. This will be used to
    //know the status of IBI process.
    I3C_Target_IBIDoneCallbackRegister(IBIDoneCallback);
      
    I3C_Target_IBIMandatoryDataByteSet(mandatoryByte);
              
    if(I3C_Target_IsIBIEnabledOnBus())
    {
        //Send IBI request
        ibiError = I3C_Target_IBIRequest(payload, 20);
 
        if(ibiError == I3C_TARGET_IBI_REQUEST_NOT_IN_I3C_MODE)
        {
            //Target is not in I3C mode
        }
        else if(ibiError == I3C_TARGET_IBI_REQUEST_IBI_DISABLED_ON_BUS)
        {
            //IBI is not enabled on the bus
        }
        else if(ibiError == I3C_TARGET_IBI_REQUEST_SEND_BUFFER_SIZE_EXCEEDED)
        {
            //Software buffer size exceeded
        }
        else if(ibiError == I3C_TARGET_IBI_REQUEST_NO_ERROR)
        {
            //No error during IBI request
        } 
    }  
}
 
void IBIDoneCallback(void)
{
    //IBI process is completed
     
    //Check the error flags for error conditions occurred during last transaction
}

1. I3C Target Module must be operating in I3C mode.

2. I3C Reset (system level interrupt) and Global Interrupt must be enabled.

enum I3C_RESET_ACTION resetAction;
volatile bool resetPatternDetected = false;
 
void I3CUseCase_Reset(void)
{
    uint8_t resetCount = 0;
     
    //Register user callback for Reset action detected interrupt           
    I3C_Target_ResetPatternDetectedCallbackRegister(ResetPatternDetectedCallback); 
     
    while(1)
    {
        if(resetPatternDetected)
        {
            resetPatternDetected = false;
 
            if(resetAction == I3C_RESET_ACTION_NO_RESET)
            {
                resetCount = 0;
                 
                //No action required to be taken               
            }
            else if(resetAction == I3C_RESET_ACTION_RESET_PERIPHERAL)
            {
                resetCount = 0;
                 
                //Perform software peripheral reset
                I3C_Target_PeripheralReset();
                 
                I3C_Target_Initialize();
                 
                I3C_Target_HotJoinRequest();
            }
            else if(resetAction == I3C_RESET_ACTION_RESET_WHOLE_TARGET)
            {
                resetCount = 0;
                 
                //Soft reset of microcontroller
                RESET();
            }
            else if(resetAction == I3C_RESET_ACTION_NO_ACTION_SET)
            {
                if(resetCount == 0)
                {
                    //Reset Pattern detected w/o RSTACT for the first time
                    //Suggested user action is to reset the I3C module
                    resetCount++; // Increment counter
                     
                    //Perform software peripheral reset
                    I3C_Target_PeripheralReset();
                     
                    //It is suggested for the user to detect RSTACT or GETSTATUS CCC
                    //and reset the reset-count to 0 after the first reset as mentioned in the  
                    //MIPI spec            
                }
                else if(resetCount > 0)
                {
                    //Reset Pattern detected w/o RSTACT for the second time
                    //Suggested user action is to reset the whole device
                    //Note that the counter can be reset by user software if GETSTATUS CCC is received
                    resetCount = 0; // Reset counter
                     
                    //Soft reset of microcontroller
                    RESET();
                }
            }  
        }           
    }
}
 
void ResetPatternDetectedCallback(void)
{
    resetPatternDetected = true;
     
    resetAction = I3C_Target_ResetActionGetAndClear();  
}

1. I3C Target Module must be operating in I2C mode.

2. Hot Join capability must be enabled.

void I3CUseCase_HotJoinRequest(void)
{
    enum I3C_TARGET_OPERATING_MODE opMode;
    enum I3C_TARGET_HJ_REQUEST_ERROR hJRequestError; 
    enum I3C_TARGET_HJ_STATUS;
     
    //Get operating mode
    opMode = I3C_Target_OperatingModeGet();
     
    //opMode should be either I2C_SDR or I2C_HDR
     
    if(I3C_Target_IsHotJoinEnabledOnBus())
    {
        //Request for Hot Join
        hJRequestError = I3C_Target_HotJoinRequest();
         
        if(hJRequestError == I3C_TARGET_HJ_REQUEST_NO_ERROR)
        {
            //No error while requesting Hot Join
        }
        else if(hJRequestError == I3C_TARGET_HJ_REQUEST_NOT_HJ_CAPABLE)
        {
            //Target is not HJ capable
        }
        else if(hJRequestError == I3C_TARGET_HJ_REQUEST_DYNAMIC_ADDRESS_ALREADY_ASSIGNED)
        {
            //Dynamic address has been already assigned
        }
        else if(hJRequestError == I3C_TARGET_HJ_REQUEST_HJ_DISABLED_ON_BUS)
        {
            //HJ is disabled on the bus
        }
         
        //Wait for Hot Join to complete
        while(I3C_Target_HotJoinStatusGet() == I3C_TARGET_HJ_PENDING);
         
        //Get operating mode
        opMode = I3C_Target_OperatingModeGet();
     
        //opMode should be either I3C_SDR or I3C_HDR
    }        
}

1. I3C Target Module must be operating in I3C mode.

2. I3C Bus error (module level interrupt), I3C error (system level interrupt) and Global interrupt must be enabled.

volatile uint8_t busErrorStatus;
volatile uint8_t busErrorReceived;
 
void I3CUseCase_BusError(void)
{ 
    //Register user callback for Bus error
    I3C_Target_BusErrorCallbackRegister(BusErrorCallback);
        
    while(1)
    {
        if(busErrorReceived)
        {
            busErrorReceived = false;
 
            if(busErrorStatus &= I3C_TARGET_BUS_TE0_ERROR)
            {
                //Perform required action as per the application
            }
 
            if(busErrorStatus &= I3C_TARGET_BUS_TE1_ERROR)
            {
                //Perform required action as per the application
            }
 
            if(busErrorStatus &= I3C_TARGET_BUS_TE2_ERROR)
            {
                //Perform required action as per the application
            }
 
            if(busErrorStatus &= I3C_TARGET_BUS_TE3_ERROR)
            {
                //Perform required action as per the application
            }
             
            if(busErrorStatus &= I3C_TARGET_BUS_TE4_ERROR)
            {
                //Perform required action as per the application
            }
 
            if(busErrorStatus &= I3C_TARGET_BUS_TE5_ERROR)
            {
                //Perform required action as per the application
            }
 
            if(busErrorStatus &= I3C_TARGET_BUS_TE6_ERROR)
            {
                //Perform required action as per the application
            }
        }
    }
}
 
void BusErrorCallback(void)
{
    busErrorReceived = true;
             
    busErrorStatus = I3C_Target_BusErrorStatusGetAndClear();
}

1. I3C Target Module must be operating in I3C mode.

2. I3C Unsupported CCC (module level interrupt), I3C error (system level interrupt) and Global interrupt must be enabled.

volatile enum I3C_CCC receivedCCC;
volatile bool unsupportedCCCreceived = false;
 
void I3CUseCase_UsingUnsupportedCCC(void)
{ 
    //Register user callback for Unsupported CCC
    I3C_Target_UnsupportedCCCReceivedCallbackRegister(UnsupportedCCCReceivedCallback);
     
    while(1)
    {
        if(unsupportedCCCreceived)
        {
            unsupportedCCCreceived = false;
             
            switch(receivedCCC)
            {
                case I3C_CCC_ENTTM_D :
                    //Perform required action as per the application
                    break;
                     
                case I3C_CCC_GETCAPS_D :
                    //Perform required action as per the application
                    break;
                     
                case I3C_CCC_SETROUTE_D :
                    //Perform required action as per the application
                    break;
            }
        }
    }
}
 
void UnsupportedCCCReceivedCallback(void)
{
    unsupportedCCCreceived = true;
             
    receivedCCC = I3C1_LastCCCReceivedGet();
}