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
54 /* if the driver is not enabled the list won't be consistent */
55 if (dev->dev_state != MEI_DEV_ENABLED)
56 goto out;
57
58 list_for_each_entry(me_cl, &dev->me_clients, list) {
59
60 if (mei_me_cl_get(me_cl)) {
61 pos += scnprintf(buf + pos, bufsz - pos,
62 "%2d|%2d|%3d|%pUl|%3d|%7d|%2d|%4d|\n",
63 i++, me_cl->client_id,
64 me_cl->props.fixed_address,
65 &me_cl->props.protocol_name,
66 me_cl->props.max_number_of_connections,
67 me_cl->props.max_msg_length,
68 me_cl->props.single_recv_buf,
69 atomic_read(&me_cl->refcnt.refcount));
70
71 mei_me_cl_put(me_cl);
72 }
73 }
74
75 out:
76 up_read(&dev->me_clients_rwsem);
77 ret = simple_read_from_buffer(ubuf, cnt, ppos, buf, pos);
78 kfree(buf);
79 return ret;
80 }
81
82 static const struct file_operations mei_dbgfs_fops_meclients = {
83 .open = simple_open,
84 .read = mei_dbgfs_read_meclients,
85 .llseek = generic_file_llseek,
86 };
87
mei_dbgfs_read_active(struct file * fp,char __user * ubuf,size_t cnt,loff_t * ppos)88 static ssize_t mei_dbgfs_read_active(struct file *fp, char __user *ubuf,
89 size_t cnt, loff_t *ppos)
90 {
91 struct mei_device *dev = fp->private_data;
92 struct mei_cl *cl;
93 const size_t bufsz = 1024;
94 char *buf;
95 int i = 0;
96 int pos = 0;
97 int ret;
98
99 if (!dev)
100 return -ENODEV;
101
102 buf = kzalloc(bufsz, GFP_KERNEL);
103 if (!buf)
104 return -ENOMEM;
105
106 pos += scnprintf(buf + pos, bufsz - pos,
107 " |me|host|state|rd|wr|\n");
108
109 mutex_lock(&dev->device_lock);
110
111 /* if the driver is not enabled the list won't be consistent */
112 if (dev->dev_state != MEI_DEV_ENABLED)
113 goto out;
114
115 list_for_each_entry(cl, &dev->file_list, link) {
116
117 pos += scnprintf(buf + pos, bufsz - pos,
118 "%2d|%2d|%4d|%5d|%2d|%2d|\n",
119 i, mei_cl_me_id(cl), cl->host_client_id, cl->state,
120 !list_empty(&cl->rd_completed), cl->writing_state);
121 i++;
122 }
123 out:
124 mutex_unlock(&dev->device_lock);
125 ret = simple_read_from_buffer(ubuf, cnt, ppos, buf, pos);
126 kfree(buf);
127 return ret;
128 }
129
130 static const struct file_operations mei_dbgfs_fops_active = {
131 .open = simple_open,
132 .read = mei_dbgfs_read_active,
133 .llseek = generic_file_llseek,
134 };
135
mei_dbgfs_read_devstate(struct file * fp,char __user * ubuf,size_t cnt,loff_t * ppos)136 static ssize_t mei_dbgfs_read_devstate(struct file *fp, char __user *ubuf,
137 size_t cnt, loff_t *ppos)
138 {
139 struct mei_device *dev = fp->private_data;
140 const size_t bufsz = 1024;
141 char *buf = kzalloc(bufsz, GFP_KERNEL);
142 int pos = 0;
143 int ret;
144
145 if (!buf)
146 return -ENOMEM;
147
148 pos += scnprintf(buf + pos, bufsz - pos, "dev: %s\n",
149 mei_dev_state_str(dev->dev_state));
150 pos += scnprintf(buf + pos, bufsz - pos, "hbm: %s\n",
151 mei_hbm_state_str(dev->hbm_state));
152
153 if (dev->hbm_state == MEI_HBM_STARTED) {
154 pos += scnprintf(buf + pos, bufsz - pos, "hbm features:\n");
155 pos += scnprintf(buf + pos, bufsz - pos, "\tPG: %01d\n",
156 dev->hbm_f_pg_supported);
157 pos += scnprintf(buf + pos, bufsz - pos, "\tDC: %01d\n",
158 dev->hbm_f_dc_supported);
159 pos += scnprintf(buf + pos, bufsz - pos, "\tDOT: %01d\n",
160 dev->hbm_f_dot_supported);
161 pos += scnprintf(buf + pos, bufsz - pos, "\tEV: %01d\n",
162 dev->hbm_f_ev_supported);
163 }
164
165 pos += scnprintf(buf + pos, bufsz - pos, "pg: %s, %s\n",
166 mei_pg_is_enabled(dev) ? "ENABLED" : "DISABLED",
167 mei_pg_state_str(mei_pg_state(dev)));
168 ret = simple_read_from_buffer(ubuf, cnt, ppos, buf, pos);
169 kfree(buf);
170 return ret;
171 }
172 static const struct file_operations mei_dbgfs_fops_devstate = {
173 .open = simple_open,
174 .read = mei_dbgfs_read_devstate,
175 .llseek = generic_file_llseek,
176 };
177
178 /**
179 * mei_dbgfs_deregister - Remove the debugfs files and directories
180 *
181 * @dev: the mei device structure
182 */
mei_dbgfs_deregister(struct mei_device * dev)183 void mei_dbgfs_deregister(struct mei_device *dev)
184 {
185 if (!dev->dbgfs_dir)
186 return;
187 debugfs_remove_recursive(dev->dbgfs_dir);
188 dev->dbgfs_dir = NULL;
189 }
190
191 /**
192 * mei_dbgfs_register - Add the debugfs files
193 *
194 * @dev: the mei device structure
195 * @name: the mei device name
196 *
197 * Return: 0 on success, <0 on failure.
198 */
mei_dbgfs_register(struct mei_device * dev,const char * name)199 int mei_dbgfs_register(struct mei_device *dev, const char *name)
200 {
201 struct dentry *dir, *f;
202
203 dir = debugfs_create_dir(name, NULL);
204 if (!dir)
205 return -ENOMEM;
206
207 dev->dbgfs_dir = dir;
208
209 f = debugfs_create_file("meclients", S_IRUSR, dir,
210 dev, &mei_dbgfs_fops_meclients);
211 if (!f) {
212 dev_err(dev->dev, "meclients: registration failed\n");
213 goto err;
214 }
215 f = debugfs_create_file("active", S_IRUSR, dir,
216 dev, &mei_dbgfs_fops_active);
217 if (!f) {
218 dev_err(dev->dev, "active: registration failed\n");
219 goto err;
220 }
221 f = debugfs_create_file("devstate", S_IRUSR, dir,
222 dev, &mei_dbgfs_fops_devstate);
223 if (!f) {
224 dev_err(dev->dev, "devstate: registration failed\n");
225 goto err;
226 }
227 f = debugfs_create_bool("allow_fixed_address", S_IRUSR | S_IWUSR, dir,
228 &dev->allow_fixed_address);
229 if (!f) {
230 dev_err(dev->dev, "allow_fixed_address: registration failed\n");
231 goto err;
232 }
233 return 0;
234 err:
235 mei_dbgfs_deregister(dev);
236 return -ENODEV;
237 }
238
239