2 * manager.c - Resource Management, Conflict Resolution, Activation and Disabling of Devices
4 * based on isapnp.c resource management (c) Jaroslav Kysela <perex@perex.cz>
5 * Copyright 2003 Adam Belay <ambx1@neo.rr.com>
8 #include <linux/errno.h>
9 #include <linux/module.h>
10 #include <linux/init.h>
11 #include <linux/kernel.h>
12 #include <linux/pnp.h>
13 #include <linux/slab.h>
14 #include <linux/bitmap.h>
15 #include <linux/mutex.h>
18 DEFINE_MUTEX(pnp_res_mutex);
20 static int pnp_assign_port(struct pnp_dev *dev, struct pnp_port *rule, int idx)
22 resource_size_t *start, *end;
25 if (idx >= PNP_MAX_PORT) {
26 dev_err(&dev->dev, "too many I/O port resources\n");
27 /* pretend we were successful so at least the manager won't try again */
31 start = &dev->res.port_resource[idx].start;
32 end = &dev->res.port_resource[idx].end;
33 flags = &dev->res.port_resource[idx].flags;
35 /* check if this resource has been manually set, if so skip */
36 if (!(dev->res.port_resource[idx].flags & IORESOURCE_AUTO)) {
37 dev_dbg(&dev->dev, " io %d already set to %#llx-%#llx "
38 "flags %#lx\n", idx, (unsigned long long) *start,
39 (unsigned long long) *end, *flags);
43 /* set the initial values */
44 *flags |= rule->flags | IORESOURCE_IO;
45 *flags &= ~IORESOURCE_UNSET;
48 *flags |= IORESOURCE_DISABLED;
49 dev_dbg(&dev->dev, " io %d disabled\n", idx);
50 return 1; /* skip disabled resource requests */
54 *end = *start + rule->size - 1;
56 /* run through until pnp_check_port is happy */
57 while (!pnp_check_port(dev, idx)) {
58 *start += rule->align;
59 *end = *start + rule->size - 1;
60 if (*start > rule->max || !rule->align) {
61 dev_dbg(&dev->dev, " couldn't assign io %d\n", idx);
65 dev_dbg(&dev->dev, " assign io %d %#llx-%#llx\n", idx,
66 (unsigned long long) *start, (unsigned long long) *end);
70 static int pnp_assign_mem(struct pnp_dev *dev, struct pnp_mem *rule, int idx)
72 resource_size_t *start, *end;
75 if (idx >= PNP_MAX_MEM) {
76 dev_err(&dev->dev, "too many memory resources\n");
77 /* pretend we were successful so at least the manager won't try again */
81 start = &dev->res.mem_resource[idx].start;
82 end = &dev->res.mem_resource[idx].end;
83 flags = &dev->res.mem_resource[idx].flags;
85 /* check if this resource has been manually set, if so skip */
86 if (!(dev->res.mem_resource[idx].flags & IORESOURCE_AUTO)) {
87 dev_dbg(&dev->dev, " mem %d already set to %#llx-%#llx "
88 "flags %#lx\n", idx, (unsigned long long) *start,
89 (unsigned long long) *end, *flags);
93 /* set the initial values */
94 *flags |= rule->flags | IORESOURCE_MEM;
95 *flags &= ~IORESOURCE_UNSET;
97 /* convert pnp flags to standard Linux flags */
98 if (!(rule->flags & IORESOURCE_MEM_WRITEABLE))
99 *flags |= IORESOURCE_READONLY;
100 if (rule->flags & IORESOURCE_MEM_CACHEABLE)
101 *flags |= IORESOURCE_CACHEABLE;
102 if (rule->flags & IORESOURCE_MEM_RANGELENGTH)
103 *flags |= IORESOURCE_RANGELENGTH;
104 if (rule->flags & IORESOURCE_MEM_SHADOWABLE)
105 *flags |= IORESOURCE_SHADOWABLE;
108 *flags |= IORESOURCE_DISABLED;
109 dev_dbg(&dev->dev, " mem %d disabled\n", idx);
110 return 1; /* skip disabled resource requests */
114 *end = *start + rule->size - 1;
116 /* run through until pnp_check_mem is happy */
117 while (!pnp_check_mem(dev, idx)) {
118 *start += rule->align;
119 *end = *start + rule->size - 1;
120 if (*start > rule->max || !rule->align) {
121 dev_dbg(&dev->dev, " couldn't assign mem %d\n", idx);
125 dev_dbg(&dev->dev, " assign mem %d %#llx-%#llx\n", idx,
126 (unsigned long long) *start, (unsigned long long) *end);
130 static int pnp_assign_irq(struct pnp_dev *dev, struct pnp_irq *rule, int idx)
132 resource_size_t *start, *end;
133 unsigned long *flags;
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
141 if (idx >= PNP_MAX_IRQ) {
142 dev_err(&dev->dev, "too many IRQ resources\n");
143 /* pretend we were successful so at least the manager won't try again */
147 start = &dev->res.irq_resource[idx].start;
148 end = &dev->res.irq_resource[idx].end;
149 flags = &dev->res.irq_resource[idx].flags;
151 /* check if this resource has been manually set, if so skip */
152 if (!(dev->res.irq_resource[idx].flags & IORESOURCE_AUTO)) {
153 dev_dbg(&dev->dev, " irq %d already set to %d flags %#lx\n",
154 idx, (int) *start, *flags);
158 /* set the initial values */
159 *flags |= rule->flags | IORESOURCE_IRQ;
160 *flags &= ~IORESOURCE_UNSET;
162 if (bitmap_empty(rule->map, PNP_IRQ_NR)) {
163 *flags |= IORESOURCE_DISABLED;
164 dev_dbg(&dev->dev, " irq %d disabled\n", idx);
165 return 1; /* skip disabled resource requests */
168 /* TBD: need check for >16 IRQ */
169 *start = find_next_bit(rule->map, PNP_IRQ_NR, 16);
170 if (*start < PNP_IRQ_NR) {
172 dev_dbg(&dev->dev, " assign irq %d %d\n", idx, (int) *start);
175 for (i = 0; i < 16; i++) {
176 if (test_bit(xtab[i], rule->map)) {
177 *start = *end = xtab[i];
178 if (pnp_check_irq(dev, idx)) {
179 dev_dbg(&dev->dev, " assign irq %d %d\n", idx,
185 dev_dbg(&dev->dev, " couldn't assign irq %d\n", idx);
189 static void pnp_assign_dma(struct pnp_dev *dev, struct pnp_dma *rule, int idx)
191 resource_size_t *start, *end;
192 unsigned long *flags;
195 /* DMA priority: this table is good for i386 */
196 static unsigned short xtab[8] = {
197 1, 3, 5, 6, 7, 0, 2, 4
200 if (idx >= PNP_MAX_DMA) {
201 dev_err(&dev->dev, "too many DMA resources\n");
205 start = &dev->res.dma_resource[idx].start;
206 end = &dev->res.dma_resource[idx].end;
207 flags = &dev->res.dma_resource[idx].flags;
209 /* check if this resource has been manually set, if so skip */
210 if (!(dev->res.dma_resource[idx].flags & IORESOURCE_AUTO)) {
211 dev_dbg(&dev->dev, " dma %d already set to %d flags %#lx\n",
212 idx, (int) *start, *flags);
216 /* set the initial values */
217 *flags |= rule->flags | IORESOURCE_DMA;
218 *flags &= ~IORESOURCE_UNSET;
220 for (i = 0; i < 8; i++) {
221 if (rule->map & (1 << xtab[i])) {
222 *start = *end = xtab[i];
223 if (pnp_check_dma(dev, idx)) {
224 dev_dbg(&dev->dev, " assign dma %d %d\n", idx,
230 #ifdef MAX_DMA_CHANNELS
231 *start = *end = MAX_DMA_CHANNELS;
233 *flags |= IORESOURCE_UNSET | IORESOURCE_DISABLED;
234 dev_dbg(&dev->dev, " disable dma %d\n", idx);
237 void pnp_init_resource(struct resource *res)
241 type = res->flags & (IORESOURCE_IO | IORESOURCE_MEM |
242 IORESOURCE_IRQ | IORESOURCE_DMA);
245 res->flags = type | IORESOURCE_AUTO | IORESOURCE_UNSET;
246 if (type == IORESOURCE_IRQ || type == IORESOURCE_DMA) {
256 * pnp_init_resources - Resets a resource table to default values.
257 * @table: pointer to the desired resource table
259 void pnp_init_resources(struct pnp_dev *dev)
261 struct resource *res;
264 for (idx = 0; idx < PNP_MAX_IRQ; idx++) {
265 res = &dev->res.irq_resource[idx];
266 res->flags = IORESOURCE_IRQ;
267 pnp_init_resource(res);
269 for (idx = 0; idx < PNP_MAX_DMA; idx++) {
270 res = &dev->res.dma_resource[idx];
271 res->flags = IORESOURCE_DMA;
272 pnp_init_resource(res);
274 for (idx = 0; idx < PNP_MAX_PORT; idx++) {
275 res = &dev->res.port_resource[idx];
276 res->flags = IORESOURCE_IO;
277 pnp_init_resource(res);
279 for (idx = 0; idx < PNP_MAX_MEM; idx++) {
280 res = &dev->res.mem_resource[idx];
281 res->flags = IORESOURCE_MEM;
282 pnp_init_resource(res);
287 * pnp_clean_resources - clears resources that were not manually set
288 * @res: the resources to clean
290 static void pnp_clean_resource_table(struct pnp_dev *dev)
292 struct resource *res;
295 for (idx = 0; idx < PNP_MAX_IRQ; idx++) {
296 res = &dev->res.irq_resource[idx];
297 if (res->flags & IORESOURCE_AUTO) {
298 res->flags = IORESOURCE_IRQ;
299 pnp_init_resource(res);
302 for (idx = 0; idx < PNP_MAX_DMA; idx++) {
303 res = &dev->res.dma_resource[idx];
304 if (res->flags & IORESOURCE_AUTO) {
305 res->flags = IORESOURCE_DMA;
306 pnp_init_resource(res);
309 for (idx = 0; idx < PNP_MAX_PORT; idx++) {
310 res = &dev->res.port_resource[idx];
311 if (res->flags & IORESOURCE_AUTO) {
312 res->flags = IORESOURCE_IO;
313 pnp_init_resource(res);
316 for (idx = 0; idx < PNP_MAX_MEM; idx++) {
317 res = &dev->res.mem_resource[idx];
318 if (res->flags & IORESOURCE_AUTO) {
319 res->flags = IORESOURCE_MEM;
320 pnp_init_resource(res);
326 * pnp_assign_resources - assigns resources to the device based on the specified dependent number
327 * @dev: pointer to the desired device
328 * @depnum: the dependent function number
330 * Only set depnum to 0 if the device does not have dependent options.
332 static int pnp_assign_resources(struct pnp_dev *dev, int depnum)
334 struct pnp_port *port;
338 int nport = 0, nmem = 0, nirq = 0, ndma = 0;
340 if (!pnp_can_configure(dev))
343 dbg_pnp_show_resources(dev, "before pnp_assign_resources");
344 mutex_lock(&pnp_res_mutex);
345 pnp_clean_resource_table(dev);
346 if (dev->independent) {
347 dev_dbg(&dev->dev, "assigning independent options\n");
348 port = dev->independent->port;
349 mem = dev->independent->mem;
350 irq = dev->independent->irq;
351 dma = dev->independent->dma;
353 if (!pnp_assign_port(dev, port, nport))
359 if (!pnp_assign_mem(dev, mem, nmem))
365 if (!pnp_assign_irq(dev, irq, nirq))
371 pnp_assign_dma(dev, dma, ndma);
378 struct pnp_option *dep;
381 dev_dbg(&dev->dev, "assigning dependent option %d\n", depnum);
382 for (i = 1, dep = dev->dependent; i < depnum;
383 i++, dep = dep->next)
391 if (!pnp_assign_port(dev, port, nport))
397 if (!pnp_assign_mem(dev, mem, nmem))
403 if (!pnp_assign_irq(dev, irq, nirq))
409 pnp_assign_dma(dev, dma, ndma);
413 } else if (dev->dependent)
416 mutex_unlock(&pnp_res_mutex);
417 dbg_pnp_show_resources(dev, "after pnp_assign_resources");
421 pnp_clean_resource_table(dev);
422 mutex_unlock(&pnp_res_mutex);
423 dbg_pnp_show_resources(dev, "after pnp_assign_resources (failed)");
428 * pnp_auto_config_dev - automatically assigns resources to a device
429 * @dev: pointer to the desired device
431 int pnp_auto_config_dev(struct pnp_dev *dev)
433 struct pnp_option *dep;
436 if (!pnp_can_configure(dev)) {
437 dev_dbg(&dev->dev, "configuration not supported\n");
441 if (!dev->dependent) {
442 if (pnp_assign_resources(dev, 0))
445 dep = dev->dependent;
447 if (pnp_assign_resources(dev, i))
454 dev_err(&dev->dev, "unable to assign resources\n");
459 * pnp_start_dev - low-level start of the PnP device
460 * @dev: pointer to the desired device
462 * assumes that resources have already been allocated
464 int pnp_start_dev(struct pnp_dev *dev)
466 if (!pnp_can_write(dev)) {
467 dev_dbg(&dev->dev, "activation not supported\n");
471 dbg_pnp_show_resources(dev, "pnp_start_dev");
472 if (dev->protocol->set(dev) < 0) {
473 dev_err(&dev->dev, "activation failed\n");
477 dev_info(&dev->dev, "activated\n");
482 * pnp_stop_dev - low-level disable of the PnP device
483 * @dev: pointer to the desired device
485 * does not free resources
487 int pnp_stop_dev(struct pnp_dev *dev)
489 if (!pnp_can_disable(dev)) {
490 dev_dbg(&dev->dev, "disabling not supported\n");
493 if (dev->protocol->disable(dev) < 0) {
494 dev_err(&dev->dev, "disable failed\n");
498 dev_info(&dev->dev, "disabled\n");
503 * pnp_activate_dev - activates a PnP device for use
504 * @dev: pointer to the desired device
506 * does not validate or set resources so be careful.
508 int pnp_activate_dev(struct pnp_dev *dev)
515 /* ensure resources are allocated */
516 if (pnp_auto_config_dev(dev))
519 error = pnp_start_dev(dev);
528 * pnp_disable_dev - disables device
529 * @dev: pointer to the desired device
531 * inform the correct pnp protocol so that resources can be used by other devices
533 int pnp_disable_dev(struct pnp_dev *dev)
540 error = pnp_stop_dev(dev);
546 /* release the resources so that other devices can use them */
547 mutex_lock(&pnp_res_mutex);
548 pnp_clean_resource_table(dev);
549 mutex_unlock(&pnp_res_mutex);
554 EXPORT_SYMBOL(pnp_start_dev);
555 EXPORT_SYMBOL(pnp_stop_dev);
556 EXPORT_SYMBOL(pnp_activate_dev);
557 EXPORT_SYMBOL(pnp_disable_dev);