util.h

Go to the documentation of this file.

/*
 * Copyright 2024 NXP
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef _INCLUDE_ZEPHYR_DRIVERS_FIRMWARE_SCMI_UTIL_H_
#define _INCLUDE_ZEPHYR_DRIVERS_FIRMWARE_SCMI_UTIL_H_


#define SCMI_PROTOCOL_NAME(proto) CONCAT(scmi_protocol_, proto)
 
#ifdef CONFIG_ARM_SCMI_MAILBOX_TRANSPORT
#define DT_SCMI_TRANSPORT_COMPATIBLE arm_scmi
#elif CONFIG_ARM_SCMI_SMC_TRANSPORT
#define DT_SCMI_TRANSPORT_COMPATIBLE arm_scmi_smc
#else
#error "Transport needs to define COMPATIBLE macro"
#endif

#define DT_SCMI_TRANSPORT_PROTO_IS_BASE(node_id) \
        DT_NODE_HAS_COMPAT(node_id, DT_SCMI_TRANSPORT_COMPATIBLE)

#define DT_SCMI_TRANSPORT_PROTOCOL_ID(node_id)                                  \
        COND_CODE_1(DT_SCMI_TRANSPORT_PROTO_IS_BASE(node_id),                   \
                    (SCMI_PROTOCOL_BASE),                                       \
                    (DT_REG_ADDR_RAW(node_id)))
 
#ifdef CONFIG_ARM_SCMI_TRANSPORT_HAS_STATIC_CHANNELS
 
#ifdef CONFIG_ARM_SCMI_MAILBOX_TRANSPORT
#define DT_SCMI_TRANSPORT_PROTO_HAS_CHAN(node_id, idx)\
        DT_PROP_HAS_IDX(node_id, shmem, idx)
#elif CONFIG_ARM_SCMI_SMC_TRANSPORT
#define DT_SCMI_TRANSPORT_PROTO_HAS_CHAN(node_id, idx) 0
#else
#error "Transport with static channels needs to define HAS_CHAN macro"
#endif

/* builds the symbol name of the static channel for a (proto, idx) pair */
#define SCMI_TRANSPORT_CHAN_NAME(proto, idx) CONCAT(scmi_channel_, proto, _, idx)

 
/*
 * Declare a TX SCMI channel.
 *
 * Given a node_id for a protocol, this macro declares the SCMI
 * TX channel statically bound to said protocol via the "extern"
 * qualifier. This is useful when the transport layer driver
 * supports static channels since all channel structures are
 * defined inside the transport layer driver. Internal helper used
 * by DT_SCMI_TRANSPORT_CHANNELS_DECLARE(); not meant to be used directly.
 */
#define DT_SCMI_TRANSPORT_TX_CHAN_DECLARE(node_id)                              \
        COND_CODE_1(DT_SCMI_TRANSPORT_PROTO_HAS_CHAN(node_id, 0),               \
                    (extern struct scmi_channel                                 \
                     SCMI_TRANSPORT_CHAN_NAME(                                  \
                        DT_SCMI_TRANSPORT_PROTOCOL_ID(node_id), 0);),           \
                    (extern struct scmi_channel                                 \
                     SCMI_TRANSPORT_CHAN_NAME(SCMI_PROTOCOL_BASE, 0);))         \


#define DT_SCMI_TRANSPORT_CHANNELS_DECLARE(node_id)                             \
        DT_SCMI_TRANSPORT_TX_CHAN_DECLARE(node_id)                              \

#define DT_INST_SCMI_TRANSPORT_CHANNELS_DECLARE(inst)                           \
        DT_SCMI_TRANSPORT_CHANNELS_DECLARE(DT_INST(inst, DT_DRV_COMPAT))

#define DT_SCMI_TRANSPORT_TX_CHAN(node_id)                                      \
        COND_CODE_1(DT_SCMI_TRANSPORT_PROTO_HAS_CHAN(node_id, 0),               \
                    (&SCMI_TRANSPORT_CHAN_NAME(                                 \
                        DT_SCMI_TRANSPORT_PROTOCOL_ID(node_id), 0)),            \
                    (&SCMI_TRANSPORT_CHAN_NAME(SCMI_PROTOCOL_BASE, 0)))

#define DT_SCMI_TRANSPORT_CHAN_DEFINE(node_id, idx, proto, pdata)               \
        struct scmi_channel SCMI_TRANSPORT_CHAN_NAME(proto, idx) =              \
        {                                                                       \
                .data = pdata,                                                  \
        }

 
