target_device.h

Go to the documentation of this file.

/*
 * Copyright 2022 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_DRIVERS_I3C_TARGET_DEVICE_H_
#define ZEPHYR_INCLUDE_DRIVERS_I3C_TARGET_DEVICE_H_
 
#include <errno.h>
#include <stddef.h>
#include <stdint.h>
 
#include <zephyr/device.h>
#include <zephyr/sys/slist.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct i3c_driver_api;
 
struct i3c_config_target {
        bool enabled;
 
        uint8_t dynamic_addr;
 
        uint8_t static_addr;
 
        uint64_t pid;
 
        bool pid_random;
 
        uint8_t bcr;
 
        uint8_t dcr;
 
        uint16_t max_read_len;
 
        uint16_t max_write_len;
 
        uint8_t supported_hdr;
};
struct i3c_config_target {…};
 
struct i3c_target_config {
        sys_snode_t node;
 
        uint8_t flags;
 
        uint8_t address;
 
        const struct i3c_target_callbacks *callbacks;
};
struct i3c_target_config {…};
 
struct i3c_target_callbacks {
        int (*write_requested_cb)(struct i3c_target_config *config);
 
        int (*write_received_cb)(struct i3c_target_config *config,
                                 uint8_t val);
 
        int (*read_requested_cb)(struct i3c_target_config *config,
                                 uint8_t *val);
 
        int (*read_processed_cb)(struct i3c_target_config *config,
                                 uint8_t *val);
 
#ifdef CONFIG_I3C_TARGET_BUFFER_MODE
        void (*buf_write_received_cb)(struct i3c_target_config *config, uint8_t *ptr, uint32_t len);
 
        int (*buf_read_requested_cb)(struct i3c_target_config *config, uint8_t **ptr, uint32_t *len,
                                     uint8_t *hdr_mode);
#endif
        int (*stop_cb)(struct i3c_target_config *config);
 
        int (*controller_handoff_cb)(struct i3c_target_config *config);
};
struct i3c_target_callbacks {…};
 
__subsystem struct i3c_target_driver_api {
        int (*driver_register)(const struct device *dev);
        int (*driver_unregister)(const struct device *dev);
};
__subsystem struct i3c_target_driver_api {…};
 
static inline int i3c_target_controller_handoff(const struct device *dev,
                                      bool accept)
{
        const struct i3c_driver_api *api =
                (const struct i3c_driver_api *)dev->api;
 
        if (api->target_controller_handoff == NULL) {
                return -ENOSYS;
        }
 
        return api->target_controller_handoff(dev, accept);
}
static inline int i3c_target_controller_handoff(const struct device *dev, {…}
 
static inline int i3c_target_tx_write(const struct device *dev,
                                      uint8_t *buf, uint16_t len, uint8_t hdr_mode)
{
        const struct i3c_driver_api *api =
                (const struct i3c_driver_api *)dev->api;
 
        if (api->target_tx_write == NULL) {
                return -ENOSYS;
        }
 
        return api->target_tx_write(dev, buf, len, hdr_mode);
}
static inline int i3c_target_tx_write(const struct device *dev, {…}
 
static inline int i3c_target_register(const struct device *dev,
                                      struct i3c_target_config *cfg)
{
        const struct i3c_driver_api *api =
                (const struct i3c_driver_api *)dev->api;
 
        if (api->target_register == NULL) {
                return -ENOSYS;
        }
 
        return api->target_register(dev, cfg);
}
static inline int i3c_target_register(const struct device *dev, {…}
 
static inline int i3c_target_unregister(const struct device *dev,
                                        struct i3c_target_config *cfg)
{
        const struct i3c_driver_api *api =
                (const struct i3c_driver_api *)dev->api;
 
        if (api->target_unregister == NULL) {
                return -ENOSYS;
        }
 
        return api->target_unregister(dev, cfg);
}
static inline int i3c_target_unregister(const struct device *dev, {…}
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_I3C_TARGET_DEVICE_H_ */