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_RANGELENGTH) |
28ccffcf | 101 | res->flags |= IORESOURCE_RANGELENGTH; |
1da177e4 | 102 | if (rule->flags & IORESOURCE_MEM_SHADOWABLE) |
28ccffcf | 103 | res->flags |= IORESOURCE_SHADOWABLE; |
1da177e4 LT |
104 | |
105 | if (!rule->size) { | |
28ccffcf | 106 | res->flags |= IORESOURCE_DISABLED; |
2f53432c | 107 | pnp_dbg(&dev->dev, " mem %d disabled\n", idx); |
aee3ad81 | 108 | goto __add; |
1da177e4 LT |
109 | } |
110 | ||
28ccffcf BH |
111 | res->start = rule->min; |
112 | res->end = res->start + rule->size - 1; | |
1da177e4 | 113 | |
f5d94ff0 | 114 | while (!pnp_check_mem(dev, res)) { |
28ccffcf BH |
115 | res->start += rule->align; |
116 | res->end = res->start + rule->size - 1; | |
117 | if (res->start > rule->max || !rule->align) { | |
2f53432c | 118 | pnp_dbg(&dev->dev, " couldn't assign mem %d " |
fcfb7ce3 BH |
119 | "(min %#llx max %#llx)\n", idx, |
120 | (unsigned long long) rule->min, | |
121 | (unsigned long long) rule->max); | |
6e906f0e | 122 | return -EBUSY; |
81b5c75f | 123 | } |
1da177e4 | 124 | } |
aee3ad81 BH |
125 | |
126 | __add: | |
127 | pnp_add_mem_resource(dev, res->start, res->end, res->flags); | |
6e906f0e | 128 | return 0; |
1da177e4 LT |
129 | } |
130 | ||
9dd78466 | 131 | static int pnp_assign_irq(struct pnp_dev *dev, struct pnp_irq *rule, int idx) |
1da177e4 | 132 | { |
aee3ad81 | 133 | struct resource *res, local_res; |
1da177e4 LT |
134 | int i; |
135 | ||
136 | /* IRQ priority: this table is good for i386 */ | |
137 | static unsigned short xtab[16] = { | |
138 | 5, 10, 11, 12, 9, 14, 15, 7, 3, 4, 13, 0, 1, 6, 8, 2 | |
139 | }; | |
140 | ||
13cde3b2 | 141 | res = pnp_find_resource(dev, rule->flags, IORESOURCE_IRQ, idx); |
aee3ad81 | 142 | if (res) { |
2f53432c | 143 | pnp_dbg(&dev->dev, " irq %d already set to %d flags %#lx\n", |
28ccffcf | 144 | idx, (int) res->start, res->flags); |
6e906f0e | 145 | return 0; |
81b5c75f BH |
146 | } |
147 | ||
aee3ad81 BH |
148 | res = &local_res; |
149 | res->flags = rule->flags | IORESOURCE_AUTO; | |
150 | res->start = -1; | |
151 | res->end = -1; | |
1da177e4 | 152 | |
7aefff51 | 153 | if (bitmap_empty(rule->map.bits, PNP_IRQ_NR)) { |
28ccffcf | 154 | res->flags |= IORESOURCE_DISABLED; |
2f53432c | 155 | pnp_dbg(&dev->dev, " irq %d disabled\n", idx); |
aee3ad81 | 156 | goto __add; |
1da177e4 LT |
157 | } |
158 | ||
159 | /* TBD: need check for >16 IRQ */ | |
7aefff51 | 160 | res->start = find_next_bit(rule->map.bits, PNP_IRQ_NR, 16); |
28ccffcf BH |
161 | if (res->start < PNP_IRQ_NR) { |
162 | res->end = res->start; | |
aee3ad81 | 163 | goto __add; |
1da177e4 LT |
164 | } |
165 | for (i = 0; i < 16; i++) { | |
7aefff51 | 166 | if (test_bit(xtab[i], rule->map.bits)) { |
28ccffcf | 167 | res->start = res->end = xtab[i]; |
aee3ad81 BH |
168 | if (pnp_check_irq(dev, res)) |
169 | goto __add; | |
1da177e4 LT |
170 | } |
171 | } | |
d5ebde6e BH |
172 | |
173 | if (rule->flags & IORESOURCE_IRQ_OPTIONAL) { | |
174 | res->start = -1; | |
175 | res->end = -1; | |
176 | res->flags |= IORESOURCE_DISABLED; | |
2f53432c | 177 | pnp_dbg(&dev->dev, " irq %d disabled (optional)\n", idx); |
d5ebde6e BH |
178 | goto __add; |
179 | } | |
180 | ||
2f53432c | 181 | pnp_dbg(&dev->dev, " couldn't assign irq %d\n", idx); |
6e906f0e | 182 | return -EBUSY; |
aee3ad81 BH |
183 | |
184 | __add: | |
185 | pnp_add_irq_resource(dev, res->start, res->flags); | |
6e906f0e | 186 | return 0; |
1da177e4 LT |
187 | } |
188 | ||
586f83e2 | 189 | #ifdef CONFIG_ISA_DMA_API |
6e906f0e | 190 | static int pnp_assign_dma(struct pnp_dev *dev, struct pnp_dma *rule, int idx) |
1da177e4 | 191 | { |
aee3ad81 | 192 | struct resource *res, local_res; |
1da177e4 LT |
193 | int i; |
194 | ||
195 | /* DMA priority: this table is good for i386 */ | |
196 | static unsigned short xtab[8] = { | |
197 | 1, 3, 5, 6, 7, 0, 2, 4 | |
198 | }; | |
199 | ||
13cde3b2 | 200 | res = pnp_find_resource(dev, rule->flags, IORESOURCE_DMA, idx); |
aee3ad81 | 201 | if (res) { |
2f53432c | 202 | pnp_dbg(&dev->dev, " dma %d already set to %d flags %#lx\n", |
28ccffcf | 203 | idx, (int) res->start, res->flags); |
6e906f0e | 204 | return 0; |
81b5c75f BH |
205 | } |
206 | ||
aee3ad81 BH |
207 | res = &local_res; |
208 | res->flags = rule->flags | IORESOURCE_AUTO; | |
209 | res->start = -1; | |
210 | res->end = -1; | |
1da177e4 | 211 | |
bdf0eb3a DF |
212 | if (!rule->map) { |
213 | res->flags |= IORESOURCE_DISABLED; | |
214 | pnp_dbg(&dev->dev, " dma %d disabled\n", idx); | |
215 | goto __add; | |
216 | } | |
217 | ||
1da177e4 | 218 | for (i = 0; i < 8; i++) { |
9dd78466 | 219 | if (rule->map & (1 << xtab[i])) { |
28ccffcf | 220 | res->start = res->end = xtab[i]; |
aee3ad81 BH |
221 | if (pnp_check_dma(dev, res)) |
222 | goto __add; | |
1da177e4 LT |
223 | } |
224 | } | |
bdf0eb3a DF |
225 | |
226 | pnp_dbg(&dev->dev, " couldn't assign dma %d\n", idx); | |
227 | return -EBUSY; | |
1da177e4 | 228 | |
aee3ad81 BH |
229 | __add: |
230 | pnp_add_dma_resource(dev, res->start, res->flags); | |
6e906f0e | 231 | return 0; |
d948a8da | 232 | } |
586f83e2 | 233 | #endif /* CONFIG_ISA_DMA_API */ |
d948a8da | 234 | |
2cd13930 | 235 | void pnp_init_resources(struct pnp_dev *dev) |
1da177e4 | 236 | { |
aee3ad81 | 237 | pnp_free_resources(dev); |
1da177e4 LT |
238 | } |
239 | ||
6969c7ed | 240 | static void pnp_clean_resource_table(struct pnp_dev *dev) |
1da177e4 | 241 | { |
aee3ad81 BH |
242 | struct pnp_resource *pnp_res, *tmp; |
243 | ||
244 | list_for_each_entry_safe(pnp_res, tmp, &dev->resources, list) { | |
245 | if (pnp_res->res.flags & IORESOURCE_AUTO) | |
246 | pnp_free_resource(pnp_res); | |
1da177e4 LT |
247 | } |
248 | } | |
249 | ||
250 | /** | |
251 | * pnp_assign_resources - assigns resources to the device based on the specified dependent number | |
252 | * @dev: pointer to the desired device | |
1f32ca31 | 253 | * @set: the dependent function number |
1da177e4 | 254 | */ |
1f32ca31 | 255 | static int pnp_assign_resources(struct pnp_dev *dev, int set) |
1da177e4 | 256 | { |
1f32ca31 | 257 | struct pnp_option *option; |
586f83e2 DR |
258 | int nport = 0, nmem = 0, nirq = 0; |
259 | int ndma __maybe_unused = 0; | |
1f32ca31 | 260 | int ret = 0; |
1da177e4 | 261 | |
2f53432c | 262 | pnp_dbg(&dev->dev, "pnp_assign_resources, try dependent set %d\n", set); |
b3bd86e2 | 263 | mutex_lock(&pnp_res_mutex); |
6969c7ed | 264 | pnp_clean_resource_table(dev); |
1da177e4 | 265 | |
1f32ca31 BH |
266 | list_for_each_entry(option, &dev->options, list) { |
267 | if (pnp_option_is_dependent(option) && | |
268 | pnp_option_set(option) != set) | |
269 | continue; | |
270 | ||
271 | switch (option->type) { | |
272 | case IORESOURCE_IO: | |
273 | ret = pnp_assign_port(dev, &option->u.port, nport++); | |
274 | break; | |
275 | case IORESOURCE_MEM: | |
276 | ret = pnp_assign_mem(dev, &option->u.mem, nmem++); | |
277 | break; | |
278 | case IORESOURCE_IRQ: | |
279 | ret = pnp_assign_irq(dev, &option->u.irq, nirq++); | |
280 | break; | |
586f83e2 | 281 | #ifdef CONFIG_ISA_DMA_API |
1f32ca31 BH |
282 | case IORESOURCE_DMA: |
283 | ret = pnp_assign_dma(dev, &option->u.dma, ndma++); | |
284 | break; | |
586f83e2 | 285 | #endif |
1f32ca31 BH |
286 | default: |
287 | ret = -EINVAL; | |
288 | break; | |
1da177e4 | 289 | } |
1f32ca31 BH |
290 | if (ret < 0) |
291 | break; | |
292 | } | |
1da177e4 | 293 | |
b3bd86e2 | 294 | mutex_unlock(&pnp_res_mutex); |
1f32ca31 | 295 | if (ret < 0) { |
2f53432c | 296 | pnp_dbg(&dev->dev, "pnp_assign_resources failed (%d)\n", ret); |
1f32ca31 BH |
297 | pnp_clean_resource_table(dev); |
298 | } else | |
299 | dbg_pnp_show_resources(dev, "pnp_assign_resources succeeded"); | |
300 | return ret; | |
1da177e4 LT |
301 | } |
302 | ||
1da177e4 LT |
303 | /** |
304 | * pnp_auto_config_dev - automatically assigns resources to a device | |
305 | * @dev: pointer to the desired device | |
1da177e4 LT |
306 | */ |
307 | int pnp_auto_config_dev(struct pnp_dev *dev) | |
308 | { | |
1f32ca31 | 309 | int i, ret; |
1da177e4 | 310 | |
9dd78466 | 311 | if (!pnp_can_configure(dev)) { |
2f53432c | 312 | pnp_dbg(&dev->dev, "configuration not supported\n"); |
1da177e4 LT |
313 | return -ENODEV; |
314 | } | |
315 | ||
1f32ca31 BH |
316 | ret = pnp_assign_resources(dev, 0); |
317 | if (ret == 0) | |
318 | return 0; | |
319 | ||
320 | for (i = 1; i < dev->num_dependent_sets; i++) { | |
321 | ret = pnp_assign_resources(dev, i); | |
322 | if (ret == 0) | |
1da177e4 | 323 | return 0; |
1da177e4 LT |
324 | } |
325 | ||
a05d0781 | 326 | dev_err(&dev->dev, "unable to assign resources\n"); |
1f32ca31 | 327 | return ret; |
1da177e4 LT |
328 | } |
329 | ||
68094e32 PO |
330 | /** |
331 | * pnp_start_dev - low-level start of the PnP device | |
332 | * @dev: pointer to the desired device | |
333 | * | |
07d4e9af | 334 | * assumes that resources have already been allocated |
68094e32 | 335 | */ |
68094e32 PO |
336 | int pnp_start_dev(struct pnp_dev *dev) |
337 | { | |
338 | if (!pnp_can_write(dev)) { | |
2f53432c | 339 | pnp_dbg(&dev->dev, "activation not supported\n"); |
68094e32 PO |
340 | return -EINVAL; |
341 | } | |
342 | ||
81b5c75f | 343 | dbg_pnp_show_resources(dev, "pnp_start_dev"); |
59284cb4 | 344 | if (dev->protocol->set(dev) < 0) { |
a05d0781 | 345 | dev_err(&dev->dev, "activation failed\n"); |
68094e32 PO |
346 | return -EIO; |
347 | } | |
348 | ||
a05d0781 | 349 | dev_info(&dev->dev, "activated\n"); |
68094e32 PO |
350 | return 0; |
351 | } | |
352 | ||
353 | /** | |
354 | * pnp_stop_dev - low-level disable of the PnP device | |
355 | * @dev: pointer to the desired device | |
356 | * | |
357 | * does not free resources | |
358 | */ | |
68094e32 PO |
359 | int pnp_stop_dev(struct pnp_dev *dev) |
360 | { | |
361 | if (!pnp_can_disable(dev)) { | |
2f53432c | 362 | pnp_dbg(&dev->dev, "disabling not supported\n"); |
68094e32 PO |
363 | return -EINVAL; |
364 | } | |
9dd78466 | 365 | if (dev->protocol->disable(dev) < 0) { |
a05d0781 | 366 | dev_err(&dev->dev, "disable failed\n"); |
68094e32 PO |
367 | return -EIO; |
368 | } | |
369 | ||
a05d0781 | 370 | dev_info(&dev->dev, "disabled\n"); |
68094e32 PO |
371 | return 0; |
372 | } | |
373 | ||
1da177e4 LT |
374 | /** |
375 | * pnp_activate_dev - activates a PnP device for use | |
376 | * @dev: pointer to the desired device | |
377 | * | |
378 | * does not validate or set resources so be careful. | |
379 | */ | |
380 | int pnp_activate_dev(struct pnp_dev *dev) | |
381 | { | |
68094e32 PO |
382 | int error; |
383 | ||
07d4e9af | 384 | if (dev->active) |
cc8259a6 | 385 | return 0; |
1da177e4 LT |
386 | |
387 | /* ensure resources are allocated */ | |
388 | if (pnp_auto_config_dev(dev)) | |
389 | return -EBUSY; | |
390 | ||
68094e32 PO |
391 | error = pnp_start_dev(dev); |
392 | if (error) | |
393 | return error; | |
1da177e4 LT |
394 | |
395 | dev->active = 1; | |
cc8259a6 | 396 | return 0; |
1da177e4 LT |
397 | } |
398 | ||
399 | /** | |
400 | * pnp_disable_dev - disables device | |
401 | * @dev: pointer to the desired device | |
402 | * | |
403 | * inform the correct pnp protocol so that resources can be used by other devices | |
404 | */ | |
405 | int pnp_disable_dev(struct pnp_dev *dev) | |
406 | { | |
68094e32 PO |
407 | int error; |
408 | ||
07d4e9af | 409 | if (!dev->active) |
cc8259a6 | 410 | return 0; |
1da177e4 | 411 | |
68094e32 PO |
412 | error = pnp_stop_dev(dev); |
413 | if (error) | |
414 | return error; | |
1da177e4 LT |
415 | |
416 | dev->active = 0; | |
1da177e4 LT |
417 | |
418 | /* release the resources so that other devices can use them */ | |
b3bd86e2 | 419 | mutex_lock(&pnp_res_mutex); |
6969c7ed | 420 | pnp_clean_resource_table(dev); |
b3bd86e2 | 421 | mutex_unlock(&pnp_res_mutex); |
1da177e4 | 422 | |
cc8259a6 | 423 | return 0; |
1da177e4 LT |
424 | } |
425 | ||
68094e32 PO |
426 | EXPORT_SYMBOL(pnp_start_dev); |
427 | EXPORT_SYMBOL(pnp_stop_dev); | |
1da177e4 LT |
428 | EXPORT_SYMBOL(pnp_activate_dev); |
429 | EXPORT_SYMBOL(pnp_disable_dev); |