linux/drivers/nubus/proc.c
<<
>>
Prefs
   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
  31static int
  32nubus_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
  49static int nubus_devices_proc_open(struct inode *inode, struct file *file)
  50{
  51        return single_open(file, nubus_devices_proc_show, NULL);
  52}
  53
  54static const struct file_operations nubus_devices_proc_fops = {
  55        .open           = nubus_devices_proc_open,
  56        .read           = seq_read,
  57        .llseek         = seq_lseek,
  58        .release        = single_release,
  59};
  60
  61static struct proc_dir_entry *proc_bus_nubus_dir;
  62
  63static const struct file_operations nubus_proc_subdir_fops = {
  64#warning Need to set some I/O handlers here
  65};
  66
  67static void nubus_proc_subdir(struct nubus_dev* dev,
  68                              struct proc_dir_entry* parent,
  69                              struct nubus_dir* dir)
  70{
  71        struct nubus_dirent ent;
  72
  73        /* Some of these are directories, others aren't */
  74        while (nubus_readdir(dir, &ent) != -1) {
  75                char name[8];
  76                struct proc_dir_entry* e;
  77                
  78                sprintf(name, "%x", ent.type);
  79                e = proc_create(name, S_IFREG | S_IRUGO | S_IWUSR, parent,
  80                                &nubus_proc_subdir_fops);
  81                if (!e)
  82                        return;
  83        }
  84}
  85
  86/* Can't do this recursively since the root directory is structured
  87   somewhat differently from the subdirectories */
  88static void nubus_proc_populate(struct nubus_dev* dev,
  89                                struct proc_dir_entry* parent,
  90                                struct nubus_dir* root)
  91{
  92        struct nubus_dirent ent;
  93
  94        /* We know these are all directories (board resource + one or
  95           more functional resources) */
  96        while (nubus_readdir(root, &ent) != -1) {
  97                char name[8];
  98                struct proc_dir_entry* e;
  99                struct nubus_dir dir;
 100                
 101                sprintf(name, "%x", ent.type);
 102                e = proc_mkdir(name, parent);
 103                if (!e) return;
 104
 105                /* And descend */
 106                if (nubus_get_subdir(&ent, &dir) == -1) {
 107                        /* This shouldn't happen */
 108                        printk(KERN_ERR "NuBus root directory node %x:%x has no subdir!\n",
 109                               dev->board->slot, ent.type);
 110                        continue;
 111                } else {
 112                        nubus_proc_subdir(dev, e, &dir);
 113                }
 114        }
 115}
 116
 117int nubus_proc_attach_device(struct nubus_dev *dev)
 118{
 119        struct proc_dir_entry *e;
 120        struct nubus_dir root;
 121        char name[8];
 122
 123        if (dev == NULL) {
 124                printk(KERN_ERR
 125                       "NULL pointer in nubus_proc_attach_device, shoot the programmer!\n");
 126                return -1;
 127        }
 128                
 129        if (dev->board == NULL) {
 130                printk(KERN_ERR
 131                       "NULL pointer in nubus_proc_attach_device, shoot the programmer!\n");
 132                printk("dev = %p, dev->board = %p\n", dev, dev->board);
 133                return -1;
 134        }
 135                
 136        /* Create a directory */
 137        sprintf(name, "%x", dev->board->slot);
 138        e = dev->procdir = proc_mkdir(name, proc_bus_nubus_dir);
 139        if (!e)
 140                return -ENOMEM;
 141
 142        /* Now recursively populate it with files */
 143        nubus_get_root_dir(dev->board, &root);
 144        nubus_proc_populate(dev, e, &root);
 145
 146        return 0;
 147}
 148EXPORT_SYMBOL(nubus_proc_attach_device);
 149
 150/*
 151 * /proc/nubus stuff
 152 */
 153static int nubus_proc_show(struct seq_file *m, void *v)
 154{
 155        const struct nubus_board *board = v;
 156
 157        /* Display header on line 1 */
 158        if (v == SEQ_START_TOKEN)
 159                seq_puts(m, "Nubus devices found:\n");
 160        else
 161                seq_printf(m, "Slot %X: %s\n", board->slot, board->name);
 162        return 0;
 163}
 164
 165static void *nubus_proc_start(struct seq_file *m, loff_t *_pos)
 166{
 167        struct nubus_board *board;
 168        unsigned pos;
 169
 170        if (*_pos > LONG_MAX)
 171                return NULL;
 172        pos = *_pos;
 173        if (pos == 0)
 174                return SEQ_START_TOKEN;
 175        for (board = nubus_boards; board; board = board->next)
 176                if (--pos == 0)
 177                        break;
 178        return board;
 179}
 180
 181static void *nubus_proc_next(struct seq_file *p, void *v, loff_t *_pos)
 182{
 183        /* Walk the list of NuBus boards */
 184        struct nubus_board *board = v;
 185
 186        ++*_pos;
 187        if (v == SEQ_START_TOKEN)
 188                board = nubus_boards;
 189        else if (board)
 190                board = board->next;
 191        return board;
 192}
 193
 194static void nubus_proc_stop(struct seq_file *p, void *v)
 195{
 196}
 197
 198static const struct seq_operations nubus_proc_seqops = {
 199        .start  = nubus_proc_start,
 200        .next   = nubus_proc_next,
 201        .stop   = nubus_proc_stop,
 202        .show   = nubus_proc_show,
 203};
 204
 205static int nubus_proc_open(struct inode *inode, struct file *file)
 206{
 207        return seq_open(file, &nubus_proc_seqops);
 208}
 209
 210static const struct file_operations nubus_proc_fops = {
 211        .open           = nubus_proc_open,
 212        .read           = seq_read,
 213        .llseek         = seq_lseek,
 214        .release        = seq_release,
 215};
 216
 217void __init proc_bus_nubus_add_devices(void)
 218{
 219        struct nubus_dev *dev;
 220        
 221        for(dev = nubus_devices; dev; dev = dev->next)
 222                nubus_proc_attach_device(dev);
 223}
 224
 225void __init nubus_proc_init(void)
 226{
 227        proc_create("nubus", 0, NULL, &nubus_proc_fops);
 228        if (!MACH_IS_MAC)
 229                return;
 230        proc_bus_nubus_dir = proc_mkdir("bus/nubus", NULL);
 231        proc_create("devices", 0, proc_bus_nubus_dir, &nubus_devices_proc_fops);
 232        proc_bus_nubus_add_devices();
 233}
 234
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.