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