/*
 * Define an SCMI protocol's data.
 *
 * Each SCMI protocol is identified by a struct scmi_protocol
 * placed in a linker section called scmi_protocol. Each protocol
 * driver is required to use this macro for "registration". Using
 * this macro directly is highly discouraged and users should opt
 * for macros such as DT_SCMI_PROTOCOL_DEFINE_NODEV() or
 * DT_SCMI_PROTOCOL_DEFINE(), which also takes care of the static
 * channel declaration (if applicable).
 *
 * node_id     - protocol node identifier
 * proto       - protocol ID in decimal format
 * pdata       - protocol private data
 * version_val - protocol version supported by the driver
 */
#define DT_SCMI_PROTOCOL_DATA_DEFINE(node_id, proto, pdata, version_val)        \
        STRUCT_SECTION_ITERABLE(scmi_protocol, SCMI_PROTOCOL_NAME(proto)) =     \
        {                                                                       \
                .id = proto,                                                    \
                .tx = DT_SCMI_TRANSPORT_TX_CHAN(node_id),                       \
                .data = pdata,                                                  \
                .version = version_val                                          \
        }
 
#else /* CONFIG_ARM_SCMI_TRANSPORT_HAS_STATIC_CHANNELS */

/* no-op variant used when the transport does not support static channels */
#define DT_SCMI_TRANSPORT_CHANNELS_DECLARE(node_id)
 
/* variant used when the transport does not support static channels */
#define DT_SCMI_PROTOCOL_DATA_DEFINE(node_id, proto, pdata)                     \
        STRUCT_SECTION_ITERABLE(scmi_protocol, SCMI_PROTOCOL_NAME(proto)) =     \
        {                                                                       \
                .id = proto,                                                    \
                .data = pdata,                                                  \
        }
 
#endif /* CONFIG_ARM_SCMI_TRANSPORT_HAS_STATIC_CHANNELS */

#define DT_INST_SCMI_TRANSPORT_DEFINE(inst, pm, data, config, level, prio, api) \
        DEVICE_DT_INST_DEFINE(inst, &scmi_core_transport_init,                  \
                              pm, data, config, level, prio, api)

#define DT_SCMI_PROTOCOL_DEFINE(node_id, init_fn, pm, data, config,             \
                                level, prio, api, version_val)                  \
        DT_SCMI_TRANSPORT_CHANNELS_DECLARE(node_id)                             \
        DT_SCMI_PROTOCOL_DATA_DEFINE(node_id,                                   \
                                     DT_SCMI_TRANSPORT_PROTOCOL_ID(node_id),    \
                                     data, version_val);                        \
        DEVICE_DT_DEFINE(node_id, init_fn, pm,                                  \
                         &SCMI_PROTOCOL_NAME(                                   \
                                DT_SCMI_TRANSPORT_PROTOCOL_ID(node_id)),        \
                         config, level, prio, api)

#define DT_INST_SCMI_PROTOCOL_DEFINE(inst, init_fn, pm, data, config,           \
                                     level, prio, api, version)                 \
        DT_SCMI_PROTOCOL_DEFINE(DT_INST(inst, DT_DRV_COMPAT), init_fn, pm,      \
                                data, config, level, prio, api, version)

#define DT_SCMI_PROTOCOL_DEFINE_NODEV(node_id, data, version)                   \
        DT_SCMI_TRANSPORT_CHANNELS_DECLARE(node_id)                             \
        DT_SCMI_PROTOCOL_DATA_DEFINE(node_id,                                   \
                                     DT_SCMI_TRANSPORT_PROTOCOL_ID(node_id),    \
                                     data, version)

#define SCMI_FIELD_MAKE(x, mask, shift)\
        (((uint32_t)(x) & (mask)) << (shift))

#define SCMI_PROTOCOL_BASE 16           
#define SCMI_PROTOCOL_POWER_DOMAIN 17   
#define SCMI_PROTOCOL_SYSTEM 18         
#define SCMI_PROTOCOL_PERF 19           
#define SCMI_PROTOCOL_CLOCK 20          
#define SCMI_PROTOCOL_SENSOR 21         
#define SCMI_PROTOCOL_RESET_DOMAIN 22   
#define SCMI_PROTOCOL_VOLTAGE_DOMAIN 23 
#define SCMI_PROTOCOL_PCAP_MONITOR 24   
#define SCMI_PROTOCOL_PINCTRL 25        

 
#endif /* _INCLUDE_ZEPHYR_DRIVERS_FIRMWARE_SCMI_UTIL_H_ */