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;
275 void pnp_init_resources(struct pnp_dev *dev)
277 pnp_init_resource_table(&dev->res);
281 * pnp_clean_resources - clears resources that were not manually set
282 * @res: the resources to clean
284 static void pnp_clean_resource_table(struct pnp_dev *dev)
286 struct pnp_resource_table *res = &dev->res;
289 for (idx = 0; idx < PNP_MAX_IRQ; idx++) {
290 if (!(res->irq_resource[idx].flags & IORESOURCE_AUTO))
292 res->irq_resource[idx].start = -1;
293 res->irq_resource[idx].end = -1;
294 res->irq_resource[idx].flags =
295 IORESOURCE_IRQ | IORESOURCE_AUTO | IORESOURCE_UNSET;
297 for (idx = 0; idx < PNP_MAX_DMA; idx++) {
298 if (!(res->dma_resource[idx].flags & IORESOURCE_AUTO))
300 res->dma_resource[idx].start = -1;
301 res->dma_resource[idx].end = -1;
302 res->dma_resource[idx].flags =
303 IORESOURCE_DMA | IORESOURCE_AUTO | IORESOURCE_UNSET;
305 for (idx = 0; idx < PNP_MAX_PORT; idx++) {
306 if (!(res->port_resource[idx].flags & IORESOURCE_AUTO))
308 res->port_resource[idx].start = 0;
309 res->port_resource[idx].end = 0;
310 res->port_resource[idx].flags =
311 IORESOURCE_IO | IORESOURCE_AUTO | IORESOURCE_UNSET;
313 for (idx = 0; idx < PNP_MAX_MEM; idx++) {
314 if (!(res->mem_resource[idx].flags & IORESOURCE_AUTO))
316 res->mem_resource[idx].start = 0;
317 res->mem_resource[idx].end = 0;
318 res->mem_resource[idx].flags =
319 IORESOURCE_MEM | IORESOURCE_AUTO | IORESOURCE_UNSET;
324 * pnp_assign_resources - assigns resources to the device based on the specified dependent number
325 * @dev: pointer to the desired device
326 * @depnum: the dependent function number
328 * Only set depnum to 0 if the device does not have dependent options.
330 static int pnp_assign_resources(struct pnp_dev *dev, int depnum)
332 struct pnp_port *port;
336 int nport = 0, nmem = 0, nirq = 0, ndma = 0;
338 if (!pnp_can_configure(dev))
341 dbg_pnp_show_resources(dev, "before pnp_assign_resources");
342 mutex_lock(&pnp_res_mutex);
343 pnp_clean_resource_table(dev);
344 if (dev->independent) {
345 dev_dbg(&dev->dev, "assigning independent options\n");
346 port = dev->independent->port;
347 mem = dev->independent->mem;
348 irq = dev->independent->irq;
349 dma = dev->independent->dma;
351 if (!pnp_assign_port(dev, port, nport))
357 if (!pnp_assign_mem(dev, mem, nmem))
363 if (!pnp_assign_irq(dev, irq, nirq))
369 pnp_assign_dma(dev, dma, ndma);
376 struct pnp_option *dep;
379 dev_dbg(&dev->dev, "assigning dependent option %d\n", depnum);
380 for (i = 1, dep = dev->dependent; i < depnum;
381 i++, dep = dep->next)
389 if (!pnp_assign_port(dev, port, nport))
395 if (!pnp_assign_mem(dev, mem, nmem))
401 if (!pnp_assign_irq(dev, irq, nirq))
407 pnp_assign_dma(dev, dma, ndma);
411 } else if (dev->dependent)
414 mutex_unlock(&pnp_res_mutex);
415 dbg_pnp_show_resources(dev, "after pnp_assign_resources");
419 pnp_clean_resource_table(dev);
420 mutex_unlock(&pnp_res_mutex);
421 dbg_pnp_show_resources(dev, "after pnp_assign_resources (failed)");
426 * pnp_manual_config_dev - Disables Auto Config and Manually sets the resource table
427 * @dev: pointer to the desired device
428 * @res: pointer to the new resource config
429 * @mode: 0 or PNP_CONFIG_FORCE
431 * This function can be used by drivers that want to manually set thier resources.
433 int pnp_manual_config_dev(struct pnp_dev *dev, struct pnp_resource_table *res,
437 struct pnp_resource_table *bak;
439 if (!pnp_can_configure(dev))
441 bak = pnp_alloc(sizeof(struct pnp_resource_table));
446 mutex_lock(&pnp_res_mutex);
448 if (!(mode & PNP_CONFIG_FORCE)) {
449 for (i = 0; i < PNP_MAX_PORT; i++) {
450 if (!pnp_check_port(dev, i))
453 for (i = 0; i < PNP_MAX_MEM; i++) {
454 if (!pnp_check_mem(dev, i))
457 for (i = 0; i < PNP_MAX_IRQ; i++) {
458 if (!pnp_check_irq(dev, i))
461 for (i = 0; i < PNP_MAX_DMA; i++) {
462 if (!pnp_check_dma(dev, i))
466 mutex_unlock(&pnp_res_mutex);
473 mutex_unlock(&pnp_res_mutex);
479 * pnp_auto_config_dev - automatically assigns resources to a device
480 * @dev: pointer to the desired device
482 int pnp_auto_config_dev(struct pnp_dev *dev)
484 struct pnp_option *dep;
487 if (!pnp_can_configure(dev)) {
488 dev_dbg(&dev->dev, "configuration not supported\n");
492 if (!dev->dependent) {
493 if (pnp_assign_resources(dev, 0))
496 dep = dev->dependent;
498 if (pnp_assign_resources(dev, i))
505 dev_err(&dev->dev, "unable to assign resources\n");
510 * pnp_start_dev - low-level start of the PnP device
511 * @dev: pointer to the desired device
513 * assumes that resources have already been allocated
515 int pnp_start_dev(struct pnp_dev *dev)
517 if (!pnp_can_write(dev)) {
518 dev_dbg(&dev->dev, "activation not supported\n");
522 dbg_pnp_show_resources(dev, "pnp_start_dev");
523 if (dev->protocol->set(dev) < 0) {
524 dev_err(&dev->dev, "activation failed\n");
528 dev_info(&dev->dev, "activated\n");
533 * pnp_stop_dev - low-level disable of the PnP device
534 * @dev: pointer to the desired device
536 * does not free resources
538 int pnp_stop_dev(struct pnp_dev *dev)
540 if (!pnp_can_disable(dev)) {
541 dev_dbg(&dev->dev, "disabling not supported\n");
544 if (dev->protocol->disable(dev) < 0) {
545 dev_err(&dev->dev, "disable failed\n");
549 dev_info(&dev->dev, "disabled\n");
554 * pnp_activate_dev - activates a PnP device for use
555 * @dev: pointer to the desired device
557 * does not validate or set resources so be careful.
559 int pnp_activate_dev(struct pnp_dev *dev)
566 /* ensure resources are allocated */
567 if (pnp_auto_config_dev(dev))
570 error = pnp_start_dev(dev);
579 * pnp_disable_dev - disables device
580 * @dev: pointer to the desired device
582 * inform the correct pnp protocol so that resources can be used by other devices
584 int pnp_disable_dev(struct pnp_dev *dev)
591 error = pnp_stop_dev(dev);
597 /* release the resources so that other devices can use them */
598 mutex_lock(&pnp_res_mutex);
599 pnp_clean_resource_table(dev);
600 mutex_unlock(&pnp_res_mutex);
606 * pnp_resource_change - change one resource
607 * @resource: pointer to resource to be changed
608 * @start: start of region
609 * @size: size of region
611 void pnp_resource_change(struct resource *resource, resource_size_t start,
612 resource_size_t size)
614 resource->flags &= ~(IORESOURCE_AUTO | IORESOURCE_UNSET);
615 resource->start = start;
616 resource->end = start + size - 1;
619 EXPORT_SYMBOL(pnp_manual_config_dev);
620 EXPORT_SYMBOL(pnp_start_dev);
621 EXPORT_SYMBOL(pnp_stop_dev);
622 EXPORT_SYMBOL(pnp_activate_dev);
623 EXPORT_SYMBOL(pnp_disable_dev);
624 EXPORT_SYMBOL(pnp_resource_change);
625 EXPORT_SYMBOL(pnp_init_resource_table);