2251dd7da06268df5afb939a83624c2071271b6b
[linux-2.6.git] / drivers / pnp / manager.c
1 /*
2  * manager.c - Resource Management, Conflict Resolution, Activation and Disabling of Devices
3  *
4  * based on isapnp.c resource management (c) Jaroslav Kysela <perex@perex.cz>
5  * Copyright 2003 Adam Belay <ambx1@neo.rr.com>
6  */
7
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>
16 #include "base.h"
17
18 DEFINE_MUTEX(pnp_res_mutex);
19
20 static int pnp_assign_port(struct pnp_dev *dev, struct pnp_port *rule, int idx)
21 {
22         resource_size_t *start, *end;
23         unsigned long *flags;
24
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 */
28                 return 1;
29         }
30
31         start = &dev->res.port_resource[idx].start;
32         end = &dev->res.port_resource[idx].end;
33         flags = &dev->res.port_resource[idx].flags;
34
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);
40                 return 1;
41         }
42
43         /* set the initial values */
44         *flags |= rule->flags | IORESOURCE_IO;
45         *flags &= ~IORESOURCE_UNSET;
46
47         if (!rule->size) {
48                 *flags |= IORESOURCE_DISABLED;
49                 dev_dbg(&dev->dev, "  io %d disabled\n", idx);
50                 return 1;       /* skip disabled resource requests */
51         }
52
53         *start = rule->min;
54         *end = *start + rule->size - 1;
55
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);
62                         return 0;
63                 }
64         }
65         dev_dbg(&dev->dev, "  assign io  %d %#llx-%#llx\n", idx,
66                 (unsigned long long) *start, (unsigned long long) *end);
67         return 1;
68 }
69
70 static int pnp_assign_mem(struct pnp_dev *dev, struct pnp_mem *rule, int idx)
71 {
72         resource_size_t *start, *end;
73         unsigned long *flags;
74
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 */
78                 return 1;
79         }
80
81         start = &dev->res.mem_resource[idx].start;
82         end = &dev->res.mem_resource[idx].end;
83         flags = &dev->res.mem_resource[idx].flags;
84
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);
90                 return 1;
91         }
92
93         /* set the initial values */
94         *flags |= rule->flags | IORESOURCE_MEM;
95         *flags &= ~IORESOURCE_UNSET;
96
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;
106
107         if (!rule->size) {
108                 *flags |= IORESOURCE_DISABLED;
109                 dev_dbg(&dev->dev, "  mem %d disabled\n", idx);
110                 return 1;       /* skip disabled resource requests */
111         }
112
113         *start = rule->min;
114         *end = *start + rule->size - 1;
115
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);
122                         return 0;
123                 }
124         }
125         dev_dbg(&dev->dev, "  assign mem %d %#llx-%#llx\n", idx,
126                 (unsigned long long) *start, (unsigned long long) *end);
127         return 1;
128 }
129
130 static int pnp_assign_irq(struct pnp_dev *dev, struct pnp_irq *rule, int idx)
131 {
132         resource_size_t *start, *end;
133         unsigned long *flags;
134         int i;
135
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
139         };
140
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 */
144                 return 1;
145         }
146
147         start = &dev->res.irq_resource[idx].start;
148         end = &dev->res.irq_resource[idx].end;
149         flags = &dev->res.irq_resource[idx].flags;
150
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);
155                 return 1;
156         }
157
158         /* set the initial values */
159         *flags |= rule->flags | IORESOURCE_IRQ;
160         *flags &= ~IORESOURCE_UNSET;
161
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 */
166         }
167
168         /* TBD: need check for >16 IRQ */
169         *start = find_next_bit(rule->map, PNP_IRQ_NR, 16);
170         if (*start < PNP_IRQ_NR) {
171                 *end = *start;
172                 dev_dbg(&dev->dev, "  assign irq %d %d\n", idx, (int) *start);
173                 return 1;
174         }
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,
180                                         (int) *start);
181                                 return 1;
182                         }
183                 }
184         }
185         dev_dbg(&dev->dev, "  couldn't assign irq %d\n", idx);
186         return 0;
187 }
188
189 static void pnp_assign_dma(struct pnp_dev *dev, struct pnp_dma *rule, int idx)
190 {
191         resource_size_t *start, *end;
192         unsigned long *flags;
193         int i;
194
195         /* DMA priority: this table is good for i386 */
196         static unsigned short xtab[8] = {
197                 1, 3, 5, 6, 7, 0, 2, 4
198         };
199
200         if (idx >= PNP_MAX_DMA) {
201                 dev_err(&dev->dev, "too many DMA resources\n");
202                 return;
203         }
204
205         start = &dev->res.dma_resource[idx].start;
206         end = &dev->res.dma_resource[idx].end;
207         flags = &dev->res.dma_resource[idx].flags;
208
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);
213                 return;
214         }
215
216         /* set the initial values */
217         *flags |= rule->flags | IORESOURCE_DMA;
218         *flags &= ~IORESOURCE_UNSET;
219
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,
225                                         (int) *start);
226                                 return;
227                         }
228                 }
229         }
230 #ifdef MAX_DMA_CHANNELS
231         *start = *end = MAX_DMA_CHANNELS;
232 #endif
233         *flags |= IORESOURCE_UNSET | IORESOURCE_DISABLED;
234         dev_dbg(&dev->dev, "  disable dma %d\n", idx);
235 }
236
237 /**
238  * pnp_init_resources - Resets a resource table to default values.
239  * @table: pointer to the desired resource table
240  */
241 void pnp_init_resource_table(struct pnp_resource_table *table)
242 {
243         int idx;
244
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;
251         }
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;
258         }
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;
265         }
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;
272         }
273 }
274
275 void pnp_init_resources(struct pnp_dev *dev)
276 {
277         pnp_init_resource_table(&dev->res);
278 }
279
280 /**
281  * pnp_clean_resources - clears resources that were not manually set
282  * @res: the resources to clean
283  */
284 static void pnp_clean_resource_table(struct pnp_dev *dev)
285 {
286         struct pnp_resource_table *res = &dev->res;
287         int idx;
288
289         for (idx = 0; idx < PNP_MAX_IRQ; idx++) {
290                 if (!(res->irq_resource[idx].flags & IORESOURCE_AUTO))
291                         continue;
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;
296         }
297         for (idx = 0; idx < PNP_MAX_DMA; idx++) {
298                 if (!(res->dma_resource[idx].flags & IORESOURCE_AUTO))
299                         continue;
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;
304         }
305         for (idx = 0; idx < PNP_MAX_PORT; idx++) {
306                 if (!(res->port_resource[idx].flags & IORESOURCE_AUTO))
307                         continue;
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;
312         }
313         for (idx = 0; idx < PNP_MAX_MEM; idx++) {
314                 if (!(res->mem_resource[idx].flags & IORESOURCE_AUTO))
315                         continue;
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;
320         }
321 }
322
323 /**
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
327  *
328  * Only set depnum to 0 if the device does not have dependent options.
329  */
330 static int pnp_assign_resources(struct pnp_dev *dev, int depnum)
331 {
332         struct pnp_port *port;
333         struct pnp_mem *mem;
334         struct pnp_irq *irq;
335         struct pnp_dma *dma;
336         int nport = 0, nmem = 0, nirq = 0, ndma = 0;
337
338         if (!pnp_can_configure(dev))
339                 return -ENODEV;
340
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;
350                 while (port) {
351                         if (!pnp_assign_port(dev, port, nport))
352                                 goto fail;
353                         nport++;
354                         port = port->next;
355                 }
356                 while (mem) {
357                         if (!pnp_assign_mem(dev, mem, nmem))
358                                 goto fail;
359                         nmem++;
360                         mem = mem->next;
361                 }
362                 while (irq) {
363                         if (!pnp_assign_irq(dev, irq, nirq))
364                                 goto fail;
365                         nirq++;
366                         irq = irq->next;
367                 }
368                 while (dma) {
369                         pnp_assign_dma(dev, dma, ndma);
370                         ndma++;
371                         dma = dma->next;
372                 }
373         }
374
375         if (depnum) {
376                 struct pnp_option *dep;
377                 int i;
378
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)
382                         if (!dep)
383                                 goto fail;
384                 port = dep->port;
385                 mem = dep->mem;
386                 irq = dep->irq;
387                 dma = dep->dma;
388                 while (port) {
389                         if (!pnp_assign_port(dev, port, nport))
390                                 goto fail;
391                         nport++;
392                         port = port->next;
393                 }
394                 while (mem) {
395                         if (!pnp_assign_mem(dev, mem, nmem))
396                                 goto fail;
397                         nmem++;
398                         mem = mem->next;
399                 }
400                 while (irq) {
401                         if (!pnp_assign_irq(dev, irq, nirq))
402                                 goto fail;
403                         nirq++;
404                         irq = irq->next;
405                 }
406                 while (dma) {
407                         pnp_assign_dma(dev, dma, ndma);
408                         ndma++;
409                         dma = dma->next;
410                 }
411         } else if (dev->dependent)
412                 goto fail;
413
414         mutex_unlock(&pnp_res_mutex);
415         dbg_pnp_show_resources(dev, "after pnp_assign_resources");
416         return 1;
417
418 fail:
419         pnp_clean_resource_table(dev);
420         mutex_unlock(&pnp_res_mutex);
421         dbg_pnp_show_resources(dev, "after pnp_assign_resources (failed)");
422         return 0;
423 }
424
425 /**
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
430  *
431  * This function can be used by drivers that want to manually set thier resources.
432  */
433 int pnp_manual_config_dev(struct pnp_dev *dev, struct pnp_resource_table *res,
434                           int mode)
435 {
436         int i;
437         struct pnp_resource_table *bak;
438
439         if (!pnp_can_configure(dev))
440                 return -ENODEV;
441         bak = pnp_alloc(sizeof(struct pnp_resource_table));
442         if (!bak)
443                 return -ENOMEM;
444         *bak = dev->res;
445
446         mutex_lock(&pnp_res_mutex);
447         dev->res = *res;
448         if (!(mode & PNP_CONFIG_FORCE)) {
449                 for (i = 0; i < PNP_MAX_PORT; i++) {
450                         if (!pnp_check_port(dev, i))
451                                 goto fail;
452                 }
453                 for (i = 0; i < PNP_MAX_MEM; i++) {
454                         if (!pnp_check_mem(dev, i))
455                                 goto fail;
456                 }
457                 for (i = 0; i < PNP_MAX_IRQ; i++) {
458                         if (!pnp_check_irq(dev, i))
459                                 goto fail;
460                 }
461                 for (i = 0; i < PNP_MAX_DMA; i++) {
462                         if (!pnp_check_dma(dev, i))
463                                 goto fail;
464                 }
465         }
466         mutex_unlock(&pnp_res_mutex);
467
468         kfree(bak);
469         return 0;
470
471 fail:
472         dev->res = *bak;
473         mutex_unlock(&pnp_res_mutex);
474         kfree(bak);
475         return -EINVAL;
476 }
477
478 /**
479  * pnp_auto_config_dev - automatically assigns resources to a device
480  * @dev: pointer to the desired device
481  */
482 int pnp_auto_config_dev(struct pnp_dev *dev)
483 {
484         struct pnp_option *dep;
485         int i = 1;
486
487         if (!pnp_can_configure(dev)) {
488                 dev_dbg(&dev->dev, "configuration not supported\n");
489                 return -ENODEV;
490         }
491
492         if (!dev->dependent) {
493                 if (pnp_assign_resources(dev, 0))
494                         return 0;
495         } else {
496                 dep = dev->dependent;
497                 do {
498                         if (pnp_assign_resources(dev, i))
499                                 return 0;
500                         dep = dep->next;
501                         i++;
502                 } while (dep);
503         }
504
505         dev_err(&dev->dev, "unable to assign resources\n");
506         return -EBUSY;
507 }
508
509 /**
510  * pnp_start_dev - low-level start of the PnP device
511  * @dev: pointer to the desired device
512  *
513  * assumes that resources have already been allocated
514  */
515 int pnp_start_dev(struct pnp_dev *dev)
516 {
517         if (!pnp_can_write(dev)) {
518                 dev_dbg(&dev->dev, "activation not supported\n");
519                 return -EINVAL;
520         }
521
522         dbg_pnp_show_resources(dev, "pnp_start_dev");
523         if (dev->protocol->set(dev) < 0) {
524                 dev_err(&dev->dev, "activation failed\n");
525                 return -EIO;
526         }
527
528         dev_info(&dev->dev, "activated\n");
529         return 0;
530 }
531
532 /**
533  * pnp_stop_dev - low-level disable of the PnP device
534  * @dev: pointer to the desired device
535  *
536  * does not free resources
537  */
538 int pnp_stop_dev(struct pnp_dev *dev)
539 {
540         if (!pnp_can_disable(dev)) {
541                 dev_dbg(&dev->dev, "disabling not supported\n");
542                 return -EINVAL;
543         }
544         if (dev->protocol->disable(dev) < 0) {
545                 dev_err(&dev->dev, "disable failed\n");
546                 return -EIO;
547         }
548
549         dev_info(&dev->dev, "disabled\n");
550         return 0;
551 }
552
553 /**
554  * pnp_activate_dev - activates a PnP device for use
555  * @dev: pointer to the desired device
556  *
557  * does not validate or set resources so be careful.
558  */
559 int pnp_activate_dev(struct pnp_dev *dev)
560 {
561         int error;
562
563         if (dev->active)
564                 return 0;
565
566         /* ensure resources are allocated */
567         if (pnp_auto_config_dev(dev))
568                 return -EBUSY;
569
570         error = pnp_start_dev(dev);
571         if (error)
572                 return error;
573
574         dev->active = 1;
575         return 0;
576 }
577
578 /**
579  * pnp_disable_dev - disables device
580  * @dev: pointer to the desired device
581  *
582  * inform the correct pnp protocol so that resources can be used by other devices
583  */
584 int pnp_disable_dev(struct pnp_dev *dev)
585 {
586         int error;
587
588         if (!dev->active)
589                 return 0;
590
591         error = pnp_stop_dev(dev);
592         if (error)
593                 return error;
594
595         dev->active = 0;
596
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);
601
602         return 0;
603 }
604
605 /**
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
610  */
611 void pnp_resource_change(struct resource *resource, resource_size_t start,
612                          resource_size_t size)
613 {
614         resource->flags &= ~(IORESOURCE_AUTO | IORESOURCE_UNSET);
615         resource->start = start;
616         resource->end = start + size - 1;
617 }
618
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);