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
mei_dbgfs_read_meclients(struct file * fp,char __user * ubuf,size_t cnt,loff_t * ppos)27 static 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
76 out:
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
83 static 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
mei_dbgfs_read_active(struct file * fp,char __user * ubuf,size_t cnt,loff_t * ppos)89 static 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 }
139 out:
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
146 static 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
mei_dbgfs_read_devstate(struct file * fp,char __user * ubuf,size_t cnt,loff_t * ppos)152 static 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 pos += scnprintf(buf + pos, bufsz - pos, "\tDR: %01d\n",
187 dev->hbm_f_dr_supported);
188 }
189
190 pos += scnprintf(buf + pos, bufsz - pos, "pg: %s, %s\n",
191 mei_pg_is_enabled(dev) ? "ENABLED" : "DISABLED",
192 mei_pg_state_str(mei_pg_state(dev)));
193 ret = simple_read_from_buffer(ubuf, cnt, ppos, buf, pos);
194 kfree(buf);
195 return ret;
196 }
197 static const struct file_operations mei_dbgfs_fops_devstate = {
198 .open = simple_open,
199 .read = mei_dbgfs_read_devstate,
200 .llseek = generic_file_llseek,
201 };
202
mei_dbgfs_write_allow_fa(struct file * file,const char __user * user_buf,size_t count,loff_t * ppos)203 static ssize_t mei_dbgfs_write_allow_fa(struct file *file,
204 const char __user *user_buf,
205 size_t count, loff_t *ppos)
206 {
207 struct mei_device *dev;
208 int ret;
209
210 dev = container_of(file->private_data,
211 struct mei_device, allow_fixed_address);
212
213 ret = debugfs_write_file_bool(file, user_buf, count, ppos);
214 if (ret < 0)
215 return ret;
216 dev->override_fixed_address = true;
217 return ret;
218 }
219
220 static const struct file_operations mei_dbgfs_fops_allow_fa = {
221 .open = simple_open,
222 .read = debugfs_read_file_bool,
223 .write = mei_dbgfs_write_allow_fa,
224 .llseek = generic_file_llseek,
225 };
226
227 /**
228 * mei_dbgfs_deregister - Remove the debugfs files and directories
229 *
230 * @dev: the mei device structure
231 */
mei_dbgfs_deregister(struct mei_device * dev)232 void mei_dbgfs_deregister(struct mei_device *dev)
233 {
234 if (!dev->dbgfs_dir)
235 return;
236 debugfs_remove_recursive(dev->dbgfs_dir);
237 dev->dbgfs_dir = NULL;
238 }
239
240 /**
241 * mei_dbgfs_register - Add the debugfs files
242 *
243 * @dev: the mei device structure
244 * @name: the mei device name
245 *
246 * Return: 0 on success, <0 on failure.
247 */
mei_dbgfs_register(struct mei_device * dev,const char * name)248 int mei_dbgfs_register(struct mei_device *dev, const char *name)
249 {
250 struct dentry *dir, *f;
251
252 dir = debugfs_create_dir(name, NULL);
253 if (!dir)
254 return -ENOMEM;
255
256 dev->dbgfs_dir = dir;
257
258 f = debugfs_create_file("meclients", S_IRUSR, dir,
259 dev, &mei_dbgfs_fops_meclients);
260 if (!f) {
261 dev_err(dev->dev, "meclients: registration failed\n");
262 goto err;
263 }
264 f = debugfs_create_file("active", S_IRUSR, dir,
265 dev, &mei_dbgfs_fops_active);
266 if (!f) {
267 dev_err(dev->dev, "active: registration failed\n");
268 goto err;
269 }
270 f = debugfs_create_file("devstate", S_IRUSR, dir,
271 dev, &mei_dbgfs_fops_devstate);
272 if (!f) {
273 dev_err(dev->dev, "devstate: registration failed\n");
274 goto err;
275 }
276 f = debugfs_create_file("allow_fixed_address", S_IRUSR | S_IWUSR, dir,
277 &dev->allow_fixed_address,
278 &mei_dbgfs_fops_allow_fa);
279 if (!f) {
280 dev_err(dev->dev, "allow_fixed_address: registration failed\n");
281 goto err;
282 }
283 return 0;
284 err:
285 mei_dbgfs_deregister(dev);
286 return -ENODEV;
287 }
288
289