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 #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 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 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 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 */ 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 */ 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