3 * Intel Management Engine Interface (Intel MEI) Linux driver
4 * Copyright (c) 2003-2012, Intel Corporation.
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.
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
17 #include <linux/export.h>
18 #include <linux/sched.h>
19 #include <linux/wait.h>
20 #include <linux/delay.h>
22 #include <linux/mei.h>
28 const char *mei_dev_state_str(int state)
30 #define MEI_DEV_STATE(state) case MEI_DEV_##state: return #state
32 MEI_DEV_STATE(INITIALIZING);
33 MEI_DEV_STATE(INIT_CLIENTS);
34 MEI_DEV_STATE(ENABLED);
35 MEI_DEV_STATE(RESETTING);
36 MEI_DEV_STATE(DISABLED);
37 MEI_DEV_STATE(POWER_DOWN);
38 MEI_DEV_STATE(POWER_UP);
45 const char *mei_pg_state_str(enum mei_pg_state state)
47 #define MEI_PG_STATE(state) case MEI_PG_##state: return #state
58 * mei_fw_status2str - convert fw status registers to printable string
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
64 * Return: number of bytes written or -EINVAL if buffer is to small
66 ssize_t mei_fw_status2str(struct mei_fw_status *fw_status,
67 char *buf, size_t len)
74 if (len < MEI_FW_STATUS_STR_SZ)
77 for (i = 0; i < fw_status->count; i++)
78 cnt += scnprintf(buf + cnt, len - cnt, "%08X ",
79 fw_status->status[i]);
85 EXPORT_SYMBOL_GPL(mei_fw_status2str);
88 * mei_cancel_work - Cancel mei background jobs
90 * @dev: the device structure
92 void mei_cancel_work(struct mei_device *dev)
94 cancel_work_sync(&dev->reset_work);
95 cancel_work_sync(&dev->bus_rescan_work);
97 cancel_delayed_work_sync(&dev->timer_work);
99 EXPORT_SYMBOL_GPL(mei_cancel_work);
102 * mei_reset - resets host and fw.
104 * @dev: the device structure
106 * Return: 0 on success or < 0 if the reset hasn't succeeded
108 int mei_reset(struct mei_device *dev)
110 enum mei_dev_state state = dev->dev_state;
111 bool interrupts_enabled;
114 if (state != MEI_DEV_INITIALIZING &&
115 state != MEI_DEV_DISABLED &&
116 state != MEI_DEV_POWER_DOWN &&
117 state != MEI_DEV_POWER_UP) {
118 char fw_sts_str[MEI_FW_STATUS_STR_SZ];
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);
125 mei_clear_interrupts(dev);
127 mei_synchronize_irq(dev);
129 /* we're already in reset, cancel the init timer
130 * if the reset was called due the hbm protocol error
131 * we need to call it before hw start
132 * so the hbm watchdog won't kick in
136 /* enter reset flow */
137 interrupts_enabled = state != MEI_DEV_POWER_DOWN;
138 dev->dev_state = MEI_DEV_RESETTING;
141 if (dev->reset_count > MEI_MAX_CONSEC_RESET) {
142 dev_err(dev->dev, "reset: reached maximal consecutive resets: disabling the device\n");
143 dev->dev_state = MEI_DEV_DISABLED;
147 ret = mei_hw_reset(dev, interrupts_enabled);
148 /* fall through and remove the sw state even if hw reset has failed */
150 /* no need to clean up software state in case of power up */
151 if (state != MEI_DEV_INITIALIZING &&
152 state != MEI_DEV_POWER_UP) {
154 /* remove all waiting requests */
155 mei_cl_all_disconnect(dev);
157 /* remove entry if already in list */
158 dev_dbg(dev->dev, "remove iamthif from the file list.\n");
159 mei_cl_unlink(&dev->iamthif_cl);
160 mei_amthif_reset_params(dev);
168 dev_err(dev->dev, "hw_reset failed ret = %d\n", ret);
172 if (state == MEI_DEV_POWER_DOWN) {
173 dev_dbg(dev->dev, "powering down: end of reset\n");
174 dev->dev_state = MEI_DEV_DISABLED;
178 ret = mei_hw_start(dev);
180 dev_err(dev->dev, "hw_start failed ret = %d\n", ret);
184 dev_dbg(dev->dev, "link is established start sending messages.\n");
186 dev->dev_state = MEI_DEV_INIT_CLIENTS;
187 ret = mei_hbm_start_req(dev);
189 dev_err(dev->dev, "hbm_start failed ret = %d\n", ret);
190 dev->dev_state = MEI_DEV_RESETTING;
196 EXPORT_SYMBOL_GPL(mei_reset);
199 * mei_start - initializes host and fw to start work.
201 * @dev: the device structure
203 * Return: 0 on success, <0 on failure.
205 int mei_start(struct mei_device *dev)
209 mutex_lock(&dev->device_lock);
211 /* acknowledge interrupt and stop interrupts */
212 mei_clear_interrupts(dev);
216 dev_dbg(dev->dev, "reset in start the mei device.\n");
218 dev->reset_count = 0;
220 dev->dev_state = MEI_DEV_INITIALIZING;
221 ret = mei_reset(dev);
223 if (ret == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) {
224 dev_err(dev->dev, "reset failed ret = %d", ret);
229 /* we cannot start the device w/o hbm start message completed */
230 if (dev->dev_state == MEI_DEV_DISABLED) {
231 dev_err(dev->dev, "reset failed");
235 if (mei_hbm_start_wait(dev)) {
236 dev_err(dev->dev, "HBM haven't started");
240 if (!mei_host_is_ready(dev)) {
241 dev_err(dev->dev, "host is not ready.\n");
245 if (!mei_hw_is_ready(dev)) {
246 dev_err(dev->dev, "ME is not ready.\n");
250 if (!mei_hbm_version_is_supported(dev)) {
251 dev_dbg(dev->dev, "MEI start failed.\n");
255 dev_dbg(dev->dev, "link layer has been established.\n");
257 mutex_unlock(&dev->device_lock);
260 dev_err(dev->dev, "link layer initialization failed.\n");
261 dev->dev_state = MEI_DEV_DISABLED;
262 mutex_unlock(&dev->device_lock);
265 EXPORT_SYMBOL_GPL(mei_start);
268 * mei_restart - restart device after suspend
270 * @dev: the device structure
272 * Return: 0 on success or -ENODEV if the restart hasn't succeeded
274 int mei_restart(struct mei_device *dev)
278 mutex_lock(&dev->device_lock);
280 dev->dev_state = MEI_DEV_POWER_UP;
281 dev->reset_count = 0;
283 err = mei_reset(dev);
285 mutex_unlock(&dev->device_lock);
287 if (err == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) {
288 dev_err(dev->dev, "device disabled = %d\n", err);
292 /* try to start again */
294 schedule_work(&dev->reset_work);
299 EXPORT_SYMBOL_GPL(mei_restart);
301 static void mei_reset_work(struct work_struct *work)
303 struct mei_device *dev =
304 container_of(work, struct mei_device, reset_work);
307 mutex_lock(&dev->device_lock);
309 ret = mei_reset(dev);
311 mutex_unlock(&dev->device_lock);
313 if (dev->dev_state == MEI_DEV_DISABLED) {
314 dev_err(dev->dev, "device disabled = %d\n", ret);
318 /* retry reset in case of failure */
320 schedule_work(&dev->reset_work);
323 void mei_stop(struct mei_device *dev)
325 dev_dbg(dev->dev, "stopping the device.\n");
327 mei_cl_bus_remove_devices(dev);
329 mei_cancel_work(dev);
331 mutex_lock(&dev->device_lock);
333 dev->dev_state = MEI_DEV_POWER_DOWN;
335 /* move device to disabled state unconditionally */
336 dev->dev_state = MEI_DEV_DISABLED;
338 mutex_unlock(&dev->device_lock);
340 EXPORT_SYMBOL_GPL(mei_stop);
343 * mei_write_is_idle - check if the write queues are idle
345 * @dev: the device structure
347 * Return: true of there is no pending write
349 bool mei_write_is_idle(struct mei_device *dev)
351 bool idle = (dev->dev_state == MEI_DEV_ENABLED &&
352 list_empty(&dev->ctrl_wr_list) &&
353 list_empty(&dev->write_list) &&
354 list_empty(&dev->write_waiting_list));
356 dev_dbg(dev->dev, "write pg: is idle[%d] state=%s ctrl=%01d write=%01d wwait=%01d\n",
358 mei_dev_state_str(dev->dev_state),
359 list_empty(&dev->ctrl_wr_list),
360 list_empty(&dev->write_list),
361 list_empty(&dev->write_waiting_list));
365 EXPORT_SYMBOL_GPL(mei_write_is_idle);
368 * mei_device_init -- initialize mei_device structure
370 * @dev: the mei device
371 * @device: the device structure
372 * @hw_ops: hw operations
374 void mei_device_init(struct mei_device *dev,
375 struct device *device,
376 const struct mei_hw_ops *hw_ops)
378 /* setup our list array */
379 INIT_LIST_HEAD(&dev->file_list);
380 INIT_LIST_HEAD(&dev->device_list);
381 INIT_LIST_HEAD(&dev->me_clients);
382 mutex_init(&dev->device_lock);
383 init_rwsem(&dev->me_clients_rwsem);
384 mutex_init(&dev->cl_bus_lock);
385 init_waitqueue_head(&dev->wait_hw_ready);
386 init_waitqueue_head(&dev->wait_pg);
387 init_waitqueue_head(&dev->wait_hbm_start);
388 dev->dev_state = MEI_DEV_INITIALIZING;
389 dev->reset_count = 0;
391 INIT_LIST_HEAD(&dev->write_list);
392 INIT_LIST_HEAD(&dev->write_waiting_list);
393 INIT_LIST_HEAD(&dev->ctrl_wr_list);
394 INIT_LIST_HEAD(&dev->ctrl_rd_list);
396 INIT_DELAYED_WORK(&dev->timer_work, mei_timer);
397 INIT_WORK(&dev->reset_work, mei_reset_work);
398 INIT_WORK(&dev->bus_rescan_work, mei_cl_bus_rescan_work);
400 INIT_LIST_HEAD(&dev->iamthif_cl.link);
401 INIT_LIST_HEAD(&dev->amthif_cmd_list);
403 bitmap_zero(dev->host_clients_map, MEI_CLIENTS_MAX);
404 dev->open_handle_count = 0;
407 * Reserving the first client ID
408 * 0: Reserved for MEI Bus Message communications
410 bitmap_set(dev->host_clients_map, 0, 1);
412 dev->pg_event = MEI_PG_EVENT_IDLE;
416 EXPORT_SYMBOL_GPL(mei_device_init);