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_target_config {
        sys_snode_t node;

        uint8_t flags;

        uint8_t address;

        const struct i3c_target_callbacks *callbacks;
};
 
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);
};
 
__subsystem struct i3c_target_driver_api {
        int (*driver_register)(const struct device *dev);
        int (*driver_unregister)(const struct device *dev);
};

static inline int i3c_target_controller_handoff(const struct device *dev,
                                      bool accept)
{
        const struct i3c_driver_api *api = DEVICE_API_GET(i3c, dev);
 
        if (api->target_controller_handoff == NULL) {
                return -ENOSYS;
        }
 
        return api->target_controller_handoff(dev, accept);
}

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 = DEVICE_API_GET(i3c, dev);
 
        if (api->target_tx_write == NULL) {
                return -ENOSYS;
        }
 
        return api->target_tx_write(dev, buf, len, hdr_mode);
}

static inline int i3c_target_register(const struct device *dev,
                                      struct i3c_target_config *cfg)
{
        const struct i3c_driver_api *api = DEVICE_API_GET(i3c, dev);
 
        if (api->target_register == NULL) {
                return -ENOSYS;
        }
 
        return api->target_register(dev, cfg);
}

static inline int i3c_target_unregister(const struct device *dev,
                                        struct i3c_target_config *cfg)
{
        const struct i3c_driver_api *api = DEVICE_API_GET(i3c, dev);
 
        if (api->target_unregister == NULL) {
                return -ENOSYS;
        }
 
        return api->target_unregister(dev, cfg);
}
 
#ifdef __cplusplus
}
#endif

 
#endif /* ZEPHYR_INCLUDE_DRIVERS_I3C_TARGET_DEVICE_H_ */