drx_dap_wasi.c

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

/******************************
 *
 * DRXStatus_t DRXDAP_WASI_ReadModifyWriteReg16 (
 *      pI2CDeviceAddr_t devAddr,   -- address of I2C device
 *      DRXaddr_t        waddr,     -- address of chip register/memory
 *      DRXaddr_t        raddr,     -- chip address to read back from
 *      u16_t            wdata,     -- data to send
 *      pu16_t           rdata)     -- data to receive back
 *
 * Write 16-bit data, then read back the original contents of that location.
 *
 * Before sending data, the data is converted to little endian. The
 * data received back is converted back to the target platform's endianness.
 *
 * WARNING: This function is only guaranteed to work if there is one
 * master on the I2C bus.
 *
 * Output:
 * - DRX_STS_OK     if reading was successful
 *                  in that case: read back data is at *rdata
 * - DRX_STS_ERROR  if anything went wrong
 *
 ******************************/

static DRXStatus_t DRXDAP_WASI_ReadModifyWriteReg16 (
    pI2CDeviceAddr_t devAddr,
    DRXaddr_t        waddr,
    DRXaddr_t        raddr,
    u16_t            wdata,
    pu16_t           rdata)
{
    DRXStatus_t rc;

    if (rdata == NULL)
    {
        return DRX_STS_INVALID_ARG;
    }

    rc = DRXDAP_WASI_WriteReg16 (devAddr, waddr, wdata, DRXDAP_WASI_RMW);
    if (rc != DRX_STS_OK)
    {
        return rc;
    }
    return DRXDAP_WASI_ReadReg16 (devAddr, raddr, rdata, 0);
}




/******************************
 *
 * DRXStatus_t DRXDAP_WASI_ReadReg16 (
 *     pI2CDeviceAddr_t devAddr, -- address of I2C device
 *     DRXaddr_t        addr,    -- address of chip register/memory
 *     pu16_t           data,    -- data to receive
 *     DRXflags_t       flags)   -- special device flags
 *
 * Read one 16-bit register or memory location. The data received back is
 * converted back to the target platform's endianness.
 *
 * Output:
 * - DRX_STS_OK     if reading was successful
 *                  in that case: read data is at *data
 * - DRX_STS_ERROR  if anything went wrong
 *
 ******************************/

static DRXStatus_t DRXDAP_WASI_ReadReg16 (
    pI2CDeviceAddr_t devAddr,
    DRXaddr_t        addr,
    pu16_t           data,
    DRXflags_t       flags)
{
    u8_t buf[sizeof (*data)];
    DRXStatus_t rc;

    if (!data)
    {
        return DRX_STS_INVALID_ARG;
    }
    rc = DRXDAP_WASI_ReadBlock (devAddr, addr, sizeof (*data), buf, flags);
    *data = buf[0] + (((u16_t) buf[1]) << 8);
    return rc;
}




/******************************
 *
 * DRXStatus_t DRXDAP_WASI_ReadReg32 (
 *     pI2CDeviceAddr_t devAddr, -- address of I2C device
 *     DRXaddr_t        addr,    -- address of chip register/memory
 *     pu32_t           data,    -- data to receive
 *     DRXflags_t       flags)   -- special device flags
 *
 * Read one 32-bit register or memory location. The data received back is
 * converted back to the target platform's endianness.
 *
 * Output:
 * - DRX_STS_OK     if reading was successful
 *                  in that case: read data is at *data
 * - DRX_STS_ERROR  if anything went wrong
 *
 ******************************/

static DRXStatus_t DRXDAP_WASI_ReadReg32 (
    pI2CDeviceAddr_t devAddr,
    DRXaddr_t        addr,
    pu32_t           data,
    DRXflags_t       flags)
{
    u8_t buf[sizeof (*data)];
    DRXStatus_t rc;

    if (!data)
    {
        return DRX_STS_INVALID_ARG;
    }
    rc = DRXDAP_WASI_ReadBlock (devAddr, addr, sizeof (*data), buf, flags);
    *data = (((u32_t) buf[0]) <<  0) +
            (((u32_t) buf[1]) <<  8) +
            (((u32_t) buf[2]) << 16) +
            (((u32_t) buf[3]) << 24);
    return rc;
}




/******************************
 *
 * DRXStatus_t DRXDAP_WASI_WriteBlock (
 *      pI2CDeviceAddr_t devAddr,    -- address of I2C device
 *      DRXaddr_t        addr,       -- address of chip register/memory
 *      u16_t            datasize,   -- number of bytes to read
 *      pu8_t            data,       -- data to receive
 *      DRXflags_t       flags)      -- special device flags
 *
 * Write block data to chip address. Because the chip is word oriented,
 * the number of bytes to write must be even.
 *
 * Although this function expects an even number of bytes, it is still byte
 * oriented, and the data being written is NOT translated from the endianness of
 * the target platform.
 *
 * Output:
 * - DRX_STS_OK     if writing was successful
 * - DRX_STS_ERROR  if anything went wrong
 *
 ******************************/

