[SCSI] zfcp: Cleanup function parameters for sbal value.
[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  * Copyright (C) 2008 Hewlett-Packard Development Company, L.P.
7  *      Bjorn Helgaas <bjorn.helgaas@hp.com>
8  */
9
10 #include <linux/errno.h>
11 #include <linux/module.h>
12 #include <linux/init.h>
13 #include <linux/kernel.h>
14 #include <linux/pnp.h>
15 #include <linux/bitmap.h>
16 #include <linux/mutex.h>
17 #include "base.h"
18
19 DEFINE_MUTEX(pnp_res_mutex);
20
21 static int pnp_assign_port(struct pnp_dev *dev, struct pnp_port *rule, int idx)
22 {
23         struct resource *res, local_res;
24
25         res = pnp_get_resource(dev, IORESOURCE_IO, idx);
26         if (res) {
27                 pnp_dbg(&dev->dev, "  io %d already set to %#llx-%#llx "
28                         "flags %#lx\n", idx, (unsigned long long) res->start,
29                         (unsigned long long) res->end, res->flags);
30                 return 0;
31         }
32
33         res = &local_res;
34         res->flags = rule->flags | IORESOURCE_AUTO;
35         res->start = 0;
36         res->end = 0;
37
38         if (!rule->size) {
39                 res->flags |= IORESOURCE_DISABLED;
40                 pnp_dbg(&dev->dev, "  io %d disabled\n", idx);
41                 goto __add;
42         }
43
44         res->start = rule->min;
45         res->end = res->start + rule->size - 1;
46
47         while (!pnp_check_port(dev, res)) {
48                 res->start += rule->align;
49                 res->end = res->start + rule->size - 1;
50                 if (res->start > rule->max || !rule->align) {
51                         pnp_dbg(&dev->dev, "  couldn't assign io %d "
52                                 "(min %#llx max %#llx)\n", idx,
53                                 (unsigned long long) rule->min,
54                                 (unsigned long long) rule->max);
55                         return -EBUSY;
56                 }
57         }
58
59 __add:
60         pnp_add_io_resource(dev, res->start, res->end, res->flags);
61         return 0;
62 }
63
64 static int pnp_assign_mem(struct pnp_dev *dev, struct pnp_mem *rule, int idx)
65 {
66         struct resource *res, local_res;
67
68         res = pnp_get_resource(dev, IORESOURCE_MEM, idx);
69         if (res) {
70                 pnp_dbg(&dev->dev, "  mem %d already set to %#llx-%#llx "
71                         "flags %#lx\n", idx, (unsigned long long) res->start,
72                         (unsigned long long) res->end, res->flags);
73                 return 0;
74         }
75
76         res = &local_res;
77         res->flags = rule->flags | IORESOURCE_AUTO;
78         res->start = 0;
79         res->end = 0;
80
81         if (!(rule->flags & IORESOURCE_MEM_WRITEABLE))
82                 res->flags |= IORESOURCE_READONLY;
83         if (rule->flags & IORESOURCE_MEM_CACHEABLE)
84                 res->flags |= IORESOURCE_CACHEABLE;
85         if (rule->flags & IORESOURCE_MEM_RANGELENGTH)
86                 res->flags |= IORESOURCE_RANGELENGTH;
87         if (rule->flags & IORESOURCE_MEM_SHADOWABLE)
88                 res->flags |= IORESOURCE_SHADOWABLE;
89
90         if (!rule->size) {
91                 res->flags |= IORESOURCE_DISABLED;
92                 pnp_dbg(&dev->dev, "  mem %d disabled\n", idx);
93                 goto __add;
94         }
95
96         res->start = rule->min;
97         res->end = res->start + rule->size - 1;
98
99         while (!pnp_check_mem(dev, res)) {
100                 res->start += rule->align;
101                 res->end = res->start + rule->size - 1;
102                 if (res->start > rule->max || !rule->align) {
103                         pnp_dbg(&dev->dev, "  couldn't assign mem %d "
104                                 "(min %#llx max %#llx)\n", idx,
105                                 (unsigned long long) rule->min,
106                                 (unsigned long long) rule->max);
107                         return -EBUSY;
108                 }
109         }
110
111 __add:
112         pnp_add_mem_resource(dev, res->start, res->end, res->flags);
113         return 0;
114 }
115
116 static int pnp_assign_irq(struct pnp_dev *dev, struct pnp_irq *rule, int idx)
117 {
118         struct resource *res, local_res;
119         int i;
120
121         /* IRQ priority: this table is good for i386 */
122         static unsigned short xtab[16] = {
123                 5, 10, 11, 12, 9, 14, 15, 7, 3, 4, 13, 0, 1, 6, 8, 2
124         };
125
126         res = pnp_get_resource(dev, IORESOURCE_IRQ, idx);
127         if (res) {
128                 pnp_dbg(&dev->dev, "  irq %d already set to %d flags %#lx\n",
129                         idx, (int) res->start, res->flags);
130                 return 0;
131         }
132
133         res = &local_res;
134         res->flags = rule->flags | IORESOURCE_AUTO;
135         res->start = -1;
136         res->end = -1;
137
138         if (bitmap_empty(rule->map.bits, PNP_IRQ_NR)) {
139                 res->flags |= IORESOURCE_DISABLED;
140                 pnp_dbg(&dev->dev, "  irq %d disabled\n", idx);
141                 goto __add;
142         }
143
144         /* TBD: need check for >16 IRQ */
145         res->start = find_next_bit(rule->map.bits, PNP_IRQ_NR, 16);
146         if (res->start < PNP_IRQ_NR) {
147                 res->end = res->start;
148                 goto __add;
149         }
150         for (i = 0; i < 16; i++) {
151                 if (test_bit(xtab[i], rule->map.bits)) {
152                         res->start = res->end = xtab[i];
153                         if (pnp_check_irq(dev, res))
154                                 goto __add;
155                 }
156         }
157
158         if (rule->flags & IORESOURCE_IRQ_OPTIONAL) {
159                 res->start = -1;
160                 res->end = -1;
161                 res->flags |= IORESOURCE_DISABLED;
162                 pnp_dbg(&dev->dev, "  irq %d disabled (optional)\n", idx);
163                 goto __add;
164         }
165
166         pnp_dbg(&dev->dev, "  couldn't assign irq %d\n", idx);
167         return -EBUSY;
168
169 __add:
170         pnp_add_irq_resource(dev, res->start, res->flags);
171         return 0;
172 }
173
174 static int pnp_assign_dma(struct pnp_dev *dev, struct pnp_dma *rule, int idx)
175 {
176         struct resource *res, local_res;
177         int i;
178
179         /* DMA priority: this table is good for i386 */
180         static unsigned short xtab[8] = {
181                 1, 3, 5, 6, 7, 0, 2, 4
182         };
183
184         res = pnp_get_resource(dev, IORESOURCE_DMA, idx);
185         if (res) {
186                 pnp_dbg(&dev->dev, "  dma %d already set to %d flags %#lx\n",
187                         idx, (int) res->start, res->flags);
188                 return 0;
189         }
190
191         res = &local_res;
192         res->flags = rule->flags | IORESOURCE_AUTO;
193         res->start = -1;
194         res->end = -1;
195
196         for (i = 0; i < 8; i++) {
197                 if (rule->map & (1 << xtab[i])) {
198                         res->start = res->end = xtab[i];
199                         if (pnp_check_dma(dev, res))
200                                 goto __add;
201                 }
202         }
203 #ifdef MAX_DMA_CHANNELS
204         res->start = res->end = MAX_DMA_CHANNELS;
205 #endif
206         res->flags |= IORESOURCE_DISABLED;
207         pnp_dbg(&dev->dev, "  disable dma %d\n", idx);
208
209 __add:
210         pnp_add_dma_resource(dev, res->start, res->flags);
211         return 0;
212 }
213
214 void pnp_init_resources(struct pnp_dev *dev)
215 {
216         pnp_free_resources(dev);
217 }
218
219 static void pnp_clean_resource_table(struct pnp_dev *dev)
220 {
221         struct pnp_resource *pnp_res, *tmp;
222
223         list_for_each_entry_safe(pnp_res, tmp, &dev->resources, list) {
224                 if (pnp_res->res.flags & IORESOURCE_AUTO)
225                         pnp_free_resource(pnp_res);
226         }
227 }
228
229 /**
230  * pnp_assign_resources - assigns resources to the device based on the specified dependent number
231  * @dev: pointer to the desired device
232  * @set: the dependent function number
233  */
234 static int pnp_assign_resources(struct pnp_dev *dev, int set)
235 {
236         struct pnp_option *option;
237         int nport = 0, nmem = 0, nirq = 0, ndma = 0;
238         int ret = 0;
239
240         pnp_dbg(&dev->dev, "pnp_assign_resources, try dependent set %d\n", set);
241         mutex_lock(&pnp_res_mutex);
242         pnp_clean_resource_table(dev);
243
244         list_for_each_entry(option, &dev->options, list) {
245                 if (pnp_option_is_dependent(option) &&
246                     pnp_option_set(option) != set)
247                                 continue;
248
249                 switch (option->type) {
250                 case IORESOURCE_IO:
251                         ret = pnp_assign_port(dev, &option->u.port, nport++);
252                         break;
253                 case IORESOURCE_MEM:
254                         ret = pnp_assign_mem(dev, &option->u.mem, nmem++);
255                         break;
256                 case IORESOURCE_IRQ:
257                         ret = pnp_assign_irq(dev, &option->u.irq, nirq++);
258                         break;
259                 case IORESOURCE_DMA:
260                         ret = pnp_assign_dma(dev, &option->u.dma, ndma++);
261                         break;
262                 default:
263                         ret = -EINVAL;
264                         break;
265                 }
266                 if (ret < 0)
267                         break;
268         }
269
270         mutex_unlock(&pnp_res_mutex);
271         if (ret < 0) {
272                 pnp_dbg(&dev->dev, "pnp_assign_resources failed (%d)\n", ret);
273                 pnp_clean_resource_table(dev);
274         } else
275                 dbg_pnp_show_resources(dev, "pnp_assign_resources succeeded");
276         return ret;
277 }
278
279 /**
280  * pnp_auto_config_dev - automatically assigns resources to a device
281  * @dev: pointer to the desired device
282  */
283 int pnp_auto_config_dev(struct pnp_dev *dev)
284 {
285         int i, ret;
286
287         if (!pnp_can_configure(dev)) {
288                 pnp_dbg(&dev->dev, "configuration not supported\n");
289                 return -ENODEV;
290         }
291
292         ret = pnp_assign_resources(dev, 0);
293         if (ret == 0)
294                 return 0;
295
296         for (i = 1; i < dev->num_dependent_sets; i++) {
297                 ret = pnp_assign_resources(dev, i);
298                 if (ret == 0)
299                         return 0;
300         }
301
302         dev_err(&dev->dev, "unable to assign resources\n");
303         return ret;
304 }
305
306 /**
307  * pnp_start_dev - low-level start of the PnP device
308  * @dev: pointer to the desired device
309  *
310  * assumes that resources have already been allocated
311  */
312 int pnp_start_dev(struct pnp_dev *dev)
313 {
314         if (!pnp_can_write(dev)) {
315                 pnp_dbg(&dev->dev, "activation not supported\n");
316                 return -EINVAL;
317         }
318
319         dbg_pnp_show_resources(dev, "pnp_start_dev");
320         if (dev->protocol->set(dev) < 0) {
321                 dev_err(&dev->dev, "activation failed\n");
322                 return -EIO;
323         }
324
325         dev_info(&dev->dev, "activated\n");
326         return 0;
327 }
328
329 /**
330  * pnp_stop_dev - low-level disable of the PnP device
331  * @dev: pointer to the desired device
332  *
333  * does not free resources
334  */
335 int pnp_stop_dev(struct pnp_dev *dev)
336 {
337         if (!pnp_can_disable(dev)) {
338                 pnp_dbg(&dev->dev, "disabling not supported\n");
339                 return -EINVAL;
340         }
341         if (dev->protocol->disable(dev) < 0) {
342                 dev_err(&dev->dev, "disable failed\n");
343                 return -EIO;
344         }
345
346         dev_info(&dev->dev, "disabled\n");
347         return 0;
348 }
349
350 /**
351  * pnp_activate_dev - activates a PnP device for use
352  * @dev: pointer to the desired device
353  *
354  * does not validate or set resources so be careful.
355  */
356 int pnp_activate_dev(struct pnp_dev *dev)
357 {
358         int error;
359
360         if (dev->active)
361                 return 0;
362
363         /* ensure resources are allocated */
364         if (pnp_auto_config_dev(dev))
365                 return -EBUSY;
366
367         error = pnp_start_dev(dev);
368         if (error)
369                 return error;
370
371         dev->active = 1;
372         return 0;
373 }
374
375 /**
376  * pnp_disable_dev - disables device
377  * @dev: pointer to the desired device
378  *
379  * inform the correct pnp protocol so that resources can be used by other devices
380  */
381 int pnp_disable_dev(struct pnp_dev *dev)
382 {
383         int error;
384
385         if (!dev->active)
386                 return 0;
387
388         error = pnp_stop_dev(dev);
389         if (error)
390                 return error;
391
392         dev->active = 0;
393
394         /* release the resources so that other devices can use them */
395         mutex_lock(&pnp_res_mutex);
396         pnp_clean_resource_table(dev);
397         mutex_unlock(&pnp_res_mutex);
398
399         return 0;
400 }
401
402 EXPORT_SYMBOL(pnp_start_dev);
403 EXPORT_SYMBOL(pnp_stop_dev);
404 EXPORT_SYMBOL(pnp_activate_dev);
405 EXPORT_SYMBOL(pnp_disable_dev);