Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * manager.c - Resource Management, Conflict Resolution, Activation and Disabling of Devices | |
3 | * | |
c1017a4c | 4 | * based on isapnp.c resource management (c) Jaroslav Kysela <perex@perex.cz> |
1da177e4 | 5 | * Copyright 2003 Adam Belay <ambx1@neo.rr.com> |
1f32ca31 BH |
6 | * Copyright (C) 2008 Hewlett-Packard Development Company, L.P. |
7 | * Bjorn Helgaas <bjorn.helgaas@hp.com> | |
1da177e4 LT |
8 | */ |
9 | ||
1da177e4 LT |
10 | #include <linux/errno.h> |
11 | #include <linux/module.h> | |
12 | #include <linux/init.h> | |
13 | #include <linux/kernel.h> | |
1da177e4 | 14 | #include <linux/pnp.h> |
4e57b681 | 15 | #include <linux/bitmap.h> |
b3bd86e2 | 16 | #include <linux/mutex.h> |
1da177e4 LT |
17 | #include "base.h" |
18 | ||
b3bd86e2 | 19 | DEFINE_MUTEX(pnp_res_mutex); |
1da177e4 | 20 | |
13cde3b2 WS |
21 | static struct resource *pnp_find_resource(struct pnp_dev *dev, |
22 | unsigned char rule, | |
23 | unsigned long type, | |
24 | unsigned int bar) | |
25 | { | |
26 | struct resource *res = pnp_get_resource(dev, type, bar); | |
27 | ||
28 | /* when the resource already exists, set its resource bits from rule */ | |
29 | if (res) { | |
30 | res->flags &= ~IORESOURCE_BITS; | |
31 | res->flags |= rule & IORESOURCE_BITS; | |
32 | } | |
33 | ||
34 | return res; | |
35 | } | |
36 | ||
1da177e4 LT |
37 | static int pnp_assign_port(struct pnp_dev *dev, struct pnp_port *rule, int idx) |
38 | { | |
aee3ad81 | 39 | struct resource *res, local_res; |
1da177e4 | 40 | |
13cde3b2 | 41 | res = pnp_find_resource(dev, rule->flags, IORESOURCE_IO, idx); |
aee3ad81 | 42 | if (res) { |
2f53432c | 43 | pnp_dbg(&dev->dev, " io %d already set to %#llx-%#llx " |
28ccffcf BH |
44 | "flags %#lx\n", idx, (unsigned long long) res->start, |
45 | (unsigned long long) res->end, res->flags); | |
6e906f0e | 46 | return 0; |
81b5c75f BH |
47 | } |
48 | ||
aee3ad81 BH |
49 | res = &local_res; |
50 | res->flags = rule->flags | IORESOURCE_AUTO; | |
51 | res->start = 0; | |
52 | res->end = 0; | |
1da177e4 LT |
53 | |
54 | if (!rule->size) { | |
28ccffcf | 55 | res->flags |= IORESOURCE_DISABLED; |
2f53432c | 56 | pnp_dbg(&dev->dev, " io %d disabled\n", idx); |
aee3ad81 | 57 | goto __add; |
1da177e4 LT |
58 | } |
59 | ||
28ccffcf BH |
60 | res->start = rule->min; |
61 | res->end = res->start + rule->size - 1; | |
1da177e4 | 62 | |
f5d94ff0 | 63 | while (!pnp_check_port(dev, res)) { |
28ccffcf BH |
64 | res->start += rule->align; |
65 | res->end = res->start + rule->size - 1; | |
66 | if (res->start > rule->max || !rule->align) { | |
2f53432c | 67 | pnp_dbg(&dev->dev, " couldn't assign io %d " |
fcfb7ce3 BH |
68 | "(min %#llx max %#llx)\n", idx, |
69 | (unsigned long long) rule->min, | |
70 | (unsigned long long) rule->max); | |
6e906f0e | 71 | return -EBUSY; |
81b5c75f | 72 | } |
1da177e4 | 73 | } |
aee3ad81 BH |
74 | |
75 | __add: | |
76 | pnp_add_io_resource(dev, res->start, res->end, res->flags); | |
6e906f0e | 77 | return 0; |
1da177e4 LT |
78 | } |
79 | ||
80 | static int pnp_assign_mem(struct pnp_dev *dev, struct pnp_mem *rule, int idx) | |
81 | { | |
aee3ad81 | 82 | struct resource *res, local_res; |
1da177e4 | 83 | |
13cde3b2 | 84 | res = pnp_find_resource(dev, rule->flags, IORESOURCE_MEM, idx); |
aee3ad81 | 85 | if (res) { |
2f53432c | 86 | pnp_dbg(&dev->dev, " mem %d already set to %#llx-%#llx " |
28ccffcf BH |
87 | "flags %#lx\n", idx, (unsigned long long) res->start, |
88 | (unsigned long long) res->end, res->flags); | |
6e906f0e | 89 | return 0; |
81b5c75f BH |
90 | } |
91 | ||
aee3ad81 BH |
92 | res = &local_res; |
93 | res->flags = rule->flags | IORESOURCE_AUTO; | |
94 | res->start = 0; | |
95 | res->end = 0; | |
1da177e4 | 96 | |
13cde3b2 | 97 | /* ??? rule->flags restricted to 8 bits, all tests bogus ??? */ |
1da177e4 | 98 | if (!(rule->flags & IORESOURCE_MEM_WRITEABLE)) |
28ccffcf | 99 | res->flags |= IORESOURCE_READONLY; |
1da177e4 | 100 | if (rule->flags & IORESOURCE_MEM_CACHEABLE) |
28ccffcf | 101 | res->flags |= IORESOURCE_CACHEABLE; |
1da177e4 | 102 | if (rule->flags & IORESOURCE_MEM_RANGELENGTH) |
28ccffcf | 103 | res->flags |= IORESOURCE_RANGELENGTH; |
1da177e4 | 104 | if (rule->flags & IORESOURCE_MEM_SHADOWABLE) |
28ccffcf | 105 | res->flags |= IORESOURCE_SHADOWABLE; |
1da177e4 LT |
106 | |
107 | if (!rule->size) { | |
28ccffcf | 108 | res->flags |= IORESOURCE_DISABLED; |
2f53432c | 109 | pnp_dbg(&dev->dev, " mem %d disabled\n", idx); |
aee3ad81 | 110 | goto __add; |
1da177e4 LT |
111 | } |
112 | ||
28ccffcf BH |
113 | res->start = rule->min; |
114 | res->end = res->start + rule->size - 1; | |
1da177e4 | 115 | |
f5d94ff0 | 116 | while (!pnp_check_mem(dev, res)) { |
28ccffcf BH |
117 | res->start += rule->align; |
118 | res->end = res->start + rule->size - 1; | |
119 | if (res->start > rule->max || !rule->align) { | |
2f53432c | 120 | pnp_dbg(&dev->dev, " couldn't assign mem %d " |
fcfb7ce3 BH |
121 | "(min %#llx max %#llx)\n", idx, |
122 | (unsigned long long) rule->min, | |
123 | (unsigned long long) rule->max); | |
6e906f0e | 124 | return -EBUSY; |
81b5c75f | 125 | } |
1da177e4 | 126 | } |
aee3ad81 BH |
127 | |
128 | __add: | |
129 | pnp_add_mem_resource(dev, res->start, res->end, res->flags); | |
6e906f0e | 130 | return 0; |
1da177e4 LT |
131 | } |
132 | ||
9dd78466 | 133 | static int pnp_assign_irq(struct pnp_dev *dev, struct pnp_irq *rule, int idx) |
1da177e4 | 134 | { |
aee3ad81 | 135 | struct resource *res, local_res; |
1da177e4 LT |
136 | int i; |
137 | ||
138 | /* IRQ priority: this table is good for i386 */ | |
139 | static unsigned short xtab[16] = { | |
140 | 5, 10, 11, 12, 9, 14, 15, 7, 3, 4, 13, 0, 1, 6, 8, 2 | |
141 | }; | |
142 | ||
13cde3b2 | 143 | res = pnp_find_resource(dev, rule->flags, IORESOURCE_IRQ, idx); |
aee3ad81 | 144 | if (res) { |
2f53432c | 145 | pnp_dbg(&dev->dev, " irq %d already set to %d flags %#lx\n", |
28ccffcf | 146 | idx, (int) res->start, res->flags); |
6e906f0e | 147 | return 0; |
81b5c75f BH |
148 | } |
149 | ||
aee3ad81 BH |
150 | res = &local_res; |
151 | res->flags = rule->flags | IORESOURCE_AUTO; | |
152 | res->start = -1; | |
153 | res->end = -1; | |
1da177e4 | 154 | |
7aefff51 | 155 | if (bitmap_empty(rule->map.bits, PNP_IRQ_NR)) { |
28ccffcf | 156 | res->flags |= IORESOURCE_DISABLED; |
2f53432c | 157 | pnp_dbg(&dev->dev, " irq %d disabled\n", idx); |
aee3ad81 | 158 | goto __add; |
1da177e4 LT |
159 | } |
160 | ||
161 | /* TBD: need check for >16 IRQ */ | |
7aefff51 | 162 | res->start = find_next_bit(rule->map.bits, PNP_IRQ_NR, 16); |
28ccffcf BH |
163 | if (res->start < PNP_IRQ_NR) { |
164 | res->end = res->start; | |
aee3ad81 | 165 | goto __add; |
1da177e4 LT |
166 | } |
167 | for (i = 0; i < 16; i++) { | |
7aefff51 | 168 | if (test_bit(xtab[i], rule->map.bits)) { |
28ccffcf | 169 | res->start = res->end = xtab[i]; |
aee3ad81 BH |
170 | if (pnp_check_irq(dev, res)) |
171 | goto __add; | |
1da177e4 LT |
172 | } |
173 | } | |
d5ebde6e BH |
174 | |
175 | if (rule->flags & IORESOURCE_IRQ_OPTIONAL) { | |
176 | res->start = -1; | |
177 | res->end = -1; | |
178 | res->flags |= IORESOURCE_DISABLED; | |
2f53432c | 179 | pnp_dbg(&dev->dev, " irq %d disabled (optional)\n", idx); |
d5ebde6e BH |
180 | goto __add; |
181 | } | |
182 | ||
2f53432c | 183 | pnp_dbg(&dev->dev, " couldn't assign irq %d\n", idx); |
6e906f0e | 184 | return -EBUSY; |
aee3ad81 BH |
185 | |
186 | __add: | |
187 | pnp_add_irq_resource(dev, res->start, res->flags); | |
6e906f0e | 188 | return 0; |
1da177e4 LT |
189 | } |
190 | ||
586f83e2 | 191 | #ifdef CONFIG_ISA_DMA_API |
6e906f0e | 192 | static int pnp_assign_dma(struct pnp_dev *dev, struct pnp_dma *rule, int idx) |
1da177e4 | 193 | { |
aee3ad81 | 194 | struct resource *res, local_res; |
1da177e4 LT |
195 | int i; |
196 | ||
197 | /* DMA priority: this table is good for i386 */ | |
198 | static unsigned short xtab[8] = { | |
199 | 1, 3, 5, 6, 7, 0, 2, 4 | |
200 | }; | |
201 | ||
13cde3b2 | 202 | res = pnp_find_resource(dev, rule->flags, IORESOURCE_DMA, idx); |
aee3ad81 | 203 | if (res) { |
2f53432c | 204 | pnp_dbg(&dev->dev, " dma %d already set to %d flags %#lx\n", |
28ccffcf | 205 | idx, (int) res->start, res->flags); |
6e906f0e | 206 | return 0; |
81b5c75f BH |
207 | } |
208 | ||
aee3ad81 BH |
209 | res = &local_res; |
210 | res->flags = rule->flags | IORESOURCE_AUTO; | |
211 | res->start = -1; | |
212 | res->end = -1; | |
1da177e4 | 213 | |
bdf0eb3a DF |
214 | if (!rule->map) { |
215 | res->flags |= IORESOURCE_DISABLED; | |
216 | pnp_dbg(&dev->dev, " dma %d disabled\n", idx); | |
217 | goto __add; | |
218 | } | |
219 | ||
1da177e4 | 220 | for (i = 0; i < 8; i++) { |
9dd78466 | 221 | if (rule->map & (1 << xtab[i])) { |
28ccffcf | 222 | res->start = res->end = xtab[i]; |
aee3ad81 BH |
223 | if (pnp_check_dma(dev, res)) |
224 | goto __add; | |
1da177e4 LT |
225 | } |
226 | } | |
bdf0eb3a DF |
227 | |
228 | pnp_dbg(&dev->dev, " couldn't assign dma %d\n", idx); | |
229 | return -EBUSY; | |
1da177e4 | 230 | |
aee3ad81 BH |
231 | __add: |
232 | pnp_add_dma_resource(dev, res->start, res->flags); | |
6e906f0e | 233 | return 0; |
d948a8da | 234 | } |
586f83e2 | 235 | #endif /* CONFIG_ISA_DMA_API */ |
d948a8da | 236 | |
2cd13930 | 237 | void pnp_init_resources(struct pnp_dev *dev) |
1da177e4 | 238 | { |
aee3ad81 | 239 | pnp_free_resources(dev); |
1da177e4 LT |
240 | } |
241 | ||
6969c7ed | 242 | static void pnp_clean_resource_table(struct pnp_dev *dev) |
1da177e4 | 243 | { |
aee3ad81 BH |
244 | struct pnp_resource *pnp_res, *tmp; |
245 | ||
246 | list_for_each_entry_safe(pnp_res, tmp, &dev->resources, list) { | |
247 | if (pnp_res->res.flags & IORESOURCE_AUTO) | |
248 | pnp_free_resource(pnp_res); | |
1da177e4 LT |
249 | } |
250 | } | |
251 | ||
252 | /** | |
253 | * pnp_assign_resources - assigns resources to the device based on the specified dependent number | |
254 | * @dev: pointer to the desired device | |
1f32ca31 | 255 | * @set: the dependent function number |
1da177e4 | 256 | */ |
1f32ca31 | 257 | static int pnp_assign_resources(struct pnp_dev *dev, int set) |
1da177e4 | 258 | { |
1f32ca31 | 259 | struct pnp_option *option; |
586f83e2 DR |
260 | int nport = 0, nmem = 0, nirq = 0; |
261 | int ndma __maybe_unused = 0; | |
1f32ca31 | 262 | int ret = 0; |
1da177e4 | 263 | |
2f53432c | 264 | pnp_dbg(&dev->dev, "pnp_assign_resources, try dependent set %d\n", set); |
b3bd86e2 | 265 | mutex_lock(&pnp_res_mutex); |
6969c7ed | 266 | pnp_clean_resource_table(dev); |
1da177e4 | 267 | |
1f32ca31 BH |
268 | list_for_each_entry(option, &dev->options, list) { |
269 | if (pnp_option_is_dependent(option) && | |
270 | pnp_option_set(option) != set) | |
271 | continue; | |
272 | ||
273 | switch (option->type) { | |
274 | case IORESOURCE_IO: | |
275 | ret = pnp_assign_port(dev, &option->u.port, nport++); | |
276 | break; | |
277 | case IORESOURCE_MEM: | |
278 | ret = pnp_assign_mem(dev, &option->u.mem, nmem++); | |
279 | break; | |
280 | case IORESOURCE_IRQ: | |
281 | ret = pnp_assign_irq(dev, &option->u.irq, nirq++); | |
282 | break; | |
586f83e2 | 283 | #ifdef CONFIG_ISA_DMA_API |
1f32ca31 BH |
284 | case IORESOURCE_DMA: |
285 | ret = pnp_assign_dma(dev, &option->u.dma, ndma++); | |
286 | break; | |
586f83e2 | 287 | #endif |
1f32ca31 BH |
288 | default: |
289 | ret = -EINVAL; | |
290 | break; | |
1da177e4 | 291 | } |
1f32ca31 BH |
292 | if (ret < 0) |
293 | break; | |
294 | } | |
1da177e4 | 295 | |
b3bd86e2 | 296 | mutex_unlock(&pnp_res_mutex); |
1f32ca31 | 297 | if (ret < 0) { |
2f53432c | 298 | pnp_dbg(&dev->dev, "pnp_assign_resources failed (%d)\n", ret); |
1f32ca31 BH |
299 | pnp_clean_resource_table(dev); |
300 | } else | |
301 | dbg_pnp_show_resources(dev, "pnp_assign_resources succeeded"); | |
302 | return ret; | |
1da177e4 LT |
303 | } |
304 | ||
1da177e4 LT |
305 | /** |
306 | * pnp_auto_config_dev - automatically assigns resources to a device | |
307 | * @dev: pointer to the desired device | |
1da177e4 LT |
308 | */ |
309 | int pnp_auto_config_dev(struct pnp_dev *dev) | |
310 | { | |
1f32ca31 | 311 | int i, ret; |
1da177e4 | 312 | |
9dd78466 | 313 | if (!pnp_can_configure(dev)) { |
2f53432c | 314 | pnp_dbg(&dev->dev, "configuration not supported\n"); |
1da177e4 LT |
315 | return -ENODEV; |
316 | } | |
317 | ||
1f32ca31 BH |
318 | ret = pnp_assign_resources(dev, 0); |
319 | if (ret == 0) | |
320 | return 0; | |
321 | ||
322 | for (i = 1; i < dev->num_dependent_sets; i++) { | |
323 | ret = pnp_assign_resources(dev, i); | |
324 | if (ret == 0) | |
1da177e4 | 325 | return 0; |
1da177e4 LT |
326 | } |
327 | ||
a05d0781 | 328 | dev_err(&dev->dev, "unable to assign resources\n"); |
1f32ca31 | 329 | return ret; |
1da177e4 LT |
330 | } |
331 | ||
68094e32 PO |
332 | /** |
333 | * pnp_start_dev - low-level start of the PnP device | |
334 | * @dev: pointer to the desired device | |
335 | * | |
07d4e9af | 336 | * assumes that resources have already been allocated |
68094e32 | 337 | */ |
68094e32 PO |
338 | int pnp_start_dev(struct pnp_dev *dev) |
339 | { | |
340 | if (!pnp_can_write(dev)) { | |
2f53432c | 341 | pnp_dbg(&dev->dev, "activation not supported\n"); |
68094e32 PO |
342 | return -EINVAL; |
343 | } | |
344 | ||
81b5c75f | 345 | dbg_pnp_show_resources(dev, "pnp_start_dev"); |
59284cb4 | 346 | if (dev->protocol->set(dev) < 0) { |
a05d0781 | 347 | dev_err(&dev->dev, "activation failed\n"); |
68094e32 PO |
348 | return -EIO; |
349 | } | |
350 | ||
a05d0781 | 351 | dev_info(&dev->dev, "activated\n"); |
68094e32 PO |
352 | return 0; |
353 | } | |
354 | ||
355 | /** | |
356 | * pnp_stop_dev - low-level disable of the PnP device | |
357 | * @dev: pointer to the desired device | |
358 | * | |
359 | * does not free resources | |
360 | */ | |
68094e32 PO |
361 | int pnp_stop_dev(struct pnp_dev *dev) |
362 | { | |
363 | if (!pnp_can_disable(dev)) { | |
2f53432c | 364 | pnp_dbg(&dev->dev, "disabling not supported\n"); |
68094e32 PO |
365 | return -EINVAL; |
366 | } | |
9dd78466 | 367 | if (dev->protocol->disable(dev) < 0) { |
a05d0781 | 368 | dev_err(&dev->dev, "disable failed\n"); |
68094e32 PO |
369 | return -EIO; |
370 | } | |
371 | ||
a05d0781 | 372 | dev_info(&dev->dev, "disabled\n"); |
68094e32 PO |
373 | return 0; |
374 | } | |
375 | ||
1da177e4 LT |
376 | /** |
377 | * pnp_activate_dev - activates a PnP device for use | |
378 | * @dev: pointer to the desired device | |
379 | * | |
380 | * does not validate or set resources so be careful. | |
381 | */ | |
382 | int pnp_activate_dev(struct pnp_dev *dev) | |
383 | { | |
68094e32 PO |
384 | int error; |
385 | ||
07d4e9af | 386 | if (dev->active) |
cc8259a6 | 387 | return 0; |
1da177e4 LT |
388 | |
389 | /* ensure resources are allocated */ | |
390 | if (pnp_auto_config_dev(dev)) | |
391 | return -EBUSY; | |
392 | ||
68094e32 PO |
393 | error = pnp_start_dev(dev); |
394 | if (error) | |
395 | return error; | |
1da177e4 LT |
396 | |
397 | dev->active = 1; | |
cc8259a6 | 398 | return 0; |
1da177e4 LT |
399 | } |
400 | ||
401 | /** | |
402 | * pnp_disable_dev - disables device | |
403 | * @dev: pointer to the desired device | |
404 | * | |
405 | * inform the correct pnp protocol so that resources can be used by other devices | |
406 | */ | |
407 | int pnp_disable_dev(struct pnp_dev *dev) | |
408 | { | |
68094e32 PO |
409 | int error; |
410 | ||
07d4e9af | 411 | if (!dev->active) |
cc8259a6 | 412 | return 0; |
1da177e4 | 413 | |
68094e32 PO |
414 | error = pnp_stop_dev(dev); |
415 | if (error) | |
416 | return error; | |
1da177e4 LT |
417 | |
418 | dev->active = 0; | |
1da177e4 LT |
419 | |
420 | /* release the resources so that other devices can use them */ | |
b3bd86e2 | 421 | mutex_lock(&pnp_res_mutex); |
6969c7ed | 422 | pnp_clean_resource_table(dev); |
b3bd86e2 | 423 | mutex_unlock(&pnp_res_mutex); |
1da177e4 | 424 | |
cc8259a6 | 425 | return 0; |
1da177e4 LT |
426 | } |
427 | ||
68094e32 PO |
428 | EXPORT_SYMBOL(pnp_start_dev); |
429 | EXPORT_SYMBOL(pnp_stop_dev); | |
1da177e4 LT |
430 | EXPORT_SYMBOL(pnp_activate_dev); |
431 | EXPORT_SYMBOL(pnp_disable_dev); |