1/*
  2 *
  3 * Intel Management Engine Interface (Intel MEI) Linux driver
  4 * Copyright (c) 2012-2013, 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#include <linux/slab.h>
 17#include <linux/kernel.h>
 18#include <linux/device.h>
 19#include <linux/debugfs.h>
 20
 21#include <linux/mei.h>
 22
 23#include "mei_dev.h"
 24#include "client.h"
 25#include "hw.h"
 26
 27static ssize_t mei_dbgfs_read_meclients(struct file *fp, char __user *ubuf,
 28					size_t cnt, loff_t *ppos)
 29{
 30	struct mei_device *dev = fp->private_data;
 31	struct mei_me_client *me_cl;
 32	size_t bufsz = 1;
 33	char *buf;
 34	int i = 0;
 35	int pos = 0;
 36	int ret;
 37
 38#define HDR \
 39"  |id|fix|         UUID                       |con|msg len|sb|refc|\n"
 40
 41	down_read(&dev->me_clients_rwsem);
 42	list_for_each_entry(me_cl, &dev->me_clients, list)
 43		bufsz++;
 44
 45	bufsz *= sizeof(HDR) + 1;
 46	buf = kzalloc(bufsz, GFP_KERNEL);
 47	if (!buf) {
 48		up_read(&dev->me_clients_rwsem);
 49		return -ENOMEM;
 50	}
 51
 52	pos += scnprintf(buf + pos, bufsz - pos, HDR);
 53#undef HDR
 54
 55	/*  if the driver is not enabled the list won't be consistent */
 56	if (dev->dev_state != MEI_DEV_ENABLED)
 57		goto out;
 58
 59	list_for_each_entry(me_cl, &dev->me_clients, list) {
 60
 61		if (mei_me_cl_get(me_cl)) {
 62			pos += scnprintf(buf + pos, bufsz - pos,
 63				"%2d|%2d|%3d|%pUl|%3d|%7d|%2d|%4d|\n",
 64				i++, me_cl->client_id,
 65				me_cl->props.fixed_address,
 66				&me_cl->props.protocol_name,
 67				me_cl->props.max_number_of_connections,
 68				me_cl->props.max_msg_length,
 69				me_cl->props.single_recv_buf,
 70				kref_read(&me_cl->refcnt));
 71
 72			mei_me_cl_put(me_cl);
 73		}
 74	}
 75
 76out:
 77	up_read(&dev->me_clients_rwsem);
 78	ret = simple_read_from_buffer(ubuf, cnt, ppos, buf, pos);
 79	kfree(buf);
 80	return ret;
 81}
 82
 83static const struct file_operations mei_dbgfs_fops_meclients = {
 84	.open = simple_open,
 85	.read = mei_dbgfs_read_meclients,
 86	.llseek = generic_file_llseek,
 87};
 88
 89static ssize_t mei_dbgfs_read_active(struct file *fp, char __user *ubuf,
 90					size_t cnt, loff_t *ppos)
 91{
 92	struct mei_device *dev = fp->private_data;
 93	struct mei_cl *cl;
 94	size_t bufsz = 1;
 95	char *buf;
 96	int i = 0;
 97	int pos = 0;
 98	int ret;
 99
100#define HDR "   |me|host|state|rd|wr|wrq\n"
101
102	if (!dev)
103		return -ENODEV;
104
105	mutex_lock(&dev->device_lock);
106
107	/*
108	 * if the driver is not enabled the list won't be consistent,
109	 * we output empty table
110	 */
111	if (dev->dev_state == MEI_DEV_ENABLED)
112		list_for_each_entry(cl, &dev->file_list, link)
113			bufsz++;
114
115	bufsz *= sizeof(HDR) + 1;
116
117	buf = kzalloc(bufsz, GFP_KERNEL);
118	if  (!buf) {
119		mutex_unlock(&dev->device_lock);
120		return -ENOMEM;
121	}
122
123	pos += scnprintf(buf + pos, bufsz - pos, HDR);
124#undef HDR
125
126	/*  if the driver is not enabled the list won't be consistent */
127	if (dev->dev_state != MEI_DEV_ENABLED)
128		goto out;
129
130	list_for_each_entry(cl, &dev->file_list, link) {
131
132		pos += scnprintf(buf + pos, bufsz - pos,
133			"%3d|%2d|%4d|%5d|%2d|%2d|%3u\n",
134			i, mei_cl_me_id(cl), cl->host_client_id, cl->state,
135			!list_empty(&cl->rd_completed), cl->writing_state,
136			cl->tx_cb_queued);
137		i++;
138	}
139out:
140	mutex_unlock(&dev->device_lock);
141	ret = simple_read_from_buffer(ubuf, cnt, ppos, buf, pos);
142	kfree(buf);
143	return ret;
144}
145
146static const struct file_operations mei_dbgfs_fops_active = {
147	.open = simple_open,
148	.read = mei_dbgfs_read_active,
149	.llseek = generic_file_llseek,
150};
151
152static ssize_t mei_dbgfs_read_devstate(struct file *fp, char __user *ubuf,
153					size_t cnt, loff_t *ppos)
154{
155	struct mei_device *dev = fp->private_data;
156	const size_t bufsz = 1024;
157	char *buf = kzalloc(bufsz, GFP_KERNEL);
158	int pos = 0;
159	int ret;
160
161	if  (!buf)
162		return -ENOMEM;
163
164	pos += scnprintf(buf + pos, bufsz - pos, "dev: %s\n",
165			mei_dev_state_str(dev->dev_state));
166	pos += scnprintf(buf + pos, bufsz - pos, "hbm: %s\n",
167			mei_hbm_state_str(dev->hbm_state));
168
169	if (dev->hbm_state >= MEI_HBM_ENUM_CLIENTS &&
170	    dev->hbm_state <= MEI_HBM_STARTED) {
171		pos += scnprintf(buf + pos, bufsz - pos, "hbm features:\n");
172		pos += scnprintf(buf + pos, bufsz - pos, "\tPG: %01d\n",
173				 dev->hbm_f_pg_supported);
174		pos += scnprintf(buf + pos, bufsz - pos, "\tDC: %01d\n",
175				 dev->hbm_f_dc_supported);
176		pos += scnprintf(buf + pos, bufsz - pos, "\tIE: %01d\n",
177				 dev->hbm_f_ie_supported);
178		pos += scnprintf(buf + pos, bufsz - pos, "\tDOT: %01d\n",
179				 dev->hbm_f_dot_supported);
180		pos += scnprintf(buf + pos, bufsz - pos, "\tEV: %01d\n",
181				 dev->hbm_f_ev_supported);
182		pos += scnprintf(buf + pos, bufsz - pos, "\tFA: %01d\n",
183				 dev->hbm_f_fa_supported);
184		pos += scnprintf(buf + pos, bufsz - pos, "\tOS: %01d\n",
185				 dev->hbm_f_os_supported);
186	}
187
188	pos += scnprintf(buf + pos, bufsz - pos, "pg:  %s, %s\n",
189			mei_pg_is_enabled(dev) ? "ENABLED" : "DISABLED",
190			mei_pg_state_str(mei_pg_state(dev)));
191	ret = simple_read_from_buffer(ubuf, cnt, ppos, buf, pos);
192	kfree(buf);
193	return ret;
194}
195static const struct file_operations mei_dbgfs_fops_devstate = {
196	.open = simple_open,
197	.read = mei_dbgfs_read_devstate,
198	.llseek = generic_file_llseek,
199};
200
201static ssize_t mei_dbgfs_write_allow_fa(struct file *file,
202					const char __user *user_buf,
203					size_t count, loff_t *ppos)
204{
205	struct mei_device *dev;
206	int ret;
207
208	dev = container_of(file->private_data,
209			   struct mei_device, allow_fixed_address);
210
211	ret = debugfs_write_file_bool(file, user_buf, count, ppos);
212	if (ret < 0)
213		return ret;
214	dev->override_fixed_address = true;
215	return ret;
216}
217
218static const struct file_operations mei_dbgfs_fops_allow_fa = {
219	.open = simple_open,
220	.read = debugfs_read_file_bool,
221	.write = mei_dbgfs_write_allow_fa,
222	.llseek = generic_file_llseek,
223};
224
225/**
226 * mei_dbgfs_deregister - Remove the debugfs files and directories
227 *
228 * @dev: the mei device structure
229 */
230void mei_dbgfs_deregister(struct mei_device *dev)
231{
232	if (!dev->dbgfs_dir)
233		return;
234	debugfs_remove_recursive(dev->dbgfs_dir);
235	dev->dbgfs_dir = NULL;
236}
237
238/**
239 * mei_dbgfs_register - Add the debugfs files
240 *
241 * @dev: the mei device structure
242 * @name: the mei device name
243 *
244 * Return: 0 on success, <0 on failure.
245 */
246int mei_dbgfs_register(struct mei_device *dev, const char *name)
247{
248	struct dentry *dir, *f;
249
250	dir = debugfs_create_dir(name, NULL);
251	if (!dir)
252		return -ENOMEM;
253
254	dev->dbgfs_dir = dir;
255
256	f = debugfs_create_file("meclients", S_IRUSR, dir,
257				dev, &mei_dbgfs_fops_meclients);
258	if (!f) {
259		dev_err(dev->dev, "meclients: registration failed\n");
260		goto err;
261	}
262	f = debugfs_create_file("active", S_IRUSR, dir,
263				dev, &mei_dbgfs_fops_active);
264	if (!f) {
265		dev_err(dev->dev, "active: registration failed\n");
266		goto err;
267	}
268	f = debugfs_create_file("devstate", S_IRUSR, dir,
269				dev, &mei_dbgfs_fops_devstate);
270	if (!f) {
271		dev_err(dev->dev, "devstate: registration failed\n");
272		goto err;
273	}
274	f = debugfs_create_file("allow_fixed_address", S_IRUSR | S_IWUSR, dir,
275				&dev->allow_fixed_address,
276				&mei_dbgfs_fops_allow_fa);
277	if (!f) {
278		dev_err(dev->dev, "allow_fixed_address: registration failed\n");
279		goto err;
280	}
281	return 0;
282err:
283	mei_dbgfs_deregister(dev);
284	return -ENODEV;
285}
286