1 /* SPDX-License-Identifier: GPL-2.0-only */
2 /*
3 * Most ISHTP provider device and ISHTP logic declarations
4 *
5 * Copyright (c) 2003-2016, Intel Corporation.
6 */
7
8 #ifndef _ISHTP_DEV_H_
9 #define _ISHTP_DEV_H_
10
11 #include <linux/types.h>
12 #include <linux/spinlock.h>
13 #include <linux/intel-ish-client-if.h>
14 #include "bus.h"
15 #include "hbm.h"
16
17 #define IPC_PAYLOAD_SIZE 128
18 #define ISHTP_RD_MSG_BUF_SIZE IPC_PAYLOAD_SIZE
19 #define IPC_FULL_MSG_SIZE 132
20
21 /* Number of messages to be held in ISR->BH FIFO */
22 #define RD_INT_FIFO_SIZE 64
23
24 /*
25 * Number of IPC messages to be held in Tx FIFO, to be sent by ISR -
26 * Tx complete interrupt or RX_COMPLETE handler
27 */
28 #define IPC_TX_FIFO_SIZE 512
29
30 /*
31 * Number of Maximum ISHTP Clients
32 */
33 #define ISHTP_CLIENTS_MAX 256
34
35 /*
36 * Number of File descriptors/handles
37 * that can be opened to the driver.
38 *
39 * Limit to 255: 256 Total Clients
40 * minus internal client for ISHTP Bus Messages
41 */
42 #define ISHTP_MAX_OPEN_HANDLE_COUNT (ISHTP_CLIENTS_MAX - 1)
43
44 /* Internal Clients Number */
45 #define ISHTP_HOST_CLIENT_ID_ANY (-1)
46 #define ISHTP_HBM_HOST_CLIENT_ID 0
47
48 #define MAX_DMA_DELAY 20
49
50 /* 300ms to get resume response */
51 #define WAIT_FOR_RESUME_ACK_MS 300
52
53 /* ISHTP device states */
54 enum ishtp_dev_state {
55 ISHTP_DEV_INITIALIZING = 0,
56 ISHTP_DEV_INIT_CLIENTS,
57 ISHTP_DEV_ENABLED,
58 ISHTP_DEV_RESETTING,
59 ISHTP_DEV_DISABLED,
60 ISHTP_DEV_POWER_DOWN,
61 ISHTP_DEV_POWER_UP
62 };
63
64 struct ishtp_cl;
65
66 /**
67 * struct ishtp_fw_client - representation of fw client
68 *
69 * @props - client properties
70 * @client_id - fw client id
71 */
72 struct ishtp_fw_client {
73 struct ishtp_client_properties props;
74 uint8_t client_id;
75 };
76
77 /*
78 * Control info for IPC messages ISHTP/IPC sending FIFO -
79 * list with inline data buffer
80 * This structure will be filled with parameters submitted
81 * by the caller glue layer
82 * 'buf' may be pointing to the external buffer or to 'inline_data'
83 * 'offset' will be initialized to 0 by submitting
84 *
85 * 'ipc_send_compl' is intended for use by clients that send fragmented
86 * messages. When a fragment is sent down to IPC msg regs,
87 * it will be called.
88 * If it has more fragments to send, it will do it. With last fragment
89 * it will send appropriate ISHTP "message-complete" flag.
90 * It will remove the outstanding message
91 * (mark outstanding buffer as available).
92 * If counting flow control is in work and there are more flow control
93 * credits, it can put the next client message queued in cl.
94 * structure for IPC processing.
95 *
96 */
97 struct wr_msg_ctl_info {
98 /* Will be called with 'ipc_send_compl_prm' as parameter */
99 void (*ipc_send_compl)(void *);
100
101 void *ipc_send_compl_prm;
102 size_t length;
103 struct list_head link;
104 unsigned char inline_data[IPC_FULL_MSG_SIZE];
105 };
106
107 /*
108 * The ISHTP layer talks to hardware IPC message using the following
109 * callbacks
110 */
111 struct ishtp_hw_ops {
112 int (*hw_reset)(struct ishtp_device *dev);
113 int (*ipc_reset)(struct ishtp_device *dev);
114 uint32_t (*ipc_get_header)(struct ishtp_device *dev, int length,
115 int busy);
116 int (*write)(struct ishtp_device *dev,
117 void (*ipc_send_compl)(void *), void *ipc_send_compl_prm,
118 unsigned char *msg, int length);
119 uint32_t (*ishtp_read_hdr)(const struct ishtp_device *dev);
120 int (*ishtp_read)(struct ishtp_device *dev, unsigned char *buffer,
121 unsigned long buffer_length);
122 uint32_t (*get_fw_status)(struct ishtp_device *dev);
123 void (*sync_fw_clock)(struct ishtp_device *dev);
124 bool (*dma_no_cache_snooping)(struct ishtp_device *dev);
125 };
126
127 /**
128 * struct ishtp_driver_data - Driver-specific data for ISHTP devices
129 *
130 * This structure holds driver-specific data that can be associated with each
131 * ISHTP device instance. It allows for the storage of data that is unique to
132 * a particular driver or hardware variant.
133 *
134 * @fw_generation: The generation name associated with a specific hardware
135 * variant of the Intel Integrated Sensor Hub (ISH). This allows
136 * the driver to load the correct firmware based on the device's
137 * hardware variant. For example, "lnlm" for the Lunar Lake-M
138 * platform. The generation name must not exceed 8 characters
139 * in length.
140 */
141 struct ishtp_driver_data {
142 char *fw_generation;
143 };
144
145 struct ish_version {
146 u16 major;
147 u16 minor;
148 u16 hotfix;
149 u16 build;
150 };
151
152 /**
153 * struct ishtp_device - ISHTP private device struct
154 */
155 struct ishtp_device {
156 struct device *devc; /* pointer to lowest device */
157 struct pci_dev *pdev; /* PCI device to get device ids */
158 struct ishtp_driver_data *driver_data; /* pointer to driver-specific data */
159
160 /* waitq for waiting for suspend response */
161 wait_queue_head_t suspend_wait;
162 bool suspend_flag; /* Suspend is active */
163
164 /* waitq for waiting for resume response */
165 wait_queue_head_t resume_wait;
166 bool resume_flag; /*Resume is active */
167
168 /*
169 * lock for the device, for everything that doesn't have
170 * a dedicated spinlock
171 */
172 spinlock_t device_lock;
173
174 bool recvd_hw_ready;
175 struct hbm_version version;
176 int transfer_path; /* Choice of transfer path: IPC or DMA */
177
178 /* Alloc a dedicated unbound workqueue for ishtp device */
179 struct workqueue_struct *unbound_wq;
180
181 /* work structure for scheduling firmware loading tasks */
182 struct work_struct work_fw_loader;
183 /* waitq for waiting for command response from the firmware loader */
184 wait_queue_head_t wait_loader_recvd_msg;
185 /* indicating whether a message from the firmware loader has been received */
186 bool fw_loader_received;
187 /* pointer to a buffer for receiving messages from the firmware loader */
188 void *fw_loader_rx_buf;
189 /* size of the buffer pointed to by fw_loader_rx_buf */
190 int fw_loader_rx_size;
191
192 /* ishtp device states */
193 enum ishtp_dev_state dev_state;
194 enum ishtp_hbm_state hbm_state;
195
196 /* driver read queue */
197 struct ishtp_cl_rb read_list;
198 spinlock_t read_list_spinlock;
199
200 /* list of ishtp_cl's */
201 struct list_head cl_list;
202 spinlock_t cl_list_lock;
203 long open_handle_count;
204
205 /* List of bus devices */
206 struct list_head device_list;
207 spinlock_t device_list_lock;
208
209 /* waiting queues for receive message from FW */
210 wait_queue_head_t wait_hw_ready;
211 wait_queue_head_t wait_hbm_recvd_msg;
212
213 /* FIFO for input messages for BH processing */
214 unsigned char rd_msg_fifo[RD_INT_FIFO_SIZE * IPC_PAYLOAD_SIZE];
215 unsigned int rd_msg_fifo_head, rd_msg_fifo_tail;
216 spinlock_t rd_msg_spinlock;
217 struct work_struct bh_hbm_work;
218
219 /* IPC write queue */
220 struct list_head wr_processing_list, wr_free_list;
221 /* For both processing list and free list */
222 spinlock_t wr_processing_spinlock;
223
224 struct ishtp_fw_client *fw_clients; /*Note:memory has to be allocated*/
225 DECLARE_BITMAP(fw_clients_map, ISHTP_CLIENTS_MAX);
226 DECLARE_BITMAP(host_clients_map, ISHTP_CLIENTS_MAX);
227 uint8_t fw_clients_num;
228 uint8_t fw_client_presentation_num;
229 uint8_t fw_client_index;
230 spinlock_t fw_clients_lock;
231
232 /* TX DMA buffers and slots */
233 int ishtp_host_dma_enabled;
234 void *ishtp_host_dma_tx_buf;
235 unsigned int ishtp_host_dma_tx_buf_size;
236 uint64_t ishtp_host_dma_tx_buf_phys;
237 int ishtp_dma_num_slots;
238
239 /* map of 4k blocks in Tx dma buf: 0-free, 1-used */
240 uint8_t *ishtp_dma_tx_map;
241 spinlock_t ishtp_dma_tx_lock;
242
243 /* RX DMA buffers and slots */
244 void *ishtp_host_dma_rx_buf;
245 unsigned int ishtp_host_dma_rx_buf_size;
246 uint64_t ishtp_host_dma_rx_buf_phys;
247
248 /* Dump to trace buffers if enabled*/
249 ishtp_print_log print_log;
250
251 /* Base version of Intel's released firmware */
252 struct ish_version base_ver;
253 /* Vendor-customized project version */
254 struct ish_version prj_ver;
255
256 /* Debug stats */
257 unsigned int ipc_rx_cnt;
258 unsigned long long ipc_rx_bytes_cnt;
259 unsigned int ipc_tx_cnt;
260 unsigned long long ipc_tx_bytes_cnt;
261
262 /* Time of the last clock sync */
263 unsigned long prev_sync;
264 const struct ishtp_hw_ops *ops;
265 size_t mtu;
266 uint32_t ishtp_msg_hdr;
267 char hw[] __aligned(sizeof(void *));
268 };
269
ishtp_secs_to_jiffies(unsigned long sec)270 static inline unsigned long ishtp_secs_to_jiffies(unsigned long sec)
271 {
272 return msecs_to_jiffies(sec * MSEC_PER_SEC);
273 }
274
275 /*
276 * Register Access Function
277 */
ish_ipc_reset(struct ishtp_device * dev)278 static inline int ish_ipc_reset(struct ishtp_device *dev)
279 {
280 return dev->ops->ipc_reset(dev);
281 }
282
283 /* Exported function */
284 void ishtp_device_init(struct ishtp_device *dev);
285 int ishtp_start(struct ishtp_device *dev);
286
287 #endif /*_ISHTP_DEV_H_*/
288