i2c_test.c

用于DRX3973或DRX39系列的芯片的控制

    /* Check DRX_Read with faulty parameters */
    /* Coverage: DRX_Read error checking     */
    if (DRX_Read (dev, addr, 4, 0, 0) != DRX_STS_INVALID_ARG)
    {
        return TEST_ARG_FAILED;
    }
    return TEST_OK;
}

TestError_t Test_API_DRX_Write_Param (pI2CDeviceAddr_t dev, DRXaddr_t addr, DRXaddr_t addr_rb)
{
    /* Check DRX_Write with faulty parameters */
    /* Coverage: DRX_Write error checking     */
    if (DRX_Write (dev, addr, 4, 0, 0) != DRX_STS_INVALID_ARG)
    {
        return TEST_ARG_FAILED;
    }
    return TEST_OK;
}

TestError_t Test_API_DRX_ReadModifyWriteReg16_Param (pI2CDeviceAddr_t dev, DRXaddr_t addr, DRXaddr_t addr_rb)
{
    /* Check DRX_ReadModifyWriteReg16 with faulty argument */
    /* Coverage: DRX_ReadModifyWriteReg16 error checking   */
    if (DRX_ReadModifyWriteReg16 (dev, addr, addr_rb, 0, 0) != DRX_STS_INVALID_ARG)
    {
        return TEST_ARG_FAILED;
    }
    return TEST_OK;
}

TestError_t Test_API_DRX_ReadReg16 (pI2CDeviceAddr_t dev, DRXaddr_t addr, DRXaddr_t addr_rb)
{
    /* Check DRX_ReadReg16 with faulty argument */
    /* Coverage: DRX_ReadReg16 error checking   */
    if (DRX_ReadReg16 (dev, addr, 0, 0) != DRX_STS_INVALID_ARG)
    {
        return TEST_ARG_FAILED;
    }
    return TEST_OK;
}

TestError_t Test_API_DRX_ReadReg32 (pI2CDeviceAddr_t dev, DRXaddr_t addr, DRXaddr_t addr_rb)
{
    /* Check DRX_ReadReg32 with faulty argument */
    /* Coverage: DRX_ReadReg16 error checking   */
    if (DRX_ReadReg32 (dev, addr, 0, 0) != DRX_STS_INVALID_ARG)
    {
        return TEST_ARG_FAILED;
    }
    return TEST_OK;
}

TestError_t Test_API_DRX_ReadReg16_I2C (pI2CDeviceAddr_t dev, DRXaddr_t addr, DRXaddr_t addr_rb)
{
    /* Check DRX_ReadReg16 with invalid I2C address */
    /* Coverage: DRX_ReadReg16, DRX_Read            */
    u16_t data;

    if (DRX_ReadReg16 (&dev[1], addr, &data, 0) != DRX_STS_ERROR
#ifdef BSP_I2C_USE_I2CECP
        || DRX_I2C_Error_g != I2CECP_STATUS_I2C_NAK
#endif
        )
    {
        return TEST_READ_ERROR_FAILED;
    }
    return TEST_OK;
}

TestError_t Test_API_DRX_ReadModifyWriteReg16_I2C (pI2CDeviceAddr_t dev, DRXaddr_t addr, DRXaddr_t addr_rb)
{
    /* Check DRX_ReadModifyWriteReg16 with invalid I2C address */
    /* Coverage: DRX_ReadModifyWriteReg16                                */
    u16_t data;

    if (DRX_ReadModifyWriteReg16 (&dev[1], addr, addr_rb, 0, &data) != DRX_STS_ERROR
#ifdef BSP_I2C_USE_I2CECP
        || DRX_I2C_Error_g != I2CECP_STATUS_I2C_NAK
#endif
        )
    {
        return TEST_WRITE_ERROR_FAILED;
    }
    return TEST_OK;
}

TestError_t Test_API_DRX_WriteReg16_I2C (pI2CDeviceAddr_t dev, DRXaddr_t addr, DRXaddr_t addr_rb)
{
    /* Check DRX_WriteReg16 with invalid I2C address */
    /* Coverage: DRX_WriteReg16, DRX_Write           */
    if (DRX_WriteReg16 (&dev[1], addr, 0, 0) != DRX_STS_ERROR
#ifdef BSP_I2C_USE_I2CECP
        || DRX_I2C_Error_g != I2CECP_STATUS_I2C_NAK
#endif
        )
    {
        return TEST_WRITE_ERROR_FAILED;
    }
    return TEST_OK;
}

