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 struct resource
*res
, local_res
;
24 res
= pnp_get_resource(dev
, IORESOURCE_IO
, idx
);
26 dev_dbg(&dev
->dev
, " io %d already set to %#llx-%#llx "
27 "flags %#lx\n", idx
, (unsigned long long) res
->start
,
28 (unsigned long long) res
->end
, res
->flags
);
33 res
->flags
= rule
->flags
| IORESOURCE_AUTO
;
38 res
->flags
|= IORESOURCE_DISABLED
;
39 dev_dbg(&dev
->dev
, " io %d disabled\n", idx
);
43 res
->start
= rule
->min
;
44 res
->end
= res
->start
+ rule
->size
- 1;
46 while (!pnp_check_port(dev
, res
)) {
47 res
->start
+= rule
->align
;
48 res
->end
= res
->start
+ rule
->size
- 1;
49 if (res
->start
> rule
->max
|| !rule
->align
) {
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
);
59 pnp_add_io_resource(dev
, res
->start
, res
->end
, res
->flags
);
63 static int pnp_assign_mem(struct pnp_dev
*dev
, struct pnp_mem
*rule
, int idx
)
65 struct resource
*res
, local_res
;
67 res
= pnp_get_resource(dev
, IORESOURCE_MEM
, idx
);
69 dev_dbg(&dev
->dev
, " mem %d already set to %#llx-%#llx "
70 "flags %#lx\n", idx
, (unsigned long long) res
->start
,
71 (unsigned long long) res
->end
, res
->flags
);
76 res
->flags
= rule
->flags
| IORESOURCE_AUTO
;
80 if (!(rule
->flags
& IORESOURCE_MEM_WRITEABLE
))
81 res
->flags
|= IORESOURCE_READONLY
;
82 if (rule
->flags
& IORESOURCE_MEM_CACHEABLE
)
83 res
->flags
|= IORESOURCE_CACHEABLE
;
84 if (rule
->flags
& IORESOURCE_MEM_RANGELENGTH
)
85 res
->flags
|= IORESOURCE_RANGELENGTH
;
86 if (rule
->flags
& IORESOURCE_MEM_SHADOWABLE
)
87 res
->flags
|= IORESOURCE_SHADOWABLE
;
90 res
->flags
|= IORESOURCE_DISABLED
;
91 dev_dbg(&dev
->dev
, " mem %d disabled\n", idx
);
95 res
->start
= rule
->min
;
96 res
->end
= res
->start
+ rule
->size
- 1;
98 while (!pnp_check_mem(dev
, res
)) {
99 res
->start
+= rule
->align
;
100 res
->end
= res
->start
+ rule
->size
- 1;
101 if (res
->start
> rule
->max
|| !rule
->align
) {
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
);
111 pnp_add_mem_resource(dev
, res
->start
, res
->end
, res
->flags
);
115 static int pnp_assign_irq(struct pnp_dev
*dev
, struct pnp_irq
*rule
, int idx
)
117 struct resource
*res
, local_res
;
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
125 res
= pnp_get_resource(dev
, IORESOURCE_IRQ
, idx
);
127 dev_dbg(&dev
->dev
, " irq %d already set to %d flags %#lx\n",
128 idx
, (int) res
->start
, res
->flags
);
133 res
->flags
= rule
->flags
| IORESOURCE_AUTO
;
137 if (bitmap_empty(rule
->map
.bits
, PNP_IRQ_NR
)) {
138 res
->flags
|= IORESOURCE_DISABLED
;
139 dev_dbg(&dev
->dev
, " irq %d disabled\n", idx
);
143 /* TBD: need check for >16 IRQ */
144 res
->start
= find_next_bit(rule
->map
.bits
, PNP_IRQ_NR
, 16);
145 if (res
->start
< PNP_IRQ_NR
) {
146 res
->end
= res
->start
;
149 for (i
= 0; i
< 16; i
++) {
150 if (test_bit(xtab
[i
], rule
->map
.bits
)) {
151 res
->start
= res
->end
= xtab
[i
];
152 if (pnp_check_irq(dev
, res
))
156 dev_dbg(&dev
->dev
, " couldn't assign irq %d\n", idx
);
160 pnp_add_irq_resource(dev
, res
->start
, res
->flags
);
164 static int pnp_assign_dma(struct pnp_dev
*dev
, struct pnp_dma
*rule
, int idx
)
166 struct resource
*res
, local_res
;
169 /* DMA priority: this table is good for i386 */
170 static unsigned short xtab
[8] = {
171 1, 3, 5, 6, 7, 0, 2, 4
174 res
= pnp_get_resource(dev
, IORESOURCE_DMA
, idx
);
176 dev_dbg(&dev
->dev
, " dma %d already set to %d flags %#lx\n",
177 idx
, (int) res
->start
, res
->flags
);
182 res
->flags
= rule
->flags
| IORESOURCE_AUTO
;
186 for (i
= 0; i
< 8; i
++) {
187 if (rule
->map
& (1 << xtab
[i
])) {
188 res
->start
= res
->end
= xtab
[i
];
189 if (pnp_check_dma(dev
, res
))
193 #ifdef MAX_DMA_CHANNELS
194 res
->start
= res
->end
= MAX_DMA_CHANNELS
;
196 res
->flags
|= IORESOURCE_DISABLED
;
197 dev_dbg(&dev
->dev
, " disable dma %d\n", idx
);
200 pnp_add_dma_resource(dev
, res
->start
, res
->flags
);
204 void pnp_init_resources(struct pnp_dev
*dev
)
206 pnp_free_resources(dev
);
209 static void pnp_clean_resource_table(struct pnp_dev
*dev
)
211 struct pnp_resource
*pnp_res
, *tmp
;
213 list_for_each_entry_safe(pnp_res
, tmp
, &dev
->resources
, list
) {
214 if (pnp_res
->res
.flags
& IORESOURCE_AUTO
)
215 pnp_free_resource(pnp_res
);
220 * pnp_assign_resources - assigns resources to the device based on the specified dependent number
221 * @dev: pointer to the desired device
222 * @depnum: the dependent function number
224 * Only set depnum to 0 if the device does not have dependent options.
226 static int pnp_assign_resources(struct pnp_dev
*dev
, int depnum
)
228 struct pnp_port
*port
;
232 int nport
= 0, nmem
= 0, nirq
= 0, ndma
= 0;
234 if (!pnp_can_configure(dev
))
237 dbg_pnp_show_resources(dev
, "before pnp_assign_resources");
238 mutex_lock(&pnp_res_mutex
);
239 pnp_clean_resource_table(dev
);
240 if (dev
->independent
) {
241 dev_dbg(&dev
->dev
, "assigning independent options\n");
242 port
= dev
->independent
->port
;
243 mem
= dev
->independent
->mem
;
244 irq
= dev
->independent
->irq
;
245 dma
= dev
->independent
->dma
;
247 if (pnp_assign_port(dev
, port
, nport
) < 0)
253 if (pnp_assign_mem(dev
, mem
, nmem
) < 0)
259 if (pnp_assign_irq(dev
, irq
, nirq
) < 0)
265 if (pnp_assign_dma(dev
, dma
, ndma
) < 0)
273 struct pnp_option
*dep
;
276 dev_dbg(&dev
->dev
, "assigning dependent option %d\n", depnum
);
277 for (i
= 1, dep
= dev
->dependent
; i
< depnum
;
278 i
++, dep
= dep
->next
)
286 if (pnp_assign_port(dev
, port
, nport
) < 0)
292 if (pnp_assign_mem(dev
, mem
, nmem
) < 0)
298 if (pnp_assign_irq(dev
, irq
, nirq
) < 0)
304 if (pnp_assign_dma(dev
, dma
, ndma
) < 0)
309 } else if (dev
->dependent
)
312 mutex_unlock(&pnp_res_mutex
);
313 dbg_pnp_show_resources(dev
, "after pnp_assign_resources");
317 pnp_clean_resource_table(dev
);
318 mutex_unlock(&pnp_res_mutex
);
319 dbg_pnp_show_resources(dev
, "after pnp_assign_resources (failed)");
324 * pnp_auto_config_dev - automatically assigns resources to a device
325 * @dev: pointer to the desired device
327 int pnp_auto_config_dev(struct pnp_dev
*dev
)
329 struct pnp_option
*dep
;
332 if (!pnp_can_configure(dev
)) {
333 dev_dbg(&dev
->dev
, "configuration not supported\n");
337 if (!dev
->dependent
) {
338 if (pnp_assign_resources(dev
, 0))
341 dep
= dev
->dependent
;
343 if (pnp_assign_resources(dev
, i
))
350 dev_err(&dev
->dev
, "unable to assign resources\n");
355 * pnp_start_dev - low-level start of the PnP device
356 * @dev: pointer to the desired device
358 * assumes that resources have already been allocated
360 int pnp_start_dev(struct pnp_dev
*dev
)
362 if (!pnp_can_write(dev
)) {
363 dev_dbg(&dev
->dev
, "activation not supported\n");
367 dbg_pnp_show_resources(dev
, "pnp_start_dev");
368 if (dev
->protocol
->set(dev
) < 0) {
369 dev_err(&dev
->dev
, "activation failed\n");
373 dev_info(&dev
->dev
, "activated\n");
378 * pnp_stop_dev - low-level disable of the PnP device
379 * @dev: pointer to the desired device
381 * does not free resources
383 int pnp_stop_dev(struct pnp_dev
*dev
)
385 if (!pnp_can_disable(dev
)) {
386 dev_dbg(&dev
->dev
, "disabling not supported\n");
389 if (dev
->protocol
->disable(dev
) < 0) {
390 dev_err(&dev
->dev
, "disable failed\n");
394 dev_info(&dev
->dev
, "disabled\n");
399 * pnp_activate_dev - activates a PnP device for use
400 * @dev: pointer to the desired device
402 * does not validate or set resources so be careful.
404 int pnp_activate_dev(struct pnp_dev
*dev
)
411 /* ensure resources are allocated */
412 if (pnp_auto_config_dev(dev
))
415 error
= pnp_start_dev(dev
);
424 * pnp_disable_dev - disables device
425 * @dev: pointer to the desired device
427 * inform the correct pnp protocol so that resources can be used by other devices
429 int pnp_disable_dev(struct pnp_dev
*dev
)
436 error
= pnp_stop_dev(dev
);
442 /* release the resources so that other devices can use them */
443 mutex_lock(&pnp_res_mutex
);
444 pnp_clean_resource_table(dev
);
445 mutex_unlock(&pnp_res_mutex
);
450 EXPORT_SYMBOL(pnp_start_dev
);
451 EXPORT_SYMBOL(pnp_stop_dev
);
452 EXPORT_SYMBOL(pnp_activate_dev
);
453 EXPORT_SYMBOL(pnp_disable_dev
);