/* SPDX-License-Identifier: GPL-2.0 */ /* * System Control and Management Interface (SCMI) Message Protocol * driver common header file containing some definitions, structures * and function prototypes used in all the different SCMI protocols. * * Copyright (C) 2018-2022 ARM Ltd. */ #ifndef _SCMI_COMMON_H #define _SCMI_COMMON_H #include <linux/bitfield.h> #include <linux/completion.h> #include <linux/device.h> #include <linux/errno.h> #include <linux/kernel.h> #include <linux/hashtable.h> #include <linux/list.h> #include <linux/module.h> #include <linux/refcount.h> #include <linux/scmi_protocol.h> #include <linux/spinlock.h> #include <linux/types.h> #include <asm/unaligned.h> #include "protocols.h" #include "notify.h" #define SCMI_MAX_CHANNELS … #define SCMI_MAX_RESPONSE_TIMEOUT … enum scmi_error_codes { … }; static const int scmi_linux_errmap[] = …; static inline int scmi_to_linux_errno(int errno) { … } #define MSG_ID_MASK … #define MSG_XTRACT_ID(hdr) … #define MSG_TYPE_MASK … #define MSG_XTRACT_TYPE(hdr) … #define MSG_TYPE_COMMAND … #define MSG_TYPE_DELAYED_RESP … #define MSG_TYPE_NOTIFICATION … #define MSG_PROTOCOL_ID_MASK … #define MSG_XTRACT_PROT_ID(hdr) … #define MSG_TOKEN_ID_MASK … #define MSG_XTRACT_TOKEN(hdr) … #define MSG_TOKEN_MAX … /* * Size of @pending_xfers hashtable included in @scmi_xfers_info; ideally, in * order to minimize space and collisions, this should equal max_msg, i.e. the * maximum number of in-flight messages on a specific platform, but such value * is only available at runtime while kernel hashtables are statically sized: * pick instead as a fixed static size the maximum number of entries that can * fit the whole table into one 4k page. */ #define SCMI_PENDING_XFERS_HT_ORDER_SZ … /** * pack_scmi_header() - packs and returns 32-bit header * * @hdr: pointer to header containing all the information on message id, * protocol id, sequence id and type. * * Return: 32-bit packed message header to be sent to the platform. */ static inline u32 pack_scmi_header(struct scmi_msg_hdr *hdr) { … } /** * unpack_scmi_header() - unpacks and records message and protocol id * * @msg_hdr: 32-bit packed message header sent from the platform * @hdr: pointer to header to fetch message and protocol id. */ static inline void unpack_scmi_header(u32 msg_hdr, struct scmi_msg_hdr *hdr) { … } /* * An helper macro to lookup an xfer from the @pending_xfers hashtable * using the message sequence number token as a key. */ #define XFER_FIND(__ht, __k) … struct scmi_revision_info * scmi_revision_area_get(const struct scmi_protocol_handle *ph); void scmi_setup_protocol_implemented(const struct scmi_protocol_handle *ph, u8 *prot_imp); extern const struct bus_type scmi_bus_type; #define SCMI_BUS_NOTIFY_DEVICE_REQUEST … #define SCMI_BUS_NOTIFY_DEVICE_UNREQUEST … extern struct blocking_notifier_head scmi_requested_devices_nh; struct scmi_device *scmi_device_create(struct device_node *np, struct device *parent, int protocol, const char *name); void scmi_device_destroy(struct device *parent, int protocol, const char *name); int scmi_protocol_acquire(const struct scmi_handle *handle, u8 protocol_id); void scmi_protocol_release(const struct scmi_handle *handle, u8 protocol_id); /* SCMI Transport */ /** * struct scmi_chan_info - Structure representing a SCMI channel information * * @id: An identifier for this channel: this matches the protocol number * used to initialize this channel * @dev: Reference to device in the SCMI hierarchy corresponding to this * channel * @rx_timeout_ms: The configured RX timeout in milliseconds. * @handle: Pointer to SCMI entity handle * @no_completion_irq: Flag to indicate that this channel has no completion * interrupt mechanism for synchronous commands. * This can be dynamically set by transports at run-time * inside their provided .chan_setup(). * @transport_info: Transport layer related information */ struct scmi_chan_info { … }; /** * struct scmi_transport_ops - Structure representing a SCMI transport ops * * @link_supplier: Optional callback to add link to a supplier device * @chan_available: Callback to check if channel is available or not * @chan_setup: Callback to allocate and setup a channel * @chan_free: Callback to free a channel * @get_max_msg: Optional callback to provide max_msg dynamically * Returns the maximum number of messages for the channel type * (tx or rx) that can be pending simultaneously in the system * @send_message: Callback to send a message * @mark_txdone: Callback to mark tx as done * @fetch_response: Callback to fetch response * @fetch_notification: Callback to fetch notification * @clear_channel: Callback to clear a channel * @poll_done: Callback to poll transfer status */ struct scmi_transport_ops { … }; /** * struct scmi_desc - Description of SoC integration * * @transport_init: An optional function that a transport can provide to * initialize some transport-specific setup during SCMI core * initialization, so ahead of SCMI core probing. * @transport_exit: An optional function that a transport can provide to * de-initialize some transport-specific setup during SCMI core * de-initialization, so after SCMI core removal. * @ops: Pointer to the transport specific ops structure * @max_rx_timeout_ms: Timeout for communication with SoC (in Milliseconds) * @max_msg: Maximum number of messages for a channel type (tx or rx) that can * be pending simultaneously in the system. May be overridden by the * get_max_msg op. * @max_msg_size: Maximum size of data per message that can be handled. * @force_polling: Flag to force this whole transport to use SCMI core polling * mechanism instead of completion interrupts even if available. * @sync_cmds_completed_on_ret: Flag to indicate that the transport assures * synchronous-command messages are atomically * completed on .send_message: no need to poll * actively waiting for a response. * Used by core internally only when polling is * selected as a waiting for reply method: i.e. * if a completion irq was found use that anyway. * @atomic_enabled: Flag to indicate that this transport, which is assured not * to sleep anywhere on the TX path, can be used in atomic mode * when requested. */ struct scmi_desc { … }; static inline bool is_polling_required(struct scmi_chan_info *cinfo, const struct scmi_desc *desc) { … } static inline bool is_transport_polling_capable(const struct scmi_desc *desc) { … } static inline bool is_polling_enabled(struct scmi_chan_info *cinfo, const struct scmi_desc *desc) { … } void scmi_xfer_raw_put(const struct scmi_handle *handle, struct scmi_xfer *xfer); struct scmi_xfer *scmi_xfer_raw_get(const struct scmi_handle *handle); struct scmi_chan_info * scmi_xfer_raw_channel_get(const struct scmi_handle *handle, u8 protocol_id); int scmi_xfer_raw_inflight_register(const struct scmi_handle *handle, struct scmi_xfer *xfer); int scmi_xfer_raw_wait_for_message_response(struct scmi_chan_info *cinfo, struct scmi_xfer *xfer, unsigned int timeout_ms); #ifdef CONFIG_ARM_SCMI_TRANSPORT_MAILBOX extern const struct scmi_desc scmi_mailbox_desc; #endif #ifdef CONFIG_ARM_SCMI_TRANSPORT_SMC extern const struct scmi_desc scmi_smc_desc; #endif #ifdef CONFIG_ARM_SCMI_TRANSPORT_VIRTIO extern const struct scmi_desc scmi_virtio_desc; #endif #ifdef CONFIG_ARM_SCMI_TRANSPORT_OPTEE extern const struct scmi_desc scmi_optee_desc; #endif void scmi_rx_callback(struct scmi_chan_info *cinfo, u32 msg_hdr, void *priv); enum scmi_bad_msg { … }; void scmi_bad_message_trace(struct scmi_chan_info *cinfo, u32 msg_hdr, enum scmi_bad_msg err); /* shmem related declarations */ struct scmi_shared_mem; void shmem_tx_prepare(struct scmi_shared_mem __iomem *shmem, struct scmi_xfer *xfer, struct scmi_chan_info *cinfo); u32 shmem_read_header(struct scmi_shared_mem __iomem *shmem); void shmem_fetch_response(struct scmi_shared_mem __iomem *shmem, struct scmi_xfer *xfer); void shmem_fetch_notification(struct scmi_shared_mem __iomem *shmem, size_t max_len, struct scmi_xfer *xfer); void shmem_clear_channel(struct scmi_shared_mem __iomem *shmem); bool shmem_poll_done(struct scmi_shared_mem __iomem *shmem, struct scmi_xfer *xfer); bool shmem_channel_free(struct scmi_shared_mem __iomem *shmem); bool shmem_channel_intr_enabled(struct scmi_shared_mem __iomem *shmem); /* declarations for message passing transports */ struct scmi_msg_payld; /* Maximum overhead of message w.r.t. struct scmi_desc.max_msg_size */ #define SCMI_MSG_MAX_PROT_OVERHEAD … size_t msg_response_size(struct scmi_xfer *xfer); size_t msg_command_size(struct scmi_xfer *xfer); void msg_tx_prepare(struct scmi_msg_payld *msg, struct scmi_xfer *xfer); u32 msg_read_header(struct scmi_msg_payld *msg); void msg_fetch_response(struct scmi_msg_payld *msg, size_t len, struct scmi_xfer *xfer); void msg_fetch_notification(struct scmi_msg_payld *msg, size_t len, size_t max_len, struct scmi_xfer *xfer); void scmi_notification_instance_data_set(const struct scmi_handle *handle, void *priv); void *scmi_notification_instance_data_get(const struct scmi_handle *handle); #endif /* _SCMI_COMMON_H */
Codebase Browser
linux