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