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
);