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_resources(struct pnp_dev *dev)
243 struct pnp_resource_table *table = &dev->res;
246 for (idx = 0; idx < PNP_MAX_IRQ; idx++) {
247 table->irq_resource[idx].name = NULL;
248 table->irq_resource[idx].start = -1;
249 table->irq_resource[idx].end = -1;
250 table->irq_resource[idx].flags =
251 IORESOURCE_IRQ | IORESOURCE_AUTO | IORESOURCE_UNSET;
253 for (idx = 0; idx < PNP_MAX_DMA; idx++) {
254 table->dma_resource[idx].name = NULL;
255 table->dma_resource[idx].start = -1;
256 table->dma_resource[idx].end = -1;
257 table->dma_resource[idx].flags =
258 IORESOURCE_DMA | IORESOURCE_AUTO | IORESOURCE_UNSET;
260 for (idx = 0; idx < PNP_MAX_PORT; idx++) {
261 table->port_resource[idx].name = NULL;
262 table->port_resource[idx].start = 0;
263 table->port_resource[idx].end = 0;
264 table->port_resource[idx].flags =
265 IORESOURCE_IO | IORESOURCE_AUTO | IORESOURCE_UNSET;
267 for (idx = 0; idx < PNP_MAX_MEM; idx++) {
268 table->mem_resource[idx].name = NULL;
269 table->mem_resource[idx].start = 0;
270 table->mem_resource[idx].end = 0;
271 table->mem_resource[idx].flags =
272 IORESOURCE_MEM | IORESOURCE_AUTO | IORESOURCE_UNSET;
277 * pnp_clean_resources - clears resources that were not manually set
278 * @res: the resources to clean
280 static void pnp_clean_resource_table(struct pnp_dev *dev)
282 struct pnp_resource_table *res = &dev->res;
285 for (idx = 0; idx < PNP_MAX_IRQ; idx++) {
286 if (!(res->irq_resource[idx].flags & IORESOURCE_AUTO))
288 res->irq_resource[idx].start = -1;
289 res->irq_resource[idx].end = -1;
290 res->irq_resource[idx].flags =
291 IORESOURCE_IRQ | IORESOURCE_AUTO | IORESOURCE_UNSET;
293 for (idx = 0; idx < PNP_MAX_DMA; idx++) {
294 if (!(res->dma_resource[idx].flags & IORESOURCE_AUTO))
296 res->dma_resource[idx].start = -1;
297 res->dma_resource[idx].end = -1;
298 res->dma_resource[idx].flags =
299 IORESOURCE_DMA | IORESOURCE_AUTO | IORESOURCE_UNSET;
301 for (idx = 0; idx < PNP_MAX_PORT; idx++) {
302 if (!(res->port_resource[idx].flags & IORESOURCE_AUTO))
304 res->port_resource[idx].start = 0;
305 res->port_resource[idx].end = 0;
306 res->port_resource[idx].flags =
307 IORESOURCE_IO | IORESOURCE_AUTO | IORESOURCE_UNSET;
309 for (idx = 0; idx < PNP_MAX_MEM; idx++) {
310 if (!(res->mem_resource[idx].flags & IORESOURCE_AUTO))
312 res->mem_resource[idx].start = 0;
313 res->mem_resource[idx].end = 0;
314 res->mem_resource[idx].flags =
315 IORESOURCE_MEM | IORESOURCE_AUTO | IORESOURCE_UNSET;
320 * pnp_assign_resources - assigns resources to the device based on the specified dependent number
321 * @dev: pointer to the desired device
322 * @depnum: the dependent function number
324 * Only set depnum to 0 if the device does not have dependent options.
326 static int pnp_assign_resources(struct pnp_dev *dev, int depnum)
328 struct pnp_port *port;
332 int nport = 0, nmem = 0, nirq = 0, ndma = 0;
334 if (!pnp_can_configure(dev))
337 dbg_pnp_show_resources(dev, "before pnp_assign_resources");
338 mutex_lock(&pnp_res_mutex);
339 pnp_clean_resource_table(dev);
340 if (dev->independent) {
341 dev_dbg(&dev->dev, "assigning independent options\n");
342 port = dev->independent->port;
343 mem = dev->independent->mem;
344 irq = dev->independent->irq;
345 dma = dev->independent->dma;
347 if (!pnp_assign_port(dev, port, nport))
353 if (!pnp_assign_mem(dev, mem, nmem))
359 if (!pnp_assign_irq(dev, irq, nirq))
365 pnp_assign_dma(dev, dma, ndma);
372 struct pnp_option *dep;
375 dev_dbg(&dev->dev, "assigning dependent option %d\n", depnum);
376 for (i = 1, dep = dev->dependent; i < depnum;
377 i++, dep = dep->next)
385 if (!pnp_assign_port(dev, port, nport))
391 if (!pnp_assign_mem(dev, mem, nmem))
397 if (!pnp_assign_irq(dev, irq, nirq))
403 pnp_assign_dma(dev, dma, ndma);
407 } else if (dev->dependent)
410 mutex_unlock(&pnp_res_mutex);
411 dbg_pnp_show_resources(dev, "after pnp_assign_resources");
415 pnp_clean_resource_table(dev);
416 mutex_unlock(&pnp_res_mutex);
417 dbg_pnp_show_resources(dev, "after pnp_assign_resources (failed)");
422 * pnp_auto_config_dev - automatically assigns resources to a device
423 * @dev: pointer to the desired device
425 int pnp_auto_config_dev(struct pnp_dev *dev)
427 struct pnp_option *dep;
430 if (!pnp_can_configure(dev)) {
431 dev_dbg(&dev->dev, "configuration not supported\n");
435 if (!dev->dependent) {
436 if (pnp_assign_resources(dev, 0))
439 dep = dev->dependent;
441 if (pnp_assign_resources(dev, i))
448 dev_err(&dev->dev, "unable to assign resources\n");
453 * pnp_start_dev - low-level start of the PnP device
454 * @dev: pointer to the desired device
456 * assumes that resources have already been allocated
458 int pnp_start_dev(struct pnp_dev *dev)
460 if (!pnp_can_write(dev)) {
461 dev_dbg(&dev->dev, "activation not supported\n");
465 dbg_pnp_show_resources(dev, "pnp_start_dev");
466 if (dev->protocol->set(dev) < 0) {
467 dev_err(&dev->dev, "activation failed\n");
471 dev_info(&dev->dev, "activated\n");
476 * pnp_stop_dev - low-level disable of the PnP device
477 * @dev: pointer to the desired device
479 * does not free resources
481 int pnp_stop_dev(struct pnp_dev *dev)
483 if (!pnp_can_disable(dev)) {
484 dev_dbg(&dev->dev, "disabling not supported\n");
487 if (dev->protocol->disable(dev) < 0) {
488 dev_err(&dev->dev, "disable failed\n");
492 dev_info(&dev->dev, "disabled\n");
497 * pnp_activate_dev - activates a PnP device for use
498 * @dev: pointer to the desired device
500 * does not validate or set resources so be careful.
502 int pnp_activate_dev(struct pnp_dev *dev)
509 /* ensure resources are allocated */
510 if (pnp_auto_config_dev(dev))
513 error = pnp_start_dev(dev);
522 * pnp_disable_dev - disables device
523 * @dev: pointer to the desired device
525 * inform the correct pnp protocol so that resources can be used by other devices
527 int pnp_disable_dev(struct pnp_dev *dev)
534 error = pnp_stop_dev(dev);
540 /* release the resources so that other devices can use them */
541 mutex_lock(&pnp_res_mutex);
542 pnp_clean_resource_table(dev);
543 mutex_unlock(&pnp_res_mutex);
548 EXPORT_SYMBOL(pnp_start_dev);
549 EXPORT_SYMBOL(pnp_stop_dev);
550 EXPORT_SYMBOL(pnp_activate_dev);
551 EXPORT_SYMBOL(pnp_disable_dev);