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
28const 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
45const 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 */
66ssize_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}
85EXPORT_SYMBOL_GPL(mei_fw_status2str);
86
87/**
88 * mei_cancel_work - Cancel mei background jobs
89 *
90 * @dev: the device structure
91 */
92void mei_cancel_work(struct mei_device *dev)
93{
94	cancel_work_sync(&dev->init_work);
95	cancel_work_sync(&dev->reset_work);
96
97	cancel_delayed_work(&dev->timer_work);
98}
99EXPORT_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 */
108int 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	/* 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
132	/* enter reset flow */
133	interrupts_enabled = state != MEI_DEV_POWER_DOWN;
134	dev->dev_state = MEI_DEV_RESETTING;
135
136	dev->reset_count++;
137	if (dev->reset_count > MEI_MAX_CONSEC_RESET) {
138		dev_err(dev->dev, "reset: reached maximal consecutive resets: disabling the device\n");
139		dev->dev_state = MEI_DEV_DISABLED;
140		return -ENODEV;
141	}
142
143	ret = mei_hw_reset(dev, interrupts_enabled);
144	/* fall through and remove the sw state even if hw reset has failed */
145
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) {
149
150		/* remove all waiting requests */
151		mei_cl_all_write_clear(dev);
152
153		mei_cl_all_disconnect(dev);
154
155		/* wake up all readers and writers so they can be interrupted */
156		mei_cl_all_wakeup(dev);
157
158		/* remove entry if already in list */
159		dev_dbg(dev->dev, "remove iamthif and wd from the file list.\n");
160		mei_cl_unlink(&dev->wd_cl);
161		mei_cl_unlink(&dev->iamthif_cl);
162		mei_amthif_reset_params(dev);
163	}
164
165	mei_hbm_reset(dev);
166
167	dev->rd_msg_hdr = 0;
168	dev->wd_pending = false;
169
170	if (ret) {
171		dev_err(dev->dev, "hw_reset failed ret = %d\n", ret);
172		return ret;
173	}
174
175	if (state == MEI_DEV_POWER_DOWN) {
176		dev_dbg(dev->dev, "powering down: end of reset\n");
177		dev->dev_state = MEI_DEV_DISABLED;
178		return 0;
179	}
180
181	ret = mei_hw_start(dev);
182	if (ret) {
183		dev_err(dev->dev, "hw_start failed ret = %d\n", ret);
184		return ret;
185	}
186
187	dev_dbg(dev->dev, "link is established start sending messages.\n");
188
189	dev->dev_state = MEI_DEV_INIT_CLIENTS;
190	ret = mei_hbm_start_req(dev);
191	if (ret) {
192		dev_err(dev->dev, "hbm_start failed ret = %d\n", ret);
193		dev->dev_state = MEI_DEV_RESETTING;
194		return ret;
195	}
196
197	return 0;
198}
199EXPORT_SYMBOL_GPL(mei_reset);
200
201/**
202 * mei_start - initializes host and fw to start work.
203 *
204 * @dev: the device structure
205 *
206 * Return: 0 on success, <0 on failure.
207 */
208int mei_start(struct mei_device *dev)
209{
210	int ret;
211
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
219	dev_dbg(dev->dev, "reset in start the mei device.\n");
220
221	dev->reset_count = 0;
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) {
227			dev_err(dev->dev, "reset failed ret = %d", ret);
228			goto err;
229		}
230	} while (ret);
231
232	/* we cannot start the device w/o hbm start message completed */
233	if (dev->dev_state == MEI_DEV_DISABLED) {
234		dev_err(dev->dev, "reset failed");
235		goto err;
236	}
237
238	if (mei_hbm_start_wait(dev)) {
239		dev_err(dev->dev, "HBM haven't started");
240		goto err;
241	}
242
243	if (!mei_host_is_ready(dev)) {
244		dev_err(dev->dev, "host is not ready.\n");
245		goto err;
246	}
247
248	if (!mei_hw_is_ready(dev)) {
249		dev_err(dev->dev, "ME is not ready.\n");
250		goto err;
251	}
252
253	if (!mei_hbm_version_is_supported(dev)) {
254		dev_dbg(dev->dev, "MEI start failed.\n");
255		goto err;
256	}
257
258	dev_dbg(dev->dev, "link layer has been established.\n");
259
260	mutex_unlock(&dev->device_lock);
261	return 0;
262err:
263	dev_err(dev->dev, "link layer initialization failed.\n");
264	dev->dev_state = MEI_DEV_DISABLED;
265	mutex_unlock(&dev->device_lock);
266	return -ENODEV;
267}
268EXPORT_SYMBOL_GPL(mei_start);
269
270/**
271 * mei_restart - restart device after suspend
272 *
273 * @dev: the device structure
274 *
275 * Return: 0 on success or -ENODEV if the restart hasn't succeeded
276 */
277int 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;
286	dev->reset_count = 0;
287
288	err = mei_reset(dev);
289
290	mutex_unlock(&dev->device_lock);
291
292	if (err == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) {
293		dev_err(dev->dev, "device disabled = %d\n", err);
294		return -ENODEV;
295	}
296
297	/* try to start again */
298	if (err)
299		schedule_work(&dev->reset_work);
300
301
302	return 0;
303}
304EXPORT_SYMBOL_GPL(mei_restart);
305
306static void mei_reset_work(struct work_struct *work)
307{
308	struct mei_device *dev =
309		container_of(work, struct mei_device,  reset_work);
310	int ret;
311
312	mutex_lock(&dev->device_lock);
313
314	ret = mei_reset(dev);
315
316	mutex_unlock(&dev->device_lock);
317
318	if (dev->dev_state == MEI_DEV_DISABLED) {
319		dev_err(dev->dev, "device disabled = %d\n", ret);
320		return;
321	}
322
323	/* retry reset in case of failure */
324	if (ret)
325		schedule_work(&dev->reset_work);
326}
327
328void mei_stop(struct mei_device *dev)
329{
330	dev_dbg(dev->dev, "stopping the device.\n");
331
332	mei_cancel_work(dev);
333
334	mei_nfc_host_exit(dev);
335
336	mei_cl_bus_remove_devices(dev);
337
338	mutex_lock(&dev->device_lock);
339
340	mei_wd_stop(dev);
341
342	dev->dev_state = MEI_DEV_POWER_DOWN;
343	mei_reset(dev);
344	/* move device to disabled state unconditionally */
345	dev->dev_state = MEI_DEV_DISABLED;
346
347	mutex_unlock(&dev->device_lock);
348
349	mei_watchdog_unregister(dev);
350}
351EXPORT_SYMBOL_GPL(mei_stop);
352
353/**
354 * mei_write_is_idle - check if the write queues are idle
355 *
356 * @dev: the device structure
357 *
358 * Return: true of there is no pending write
359 */
360bool mei_write_is_idle(struct mei_device *dev)
361{
362	bool idle = (dev->dev_state == MEI_DEV_ENABLED &&
363		list_empty(&dev->ctrl_wr_list.list) &&
364		list_empty(&dev->write_list.list));
365
366	dev_dbg(dev->dev, "write pg: is idle[%d] state=%s ctrl=%d write=%d\n",
367		idle,
368		mei_dev_state_str(dev->dev_state),
369		list_empty(&dev->ctrl_wr_list.list),
370		list_empty(&dev->write_list.list));
371
372	return idle;
373}
374EXPORT_SYMBOL_GPL(mei_write_is_idle);
375
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 */
383void mei_device_init(struct mei_device *dev,
384		     struct device *device,
385		     const struct mei_hw_ops *hw_ops)
386{
387	/* setup our list array */
388	INIT_LIST_HEAD(&dev->file_list);
389	INIT_LIST_HEAD(&dev->device_list);
390	INIT_LIST_HEAD(&dev->me_clients);
391	mutex_init(&dev->device_lock);
392	init_rwsem(&dev->me_clients_rwsem);
393	init_waitqueue_head(&dev->wait_hw_ready);
394	init_waitqueue_head(&dev->wait_pg);
395	init_waitqueue_head(&dev->wait_hbm_start);
396	init_waitqueue_head(&dev->wait_stop_wd);
397	dev->dev_state = MEI_DEV_INITIALIZING;
398	dev->reset_count = 0;
399
400	mei_io_list_init(&dev->write_list);
401	mei_io_list_init(&dev->write_waiting_list);
402	mei_io_list_init(&dev->ctrl_wr_list);
403	mei_io_list_init(&dev->ctrl_rd_list);
404
405	INIT_DELAYED_WORK(&dev->timer_work, mei_timer);
406	INIT_WORK(&dev->init_work, mei_host_client_init);
407	INIT_WORK(&dev->reset_work, mei_reset_work);
408
409	INIT_LIST_HEAD(&dev->wd_cl.link);
410	INIT_LIST_HEAD(&dev->iamthif_cl.link);
411	mei_io_list_init(&dev->amthif_cmd_list);
412	mei_io_list_init(&dev->amthif_rd_complete_list);
413
414	bitmap_zero(dev->host_clients_map, MEI_CLIENTS_MAX);
415	dev->open_handle_count = 0;
416
417	/*
418	 * Reserving the first client ID
419	 * 0: Reserved for MEI Bus Message communications
420	 */
421	bitmap_set(dev->host_clients_map, 0, 1);
422
423	dev->pg_event = MEI_PG_EVENT_IDLE;
424	dev->ops      = hw_ops;
425	dev->dev      = device;
426}
427EXPORT_SYMBOL_GPL(mei_device_init);
428
429