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