1 /*
2  *
3  * Intel Management Engine Interface (Intel MEI) Linux driver
4  * Copyright (c) 2003-2012, Intel Corporation.
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 
17 #include <linux/export.h>
18 #include <linux/sched.h>
19 #include <linux/wait.h>
20 #include <linux/delay.h>
21 
22 #include <linux/mei.h>
23 
24 #include "mei_dev.h"
25 #include "hbm.h"
26 #include "client.h"
27 
mei_dev_state_str(int state)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);
35 	MEI_DEV_STATE(RESETTING);
36 	MEI_DEV_STATE(DISABLED);
37 	MEI_DEV_STATE(POWER_DOWN);
38 	MEI_DEV_STATE(POWER_UP);
39 	default:
40 		return "unknown";
41 	}
42 #undef MEI_DEV_STATE
43 }
44 
mei_pg_state_str(enum mei_pg_state state)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 
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  */
mei_fw_status2str(struct mei_fw_status * fw_status,char * buf,size_t len)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);
86 
87 /**
88  * mei_cancel_work - Cancel mei background jobs
89  *
90  * @dev: the device structure
91  */
mei_cancel_work(struct mei_device * dev)92 void mei_cancel_work(struct mei_device *dev)
93 {
94 	cancel_work_sync(&dev->reset_work);
95 	cancel_work_sync(&dev->bus_rescan_work);
96 
97 	cancel_delayed_work_sync(&dev->timer_work);
98 }
99 EXPORT_SYMBOL_GPL(mei_cancel_work);
100 
101 /**
102  * mei_reset - resets host and fw.
103  *
104  * @dev: the device structure
105  *
106  * Return: 0 on success or < 0 if the reset hasn't succeeded
107  */
mei_reset(struct mei_device * dev)108 int mei_reset(struct mei_device *dev)
109 {
110 	enum mei_dev_state state = dev->dev_state;
111 	bool interrupts_enabled;
112 	int ret;
113 
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];
119 
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);
123 	}
124 
125 	mei_clear_interrupts(dev);
126 
127 	/* we're already in reset, cancel the init timer
128 	 * if the reset was called due the hbm protocol error
129 	 * we need to call it before hw start
130 	 * so the hbm watchdog won't kick in
131 	 */
132 	mei_hbm_idle(dev);
133 
134 	/* enter reset flow */
135 	interrupts_enabled = state != MEI_DEV_POWER_DOWN;
136 	dev->dev_state = MEI_DEV_RESETTING;
137 
138 	dev->reset_count++;
139 	if (dev->reset_count > MEI_MAX_CONSEC_RESET) {
140 		dev_err(dev->dev, "reset: reached maximal consecutive resets: disabling the device\n");
141 		dev->dev_state = MEI_DEV_DISABLED;
142 		return -ENODEV;
143 	}
144 
145 	ret = mei_hw_reset(dev, interrupts_enabled);
146 	/* fall through and remove the sw state even if hw reset has failed */
147 
148 	/* no need to clean up software state in case of power up */
149 	if (state != MEI_DEV_INITIALIZING && state != MEI_DEV_POWER_UP)
150 		mei_cl_all_disconnect(dev);
151 
152 	mei_hbm_reset(dev);
153 
154 	dev->rd_msg_hdr = 0;
155 
156 	if (ret) {
157 		dev_err(dev->dev, "hw_reset failed ret = %d\n", ret);
158 		return ret;
159 	}
160 
161 	if (state == MEI_DEV_POWER_DOWN) {
162 		dev_dbg(dev->dev, "powering down: end of reset\n");
163 		dev->dev_state = MEI_DEV_DISABLED;
164 		return 0;
165 	}
166 
167 	ret = mei_hw_start(dev);
168 	if (ret) {
169 		dev_err(dev->dev, "hw_start failed ret = %d\n", ret);
170 		return ret;
171 	}
172 
173 	dev_dbg(dev->dev, "link is established start sending messages.\n");
174 
175 	dev->dev_state = MEI_DEV_INIT_CLIENTS;
176 	ret = mei_hbm_start_req(dev);
177 	if (ret) {
178 		dev_err(dev->dev, "hbm_start failed ret = %d\n", ret);
179 		dev->dev_state = MEI_DEV_RESETTING;
180 		return ret;
181 	}
182 
183 	return 0;
184 }
185 EXPORT_SYMBOL_GPL(mei_reset);
186 
187 /**
188  * mei_start - initializes host and fw to start work.
189  *
190  * @dev: the device structure
191  *
192  * Return: 0 on success, <0 on failure.
193  */
mei_start(struct mei_device * dev)194 int mei_start(struct mei_device *dev)
195 {
196 	int ret;
197 
198 	mutex_lock(&dev->device_lock);
199 
200 	/* acknowledge interrupt and stop interrupts */
201 	mei_clear_interrupts(dev);
202 
203 	mei_hw_config(dev);
204 
205 	dev_dbg(dev->dev, "reset in start the mei device.\n");
206 
207 	dev->reset_count = 0;
208 	do {
209 		dev->dev_state = MEI_DEV_INITIALIZING;
210 		ret = mei_reset(dev);
211 
212 		if (ret == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) {
213 			dev_err(dev->dev, "reset failed ret = %d", ret);
214 			goto err;
215 		}
216 	} while (ret);
217 
218 	if (mei_hbm_start_wait(dev)) {
219 		dev_err(dev->dev, "HBM haven't started");
220 		goto err;
221 	}
222 
223 	if (!mei_host_is_ready(dev)) {
224 		dev_err(dev->dev, "host is not ready.\n");
225 		goto err;
226 	}
227 
228 	if (!mei_hw_is_ready(dev)) {
229 		dev_err(dev->dev, "ME is not ready.\n");
230 		goto err;
231 	}
232 
233 	if (!mei_hbm_version_is_supported(dev)) {
234 		dev_dbg(dev->dev, "MEI start failed.\n");
235 		goto err;
236 	}
237 
238 	dev_dbg(dev->dev, "link layer has been established.\n");
239 
240 	mutex_unlock(&dev->device_lock);
241 	return 0;
242 err:
243 	dev_err(dev->dev, "link layer initialization failed.\n");
244 	dev->dev_state = MEI_DEV_DISABLED;
245 	mutex_unlock(&dev->device_lock);
246 	return -ENODEV;
247 }
248 EXPORT_SYMBOL_GPL(mei_start);
249 
250 /**
251  * mei_restart - restart device after suspend
252  *
253  * @dev: the device structure
254  *
255  * Return: 0 on success or -ENODEV if the restart hasn't succeeded
256  */
mei_restart(struct mei_device * dev)257 int mei_restart(struct mei_device *dev)
258 {
259 	int err;
260 
261 	mutex_lock(&dev->device_lock);
262 
263 	dev->dev_state = MEI_DEV_POWER_UP;
264 	dev->reset_count = 0;
265 
266 	err = mei_reset(dev);
267 
268 	mutex_unlock(&dev->device_lock);
269 
270 	if (err == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) {
271 		dev_err(dev->dev, "device disabled = %d\n", err);
272 		return -ENODEV;
273 	}
274 
275 	/* try to start again */
276 	if (err)
277 		schedule_work(&dev->reset_work);
278 
279 
280 	return 0;
281 }
282 EXPORT_SYMBOL_GPL(mei_restart);
283 
mei_reset_work(struct work_struct * work)284 static void mei_reset_work(struct work_struct *work)
285 {
286 	struct mei_device *dev =
287 		container_of(work, struct mei_device,  reset_work);
288 	int ret;
289 
290 	mei_clear_interrupts(dev);
291 	mei_synchronize_irq(dev);
292 
293 	mutex_lock(&dev->device_lock);
294 
295 	ret = mei_reset(dev);
296 
297 	mutex_unlock(&dev->device_lock);
298 
299 	if (dev->dev_state == MEI_DEV_DISABLED) {
300 		dev_err(dev->dev, "device disabled = %d\n", ret);
301 		return;
302 	}
303 
304 	/* retry reset in case of failure */
305 	if (ret)
306 		schedule_work(&dev->reset_work);
307 }
308 
mei_stop(struct mei_device * dev)309 void mei_stop(struct mei_device *dev)
310 {
311 	dev_dbg(dev->dev, "stopping the device.\n");
312 
313 	mutex_lock(&dev->device_lock);
314 	dev->dev_state = MEI_DEV_POWER_DOWN;
315 	mutex_unlock(&dev->device_lock);
316 	mei_cl_bus_remove_devices(dev);
317 
318 	mei_cancel_work(dev);
319 
320 	mei_clear_interrupts(dev);
321 	mei_synchronize_irq(dev);
322 
323 	mutex_lock(&dev->device_lock);
324 
325 	mei_reset(dev);
326 	/* move device to disabled state unconditionally */
327 	dev->dev_state = MEI_DEV_DISABLED;
328 
329 	mutex_unlock(&dev->device_lock);
330 }
331 EXPORT_SYMBOL_GPL(mei_stop);
332 
333 /**
334  * mei_write_is_idle - check if the write queues are idle
335  *
336  * @dev: the device structure
337  *
338  * Return: true of there is no pending write
339  */
mei_write_is_idle(struct mei_device * dev)340 bool mei_write_is_idle(struct mei_device *dev)
341 {
342 	bool idle = (dev->dev_state == MEI_DEV_ENABLED &&
343 		list_empty(&dev->ctrl_wr_list) &&
344 		list_empty(&dev->write_list)   &&
345 		list_empty(&dev->write_waiting_list));
346 
347 	dev_dbg(dev->dev, "write pg: is idle[%d] state=%s ctrl=%01d write=%01d wwait=%01d\n",
348 		idle,
349 		mei_dev_state_str(dev->dev_state),
350 		list_empty(&dev->ctrl_wr_list),
351 		list_empty(&dev->write_list),
352 		list_empty(&dev->write_waiting_list));
353 
354 	return idle;
355 }
356 EXPORT_SYMBOL_GPL(mei_write_is_idle);
357 
358 /**
359  * mei_device_init  -- initialize mei_device structure
360  *
361  * @dev: the mei device
362  * @device: the device structure
363  * @hw_ops: hw operations
364  */
mei_device_init(struct mei_device * dev,struct device * device,const struct mei_hw_ops * hw_ops)365 void mei_device_init(struct mei_device *dev,
366 		     struct device *device,
367 		     const struct mei_hw_ops *hw_ops)
368 {
369 	/* setup our list array */
370 	INIT_LIST_HEAD(&dev->file_list);
371 	INIT_LIST_HEAD(&dev->device_list);
372 	INIT_LIST_HEAD(&dev->me_clients);
373 	mutex_init(&dev->device_lock);
374 	init_rwsem(&dev->me_clients_rwsem);
375 	mutex_init(&dev->cl_bus_lock);
376 	init_waitqueue_head(&dev->wait_hw_ready);
377 	init_waitqueue_head(&dev->wait_pg);
378 	init_waitqueue_head(&dev->wait_hbm_start);
379 	dev->dev_state = MEI_DEV_INITIALIZING;
380 	dev->reset_count = 0;
381 
382 	INIT_LIST_HEAD(&dev->write_list);
383 	INIT_LIST_HEAD(&dev->write_waiting_list);
384 	INIT_LIST_HEAD(&dev->ctrl_wr_list);
385 	INIT_LIST_HEAD(&dev->ctrl_rd_list);
386 	dev->tx_queue_limit = MEI_TX_QUEUE_LIMIT_DEFAULT;
387 
388 	INIT_DELAYED_WORK(&dev->timer_work, mei_timer);
389 	INIT_WORK(&dev->reset_work, mei_reset_work);
390 	INIT_WORK(&dev->bus_rescan_work, mei_cl_bus_rescan_work);
391 
392 	bitmap_zero(dev->host_clients_map, MEI_CLIENTS_MAX);
393 	dev->open_handle_count = 0;
394 
395 	/*
396 	 * Reserving the first client ID
397 	 * 0: Reserved for MEI Bus Message communications
398 	 */
399 	bitmap_set(dev->host_clients_map, 0, 1);
400 
401 	dev->pg_event = MEI_PG_EVENT_IDLE;
402 	dev->ops      = hw_ops;
403 	dev->dev      = device;
404 }
405 EXPORT_SYMBOL_GPL(mei_device_init);
406 
407