1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Copyright (c) 2012-2022, Intel Corporation. All rights reserved. |
4 | * Intel Management Engine Interface (Intel MEI) Linux driver |
5 | */ |
6 | |
7 | #include <linux/export.h> |
8 | #include <linux/sched.h> |
9 | #include <linux/wait.h> |
10 | #include <linux/delay.h> |
11 | |
12 | #include <linux/mei.h> |
13 | |
14 | #include "mei_dev.h" |
15 | #include "hbm.h" |
16 | #include "client.h" |
17 | |
18 | const char *mei_dev_state_str(int state) |
19 | { |
20 | #define MEI_DEV_STATE(state) case MEI_DEV_##state: return #state |
21 | switch (state) { |
22 | MEI_DEV_STATE(INITIALIZING); |
23 | MEI_DEV_STATE(INIT_CLIENTS); |
24 | MEI_DEV_STATE(ENABLED); |
25 | MEI_DEV_STATE(RESETTING); |
26 | MEI_DEV_STATE(DISABLED); |
27 | MEI_DEV_STATE(POWERING_DOWN); |
28 | MEI_DEV_STATE(POWER_DOWN); |
29 | MEI_DEV_STATE(POWER_UP); |
30 | default: |
31 | return "unknown" ; |
32 | } |
33 | #undef MEI_DEV_STATE |
34 | } |
35 | |
36 | const char *mei_pg_state_str(enum mei_pg_state state) |
37 | { |
38 | #define MEI_PG_STATE(state) case MEI_PG_##state: return #state |
39 | switch (state) { |
40 | MEI_PG_STATE(OFF); |
41 | MEI_PG_STATE(ON); |
42 | default: |
43 | return "unknown" ; |
44 | } |
45 | #undef MEI_PG_STATE |
46 | } |
47 | |
48 | /** |
49 | * mei_fw_status2str - convert fw status registers to printable string |
50 | * |
51 | * @fw_status: firmware status |
52 | * @buf: string buffer at minimal size MEI_FW_STATUS_STR_SZ |
53 | * @len: buffer len must be >= MEI_FW_STATUS_STR_SZ |
54 | * |
55 | * Return: number of bytes written or -EINVAL if buffer is to small |
56 | */ |
57 | ssize_t mei_fw_status2str(struct mei_fw_status *fw_status, |
58 | char *buf, size_t len) |
59 | { |
60 | ssize_t cnt = 0; |
61 | int i; |
62 | |
63 | buf[0] = '\0'; |
64 | |
65 | if (len < MEI_FW_STATUS_STR_SZ) |
66 | return -EINVAL; |
67 | |
68 | for (i = 0; i < fw_status->count; i++) |
69 | cnt += scnprintf(buf: buf + cnt, size: len - cnt, fmt: "%08X " , |
70 | fw_status->status[i]); |
71 | |
72 | /* drop last space */ |
73 | buf[cnt] = '\0'; |
74 | return cnt; |
75 | } |
76 | EXPORT_SYMBOL_GPL(mei_fw_status2str); |
77 | |
78 | /** |
79 | * mei_cancel_work - Cancel mei background jobs |
80 | * |
81 | * @dev: the device structure |
82 | */ |
83 | void mei_cancel_work(struct mei_device *dev) |
84 | { |
85 | cancel_work_sync(work: &dev->reset_work); |
86 | cancel_work_sync(work: &dev->bus_rescan_work); |
87 | |
88 | cancel_delayed_work_sync(dwork: &dev->timer_work); |
89 | } |
90 | EXPORT_SYMBOL_GPL(mei_cancel_work); |
91 | |
92 | static void mei_save_fw_status(struct mei_device *dev) |
93 | { |
94 | struct mei_fw_status fw_status; |
95 | int ret; |
96 | |
97 | ret = mei_fw_status(dev, fw_status: &fw_status); |
98 | if (ret) { |
99 | dev_err(dev->dev, "failed to read firmware status: %d\n" , ret); |
100 | return; |
101 | } |
102 | |
103 | dev->saved_dev_state = dev->dev_state; |
104 | dev->saved_fw_status_flag = true; |
105 | memcpy(&dev->saved_fw_status, &fw_status, sizeof(fw_status)); |
106 | } |
107 | |
108 | /** |
109 | * mei_reset - resets host and fw. |
110 | * |
111 | * @dev: the device structure |
112 | * |
113 | * Return: 0 on success or < 0 if the reset hasn't succeeded |
114 | */ |
115 | int mei_reset(struct mei_device *dev) |
116 | { |
117 | enum mei_dev_state state = dev->dev_state; |
118 | bool interrupts_enabled; |
119 | int ret; |
120 | |
121 | if (state != MEI_DEV_INITIALIZING && |
122 | state != MEI_DEV_DISABLED && |
123 | state != MEI_DEV_POWER_DOWN && |
124 | state != MEI_DEV_POWER_UP) { |
125 | char fw_sts_str[MEI_FW_STATUS_STR_SZ]; |
126 | |
127 | mei_fw_status_str(dev, buf: fw_sts_str, MEI_FW_STATUS_STR_SZ); |
128 | if (kind_is_gsc(dev) || kind_is_gscfi(dev)) { |
129 | dev_dbg(dev->dev, "unexpected reset: dev_state = %s fw status = %s\n" , |
130 | mei_dev_state_str(state), fw_sts_str); |
131 | mei_save_fw_status(dev); |
132 | } else { |
133 | dev_warn(dev->dev, "unexpected reset: dev_state = %s fw status = %s\n" , |
134 | mei_dev_state_str(state), fw_sts_str); |
135 | } |
136 | } |
137 | |
138 | mei_clear_interrupts(dev); |
139 | |
140 | /* we're already in reset, cancel the init timer |
141 | * if the reset was called due the hbm protocol error |
142 | * we need to call it before hw start |
143 | * so the hbm watchdog won't kick in |
144 | */ |
145 | mei_hbm_idle(dev); |
146 | |
147 | /* enter reset flow */ |
148 | interrupts_enabled = state != MEI_DEV_POWER_DOWN; |
149 | mei_set_devstate(dev, state: MEI_DEV_RESETTING); |
150 | |
151 | dev->reset_count++; |
152 | if (dev->reset_count > MEI_MAX_CONSEC_RESET) { |
153 | dev_err(dev->dev, "reset: reached maximal consecutive resets: disabling the device\n" ); |
154 | mei_set_devstate(dev, state: MEI_DEV_DISABLED); |
155 | return -ENODEV; |
156 | } |
157 | |
158 | ret = mei_hw_reset(dev, enable: interrupts_enabled); |
159 | /* fall through and remove the sw state even if hw reset has failed */ |
160 | |
161 | /* no need to clean up software state in case of power up */ |
162 | if (state != MEI_DEV_INITIALIZING && state != MEI_DEV_POWER_UP) |
163 | mei_cl_all_disconnect(dev); |
164 | |
165 | mei_hbm_reset(dev); |
166 | |
167 | /* clean stale FW version */ |
168 | dev->fw_ver_received = 0; |
169 | |
170 | memset(dev->rd_msg_hdr, 0, sizeof(dev->rd_msg_hdr)); |
171 | |
172 | if (ret) { |
173 | dev_err(dev->dev, "hw_reset failed ret = %d\n" , ret); |
174 | return ret; |
175 | } |
176 | |
177 | if (state == MEI_DEV_POWER_DOWN) { |
178 | dev_dbg(dev->dev, "powering down: end of reset\n" ); |
179 | mei_set_devstate(dev, state: MEI_DEV_DISABLED); |
180 | return 0; |
181 | } |
182 | |
183 | ret = mei_hw_start(dev); |
184 | if (ret) { |
185 | char fw_sts_str[MEI_FW_STATUS_STR_SZ]; |
186 | |
187 | mei_fw_status_str(dev, buf: fw_sts_str, MEI_FW_STATUS_STR_SZ); |
188 | dev_err(dev->dev, "hw_start failed ret = %d fw status = %s\n" , ret, fw_sts_str); |
189 | return ret; |
190 | } |
191 | |
192 | if (dev->dev_state != MEI_DEV_RESETTING) { |
193 | dev_dbg(dev->dev, "wrong state = %d on link start\n" , dev->dev_state); |
194 | return 0; |
195 | } |
196 | |
197 | dev_dbg(dev->dev, "link is established start sending messages.\n" ); |
198 | |
199 | mei_set_devstate(dev, state: MEI_DEV_INIT_CLIENTS); |
200 | ret = mei_hbm_start_req(dev); |
201 | if (ret) { |
202 | dev_err(dev->dev, "hbm_start failed ret = %d\n" , ret); |
203 | mei_set_devstate(dev, state: MEI_DEV_RESETTING); |
204 | return ret; |
205 | } |
206 | |
207 | return 0; |
208 | } |
209 | EXPORT_SYMBOL_GPL(mei_reset); |
210 | |
211 | /** |
212 | * mei_start - initializes host and fw to start work. |
213 | * |
214 | * @dev: the device structure |
215 | * |
216 | * Return: 0 on success, <0 on failure. |
217 | */ |
218 | int mei_start(struct mei_device *dev) |
219 | { |
220 | int ret; |
221 | |
222 | mutex_lock(&dev->device_lock); |
223 | |
224 | /* acknowledge interrupt and stop interrupts */ |
225 | mei_clear_interrupts(dev); |
226 | |
227 | ret = mei_hw_config(dev); |
228 | if (ret) |
229 | goto err; |
230 | |
231 | dev_dbg(dev->dev, "reset in start the mei device.\n" ); |
232 | |
233 | dev->reset_count = 0; |
234 | do { |
235 | mei_set_devstate(dev, state: MEI_DEV_INITIALIZING); |
236 | ret = mei_reset(dev); |
237 | |
238 | if (ret == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) { |
239 | dev_err(dev->dev, "reset failed ret = %d" , ret); |
240 | goto err; |
241 | } |
242 | } while (ret); |
243 | |
244 | if (mei_hbm_start_wait(dev)) { |
245 | dev_err(dev->dev, "HBM haven't started" ); |
246 | goto err; |
247 | } |
248 | |
249 | if (!mei_hbm_version_is_supported(dev)) { |
250 | dev_dbg(dev->dev, "MEI start failed.\n" ); |
251 | goto err; |
252 | } |
253 | |
254 | dev_dbg(dev->dev, "link layer has been established.\n" ); |
255 | |
256 | mutex_unlock(lock: &dev->device_lock); |
257 | return 0; |
258 | err: |
259 | dev_err(dev->dev, "link layer initialization failed.\n" ); |
260 | mei_set_devstate(dev, state: MEI_DEV_DISABLED); |
261 | mutex_unlock(lock: &dev->device_lock); |
262 | return -ENODEV; |
263 | } |
264 | EXPORT_SYMBOL_GPL(mei_start); |
265 | |
266 | /** |
267 | * mei_restart - restart device after suspend |
268 | * |
269 | * @dev: the device structure |
270 | * |
271 | * Return: 0 on success or -ENODEV if the restart hasn't succeeded |
272 | */ |
273 | int mei_restart(struct mei_device *dev) |
274 | { |
275 | int err; |
276 | |
277 | mutex_lock(&dev->device_lock); |
278 | |
279 | mei_set_devstate(dev, state: MEI_DEV_POWER_UP); |
280 | dev->reset_count = 0; |
281 | |
282 | err = mei_reset(dev); |
283 | |
284 | mutex_unlock(lock: &dev->device_lock); |
285 | |
286 | if (err == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) { |
287 | dev_err(dev->dev, "device disabled = %d\n" , err); |
288 | return -ENODEV; |
289 | } |
290 | |
291 | /* try to start again */ |
292 | if (err) |
293 | schedule_work(work: &dev->reset_work); |
294 | |
295 | |
296 | return 0; |
297 | } |
298 | EXPORT_SYMBOL_GPL(mei_restart); |
299 | |
300 | static void mei_reset_work(struct work_struct *work) |
301 | { |
302 | struct mei_device *dev = |
303 | container_of(work, struct mei_device, reset_work); |
304 | int ret; |
305 | |
306 | mei_clear_interrupts(dev); |
307 | mei_synchronize_irq(dev); |
308 | |
309 | mutex_lock(&dev->device_lock); |
310 | |
311 | ret = mei_reset(dev); |
312 | |
313 | mutex_unlock(lock: &dev->device_lock); |
314 | |
315 | if (dev->dev_state == MEI_DEV_DISABLED) { |
316 | dev_err(dev->dev, "device disabled = %d\n" , ret); |
317 | return; |
318 | } |
319 | |
320 | /* retry reset in case of failure */ |
321 | if (ret) |
322 | schedule_work(work: &dev->reset_work); |
323 | } |
324 | |
325 | void mei_stop(struct mei_device *dev) |
326 | { |
327 | dev_dbg(dev->dev, "stopping the device.\n" ); |
328 | |
329 | mutex_lock(&dev->device_lock); |
330 | mei_set_devstate(dev, state: MEI_DEV_POWERING_DOWN); |
331 | mutex_unlock(lock: &dev->device_lock); |
332 | mei_cl_bus_remove_devices(bus: dev); |
333 | mutex_lock(&dev->device_lock); |
334 | mei_set_devstate(dev, state: MEI_DEV_POWER_DOWN); |
335 | mutex_unlock(lock: &dev->device_lock); |
336 | |
337 | mei_cancel_work(dev); |
338 | |
339 | mei_clear_interrupts(dev); |
340 | mei_synchronize_irq(dev); |
341 | /* to catch HW-initiated reset */ |
342 | mei_cancel_work(dev); |
343 | |
344 | mutex_lock(&dev->device_lock); |
345 | |
346 | mei_reset(dev); |
347 | /* move device to disabled state unconditionally */ |
348 | mei_set_devstate(dev, state: MEI_DEV_DISABLED); |
349 | |
350 | mutex_unlock(lock: &dev->device_lock); |
351 | } |
352 | EXPORT_SYMBOL_GPL(mei_stop); |
353 | |
354 | /** |
355 | * mei_write_is_idle - check if the write queues are idle |
356 | * |
357 | * @dev: the device structure |
358 | * |
359 | * Return: true of there is no pending write |
360 | */ |
361 | bool mei_write_is_idle(struct mei_device *dev) |
362 | { |
363 | bool idle = (dev->dev_state == MEI_DEV_ENABLED && |
364 | list_empty(head: &dev->ctrl_wr_list) && |
365 | list_empty(head: &dev->write_list) && |
366 | list_empty(head: &dev->write_waiting_list)); |
367 | |
368 | dev_dbg(dev->dev, "write pg: is idle[%d] state=%s ctrl=%01d write=%01d wwait=%01d\n" , |
369 | idle, |
370 | mei_dev_state_str(dev->dev_state), |
371 | list_empty(&dev->ctrl_wr_list), |
372 | list_empty(&dev->write_list), |
373 | list_empty(&dev->write_waiting_list)); |
374 | |
375 | return idle; |
376 | } |
377 | EXPORT_SYMBOL_GPL(mei_write_is_idle); |
378 | |
379 | /** |
380 | * mei_device_init - initialize mei_device structure |
381 | * |
382 | * @dev: the mei device |
383 | * @device: the device structure |
384 | * @slow_fw: configure longer timeouts as FW is slow |
385 | * @hw_ops: hw operations |
386 | */ |
387 | void mei_device_init(struct mei_device *dev, |
388 | struct device *device, |
389 | bool slow_fw, |
390 | const struct mei_hw_ops *hw_ops) |
391 | { |
392 | /* setup our list array */ |
393 | INIT_LIST_HEAD(list: &dev->file_list); |
394 | INIT_LIST_HEAD(list: &dev->device_list); |
395 | INIT_LIST_HEAD(list: &dev->me_clients); |
396 | mutex_init(&dev->device_lock); |
397 | init_rwsem(&dev->me_clients_rwsem); |
398 | mutex_init(&dev->cl_bus_lock); |
399 | init_waitqueue_head(&dev->wait_hw_ready); |
400 | init_waitqueue_head(&dev->wait_pg); |
401 | init_waitqueue_head(&dev->wait_hbm_start); |
402 | dev->dev_state = MEI_DEV_INITIALIZING; |
403 | dev->reset_count = 0; |
404 | |
405 | INIT_LIST_HEAD(list: &dev->write_list); |
406 | INIT_LIST_HEAD(list: &dev->write_waiting_list); |
407 | INIT_LIST_HEAD(list: &dev->ctrl_wr_list); |
408 | INIT_LIST_HEAD(list: &dev->ctrl_rd_list); |
409 | dev->tx_queue_limit = MEI_TX_QUEUE_LIMIT_DEFAULT; |
410 | |
411 | INIT_DELAYED_WORK(&dev->timer_work, mei_timer); |
412 | INIT_WORK(&dev->reset_work, mei_reset_work); |
413 | INIT_WORK(&dev->bus_rescan_work, mei_cl_bus_rescan_work); |
414 | |
415 | bitmap_zero(dst: dev->host_clients_map, MEI_CLIENTS_MAX); |
416 | dev->open_handle_count = 0; |
417 | |
418 | dev->pxp_mode = MEI_DEV_PXP_DEFAULT; |
419 | dev->gsc_reset_to_pxp = MEI_DEV_RESET_TO_PXP_DEFAULT; |
420 | |
421 | /* |
422 | * Reserving the first client ID |
423 | * 0: Reserved for MEI Bus Message communications |
424 | */ |
425 | bitmap_set(map: dev->host_clients_map, start: 0, nbits: 1); |
426 | |
427 | dev->pg_event = MEI_PG_EVENT_IDLE; |
428 | dev->ops = hw_ops; |
429 | dev->dev = device; |
430 | |
431 | dev->timeouts.hw_ready = mei_secs_to_jiffies(MEI_HW_READY_TIMEOUT); |
432 | dev->timeouts.connect = MEI_CONNECT_TIMEOUT; |
433 | dev->timeouts.client_init = MEI_CLIENTS_INIT_TIMEOUT; |
434 | dev->timeouts.pgi = mei_secs_to_jiffies(MEI_PGI_TIMEOUT); |
435 | dev->timeouts.d0i3 = mei_secs_to_jiffies(MEI_D0I3_TIMEOUT); |
436 | if (slow_fw) { |
437 | dev->timeouts.cl_connect = mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT_SLOW); |
438 | dev->timeouts.hbm = mei_secs_to_jiffies(MEI_HBM_TIMEOUT_SLOW); |
439 | dev->timeouts.mkhi_recv = msecs_to_jiffies(MKHI_RCV_TIMEOUT_SLOW); |
440 | } else { |
441 | dev->timeouts.cl_connect = mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT); |
442 | dev->timeouts.hbm = mei_secs_to_jiffies(MEI_HBM_TIMEOUT); |
443 | dev->timeouts.mkhi_recv = msecs_to_jiffies(MKHI_RCV_TIMEOUT); |
444 | } |
445 | } |
446 | EXPORT_SYMBOL_GPL(mei_device_init); |
447 | |
448 | |