1 /* drivers/nubus/proc.c: Proc FS interface for NuBus. 2 3 By David Huggins-Daines <dhd@debian.org> 4 5 Much code and many ideas from drivers/pci/proc.c: 6 Copyright (c) 1997, 1998 Martin Mares <mj@atrey.karlin.mff.cuni.cz> 7 8 This is initially based on the Zorro and PCI interfaces. However, 9 it works somewhat differently. The intent is to provide a 10 structure in /proc analogous to the structure of the NuBus ROM 11 resources. 12 13 Therefore each NuBus device is in fact a directory, which may in 14 turn contain subdirectories. The "files" correspond to NuBus 15 resource records. For those types of records which we know how to 16 convert to formats that are meaningful to userspace (mostly just 17 icons) these files will provide "cooked" data. Otherwise they will 18 simply provide raw access (read-only of course) to the ROM. */ 19 20 #include <linux/types.h> 21 #include <linux/kernel.h> 22 #include <linux/nubus.h> 23 #include <linux/proc_fs.h> 24 #include <linux/seq_file.h> 25 #include <linux/init.h> 26 #include <linux/module.h> 27 28 #include <asm/uaccess.h> 29 #include <asm/byteorder.h> 30 31 static int 32 nubus_devices_proc_show(struct seq_file *m, void *v) 33 { 34 struct nubus_dev *dev = nubus_devices; 35 36 while (dev) { 37 seq_printf(m, "%x\t%04x %04x %04x %04x", 38 dev->board->slot, 39 dev->category, 40 dev->type, 41 dev->dr_sw, 42 dev->dr_hw); 43 seq_printf(m, "\t%08lx\n", dev->board->slot_addr); 44 dev = dev->next; 45 } 46 return 0; 47 } 48 49 static int nubus_devices_proc_open(struct inode *inode, struct file *file) 50 { 51 return single_open(file, nubus_devices_proc_show, NULL); 52 } 53 54 static const struct file_operations nubus_devices_proc_fops = { 55 .owner = THIS_MODULE, 56 .open = nubus_devices_proc_open, 57 .read = seq_read, 58 .llseek = seq_lseek, 59 .release = single_release, 60 }; 61 62 static struct proc_dir_entry *proc_bus_nubus_dir; 63 64 static void nubus_proc_subdir(struct nubus_dev* dev, 65 struct proc_dir_entry* parent, 66 struct nubus_dir* dir) 67 { 68 struct nubus_dirent ent; 69 70 /* Some of these are directories, others aren't */ 71 while (nubus_readdir(dir, &ent) != -1) { 72 char name[8]; 73 struct proc_dir_entry* e; 74 75 sprintf(name, "%x", ent.type); 76 e = create_proc_entry(name, S_IFREG | S_IRUGO | 77 S_IWUSR, parent); 78 if (!e) return; 79 } 80 } 81 82 /* Can't do this recursively since the root directory is structured 83 somewhat differently from the subdirectories */ 84 static void nubus_proc_populate(struct nubus_dev* dev, 85 struct proc_dir_entry* parent, 86 struct nubus_dir* root) 87 { 88 struct nubus_dirent ent; 89 90 /* We know these are all directories (board resource + one or 91 more functional resources) */ 92 while (nubus_readdir(root, &ent) != -1) { 93 char name[8]; 94 struct proc_dir_entry* e; 95 struct nubus_dir dir; 96 97 sprintf(name, "%x", ent.type); 98 e = proc_mkdir(name, parent); 99 if (!e) return; 100 101 /* And descend */ 102 if (nubus_get_subdir(&ent, &dir) == -1) { 103 /* This shouldn't happen */ 104 printk(KERN_ERR "NuBus root directory node %x:%x has no subdir!\n", 105 dev->board->slot, ent.type); 106 continue; 107 } else { 108 nubus_proc_subdir(dev, e, &dir); 109 } 110 } 111 } 112 113 int nubus_proc_attach_device(struct nubus_dev *dev) 114 { 115 struct proc_dir_entry *e; 116 struct nubus_dir root; 117 char name[8]; 118 119 if (dev == NULL) { 120 printk(KERN_ERR 121 "NULL pointer in nubus_proc_attach_device, shoot the programmer!\n"); 122 return -1; 123 } 124 125 if (dev->board == NULL) { 126 printk(KERN_ERR 127 "NULL pointer in nubus_proc_attach_device, shoot the programmer!\n"); 128 printk("dev = %p, dev->board = %p\n", dev, dev->board); 129 return -1; 130 } 131 132 /* Create a directory */ 133 sprintf(name, "%x", dev->board->slot); 134 e = dev->procdir = proc_mkdir(name, proc_bus_nubus_dir); 135 if (!e) 136 return -ENOMEM; 137 138 /* Now recursively populate it with files */ 139 nubus_get_root_dir(dev->board, &root); 140 nubus_proc_populate(dev, e, &root); 141 142 return 0; 143 } 144 EXPORT_SYMBOL(nubus_proc_attach_device); 145 146 /* FIXME: this is certainly broken! */ 147 int nubus_proc_detach_device(struct nubus_dev *dev) 148 { 149 struct proc_dir_entry *e; 150 151 if ((e = dev->procdir)) { 152 if (atomic_read(&e->count)) 153 return -EBUSY; 154 remove_proc_entry(e->name, proc_bus_nubus_dir); 155 dev->procdir = NULL; 156 } 157 return 0; 158 } 159 EXPORT_SYMBOL(nubus_proc_detach_device); 160 161 void __init proc_bus_nubus_add_devices(void) 162 { 163 struct nubus_dev *dev; 164 165 for(dev = nubus_devices; dev; dev = dev->next) 166 nubus_proc_attach_device(dev); 167 } 168 169 void __init nubus_proc_init(void) 170 { 171 if (!MACH_IS_MAC) 172 return; 173 proc_bus_nubus_dir = proc_mkdir("bus/nubus", NULL); 174 proc_create("devices", 0, proc_bus_nubus_dir, &nubus_devices_proc_fops); 175 proc_bus_nubus_add_devices(); 176 } 177