smbus.h

Go to the documentation of this file.

/*
 * Copyright (c) 2022 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_DRIVERS_SMBUS_H_
#define ZEPHYR_INCLUDE_DRIVERS_SMBUS_H_

 
#include <errno.h>
#include <zephyr/sys/slist.h>
#include <zephyr/types.h>
#include <zephyr/device.h>
 
#ifdef __cplusplus
extern "C" {
#endif


#define SMBUS_CMD_QUICK                 0b000

#define SMBUS_CMD_BYTE                  0b001

#define SMBUS_CMD_BYTE_DATA             0b010

#define SMBUS_CMD_WORD_DATA             0b011

#define SMBUS_CMD_PROC_CALL             0b100

#define SMBUS_CMD_BLOCK                 0b101

#define SMBUS_CMD_BLOCK_PROC            0b111

#define SMBUS_BLOCK_BYTES_MAX           32


#define SMBUS_MODE_CONTROLLER           BIT(0)

#define SMBUS_MODE_PEC                  BIT(1)

#define SMBUS_MODE_HOST_NOTIFY          BIT(2)

#define SMBUS_MODE_SMBALERT             BIT(3)



#define SMBUS_ADDRESS_ARA               0x0c



enum smbus_direction {
        SMBUS_MSG_WRITE = 0,
        SMBUS_MSG_READ = 1,
};


#define SMBUS_MSG_RW_MASK               BIT(0)
 
struct smbus_callback;

typedef void (*smbus_callback_handler_t)(const struct device *dev,
                                         struct smbus_callback *cb,
                                         uint8_t addr);

struct smbus_callback {
        sys_snode_t node;

        smbus_callback_handler_t handler;

        uint8_t addr;
};

struct smbus_dt_spec {
        const struct device *bus;
        uint16_t addr;
};

#define SMBUS_DT_SPEC_GET(node_id)                              \
        {                                                       \
                .bus = DEVICE_DT_GET(DT_BUS(node_id)),          \
                .addr = DT_REG_ADDR(node_id)                    \
        }

#define SMBUS_DT_SPEC_INST_GET(inst) SMBUS_DT_SPEC_GET(DT_DRV_INST(inst))


typedef int (*smbus_api_configure_t)(const struct device *dev,
                                     uint32_t dev_config);
typedef int (*smbus_api_get_config_t)(const struct device *dev,
                                      uint32_t *dev_config);
typedef int (*smbus_api_quick_t)(const struct device *dev,
                                 uint16_t addr, enum smbus_direction);
typedef int (*smbus_api_byte_write_t)(const struct device *dev,
                                      uint16_t addr, uint8_t byte);
typedef int (*smbus_api_byte_read_t)(const struct device *dev,
                                     uint16_t addr, uint8_t *byte);
typedef int (*smbus_api_byte_data_write_t)(const struct device *dev,
                                           uint16_t addr, uint8_t cmd,
                                           uint8_t byte);
typedef int (*smbus_api_byte_data_read_t)(const struct device *dev,
                                          uint16_t addr, uint8_t cmd,
                                          uint8_t *byte);
typedef int (*smbus_api_word_data_write_t)(const struct device *dev,
                                           uint16_t addr, uint8_t cmd,
                                           uint16_t word);
typedef int (*smbus_api_word_data_read_t)(const struct device *dev,
                                          uint16_t addr, uint8_t cmd,
                                          uint16_t *word);
typedef int (*smbus_api_pcall_t)(const struct device *dev,
                                 uint16_t addr, uint8_t cmd,
                                 uint16_t send_word, uint16_t *recv_word);
typedef int (*smbus_api_block_write_t)(const struct device *dev,
                                       uint16_t addr, uint8_t cmd,
                                       uint8_t count, uint8_t *buf);
typedef int (*smbus_api_block_read_t)(const struct device *dev,
                                      uint16_t addr, uint8_t cmd,
                                      uint8_t *count, uint8_t *buf);
typedef int (*smbus_api_block_pcall_t)(const struct device *dev,
                                       uint16_t addr, uint8_t cmd,
                                       uint8_t send_count, uint8_t *send_buf,
                                       uint8_t *recv_count, uint8_t *recv_buf);
typedef int (*smbus_api_smbalert_cb_t)(const struct device *dev,
                                       struct smbus_callback *cb);
typedef int (*smbus_api_host_notify_cb_t)(const struct device *dev,
                                          struct smbus_callback *cb);

__subsystem struct smbus_driver_api {
        smbus_api_configure_t configure;
        smbus_api_get_config_t get_config;
        smbus_api_quick_t smbus_quick;
        smbus_api_byte_write_t smbus_byte_write;
        smbus_api_byte_read_t smbus_byte_read;
        smbus_api_byte_data_write_t smbus_byte_data_write;
        smbus_api_byte_data_read_t smbus_byte_data_read;
        smbus_api_word_data_write_t smbus_word_data_write;
        smbus_api_word_data_read_t smbus_word_data_read;
        smbus_api_pcall_t smbus_pcall;
        smbus_api_block_write_t smbus_block_write;
        smbus_api_block_read_t smbus_block_read;
        smbus_api_block_pcall_t smbus_block_pcall;
        smbus_api_smbalert_cb_t smbus_smbalert_set_cb;
        smbus_api_smbalert_cb_t smbus_smbalert_remove_cb;
        smbus_api_host_notify_cb_t smbus_host_notify_set_cb;
        smbus_api_host_notify_cb_t smbus_host_notify_remove_cb;
};

 
#if defined(CONFIG_SMBUS_STATS) || defined(__DOXYGEN__)
 
#include <zephyr/stats/stats.h>

 
STATS_SECT_START(smbus)
STATS_SECT_ENTRY32(bytes_read)
STATS_SECT_ENTRY32(bytes_written)
STATS_SECT_ENTRY32(command_count)
STATS_SECT_END;
 
STATS_NAME_START(smbus)
STATS_NAME(smbus, bytes_read)
STATS_NAME(smbus, bytes_written)
STATS_NAME(smbus, command_count)
STATS_NAME_END(smbus);
 
struct smbus_device_state {
        struct device_state devstate;
        struct stats_smbus stats;
};

#define Z_SMBUS_DEVICE_STATE_DEFINE(node_id, dev_name)                  \
        static struct smbus_device_state Z_DEVICE_STATE_NAME(dev_name)  \
        __attribute__((__section__(".z_devstate")));

#define Z_SMBUS_INIT_FN(dev_name, init_fn)                              \
        static inline int                                               \
                UTIL_CAT(dev_name, _init)(const struct device *dev)     \
        {                                                               \
                struct smbus_device_state *state =                      \
                        CONTAINER_OF(dev->state,                        \
                                     struct smbus_device_state,         \
                                     devstate);                         \
                stats_init(&state->stats.s_hdr, STATS_SIZE_32, 4,       \
                           STATS_NAME_INIT_PARMS(smbus));               \
                stats_register(dev->name, &(state->stats.s_hdr));       \
                return init_fn(dev);                                    \
        }


static inline void smbus_xfer_stats(const struct device *dev, uint8_t sent,
                                    uint8_t recv)
{
        struct smbus_device_state *state =
                CONTAINER_OF(dev->state, struct smbus_device_state, devstate);
 
        STATS_INC(state->stats, command_count);
        STATS_INCN(state->stats, bytes_read, recv);
        STATS_INCN(state->stats, bytes_written, sent);
}

#define SMBUS_DEVICE_DT_DEFINE(node_id, init_fn, pm_device,             \
                               data_ptr, cfg_ptr, level, prio,          \
                               api_ptr, ...)                            \
        Z_SMBUS_DEVICE_STATE_DEFINE(node_id,                            \
                                    Z_DEVICE_DT_DEV_NAME(node_id));     \
        Z_SMBUS_INIT_FN(Z_DEVICE_DT_DEV_NAME(node_id), init_fn)         \
        Z_DEVICE_DEFINE(node_id, Z_DEVICE_DT_DEV_NAME(node_id),         \
                        DEVICE_DT_NAME(node_id),                        \
                        &UTIL_CAT(Z_DEVICE_DT_DEV_NAME(node_id), _init),\
                        NULL, Z_DEVICE_DT_FLAGS(node_id), pm_device,    \
                        data_ptr, cfg_ptr, level, prio,                 \
                        api_ptr,                                        \
                        &(Z_DEVICE_STATE_NAME(Z_DEVICE_DT_DEV_NAME      \
                                              (node_id)).devstate),     \
                        __VA_ARGS__)
 
#else /* CONFIG_SMBUS_STATS */
 
