284 lines
8.3 KiB
C
284 lines
8.3 KiB
C
/*
|
|
Copyright (C) 2016 Stephane D'Alu
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
#ifndef I2C_HELPERS_H
|
|
#define I2C_HELPERS_H
|
|
|
|
#include "hal.h"
|
|
#include "bswap.h"
|
|
|
|
|
|
typedef struct {
|
|
/**
|
|
* @brief Pointer to the I2C driver.
|
|
*/
|
|
I2CDriver *driver;
|
|
/**
|
|
* @brief I2C address.
|
|
*/
|
|
i2caddr_t addr;
|
|
} I2CHelper;
|
|
|
|
|
|
|
|
#if !defined(I2C_HELPERS_AUTOMATIC_DRV) || (I2C_HELPERS_AUTOMATIC_DRV == FALSE)
|
|
|
|
#define i2c_send(i2c, txbuf, txbytes) \
|
|
_i2c_send(i2c, txbuf, txbytes)
|
|
#define i2c_transmit(i2c, txbuf, txbytes, rxbuf, rxbytes) \
|
|
_i2c_transmit(i2c, txbuf, txbytes, rxbuf, rxbytes)
|
|
#define i2c_receive(i2, rxbuf, rxbytes) \
|
|
_i2c_receive(i2c, rxbuf, rxbytes)
|
|
|
|
#define i2c_send_timeout(i2c, txbuf, txbytes) \
|
|
_i2c_send(i2c, txbuf, txbytes)
|
|
#define i2c_transmit_timeout(i2c, txbuf, txbytes, rxbuf, rxbytes) \
|
|
_i2c_transmit(i2c, txbuf, txbytes, rxbuf, rxbytes)
|
|
#define i2c_receive_timeout(i2, rxbuf, rxbytes) \
|
|
_i2c_receive(i2c, rxbuf, rxbytes)
|
|
|
|
#define i2c_reg(i2c, reg) \
|
|
_i2c_reg(i2c, reg)
|
|
|
|
#define i2c_reg_recv8(i2c, reg, val) \
|
|
_i2c_reg_recv8(i2c, reg, val)
|
|
#define i2c_reg_recv16(i2c, reg, val) \
|
|
_i2c_reg_recv16(i2c, reg, val)
|
|
#define i2c_reg_recv16_le(i2c, reg, val) \
|
|
_i2c_reg_recv16_le(i2c, reg, val)
|
|
#define i2c_reg_recv16_be(i2c, reg, val) \
|
|
_i2c_reg_recv16_be(i2c, reg, val)
|
|
#define i2c_reg_recv32(i2c, reg, val) \
|
|
_i2c_reg_recv32(i2c, reg, val)
|
|
#define i2c_reg_recv32_le(i2c, reg, val) \
|
|
_i2c_reg_recv32_le(i2c, reg, val)
|
|
#define i2c_reg_recv32_be(i2c, reg, val) \
|
|
_i2c_reg_recv32_be(i2c, reg, val)
|
|
|
|
#define i2c_recv8(i2c, val) \
|
|
_i2c_recv8(i2c, val)
|
|
#define i2c_recv16(i2c, val) \
|
|
_i2c_recv16(i2c, val)
|
|
#define i2c_recv16_le(i2c, val) \
|
|
_i2c_recv16_le(i2c, val)
|
|
#define i2c_recv16_be(i2c, val) \
|
|
_i2c_recv16_be(i2c, val)
|
|
#define i2c_recv32(i2c, val) \
|
|
_i2c_recv32(i2c, val)
|
|
#define i2c_recv32_le(i2c, val) \
|
|
_i2c_recv32_le(i2c, val)
|
|
#define i2c_recv32_be(i2c, val) \
|
|
_i2c_recv32_be(i2c, val)
|
|
|
|
#else
|
|
|
|
#define i2c_send(txbuf, txbytes) \
|
|
_i2c_send(&drv->config->i2c, txbuf, txbytes)
|
|
#define i2c_transmit(txbuf, txbytes, rxbuf, rxbytes) \
|
|
_i2c_transmit(&drv->config->i2c, txbuf, txbytes, rxbuf, rxbytes)
|
|
#define i2c_receive(rxbuf, rxbytes) \
|
|
_i2c_receive(&drv->config->i2c, rxbuf, rxbytes)
|
|
|
|
#define i2c_send_timeout(txbuf, txbytes) \
|
|
_i2c_send(&drv->config->i2c, txbuf, txbytes)
|
|
#define i2c_transmit_timeout(txbuf, txbytes, rxbuf, rxbytes) \
|
|
_i2c_transmit(&drv->config->i2c, txbuf, txbytes, rxbuf, rxbytes)
|
|
#define i2c_receive_timeout(rxbuf, rxbytes) \
|
|
_i2c_receive(&drv->config->i2c, rxbuf, rxbytes)
|
|
|
|
|
|
#define i2c_reg(reg) \
|
|
_i2c_reg(&drv->config->i2c, reg)
|
|
|
|
#define i2c_reg_recv8(reg, val) \
|
|
_i2c_reg_recv8(&drv->config->i2c, reg, val)
|
|
#define i2c_reg_recv16(reg, val) \
|
|
_i2c_reg_recv16(&drv->config->i2c, reg, val)
|
|
#define i2c_reg_recv16_le(reg, val) \
|
|
_i2c_reg_recv16_le(&drv->config->i2c, reg, val)
|
|
#define i2c_reg_recv16_be(reg, val) \
|
|
_i2c_reg_recv16_be(&drv->config->i2c, reg, val)
|
|
#define i2c_reg_recv32(reg, val) \
|
|
_i2c_reg_recv32(&drv->config->i2c, reg, val)
|
|
#define i2c_reg_recv32_le(reg, val) \
|
|
_i2c_reg_recv32_le(&drv->config->i2c, reg, val)
|
|
#define i2c_reg_recv32_be(reg, val) \
|
|
_i2c_reg_recv32_be(&drv->config->i2c, reg, val)
|
|
|
|
#define i2c_recv8(val) \
|
|
_i2c_recv8(&drv->config->i2c, val)
|
|
#define i2c_recv16(val) \
|
|
_i2c_recv16(&drv->config->i2c, val)
|
|
#define i2c_recv16_le(val) \
|
|
_i2c_recv16_le(&drv->config->i2c, val)
|
|
#define i2c_recv16_be(val) \
|
|
_i2c_recv16_be(&drv->config->i2c, val)
|
|
#define i2c_recv32(val) \
|
|
_i2c_recv32(&drv->config->i2c, val)
|
|
#define i2c_recv32_le(val) \
|
|
_i2c_recv32_le(&drv->config->i2c, val)
|
|
#define i2c_recv32_be(val) \
|
|
_i2c_recv32_be(&drv->config->i2c, val)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
static inline msg_t
|
|
_i2c_send(I2CHelper *i2c, const uint8_t *txbuf, size_t txbytes) {
|
|
return i2cMasterTransmitTimeout(i2c->driver, i2c->addr,
|
|
txbuf, txbytes, NULL, 0, TIME_INFINITE);
|
|
};
|
|
|
|
static inline msg_t
|
|
_i2c_transmit(I2CHelper *i2c, const uint8_t *txbuf, size_t txbytes,
|
|
uint8_t *rxbuf, size_t rxbytes) {
|
|
return i2cMasterTransmitTimeout(i2c->driver, i2c->addr,
|
|
txbuf, txbytes, rxbuf, rxbytes, TIME_INFINITE);
|
|
}
|
|
|
|
static inline msg_t
|
|
_i2c_receive(I2CHelper *i2c, uint8_t *rxbuf, size_t rxbytes) {
|
|
return i2cMasterReceiveTimeout(i2c->driver, i2c->addr,
|
|
rxbuf, rxbytes, TIME_INFINITE);
|
|
};
|
|
|
|
|
|
|
|
static inline msg_t
|
|
_i2c_send_timeout(I2CHelper *i2c, const uint8_t *txbuf, size_t txbytes,
|
|
systime_t timeout) {
|
|
return i2cMasterTransmitTimeout(i2c->driver, i2c->addr,
|
|
txbuf, txbytes, NULL, 0, timeout);
|
|
};
|
|
|
|
static inline msg_t
|
|
_i2c_transmit_timeout(I2CHelper *i2c, const uint8_t *txbuf, size_t txbytes,
|
|
uint8_t *rxbuf, size_t rxbytes, systime_t timeout) {
|
|
return i2cMasterTransmitTimeout(i2c->driver, i2c->addr,
|
|
txbuf, txbytes, rxbuf, rxbytes, timeout);
|
|
}
|
|
|
|
static inline msg_t
|
|
_i2c_receive_timeout(I2CHelper *i2c, uint8_t *rxbuf, size_t rxbytes, systime_t timeout) {
|
|
return i2cMasterReceiveTimeout(i2c->driver, i2c->addr,
|
|
rxbuf, rxbytes, timeout);
|
|
};
|
|
|
|
|
|
/*======================================================================*/
|
|
|
|
|
|
static inline msg_t
|
|
_i2c_reg(I2CHelper *i2c, uint8_t reg) {
|
|
return _i2c_transmit(i2c, ®, sizeof(reg), NULL, 0);
|
|
};
|
|
|
|
/*======================================================================*/
|
|
|
|
static inline msg_t
|
|
_i2c_reg_recv8(I2CHelper *i2c, uint8_t reg, uint8_t *val) {
|
|
return _i2c_transmit(i2c, ®, sizeof(reg), (uint8_t*)val, sizeof(val));
|
|
};
|
|
|
|
static inline msg_t
|
|
_i2c_reg_recv16(I2CHelper *i2c, uint8_t reg, uint16_t *val) {
|
|
return _i2c_transmit(i2c, ®, sizeof(reg), (uint8_t*)val, sizeof(val));
|
|
};
|
|
|
|
static inline msg_t
|
|
_i2c_reg_recv16_le(I2CHelper *i2c, uint8_t reg, uint16_t *val) {
|
|
int msg = _i2c_reg_recv16(i2c, reg, val);
|
|
if (msg >= 0) *val = le16_to_cpu(*val);
|
|
return msg;
|
|
};
|
|
|
|
static inline msg_t
|
|
_i2c_reg_recv16_be(I2CHelper *i2c, uint8_t reg, uint16_t *val) {
|
|
int msg = _i2c_reg_recv16(i2c, reg, val);
|
|
if (msg >= 0) *val = be16_to_cpu(*val);
|
|
return msg;
|
|
};
|
|
|
|
static inline msg_t
|
|
_i2c_reg_recv32(I2CHelper *i2c, uint8_t reg, uint32_t *val) {
|
|
return _i2c_transmit(i2c, ®, sizeof(reg), (uint8_t*)val, sizeof(val));
|
|
};
|
|
|
|
static inline msg_t
|
|
_i2c_reg_recv32_le(I2CHelper *i2c, uint8_t reg, uint32_t *val) {
|
|
int msg = _i2c_reg_recv32(i2c, reg, val);
|
|
if (msg >= 0) *val = le32_to_cpu(*val);
|
|
return msg;
|
|
};
|
|
|
|
static inline msg_t
|
|
_i2c_reg_recv32_be(I2CHelper *i2c, uint8_t reg, uint32_t *val) {
|
|
int msg = _i2c_reg_recv32(i2c, reg, val);
|
|
if (msg >= 0) *val = be32_to_cpu(*val);
|
|
return msg;
|
|
};
|
|
|
|
|
|
/*======================================================================*/
|
|
|
|
static inline msg_t
|
|
_i2c_recv8(I2CHelper *i2c, uint8_t *val) {
|
|
return _i2c_receive(i2c, (uint8_t*)val, sizeof(val));
|
|
};
|
|
|
|
static inline msg_t
|
|
_i2c_recv16(I2CHelper *i2c, uint16_t *val) {
|
|
return _i2c_receive(i2c, (uint8_t*)val, sizeof(val));
|
|
};
|
|
|
|
static inline msg_t
|
|
_i2c_recv16_le(I2CHelper *i2c, uint16_t *val) {
|
|
int msg = _i2c_recv16(i2c, val);
|
|
if (msg >= 0) *val = le16_to_cpu(*val);
|
|
return msg;
|
|
};
|
|
|
|
static inline msg_t
|
|
_i2c_recv16_be(I2CHelper *i2c, uint16_t *val) {
|
|
int msg = _i2c_recv16(i2c, val);
|
|
if (msg >= 0) *val = be16_to_cpu(*val);
|
|
return msg;
|
|
};
|
|
|
|
static inline msg_t
|
|
_i2c_recv32(I2CHelper *i2c, uint32_t *val) {
|
|
return _i2c_receive(i2c, (uint8_t*)val, sizeof(val));
|
|
};
|
|
|
|
static inline msg_t
|
|
_i2c_recv32_le(I2CHelper *i2c, uint32_t *val) {
|
|
int msg = _i2c_recv32(i2c, val);
|
|
if (msg >= 0) *val = le32_to_cpu(*val);
|
|
return msg;
|
|
};
|
|
|
|
static inline msg_t
|
|
_i2c_recv32_be(I2CHelper *i2c, uint32_t *val) {
|
|
int msg = _i2c_recv32(i2c, val);
|
|
if (msg >= 0) *val = be32_to_cpu(*val);
|
|
return msg;
|
|
};
|
|
|
|
#endif
|