TestError_t Test_API_DRX_ReadReg32_I2C (pI2CDeviceAddr_t dev, DRXaddr_t addr, DRXaddr_t addr_rb)
{
    /* Check DRX_ReadReg32 with invalid I2C address */
    /* Coverage: DRX_ReadReg32, DRX_Read            */
    u32_t data;

    if (DRX_ReadReg32 (&dev[1], addr, &data, 0) != DRX_STS_ERROR
#ifdef BSP_I2C_USE_I2CECP
        || DRX_I2C_Error_g != I2CECP_STATUS_I2C_NAK
#endif
        )
    {
        return TEST_READ_ERROR_FAILED;
    }
    return TEST_OK;
}

TestError_t Test_API_DRX_WriteReg32_I2C (pI2CDeviceAddr_t dev, DRXaddr_t addr, DRXaddr_t addr_rb)
{
    /* Check DRX_WriteReg32 with invalid I2C address */
    /* Coverage: DRX_WriteReg32, DRX_Write           */
    if (DRX_WriteReg32 (&dev[1], addr, 0, 0) != DRX_STS_ERROR
#ifdef BSP_I2C_USE_I2CECP
        || DRX_I2C_Error_g != I2CECP_STATUS_I2C_NAK
#endif
        )
    {
        return TEST_WRITE_ERROR_FAILED;
    }
    return TEST_OK;
}

TestError_t Test_API_DRX_ReadWriteReg16 (pI2CDeviceAddr_t dev, DRXaddr_t addr, DRXaddr_t addr_rb)
{
    /* Write 16-bit register and read back     */
    /* Coverage: DRX_WriteReg16, DRX_ReadReg16 */
    u16_t datain = 0;

    if (DRX_WriteReg16 (dev, addr, 0x1234, 0) != DRX_STS_OK)
    {
        return TEST_WRITE_I2C_FAILED;
    }
    if (DRX_WriteReg16 (dev, addr + 1, 0, 0) != DRX_STS_OK)
    {
        return TEST_WRITE_I2C_FAILED;
    }
    if (DRX_ReadReg16 (dev, addr, &datain, 0) != DRX_STS_OK)
    {
        return TEST_READ_I2C_FAILED;
    }
    if (datain != 0x1234)
    {
        return TEST_READ_FAILED;
    }
    return TEST_OK;
}

TestError_t Test_API_DRX_ReadWriteReg32 (pI2CDeviceAddr_t dev, DRXaddr_t addr, DRXaddr_t addr_rb)
{
    /* Write 32-bit register and read back     */
    /* Coverage: DRX_WriteReg32, DRX_ReadReg32 */
    u32_t datain = 0;

    if (DRX_WriteReg32 (dev, addr, 0x23456789, 0) != DRX_STS_OK)
    {
        return TEST_WRITE_I2C_FAILED;
    }
    if (DRX_WriteReg32 (dev, addr + 2, 0, 0) != DRX_STS_OK)
    {
        return TEST_WRITE_I2C_FAILED;
    }
    if (DRX_ReadReg32 (dev, addr, &datain, 0) != DRX_STS_OK)
    {
        return TEST_READ_I2C_FAILED;
    }
    if (datain != 0x23456789)
    {
        return TEST_READ_FAILED;
    }
    return TEST_OK;
}

TestError_t Test_API_DRX_ReadModifyWriteReg16 (pI2CDeviceAddr_t dev, DRXaddr_t addr, DRXaddr_t addr_rb)
{
    /* Check read-modify-write            */
    /* Coverage: DRX_ReadModifyWriteReg16 */
    u16_t datain = 0;

    if (DRX_WriteReg16 (dev, addr, 0x4321, 0) != DRX_STS_OK)
    {
        return TEST_WRITE_I2C_FAILED;
    }
    if (DRX_WriteReg16 (dev, addr + 1, 0, 0) != DRX_STS_OK)
    {
        return TEST_WRITE_I2C_FAILED;
    }
    if (DRX_ReadModifyWriteReg16 (dev, addr, addr_rb, 0x8765, &datain) != DRX_STS_OK)
    {
        return TEST_RMW_I2C_FAILED;
    }
    if (datain != 0x4321)
    {
        return TEST_RMW_FAILED;
    }
    if (DRX_ReadReg16 (dev, addr, &datain, 0) != DRX_STS_OK)
    {
        return TEST_READ_I2C_FAILED;
    }
    if (datain != 0x8765)
    {
        return TEST_READ_FAILED;
    }
    return TEST_OK;
}

