kernel/resource.c

   1 /*
   2  *      linux/kernel/resource.c
   3  *
   4  * Copyright (C) 1999   Linus Torvalds
   5  * Copyright (C) 1999   Martin Mares <mj@ucw.cz>
   6  *
   7  * Arbitrary resource management.
   8  */
   9
  10 #include <linux/config.h>
  11 #include <linux/sched.h>
  12 #include <linux/errno.h>
  13 #include <linux/ioport.h>
  14 #include <linux/init.h>
  15 #include <linux/slab.h>
  16 #include <linux/spinlock.h>
  17 #include <linux/fs.h>
  18 #include <linux/proc_fs.h>
  19 #include <linux/seq_file.h>
  20 #include <asm/io.h>
  21
  22
  23 struct resource ioport_resource = {
  24         .name   = "PCI IO",
  25         .start  = 0x0000,
  26         .end    = IO_SPACE_LIMIT,
  27         .flags  = IORESOURCE_IO,
  28 };
  29
  30 struct resource iomem_resource = {
  31         .name   = "PCI mem",
  32         .start  = 0UL,
  33         .end    = ~0UL,
  34         .flags  = IORESOURCE_MEM,
  35 };
  36
  37 static rwlock_t resource_lock = RW_LOCK_UNLOCKED;
  38
  39 #ifdef CONFIG_PROC_FS
  40
  41 #define MAX_IORES_LEVEL         5
  42
  43 /*
  44  * do_resource_list():
  45  * for reports of /proc/ioports and /proc/iomem;
  46  * do current entry, then children, then siblings;
  47  */
  48 static int do_resource_list(struct seq_file *m, struct resource *res, const char *fmt, int level)
  49 {
  50         while (res) {
  51                 const char *name;
  52
  53                 name = res->name ? res->name : "<BAD>";
  54                 if (level > MAX_IORES_LEVEL)
  55                         level = MAX_IORES_LEVEL;
  56                 seq_printf (m, fmt + 2 * MAX_IORES_LEVEL - 2 * level,
  57                                 res->start, res->end, name);
  58
  59                 if (res->child)
  60                         do_resource_list(m, res->child, fmt, level + 1);
  61
  62                 res = res->sibling;
  63         }
  64
  65         return 0;
  66 }
  67
  68 static int ioresources_show(struct seq_file *m, void *v)
  69 {
  70         struct resource *root = m->private;
  71         char *fmt;
  72         int retval;
  73
  74         fmt = root->end < 0x10000
  75                 ? "          %04lx-%04lx : %s\n"
  76                 : "          %08lx-%08lx : %s\n";
  77         read_lock(&resource_lock);
  78         retval = do_resource_list(m, root->child, fmt, 0);
  79         read_unlock(&resource_lock);
  80         return retval;
  81 }
  82
  83 static int ioresources_open(struct file *file, struct resource *root)
  84 {
  85         return single_open(file, ioresources_show, root);
  86 }
  87
  88 static int ioports_open(struct inode *inode, struct file *file)
  89 {
  90         return ioresources_open(file, &ioport_resource);
  91 }
  92
  93 static struct file_operations proc_ioports_operations = {
  94         .open           = ioports_open,
  95         .read           = seq_read,
  96         .llseek         = seq_lseek,
  97         .release        = single_release,
  98 };
  99
 100 static int iomem_open(struct inode *inode, struct file *file)
 101 {
 102         return ioresources_open(file, &iomem_resource);
 103 }
 104
 105 static struct file_operations proc_iomem_operations = {
 106         .open           = iomem_open,
 107         .read           = seq_read,
 108         .llseek         = seq_lseek,
 109         .release        = single_release,
 110 };
 111
 112 static int __init ioresources_init(void)
 113 {
 114         struct proc_dir_entry *entry;
 115
 116         entry = create_proc_entry("ioports", 0, NULL);
 117         if (entry)
 118                 entry->proc_fops = &proc_ioports_operations;
 119         entry = create_proc_entry("iomem", 0, NULL);
 120         if (entry)
 121                 entry->proc_fops = &proc_iomem_operations;
 122         return 0;
 123 }
 124 __initcall(ioresources_init);
 125
 126 #endif /* CONFIG_PROC_FS */
 127
 128 /* Return the conflict entry if you can't request it */
 129 static struct resource * __request_resource(struct resource *root, struct resource *new)
 130 {
 131         unsigned long start = new->start;
 132         unsigned long end = new->end;
 133         struct resource *tmp, **p;
 134
 135         if (end < start)
 136                 return root;
 137         if (start < root->start)
 138                 return root;
 139         if (end > root->end)
 140                 return root;
 141         p = &root->child;
 142         for (;;) {
 143                 tmp = *p;
 144                 if (!tmp || tmp->start > end) {
 145                         new->sibling = tmp;
 146                         *p = new;
 147                         new->parent = root;
 148                         return NULL;
 149                 }
 150                 p = &tmp->sibling;
 151                 if (tmp->end < start)
 152                         continue;
 153                 return tmp;
 154         }
 155 }
 156
 157 static int __release_resource(struct resource *old)
 158 {
 159         struct resource *tmp, **p;
 160
 161         p = &old->parent->child;
 162         for (;;) {
 163                 tmp = *p;
 164                 if (!tmp)
 165                         break;
 166                 if (tmp == old) {
 167                         *p = tmp->sibling;
 168                         old->parent = NULL;
 169                         return 0;
 170                 }
 171                 p = &tmp->sibling;
 172         }
 173         return -EINVAL;
 174 }
 175
 176 int request_resource(struct resource *root, struct resource *new)
 177 {
 178         struct resource *conflict;
 179
 180         write_lock(&resource_lock);
 181         conflict = __request_resource(root, new);
 182         write_unlock(&resource_lock);
 183         return conflict ? -EBUSY : 0;
 184 }
 185
 186 int release_resource(struct resource *old)
 187 {
 188         int retval;
 189
 190         write_lock(&resource_lock);
 191         retval = __release_resource(old);
 192         write_unlock(&resource_lock);
 193         return retval;
 194 }
 195
 196 /*
 197  * Find empty slot in the resource tree given range and alignment.
 198  */
 199 static int find_resource(struct resource *root, struct resource *new,
 200                          unsigned long size,
 201                          unsigned long min, unsigned long max,
 202                          unsigned long align,
 203                          void (*alignf)(void *, struct resource *,
 204                                         unsigned long, unsigned long),
 205                          void *alignf_data)
 206 {
 207         struct resource *this = root->child;
 208
 209         new->start = root->start;
 210         for(;;) {
 211                 if (this)
 212                         new->end = this->start;
 213                 else
 214                         new->end = root->end;
 215                 if (new->start < min)
 216                         new->start = min;
 217                 if (new->end > max)
 218                         new->end = max;
 219                 new->start = (new->start + align - 1) & ~(align - 1);
 220                 if (alignf)
 221                         alignf(alignf_data, new, size, align);
 222                 if (new->start < new->end && new->end - new->start + 1 >= size) {
 223                         new->end = new->start + size - 1;
 224                         return 0;
 225                 }
 226                 if (!this)
 227                         break;
 228                 new->start = this->end + 1;
 229                 this = this->sibling;
 230         }
 231         return -EBUSY;
 232 }
 233
 234 /*
 235  * Allocate empty slot in the resource tree given range and alignment.
 236  */
 237 int allocate_resource(struct resource *root, struct resource *new,
 238                       unsigned long size,
 239                       unsigned long min, unsigned long max,
 240                       unsigned long align,
 241                       void (*alignf)(void *, struct resource *,
 242                                      unsigned long, unsigned long),
 243                       void *alignf_data)
 244 {
 245         int err;
 246
 247         write_lock(&resource_lock);
 248         err = find_resource(root, new, size, min, max, align, alignf, alignf_data);
 249         if (err >= 0 && __request_resource(root, new))
 250                 err = -EBUSY;
 251         write_unlock(&resource_lock);
 252         return err;
 253 }
 254
 255 /*
 256  * This is compatibility stuff for IO resources.
 257  *
 258  * Note how this, unlike the above, knows about
 259  * the IO flag meanings (busy etc).
 260  *
 261  * Request-region creates a new busy region.
 262  *
 263  * Check-region returns non-zero if the area is already busy
 264  *
 265  * Release-region releases a matching busy region.
 266  */
 267 struct resource * __request_region(struct resource *parent, unsigned long start, unsigned long n, const char *name)
 268 {
 269         struct resource *res = kmalloc(sizeof(*res), GFP_KERNEL);
 270
 271         if (res) {
 272                 memset(res, 0, sizeof(*res));
 273                 res->name = name;
 274                 res->start = start;
 275                 res->end = start + n - 1;
 276                 res->flags = IORESOURCE_BUSY;
 277
 278                 write_lock(&resource_lock);
 279
 280                 for (;;) {
 281                         struct resource *conflict;
 282
 283                         conflict = __request_resource(parent, res);
 284                         if (!conflict)
 285                                 break;
 286                         if (conflict != parent) {
 287                                 parent = conflict;
 288                                 if (!(conflict->flags & IORESOURCE_BUSY))
 289                                         continue;
 290                         }
 291
 292                         /* Uhhuh, that didn't work out.. */
 293                         kfree(res);
 294                         res = NULL;
 295                         break;
 296                 }
 297                 write_unlock(&resource_lock);
 298         }
 299         return res;
 300 }
 301
 302 int __deprecated __check_region(struct resource *parent, unsigned long start, unsigned long n)
 303 {
 304         struct resource * res;
 305
 306         res = __request_region(parent, start, n, "check-region");
 307         if (!res)
 308                 return -EBUSY;
 309
 310         release_resource(res);
 311         kfree(res);
 312         return 0;
 313 }
 314
 315 void __release_region(struct resource *parent, unsigned long start, unsigned long n)
 316 {
 317         struct resource **p;
 318         unsigned long end;
 319
 320         p = &parent->child;
 321         end = start + n - 1;
 322
 323         for (;;) {
 324                 struct resource *res = *p;
 325
 326                 if (!res)
 327                         break;
 328                 if (res->start <= start && res->end >= end) {
 329                         if (!(res->flags & IORESOURCE_BUSY)) {
 330                                 p = &res->child;
 331                                 continue;
 332                         }
 333                         if (res->start != start || res->end != end)
 334                                 break;
 335                         *p = res->sibling;
 336                         kfree(res);
 337                         return;
 338                 }
 339                 p = &res->sibling;
 340         }
 341         printk(KERN_WARNING "Trying to free nonexistent resource <%08lx-%08lx>\n", start, end);
 342 }
 343
 344 /*
 345  * Called from init/main.c to reserve IO ports.
 346  */
 347 #define MAXRESERVE 4
 348 static int __init reserve_setup(char *str)
 349 {
 350         static int reserved = 0;
 351         static struct resource reserve[MAXRESERVE];
 352
 353         for (;;) {
 354                 int io_start, io_num;
 355                 int x = reserved;
 356
 357                 if (get_option (&str, &io_start) != 2)
 358                         break;
 359                 if (get_option (&str, &io_num)   == 0)
 360                         break;
 361                 if (x < MAXRESERVE) {
 362                         struct resource *res = reserve + x;
 363                         res->name = "reserved";
 364                         res->start = io_start;
 365                         res->end = io_start + io_num - 1;
 366                         res->flags = IORESOURCE_BUSY;
 367                         res->child = NULL;
 368                         if (request_resource(res->start >= 0x10000 ? &iomem_resource : &ioport_resource, res) == 0)
 369                                 reserved = x+1;
 370                 }
 371         }
 372         return 1;
 373 }
 374
 375 __setup("reserve=", reserve_setup);