static inline void smbus_xfer_stats(const struct device *dev, uint8_t sent,
                                    uint8_t recv)
{
        ARG_UNUSED(dev);
        ARG_UNUSED(sent);
        ARG_UNUSED(recv);
}
 
#define SMBUS_DEVICE_DT_DEFINE(node_id, init_fn, pm_device,             \
                             data_ptr, cfg_ptr, level, prio,            \
                             api_ptr, ...)                              \
        DEVICE_DT_DEFINE(node_id, &init_fn, pm_device,                  \
                             data_ptr, cfg_ptr, level, prio,            \
                             api_ptr, __VA_ARGS__)
 
#endif /* CONFIG_SMBUS_STATS */

#define SMBUS_DEVICE_DT_INST_DEFINE(inst, ...)          \
        SMBUS_DEVICE_DT_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)

__syscall int smbus_configure(const struct device *dev, uint32_t dev_config);
 
static inline int z_impl_smbus_configure(const struct device *dev,
                                         uint32_t dev_config)
{
        return DEVICE_API_GET(smbus, dev)->configure(dev, dev_config);
}

__syscall int smbus_get_config(const struct device *dev, uint32_t *dev_config);
 
static inline int z_impl_smbus_get_config(const struct device *dev,
                                          uint32_t *dev_config)
{
        const struct smbus_driver_api *api = DEVICE_API_GET(smbus, dev);
 
        if (api->get_config == NULL) {
                return -ENOSYS;
        }
 
        return api->get_config(dev, dev_config);
}

