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 208