PCI: Enforce bus address limits in resource allocation
[deliverable/linux.git] / drivers / pci / bus.c
CommitLineData
1da177e4
LT
1/*
2 * drivers/pci/bus.c
3 *
4 * From setup-res.c, by:
5 * Dave Rusling (david.rusling@reo.mts.dec.com)
6 * David Mosberger (davidm@cs.arizona.edu)
7 * David Miller (davem@redhat.com)
8 * Ivan Kokshaysky (ink@jurassic.park.msu.ru)
9 */
10#include <linux/module.h>
11#include <linux/kernel.h>
12#include <linux/pci.h>
13#include <linux/errno.h>
14#include <linux/ioport.h>
15#include <linux/proc_fs.h>
16#include <linux/init.h>
5a0e3ad6 17#include <linux/slab.h>
1da177e4
LT
18
19#include "pci.h"
20
0efd5aab
BH
21void pci_add_resource_offset(struct list_head *resources, struct resource *res,
22 resource_size_t offset)
45ca9e97 23{
0efd5aab 24 struct pci_host_bridge_window *window;
45ca9e97 25
0efd5aab
BH
26 window = kzalloc(sizeof(struct pci_host_bridge_window), GFP_KERNEL);
27 if (!window) {
28 printk(KERN_ERR "PCI: can't add host bridge window %pR\n", res);
45ca9e97
BH
29 return;
30 }
31
0efd5aab
BH
32 window->res = res;
33 window->offset = offset;
34 list_add_tail(&window->list, resources);
35}
36EXPORT_SYMBOL(pci_add_resource_offset);
37
38void pci_add_resource(struct list_head *resources, struct resource *res)
39{
40 pci_add_resource_offset(resources, res, 0);
45ca9e97
BH
41}
42EXPORT_SYMBOL(pci_add_resource);
43
44void pci_free_resource_list(struct list_head *resources)
45{
0efd5aab 46 struct pci_host_bridge_window *window, *tmp;
45ca9e97 47
0efd5aab
BH
48 list_for_each_entry_safe(window, tmp, resources, list) {
49 list_del(&window->list);
50 kfree(window);
45ca9e97
BH
51 }
52}
53EXPORT_SYMBOL(pci_free_resource_list);
54
2fe2abf8
BH
55void pci_bus_add_resource(struct pci_bus *bus, struct resource *res,
56 unsigned int flags)
57{
58 struct pci_bus_resource *bus_res;
59
60 bus_res = kzalloc(sizeof(struct pci_bus_resource), GFP_KERNEL);
61 if (!bus_res) {
62 dev_err(&bus->dev, "can't add %pR resource\n", res);
63 return;
64 }
65
66 bus_res->res = res;
67 bus_res->flags = flags;
68 list_add_tail(&bus_res->list, &bus->resources);
69}
70
71struct resource *pci_bus_resource_n(const struct pci_bus *bus, int n)
72{
73 struct pci_bus_resource *bus_res;
74
75 if (n < PCI_BRIDGE_RESOURCE_NUM)
76 return bus->resource[n];
77
78 n -= PCI_BRIDGE_RESOURCE_NUM;
79 list_for_each_entry(bus_res, &bus->resources, list) {
80 if (n-- == 0)
81 return bus_res->res;
82 }
83 return NULL;
84}
85EXPORT_SYMBOL_GPL(pci_bus_resource_n);
86
87void pci_bus_remove_resources(struct pci_bus *bus)
88{
2fe2abf8 89 int i;
817a2685 90 struct pci_bus_resource *bus_res, *tmp;
2fe2abf8
BH
91
92 for (i = 0; i < PCI_BRIDGE_RESOURCE_NUM; i++)
7736a05a 93 bus->resource[i] = NULL;
2fe2abf8 94
817a2685
YL
95 list_for_each_entry_safe(bus_res, tmp, &bus->resources, list) {
96 list_del(&bus_res->list);
97 kfree(bus_res);
98 }
2fe2abf8
BH
99}
100
f75b99d5
YL
101static struct pci_bus_region pci_32_bit = {0, 0xffffffffULL};
102#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
103static struct pci_bus_region pci_64_bit = {0,
104 (dma_addr_t) 0xffffffffffffffffULL};
105#endif
106
107/*
108 * @res contains CPU addresses. Clip it so the corresponding bus addresses
109 * on @bus are entirely within @region. This is used to control the bus
110 * addresses of resources we allocate, e.g., we may need a resource that
111 * can be mapped by a 32-bit BAR.
1da177e4 112 */
f75b99d5
YL
113static void pci_clip_resource_to_region(struct pci_bus *bus,
114 struct resource *res,
115 struct pci_bus_region *region)
116{
117 struct pci_bus_region r;
118
119 pcibios_resource_to_bus(bus, &r, res);
120 if (r.start < region->start)
121 r.start = region->start;
122 if (r.end > region->end)
123 r.end = region->end;
124
125 if (r.end < r.start)
126 res->end = res->start - 1;
127 else
128 pcibios_bus_to_resource(bus, res, &r);
129}
130
131static int pci_bus_alloc_from_region(struct pci_bus *bus, struct resource *res,
e31dd6e4
GKH
132 resource_size_t size, resource_size_t align,
133 resource_size_t min, unsigned int type_mask,
b26b2d49 134 resource_size_t (*alignf)(void *,
3b7a17fc 135 const struct resource *,
b26b2d49
DB
136 resource_size_t,
137 resource_size_t),
f75b99d5
YL
138 void *alignf_data,
139 struct pci_bus_region *region)
1da177e4 140{
f75b99d5
YL
141 int i, ret;
142 struct resource *r, avail;
143 resource_size_t max;
1da177e4
LT
144
145 type_mask |= IORESOURCE_IO | IORESOURCE_MEM;
146
6db45b76
BH
147 pci_bus_for_each_resource(bus, r, i) {
148 if (!r)
149 continue;
150
1da177e4
LT
151 /* type_mask must match */
152 if ((res->flags ^ r->flags) & type_mask)
153 continue;
154
155 /* We cannot allocate a non-prefetching resource
156 from a pre-fetching area */
157 if ((r->flags & IORESOURCE_PREFETCH) &&
158 !(res->flags & IORESOURCE_PREFETCH))
159 continue;
160
f75b99d5
YL
161 avail = *r;
162 pci_clip_resource_to_region(bus, &avail, region);
163 if (!resource_size(&avail))
164 continue;
165
36e097a8
BH
166 /*
167 * "min" is typically PCIBIOS_MIN_IO or PCIBIOS_MIN_MEM to
168 * protect badly documented motherboard resources, but if
169 * this is an already-configured bridge window, its start
170 * overrides "min".
171 */
f75b99d5
YL
172 if (avail.start)
173 min = avail.start;
174
175 max = avail.end;
36e097a8 176
1da177e4 177 /* Ok, try it out.. */
36e097a8
BH
178 ret = allocate_resource(r, res, size, min, max,
179 align, alignf, alignf_data);
1da177e4 180 if (ret == 0)
f75b99d5 181 return 0;
1da177e4 182 }
f75b99d5
YL
183 return -ENOMEM;
184}
185
186/**
187 * pci_bus_alloc_resource - allocate a resource from a parent bus
188 * @bus: PCI bus
189 * @res: resource to allocate
190 * @size: size of resource to allocate
191 * @align: alignment of resource to allocate
192 * @min: minimum /proc/iomem address to allocate
193 * @type_mask: IORESOURCE_* type flags
194 * @alignf: resource alignment function
195 * @alignf_data: data argument for resource alignment function
196 *
197 * Given the PCI bus a device resides on, the size, minimum address,
198 * alignment and type, try to find an acceptable resource allocation
199 * for a specific device resource.
200 */
201int
202pci_bus_alloc_resource(struct pci_bus *bus, struct resource *res,
203 resource_size_t size, resource_size_t align,
204 resource_size_t min, unsigned int type_mask,
205 resource_size_t (*alignf)(void *,
206 const struct resource *,
207 resource_size_t,
208 resource_size_t),
209 void *alignf_data)
210{
211#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
212 if (res->flags & IORESOURCE_MEM_64)
213 return pci_bus_alloc_from_region(bus, res, size, align, min,
214 type_mask, alignf, alignf_data,
215 &pci_64_bit);
216#endif
217
218 return pci_bus_alloc_from_region(bus, res, size, align, min,
219 type_mask, alignf, alignf_data,
220 &pci_32_bit);
1da177e4
LT
221}
222
3c449ed0
YL
223void __weak pcibios_resource_survey_bus(struct pci_bus *bus) { }
224
1da177e4 225/**
4f535093 226 * pci_bus_add_device - start driver for a single device
1da177e4
LT
227 * @dev: device to add
228 *
4f535093 229 * This adds add sysfs entries and start device drivers
1da177e4 230 */
96bde06a 231int pci_bus_add_device(struct pci_dev *dev)
1da177e4 232{
b19441af 233 int retval;
735bff10 234
4f535093
YL
235 /*
236 * Can not put in pci_device_add yet because resources
237 * are not assigned yet for some devices.
238 */
e253aaf0 239 pci_fixup_device(pci_fixup_final, dev);
4f535093 240 pci_create_sysfs_dev_files(dev);
1da177e4 241
58d9a38f
YL
242 dev->match_driver = true;
243 retval = device_attach(&dev->dev);
244 WARN_ON(retval < 0);
245
8a1bc901 246 dev->is_added = 1;
876e501a 247
4f535093 248 return 0;
876e501a
YZ
249}
250
1da177e4 251/**
4f535093 252 * pci_bus_add_devices - start driver for PCI devices
1da177e4
LT
253 * @bus: bus to check for new devices
254 *
4f535093 255 * Start driver for PCI devices and add some sysfs entries.
1da177e4 256 */
c48f1670 257void pci_bus_add_devices(const struct pci_bus *bus)
1da177e4
LT
258{
259 struct pci_dev *dev;
3fa16fdb 260 struct pci_bus *child;
b19441af 261 int retval;
1da177e4
LT
262
263 list_for_each_entry(dev, &bus->devices, bus_list) {
8a1bc901
GKH
264 /* Skip already-added devices */
265 if (dev->is_added)
1da177e4 266 continue;
b19441af 267 retval = pci_bus_add_device(dev);
9fc9eea0
BH
268 if (retval)
269 dev_err(&dev->dev, "Error adding device (%d)\n",
270 retval);
1da177e4
LT
271 }
272
273 list_for_each_entry(dev, &bus->devices, bus_list) {
8a1bc901 274 BUG_ON(!dev->is_added);
3fa16fdb 275 child = dev->subordinate;
981cf9ea
JL
276 if (child)
277 pci_bus_add_devices(child);
1da177e4
LT
278 }
279}
280
cecf4864
PM
281/** pci_walk_bus - walk devices on/under bus, calling callback.
282 * @top bus whose devices should be walked
283 * @cb callback to be called for each device found
284 * @userdata arbitrary pointer to be passed to callback.
285 *
286 * Walk the given bus, including any bridged devices
287 * on buses under this bus. Call the provided callback
288 * on each device found.
70298c6e
ZY
289 *
290 * We check the return of @cb each time. If it returns anything
291 * other than 0, we break out.
292 *
cecf4864 293 */
70298c6e 294void pci_walk_bus(struct pci_bus *top, int (*cb)(struct pci_dev *, void *),
cecf4864
PM
295 void *userdata)
296{
297 struct pci_dev *dev;
298 struct pci_bus *bus;
299 struct list_head *next;
70298c6e 300 int retval;
cecf4864
PM
301
302 bus = top;
d71374da 303 down_read(&pci_bus_sem);
cecf4864
PM
304 next = top->devices.next;
305 for (;;) {
306 if (next == &bus->devices) {
307 /* end of this bus, go up or finish */
308 if (bus == top)
309 break;
310 next = bus->self->bus_list.next;
311 bus = bus->self->bus;
312 continue;
313 }
314 dev = list_entry(next, struct pci_dev, bus_list);
cecf4864
PM
315 if (dev->subordinate) {
316 /* this is a pci-pci bridge, do its devices next */
317 next = dev->subordinate->devices.next;
318 bus = dev->subordinate;
319 } else
320 next = dev->bus_list.next;
cecf4864 321
70298c6e 322 retval = cb(dev, userdata);
70298c6e
ZY
323 if (retval)
324 break;
cecf4864 325 }
d71374da 326 up_read(&pci_bus_sem);
cecf4864 327}
7c94def8 328EXPORT_SYMBOL_GPL(pci_walk_bus);
cecf4864 329
fe830ef6
JL
330struct pci_bus *pci_bus_get(struct pci_bus *bus)
331{
332 if (bus)
333 get_device(&bus->dev);
334 return bus;
335}
336EXPORT_SYMBOL(pci_bus_get);
337
338void pci_bus_put(struct pci_bus *bus)
339{
340 if (bus)
341 put_device(&bus->dev);
342}
343EXPORT_SYMBOL(pci_bus_put);
344
1da177e4
LT
345EXPORT_SYMBOL(pci_bus_alloc_resource);
346EXPORT_SYMBOL_GPL(pci_bus_add_device);
347EXPORT_SYMBOL(pci_bus_add_devices);
This page took 1.795461 seconds and 5 git commands to generate.