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); | |
81b5c75f BH |
29 | return 1; |
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); | |
1da177e4 | 54 | return 0; |
81b5c75f | 55 | } |
1da177e4 | 56 | } |
aee3ad81 BH |
57 | |
58 | __add: | |
59 | pnp_add_io_resource(dev, res->start, res->end, res->flags); | |
1da177e4 LT |
60 | return 1; |
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); | |
81b5c75f BH |
72 | return 1; |
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); | |
1da177e4 | 106 | return 0; |
81b5c75f | 107 | } |
1da177e4 | 108 | } |
aee3ad81 BH |
109 | |
110 | __add: | |
111 | pnp_add_mem_resource(dev, res->start, res->end, res->flags); | |
1da177e4 LT |
112 | return 1; |
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); |
81b5c75f BH |
129 | return 1; |
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); |
1da177e4 | 157 | return 0; |
aee3ad81 BH |
158 | |
159 | __add: | |
160 | pnp_add_irq_resource(dev, res->start, res->flags); | |
161 | return 1; | |
1da177e4 LT |
162 | } |
163 | ||
7ef36390 | 164 | static void 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); |
81b5c75f BH |
178 | return; |
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); | |
d948a8da BH |
201 | } |
202 | ||
2cd13930 | 203 | void pnp_init_resources(struct pnp_dev *dev) |
1da177e4 | 204 | { |
aee3ad81 | 205 | pnp_free_resources(dev); |
1da177e4 LT |
206 | } |
207 | ||
6969c7ed | 208 | static void pnp_clean_resource_table(struct pnp_dev *dev) |
1da177e4 | 209 | { |
aee3ad81 BH |
210 | struct pnp_resource *pnp_res, *tmp; |
211 | ||
212 | list_for_each_entry_safe(pnp_res, tmp, &dev->resources, list) { | |
213 | if (pnp_res->res.flags & IORESOURCE_AUTO) | |
214 | pnp_free_resource(pnp_res); | |
1da177e4 LT |
215 | } |
216 | } | |
217 | ||
218 | /** | |
219 | * pnp_assign_resources - assigns resources to the device based on the specified dependent number | |
220 | * @dev: pointer to the desired device | |
221 | * @depnum: the dependent function number | |
222 | * | |
223 | * Only set depnum to 0 if the device does not have dependent options. | |
224 | */ | |
225 | static int pnp_assign_resources(struct pnp_dev *dev, int depnum) | |
226 | { | |
227 | struct pnp_port *port; | |
228 | struct pnp_mem *mem; | |
229 | struct pnp_irq *irq; | |
230 | struct pnp_dma *dma; | |
231 | int nport = 0, nmem = 0, nirq = 0, ndma = 0; | |
232 | ||
233 | if (!pnp_can_configure(dev)) | |
234 | return -ENODEV; | |
235 | ||
81b5c75f | 236 | dbg_pnp_show_resources(dev, "before pnp_assign_resources"); |
b3bd86e2 | 237 | mutex_lock(&pnp_res_mutex); |
6969c7ed | 238 | pnp_clean_resource_table(dev); |
1da177e4 | 239 | if (dev->independent) { |
81b5c75f | 240 | dev_dbg(&dev->dev, "assigning independent options\n"); |
1da177e4 LT |
241 | port = dev->independent->port; |
242 | mem = dev->independent->mem; | |
243 | irq = dev->independent->irq; | |
244 | dma = dev->independent->dma; | |
245 | while (port) { | |
246 | if (!pnp_assign_port(dev, port, nport)) | |
247 | goto fail; | |
248 | nport++; | |
249 | port = port->next; | |
250 | } | |
251 | while (mem) { | |
252 | if (!pnp_assign_mem(dev, mem, nmem)) | |
253 | goto fail; | |
254 | nmem++; | |
255 | mem = mem->next; | |
256 | } | |
257 | while (irq) { | |
258 | if (!pnp_assign_irq(dev, irq, nirq)) | |
259 | goto fail; | |
260 | nirq++; | |
261 | irq = irq->next; | |
262 | } | |
263 | while (dma) { | |
7ef36390 | 264 | pnp_assign_dma(dev, dma, ndma); |
1da177e4 LT |
265 | ndma++; |
266 | dma = dma->next; | |
267 | } | |
268 | } | |
269 | ||
270 | if (depnum) { | |
271 | struct pnp_option *dep; | |
272 | int i; | |
81b5c75f BH |
273 | |
274 | dev_dbg(&dev->dev, "assigning dependent option %d\n", depnum); | |
9dd78466 BH |
275 | for (i = 1, dep = dev->dependent; i < depnum; |
276 | i++, dep = dep->next) | |
277 | if (!dep) | |
1da177e4 | 278 | goto fail; |
9dd78466 | 279 | port = dep->port; |
1da177e4 LT |
280 | mem = dep->mem; |
281 | irq = dep->irq; | |
282 | dma = dep->dma; | |
283 | while (port) { | |
284 | if (!pnp_assign_port(dev, port, nport)) | |
285 | goto fail; | |
286 | nport++; | |
287 | port = port->next; | |
288 | } | |
289 | while (mem) { | |
290 | if (!pnp_assign_mem(dev, mem, nmem)) | |
291 | goto fail; | |
292 | nmem++; | |
293 | mem = mem->next; | |
294 | } | |
295 | while (irq) { | |
296 | if (!pnp_assign_irq(dev, irq, nirq)) | |
297 | goto fail; | |
298 | nirq++; | |
299 | irq = irq->next; | |
300 | } | |
301 | while (dma) { | |
7ef36390 | 302 | pnp_assign_dma(dev, dma, ndma); |
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); |