Add the rt linux 4.1.3-rt3 as base
[kvmfornfv.git] / kernel / drivers / misc / mei / debugfs.c
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
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
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, cl->me_client_id, 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
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         pos += scnprintf(buf + pos, bufsz - pos, "pg:  %s, %s\n",
153                         mei_pg_is_enabled(dev) ? "ENABLED" : "DISABLED",
154                         mei_pg_state_str(mei_pg_state(dev)));
155         ret = simple_read_from_buffer(ubuf, cnt, ppos, buf, pos);
156         kfree(buf);
157         return ret;
158 }
159 static const struct file_operations mei_dbgfs_fops_devstate = {
160         .open = simple_open,
161         .read = mei_dbgfs_read_devstate,
162         .llseek = generic_file_llseek,
163 };
164
165 /**
166  * mei_dbgfs_deregister - Remove the debugfs files and directories
167  *
168  * @dev: the mei device structure
169  */
170 void mei_dbgfs_deregister(struct mei_device *dev)
171 {
172         if (!dev->dbgfs_dir)
173                 return;
174         debugfs_remove_recursive(dev->dbgfs_dir);
175         dev->dbgfs_dir = NULL;
176 }
177
178 /**
179  * mei_dbgfs_register - Add the debugfs files
180  *
181  * @dev: the mei device structure
182  * @name: the mei device name
183  *
184  * Return: 0 on success, <0 on failure.
185  */
186 int mei_dbgfs_register(struct mei_device *dev, const char *name)
187 {
188         struct dentry *dir, *f;
189
190         dir = debugfs_create_dir(name, NULL);
191         if (!dir)
192                 return -ENOMEM;
193
194         f = debugfs_create_file("meclients", S_IRUSR, dir,
195                                 dev, &mei_dbgfs_fops_meclients);
196         if (!f) {
197                 dev_err(dev->dev, "meclients: registration failed\n");
198                 goto err;
199         }
200         f = debugfs_create_file("active", S_IRUSR, dir,
201                                 dev, &mei_dbgfs_fops_active);
202         if (!f) {
203                 dev_err(dev->dev, "meclients: registration failed\n");
204                 goto err;
205         }
206         f = debugfs_create_file("devstate", S_IRUSR, dir,
207                                 dev, &mei_dbgfs_fops_devstate);
208         if (!f) {
209                 dev_err(dev->dev, "devstate: registration failed\n");
210                 goto err;
211         }
212         dev->dbgfs_dir = dir;
213         return 0;
214 err:
215         mei_dbgfs_deregister(dev);
216         return -ENODEV;
217 }
218