static DRXStatus_t DRXDAP_WASI_WriteBlock (
    pI2CDeviceAddr_t devAddr,
    DRXaddr_t        addr,
    u16_t            datasize,
    pu8_t            data,
    DRXflags_t       flags)
{
    u8_t buf[ DRXDAP_MAX_WCHUNKSIZE];
    DRXStatus_t st;
    u16_t overhead_size = sizeof (addr) + (IS_I2C_10BIT (devAddr->i2cAddr) ? 2 : 1);
    u16_t blocksize = ( DRXDAP_MAX_WCHUNKSIZE - overhead_size) & ~1;

    if (overhead_size >  DRXDAP_MAX_WCHUNKSIZE_MIN)
    {
        return DRX_STS_INVALID_ARG;
    }

    flags &= DRXDAP_WASI_FLAGS;
    flags &= ~DRXDAP_WASI_MODEFLAGS;
#if DRXDAP_SINGLE_MASTER
    flags |= DRXDAP_WASI_SINGLE_MASTER;
#endif

    datasize &= ~1;     /* Rounded down to even number */
    if (datasize && !data)
    {
        return DRX_STS_INVALID_ARG;
    }

    do
    {
        u16_t todo;
        u16_t bufx = 0;
        addr  &= ~DRXDAP_WASI_FLAGS;
        addr |= flags;

        todo = (blocksize < datasize ? blocksize : datasize);
        buf[bufx++] = (u8_t) ((addr >>  0) & 0xFF);
        buf[bufx++] = (u8_t) ((addr >> 16) & 0xFF);
        buf[bufx++] = (u8_t) ((addr >> 24) & 0xFF);
        buf[bufx++] = (u8_t) ((addr >>  8) & 0xFF);
        /*
        In single master mode blocksize can be 0. In such a case this I2C
        sequense will be visible: (1) write address {i2c addr,
        4 bytes chip address} (2) write data {i2c addr, 4 bytes data }
        (3) write address (4) write data etc...
        Addres must be rewriten because HI is reset after data transport and
        expects an address.
        */
        if (!todo)
        {
            /* write address */
            st = DRXBSP_I2C_WriteRead (devAddr, (u16_t)(bufx + todo), buf, NULL, 0, NULL);
            bufx = 0;
            todo = (4 < datasize ? 4 : datasize);
        }
        DRXBSP_HST_Memcpy (&buf[bufx], data, todo);
        /* write (address if can do and) data */
        st = DRXBSP_I2C_WriteRead (devAddr, (u16_t)(bufx + todo), buf, NULL, 0, NULL);
        datasize -= todo;
        data += todo;
        addr += (todo >> 1);
    } while (datasize);
    return st;
}




/******************************
 *
 * DRXStatus_t DRXDAP_WASI_WriteReg16 (
 *     pI2CDeviceAddr_t devAddr, -- address of I2C device
 *     DRXaddr_t        addr,    -- address of chip register/memory
 *     u16_t            data,    -- data to send
 *     DRXflags_t       flags)   -- special device flags
 *
 * Write one 16-bit register or memory location. The data being written is
 * converted from the target platform's endianness to little endian.
 *
 * Output:
 * - DRX_STS_OK     if writing was successful
 * - DRX_STS_ERROR  if anything went wrong
 *
 ******************************/

static DRXStatus_t DRXDAP_WASI_WriteReg16 (
    pI2CDeviceAddr_t devAddr,
    DRXaddr_t        addr,
    u16_t            data,
    DRXflags_t       flags)
{
    u8_t buf[sizeof (data)];

    buf[0] = (u8_t) ( (data >> 0 ) & 0xFF );
    buf[1] = (u8_t) ( (data >> 8 ) & 0xFF );

    return DRXDAP_WASI_WriteBlock (devAddr, addr, sizeof (data), buf, flags);
}




/******************************
 *
 * DRXStatus_t DRXDAP_WASI_WriteReg32 (
 *     pI2CDeviceAddr_t devAddr, -- address of I2C device
 *     DRXaddr_t        addr,    -- address of chip register/memory
 *     u32_t            data,    -- data to send
 *     DRXflags_t       flags)   -- special device flags
 *
 * Write one 32-bit register or memory location. The data being written is
 * converted from the target platform's endianness to little endian.
 *
 * Output:
 * - DRX_STS_OK     if writing was successful
 * - DRX_STS_ERROR  if anything went wrong
 *
 ******************************/

static DRXStatus_t DRXDAP_WASI_WriteReg32 (
    pI2CDeviceAddr_t devAddr,
    DRXaddr_t        addr,
    u32_t            data,
    DRXflags_t       flags)
{
    u8_t buf[sizeof (data)];

    buf[0] = (u8_t) ( (data >> 0 ) & 0xFF );
    buf[1] = (u8_t) ( (data >> 8 ) & 0xFF );
    buf[2] = (u8_t) ( (data >> 16) & 0xFF );
    buf[3] = (u8_t) ( (data >> 24) & 0xFF );

    return DRXDAP_WASI_WriteBlock (devAddr, addr, sizeof (data), buf, flags);
}