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 #include <linux/pci.h>
  21
  22 #include <linux/mei.h>
  23
  24 #include "mei_dev.h"
  25 #include "hw.h"
  26
  27 static int mei_dbgfs_open(struct inode *inode, struct file *file)
  28 {
  29         file->private_data = inode->i_private;
  30         return 0;
  31 }
  32
  33 static ssize_t mei_dbgfs_read_meclients(struct file *fp, char __user *ubuf,
  34                                         size_t cnt, loff_t *ppos)
  35 {
  36         struct mei_device *dev = fp->private_data;
  37         struct mei_me_client *cl;
  38         const size_t bufsz = 1024;
  39         char *buf = kzalloc(bufsz, GFP_KERNEL);
  40         int i;
  41         int pos = 0;
  42         int ret;
  43
  44         if  (!buf)
  45                 return -ENOMEM;
  46
  47         pos += scnprintf(buf + pos, bufsz - pos,
  48                         "  |id|addr|         UUID                       |con|msg len|\n");
  49
  50         mutex_lock(&dev->device_lock);
  51
  52         /*  if the driver is not enabled the list won't b consitent */
  53         if (dev->dev_state != MEI_DEV_ENABLED)
  54                 goto out;
  55
  56         for (i = 0; i < dev->me_clients_num; i++) {
  57                 cl = &dev->me_clients[i];
  58
  59                 /* skip me clients that cannot be connected */
  60                 if (cl->props.max_number_of_connections == 0)
  61                         continue;
  62
  63                 pos += scnprintf(buf + pos, bufsz - pos,
  64                         "%2d|%2d|%4d|%pUl|%3d|%7d|\n",
  65                         i, cl->client_id,
  66                         cl->props.fixed_address,
  67                         &cl->props.protocol_name,
  68                         cl->props.max_number_of_connections,
  69                         cl->props.max_msg_length);
  70         }
  71 out:
  72         mutex_unlock(&dev->device_lock);
  73         ret = simple_read_from_buffer(ubuf, cnt, ppos, buf, pos);
  74         kfree(buf);
  75         return ret;
  76 }
  77
  78 static const struct file_operations mei_dbgfs_fops_meclients = {
  79         .open = mei_dbgfs_open,
  80         .read = mei_dbgfs_read_meclients,
  81         .llseek = generic_file_llseek,
  82 };
  83
  84 static ssize_t mei_dbgfs_read_devstate(struct file *fp, char __user *ubuf,
  85                                         size_t cnt, loff_t *ppos)
  86 {
  87         struct mei_device *dev = fp->private_data;
  88         const size_t bufsz = 1024;
  89         char *buf = kzalloc(bufsz, GFP_KERNEL);
  90         int pos = 0;
  91         int ret;
  92
  93         if  (!buf)
  94                 return -ENOMEM;
  95
  96         pos += scnprintf(buf + pos, bufsz - pos, "%s\n",
  97                         mei_dev_state_str(dev->dev_state));
  98         ret = simple_read_from_buffer(ubuf, cnt, ppos, buf, pos);
  99         kfree(buf);
 100         return ret;
 101 }
 102 static const struct file_operations mei_dbgfs_fops_devstate = {
 103         .open = mei_dbgfs_open,
 104         .read = mei_dbgfs_read_devstate,
 105         .llseek = generic_file_llseek,
 106 };
 107
 108 /**
 109  * mei_dbgfs_deregister - Remove the debugfs files and directories
 110  * @mei - pointer to mei device private dat
 111  */
 112 void mei_dbgfs_deregister(struct mei_device *dev)
 113 {
 114         if (!dev->dbgfs_dir)
 115                 return;
 116         debugfs_remove_recursive(dev->dbgfs_dir);
 117         dev->dbgfs_dir = NULL;
 118 }
 119
 120 /**
 121  * Add the debugfs files
 122  *
 123  */
 124 int mei_dbgfs_register(struct mei_device *dev, const char *name)
 125 {
 126         struct dentry *dir, *f;
 127         dir = debugfs_create_dir(name, NULL);
 128         if (!dir)
 129                 return -ENOMEM;
 130
 131         f = debugfs_create_file("meclients", S_IRUSR, dir,
 132                                 dev, &mei_dbgfs_fops_meclients);
 133         if (!f) {
 134                 dev_err(&dev->pdev->dev, "meclients: registration failed\n");
 135                 goto err;
 136         }
 137         f = debugfs_create_file("devstate", S_IRUSR, dir,
 138                                 dev, &mei_dbgfs_fops_devstate);
 139         if (!f) {
 140                 dev_err(&dev->pdev->dev, "devstate: registration failed\n");
 141                 goto err;
 142         }
 143         dev->dbgfs_dir = dir;
 144         return 0;
 145 err:
 146         mei_dbgfs_deregister(dev);
 147         return -ENODEV;
 148 }
 149