libata/IDE: remove combined mode quirk
[linux-2.6.git] / 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/module.h>
11 #include <linux/errno.h>
12 #include <linux/ioport.h>
13 #include <linux/init.h>
14 #include <linux/slab.h>
15 #include <linux/spinlock.h>
16 #include <linux/fs.h>
17 #include <linux/proc_fs.h>
18 #include <linux/seq_file.h>
19 #include <linux/device.h>
20 #include <asm/io.h>
21
22
23 struct resource ioport_resource = {
24         .name   = "PCI IO",
25         .start  = 0,
26         .end    = IO_SPACE_LIMIT,
27         .flags  = IORESOURCE_IO,
28 };
29 EXPORT_SYMBOL(ioport_resource);
30
31 struct resource iomem_resource = {
32         .name   = "PCI mem",
33         .start  = 0,
34         .end    = -1,
35         .flags  = IORESOURCE_MEM,
36 };
37 EXPORT_SYMBOL(iomem_resource);
38
39 static DEFINE_RWLOCK(resource_lock);
40
41 #ifdef CONFIG_PROC_FS
42
43 enum { MAX_IORES_LEVEL = 5 };
44
45 static void *r_next(struct seq_file *m, void *v, loff_t *pos)
46 {
47         struct resource *p = v;
48         (*pos)++;
49         if (p->child)
50                 return p->child;
51         while (!p->sibling && p->parent)
52                 p = p->parent;
53         return p->sibling;
54 }
55
56 static void *r_start(struct seq_file *m, loff_t *pos)
57         __acquires(resource_lock)
58 {
59         struct resource *p = m->private;
60         loff_t l = 0;
61         read_lock(&resource_lock);
62         for (p = p->child; p && l < *pos; p = r_next(m, p, &l))
63                 ;
64         return p;
65 }
66
67 static void r_stop(struct seq_file *m, void *v)
68         __releases(resource_lock)
69 {
70         read_unlock(&resource_lock);
71 }
72
73 static int r_show(struct seq_file *m, void *v)
74 {
75         struct resource *root = m->private;
76         struct resource *r = v, *p;
77         int width = root->end < 0x10000 ? 4 : 8;
78         int depth;
79
80         for (depth = 0, p = r; depth < MAX_IORES_LEVEL; depth++, p = p->parent)
81                 if (p->parent == root)
82                         break;
83         seq_printf(m, "%*s%0*llx-%0*llx : %s\n",
84                         depth * 2, "",
85                         width, (unsigned long long) r->start,
86                         width, (unsigned long long) r->end,
87                         r->name ? r->name : "<BAD>");
88         return 0;
89 }
90
91 static const struct seq_operations resource_op = {
92         .start  = r_start,
93         .next   = r_next,
94         .stop   = r_stop,
95         .show   = r_show,
96 };
97
98 static int ioports_open(struct inode *inode, struct file *file)
99 {
100         int res = seq_open(file, &resource_op);
101         if (!res) {
102                 struct seq_file *m = file->private_data;
103                 m->private = &ioport_resource;
104         }
105         return res;
106 }
107
108 static int iomem_open(struct inode *inode, struct file *file)
109 {
110         int res = seq_open(file, &resource_op);
111         if (!res) {
112                 struct seq_file *m = file->private_data;
113                 m->private = &iomem_resource;
114         }
115         return res;
116 }
117
118 static const struct file_operations proc_ioports_operations = {
119         .open           = ioports_open,
120         .read           = seq_read,
121         .llseek         = seq_lseek,
122         .release        = seq_release,
123 };
124
125 static const struct file_operations proc_iomem_operations = {
126         .open           = iomem_open,
127         .read           = seq_read,
128         .llseek         = seq_lseek,
129         .release        = seq_release,
130 };
131
132 static int __init ioresources_init(void)
133 {
134         struct proc_dir_entry *entry;
135
136         entry = create_proc_entry("ioports", 0, NULL);
137         if (entry)
138                 entry->proc_fops = &proc_ioports_operations;
139         entry = create_proc_entry("iomem", 0, NULL);
140         if (entry)
141                 entry->proc_fops = &proc_iomem_operations;
142         return 0;
143 }
144 __initcall(ioresources_init);
145
146 #endif /* CONFIG_PROC_FS */
147
148 /* Return the conflict entry if you can't request it */
149 static struct resource * __request_resource(struct resource *root, struct resource *new)
150 {
151         resource_size_t start = new->start;
152         resource_size_t end = new->end;
153         struct resource *tmp, **p;
154
155         if (end < start)
156                 return root;
157         if (start < root->start)
158                 return root;
159         if (end > root->end)
160                 return root;
161         p = &root->child;
162         for (;;) {
163                 tmp = *p;
164                 if (!tmp || tmp->start > end) {
165                         new->sibling = tmp;
166                         *p = new;
167                         new->parent = root;
168                         return NULL;
169                 }
170                 p = &tmp->sibling;
171                 if (tmp->end < start)
172                         continue;
173                 return tmp;
174         }
175 }
176
177 static int __release_resource(struct resource *old)
178 {
179         struct resource *tmp, **p;
180
181         p = &old->parent->child;
182         for (;;) {
183                 tmp = *p;
184                 if (!tmp)
185                         break;
186                 if (tmp == old) {
187                         *p = tmp->sibling;
188                         old->parent = NULL;
189                         return 0;
190                 }
191                 p = &tmp->sibling;
192         }
193         return -EINVAL;
194 }
195
196 /**
197  * request_resource - request and reserve an I/O or memory resource
198  * @root: root resource descriptor
199  * @new: resource descriptor desired by caller
200  *
201  * Returns 0 for success, negative error code on error.
202  */
203 int request_resource(struct resource *root, struct resource *new)
204 {
205         struct resource *conflict;
206
207         write_lock(&resource_lock);
208         conflict = __request_resource(root, new);
209         write_unlock(&resource_lock);
210         return conflict ? -EBUSY : 0;
211 }
212
213 EXPORT_SYMBOL(request_resource);
214
215 /**
216  * release_resource - release a previously reserved resource
217  * @old: resource pointer
218  */
219 int release_resource(struct resource *old)
220 {
221         int retval;
222
223         write_lock(&resource_lock);
224         retval = __release_resource(old);
225         write_unlock(&resource_lock);
226         return retval;
227 }
228
229 EXPORT_SYMBOL(release_resource);
230
231 #ifdef CONFIG_MEMORY_HOTPLUG
232 /*
233  * Finds the lowest memory reosurce exists within [res->start.res->end)
234  * the caller must specify res->start, res->end, res->flags.
235  * If found, returns 0, res is overwritten, if not found, returns -1.
236  */
237 int find_next_system_ram(struct resource *res)
238 {
239         resource_size_t start, end;
240         struct resource *p;
241
242         BUG_ON(!res);
243
244         start = res->start;
245         end = res->end;
246         BUG_ON(start >= end);
247
248         read_lock(&resource_lock);
249         for (p = iomem_resource.child; p ; p = p->sibling) {
250                 /* system ram is just marked as IORESOURCE_MEM */
251                 if (p->flags != res->flags)
252                         continue;
253                 if (p->start > end) {
254                         p = NULL;
255                         break;
256                 }
257                 if ((p->end >= start) && (p->start < end))
258                         break;
259         }
260         read_unlock(&resource_lock);
261         if (!p)
262                 return -1;
263         /* copy data */
264         if (res->start < p->start)
265                 res->start = p->start;
266         if (res->end > p->end)
267                 res->end = p->end;
268         return 0;
269 }
270 #endif
271
272 /*
273  * Find empty slot in the resource tree given range and alignment.
274  */
275 static int find_resource(struct resource *root, struct resource *new,
276                          resource_size_t size, resource_size_t min,
277                          resource_size_t max, resource_size_t align,
278                          void (*alignf)(void *, struct resource *,
279                                         resource_size_t, resource_size_t),
280                          void *alignf_data)
281 {
282         struct resource *this = root->child;
283
284         new->start = root->start;
285         /*
286          * Skip past an allocated resource that starts at 0, since the assignment
287          * of this->start - 1 to new->end below would cause an underflow.
288          */
289         if (this && this->start == 0) {
290                 new->start = this->end + 1;
291                 this = this->sibling;
292         }
293         for(;;) {
294                 if (this)
295                         new->end = this->start - 1;
296                 else
297                         new->end = root->end;
298                 if (new->start < min)
299                         new->start = min;
300                 if (new->end > max)
301                         new->end = max;
302                 new->start = ALIGN(new->start, align);
303                 if (alignf)
304                         alignf(alignf_data, new, size, align);
305                 if (new->start < new->end && new->end - new->start >= size - 1) {
306                         new->end = new->start + size - 1;
307                         return 0;
308                 }
309                 if (!this)
310                         break;
311                 new->start = this->end + 1;
312                 this = this->sibling;
313         }
314         return -EBUSY;
315 }
316
317 /**
318  * allocate_resource - allocate empty slot in the resource tree given range & alignment
319  * @root: root resource descriptor
320  * @new: resource descriptor desired by caller
321  * @size: requested resource region size
322  * @min: minimum size to allocate
323  * @max: maximum size to allocate
324  * @align: alignment requested, in bytes
325  * @alignf: alignment function, optional, called if not NULL
326  * @alignf_data: arbitrary data to pass to the @alignf function
327  */
328 int allocate_resource(struct resource *root, struct resource *new,
329                       resource_size_t size, resource_size_t min,
330                       resource_size_t max, resource_size_t align,
331                       void (*alignf)(void *, struct resource *,
332                                      resource_size_t, resource_size_t),
333                       void *alignf_data)
334 {
335         int err;
336
337         write_lock(&resource_lock);
338         err = find_resource(root, new, size, min, max, align, alignf, alignf_data);
339         if (err >= 0 && __request_resource(root, new))
340                 err = -EBUSY;
341         write_unlock(&resource_lock);
342         return err;
343 }
344
345 EXPORT_SYMBOL(allocate_resource);
346
347 /**
348  * insert_resource - Inserts a resource in the resource tree
349  * @parent: parent of the new resource
350  * @new: new resource to insert
351  *
352  * Returns 0 on success, -EBUSY if the resource can't be inserted.
353  *
354  * This function is equivalent to request_resource when no conflict
355  * happens. If a conflict happens, and the conflicting resources
356  * entirely fit within the range of the new resource, then the new
357  * resource is inserted and the conflicting resources become children of
358  * the new resource.
359  */
360 int insert_resource(struct resource *parent, struct resource *new)
361 {
362         int result;
363         struct resource *first, *next;
364
365         write_lock(&resource_lock);
366
367         for (;; parent = first) {
368                 result = 0;
369                 first = __request_resource(parent, new);
370                 if (!first)
371                         goto out;
372
373                 result = -EBUSY;
374                 if (first == parent)
375                         goto out;
376
377                 if ((first->start > new->start) || (first->end < new->end))
378                         break;
379                 if ((first->start == new->start) && (first->end == new->end))
380                         break;
381         }
382
383         for (next = first; ; next = next->sibling) {
384                 /* Partial overlap? Bad, and unfixable */
385                 if (next->start < new->start || next->end > new->end)
386                         goto out;
387                 if (!next->sibling)
388                         break;
389                 if (next->sibling->start > new->end)
390                         break;
391         }
392
393         result = 0;
394
395         new->parent = parent;
396         new->sibling = next->sibling;
397         new->child = first;
398
399         next->sibling = NULL;
400         for (next = first; next; next = next->sibling)
401                 next->parent = new;
402
403         if (parent->child == first) {
404                 parent->child = new;
405         } else {
406                 next = parent->child;
407                 while (next->sibling != first)
408                         next = next->sibling;
409                 next->sibling = new;
410         }
411
412  out:
413         write_unlock(&resource_lock);
414         return result;
415 }
416
417 /**
418  * adjust_resource - modify a resource's start and size
419  * @res: resource to modify
420  * @start: new start value
421  * @size: new size
422  *
423  * Given an existing resource, change its start and size to match the
424  * arguments.  Returns 0 on success, -EBUSY if it can't fit.
425  * Existing children of the resource are assumed to be immutable.
426  */
427 int adjust_resource(struct resource *res, resource_size_t start, resource_size_t size)
428 {
429         struct resource *tmp, *parent = res->parent;
430         resource_size_t end = start + size - 1;
431         int result = -EBUSY;
432
433         write_lock(&resource_lock);
434
435         if ((start < parent->start) || (end > parent->end))
436                 goto out;
437
438         for (tmp = res->child; tmp; tmp = tmp->sibling) {
439                 if ((tmp->start < start) || (tmp->end > end))
440                         goto out;
441         }
442
443         if (res->sibling && (res->sibling->start <= end))
444                 goto out;
445
446         tmp = parent->child;
447         if (tmp != res) {
448                 while (tmp->sibling != res)
449                         tmp = tmp->sibling;
450                 if (start <= tmp->end)
451                         goto out;
452         }
453
454         res->start = start;
455         res->end = end;
456         result = 0;
457
458  out:
459         write_unlock(&resource_lock);
460         return result;
461 }
462
463 EXPORT_SYMBOL(adjust_resource);
464
465 /*
466  * This is compatibility stuff for IO resources.
467  *
468  * Note how this, unlike the above, knows about
469  * the IO flag meanings (busy etc).
470  *
471  * request_region creates a new busy region.
472  *
473  * check_region returns non-zero if the area is already busy.
474  *
475  * release_region releases a matching busy region.
476  */
477
478 /**
479  * __request_region - create a new busy resource region
480  * @parent: parent resource descriptor
481  * @start: resource start address
482  * @n: resource region size
483  * @name: reserving caller's ID string
484  */
485 struct resource * __request_region(struct resource *parent,
486                                    resource_size_t start, resource_size_t n,
487                                    const char *name)
488 {
489         struct resource *res = kzalloc(sizeof(*res), GFP_KERNEL);
490
491         if (res) {
492                 res->name = name;
493                 res->start = start;
494                 res->end = start + n - 1;
495                 res->flags = IORESOURCE_BUSY;
496
497                 write_lock(&resource_lock);
498
499                 for (;;) {
500                         struct resource *conflict;
501
502                         conflict = __request_resource(parent, res);
503                         if (!conflict)
504                                 break;
505                         if (conflict != parent) {
506                                 parent = conflict;
507                                 if (!(conflict->flags & IORESOURCE_BUSY))
508                                         continue;
509                         }
510
511                         /* Uhhuh, that didn't work out.. */
512                         kfree(res);
513                         res = NULL;
514                         break;
515                 }
516                 write_unlock(&resource_lock);
517         }
518         return res;
519 }
520 EXPORT_SYMBOL(__request_region);
521
522 /**
523  * __check_region - check if a resource region is busy or free
524  * @parent: parent resource descriptor
525  * @start: resource start address
526  * @n: resource region size
527  *
528  * Returns 0 if the region is free at the moment it is checked,
529  * returns %-EBUSY if the region is busy.
530  *
531  * NOTE:
532  * This function is deprecated because its use is racy.
533  * Even if it returns 0, a subsequent call to request_region()
534  * may fail because another driver etc. just allocated the region.
535  * Do NOT use it.  It will be removed from the kernel.
536  */
537 int __check_region(struct resource *parent, resource_size_t start,
538                         resource_size_t n)
539 {
540         struct resource * res;
541
542         res = __request_region(parent, start, n, "check-region");
543         if (!res)
544                 return -EBUSY;
545
546         release_resource(res);
547         kfree(res);
548         return 0;
549 }
550 EXPORT_SYMBOL(__check_region);
551
552 /**
553  * __release_region - release a previously reserved resource region
554  * @parent: parent resource descriptor
555  * @start: resource start address
556  * @n: resource region size
557  *
558  * The described resource region must match a currently busy region.
559  */
560 void __release_region(struct resource *parent, resource_size_t start,
561                         resource_size_t n)
562 {
563         struct resource **p;
564         resource_size_t end;
565
566         p = &parent->child;
567         end = start + n - 1;
568
569         write_lock(&resource_lock);
570
571         for (;;) {
572                 struct resource *res = *p;
573
574                 if (!res)
575                         break;
576                 if (res->start <= start && res->end >= end) {
577                         if (!(res->flags & IORESOURCE_BUSY)) {
578                                 p = &res->child;
579                                 continue;
580                         }
581                         if (res->start != start || res->end != end)
582                                 break;
583                         *p = res->sibling;
584                         write_unlock(&resource_lock);
585                         kfree(res);
586                         return;
587                 }
588                 p = &res->sibling;
589         }
590
591         write_unlock(&resource_lock);
592
593         printk(KERN_WARNING "Trying to free nonexistent resource "
594                 "<%016llx-%016llx>\n", (unsigned long long)start,
595                 (unsigned long long)end);
596 }
597 EXPORT_SYMBOL(__release_region);
598
599 /*
600  * Managed region resource
601  */
602 struct region_devres {
603         struct resource *parent;
604         resource_size_t start;
605         resource_size_t n;
606 };
607
608 static void devm_region_release(struct device *dev, void *res)
609 {
610         struct region_devres *this = res;
611
612         __release_region(this->parent, this->start, this->n);
613 }
614
615 static int devm_region_match(struct device *dev, void *res, void *match_data)
616 {
617         struct region_devres *this = res, *match = match_data;
618
619         return this->parent == match->parent &&
620                 this->start == match->start && this->n == match->n;
621 }
622
623 struct resource * __devm_request_region(struct device *dev,
624                                 struct resource *parent, resource_size_t start,
625                                 resource_size_t n, const char *name)
626 {
627         struct region_devres *dr = NULL;
628         struct resource *res;
629
630         dr = devres_alloc(devm_region_release, sizeof(struct region_devres),
631                           GFP_KERNEL);
632         if (!dr)
633                 return NULL;
634
635         dr->parent = parent;
636         dr->start = start;
637         dr->n = n;
638
639         res = __request_region(parent, start, n, name);
640         if (res)
641                 devres_add(dev, dr);
642         else
643                 devres_free(dr);
644
645         return res;
646 }
647 EXPORT_SYMBOL(__devm_request_region);
648
649 void __devm_release_region(struct device *dev, struct resource *parent,
650                            resource_size_t start, resource_size_t n)
651 {
652         struct region_devres match_data = { parent, start, n };
653
654         __release_region(parent, start, n);
655         WARN_ON(devres_destroy(dev, devm_region_release, devm_region_match,
656                                &match_data));
657 }
658 EXPORT_SYMBOL(__devm_release_region);
659
660 /*
661  * Called from init/main.c to reserve IO ports.
662  */
663 #define MAXRESERVE 4
664 static int __init reserve_setup(char *str)
665 {
666         static int reserved;
667         static struct resource reserve[MAXRESERVE];
668
669         for (;;) {
670                 int io_start, io_num;
671                 int x = reserved;
672
673                 if (get_option (&str, &io_start) != 2)
674                         break;
675                 if (get_option (&str, &io_num)   == 0)
676                         break;
677                 if (x < MAXRESERVE) {
678                         struct resource *res = reserve + x;
679                         res->name = "reserved";
680                         res->start = io_start;
681                         res->end = io_start + io_num - 1;
682                         res->flags = IORESOURCE_BUSY;
683                         res->child = NULL;
684                         if (request_resource(res->start >= 0x10000 ? &iomem_resource : &ioport_resource, res) == 0)
685                                 reserved = x+1;
686                 }
687         }
688         return 1;
689 }
690
691 __setup("reserve=", reserve_setup);