static inline int smbus_smbalert_set_cb(const struct device *dev,
                                        struct smbus_callback *cb)
{
        const struct smbus_driver_api *api = DEVICE_API_GET(smbus, dev);
 
        if (api->smbus_smbalert_set_cb == NULL) {
                return -ENOSYS;
        }
 
        return api->smbus_smbalert_set_cb(dev, cb);
}

static inline int smbus_smbalert_remove_cb(const struct device *dev,
                                           struct smbus_callback *cb)
{
        const struct smbus_driver_api *api = DEVICE_API_GET(smbus, dev);
 
        if (api->smbus_smbalert_remove_cb == NULL) {
                return -ENOSYS;
        }
 
        return api->smbus_smbalert_remove_cb(dev, cb);
}

static inline int smbus_host_notify_set_cb(const struct device *dev,
                                           struct smbus_callback *cb)
{
        const struct smbus_driver_api *api = DEVICE_API_GET(smbus, dev);
 
        if (api->smbus_host_notify_set_cb == NULL) {
                return -ENOSYS;
        }
 
        return api->smbus_host_notify_set_cb(dev, cb);
}

static inline int smbus_host_notify_remove_cb(const struct device *dev,
                                              struct smbus_callback *cb)
{
        const struct smbus_driver_api *api = DEVICE_API_GET(smbus, dev);
 
        if (api->smbus_host_notify_remove_cb == NULL) {
                return -ENOSYS;
        }
 
        return api->smbus_host_notify_remove_cb(dev, cb);
}

__syscall int smbus_quick(const struct device *dev, uint16_t addr,
                          enum smbus_direction direction);
 
static inline int z_impl_smbus_quick(const struct device *dev, uint16_t addr,
                                     enum smbus_direction direction)
{
        const struct smbus_driver_api *api = DEVICE_API_GET(smbus, dev);
 
        if (api->smbus_quick == NULL) {
                return -ENOSYS;
        }
 
        if (direction != SMBUS_MSG_READ && direction != SMBUS_MSG_WRITE) {
                return -EINVAL;
        }
 
        return  api->smbus_quick(dev, addr, direction);
}

__syscall int smbus_byte_write(const struct device *dev, uint16_t addr,
                               uint8_t byte);
 
static inline int z_impl_smbus_byte_write(const struct device *dev,
                                          uint16_t addr, uint8_t byte)
{
        const struct smbus_driver_api *api = DEVICE_API_GET(smbus, dev);
 
        if (api->smbus_byte_write == NULL) {
                return -ENOSYS;
        }
 
        return  api->smbus_byte_write(dev, addr, byte);
}

__syscall int smbus_byte_read(const struct device *dev, uint16_t addr,
                              uint8_t *byte);
 
static inline int z_impl_smbus_byte_read(const struct device *dev,
                                         uint16_t addr, uint8_t *byte)
{
        const struct smbus_driver_api *api = DEVICE_API_GET(smbus, dev);
 
        if (api->smbus_byte_read == NULL) {
                return -ENOSYS;
        }
 
        return  api->smbus_byte_read(dev, addr, byte);
}

__syscall int smbus_byte_data_write(const struct device *dev, uint16_t addr,
                                    uint8_t cmd, uint8_t byte);
 
static inline int z_impl_smbus_byte_data_write(const struct device *dev,
                                               uint16_t addr, uint8_t cmd,
                                               uint8_t byte)
{
        const struct smbus_driver_api *api = DEVICE_API_GET(smbus, dev);
 
        if (api->smbus_byte_data_write == NULL) {
                return -ENOSYS;
        }
 
        return  api->smbus_byte_data_write(dev, addr, cmd, byte);
}

