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);
238 * pnp_init_resources - Resets a resource table to default values.
239 * @table: pointer to the desired resource table
241 void pnp_init_resource_table(struct pnp_resource_table *table)
245 for (idx = 0; idx < PNP_MAX_IRQ; idx++) {
246 table->irq_resource[idx].name = NULL;
247 table->irq_resource[idx].start = -1;
248 table->irq_resource[idx].end = -1;
249 table->irq_resource[idx].flags =
250 IORESOURCE_IRQ | IORESOURCE_AUTO | IORESOURCE_UNSET;
252 for (idx = 0; idx < PNP_MAX_DMA; idx++) {
253 table->dma_resource[idx].name = NULL;
254 table->dma_resource[idx].start = -1;
255 table->dma_resource[idx].end = -1;
256 table->dma_resource[idx].flags =
257 IORESOURCE_DMA | IORESOURCE_AUTO | IORESOURCE_UNSET;
259 for (idx = 0; idx < PNP_MAX_PORT; idx++) {
260 table->port_resource[idx].name = NULL;
261 table->port_resource[idx].start = 0;
262 table->port_resource[idx].end = 0;
263 table->port_resource[idx].flags =
264 IORESOURCE_IO | IORESOURCE_AUTO | IORESOURCE_UNSET;
266 for (idx = 0; idx < PNP_MAX_MEM; idx++) {
267 table->mem_resource[idx].name = NULL;
268 table->mem_resource[idx].start = 0;
269 table->mem_resource[idx].end = 0;
270 table->mem_resource[idx].flags =
271 IORESOURCE_MEM | IORESOURCE_AUTO | IORESOURCE_UNSET;
276 * pnp_clean_resources - clears resources that were not manually set
277 * @res: the resources to clean
279 static void pnp_clean_resource_table(struct pnp_resource_table *res)
283 for (idx = 0; idx < PNP_MAX_IRQ; idx++) {
284 if (!(res->irq_resource[idx].flags & IORESOURCE_AUTO))
286 res->irq_resource[idx].start = -1;
287 res->irq_resource[idx].end = -1;
288 res->irq_resource[idx].flags =
289 IORESOURCE_IRQ | IORESOURCE_AUTO | IORESOURCE_UNSET;
291 for (idx = 0; idx < PNP_MAX_DMA; idx++) {
292 if (!(res->dma_resource[idx].flags & IORESOURCE_AUTO))
294 res->dma_resource[idx].start = -1;
295 res->dma_resource[idx].end = -1;
296 res->dma_resource[idx].flags =
297 IORESOURCE_DMA | IORESOURCE_AUTO | IORESOURCE_UNSET;
299 for (idx = 0; idx < PNP_MAX_PORT; idx++) {
300 if (!(res->port_resource[idx].flags & IORESOURCE_AUTO))
302 res->port_resource[idx].start = 0;
303 res->port_resource[idx].end = 0;
304 res->port_resource[idx].flags =
305 IORESOURCE_IO | IORESOURCE_AUTO | IORESOURCE_UNSET;
307 for (idx = 0; idx < PNP_MAX_MEM; idx++) {
308 if (!(res->mem_resource[idx].flags & IORESOURCE_AUTO))
310 res->mem_resource[idx].start = 0;
311 res->mem_resource[idx].end = 0;
312 res->mem_resource[idx].flags =
313 IORESOURCE_MEM | IORESOURCE_AUTO | IORESOURCE_UNSET;
318 * pnp_assign_resources - assigns resources to the device based on the specified dependent number
319 * @dev: pointer to the desired device
320 * @depnum: the dependent function number
322 * Only set depnum to 0 if the device does not have dependent options.
324 static int pnp_assign_resources(struct pnp_dev *dev, int depnum)
326 struct pnp_port *port;
330 int nport = 0, nmem = 0, nirq = 0, ndma = 0;
332 if (!pnp_can_configure(dev))
335 dbg_pnp_show_resources(dev, "before pnp_assign_resources");
336 mutex_lock(&pnp_res_mutex);
337 pnp_clean_resource_table(&dev->res); /* start with a fresh slate */
338 if (dev->independent) {
339 dev_dbg(&dev->dev, "assigning independent options\n");
340 port = dev->independent->port;
341 mem = dev->independent->mem;
342 irq = dev->independent->irq;
343 dma = dev->independent->dma;
345 if (!pnp_assign_port(dev, port, nport))
351 if (!pnp_assign_mem(dev, mem, nmem))
357 if (!pnp_assign_irq(dev, irq, nirq))
363 pnp_assign_dma(dev, dma, ndma);
370 struct pnp_option *dep;
373 dev_dbg(&dev->dev, "assigning dependent option %d\n", depnum);
374 for (i = 1, dep = dev->dependent; i < depnum;
375 i++, dep = dep->next)
383 if (!pnp_assign_port(dev, port, nport))
389 if (!pnp_assign_mem(dev, mem, nmem))
395 if (!pnp_assign_irq(dev, irq, nirq))
401 pnp_assign_dma(dev, dma, ndma);
405 } else if (dev->dependent)
408 mutex_unlock(&pnp_res_mutex);
409 dbg_pnp_show_resources(dev, "after pnp_assign_resources");
413 pnp_clean_resource_table(&dev->res);
414 mutex_unlock(&pnp_res_mutex);
415 dbg_pnp_show_resources(dev, "after pnp_assign_resources (failed)");
420 * pnp_manual_config_dev - Disables Auto Config and Manually sets the resource table
421 * @dev: pointer to the desired device
422 * @res: pointer to the new resource config
423 * @mode: 0 or PNP_CONFIG_FORCE
425 * This function can be used by drivers that want to manually set thier resources.
427 int pnp_manual_config_dev(struct pnp_dev *dev, struct pnp_resource_table *res,
431 struct pnp_resource_table *bak;
433 if (!pnp_can_configure(dev))
435 bak = pnp_alloc(sizeof(struct pnp_resource_table));
440 mutex_lock(&pnp_res_mutex);
442 if (!(mode & PNP_CONFIG_FORCE)) {
443 for (i = 0; i < PNP_MAX_PORT; i++) {
444 if (!pnp_check_port(dev, i))
447 for (i = 0; i < PNP_MAX_MEM; i++) {
448 if (!pnp_check_mem(dev, i))
451 for (i = 0; i < PNP_MAX_IRQ; i++) {
452 if (!pnp_check_irq(dev, i))
455 for (i = 0; i < PNP_MAX_DMA; i++) {
456 if (!pnp_check_dma(dev, i))
460 mutex_unlock(&pnp_res_mutex);
467 mutex_unlock(&pnp_res_mutex);
473 * pnp_auto_config_dev - automatically assigns resources to a device
474 * @dev: pointer to the desired device
476 int pnp_auto_config_dev(struct pnp_dev *dev)
478 struct pnp_option *dep;
481 if (!pnp_can_configure(dev)) {
482 dev_dbg(&dev->dev, "configuration not supported\n");
486 if (!dev->dependent) {
487 if (pnp_assign_resources(dev, 0))
490 dep = dev->dependent;
492 if (pnp_assign_resources(dev, i))
499 dev_err(&dev->dev, "unable to assign resources\n");
504 * pnp_start_dev - low-level start of the PnP device
505 * @dev: pointer to the desired device
507 * assumes that resources have already been allocated
509 int pnp_start_dev(struct pnp_dev *dev)
511 if (!pnp_can_write(dev)) {
512 dev_dbg(&dev->dev, "activation not supported\n");
516 dbg_pnp_show_resources(dev, "pnp_start_dev");
517 if (dev->protocol->set(dev) < 0) {
518 dev_err(&dev->dev, "activation failed\n");
522 dev_info(&dev->dev, "activated\n");
527 * pnp_stop_dev - low-level disable of the PnP device
528 * @dev: pointer to the desired device
530 * does not free resources
532 int pnp_stop_dev(struct pnp_dev *dev)
534 if (!pnp_can_disable(dev)) {
535 dev_dbg(&dev->dev, "disabling not supported\n");
538 if (dev->protocol->disable(dev) < 0) {
539 dev_err(&dev->dev, "disable failed\n");
543 dev_info(&dev->dev, "disabled\n");
548 * pnp_activate_dev - activates a PnP device for use
549 * @dev: pointer to the desired device
551 * does not validate or set resources so be careful.
553 int pnp_activate_dev(struct pnp_dev *dev)
560 /* ensure resources are allocated */
561 if (pnp_auto_config_dev(dev))
564 error = pnp_start_dev(dev);
573 * pnp_disable_dev - disables device
574 * @dev: pointer to the desired device
576 * inform the correct pnp protocol so that resources can be used by other devices
578 int pnp_disable_dev(struct pnp_dev *dev)
585 error = pnp_stop_dev(dev);
591 /* release the resources so that other devices can use them */
592 mutex_lock(&pnp_res_mutex);
593 pnp_clean_resource_table(&dev->res);
594 mutex_unlock(&pnp_res_mutex);
600 * pnp_resource_change - change one resource
601 * @resource: pointer to resource to be changed
602 * @start: start of region
603 * @size: size of region
605 void pnp_resource_change(struct resource *resource, resource_size_t start,
606 resource_size_t size)
608 resource->flags &= ~(IORESOURCE_AUTO | IORESOURCE_UNSET);
609 resource->start = start;
610 resource->end = start + size - 1;
613 EXPORT_SYMBOL(pnp_manual_config_dev);
614 EXPORT_SYMBOL(pnp_start_dev);
615 EXPORT_SYMBOL(pnp_stop_dev);
616 EXPORT_SYMBOL(pnp_activate_dev);
617 EXPORT_SYMBOL(pnp_disable_dev);
618 EXPORT_SYMBOL(pnp_resource_change);
619 EXPORT_SYMBOL(pnp_init_resource_table);