drivers/pci/hotplug/cpqphp_sysfs.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Compaq Hot Plug Controller Driver
   4  *
   5  * Copyright (C) 1995,2001 Compaq Computer Corporation
   6  * Copyright (C) 2001,2003 Greg Kroah-Hartman (greg@kroah.com)
   7  * Copyright (C) 2001 IBM Corp.
   8  *
   9  * All rights reserved.
  10  *
  11  * Send feedback to <greg@kroah.com>
  12  *
  13  */
  14
  15 #include <linux/module.h>
  16 #include <linux/kernel.h>
  17 #include <linux/slab.h>
  18 #include <linux/types.h>
  19 #include <linux/proc_fs.h>
  20 #include <linux/workqueue.h>
  21 #include <linux/pci.h>
  22 #include <linux/pci_hotplug.h>
  23 #include <linux/mutex.h>
  24 #include <linux/debugfs.h>
  25 #include "cpqphp.h"
  26
  27 static DEFINE_MUTEX(cpqphp_mutex);
  28 static int show_ctrl(struct controller *ctrl, char *buf)
  29 {
  30         char *out = buf;
  31         int index;
  32         struct pci_resource *res;
  33
  34         out += sprintf(buf, "Free resources: memory\n");
  35         index = 11;
  36         res = ctrl->mem_head;
  37         while (res && index--) {
  38                 out += sprintf(out, "start = %8.8x, length = %8.8x\n", res->base, res->length);
  39                 res = res->next;
  40         }
  41         out += sprintf(out, "Free resources: prefetchable memory\n");
  42         index = 11;
  43         res = ctrl->p_mem_head;
  44         while (res && index--) {
  45                 out += sprintf(out, "start = %8.8x, length = %8.8x\n", res->base, res->length);
  46                 res = res->next;
  47         }
  48         out += sprintf(out, "Free resources: IO\n");
  49         index = 11;
  50         res = ctrl->io_head;
  51         while (res && index--) {
  52                 out += sprintf(out, "start = %8.8x, length = %8.8x\n", res->base, res->length);
  53                 res = res->next;
  54         }
  55         out += sprintf(out, "Free resources: bus numbers\n");
  56         index = 11;
  57         res = ctrl->bus_head;
  58         while (res && index--) {
  59                 out += sprintf(out, "start = %8.8x, length = %8.8x\n", res->base, res->length);
  60                 res = res->next;
  61         }
  62
  63         return out - buf;
  64 }
  65
  66 static int show_dev(struct controller *ctrl, char *buf)
  67 {
  68         char *out = buf;
  69         int index;
  70         struct pci_resource *res;
  71         struct pci_func *new_slot;
  72         struct slot *slot;
  73
  74         slot = ctrl->slot;
  75
  76         while (slot) {
  77                 new_slot = cpqhp_slot_find(slot->bus, slot->device, 0);
  78                 if (!new_slot)
  79                         break;
  80                 out += sprintf(out, "assigned resources: memory\n");
  81                 index = 11;
  82                 res = new_slot->mem_head;
  83                 while (res && index--) {
  84                         out += sprintf(out, "start = %8.8x, length = %8.8x\n", res->base, res->length);
  85                         res = res->next;
  86                 }
  87                 out += sprintf(out, "assigned resources: prefetchable memory\n");
  88                 index = 11;
  89                 res = new_slot->p_mem_head;
  90                 while (res && index--) {
  91                         out += sprintf(out, "start = %8.8x, length = %8.8x\n", res->base, res->length);
  92                         res = res->next;
  93                 }
  94                 out += sprintf(out, "assigned resources: IO\n");
  95                 index = 11;
  96                 res = new_slot->io_head;
  97                 while (res && index--) {
  98                         out += sprintf(out, "start = %8.8x, length = %8.8x\n", res->base, res->length);
  99                         res = res->next;
 100                 }
 101                 out += sprintf(out, "assigned resources: bus numbers\n");
 102                 index = 11;
 103                 res = new_slot->bus_head;
 104                 while (res && index--) {
 105                         out += sprintf(out, "start = %8.8x, length = %8.8x\n", res->base, res->length);
 106                         res = res->next;
 107                 }
 108                 slot = slot->next;
 109         }
 110
 111         return out - buf;
 112 }
 113
 114 static int spew_debug_info(struct controller *ctrl, char *data, int size)
 115 {
 116         int used;
 117
 118         used = size - show_ctrl(ctrl, data);
 119         used = (size - used) - show_dev(ctrl, &data[used]);
 120         return used;
 121 }
 122
 123 struct ctrl_dbg {
 124         int size;
 125         char *data;
 126 };
 127
 128 #define MAX_OUTPUT      (4*PAGE_SIZE)
 129
 130 static int open(struct inode *inode, struct file *file)
 131 {
 132         struct controller *ctrl = inode->i_private;
 133         struct ctrl_dbg *dbg;
 134         int retval = -ENOMEM;
 135
 136         mutex_lock(&cpqphp_mutex);
 137         dbg = kmalloc(sizeof(*dbg), GFP_KERNEL);
 138         if (!dbg)
 139                 goto exit;
 140         dbg->data = kmalloc(MAX_OUTPUT, GFP_KERNEL);
 141         if (!dbg->data) {
 142                 kfree(dbg);
 143                 goto exit;
 144         }
 145         dbg->size = spew_debug_info(ctrl, dbg->data, MAX_OUTPUT);
 146         file->private_data = dbg;
 147         retval = 0;
 148 exit:
 149         mutex_unlock(&cpqphp_mutex);
 150         return retval;
 151 }
 152
 153 static loff_t lseek(struct file *file, loff_t off, int whence)
 154 {
 155         struct ctrl_dbg *dbg = file->private_data;
 156         return fixed_size_llseek(file, off, whence, dbg->size);
 157 }
 158
 159 static ssize_t read(struct file *file, char __user *buf,
 160                     size_t nbytes, loff_t *ppos)
 161 {
 162         struct ctrl_dbg *dbg = file->private_data;
 163         return simple_read_from_buffer(buf, nbytes, ppos, dbg->data, dbg->size);
 164 }
 165
 166 static int release(struct inode *inode, struct file *file)
 167 {
 168         struct ctrl_dbg *dbg = file->private_data;
 169
 170         kfree(dbg->data);
 171         kfree(dbg);
 172         return 0;
 173 }
 174
 175 static const struct file_operations debug_ops = {
 176         .owner = THIS_MODULE,
 177         .open = open,
 178         .llseek = lseek,
 179         .read = read,
 180         .release = release,
 181 };
 182
 183 static struct dentry *root;
 184
 185 void cpqhp_initialize_debugfs(void)
 186 {
 187         if (!root)
 188                 root = debugfs_create_dir("cpqhp", NULL);
 189 }
 190
 191 void cpqhp_shutdown_debugfs(void)
 192 {
 193         debugfs_remove(root);
 194 }
 195
 196 void cpqhp_create_debugfs_files(struct controller *ctrl)
 197 {
 198         ctrl->dentry = debugfs_create_file(dev_name(&ctrl->pci_dev->dev),
 199                                            S_IRUGO, root, ctrl, &debug_ops);
 200 }
 201
 202 void cpqhp_remove_debugfs_files(struct controller *ctrl)
 203 {
 204         debugfs_remove(ctrl->dentry);
 205         ctrl->dentry = NULL;
 206 }
 207