release/src-rt-6.x.4708/linux/linux-2.6.36/drivers/nubus/proc.c

   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 int nubus_proc_detach_device(struct nubus_dev *dev)
 147 {
 148         struct proc_dir_entry *e;
 149
 150         if ((e = dev->procdir)) {
 151                 if (atomic_read(&e->count))
 152                         return -EBUSY;
 153                 remove_proc_entry(e->name, proc_bus_nubus_dir);
 154                 dev->procdir = NULL;
 155         }
 156         return 0;
 157 }
 158 EXPORT_SYMBOL(nubus_proc_detach_device);
 159
 160 void __init proc_bus_nubus_add_devices(void)
 161 {
 162         struct nubus_dev *dev;
 163
 164         for(dev = nubus_devices; dev; dev = dev->next)
 165                 nubus_proc_attach_device(dev);
 166 }
 167
 168 void __init nubus_proc_init(void)
 169 {
 170         if (!MACH_IS_MAC)
 171                 return;
 172         proc_bus_nubus_dir = proc_mkdir("bus/nubus", NULL);
 173         proc_create("devices", 0, proc_bus_nubus_dir, &nubus_devices_proc_fops);
 174         proc_bus_nubus_add_devices();
 175 }