Commit | Line | Data |
---|---|---|
91f01c6d OW |
1 | /* |
2 | * | |
3 | * Intel Management Engine Interface (Intel MEI) Linux driver | |
733ba91c | 4 | * Copyright (c) 2003-2012, Intel Corporation. |
91f01c6d OW |
5 | * |
6 | * This program is free software; you can redistribute it and/or modify it | |
7 | * under the terms and conditions of the GNU General Public License, | |
8 | * version 2, as published by the Free Software Foundation. | |
9 | * | |
10 | * This program is distributed in the hope it will be useful, but WITHOUT | |
11 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
12 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | |
13 | * more details. | |
14 | * | |
15 | */ | |
16 | ||
40e0b67b | 17 | #include <linux/export.h> |
91f01c6d OW |
18 | #include <linux/sched.h> |
19 | #include <linux/wait.h> | |
20 | #include <linux/delay.h> | |
21 | ||
47a73801 TW |
22 | #include <linux/mei.h> |
23 | ||
91f01c6d | 24 | #include "mei_dev.h" |
aafae7ec | 25 | #include "hbm.h" |
90e0b5f1 | 26 | #include "client.h" |
91f01c6d | 27 | |
b210d750 TW |
28 | const char *mei_dev_state_str(int state) |
29 | { | |
30 | #define MEI_DEV_STATE(state) case MEI_DEV_##state: return #state | |
31 | switch (state) { | |
32 | MEI_DEV_STATE(INITIALIZING); | |
33 | MEI_DEV_STATE(INIT_CLIENTS); | |
34 | MEI_DEV_STATE(ENABLED); | |
0cfee51c | 35 | MEI_DEV_STATE(RESETTING); |
b210d750 | 36 | MEI_DEV_STATE(DISABLED); |
b210d750 TW |
37 | MEI_DEV_STATE(POWER_DOWN); |
38 | MEI_DEV_STATE(POWER_UP); | |
39 | default: | |
8b513d0c | 40 | return "unknown"; |
b210d750 TW |
41 | } |
42 | #undef MEI_DEV_STATE | |
43 | } | |
44 | ||
1beeb4b9 AU |
45 | const char *mei_pg_state_str(enum mei_pg_state state) |
46 | { | |
47 | #define MEI_PG_STATE(state) case MEI_PG_##state: return #state | |
48 | switch (state) { | |
49 | MEI_PG_STATE(OFF); | |
50 | MEI_PG_STATE(ON); | |
51 | default: | |
52 | return "unknown"; | |
53 | } | |
54 | #undef MEI_PG_STATE | |
55 | } | |
56 | ||
edca5ea3 AU |
57 | /** |
58 | * mei_fw_status2str - convert fw status registers to printable string | |
59 | * | |
60 | * @fw_status: firmware status | |
61 | * @buf: string buffer at minimal size MEI_FW_STATUS_STR_SZ | |
62 | * @len: buffer len must be >= MEI_FW_STATUS_STR_SZ | |
63 | * | |
64 | * Return: number of bytes written or -EINVAL if buffer is to small | |
65 | */ | |
66 | ssize_t mei_fw_status2str(struct mei_fw_status *fw_status, | |
67 | char *buf, size_t len) | |
68 | { | |
69 | ssize_t cnt = 0; | |
70 | int i; | |
71 | ||
72 | buf[0] = '\0'; | |
73 | ||
74 | if (len < MEI_FW_STATUS_STR_SZ) | |
75 | return -EINVAL; | |
76 | ||
77 | for (i = 0; i < fw_status->count; i++) | |
78 | cnt += scnprintf(buf + cnt, len - cnt, "%08X ", | |
79 | fw_status->status[i]); | |
80 | ||
81 | /* drop last space */ | |
82 | buf[cnt] = '\0'; | |
83 | return cnt; | |
84 | } | |
85 | EXPORT_SYMBOL_GPL(mei_fw_status2str); | |
91f01c6d | 86 | |
544f9460 | 87 | /** |
a8605ea2 | 88 | * mei_cancel_work - Cancel mei background jobs |
544f9460 TW |
89 | * |
90 | * @dev: the device structure | |
91 | */ | |
dc844b0d TW |
92 | void mei_cancel_work(struct mei_device *dev) |
93 | { | |
94 | cancel_work_sync(&dev->init_work); | |
544f9460 | 95 | cancel_work_sync(&dev->reset_work); |
dc844b0d TW |
96 | |
97 | cancel_delayed_work(&dev->timer_work); | |
98 | } | |
99 | EXPORT_SYMBOL_GPL(mei_cancel_work); | |
100 | ||
91f01c6d OW |
101 | /** |
102 | * mei_reset - resets host and fw. | |
103 | * | |
104 | * @dev: the device structure | |
ce23139c AU |
105 | * |
106 | * Return: 0 on success or < 0 if the reset hasn't succeeded | |
91f01c6d | 107 | */ |
33ec0826 | 108 | int mei_reset(struct mei_device *dev) |
91f01c6d | 109 | { |
33ec0826 TW |
110 | enum mei_dev_state state = dev->dev_state; |
111 | bool interrupts_enabled; | |
c20c68d5 | 112 | int ret; |
91f01c6d | 113 | |
33ec0826 TW |
114 | if (state != MEI_DEV_INITIALIZING && |
115 | state != MEI_DEV_DISABLED && | |
116 | state != MEI_DEV_POWER_DOWN && | |
04dd3661 | 117 | state != MEI_DEV_POWER_UP) { |
edca5ea3 | 118 | char fw_sts_str[MEI_FW_STATUS_STR_SZ]; |
92db1555 | 119 | |
edca5ea3 AU |
120 | mei_fw_status_str(dev, fw_sts_str, MEI_FW_STATUS_STR_SZ); |
121 | dev_warn(dev->dev, "unexpected reset: dev_state = %s fw status = %s\n", | |
122 | mei_dev_state_str(state), fw_sts_str); | |
04dd3661 | 123 | } |
f931f4f3 | 124 | |
66ae460b TW |
125 | /* we're already in reset, cancel the init timer |
126 | * if the reset was called due the hbm protocol error | |
127 | * we need to call it before hw start | |
128 | * so the hbm watchdog won't kick in | |
129 | */ | |
130 | mei_hbm_idle(dev); | |
131 | ||
33ec0826 TW |
132 | /* enter reset flow */ |
133 | interrupts_enabled = state != MEI_DEV_POWER_DOWN; | |
134 | dev->dev_state = MEI_DEV_RESETTING; | |
91f01c6d | 135 | |
6adb8efb TW |
136 | dev->reset_count++; |
137 | if (dev->reset_count > MEI_MAX_CONSEC_RESET) { | |
2bf94cab | 138 | dev_err(dev->dev, "reset: reached maximal consecutive resets: disabling the device\n"); |
6adb8efb TW |
139 | dev->dev_state = MEI_DEV_DISABLED; |
140 | return -ENODEV; | |
141 | } | |
142 | ||
33ec0826 TW |
143 | ret = mei_hw_reset(dev, interrupts_enabled); |
144 | /* fall through and remove the sw state even if hw reset has failed */ | |
91f01c6d | 145 | |
33ec0826 TW |
146 | /* no need to clean up software state in case of power up */ |
147 | if (state != MEI_DEV_INITIALIZING && | |
148 | state != MEI_DEV_POWER_UP) { | |
91f01c6d | 149 | |
b950ac1d TW |
150 | /* remove all waiting requests */ |
151 | mei_cl_all_write_clear(dev); | |
152 | ||
074b4c01 TW |
153 | mei_cl_all_disconnect(dev); |
154 | ||
33ec0826 | 155 | /* wake up all readers and writers so they can be interrupted */ |
b950ac1d TW |
156 | mei_cl_all_wakeup(dev); |
157 | ||
91f01c6d | 158 | /* remove entry if already in list */ |
2bf94cab | 159 | dev_dbg(dev->dev, "remove iamthif and wd from the file list.\n"); |
90e0b5f1 TW |
160 | mei_cl_unlink(&dev->wd_cl); |
161 | mei_cl_unlink(&dev->iamthif_cl); | |
19838fb8 | 162 | mei_amthif_reset_params(dev); |
91f01c6d OW |
163 | } |
164 | ||
84b3294a | 165 | mei_hbm_reset(dev); |
4a704575 | 166 | |
91f01c6d | 167 | dev->rd_msg_hdr = 0; |
eb9af0ac | 168 | dev->wd_pending = false; |
91f01c6d | 169 | |
33ec0826 | 170 | if (ret) { |
2bf94cab | 171 | dev_err(dev->dev, "hw_reset failed ret = %d\n", ret); |
33ec0826 TW |
172 | return ret; |
173 | } | |
174 | ||
175 | if (state == MEI_DEV_POWER_DOWN) { | |
2bf94cab | 176 | dev_dbg(dev->dev, "powering down: end of reset\n"); |
33ec0826 TW |
177 | dev->dev_state = MEI_DEV_DISABLED; |
178 | return 0; | |
aafae7ec TW |
179 | } |
180 | ||
9049f793 TW |
181 | ret = mei_hw_start(dev); |
182 | if (ret) { | |
2bf94cab | 183 | dev_err(dev->dev, "hw_start failed ret = %d\n", ret); |
33ec0826 | 184 | return ret; |
9049f793 | 185 | } |
aafae7ec | 186 | |
2bf94cab | 187 | dev_dbg(dev->dev, "link is established start sending messages.\n"); |
aafae7ec TW |
188 | |
189 | dev->dev_state = MEI_DEV_INIT_CLIENTS; | |
544f9460 TW |
190 | ret = mei_hbm_start_req(dev); |
191 | if (ret) { | |
2bf94cab | 192 | dev_err(dev->dev, "hbm_start failed ret = %d\n", ret); |
7d93e58d | 193 | dev->dev_state = MEI_DEV_RESETTING; |
33ec0826 | 194 | return ret; |
544f9460 | 195 | } |
33ec0826 TW |
196 | |
197 | return 0; | |
91f01c6d | 198 | } |
40e0b67b | 199 | EXPORT_SYMBOL_GPL(mei_reset); |
91f01c6d | 200 | |
33ec0826 TW |
201 | /** |
202 | * mei_start - initializes host and fw to start work. | |
203 | * | |
204 | * @dev: the device structure | |
205 | * | |
a8605ea2 | 206 | * Return: 0 on success, <0 on failure. |
33ec0826 TW |
207 | */ |
208 | int mei_start(struct mei_device *dev) | |
209 | { | |
7d93e58d | 210 | int ret; |
92db1555 | 211 | |
33ec0826 TW |
212 | mutex_lock(&dev->device_lock); |
213 | ||
214 | /* acknowledge interrupt and stop interrupts */ | |
215 | mei_clear_interrupts(dev); | |
216 | ||
217 | mei_hw_config(dev); | |
218 | ||
2bf94cab | 219 | dev_dbg(dev->dev, "reset in start the mei device.\n"); |
33ec0826 | 220 | |
6adb8efb | 221 | dev->reset_count = 0; |
7d93e58d TW |
222 | do { |
223 | dev->dev_state = MEI_DEV_INITIALIZING; | |
224 | ret = mei_reset(dev); | |
225 | ||
226 | if (ret == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) { | |
2bf94cab | 227 | dev_err(dev->dev, "reset failed ret = %d", ret); |
7d93e58d TW |
228 | goto err; |
229 | } | |
230 | } while (ret); | |
33ec0826 | 231 | |
7d93e58d | 232 | /* we cannot start the device w/o hbm start message completed */ |
33ec0826 | 233 | if (dev->dev_state == MEI_DEV_DISABLED) { |
2bf94cab | 234 | dev_err(dev->dev, "reset failed"); |
33ec0826 TW |
235 | goto err; |
236 | } | |
237 | ||
238 | if (mei_hbm_start_wait(dev)) { | |
2bf94cab | 239 | dev_err(dev->dev, "HBM haven't started"); |
33ec0826 TW |
240 | goto err; |
241 | } | |
242 | ||
243 | if (!mei_host_is_ready(dev)) { | |
2bf94cab | 244 | dev_err(dev->dev, "host is not ready.\n"); |
33ec0826 TW |
245 | goto err; |
246 | } | |
247 | ||
248 | if (!mei_hw_is_ready(dev)) { | |
2bf94cab | 249 | dev_err(dev->dev, "ME is not ready.\n"); |
33ec0826 TW |
250 | goto err; |
251 | } | |
252 | ||
253 | if (!mei_hbm_version_is_supported(dev)) { | |
2bf94cab | 254 | dev_dbg(dev->dev, "MEI start failed.\n"); |
33ec0826 TW |
255 | goto err; |
256 | } | |
257 | ||
2bf94cab | 258 | dev_dbg(dev->dev, "link layer has been established.\n"); |
33ec0826 TW |
259 | |
260 | mutex_unlock(&dev->device_lock); | |
261 | return 0; | |
262 | err: | |
2bf94cab | 263 | dev_err(dev->dev, "link layer initialization failed.\n"); |
33ec0826 TW |
264 | dev->dev_state = MEI_DEV_DISABLED; |
265 | mutex_unlock(&dev->device_lock); | |
266 | return -ENODEV; | |
267 | } | |
268 | EXPORT_SYMBOL_GPL(mei_start); | |
269 | ||
270 | /** | |
271 | * mei_restart - restart device after suspend | |
272 | * | |
273 | * @dev: the device structure | |
274 | * | |
a8605ea2 | 275 | * Return: 0 on success or -ENODEV if the restart hasn't succeeded |
33ec0826 TW |
276 | */ |
277 | int mei_restart(struct mei_device *dev) | |
278 | { | |
279 | int err; | |
280 | ||
281 | mutex_lock(&dev->device_lock); | |
282 | ||
283 | mei_clear_interrupts(dev); | |
284 | ||
285 | dev->dev_state = MEI_DEV_POWER_UP; | |
6adb8efb | 286 | dev->reset_count = 0; |
33ec0826 TW |
287 | |
288 | err = mei_reset(dev); | |
289 | ||
290 | mutex_unlock(&dev->device_lock); | |
291 | ||
7d93e58d | 292 | if (err == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) { |
2bf94cab | 293 | dev_err(dev->dev, "device disabled = %d\n", err); |
33ec0826 | 294 | return -ENODEV; |
7d93e58d TW |
295 | } |
296 | ||
297 | /* try to start again */ | |
298 | if (err) | |
299 | schedule_work(&dev->reset_work); | |
300 | ||
33ec0826 TW |
301 | |
302 | return 0; | |
303 | } | |
304 | EXPORT_SYMBOL_GPL(mei_restart); | |
305 | ||
544f9460 TW |
306 | static void mei_reset_work(struct work_struct *work) |
307 | { | |
308 | struct mei_device *dev = | |
309 | container_of(work, struct mei_device, reset_work); | |
7d93e58d | 310 | int ret; |
544f9460 TW |
311 | |
312 | mutex_lock(&dev->device_lock); | |
313 | ||
7d93e58d | 314 | ret = mei_reset(dev); |
544f9460 TW |
315 | |
316 | mutex_unlock(&dev->device_lock); | |
33ec0826 | 317 | |
7d93e58d | 318 | if (dev->dev_state == MEI_DEV_DISABLED) { |
2bf94cab | 319 | dev_err(dev->dev, "device disabled = %d\n", ret); |
7d93e58d TW |
320 | return; |
321 | } | |
322 | ||
323 | /* retry reset in case of failure */ | |
324 | if (ret) | |
325 | schedule_work(&dev->reset_work); | |
544f9460 TW |
326 | } |
327 | ||
7cb035d9 TW |
328 | void mei_stop(struct mei_device *dev) |
329 | { | |
2bf94cab | 330 | dev_dbg(dev->dev, "stopping the device.\n"); |
7cb035d9 | 331 | |
dc844b0d | 332 | mei_cancel_work(dev); |
5e85b364 | 333 | |
6009595a | 334 | mei_cl_bus_remove_devices(dev); |
7cb035d9 | 335 | |
dc844b0d | 336 | mutex_lock(&dev->device_lock); |
7cb035d9 TW |
337 | |
338 | mei_wd_stop(dev); | |
339 | ||
340 | dev->dev_state = MEI_DEV_POWER_DOWN; | |
33ec0826 | 341 | mei_reset(dev); |
6c15a851 AU |
342 | /* move device to disabled state unconditionally */ |
343 | dev->dev_state = MEI_DEV_DISABLED; | |
7cb035d9 TW |
344 | |
345 | mutex_unlock(&dev->device_lock); | |
346 | ||
2e647124 | 347 | mei_watchdog_unregister(dev); |
7cb035d9 | 348 | } |
40e0b67b | 349 | EXPORT_SYMBOL_GPL(mei_stop); |
91f01c6d | 350 | |
a532bbed TW |
351 | /** |
352 | * mei_write_is_idle - check if the write queues are idle | |
353 | * | |
354 | * @dev: the device structure | |
355 | * | |
a8605ea2 | 356 | * Return: true of there is no pending write |
a532bbed TW |
357 | */ |
358 | bool mei_write_is_idle(struct mei_device *dev) | |
359 | { | |
360 | bool idle = (dev->dev_state == MEI_DEV_ENABLED && | |
361 | list_empty(&dev->ctrl_wr_list.list) && | |
41c95b04 TW |
362 | list_empty(&dev->write_list.list) && |
363 | list_empty(&dev->write_waiting_list.list)); | |
c1174c0e | 364 | |
41c95b04 | 365 | dev_dbg(dev->dev, "write pg: is idle[%d] state=%s ctrl=%01d write=%01d wwait=%01d\n", |
a532bbed TW |
366 | idle, |
367 | mei_dev_state_str(dev->dev_state), | |
368 | list_empty(&dev->ctrl_wr_list.list), | |
41c95b04 TW |
369 | list_empty(&dev->write_list.list), |
370 | list_empty(&dev->write_waiting_list.list)); | |
a532bbed TW |
371 | |
372 | return idle; | |
373 | } | |
374 | EXPORT_SYMBOL_GPL(mei_write_is_idle); | |
91f01c6d | 375 | |
3a7e9b6c TW |
376 | /** |
377 | * mei_device_init -- initialize mei_device structure | |
378 | * | |
379 | * @dev: the mei device | |
380 | * @device: the device structure | |
381 | * @hw_ops: hw operations | |
382 | */ | |
383 | void mei_device_init(struct mei_device *dev, | |
384 | struct device *device, | |
385 | const struct mei_hw_ops *hw_ops) | |
544f9460 TW |
386 | { |
387 | /* setup our list array */ | |
388 | INIT_LIST_HEAD(&dev->file_list); | |
389 | INIT_LIST_HEAD(&dev->device_list); | |
5ca2d388 | 390 | INIT_LIST_HEAD(&dev->me_clients); |
544f9460 | 391 | mutex_init(&dev->device_lock); |
b7d88514 | 392 | init_rwsem(&dev->me_clients_rwsem); |
0ff0a8d8 | 393 | mutex_init(&dev->cl_bus_lock); |
544f9460 | 394 | init_waitqueue_head(&dev->wait_hw_ready); |
4fcbc99b | 395 | init_waitqueue_head(&dev->wait_pg); |
cb02efc3 | 396 | init_waitqueue_head(&dev->wait_hbm_start); |
544f9460 TW |
397 | init_waitqueue_head(&dev->wait_stop_wd); |
398 | dev->dev_state = MEI_DEV_INITIALIZING; | |
6adb8efb | 399 | dev->reset_count = 0; |
544f9460 | 400 | |
544f9460 TW |
401 | mei_io_list_init(&dev->write_list); |
402 | mei_io_list_init(&dev->write_waiting_list); | |
403 | mei_io_list_init(&dev->ctrl_wr_list); | |
404 | mei_io_list_init(&dev->ctrl_rd_list); | |
405 | ||
406 | INIT_DELAYED_WORK(&dev->timer_work, mei_timer); | |
407 | INIT_WORK(&dev->init_work, mei_host_client_init); | |
408 | INIT_WORK(&dev->reset_work, mei_reset_work); | |
409 | ||
410 | INIT_LIST_HEAD(&dev->wd_cl.link); | |
411 | INIT_LIST_HEAD(&dev->iamthif_cl.link); | |
412 | mei_io_list_init(&dev->amthif_cmd_list); | |
413 | mei_io_list_init(&dev->amthif_rd_complete_list); | |
414 | ||
415 | bitmap_zero(dev->host_clients_map, MEI_CLIENTS_MAX); | |
416 | dev->open_handle_count = 0; | |
417 | ||
418 | /* | |
419 | * Reserving the first client ID | |
420 | * 0: Reserved for MEI Bus Message communications | |
421 | */ | |
422 | bitmap_set(dev->host_clients_map, 0, 1); | |
964a2331 TW |
423 | |
424 | dev->pg_event = MEI_PG_EVENT_IDLE; | |
3a7e9b6c TW |
425 | dev->ops = hw_ops; |
426 | dev->dev = device; | |
544f9460 TW |
427 | } |
428 | EXPORT_SYMBOL_GPL(mei_device_init); | |
429 |