Root/
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); |
406 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9