]>
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 | |
1da177e4 | 214 | for (i = 0; i < 8; i++) { |
9dd78466 | 215 | if (rule->map & (1 << xtab[i])) { |
28ccffcf | 216 | res->start = res->end = xtab[i]; |
aee3ad81 BH |
217 | if (pnp_check_dma(dev, res)) |
218 | goto __add; | |
1da177e4 LT |
219 | } |
220 | } | |
7ef36390 | 221 | #ifdef MAX_DMA_CHANNELS |
28ccffcf | 222 | res->start = res->end = MAX_DMA_CHANNELS; |
7ef36390 | 223 | #endif |
aee3ad81 | 224 | res->flags |= IORESOURCE_DISABLED; |
2f53432c | 225 | pnp_dbg(&dev->dev, " disable dma %d\n", idx); |
1da177e4 | 226 | |
aee3ad81 BH |
227 | __add: |
228 | pnp_add_dma_resource(dev, res->start, res->flags); | |
6e906f0e | 229 | return 0; |
d948a8da | 230 | } |
586f83e2 | 231 | #endif /* CONFIG_ISA_DMA_API */ |
d948a8da | 232 | |
2cd13930 | 233 | void pnp_init_resources(struct pnp_dev *dev) |
1da177e4 | 234 | { |
aee3ad81 | 235 | pnp_free_resources(dev); |
1da177e4 LT |
236 | } |
237 | ||
6969c7ed | 238 | static void pnp_clean_resource_table(struct pnp_dev *dev) |
1da177e4 | 239 | { |
aee3ad81 BH |
240 | struct pnp_resource *pnp_res, *tmp; |
241 | ||
242 | list_for_each_entry_safe(pnp_res, tmp, &dev->resources, list) { | |
243 | if (pnp_res->res.flags & IORESOURCE_AUTO) | |
244 | pnp_free_resource(pnp_res); | |
1da177e4 LT |
245 | } |
246 | } | |
247 | ||
248 | /** | |
249 | * pnp_assign_resources - assigns resources to the device based on the specified dependent number | |
250 | * @dev: pointer to the desired device | |
1f32ca31 | 251 | * @set: the dependent function number |
1da177e4 | 252 | */ |
1f32ca31 | 253 | static int pnp_assign_resources(struct pnp_dev *dev, int set) |
1da177e4 | 254 | { |
1f32ca31 | 255 | struct pnp_option *option; |
586f83e2 DR |
256 | int nport = 0, nmem = 0, nirq = 0; |
257 | int ndma __maybe_unused = 0; | |
1f32ca31 | 258 | int ret = 0; |
1da177e4 | 259 | |
2f53432c | 260 | pnp_dbg(&dev->dev, "pnp_assign_resources, try dependent set %d\n", set); |
b3bd86e2 | 261 | mutex_lock(&pnp_res_mutex); |
6969c7ed | 262 | pnp_clean_resource_table(dev); |
1da177e4 | 263 | |
1f32ca31 BH |
264 | list_for_each_entry(option, &dev->options, list) { |
265 | if (pnp_option_is_dependent(option) && | |
266 | pnp_option_set(option) != set) | |
267 | continue; | |
268 | ||
269 | switch (option->type) { | |
270 | case IORESOURCE_IO: | |
271 | ret = pnp_assign_port(dev, &option->u.port, nport++); | |
272 | break; | |
273 | case IORESOURCE_MEM: | |
274 | ret = pnp_assign_mem(dev, &option->u.mem, nmem++); | |
275 | break; | |
276 | case IORESOURCE_IRQ: | |
277 | ret = pnp_assign_irq(dev, &option->u.irq, nirq++); | |
278 | break; | |
586f83e2 | 279 | #ifdef CONFIG_ISA_DMA_API |
1f32ca31 BH |
280 | case IORESOURCE_DMA: |
281 | ret = pnp_assign_dma(dev, &option->u.dma, ndma++); | |
282 | break; | |
586f83e2 | 283 | #endif |
1f32ca31 BH |
284 | default: |
285 | ret = -EINVAL; | |
286 | break; | |
1da177e4 | 287 | } |
1f32ca31 BH |
288 | if (ret < 0) |
289 | break; | |
290 | } | |
1da177e4 | 291 | |
b3bd86e2 | 292 | mutex_unlock(&pnp_res_mutex); |
1f32ca31 | 293 | if (ret < 0) { |
2f53432c | 294 | pnp_dbg(&dev->dev, "pnp_assign_resources failed (%d)\n", ret); |
1f32ca31 BH |
295 | pnp_clean_resource_table(dev); |
296 | } else | |
297 | dbg_pnp_show_resources(dev, "pnp_assign_resources succeeded"); | |
298 | return ret; | |
1da177e4 LT |
299 | } |
300 | ||
1da177e4 LT |
301 | /** |
302 | * pnp_auto_config_dev - automatically assigns resources to a device | |
303 | * @dev: pointer to the desired device | |
1da177e4 LT |
304 | */ |
305 | int pnp_auto_config_dev(struct pnp_dev *dev) | |
306 | { | |
1f32ca31 | 307 | int i, ret; |
1da177e4 | 308 | |
9dd78466 | 309 | if (!pnp_can_configure(dev)) { |
2f53432c | 310 | pnp_dbg(&dev->dev, "configuration not supported\n"); |
1da177e4 LT |
311 | return -ENODEV; |
312 | } | |
313 | ||
1f32ca31 BH |
314 | ret = pnp_assign_resources(dev, 0); |
315 | if (ret == 0) | |
316 | return 0; | |
317 | ||
318 | for (i = 1; i < dev->num_dependent_sets; i++) { | |
319 | ret = pnp_assign_resources(dev, i); | |
320 | if (ret == 0) | |
1da177e4 | 321 | return 0; |
1da177e4 LT |
322 | } |
323 | ||
a05d0781 | 324 | dev_err(&dev->dev, "unable to assign resources\n"); |
1f32ca31 | 325 | return ret; |
1da177e4 LT |
326 | } |
327 | ||
68094e32 PO |
328 | /** |
329 | * pnp_start_dev - low-level start of the PnP device | |
330 | * @dev: pointer to the desired device | |
331 | * | |
07d4e9af | 332 | * assumes that resources have already been allocated |
68094e32 | 333 | */ |
68094e32 PO |
334 | int pnp_start_dev(struct pnp_dev *dev) |
335 | { | |
336 | if (!pnp_can_write(dev)) { | |
2f53432c | 337 | pnp_dbg(&dev->dev, "activation not supported\n"); |
68094e32 PO |
338 | return -EINVAL; |
339 | } | |
340 | ||
81b5c75f | 341 | dbg_pnp_show_resources(dev, "pnp_start_dev"); |
59284cb4 | 342 | if (dev->protocol->set(dev) < 0) { |
a05d0781 | 343 | dev_err(&dev->dev, "activation failed\n"); |
68094e32 PO |
344 | return -EIO; |
345 | } | |
346 | ||
a05d0781 | 347 | dev_info(&dev->dev, "activated\n"); |
68094e32 PO |
348 | return 0; |
349 | } | |
350 | ||
351 | /** | |
352 | * pnp_stop_dev - low-level disable of the PnP device | |
353 | * @dev: pointer to the desired device | |
354 | * | |
355 | * does not free resources | |
356 | */ | |
68094e32 PO |
357 | int pnp_stop_dev(struct pnp_dev *dev) |
358 | { | |
359 | if (!pnp_can_disable(dev)) { | |
2f53432c | 360 | pnp_dbg(&dev->dev, "disabling not supported\n"); |
68094e32 PO |
361 | return -EINVAL; |
362 | } | |
9dd78466 | 363 | if (dev->protocol->disable(dev) < 0) { |
a05d0781 | 364 | dev_err(&dev->dev, "disable failed\n"); |
68094e32 PO |
365 | return -EIO; |
366 | } | |
367 | ||
a05d0781 | 368 | dev_info(&dev->dev, "disabled\n"); |
68094e32 PO |
369 | return 0; |
370 | } | |
371 | ||
1da177e4 LT |
372 | /** |
373 | * pnp_activate_dev - activates a PnP device for use | |
374 | * @dev: pointer to the desired device | |
375 | * | |
376 | * does not validate or set resources so be careful. | |
377 | */ | |
378 | int pnp_activate_dev(struct pnp_dev *dev) | |
379 | { | |
68094e32 PO |
380 | int error; |
381 | ||
07d4e9af | 382 | if (dev->active) |
cc8259a6 | 383 | return 0; |
1da177e4 LT |
384 | |
385 | /* ensure resources are allocated */ | |
386 | if (pnp_auto_config_dev(dev)) | |
387 | return -EBUSY; | |
388 | ||
68094e32 PO |
389 | error = pnp_start_dev(dev); |
390 | if (error) | |
391 | return error; | |
1da177e4 LT |
392 | |
393 | dev->active = 1; | |
cc8259a6 | 394 | return 0; |
1da177e4 LT |
395 | } |
396 | ||
397 | /** | |
398 | * pnp_disable_dev - disables device | |
399 | * @dev: pointer to the desired device | |
400 | * | |
401 | * inform the correct pnp protocol so that resources can be used by other devices | |
402 | */ | |
403 | int pnp_disable_dev(struct pnp_dev *dev) | |
404 | { | |
68094e32 PO |
405 | int error; |
406 | ||
07d4e9af | 407 | if (!dev->active) |
cc8259a6 | 408 | return 0; |
1da177e4 | 409 | |
68094e32 PO |
410 | error = pnp_stop_dev(dev); |
411 | if (error) | |
412 | return error; | |
1da177e4 LT |
413 | |
414 | dev->active = 0; | |
1da177e4 LT |
415 | |
416 | /* release the resources so that other devices can use them */ | |
b3bd86e2 | 417 | mutex_lock(&pnp_res_mutex); |
6969c7ed | 418 | pnp_clean_resource_table(dev); |
b3bd86e2 | 419 | mutex_unlock(&pnp_res_mutex); |
1da177e4 | 420 | |
cc8259a6 | 421 | return 0; |
1da177e4 LT |
422 | } |
423 | ||
68094e32 PO |
424 | EXPORT_SYMBOL(pnp_start_dev); |
425 | EXPORT_SYMBOL(pnp_stop_dev); | |
1da177e4 LT |
426 | EXPORT_SYMBOL(pnp_activate_dev); |
427 | EXPORT_SYMBOL(pnp_disable_dev); |