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