2 * manager.c - Resource Management, Conflict Resolution, Activation and Disabling of Devices
4 * based on isapnp.c resource management (c) Jaroslav Kysela <perex@suse.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>
17 DECLARE_MUTEX(pnp_res_mutex
);
19 static int pnp_assign_port(struct pnp_dev
*dev
, struct pnp_port
*rule
, int idx
)
21 resource_size_t
*start
, *end
;
24 if (idx
>= PNP_MAX_PORT
) {
26 ("More than 4 ports is incompatible with pnp specifications.");
27 /* pretend we were successful so at least the manager won't try again */
31 /* check if this resource has been manually set, if so skip */
32 if (!(dev
->res
.port_resource
[idx
].flags
& IORESOURCE_AUTO
))
35 start
= &dev
->res
.port_resource
[idx
].start
;
36 end
= &dev
->res
.port_resource
[idx
].end
;
37 flags
= &dev
->res
.port_resource
[idx
].flags
;
39 /* set the initial values */
40 *flags
|= rule
->flags
| IORESOURCE_IO
;
41 *flags
&= ~IORESOURCE_UNSET
;
44 *flags
|= IORESOURCE_DISABLED
;
45 return 1; /* skip disabled resource requests */
49 *end
= *start
+ rule
->size
- 1;
51 /* run through until pnp_check_port is happy */
52 while (!pnp_check_port(dev
, idx
)) {
53 *start
+= rule
->align
;
54 *end
= *start
+ rule
->size
- 1;
55 if (*start
> rule
->max
|| !rule
->align
)
61 static int pnp_assign_mem(struct pnp_dev
*dev
, struct pnp_mem
*rule
, int idx
)
63 resource_size_t
*start
, *end
;
66 if (idx
>= PNP_MAX_MEM
) {
68 ("More than 8 mems is incompatible with pnp specifications.");
69 /* pretend we were successful so at least the manager won't try again */
73 /* check if this resource has been manually set, if so skip */
74 if (!(dev
->res
.mem_resource
[idx
].flags
& IORESOURCE_AUTO
))
77 start
= &dev
->res
.mem_resource
[idx
].start
;
78 end
= &dev
->res
.mem_resource
[idx
].end
;
79 flags
= &dev
->res
.mem_resource
[idx
].flags
;
81 /* set the initial values */
82 *flags
|= rule
->flags
| IORESOURCE_MEM
;
83 *flags
&= ~IORESOURCE_UNSET
;
85 /* convert pnp flags to standard Linux flags */
86 if (!(rule
->flags
& IORESOURCE_MEM_WRITEABLE
))
87 *flags
|= IORESOURCE_READONLY
;
88 if (rule
->flags
& IORESOURCE_MEM_CACHEABLE
)
89 *flags
|= IORESOURCE_CACHEABLE
;
90 if (rule
->flags
& IORESOURCE_MEM_RANGELENGTH
)
91 *flags
|= IORESOURCE_RANGELENGTH
;
92 if (rule
->flags
& IORESOURCE_MEM_SHADOWABLE
)
93 *flags
|= IORESOURCE_SHADOWABLE
;
96 *flags
|= IORESOURCE_DISABLED
;
97 return 1; /* skip disabled resource requests */
101 *end
= *start
+ rule
->size
- 1;
103 /* run through until pnp_check_mem is happy */
104 while (!pnp_check_mem(dev
, idx
)) {
105 *start
+= rule
->align
;
106 *end
= *start
+ rule
->size
- 1;
107 if (*start
> rule
->max
|| !rule
->align
)
113 static int pnp_assign_irq(struct pnp_dev
*dev
, struct pnp_irq
*rule
, int idx
)
115 resource_size_t
*start
, *end
;
116 unsigned long *flags
;
119 /* IRQ priority: this table is good for i386 */
120 static unsigned short xtab
[16] = {
121 5, 10, 11, 12, 9, 14, 15, 7, 3, 4, 13, 0, 1, 6, 8, 2
124 if (idx
>= PNP_MAX_IRQ
) {
126 ("More than 2 irqs is incompatible with pnp specifications.");
127 /* pretend we were successful so at least the manager won't try again */
131 /* check if this resource has been manually set, if so skip */
132 if (!(dev
->res
.irq_resource
[idx
].flags
& IORESOURCE_AUTO
))
135 start
= &dev
->res
.irq_resource
[idx
].start
;
136 end
= &dev
->res
.irq_resource
[idx
].end
;
137 flags
= &dev
->res
.irq_resource
[idx
].flags
;
139 /* set the initial values */
140 *flags
|= rule
->flags
| IORESOURCE_IRQ
;
141 *flags
&= ~IORESOURCE_UNSET
;
143 if (bitmap_empty(rule
->map
, PNP_IRQ_NR
)) {
144 *flags
|= IORESOURCE_DISABLED
;
145 return 1; /* skip disabled resource requests */
148 /* TBD: need check for >16 IRQ */
149 *start
= find_next_bit(rule
->map
, PNP_IRQ_NR
, 16);
150 if (*start
< PNP_IRQ_NR
) {
154 for (i
= 0; i
< 16; i
++) {
155 if (test_bit(xtab
[i
], rule
->map
)) {
156 *start
= *end
= xtab
[i
];
157 if (pnp_check_irq(dev
, idx
))
164 static int pnp_assign_dma(struct pnp_dev
*dev
, struct pnp_dma
*rule
, int idx
)
166 resource_size_t
*start
, *end
;
167 unsigned long *flags
;
170 /* DMA priority: this table is good for i386 */
171 static unsigned short xtab
[8] = {
172 1, 3, 5, 6, 7, 0, 2, 4
175 if (idx
>= PNP_MAX_DMA
) {
177 ("More than 2 dmas is incompatible with pnp specifications.");
178 /* pretend we were successful so at least the manager won't try again */
182 /* check if this resource has been manually set, if so skip */
183 if (!(dev
->res
.dma_resource
[idx
].flags
& IORESOURCE_AUTO
))
186 start
= &dev
->res
.dma_resource
[idx
].start
;
187 end
= &dev
->res
.dma_resource
[idx
].end
;
188 flags
= &dev
->res
.dma_resource
[idx
].flags
;
190 /* set the initial values */
191 *flags
|= rule
->flags
| IORESOURCE_DMA
;
192 *flags
&= ~IORESOURCE_UNSET
;
195 *flags
|= IORESOURCE_DISABLED
;
196 return 1; /* skip disabled resource requests */
199 for (i
= 0; i
< 8; i
++) {
200 if (rule
->map
& (1 << xtab
[i
])) {
201 *start
= *end
= xtab
[i
];
202 if (pnp_check_dma(dev
, idx
))
210 * pnp_init_resources - Resets a resource table to default values.
211 * @table: pointer to the desired resource table
213 void pnp_init_resource_table(struct pnp_resource_table
*table
)
217 for (idx
= 0; idx
< PNP_MAX_IRQ
; idx
++) {
218 table
->irq_resource
[idx
].name
= NULL
;
219 table
->irq_resource
[idx
].start
= -1;
220 table
->irq_resource
[idx
].end
= -1;
221 table
->irq_resource
[idx
].flags
=
222 IORESOURCE_IRQ
| IORESOURCE_AUTO
| IORESOURCE_UNSET
;
224 for (idx
= 0; idx
< PNP_MAX_DMA
; idx
++) {
225 table
->dma_resource
[idx
].name
= NULL
;
226 table
->dma_resource
[idx
].start
= -1;
227 table
->dma_resource
[idx
].end
= -1;
228 table
->dma_resource
[idx
].flags
=
229 IORESOURCE_DMA
| IORESOURCE_AUTO
| IORESOURCE_UNSET
;
231 for (idx
= 0; idx
< PNP_MAX_PORT
; idx
++) {
232 table
->port_resource
[idx
].name
= NULL
;
233 table
->port_resource
[idx
].start
= 0;
234 table
->port_resource
[idx
].end
= 0;
235 table
->port_resource
[idx
].flags
=
236 IORESOURCE_IO
| IORESOURCE_AUTO
| IORESOURCE_UNSET
;
238 for (idx
= 0; idx
< PNP_MAX_MEM
; idx
++) {
239 table
->mem_resource
[idx
].name
= NULL
;
240 table
->mem_resource
[idx
].start
= 0;
241 table
->mem_resource
[idx
].end
= 0;
242 table
->mem_resource
[idx
].flags
=
243 IORESOURCE_MEM
| IORESOURCE_AUTO
| IORESOURCE_UNSET
;
248 * pnp_clean_resources - clears resources that were not manually set
249 * @res: the resources to clean
251 static void pnp_clean_resource_table(struct pnp_resource_table
*res
)
255 for (idx
= 0; idx
< PNP_MAX_IRQ
; idx
++) {
256 if (!(res
->irq_resource
[idx
].flags
& IORESOURCE_AUTO
))
258 res
->irq_resource
[idx
].start
= -1;
259 res
->irq_resource
[idx
].end
= -1;
260 res
->irq_resource
[idx
].flags
=
261 IORESOURCE_IRQ
| IORESOURCE_AUTO
| IORESOURCE_UNSET
;
263 for (idx
= 0; idx
< PNP_MAX_DMA
; idx
++) {
264 if (!(res
->dma_resource
[idx
].flags
& IORESOURCE_AUTO
))
266 res
->dma_resource
[idx
].start
= -1;
267 res
->dma_resource
[idx
].end
= -1;
268 res
->dma_resource
[idx
].flags
=
269 IORESOURCE_DMA
| IORESOURCE_AUTO
| IORESOURCE_UNSET
;
271 for (idx
= 0; idx
< PNP_MAX_PORT
; idx
++) {
272 if (!(res
->port_resource
[idx
].flags
& IORESOURCE_AUTO
))
274 res
->port_resource
[idx
].start
= 0;
275 res
->port_resource
[idx
].end
= 0;
276 res
->port_resource
[idx
].flags
=
277 IORESOURCE_IO
| IORESOURCE_AUTO
| IORESOURCE_UNSET
;
279 for (idx
= 0; idx
< PNP_MAX_MEM
; idx
++) {
280 if (!(res
->mem_resource
[idx
].flags
& IORESOURCE_AUTO
))
282 res
->mem_resource
[idx
].start
= 0;
283 res
->mem_resource
[idx
].end
= 0;
284 res
->mem_resource
[idx
].flags
=
285 IORESOURCE_MEM
| IORESOURCE_AUTO
| IORESOURCE_UNSET
;
290 * pnp_assign_resources - assigns resources to the device based on the specified dependent number
291 * @dev: pointer to the desired device
292 * @depnum: the dependent function number
294 * Only set depnum to 0 if the device does not have dependent options.
296 static int pnp_assign_resources(struct pnp_dev
*dev
, int depnum
)
298 struct pnp_port
*port
;
302 int nport
= 0, nmem
= 0, nirq
= 0, ndma
= 0;
304 if (!pnp_can_configure(dev
))
307 down(&pnp_res_mutex
);
308 pnp_clean_resource_table(&dev
->res
); /* start with a fresh slate */
309 if (dev
->independent
) {
310 port
= dev
->independent
->port
;
311 mem
= dev
->independent
->mem
;
312 irq
= dev
->independent
->irq
;
313 dma
= dev
->independent
->dma
;
315 if (!pnp_assign_port(dev
, port
, nport
))
321 if (!pnp_assign_mem(dev
, mem
, nmem
))
327 if (!pnp_assign_irq(dev
, irq
, nirq
))
333 if (!pnp_assign_dma(dev
, dma
, ndma
))
341 struct pnp_option
*dep
;
343 for (i
= 1, dep
= dev
->dependent
; i
< depnum
;
344 i
++, dep
= dep
->next
)
352 if (!pnp_assign_port(dev
, port
, nport
))
358 if (!pnp_assign_mem(dev
, mem
, nmem
))
364 if (!pnp_assign_irq(dev
, irq
, nirq
))
370 if (!pnp_assign_dma(dev
, dma
, ndma
))
375 } else if (dev
->dependent
)
382 pnp_clean_resource_table(&dev
->res
);
388 * pnp_manual_config_dev - Disables Auto Config and Manually sets the resource table
389 * @dev: pointer to the desired device
390 * @res: pointer to the new resource config
391 * @mode: 0 or PNP_CONFIG_FORCE
393 * This function can be used by drivers that want to manually set thier resources.
395 int pnp_manual_config_dev(struct pnp_dev
*dev
, struct pnp_resource_table
*res
,
399 struct pnp_resource_table
*bak
;
401 if (!pnp_can_configure(dev
))
403 bak
= pnp_alloc(sizeof(struct pnp_resource_table
));
408 down(&pnp_res_mutex
);
410 if (!(mode
& PNP_CONFIG_FORCE
)) {
411 for (i
= 0; i
< PNP_MAX_PORT
; i
++) {
412 if (!pnp_check_port(dev
, i
))
415 for (i
= 0; i
< PNP_MAX_MEM
; i
++) {
416 if (!pnp_check_mem(dev
, i
))
419 for (i
= 0; i
< PNP_MAX_IRQ
; i
++) {
420 if (!pnp_check_irq(dev
, i
))
423 for (i
= 0; i
< PNP_MAX_DMA
; i
++) {
424 if (!pnp_check_dma(dev
, i
))
441 * pnp_auto_config_dev - automatically assigns resources to a device
442 * @dev: pointer to the desired device
444 int pnp_auto_config_dev(struct pnp_dev
*dev
)
446 struct pnp_option
*dep
;
449 if (!pnp_can_configure(dev
)) {
450 pnp_dbg("Device %s does not support resource configuration.",
455 if (!dev
->dependent
) {
456 if (pnp_assign_resources(dev
, 0))
459 dep
= dev
->dependent
;
461 if (pnp_assign_resources(dev
, i
))
468 pnp_err("Unable to assign resources to device %s.", dev
->dev
.bus_id
);
473 * pnp_start_dev - low-level start of the PnP device
474 * @dev: pointer to the desired device
476 * assumes that resources have already been allocated
478 int pnp_start_dev(struct pnp_dev
*dev
)
480 if (!pnp_can_write(dev
)) {
481 pnp_dbg("Device %s does not support activation.",
486 if (dev
->protocol
->set(dev
, &dev
->res
) < 0) {
487 pnp_err("Failed to activate device %s.", dev
->dev
.bus_id
);
491 pnp_info("Device %s activated.", dev
->dev
.bus_id
);
496 * pnp_stop_dev - low-level disable of the PnP device
497 * @dev: pointer to the desired device
499 * does not free resources
501 int pnp_stop_dev(struct pnp_dev
*dev
)
503 if (!pnp_can_disable(dev
)) {
504 pnp_dbg("Device %s does not support disabling.",
508 if (dev
->protocol
->disable(dev
) < 0) {
509 pnp_err("Failed to disable device %s.", dev
->dev
.bus_id
);
513 pnp_info("Device %s disabled.", dev
->dev
.bus_id
);
518 * pnp_activate_dev - activates a PnP device for use
519 * @dev: pointer to the desired device
521 * does not validate or set resources so be careful.
523 int pnp_activate_dev(struct pnp_dev
*dev
)
528 return 0; /* the device is already active */
530 /* ensure resources are allocated */
531 if (pnp_auto_config_dev(dev
))
534 error
= pnp_start_dev(dev
);
543 * pnp_disable_dev - disables device
544 * @dev: pointer to the desired device
546 * inform the correct pnp protocol so that resources can be used by other devices
548 int pnp_disable_dev(struct pnp_dev
*dev
)
553 return 0; /* the device is already disabled */
555 error
= pnp_stop_dev(dev
);
561 /* release the resources so that other devices can use them */
562 down(&pnp_res_mutex
);
563 pnp_clean_resource_table(&dev
->res
);
570 * pnp_resource_change - change one resource
571 * @resource: pointer to resource to be changed
572 * @start: start of region
573 * @size: size of region
575 void pnp_resource_change(struct resource
*resource
, resource_size_t start
,
576 resource_size_t size
)
578 resource
->flags
&= ~(IORESOURCE_AUTO
| IORESOURCE_UNSET
);
579 resource
->start
= start
;
580 resource
->end
= start
+ size
- 1;
583 EXPORT_SYMBOL(pnp_manual_config_dev
);
584 EXPORT_SYMBOL(pnp_start_dev
);
585 EXPORT_SYMBOL(pnp_stop_dev
);
586 EXPORT_SYMBOL(pnp_activate_dev
);
587 EXPORT_SYMBOL(pnp_disable_dev
);
588 EXPORT_SYMBOL(pnp_resource_change
);
589 EXPORT_SYMBOL(pnp_init_resource_table
);