__syscall int smbus_byte_data_read(const struct device *dev, uint16_t addr,
                                   uint8_t cmd, uint8_t *byte);
 
static inline int z_impl_smbus_byte_data_read(const struct device *dev,
                                              uint16_t addr, uint8_t cmd,
                                              uint8_t *byte)
{
        const struct smbus_driver_api *api = DEVICE_API_GET(smbus, dev);
 
        if (api->smbus_byte_data_read == NULL) {
                return -ENOSYS;
        }
 
        return  api->smbus_byte_data_read(dev, addr, cmd, byte);
}

__syscall int smbus_word_data_write(const struct device *dev, uint16_t addr,
                                    uint8_t cmd, uint16_t word);
 
static inline int z_impl_smbus_word_data_write(const struct device *dev,
                                               uint16_t addr, uint8_t cmd,
                                               uint16_t word)
{
        const struct smbus_driver_api *api = DEVICE_API_GET(smbus, dev);
 
        if (api->smbus_word_data_write == NULL) {
                return -ENOSYS;
        }
 
        return  api->smbus_word_data_write(dev, addr, cmd, word);
}

__syscall int smbus_word_data_read(const struct device *dev, uint16_t addr,
                                   uint8_t cmd, uint16_t *word);
 
static inline int z_impl_smbus_word_data_read(const struct device *dev,
                                              uint16_t addr, uint8_t cmd,
                                              uint16_t *word)
{
        const struct smbus_driver_api *api = DEVICE_API_GET(smbus, dev);
 
        if (api->smbus_word_data_read == NULL) {
                return -ENOSYS;
        }
 
        return  api->smbus_word_data_read(dev, addr, cmd, word);
}

__syscall int smbus_pcall(const struct device *dev, uint16_t addr,
                          uint8_t cmd, uint16_t send_word, uint16_t *recv_word);
 
static inline int z_impl_smbus_pcall(const struct device *dev,
                                     uint16_t addr, uint8_t cmd,
                                     uint16_t send_word, uint16_t *recv_word)
{
        const struct smbus_driver_api *api = DEVICE_API_GET(smbus, dev);
 
        if (api->smbus_pcall == NULL) {
                return -ENOSYS;
        }
 
        return  api->smbus_pcall(dev, addr, cmd, send_word, recv_word);
}

__syscall int smbus_block_write(const struct device *dev, uint16_t addr,
                                uint8_t cmd, uint8_t count, uint8_t *buf);
 
static inline int z_impl_smbus_block_write(const struct device *dev,
                                           uint16_t addr, uint8_t cmd,
                                           uint8_t count, uint8_t *buf)
{
        const struct smbus_driver_api *api = DEVICE_API_GET(smbus, dev);
 
        if (api->smbus_block_write == NULL) {
                return -ENOSYS;
        }
 
        if (count < 1 || count > SMBUS_BLOCK_BYTES_MAX) {
                return -EINVAL;
        }
 
        return  api->smbus_block_write(dev, addr, cmd, count, buf);
}

__syscall int smbus_block_read(const struct device *dev, uint16_t addr,
                               uint8_t cmd, uint8_t *count, uint8_t *buf);
 
static inline int z_impl_smbus_block_read(const struct device *dev,
                                          uint16_t addr, uint8_t cmd,
                                          uint8_t *count, uint8_t *buf)
{
        const struct smbus_driver_api *api = DEVICE_API_GET(smbus, dev);
 
        if (api->smbus_block_read == NULL) {
                return -ENOSYS;
        }
 
        return  api->smbus_block_read(dev, addr, cmd, count, buf);
}

__syscall int smbus_block_pcall(const struct device *dev,
                                uint16_t addr, uint8_t cmd,
                                uint8_t snd_count, uint8_t *snd_buf,
                                uint8_t *rcv_count, uint8_t *rcv_buf);
 
static inline int z_impl_smbus_block_pcall(const struct device *dev,
                                           uint16_t addr, uint8_t cmd,
                                           uint8_t snd_count, uint8_t *snd_buf,
                                           uint8_t *rcv_count, uint8_t *rcv_buf)
{
        const struct smbus_driver_api *api = DEVICE_API_GET(smbus, dev);
 
        if (api->smbus_block_pcall == NULL) {
                return -ENOSYS;
        }
 
        return  api->smbus_block_pcall(dev, addr, cmd, snd_count, snd_buf,
                                       rcv_count, rcv_buf);
}
 
#ifdef __cplusplus
}
#endif

 
#include <zephyr/syscalls/smbus.h>
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_SMBUS_H_ */