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->reset_work);
 95	cancel_work_sync(&dev->bus_rescan_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_disconnect(dev);
152
153		/* remove entry if already in list */
154		dev_dbg(dev->dev, "remove iamthif from the file list.\n");
155		mei_cl_unlink(&dev->iamthif_cl);
156		mei_amthif_reset_params(dev);
157	}
158
159	mei_hbm_reset(dev);
160
161	dev->rd_msg_hdr = 0;
162
163	if (ret) {
164		dev_err(dev->dev, "hw_reset failed ret = %d\n", ret);
165		return ret;
166	}
167
168	if (state == MEI_DEV_POWER_DOWN) {
169		dev_dbg(dev->dev, "powering down: end of reset\n");
170		dev->dev_state = MEI_DEV_DISABLED;
171		return 0;
172	}
173
174	ret = mei_hw_start(dev);
175	if (ret) {
176		dev_err(dev->dev, "hw_start failed ret = %d\n", ret);
177		return ret;
178	}
179
180	dev_dbg(dev->dev, "link is established start sending messages.\n");
181
182	dev->dev_state = MEI_DEV_INIT_CLIENTS;
183	ret = mei_hbm_start_req(dev);
184	if (ret) {
185		dev_err(dev->dev, "hbm_start failed ret = %d\n", ret);
186		dev->dev_state = MEI_DEV_RESETTING;
187		return ret;
188	}
189
190	return 0;
191}
192EXPORT_SYMBOL_GPL(mei_reset);
193
194/**
195 * mei_start - initializes host and fw to start work.
196 *
197 * @dev: the device structure
198 *
199 * Return: 0 on success, <0 on failure.
200 */
201int mei_start(struct mei_device *dev)
202{
203	int ret;
204
205	mutex_lock(&dev->device_lock);
206
207	/* acknowledge interrupt and stop interrupts */
208	mei_clear_interrupts(dev);
209
210	mei_hw_config(dev);
211
212	dev_dbg(dev->dev, "reset in start the mei device.\n");
213
214	dev->reset_count = 0;
215	do {
216		dev->dev_state = MEI_DEV_INITIALIZING;
217		ret = mei_reset(dev);
218
219		if (ret == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) {
220			dev_err(dev->dev, "reset failed ret = %d", ret);
221			goto err;
222		}
223	} while (ret);
224
225	/* we cannot start the device w/o hbm start message completed */
226	if (dev->dev_state == MEI_DEV_DISABLED) {
227		dev_err(dev->dev, "reset failed");
228		goto err;
229	}
230
231	if (mei_hbm_start_wait(dev)) {
232		dev_err(dev->dev, "HBM haven't started");
233		goto err;
234	}
235
236	if (!mei_host_is_ready(dev)) {
237		dev_err(dev->dev, "host is not ready.\n");
238		goto err;
239	}
240
241	if (!mei_hw_is_ready(dev)) {
242		dev_err(dev->dev, "ME is not ready.\n");
243		goto err;
244	}
245
246	if (!mei_hbm_version_is_supported(dev)) {
247		dev_dbg(dev->dev, "MEI start failed.\n");
248		goto err;
249	}
250
251	dev_dbg(dev->dev, "link layer has been established.\n");
252
253	mutex_unlock(&dev->device_lock);
254	return 0;
255err:
256	dev_err(dev->dev, "link layer initialization failed.\n");
257	dev->dev_state = MEI_DEV_DISABLED;
258	mutex_unlock(&dev->device_lock);
259	return -ENODEV;
260}
261EXPORT_SYMBOL_GPL(mei_start);
262
263/**
264 * mei_restart - restart device after suspend
265 *
266 * @dev: the device structure
267 *
268 * Return: 0 on success or -ENODEV if the restart hasn't succeeded
269 */
270int mei_restart(struct mei_device *dev)
271{
272	int err;
273
274	mutex_lock(&dev->device_lock);
275
276	mei_clear_interrupts(dev);
277
278	dev->dev_state = MEI_DEV_POWER_UP;
279	dev->reset_count = 0;
280
281	err = mei_reset(dev);
282
283	mutex_unlock(&dev->device_lock);
284
285	if (err == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) {
286		dev_err(dev->dev, "device disabled = %d\n", err);
287		return -ENODEV;
288	}
289
290	/* try to start again */
291	if (err)
292		schedule_work(&dev->reset_work);
293
294
295	return 0;
296}
297EXPORT_SYMBOL_GPL(mei_restart);
298
299static void mei_reset_work(struct work_struct *work)
300{
301	struct mei_device *dev =
302		container_of(work, struct mei_device,  reset_work);
303	int ret;
304
305	mutex_lock(&dev->device_lock);
306
307	ret = mei_reset(dev);
308
309	mutex_unlock(&dev->device_lock);
310
311	if (dev->dev_state == MEI_DEV_DISABLED) {
312		dev_err(dev->dev, "device disabled = %d\n", ret);
313		return;
314	}
315
316	/* retry reset in case of failure */
317	if (ret)
318		schedule_work(&dev->reset_work);
319}
320
321void mei_stop(struct mei_device *dev)
322{
323	dev_dbg(dev->dev, "stopping the device.\n");
324
325	mei_cl_bus_remove_devices(dev);
326
327	mei_cancel_work(dev);
328
329	mutex_lock(&dev->device_lock);
330
331	dev->dev_state = MEI_DEV_POWER_DOWN;
332	mei_reset(dev);
333	/* move device to disabled state unconditionally */
334	dev->dev_state = MEI_DEV_DISABLED;
335
336	mutex_unlock(&dev->device_lock);
337}
338EXPORT_SYMBOL_GPL(mei_stop);
339
340/**
341 * mei_write_is_idle - check if the write queues are idle
342 *
343 * @dev: the device structure
344 *
345 * Return: true of there is no pending write
346 */
347bool mei_write_is_idle(struct mei_device *dev)
348{
349	bool idle = (dev->dev_state == MEI_DEV_ENABLED &&
350		list_empty(&dev->ctrl_wr_list.list) &&
351		list_empty(&dev->write_list.list)   &&
352		list_empty(&dev->write_waiting_list.list));
353
354	dev_dbg(dev->dev, "write pg: is idle[%d] state=%s ctrl=%01d write=%01d wwait=%01d\n",
355		idle,
356		mei_dev_state_str(dev->dev_state),
357		list_empty(&dev->ctrl_wr_list.list),
358		list_empty(&dev->write_list.list),
359		list_empty(&dev->write_waiting_list.list));
360
361	return idle;
362}
363EXPORT_SYMBOL_GPL(mei_write_is_idle);
364
365/**
366 * mei_device_init  -- initialize mei_device structure
367 *
368 * @dev: the mei device
369 * @device: the device structure
370 * @hw_ops: hw operations
371 */
372void mei_device_init(struct mei_device *dev,
373		     struct device *device,
374		     const struct mei_hw_ops *hw_ops)
375{
376	/* setup our list array */
377	INIT_LIST_HEAD(&dev->file_list);
378	INIT_LIST_HEAD(&dev->device_list);
379	INIT_LIST_HEAD(&dev->me_clients);
380	mutex_init(&dev->device_lock);
381	init_rwsem(&dev->me_clients_rwsem);
382	mutex_init(&dev->cl_bus_lock);
383	init_waitqueue_head(&dev->wait_hw_ready);
384	init_waitqueue_head(&dev->wait_pg);
385	init_waitqueue_head(&dev->wait_hbm_start);
386	dev->dev_state = MEI_DEV_INITIALIZING;
387	dev->reset_count = 0;
388
389	mei_io_list_init(&dev->write_list);
390	mei_io_list_init(&dev->write_waiting_list);
391	mei_io_list_init(&dev->ctrl_wr_list);
392	mei_io_list_init(&dev->ctrl_rd_list);
393
394	INIT_DELAYED_WORK(&dev->timer_work, mei_timer);
395	INIT_WORK(&dev->reset_work, mei_reset_work);
396	INIT_WORK(&dev->bus_rescan_work, mei_cl_bus_rescan_work);
397
398	INIT_LIST_HEAD(&dev->iamthif_cl.link);
399	mei_io_list_init(&dev->amthif_cmd_list);
400
401	bitmap_zero(dev->host_clients_map, MEI_CLIENTS_MAX);
402	dev->open_handle_count = 0;
403
404	/*
405	 * Reserving the first client ID
406	 * 0: Reserved for MEI Bus Message communications
407	 */
408	bitmap_set(dev->host_clients_map, 0, 1);
409
410	dev->pg_event = MEI_PG_EVENT_IDLE;
411	dev->ops      = hw_ops;
412	dev->dev      = device;
413}
414EXPORT_SYMBOL_GPL(mei_device_init);
415