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