7e0eed9235
Usually, we want to operate only on "available" device
nodes ("available" means "status is okay and a matching binding is
found"), but that's not true in all cases.
Sometimes we want to operate on special nodes without matching
bindings, such as those describing memory.
To handle the distinction, change various additional devicetree APIs
making it clear that they operate only on available device nodes,
adjusting gen_defines and devicetree.h implementation details
accordingly:
- emit macros for all existing nodes in gen_defines.py, regardless
of status or matching binding
- rename DT_NUM_INST to DT_NUM_INST_STATUS_OKAY
- rename DT_NODE_HAS_COMPAT to DT_NODE_HAS_COMPAT_STATUS_OKAY
- rename DT_INST_FOREACH to DT_INST_FOREACH_STATUS_OKAY
- rename DT_ANY_INST_ON_BUS to DT_ANY_INST_ON_BUS_STATUS_OKAY
- rewrite DT_HAS_NODE_STATUS_OKAY in terms of a new DT_NODE_HAS_STATUS
- resurrect DT_HAS_NODE in the form of DT_NODE_EXISTS
- remove DT_COMPAT_ON_BUS as a public API
- use the new default_prop_types edtlib parameter
Signed-off-by: Martí Bolívar <marti.bolivar@nordicsemi.no>
300 lines
8.6 KiB
C
300 lines
8.6 KiB
C
/*
|
|
* Copyright (c) 2019, Henrik Brix Andersen <henrik@brixandersen.dk>
|
|
*
|
|
* Based on the i2c_mcux_lpi2c.c driver, which is:
|
|
* Copyright (c) 2016 Freescale Semiconductor, Inc.
|
|
* Copyright (c) 2019, NXP
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
#define DT_DRV_COMPAT openisa_rv32m1_lpi2c
|
|
|
|
#include <drivers/i2c.h>
|
|
#include <drivers/clock_control.h>
|
|
#include <fsl_lpi2c.h>
|
|
#include <logging/log.h>
|
|
LOG_MODULE_REGISTER(rv32m1_lpi2c);
|
|
|
|
#include "i2c-priv.h"
|
|
|
|
struct rv32m1_lpi2c_config {
|
|
LPI2C_Type *base;
|
|
char *clock_controller;
|
|
clock_control_subsys_t clock_subsys;
|
|
clock_ip_name_t clock_ip_name;
|
|
u32_t clock_ip_src;
|
|
u32_t bitrate;
|
|
void (*irq_config_func)(struct device *dev);
|
|
};
|
|
|
|
struct rv32m1_lpi2c_data {
|
|
lpi2c_master_handle_t handle;
|
|
struct k_sem transfer_sync;
|
|
struct k_sem completion_sync;
|
|
status_t completion_status;
|
|
};
|
|
|
|
static int rv32m1_lpi2c_configure(struct device *dev, u32_t dev_config)
|
|
{
|
|
const struct rv32m1_lpi2c_config *config = dev->config_info;
|
|
struct device *clk;
|
|
u32_t baudrate;
|
|
u32_t clk_freq;
|
|
int err;
|
|
|
|
if (!(I2C_MODE_MASTER & dev_config)) {
|
|
/* Slave mode not supported - yet */
|
|
LOG_ERR("Slave mode not supported");
|
|
return -ENOTSUP;
|
|
}
|
|
|
|
if (I2C_ADDR_10_BITS & dev_config) {
|
|
/* FSL LPI2C driver only supports 7-bit addressing */
|
|
LOG_ERR("10 bit addressing not supported");
|
|
return -ENOTSUP;
|
|
}
|
|
|
|
switch (I2C_SPEED_GET(dev_config)) {
|
|
case I2C_SPEED_STANDARD:
|
|
baudrate = KHZ(100);
|
|
break;
|
|
case I2C_SPEED_FAST:
|
|
baudrate = KHZ(400);
|
|
break;
|
|
case I2C_SPEED_FAST_PLUS:
|
|
baudrate = MHZ(1);
|
|
break;
|
|
/* TODO: only if SCL pin implements current source pull-up */
|
|
/* case I2C_SPEED_HIGH: */
|
|
/* baudrate = KHZ(3400); */
|
|
/* break; */
|
|
/* TODO: ultra-fast requires pin_config setting */
|
|
/* case I2C_SPEED_ULTRA: */
|
|
/* baudrate = MHZ(5); */
|
|
/* break; */
|
|
default:
|
|
LOG_ERR("Unsupported speed");
|
|
return -ENOTSUP;
|
|
}
|
|
|
|
clk = device_get_binding(config->clock_controller);
|
|
if (!clk) {
|
|
LOG_ERR("Could not get clock controller '%s'",
|
|
config->clock_controller);
|
|
return -EINVAL;
|
|
}
|
|
|
|
err = clock_control_get_rate(clk, config->clock_subsys, &clk_freq);
|
|
if (err) {
|
|
LOG_ERR("Could not get clock frequency (err %d)", err);
|
|
return -EINVAL;
|
|
}
|
|
|
|
LPI2C_MasterSetBaudRate(config->base, clk_freq, baudrate);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void rv32m1_lpi2c_master_transfer_callback(LPI2C_Type *base,
|
|
lpi2c_master_handle_t *handle,
|
|
status_t completionStatus,
|
|
void *userData)
|
|
{
|
|
struct device *dev = userData;
|
|
struct rv32m1_lpi2c_data *data = dev->driver_data;
|
|
|
|
ARG_UNUSED(base);
|
|
ARG_UNUSED(handle);
|
|
|
|
data->completion_status = completionStatus;
|
|
k_sem_give(&data->completion_sync);
|
|
}
|
|
|
|
static u32_t rv32m1_lpi2c_convert_flags(int msg_flags)
|
|
{
|
|
u32_t flags = 0U;
|
|
|
|
if (!(msg_flags & I2C_MSG_STOP)) {
|
|
flags |= kLPI2C_TransferNoStopFlag;
|
|
}
|
|
|
|
if (msg_flags & I2C_MSG_RESTART) {
|
|
flags |= kLPI2C_TransferRepeatedStartFlag;
|
|
}
|
|
|
|
return flags;
|
|
}
|
|
|
|
static int rv32m1_lpi2c_transfer(struct device *dev, struct i2c_msg *msgs,
|
|
u8_t num_msgs, u16_t addr)
|
|
{
|
|
const struct rv32m1_lpi2c_config *config = dev->config_info;
|
|
struct rv32m1_lpi2c_data *data = dev->driver_data;
|
|
lpi2c_master_transfer_t transfer;
|
|
status_t status;
|
|
int ret = 0;
|
|
|
|
k_sem_take(&data->transfer_sync, K_FOREVER);
|
|
|
|
/* Iterate over all the messages */
|
|
for (int i = 0; i < num_msgs; i++) {
|
|
if (I2C_MSG_ADDR_10_BITS & msgs->flags) {
|
|
ret = -ENOTSUP;
|
|
goto out;
|
|
}
|
|
|
|
/* Initialize the transfer descriptor */
|
|
transfer.flags = rv32m1_lpi2c_convert_flags(msgs->flags);
|
|
|
|
/* Prevent the controller to send a start condition between
|
|
* messages, except if explicitly requested.
|
|
*/
|
|
if (i != 0 && !(msgs->flags & I2C_MSG_RESTART)) {
|
|
transfer.flags |= kLPI2C_TransferNoStartFlag;
|
|
}
|
|
|
|
transfer.slaveAddress = addr;
|
|
transfer.direction = (msgs->flags & I2C_MSG_READ)
|
|
? kLPI2C_Read : kLPI2C_Write;
|
|
transfer.subaddress = 0;
|
|
transfer.subaddressSize = 0;
|
|
transfer.data = msgs->buf;
|
|
transfer.dataSize = msgs->len;
|
|
|
|
/* Start the transfer */
|
|
status = LPI2C_MasterTransferNonBlocking(config->base,
|
|
&data->handle,
|
|
&transfer);
|
|
|
|
/* Return an error if the transfer didn't start successfully
|
|
* e.g., if the bus was busy
|
|
*/
|
|
if (status != kStatus_Success) {
|
|
LOG_DBG("Could not start transfer (status %d)", status);
|
|
ret = -EIO;
|
|
goto out;
|
|
}
|
|
|
|
/* Wait for the transfer to complete */
|
|
k_sem_take(&data->completion_sync, K_FOREVER);
|
|
|
|
/* Return an error if the transfer didn't complete
|
|
* successfully. e.g., nak, timeout, lost arbitration
|
|
*/
|
|
if (data->completion_status != kStatus_Success) {
|
|
LOG_DBG("Transfer failed (status %d)",
|
|
data->completion_status);
|
|
LPI2C_MasterTransferAbort(config->base, &data->handle);
|
|
ret = -EIO;
|
|
goto out;
|
|
}
|
|
|
|
/* Move to the next message */
|
|
msgs++;
|
|
}
|
|
|
|
out:
|
|
k_sem_give(&data->transfer_sync);
|
|
return ret;
|
|
}
|
|
|
|
static void rv32m1_lpi2c_isr(void *arg)
|
|
{
|
|
struct device *dev = (struct device *)arg;
|
|
const struct rv32m1_lpi2c_config *config = dev->config_info;
|
|
struct rv32m1_lpi2c_data *data = dev->driver_data;
|
|
|
|
LPI2C_MasterTransferHandleIRQ(config->base, &data->handle);
|
|
}
|
|
|
|
static int rv32m1_lpi2c_init(struct device *dev)
|
|
{
|
|
const struct rv32m1_lpi2c_config *config = dev->config_info;
|
|
struct rv32m1_lpi2c_data *data = dev->driver_data;
|
|
lpi2c_master_config_t master_config;
|
|
struct device *clk;
|
|
u32_t clk_freq, dev_cfg;
|
|
int err;
|
|
|
|
CLOCK_SetIpSrc(config->clock_ip_name, config->clock_ip_src);
|
|
|
|
clk = device_get_binding(config->clock_controller);
|
|
if (!clk) {
|
|
LOG_ERR("Could not get clock controller '%s'",
|
|
config->clock_controller);
|
|
return -EINVAL;
|
|
}
|
|
|
|
err = clock_control_on(clk, config->clock_subsys);
|
|
if (err) {
|
|
LOG_ERR("Could not turn on clock (err %d)", err);
|
|
return -EINVAL;
|
|
}
|
|
|
|
err = clock_control_get_rate(clk, config->clock_subsys, &clk_freq);
|
|
if (err) {
|
|
LOG_ERR("Could not get clock frequency (err %d)", err);
|
|
return -EINVAL;
|
|
}
|
|
|
|
LPI2C_MasterGetDefaultConfig(&master_config);
|
|
LPI2C_MasterInit(config->base, &master_config, clk_freq);
|
|
LPI2C_MasterTransferCreateHandle(config->base, &data->handle,
|
|
rv32m1_lpi2c_master_transfer_callback,
|
|
dev);
|
|
|
|
dev_cfg = i2c_map_dt_bitrate(config->bitrate);
|
|
err = rv32m1_lpi2c_configure(dev, dev_cfg | I2C_MODE_MASTER);
|
|
if (err) {
|
|
LOG_ERR("Could not configure controller (err %d)", err);
|
|
return err;
|
|
}
|
|
|
|
config->irq_config_func(dev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct i2c_driver_api rv32m1_lpi2c_driver_api = {
|
|
.configure = rv32m1_lpi2c_configure,
|
|
.transfer = rv32m1_lpi2c_transfer,
|
|
};
|
|
|
|
#define RV32M1_LPI2C_DEVICE(id) \
|
|
static void rv32m1_lpi2c_irq_config_func_##id(struct device *dev); \
|
|
static const struct rv32m1_lpi2c_config rv32m1_lpi2c_##id##_config = { \
|
|
.base = \
|
|
(LPI2C_Type *)DT_INST_REG_ADDR(id), \
|
|
.clock_controller = DT_INST_CLOCKS_LABEL(id), \
|
|
.clock_subsys = \
|
|
(clock_control_subsys_t) DT_INST_CLOCKS_CELL(id, name),\
|
|
.clock_ip_name = INST_DT_CLOCK_IP_NAME(id), \
|
|
.clock_ip_src = kCLOCK_IpSrcFircAsync, \
|
|
.bitrate = DT_INST_PROP(id, clock_frequency), \
|
|
.irq_config_func = rv32m1_lpi2c_irq_config_func_##id, \
|
|
}; \
|
|
static struct rv32m1_lpi2c_data rv32m1_lpi2c_##id##_data = { \
|
|
.transfer_sync = Z_SEM_INITIALIZER( \
|
|
rv32m1_lpi2c_##id##_data.transfer_sync, 1, 1), \
|
|
.completion_sync = Z_SEM_INITIALIZER( \
|
|
rv32m1_lpi2c_##id##_data.completion_sync, 0, 1), \
|
|
}; \
|
|
DEVICE_AND_API_INIT(rv32m1_lpi2c_##id, \
|
|
DT_INST_LABEL(id), \
|
|
&rv32m1_lpi2c_init, \
|
|
&rv32m1_lpi2c_##id##_data, \
|
|
&rv32m1_lpi2c_##id##_config, \
|
|
POST_KERNEL, CONFIG_I2C_INIT_PRIORITY, \
|
|
&rv32m1_lpi2c_driver_api); \
|
|
static void rv32m1_lpi2c_irq_config_func_##id(struct device *dev) \
|
|
{ \
|
|
IRQ_CONNECT(DT_INST_IRQN(id), \
|
|
0, \
|
|
rv32m1_lpi2c_isr, DEVICE_GET(rv32m1_lpi2c_##id), \
|
|
0); \
|
|
irq_enable(DT_INST_IRQN(id)); \
|
|
} \
|
|
|
|
DT_INST_FOREACH_STATUS_OKAY(RV32M1_LPI2C_DEVICE)
|