From acc9abe913b9c7d45e77117130c660d8cdfb15c5 Mon Sep 17 00:00:00 2001 From: Divya Sharma Date: Mon, 23 May 2022 13:21:51 -0700 Subject: [PATCH] include: uapi: Add snapshot of spcom headers This snapshot is taken from msm-5.15 commit ac48c2a9d47d933 ("soc: qcom: add spcom and spss_utils drivers snapshot"). Change-Id: Ic20d23e422d5e5f4e67cc06f2c9089088cfcdac3 Signed-off-by: Divya Sharma Signed-off-by: Bruce Levy --- include/uapi/linux/spcom.h | 338 ++++++++++++++++++++++++++++++++ include/uapi/linux/spss_utils.h | 108 ++++++++++ 2 files changed, 446 insertions(+) create mode 100644 include/uapi/linux/spcom.h create mode 100644 include/uapi/linux/spss_utils.h diff --git a/include/uapi/linux/spcom.h b/include/uapi/linux/spcom.h new file mode 100644 index 000000000000..5ca0d127ede3 --- /dev/null +++ b/include/uapi/linux/spcom.h @@ -0,0 +1,338 @@ +/* SPDX-License-Identifier: GPL-2.0-only WITH Linux-syscall-note */ +/* + * Copyright (c) 2015-2021, The Linux Foundation. All rights reserved. + * Copyright (c) 2021 Qualcomm Innovation Center, Inc. All rights reserved. + */ + +#ifndef _UAPI_SPCOM_H_ +#define _UAPI_SPCOM_H_ + +#include /* __u32, bool */ +#ifndef BIT + #define BIT(x) (1 << x) +#endif + +#ifndef PAGE_SIZE + #define PAGE_SIZE 4096 +#endif + +/** + * @brief - Secure Processor Communication interface to user space spcomlib. + * + * Sending data and control commands by write() file operation. + * Receiving data by read() file operation. + * Getting the next request size by read() file operation, + * with special size SPCOM_GET_NEXT_REQUEST_SIZE. + */ + +/* + * Maximum number of channel between Secure Processor and HLOS. + * including predefined channels, like "sp_kernel". + */ +#define SPCOM_MAX_CHANNELS 0x20 + +/* Maximum size (including null) for channel names */ +#define SPCOM_CHANNEL_NAME_SIZE 32 +/* + * file read(fd, buf, size) with this size, + * hints the kernel that user space wants to read the next-req-size. + * This size is bigger than both SPCOM_MAX_REQUEST_SIZE and + * SPCOM_MAX_RESPONSE_SIZE , so it is not a valid data size. + */ +#define SPCOM_GET_NEXT_REQUEST_SIZE (PAGE_SIZE-1) + +/* Command Id between spcomlib and spcom driver, on write() */ +enum spcom_cmd_id { + SPCOM_CMD_LOAD_APP = 0x4C4F4144, /* "LOAD" = 0x4C4F4144 */ + SPCOM_CMD_RESET_SP = 0x52455354, /* "REST" = 0x52455354 */ + SPCOM_CMD_SEND = 0x53454E44, /* "SEND" = 0x53454E44 */ + SPCOM_CMD_SEND_MODIFIED = 0x534E444D, /* "SNDM" = 0x534E444D */ + SPCOM_CMD_LOCK_ION_BUF = 0x4C4F434B, /* "LOCK" = 0x4C4F434B */ + SPCOM_CMD_UNLOCK_ION_BUF = 0x554C434B, /* "ULCK" = 0x4C4F434B */ + SPCOM_CMD_FSSR = 0x46535352, /* "FSSR" = 0x46535352 */ + SPCOM_CMD_CREATE_CHANNEL = 0x43524554, /* "CRET" = 0x43524554 */ + +#define SPCOM_CMD_ENABLE_SSR \ + SPCOM_CMD_ENABLE_SSR + SPCOM_CMD_ENABLE_SSR = 0x45535352, /* "ESSR" =0x45535352*/ + +#define SPCOM_CMD_RESTART_SP \ + SPCOM_CMD_RESTART_SP + SPCOM_CMD_RESTART_SP = 0x52535452, /* "RSTR" = 0x52535452 */ +}; + +/* + * @note: Event types that are always implicitly polled: + * POLLERR=0x08 | POLLHUP=0x10 | POLLNVAL=0x20 + * so bits 3,4,5 can't be used + */ +enum spcom_poll_events { + SPCOM_POLL_LINK_STATE = BIT(1), + SPCOM_POLL_CH_CONNECT = BIT(2), + SPCOM_POLL_READY_FLAG = BIT(14), /* output */ + SPCOM_POLL_WAIT_FLAG = BIT(15), /* if set , wait for the event */ +}; + +/* Common Command structure between User Space and spcom driver, on write() */ +struct spcom_user_command { + enum spcom_cmd_id cmd_id; + __u32 arg; +} __packed; + +/* Command structure between User Space and spcom driver, on write() */ +struct spcom_send_command { + enum spcom_cmd_id cmd_id; + __u32 timeout_msec; + __u32 buf_size; + char buf[0]; /* Variable buffer size - must be last field */ +} __packed; + +/* Command structure between userspace spcomlib and spcom driver, on write() */ +struct spcom_user_create_channel_command { + enum spcom_cmd_id cmd_id; + char ch_name[SPCOM_CHANNEL_NAME_SIZE]; +#define SPCOM_IS_SHARABLE_SUPPORTED + _Bool is_sharable; +} __packed; + +/* Command structure between userspace spcomlib and spcom driver, on write() */ +#define SPCOM_USER_RESTART_SP_CMD +struct spcom_user_restart_sp_command { + enum spcom_cmd_id cmd_id; + __u32 arg; +#define SPCOM_IS_UPDATED_SUPPORETED + __u32 is_updated; +} __packed; + +/* maximum ION buf for send-modfied-command */ +#define SPCOM_MAX_ION_BUF 4 + +struct spcom_ion_info { + __s32 fd; /* ION buffer File Descriptor, set -1 for invalid fd */ + __u32 buf_offset; /* virtual address offset in request/response */ +}; + +/* Pass this FD to unlock all ION buffer for the specific channel */ +#define SPCOM_ION_FD_UNLOCK_ALL 0xFFFF + +struct spcom_ion_handle { + __s32 fd; /* File Descriptor associated with the buffer */ +}; + +struct spcom_rmb_error_info { + __u32 rmb_error; + __u32 padding; +} __packed; + +/* Command structure between User Space and spcom driver, on write() */ +struct spcom_user_send_modified_command { + enum spcom_cmd_id cmd_id; + struct spcom_ion_info ion_info[SPCOM_MAX_ION_BUF]; + __u32 timeout_msec; + __u32 buf_size; + char buf[0]; /* Variable buffer size - must be last field */ +} __packed; + +enum { + SPCOM_IONFD_CMD, + SPCOM_POLL_CMD, + SPCOM_GET_RMB_CMD, +}; + +enum spcom_poll_cmd_id { + SPCOM_LINK_STATE_REQ, + SPCOM_CH_CONN_STATE_REQ, +}; + +struct spcom_poll_param { + /* input parameters */ + _Bool wait; + enum spcom_poll_cmd_id cmd_id; + /* output parameter */ + int retval; +} __packed; + +#define SPCOM_IOCTL_MAGIC 'S' + +#define SPCOM_GET_IONFD _IOR(SPCOM_IOCTL_MAGIC, SPCOM_IONFD_CMD, \ + struct spcom_ion_handle) +#define SPCOM_SET_IONFD _IOW(SPCOM_IOCTL_MAGIC, SPCOM_IONFD_CMD, \ + struct spcom_ion_handle) +#define SPCOM_POLL_STATE _IOWR(SPCOM_IOCTL_MAGIC, SPCOM_POLL_CMD, \ + struct spcom_poll_param) +#define SPCOM_GET_RMB_ERROR _IOR(SPCOM_IOCTL_MAGIC, SPCOM_GET_RMB_CMD, \ + struct spcom_rmb_error_info) + +/* Maximum number of DMA buffer for sending modified message */ +#define SPCOM_MAX_DMA_BUF SPCOM_MAX_ION_BUF + +/* Pass this FD to unlock all DMA buffer for the specific channel */ +#define SPCOM_DMABUF_FD_UNLOCK_ALL 0xFFFF + +/* SPCOM events enum */ +enum spcom_event_id { + SPCOM_EVENT_LINK_STATE = 100 +}; + +/* SPCOM IOCTL commands */ +enum spcom_ioctl_enum { + SPCOM_IOCTL_STATE_POLL_CMD = 1000, + SPCOM_IOCTL_SHARED_CH_CREATE_CMD, + SPCOM_IOCTL_CH_REGISTER_CMD, + SPCOM_IOCTL_CH_UNREGISTER_CMD, + SPCOM_IOCTL_CH_IS_CONNECTED_CMD, + SPCOM_IOCTL_SEND_MSG_CMD, + SPCOM_IOCTL_SEND_MOD_MSG_CMD, + SPCOM_IOCTL_GET_NEXT_REQ_SZ_CMD, + SPCOM_IOCTL_GET_MSG_CMD, + SPCOM_IOCTL_DMABUF_LOCK_CMD, + SPCOM_IOCTL_DMABUF_UNLOCK_CMD, + SPCOM_IOCTL_RESTART_SPU_CMD, + SPCOM_IOCTL_ENABLE_SSR_CMD +}; + +/* SPCOM dma buffer info struct */ +struct spcom_dma_buf_info { + __s32 fd; /* DMA buffer File Descriptor */ + __u32 offset; /* Address offset in request or response buffer*/ +} __packed; + +/* SPCOM dma buffers info table */ +struct spcom_dma_buf_info_table { + struct spcom_dma_buf_info info[SPCOM_MAX_DMA_BUF]; +} __packed; + +/* SPCOM poll on event cmd struct */ +struct spcom_ioctl_poll_event { + __u32 event_id; /* spcom_ioctl_enum */ + __u32 wait; /* wait for event, zero for no wait, positive number otherwise */ + __s32 retval; /* updated by spcom driver */ + __u32 padding; /* 64-bit alignment, unused */ +} __packed; + +/* SPCOM register/unregister channel cmd struct */ +struct spcom_ioctl_ch { + char ch_name[SPCOM_CHANNEL_NAME_SIZE]; /* 4 * 64-bit */ +} __packed; + +/* SPCOM message cmd struct */ +struct spcom_ioctl_message { + char ch_name[SPCOM_CHANNEL_NAME_SIZE]; /* 4 * 64-bit */ + __u32 timeout_msec; + __u32 buffer_size; + char buffer[0]; /* Variable buffer size - must be last field */ +} __packed; + +/* SPCOM modified message cmd struct */ +struct spcom_ioctl_modified_message { + char ch_name[SPCOM_CHANNEL_NAME_SIZE]; /* 4 * 64-bit */ + __u32 timeout_msec; + __u32 buffer_size; + struct spcom_dma_buf_info info[SPCOM_MAX_DMA_BUF]; + char buffer[0]; /* Variable buffer size - must be last field */ +} __packed; + +/* SPCOM ioctl get next request size command struct */ +struct spcom_ioctl_next_request_size { + char ch_name[SPCOM_CHANNEL_NAME_SIZE]; /* 4 * 64-bit */ + __u32 size; + __u32 padding; /* 64-bit alignment, unused */ +} __packed; + +/* SPCOM ioctl buffer lock or unlock command struct */ +struct spcom_ioctl_dmabuf_lock { + char ch_name[SPCOM_CHANNEL_NAME_SIZE]; /* 4 * 64-bit */ + __s32 fd; + __u32 padding; /* 64-bit alignment, unused */ +} __packed; + +/* SPCOM ioctl command to handle event poll */ +#define SPCOM_IOCTL_STATE_POLL _IOWR( \ + SPCOM_IOCTL_MAGIC, \ + SPCOM_IOCTL_STATE_POLL_CMD, \ + struct spcom_ioctl_poll_event \ + ) + +/* SPCOM ioctl command to handle SPCOM shared channel create */ +#define SPCOM_IOCTL_SHARED_CH_CREATE _IOW( \ + SPCOM_IOCTL_MAGIC, \ + SPCOM_IOCTL_SHARED_CH_CREATE_CMD, \ + struct spcom_ioctl_ch \ + ) + +/* SPCOM ioctl command to handle SPCOM channel register */ +#define SPCOM_IOCTL_CH_REGISTER _IOW( \ + SPCOM_IOCTL_MAGIC, \ + SPCOM_IOCTL_CH_REGISTER_CMD, \ + struct spcom_ioctl_ch \ + ) + +/* IOCTL to handle SPCOM channel unregister */ +#define SPCOM_IOCTL_CH_UNREGISTER _IOW( \ + SPCOM_IOCTL_MAGIC, \ + SPCOM_IOCTL_CH_UNREGISTER_CMD, \ + struct spcom_ioctl_ch \ + ) + +/* IOCTL to check SPCOM channel connectivity with remote edge */ +#define SPCOM_IOCTL_CH_IS_CONNECTED _IOW( \ + SPCOM_IOCTL_MAGIC, \ + SPCOM_IOCTL_CH_IS_CONNECTED_CMD, \ + struct spcom_ioctl_ch \ + ) + +/* IOCTL to handle SPCOM send message */ +#define SPCOM_IOCTL_SEND_MSG _IOW( \ + SPCOM_IOCTL_MAGIC, \ + SPCOM_IOCTL_SEND_MSG_CMD, \ + struct spcom_ioctl_message \ + ) + +/* IOCTL to handle SPCOM send modified message */ +#define SPCOM_IOCTL_SEND_MOD_MSG _IOW( \ + SPCOM_IOCTL_MAGIC, \ + SPCOM_IOCTL_SEND_MOD_MSG_CMD, \ + struct spcom_ioctl_modified_message \ + ) + +/* IOCTL to handle SPCOM get next request message size */ +#define SPCOM_IOCTL_GET_NEXT_REQ_SZ _IOWR( \ + SPCOM_IOCTL_MAGIC, \ + SPCOM_IOCTL_GET_NEXT_REQ_SZ_CMD, \ + struct spcom_ioctl_next_request_size \ + ) + +/* IOCTL to handle SPCOM get request */ +#define SPCOM_IOCTL_GET_MSG _IOWR( \ + SPCOM_IOCTL_MAGIC, \ + SPCOM_IOCTL_GET_MSG_CMD, \ + struct spcom_ioctl_message \ + ) + +/* IOCTL to handle DMA buffer lock/unlock */ +#define SPCOM_IOCTL_DMABUF_LOCK _IOW( \ + SPCOM_IOCTL_MAGIC, \ + SPCOM_IOCTL_DMABUF_LOCK_CMD, \ + struct spcom_ioctl_dmabuf_lock \ + ) + +/* IOCTL to handle DMA buffer unlock */ +#define SPCOM_IOCTL_DMABUF_UNLOCK _IOW( \ + SPCOM_IOCTL_MAGIC, \ + SPCOM_IOCTL_DMABUF_UNLOCK_CMD, \ + struct spcom_ioctl_dmabuf_lock \ + ) + +/* IOCTL to handle SPU restart */ +#define SPCOM_IOCTL_RESTART_SPU _IO( \ + SPCOM_IOCTL_MAGIC, \ + SPCOM_IOCTL_RESTART_SPU_CMD \ + ) + +/* IOCTL to enable SSR */ +#define SPCOM_IOCTL_ENABLE_SSR _IO( \ + SPCOM_IOCTL_MAGIC, \ + SPCOM_IOCTL_ENABLE_SSR_CMD \ + ) + +#endif /* _UAPI_SPCOM_H_ */ diff --git a/include/uapi/linux/spss_utils.h b/include/uapi/linux/spss_utils.h new file mode 100644 index 000000000000..8c68935ace94 --- /dev/null +++ b/include/uapi/linux/spss_utils.h @@ -0,0 +1,108 @@ +/* SPDX-License-Identifier: GPL-2.0-only WITH Linux-syscall-note */ +/* + * Copyright (c) 2019-2020, The Linux Foundation. All rights reserved. + * Copyright (c) 2021 Qualcomm Innovation Center, Inc. All rights reserved. + */ + +#ifndef _UAPI_SPSS_UTILS_H_ +#define _UAPI_SPSS_UTILS_H_ + +#include /* __u32, _Bool */ +#include /* ioctl() */ + +/** + * @brief - Secure Processor Utilities interface to user space + * + * The kernel spss_utils driver interface to user space via IOCTL + * and SYSFS (device attributes). + */ + +#define SPSS_IOC_MAGIC 'S' + +/* ---------- set fw cmac --------------------------------- */ +#define OLD_NUM_SPU_UEFI_APPS 3 /* Obsolete */ + +#define CMAC_SIZE_IN_WORDS 4 + +/* Obsolete struct, keep for backward compatible */ +struct spss_ioc_set_fw_cmac { + __u32 cmac[CMAC_SIZE_IN_WORDS]; + __u32 apps_cmac[OLD_NUM_SPU_UEFI_APPS][CMAC_SIZE_IN_WORDS]; +} __packed; + +#define SPSS_IOC_SET_FW_CMAC \ + _IOWR(SPSS_IOC_MAGIC, 1, struct spss_ioc_set_fw_cmac) + +/* ---------- wait for event ------------------------------ */ +enum spss_event_id { + /* signaled from user */ + SPSS_EVENT_ID_PIL_CALLED = 0, + SPSS_EVENT_ID_NVM_READY = 1, + SPSS_EVENT_ID_SPU_READY = 2, + SPSS_NUM_USER_EVENTS, + + /* signaled from kernel */ + SPSS_EVENT_ID_SPU_POWER_DOWN = 6, + SPSS_EVENT_ID_SPU_POWER_UP = 7, + SPSS_NUM_EVENTS, +}; + +enum spss_event_status { + EVENT_STATUS_SIGNALED = 0xAAAA, + EVENT_STATUS_NOT_SIGNALED = 0xFFFF, + EVENT_STATUS_TIMEOUT = 0xEEE1, + EVENT_STATUS_ABORTED = 0xEEE2, +}; + +struct spss_ioc_wait_for_event { + __u32 event_id; /* input */ + __u32 timeout_sec; /* input */ + __u32 status; /* output */ +} __packed; + +#define SPSS_IOC_WAIT_FOR_EVENT \ + _IOWR(SPSS_IOC_MAGIC, 2, struct spss_ioc_wait_for_event) + +/* ---------- signal event ------------------------------ */ +struct spss_ioc_signal_event { + __u32 event_id; /* input */ + __u32 status; /* output */ +} __packed; + +#define SPSS_IOC_SIGNAL_EVENT \ + _IOWR(SPSS_IOC_MAGIC, 3, struct spss_ioc_signal_event) + +/* ---------- is event signaled ------------------------------ */ +struct spss_ioc_is_signaled { + __u32 event_id; /* input */ + __u32 status; /* output */ +} __attribute__((packed)); + +#define SPSS_IOC_IS_EVENT_SIGNALED \ + _IOWR(SPSS_IOC_MAGIC, 4, struct spss_ioc_is_signaled) + +/* ---------- set ssr state ------------------------------ */ + +#define SPSS_IOC_SET_SSR_STATE \ + _IOWR(SPSS_IOC_MAGIC, 5, __u32) + +/* ---------- set fw and apps cmac --------------------------------- */ + +/* Asym , Crypt , Keym + 3rd party uefi apps */ +#define MAX_SPU_UEFI_APPS 8 + +/** use variable-size-array for future growth */ +struct spss_ioc_set_fw_and_apps_cmac { + __u64 cmac_buf_ptr; + /* + * expected cmac_buf_size is: + * (1+MAX_SPU_UEFI_APPS)*CMAC_SIZE_IN_WORDS*sizeof(uint32_t) + */ + __u32 cmac_buf_size; + __u32 num_of_cmacs; +} __attribute__((packed)); + +#define SPSS_IOC_SET_FW_AND_APPS_CMAC \ + _IOWR(SPSS_IOC_MAGIC, 6, struct spss_ioc_set_fw_and_apps_cmac) + +#endif /* _UAPI_SPSS_UTILS_H_ */