TestError_t Test_API_Terminate (pI2CDeviceAddr_t dev, DRXaddr_t addr, DRXaddr_t addr_rb)
{
    /* Test 23 : shut down I2C subsystem */
    /* Coverage: DRXBSP_I2C_Term         */
    if (DRXBSP_I2C_Term () != DRX_STS_OK)
    {
        return TEST_TERMINATE_FAILED;
    }

    return TEST_OK;
}




#ifdef USE_MAIN


int main ()
{
    u32_t ver = 0; /* DRX_Lib_Version (); */
    TestError_t test_result;
    int testnr;
    int nsuccess;
    static Test_API_Func_t Test_API[] = {
        NULL,
        Test_API_Init,
        Test_API_DRXBSP_RW_Param,
        Test_API_DRX_Write,
        Test_API_DRX_Read,
        Test_API_DRX_Write2,
        Test_API_DRX_Read2,
        Test_API_DRX_Write_Odd,
        Test_API_DRX_Read_Odd,
        Test_API_DRX_Read_Param,
        Test_API_DRX_Write_Param,
        Test_API_DRX_ReadModifyWriteReg16_Param,
        Test_API_DRX_ReadReg16,
        Test_API_DRX_ReadReg32,
        Test_API_DRX_ReadReg16_I2C,
        Test_API_DRX_ReadModifyWriteReg16_I2C,
        Test_API_DRX_WriteReg16_I2C,
        Test_API_DRX_ReadReg32_I2C,
        Test_API_DRX_WriteReg32_I2C,
        Test_API_DRX_ReadWriteReg16,
        Test_API_DRX_ReadWriteReg32,
        Test_API_DRX_ReadModifyWriteReg16,
        Test_API_Terminate
    };
    static I2CDeviceAddr_t testdev[2] = { { I2C_DEVICE }, { I2C_DEVICE + 8} };

    xprint ("Version = %d.%d.%04d\n",
            (int)((ver >> 20) & 0xFFF),
            (int)((ver >> 16) & 0xF),
            (int)(ver & 0xFFFF));
#if DRXDAP_SINGLE_MASTER
    xprint ("Compiled in single master mode\n");
#else
    xprint ("Compiled in multi master mode\n");
#endif
    xprint ("Write chunk size = %u bytes\n", (unsigned)  DRXDAP_MAX_WCHUNKSIZE);
    xprint ("Read chunk size  = %u bytes\n", (unsigned)  DRXDAP_MAX_RCHUNKSIZE);
    for (testnr = 1, nsuccess = 1;
         testnr < (sizeof (Test_API) / sizeof (Test_API[0]));
         testnr++)
    {
        xprint ("\rTest %d: ", testnr);
        test_result = Test_API[testnr] (&testdev[0], TEST_MEM_ADDR, TEST_MEM_ADDR_READBACK);
        switch (test_result)
        {
        case TEST_OK:
            nsuccess++;
            break;
        case TEST_INIT_FAILED:
            xprint ("I2C subsystem not initialised\n");
            testnr = sizeof (Test_API) / sizeof (Test_API[0]) - 1;
            break;
        case TEST_ARG_FAILED:
            xprint ("Invalid arguments in function not detected\n");
            break;
        case TEST_WRITE_I2C_FAILED:
            xprint ("I2C error in write\n   %s\n",DRXBSP_I2C_ErrorText());
            break;
        case TEST_READ_I2C_FAILED:
            xprint ("I2C error in read\n   %s\n", DRXBSP_I2C_ErrorText());
            break;
        case TEST_RMW_I2C_FAILED:
            xprint ("I2C error in read-modify-write\n   %s\n", DRXBSP_I2C_ErrorText());
            break;
        case TEST_READ_FAILED:
            xprint ("Error in readback (non I2C-related)\n");
            break;
        case TEST_RMW_FAILED:
            xprint ("Error in read-modify-write readback (non I2C-related)\n");
            break;
        case TEST_READ_ERROR_FAILED:
            xprint ("I2C error in read expected\n   %s\n", DRXBSP_I2C_ErrorText());
            break;
        case TEST_WRITE_ERROR_FAILED:
            xprint ("I2C error in write expected\n   %s\n", DRXBSP_I2C_ErrorText());
            break;
        case TEST_TERMINATE_FAILED:
            xprint ("I2C subsystem not properly shutdown\n");
            break;
        default:
            xprint ("Unknown error!\n");
            break;
        }
    }

    if (nsuccess == testnr)
    {
        xprint ("\rAll tests passed\n");
    }
    xprint ("\r%d test%s failed\n", testnr - nsuccess,
        (testnr - nsuccess == 1 ? "" : "s"));

    xprint ("\nPress enter to exit program.\n");
    xgetchar();

    return 0;
}

#endif  /* USE_MAIN */