Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * pnpacpi -- PnP ACPI driver | |
3 | * | |
4 | * Copyright (c) 2004 Matthieu Castet <castet.matthieu@free.fr> | |
5 | * Copyright (c) 2004 Li Shaohua <shaohua.li@intel.com> | |
50eca3eb | 6 | * |
1da177e4 LT |
7 | * This program is free software; you can redistribute it and/or modify it |
8 | * under the terms of the GNU General Public License as published by the | |
9 | * Free Software Foundation; either version 2, or (at your option) any | |
10 | * later version. | |
11 | * | |
12 | * This program is distributed in the hope that it will be useful, but | |
13 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 | * General Public License for more details. | |
16 | * | |
17 | * You should have received a copy of the GNU General Public License | |
18 | * along with this program; if not, write to the Free Software | |
19 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
20 | */ | |
21 | #include <linux/kernel.h> | |
22 | #include <linux/acpi.h> | |
23 | #include <linux/pci.h> | |
24 | #include "pnpacpi.h" | |
25 | ||
26 | #ifdef CONFIG_IA64 | |
27 | #define valid_IRQ(i) (1) | |
28 | #else | |
29 | #define valid_IRQ(i) (((i) != 0) && ((i) != 2)) | |
30 | #endif | |
31 | ||
32 | /* | |
33 | * Allocated Resources | |
34 | */ | |
50eca3eb | 35 | static int irq_flags(int triggering, int polarity) |
1da177e4 LT |
36 | { |
37 | int flag; | |
50eca3eb | 38 | if (triggering == ACPI_LEVEL_SENSITIVE) { |
1c6e7d0a | 39 | if (polarity == ACPI_ACTIVE_LOW) |
1da177e4 LT |
40 | flag = IORESOURCE_IRQ_LOWLEVEL; |
41 | else | |
42 | flag = IORESOURCE_IRQ_HIGHLEVEL; | |
43 | } | |
44 | else { | |
1c6e7d0a | 45 | if (polarity == ACPI_ACTIVE_LOW) |
1da177e4 LT |
46 | flag = IORESOURCE_IRQ_LOWEDGE; |
47 | else | |
48 | flag = IORESOURCE_IRQ_HIGHEDGE; | |
49 | } | |
50 | return flag; | |
51 | } | |
52 | ||
50eca3eb | 53 | static void decode_irq_flags(int flag, int *triggering, int *polarity) |
1da177e4 LT |
54 | { |
55 | switch (flag) { | |
56 | case IORESOURCE_IRQ_LOWLEVEL: | |
50eca3eb BM |
57 | *triggering = ACPI_LEVEL_SENSITIVE; |
58 | *polarity = ACPI_ACTIVE_LOW; | |
1da177e4 | 59 | break; |
1c6e7d0a | 60 | case IORESOURCE_IRQ_HIGHLEVEL: |
50eca3eb BM |
61 | *triggering = ACPI_LEVEL_SENSITIVE; |
62 | *polarity = ACPI_ACTIVE_HIGH; | |
1da177e4 LT |
63 | break; |
64 | case IORESOURCE_IRQ_LOWEDGE: | |
50eca3eb BM |
65 | *triggering = ACPI_EDGE_SENSITIVE; |
66 | *polarity = ACPI_ACTIVE_LOW; | |
1da177e4 LT |
67 | break; |
68 | case IORESOURCE_IRQ_HIGHEDGE: | |
50eca3eb BM |
69 | *triggering = ACPI_EDGE_SENSITIVE; |
70 | *polarity = ACPI_ACTIVE_HIGH; | |
1da177e4 LT |
71 | break; |
72 | } | |
73 | } | |
74 | ||
75 | static void | |
1c6e7d0a | 76 | pnpacpi_parse_allocated_irqresource(struct pnp_resource_table *res, u32 gsi, |
c32928c5 | 77 | int triggering, int polarity, int shareable) |
1da177e4 LT |
78 | { |
79 | int i = 0; | |
dbed12da BH |
80 | int irq; |
81 | ||
82 | if (!valid_IRQ(gsi)) | |
83 | return; | |
84 | ||
1da177e4 LT |
85 | while (!(res->irq_resource[i].flags & IORESOURCE_UNSET) && |
86 | i < PNP_MAX_IRQ) | |
87 | i++; | |
dbed12da BH |
88 | if (i >= PNP_MAX_IRQ) |
89 | return; | |
90 | ||
91 | res->irq_resource[i].flags = IORESOURCE_IRQ; // Also clears _UNSET flag | |
50eca3eb | 92 | irq = acpi_register_gsi(gsi, triggering, polarity); |
dbed12da BH |
93 | if (irq < 0) { |
94 | res->irq_resource[i].flags |= IORESOURCE_DISABLED; | |
95 | return; | |
1da177e4 | 96 | } |
dbed12da | 97 | |
c32928c5 BH |
98 | if (shareable) |
99 | res->irq_resource[i].flags |= IORESOURCE_IRQ_SHAREABLE; | |
100 | ||
dbed12da BH |
101 | res->irq_resource[i].start = irq; |
102 | res->irq_resource[i].end = irq; | |
103 | pcibios_penalize_isa_irq(irq, 1); | |
1da177e4 LT |
104 | } |
105 | ||
106 | static void | |
1c6e7d0a | 107 | pnpacpi_parse_allocated_dmaresource(struct pnp_resource_table *res, u32 dma) |
1da177e4 LT |
108 | { |
109 | int i = 0; | |
0dec63ba AB |
110 | while (i < PNP_MAX_DMA && |
111 | !(res->dma_resource[i].flags & IORESOURCE_UNSET)) | |
1da177e4 LT |
112 | i++; |
113 | if (i < PNP_MAX_DMA) { | |
114 | res->dma_resource[i].flags = IORESOURCE_DMA; // Also clears _UNSET flag | |
115 | if (dma == -1) { | |
116 | res->dma_resource[i].flags |= IORESOURCE_DISABLED; | |
117 | return; | |
118 | } | |
dbed12da BH |
119 | res->dma_resource[i].start = dma; |
120 | res->dma_resource[i].end = dma; | |
1da177e4 LT |
121 | } |
122 | } | |
123 | ||
124 | static void | |
1c6e7d0a | 125 | pnpacpi_parse_allocated_ioresource(struct pnp_resource_table *res, |
1acfb7f2 | 126 | u64 io, u64 len) |
1da177e4 LT |
127 | { |
128 | int i = 0; | |
129 | while (!(res->port_resource[i].flags & IORESOURCE_UNSET) && | |
130 | i < PNP_MAX_PORT) | |
131 | i++; | |
132 | if (i < PNP_MAX_PORT) { | |
133 | res->port_resource[i].flags = IORESOURCE_IO; // Also clears _UNSET flag | |
134 | if (len <= 0 || (io + len -1) >= 0x10003) { | |
135 | res->port_resource[i].flags |= IORESOURCE_DISABLED; | |
136 | return; | |
137 | } | |
dbed12da BH |
138 | res->port_resource[i].start = io; |
139 | res->port_resource[i].end = io + len - 1; | |
1da177e4 LT |
140 | } |
141 | } | |
142 | ||
143 | static void | |
1c6e7d0a | 144 | pnpacpi_parse_allocated_memresource(struct pnp_resource_table *res, |
dbed12da | 145 | u64 mem, u64 len) |
1da177e4 LT |
146 | { |
147 | int i = 0; | |
148 | while (!(res->mem_resource[i].flags & IORESOURCE_UNSET) && | |
149 | (i < PNP_MAX_MEM)) | |
150 | i++; | |
151 | if (i < PNP_MAX_MEM) { | |
152 | res->mem_resource[i].flags = IORESOURCE_MEM; // Also clears _UNSET flag | |
153 | if (len <= 0) { | |
154 | res->mem_resource[i].flags |= IORESOURCE_DISABLED; | |
155 | return; | |
156 | } | |
dbed12da BH |
157 | res->mem_resource[i].start = mem; |
158 | res->mem_resource[i].end = mem + len - 1; | |
1da177e4 LT |
159 | } |
160 | } | |
161 | ||
1acfb7f2 BH |
162 | static void |
163 | pnpacpi_parse_allocated_address_space(struct pnp_resource_table *res_table, | |
164 | struct acpi_resource *res) | |
165 | { | |
166 | struct acpi_resource_address64 addr, *p = &addr; | |
167 | acpi_status status; | |
168 | ||
169 | status = acpi_resource_to_address64(res, p); | |
170 | if (!ACPI_SUCCESS(status)) { | |
171 | pnp_warn("PnPACPI: failed to convert resource type %d", | |
172 | res->type); | |
173 | return; | |
174 | } | |
175 | ||
2b8de5f5 | 176 | if (p->producer_consumer == ACPI_PRODUCER) |
177 | return; | |
178 | ||
1acfb7f2 BH |
179 | if (p->resource_type == ACPI_MEMORY_RANGE) |
180 | pnpacpi_parse_allocated_memresource(res_table, | |
181 | p->minimum, p->address_length); | |
182 | else if (p->resource_type == ACPI_IO_RANGE) | |
183 | pnpacpi_parse_allocated_ioresource(res_table, | |
184 | p->minimum, p->address_length); | |
185 | } | |
1da177e4 LT |
186 | |
187 | static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res, | |
188 | void *data) | |
189 | { | |
1c6e7d0a | 190 | struct pnp_resource_table *res_table = (struct pnp_resource_table *)data; |
dbed12da | 191 | int i; |
1da177e4 | 192 | |
eca008c8 | 193 | switch (res->type) { |
50eca3eb | 194 | case ACPI_RESOURCE_TYPE_IRQ: |
dbed12da BH |
195 | /* |
196 | * Per spec, only one interrupt per descriptor is allowed in | |
197 | * _CRS, but some firmware violates this, so parse them all. | |
198 | */ | |
50eca3eb | 199 | for (i = 0; i < res->data.irq.interrupt_count; i++) { |
dbed12da BH |
200 | pnpacpi_parse_allocated_irqresource(res_table, |
201 | res->data.irq.interrupts[i], | |
50eca3eb | 202 | res->data.irq.triggering, |
c32928c5 BH |
203 | res->data.irq.polarity, |
204 | res->data.irq.sharable); | |
1da177e4 LT |
205 | } |
206 | break; | |
207 | ||
50eca3eb BM |
208 | case ACPI_RESOURCE_TYPE_DMA: |
209 | if (res->data.dma.channel_count > 0) | |
210 | pnpacpi_parse_allocated_dmaresource(res_table, | |
1da177e4 LT |
211 | res->data.dma.channels[0]); |
212 | break; | |
0af5853b | 213 | |
50eca3eb BM |
214 | case ACPI_RESOURCE_TYPE_IO: |
215 | pnpacpi_parse_allocated_ioresource(res_table, | |
216 | res->data.io.minimum, | |
217 | res->data.io.address_length); | |
1da177e4 | 218 | break; |
0af5853b LB |
219 | |
220 | case ACPI_RESOURCE_TYPE_START_DEPENDENT: | |
221 | case ACPI_RESOURCE_TYPE_END_DEPENDENT: | |
222 | break; | |
223 | ||
50eca3eb BM |
224 | case ACPI_RESOURCE_TYPE_FIXED_IO: |
225 | pnpacpi_parse_allocated_ioresource(res_table, | |
226 | res->data.fixed_io.address, | |
227 | res->data.fixed_io.address_length); | |
1da177e4 | 228 | break; |
0af5853b LB |
229 | |
230 | case ACPI_RESOURCE_TYPE_VENDOR: | |
231 | break; | |
232 | ||
233 | case ACPI_RESOURCE_TYPE_END_TAG: | |
234 | break; | |
235 | ||
50eca3eb BM |
236 | case ACPI_RESOURCE_TYPE_MEMORY24: |
237 | pnpacpi_parse_allocated_memresource(res_table, | |
238 | res->data.memory24.minimum, | |
239 | res->data.memory24.address_length); | |
1da177e4 | 240 | break; |
50eca3eb BM |
241 | case ACPI_RESOURCE_TYPE_MEMORY32: |
242 | pnpacpi_parse_allocated_memresource(res_table, | |
243 | res->data.memory32.minimum, | |
244 | res->data.memory32.address_length); | |
1da177e4 | 245 | break; |
50eca3eb BM |
246 | case ACPI_RESOURCE_TYPE_FIXED_MEMORY32: |
247 | pnpacpi_parse_allocated_memresource(res_table, | |
248 | res->data.fixed_memory32.address, | |
249 | res->data.fixed_memory32.address_length); | |
1da177e4 | 250 | break; |
50eca3eb | 251 | case ACPI_RESOURCE_TYPE_ADDRESS16: |
50eca3eb | 252 | case ACPI_RESOURCE_TYPE_ADDRESS32: |
50eca3eb | 253 | case ACPI_RESOURCE_TYPE_ADDRESS64: |
1acfb7f2 | 254 | pnpacpi_parse_allocated_address_space(res_table, res); |
1da177e4 | 255 | break; |
0af5853b LB |
256 | |
257 | case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64: | |
2b8de5f5 | 258 | if (res->data.ext_address64.producer_consumer == ACPI_PRODUCER) |
259 | return AE_OK; | |
0af5853b LB |
260 | break; |
261 | ||
262 | case ACPI_RESOURCE_TYPE_EXTENDED_IRQ: | |
2b8de5f5 | 263 | if (res->data.extended_irq.producer_consumer == ACPI_PRODUCER) |
264 | return AE_OK; | |
265 | ||
0af5853b LB |
266 | for (i = 0; i < res->data.extended_irq.interrupt_count; i++) { |
267 | pnpacpi_parse_allocated_irqresource(res_table, | |
268 | res->data.extended_irq.interrupts[i], | |
269 | res->data.extended_irq.triggering, | |
c32928c5 BH |
270 | res->data.extended_irq.polarity, |
271 | res->data.extended_irq.sharable); | |
0af5853b LB |
272 | } |
273 | break; | |
274 | ||
275 | case ACPI_RESOURCE_TYPE_GENERIC_REGISTER: | |
1da177e4 | 276 | break; |
0af5853b | 277 | |
1da177e4 | 278 | default: |
eca008c8 | 279 | pnp_warn("PnPACPI: unknown resource type %d", res->type); |
1da177e4 LT |
280 | return AE_ERROR; |
281 | } | |
1c6e7d0a | 282 | |
1da177e4 LT |
283 | return AE_OK; |
284 | } | |
285 | ||
1c6e7d0a | 286 | acpi_status pnpacpi_parse_allocated_resource(acpi_handle handle, struct pnp_resource_table *res) |
1da177e4 LT |
287 | { |
288 | /* Blank the resource table values */ | |
289 | pnp_init_resource_table(res); | |
290 | ||
291 | return acpi_walk_resources(handle, METHOD_NAME__CRS, pnpacpi_allocated_resource, res); | |
292 | } | |
293 | ||
294 | static void pnpacpi_parse_dma_option(struct pnp_option *option, struct acpi_resource_dma *p) | |
295 | { | |
296 | int i; | |
297 | struct pnp_dma * dma; | |
298 | ||
50eca3eb | 299 | if (p->channel_count == 0) |
1da177e4 | 300 | return; |
cd861280 | 301 | dma = kzalloc(sizeof(struct pnp_dma), GFP_KERNEL); |
1da177e4 LT |
302 | if (!dma) |
303 | return; | |
304 | ||
50eca3eb | 305 | for(i = 0; i < p->channel_count; i++) |
1da177e4 LT |
306 | dma->map |= 1 << p->channels[i]; |
307 | dma->flags = 0; | |
308 | if (p->bus_master) | |
309 | dma->flags |= IORESOURCE_DMA_MASTER; | |
310 | switch (p->type) { | |
311 | case ACPI_COMPATIBILITY: | |
312 | dma->flags |= IORESOURCE_DMA_COMPATIBLE; | |
313 | break; | |
314 | case ACPI_TYPE_A: | |
315 | dma->flags |= IORESOURCE_DMA_TYPEA; | |
316 | break; | |
317 | case ACPI_TYPE_B: | |
318 | dma->flags |= IORESOURCE_DMA_TYPEB; | |
319 | break; | |
320 | case ACPI_TYPE_F: | |
321 | dma->flags |= IORESOURCE_DMA_TYPEF; | |
322 | break; | |
323 | default: | |
324 | /* Set a default value ? */ | |
325 | dma->flags |= IORESOURCE_DMA_COMPATIBLE; | |
326 | pnp_err("Invalid DMA type"); | |
327 | } | |
328 | switch (p->transfer) { | |
329 | case ACPI_TRANSFER_8: | |
330 | dma->flags |= IORESOURCE_DMA_8BIT; | |
331 | break; | |
332 | case ACPI_TRANSFER_8_16: | |
333 | dma->flags |= IORESOURCE_DMA_8AND16BIT; | |
334 | break; | |
335 | case ACPI_TRANSFER_16: | |
336 | dma->flags |= IORESOURCE_DMA_16BIT; | |
337 | break; | |
338 | default: | |
339 | /* Set a default value ? */ | |
340 | dma->flags |= IORESOURCE_DMA_8AND16BIT; | |
341 | pnp_err("Invalid DMA transfer type"); | |
342 | } | |
343 | ||
1c6e7d0a | 344 | pnp_register_dma_resource(option, dma); |
1da177e4 LT |
345 | return; |
346 | } | |
347 | ||
1c6e7d0a | 348 | |
1da177e4 LT |
349 | static void pnpacpi_parse_irq_option(struct pnp_option *option, |
350 | struct acpi_resource_irq *p) | |
351 | { | |
352 | int i; | |
1c6e7d0a BH |
353 | struct pnp_irq *irq; |
354 | ||
50eca3eb | 355 | if (p->interrupt_count == 0) |
1da177e4 | 356 | return; |
cd861280 | 357 | irq = kzalloc(sizeof(struct pnp_irq), GFP_KERNEL); |
1da177e4 LT |
358 | if (!irq) |
359 | return; | |
360 | ||
50eca3eb | 361 | for(i = 0; i < p->interrupt_count; i++) |
1da177e4 LT |
362 | if (p->interrupts[i]) |
363 | __set_bit(p->interrupts[i], irq->map); | |
50eca3eb | 364 | irq->flags = irq_flags(p->triggering, p->polarity); |
1da177e4 LT |
365 | |
366 | pnp_register_irq_resource(option, irq); | |
367 | return; | |
368 | } | |
369 | ||
370 | static void pnpacpi_parse_ext_irq_option(struct pnp_option *option, | |
50eca3eb | 371 | struct acpi_resource_extended_irq *p) |
1da177e4 LT |
372 | { |
373 | int i; | |
1c6e7d0a | 374 | struct pnp_irq *irq; |
1da177e4 | 375 | |
50eca3eb | 376 | if (p->interrupt_count == 0) |
1da177e4 | 377 | return; |
cd861280 | 378 | irq = kzalloc(sizeof(struct pnp_irq), GFP_KERNEL); |
1da177e4 LT |
379 | if (!irq) |
380 | return; | |
381 | ||
50eca3eb | 382 | for(i = 0; i < p->interrupt_count; i++) |
1da177e4 LT |
383 | if (p->interrupts[i]) |
384 | __set_bit(p->interrupts[i], irq->map); | |
50eca3eb | 385 | irq->flags = irq_flags(p->triggering, p->polarity); |
1da177e4 LT |
386 | |
387 | pnp_register_irq_resource(option, irq); | |
388 | return; | |
389 | } | |
390 | ||
391 | static void | |
392 | pnpacpi_parse_port_option(struct pnp_option *option, | |
393 | struct acpi_resource_io *io) | |
394 | { | |
1c6e7d0a | 395 | struct pnp_port *port; |
1da177e4 | 396 | |
50eca3eb | 397 | if (io->address_length == 0) |
1da177e4 | 398 | return; |
cd861280 | 399 | port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL); |
1da177e4 LT |
400 | if (!port) |
401 | return; | |
50eca3eb BM |
402 | port->min = io->minimum; |
403 | port->max = io->maximum; | |
1da177e4 | 404 | port->align = io->alignment; |
50eca3eb BM |
405 | port->size = io->address_length; |
406 | port->flags = ACPI_DECODE_16 == io->io_decode ? | |
1da177e4 | 407 | PNP_PORT_FLAG_16BITADDR : 0; |
1c6e7d0a | 408 | pnp_register_port_resource(option, port); |
1da177e4 LT |
409 | return; |
410 | } | |
411 | ||
412 | static void | |
413 | pnpacpi_parse_fixed_port_option(struct pnp_option *option, | |
414 | struct acpi_resource_fixed_io *io) | |
415 | { | |
1c6e7d0a | 416 | struct pnp_port *port; |
1da177e4 | 417 | |
50eca3eb | 418 | if (io->address_length == 0) |
1da177e4 | 419 | return; |
cd861280 | 420 | port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL); |
1da177e4 LT |
421 | if (!port) |
422 | return; | |
50eca3eb BM |
423 | port->min = port->max = io->address; |
424 | port->size = io->address_length; | |
1da177e4 LT |
425 | port->align = 0; |
426 | port->flags = PNP_PORT_FLAG_FIXED; | |
1c6e7d0a | 427 | pnp_register_port_resource(option, port); |
1da177e4 LT |
428 | return; |
429 | } | |
430 | ||
431 | static void | |
432 | pnpacpi_parse_mem24_option(struct pnp_option *option, | |
50eca3eb | 433 | struct acpi_resource_memory24 *p) |
1da177e4 | 434 | { |
1c6e7d0a | 435 | struct pnp_mem *mem; |
1da177e4 | 436 | |
50eca3eb | 437 | if (p->address_length == 0) |
1da177e4 | 438 | return; |
cd861280 | 439 | mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL); |
1da177e4 LT |
440 | if (!mem) |
441 | return; | |
50eca3eb BM |
442 | mem->min = p->minimum; |
443 | mem->max = p->maximum; | |
1da177e4 | 444 | mem->align = p->alignment; |
50eca3eb | 445 | mem->size = p->address_length; |
1da177e4 | 446 | |
0897831b | 447 | mem->flags = (ACPI_READ_WRITE_MEMORY == p->write_protect) ? |
1da177e4 LT |
448 | IORESOURCE_MEM_WRITEABLE : 0; |
449 | ||
1c6e7d0a | 450 | pnp_register_mem_resource(option, mem); |
1da177e4 LT |
451 | return; |
452 | } | |
453 | ||
454 | static void | |
455 | pnpacpi_parse_mem32_option(struct pnp_option *option, | |
50eca3eb | 456 | struct acpi_resource_memory32 *p) |
1da177e4 | 457 | { |
1c6e7d0a | 458 | struct pnp_mem *mem; |
1da177e4 | 459 | |
50eca3eb | 460 | if (p->address_length == 0) |
1da177e4 | 461 | return; |
cd861280 | 462 | mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL); |
1da177e4 LT |
463 | if (!mem) |
464 | return; | |
50eca3eb BM |
465 | mem->min = p->minimum; |
466 | mem->max = p->maximum; | |
1da177e4 | 467 | mem->align = p->alignment; |
50eca3eb | 468 | mem->size = p->address_length; |
1da177e4 | 469 | |
0897831b | 470 | mem->flags = (ACPI_READ_WRITE_MEMORY == p->write_protect) ? |
1da177e4 LT |
471 | IORESOURCE_MEM_WRITEABLE : 0; |
472 | ||
1c6e7d0a | 473 | pnp_register_mem_resource(option, mem); |
1da177e4 LT |
474 | return; |
475 | } | |
476 | ||
477 | static void | |
478 | pnpacpi_parse_fixed_mem32_option(struct pnp_option *option, | |
50eca3eb | 479 | struct acpi_resource_fixed_memory32 *p) |
1da177e4 | 480 | { |
1c6e7d0a | 481 | struct pnp_mem *mem; |
1da177e4 | 482 | |
50eca3eb | 483 | if (p->address_length == 0) |
1da177e4 | 484 | return; |
cd861280 | 485 | mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL); |
1da177e4 LT |
486 | if (!mem) |
487 | return; | |
50eca3eb BM |
488 | mem->min = mem->max = p->address; |
489 | mem->size = p->address_length; | |
1da177e4 LT |
490 | mem->align = 0; |
491 | ||
0897831b | 492 | mem->flags = (ACPI_READ_WRITE_MEMORY == p->write_protect) ? |
1da177e4 LT |
493 | IORESOURCE_MEM_WRITEABLE : 0; |
494 | ||
1c6e7d0a | 495 | pnp_register_mem_resource(option, mem); |
1da177e4 LT |
496 | return; |
497 | } | |
498 | ||
6f957eaf BH |
499 | static void |
500 | pnpacpi_parse_address_option(struct pnp_option *option, struct acpi_resource *r) | |
501 | { | |
502 | struct acpi_resource_address64 addr, *p = &addr; | |
503 | acpi_status status; | |
1c6e7d0a BH |
504 | struct pnp_mem *mem; |
505 | struct pnp_port *port; | |
6f957eaf BH |
506 | |
507 | status = acpi_resource_to_address64(r, p); | |
508 | if (!ACPI_SUCCESS(status)) { | |
ed03f430 | 509 | pnp_warn("PnPACPI: failed to convert resource type %d", r->type); |
6f957eaf BH |
510 | return; |
511 | } | |
512 | ||
513 | if (p->address_length == 0) | |
514 | return; | |
515 | ||
516 | if (p->resource_type == ACPI_MEMORY_RANGE) { | |
cd861280 | 517 | mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL); |
6f957eaf BH |
518 | if (!mem) |
519 | return; | |
ed03f430 | 520 | mem->min = mem->max = p->minimum; |
6f957eaf BH |
521 | mem->size = p->address_length; |
522 | mem->align = 0; | |
ed03f430 | 523 | mem->flags = (p->info.mem.write_protect == |
6f957eaf | 524 | ACPI_READ_WRITE_MEMORY) ? IORESOURCE_MEM_WRITEABLE : 0; |
1c6e7d0a | 525 | pnp_register_mem_resource(option, mem); |
6f957eaf | 526 | } else if (p->resource_type == ACPI_IO_RANGE) { |
cd861280 | 527 | port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL); |
6f957eaf BH |
528 | if (!port) |
529 | return; | |
ed03f430 | 530 | port->min = port->max = p->minimum; |
6f957eaf BH |
531 | port->size = p->address_length; |
532 | port->align = 0; | |
533 | port->flags = PNP_PORT_FLAG_FIXED; | |
1c6e7d0a | 534 | pnp_register_port_resource(option, port); |
6f957eaf BH |
535 | } |
536 | } | |
537 | ||
1da177e4 LT |
538 | struct acpipnp_parse_option_s { |
539 | struct pnp_option *option; | |
b008b8d7 | 540 | struct pnp_option *option_independent; |
1da177e4 LT |
541 | struct pnp_dev *dev; |
542 | }; | |
543 | ||
50eca3eb | 544 | static acpi_status pnpacpi_option_resource(struct acpi_resource *res, |
1da177e4 LT |
545 | void *data) |
546 | { | |
547 | int priority = 0; | |
548 | struct acpipnp_parse_option_s *parse_data = (struct acpipnp_parse_option_s *)data; | |
549 | struct pnp_dev *dev = parse_data->dev; | |
550 | struct pnp_option *option = parse_data->option; | |
551 | ||
eca008c8 | 552 | switch (res->type) { |
50eca3eb | 553 | case ACPI_RESOURCE_TYPE_IRQ: |
1da177e4 LT |
554 | pnpacpi_parse_irq_option(option, &res->data.irq); |
555 | break; | |
0af5853b | 556 | |
50eca3eb | 557 | case ACPI_RESOURCE_TYPE_DMA: |
1c6e7d0a | 558 | pnpacpi_parse_dma_option(option, &res->data.dma); |
1da177e4 | 559 | break; |
0af5853b | 560 | |
50eca3eb | 561 | case ACPI_RESOURCE_TYPE_START_DEPENDENT: |
1da177e4 LT |
562 | switch (res->data.start_dpf.compatibility_priority) { |
563 | case ACPI_GOOD_CONFIGURATION: | |
564 | priority = PNP_RES_PRIORITY_PREFERRED; | |
565 | break; | |
1c6e7d0a | 566 | |
1da177e4 LT |
567 | case ACPI_ACCEPTABLE_CONFIGURATION: |
568 | priority = PNP_RES_PRIORITY_ACCEPTABLE; | |
569 | break; | |
570 | ||
571 | case ACPI_SUB_OPTIMAL_CONFIGURATION: | |
572 | priority = PNP_RES_PRIORITY_FUNCTIONAL; | |
573 | break; | |
574 | default: | |
575 | priority = PNP_RES_PRIORITY_INVALID; | |
576 | break; | |
577 | } | |
578 | /* TBD: Considering performace/robustness bits */ | |
579 | option = pnp_register_dependent_option(dev, priority); | |
580 | if (!option) | |
581 | return AE_ERROR; | |
1c6e7d0a | 582 | parse_data->option = option; |
1da177e4 | 583 | break; |
0af5853b | 584 | |
50eca3eb | 585 | case ACPI_RESOURCE_TYPE_END_DEPENDENT: |
b008b8d7 MC |
586 | /*only one EndDependentFn is allowed*/ |
587 | if (!parse_data->option_independent) { | |
588 | pnp_warn("PnPACPI: more than one EndDependentFn"); | |
589 | return AE_ERROR; | |
590 | } | |
591 | parse_data->option = parse_data->option_independent; | |
592 | parse_data->option_independent = NULL; | |
593 | break; | |
0af5853b LB |
594 | |
595 | case ACPI_RESOURCE_TYPE_IO: | |
596 | pnpacpi_parse_port_option(option, &res->data.io); | |
597 | break; | |
598 | ||
599 | case ACPI_RESOURCE_TYPE_FIXED_IO: | |
600 | pnpacpi_parse_fixed_port_option(option, | |
601 | &res->data.fixed_io); | |
602 | break; | |
603 | ||
604 | case ACPI_RESOURCE_TYPE_VENDOR: | |
605 | case ACPI_RESOURCE_TYPE_END_TAG: | |
606 | break; | |
607 | ||
608 | case ACPI_RESOURCE_TYPE_MEMORY24: | |
609 | pnpacpi_parse_mem24_option(option, &res->data.memory24); | |
610 | break; | |
611 | ||
612 | case ACPI_RESOURCE_TYPE_MEMORY32: | |
613 | pnpacpi_parse_mem32_option(option, &res->data.memory32); | |
614 | break; | |
615 | ||
616 | case ACPI_RESOURCE_TYPE_FIXED_MEMORY32: | |
617 | pnpacpi_parse_fixed_mem32_option(option, | |
618 | &res->data.fixed_memory32); | |
619 | break; | |
620 | ||
621 | case ACPI_RESOURCE_TYPE_ADDRESS16: | |
622 | case ACPI_RESOURCE_TYPE_ADDRESS32: | |
623 | case ACPI_RESOURCE_TYPE_ADDRESS64: | |
624 | pnpacpi_parse_address_option(option, res); | |
625 | break; | |
626 | ||
627 | case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64: | |
628 | break; | |
629 | ||
630 | case ACPI_RESOURCE_TYPE_EXTENDED_IRQ: | |
631 | pnpacpi_parse_ext_irq_option(option, | |
632 | &res->data.extended_irq); | |
633 | break; | |
634 | ||
635 | case ACPI_RESOURCE_TYPE_GENERIC_REGISTER: | |
636 | break; | |
637 | ||
1da177e4 | 638 | default: |
eca008c8 | 639 | pnp_warn("PnPACPI: unknown resource type %d", res->type); |
1da177e4 LT |
640 | return AE_ERROR; |
641 | } | |
1c6e7d0a | 642 | |
1da177e4 LT |
643 | return AE_OK; |
644 | } | |
645 | ||
50eca3eb | 646 | acpi_status pnpacpi_parse_resource_option_data(acpi_handle handle, |
1da177e4 LT |
647 | struct pnp_dev *dev) |
648 | { | |
649 | acpi_status status; | |
650 | struct acpipnp_parse_option_s parse_data; | |
651 | ||
652 | parse_data.option = pnp_register_independent_option(dev); | |
653 | if (!parse_data.option) | |
654 | return AE_ERROR; | |
b008b8d7 | 655 | parse_data.option_independent = parse_data.option; |
1da177e4 | 656 | parse_data.dev = dev; |
50eca3eb | 657 | status = acpi_walk_resources(handle, METHOD_NAME__PRS, |
1da177e4 LT |
658 | pnpacpi_option_resource, &parse_data); |
659 | ||
660 | return status; | |
661 | } | |
662 | ||
b5f2490b | 663 | static int pnpacpi_supported_resource(struct acpi_resource *res) |
1da177e4 | 664 | { |
eca008c8 | 665 | switch (res->type) { |
50eca3eb | 666 | case ACPI_RESOURCE_TYPE_IRQ: |
50eca3eb BM |
667 | case ACPI_RESOURCE_TYPE_DMA: |
668 | case ACPI_RESOURCE_TYPE_IO: | |
669 | case ACPI_RESOURCE_TYPE_FIXED_IO: | |
670 | case ACPI_RESOURCE_TYPE_MEMORY24: | |
671 | case ACPI_RESOURCE_TYPE_MEMORY32: | |
672 | case ACPI_RESOURCE_TYPE_FIXED_MEMORY32: | |
50eca3eb BM |
673 | case ACPI_RESOURCE_TYPE_ADDRESS16: |
674 | case ACPI_RESOURCE_TYPE_ADDRESS32: | |
675 | case ACPI_RESOURCE_TYPE_ADDRESS64: | |
0af5853b | 676 | case ACPI_RESOURCE_TYPE_EXTENDED_IRQ: |
b5f2490b | 677 | return 1; |
1da177e4 | 678 | } |
b5f2490b BH |
679 | return 0; |
680 | } | |
681 | ||
682 | /* | |
683 | * Set resource | |
684 | */ | |
685 | static acpi_status pnpacpi_count_resources(struct acpi_resource *res, | |
686 | void *data) | |
687 | { | |
688 | int *res_cnt = (int *)data; | |
689 | ||
690 | if (pnpacpi_supported_resource(res)) | |
691 | (*res_cnt)++; | |
1da177e4 LT |
692 | return AE_OK; |
693 | } | |
694 | ||
1c6e7d0a | 695 | static acpi_status pnpacpi_type_resources(struct acpi_resource *res, void *data) |
1da177e4 | 696 | { |
1c6e7d0a | 697 | struct acpi_resource **resource = (struct acpi_resource **)data; |
b5f2490b BH |
698 | |
699 | if (pnpacpi_supported_resource(res)) { | |
eca008c8 | 700 | (*resource)->type = res->type; |
b5f2490b | 701 | (*resource)->length = sizeof(struct acpi_resource); |
1da177e4 | 702 | (*resource)++; |
1da177e4 LT |
703 | } |
704 | ||
705 | return AE_OK; | |
706 | } | |
707 | ||
50eca3eb | 708 | int pnpacpi_build_resource_template(acpi_handle handle, |
1da177e4 LT |
709 | struct acpi_buffer *buffer) |
710 | { | |
711 | struct acpi_resource *resource; | |
712 | int res_cnt = 0; | |
713 | acpi_status status; | |
714 | ||
50eca3eb | 715 | status = acpi_walk_resources(handle, METHOD_NAME__CRS, |
1da177e4 LT |
716 | pnpacpi_count_resources, &res_cnt); |
717 | if (ACPI_FAILURE(status)) { | |
718 | pnp_err("Evaluate _CRS failed"); | |
719 | return -EINVAL; | |
720 | } | |
721 | if (!res_cnt) | |
722 | return -EINVAL; | |
723 | buffer->length = sizeof(struct acpi_resource) * (res_cnt + 1) + 1; | |
cd861280 | 724 | buffer->pointer = kzalloc(buffer->length - 1, GFP_KERNEL); |
1da177e4 LT |
725 | if (!buffer->pointer) |
726 | return -ENOMEM; | |
727 | pnp_dbg("Res cnt %d", res_cnt); | |
728 | resource = (struct acpi_resource *)buffer->pointer; | |
50eca3eb | 729 | status = acpi_walk_resources(handle, METHOD_NAME__CRS, |
1da177e4 LT |
730 | pnpacpi_type_resources, &resource); |
731 | if (ACPI_FAILURE(status)) { | |
732 | kfree(buffer->pointer); | |
733 | pnp_err("Evaluate _CRS failed"); | |
734 | return -EINVAL; | |
735 | } | |
736 | /* resource will pointer the end resource now */ | |
50eca3eb | 737 | resource->type = ACPI_RESOURCE_TYPE_END_TAG; |
1da177e4 LT |
738 | |
739 | return 0; | |
740 | } | |
741 | ||
50eca3eb | 742 | static void pnpacpi_encode_irq(struct acpi_resource *resource, |
1da177e4 LT |
743 | struct resource *p) |
744 | { | |
50eca3eb | 745 | int triggering, polarity; |
1c6e7d0a BH |
746 | |
747 | decode_irq_flags(p->flags & IORESOURCE_BITS, &triggering, &polarity); | |
50eca3eb BM |
748 | resource->data.irq.triggering = triggering; |
749 | resource->data.irq.polarity = polarity; | |
750 | if (triggering == ACPI_EDGE_SENSITIVE) | |
751 | resource->data.irq.sharable = ACPI_EXCLUSIVE; | |
1da177e4 | 752 | else |
50eca3eb BM |
753 | resource->data.irq.sharable = ACPI_SHARED; |
754 | resource->data.irq.interrupt_count = 1; | |
1da177e4 LT |
755 | resource->data.irq.interrupts[0] = p->start; |
756 | } | |
757 | ||
758 | static void pnpacpi_encode_ext_irq(struct acpi_resource *resource, | |
759 | struct resource *p) | |
760 | { | |
50eca3eb | 761 | int triggering, polarity; |
1c6e7d0a BH |
762 | |
763 | decode_irq_flags(p->flags & IORESOURCE_BITS, &triggering, &polarity); | |
1da177e4 | 764 | resource->data.extended_irq.producer_consumer = ACPI_CONSUMER; |
50eca3eb BM |
765 | resource->data.extended_irq.triggering = triggering; |
766 | resource->data.extended_irq.polarity = polarity; | |
767 | if (triggering == ACPI_EDGE_SENSITIVE) | |
768 | resource->data.irq.sharable = ACPI_EXCLUSIVE; | |
1da177e4 | 769 | else |
50eca3eb BM |
770 | resource->data.irq.sharable = ACPI_SHARED; |
771 | resource->data.extended_irq.interrupt_count = 1; | |
1da177e4 LT |
772 | resource->data.extended_irq.interrupts[0] = p->start; |
773 | } | |
774 | ||
775 | static void pnpacpi_encode_dma(struct acpi_resource *resource, | |
776 | struct resource *p) | |
777 | { | |
1da177e4 | 778 | /* Note: pnp_assign_dma will copy pnp_dma->flags into p->flags */ |
ccc4c7bb VP |
779 | switch (p->flags & IORESOURCE_DMA_SPEED_MASK) { |
780 | case IORESOURCE_DMA_TYPEA: | |
781 | resource->data.dma.type = ACPI_TYPE_A; | |
782 | break; | |
783 | case IORESOURCE_DMA_TYPEB: | |
784 | resource->data.dma.type = ACPI_TYPE_B; | |
785 | break; | |
786 | case IORESOURCE_DMA_TYPEF: | |
787 | resource->data.dma.type = ACPI_TYPE_F; | |
788 | break; | |
789 | default: | |
790 | resource->data.dma.type = ACPI_COMPATIBILITY; | |
791 | } | |
792 | ||
793 | switch (p->flags & IORESOURCE_DMA_TYPE_MASK) { | |
794 | case IORESOURCE_DMA_8BIT: | |
795 | resource->data.dma.transfer = ACPI_TRANSFER_8; | |
796 | break; | |
797 | case IORESOURCE_DMA_8AND16BIT: | |
798 | resource->data.dma.transfer = ACPI_TRANSFER_8_16; | |
799 | break; | |
800 | default: | |
801 | resource->data.dma.transfer = ACPI_TRANSFER_16; | |
802 | } | |
803 | ||
804 | resource->data.dma.bus_master = !!(p->flags & IORESOURCE_DMA_MASTER); | |
50eca3eb | 805 | resource->data.dma.channel_count = 1; |
1da177e4 LT |
806 | resource->data.dma.channels[0] = p->start; |
807 | } | |
808 | ||
809 | static void pnpacpi_encode_io(struct acpi_resource *resource, | |
810 | struct resource *p) | |
811 | { | |
1da177e4 LT |
812 | /* Note: pnp_assign_port will copy pnp_port->flags into p->flags */ |
813 | resource->data.io.io_decode = (p->flags & PNP_PORT_FLAG_16BITADDR)? | |
50eca3eb BM |
814 | ACPI_DECODE_16 : ACPI_DECODE_10; |
815 | resource->data.io.minimum = p->start; | |
816 | resource->data.io.maximum = p->end; | |
1da177e4 | 817 | resource->data.io.alignment = 0; /* Correct? */ |
50eca3eb | 818 | resource->data.io.address_length = p->end - p->start + 1; |
1da177e4 LT |
819 | } |
820 | ||
821 | static void pnpacpi_encode_fixed_io(struct acpi_resource *resource, | |
822 | struct resource *p) | |
823 | { | |
50eca3eb BM |
824 | resource->data.fixed_io.address = p->start; |
825 | resource->data.fixed_io.address_length = p->end - p->start + 1; | |
1da177e4 LT |
826 | } |
827 | ||
828 | static void pnpacpi_encode_mem24(struct acpi_resource *resource, | |
829 | struct resource *p) | |
830 | { | |
1da177e4 | 831 | /* Note: pnp_assign_mem will copy pnp_mem->flags into p->flags */ |
0897831b | 832 | resource->data.memory24.write_protect = |
1da177e4 LT |
833 | (p->flags & IORESOURCE_MEM_WRITEABLE) ? |
834 | ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY; | |
50eca3eb BM |
835 | resource->data.memory24.minimum = p->start; |
836 | resource->data.memory24.maximum = p->end; | |
1da177e4 | 837 | resource->data.memory24.alignment = 0; |
50eca3eb | 838 | resource->data.memory24.address_length = p->end - p->start + 1; |
1da177e4 LT |
839 | } |
840 | ||
841 | static void pnpacpi_encode_mem32(struct acpi_resource *resource, | |
842 | struct resource *p) | |
843 | { | |
0897831b | 844 | resource->data.memory32.write_protect = |
1da177e4 LT |
845 | (p->flags & IORESOURCE_MEM_WRITEABLE) ? |
846 | ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY; | |
50eca3eb BM |
847 | resource->data.memory32.minimum = p->start; |
848 | resource->data.memory32.maximum = p->end; | |
1da177e4 | 849 | resource->data.memory32.alignment = 0; |
50eca3eb | 850 | resource->data.memory32.address_length = p->end - p->start + 1; |
1da177e4 LT |
851 | } |
852 | ||
853 | static void pnpacpi_encode_fixed_mem32(struct acpi_resource *resource, | |
854 | struct resource *p) | |
855 | { | |
0897831b | 856 | resource->data.fixed_memory32.write_protect = |
1da177e4 LT |
857 | (p->flags & IORESOURCE_MEM_WRITEABLE) ? |
858 | ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY; | |
50eca3eb BM |
859 | resource->data.fixed_memory32.address = p->start; |
860 | resource->data.fixed_memory32.address_length = p->end - p->start + 1; | |
1da177e4 LT |
861 | } |
862 | ||
50eca3eb | 863 | int pnpacpi_encode_resources(struct pnp_resource_table *res_table, |
1da177e4 LT |
864 | struct acpi_buffer *buffer) |
865 | { | |
866 | int i = 0; | |
867 | /* pnpacpi_build_resource_template allocates extra mem */ | |
868 | int res_cnt = (buffer->length - 1)/sizeof(struct acpi_resource) - 1; | |
869 | struct acpi_resource *resource = (struct acpi_resource*)buffer->pointer; | |
870 | int port = 0, irq = 0, dma = 0, mem = 0; | |
871 | ||
872 | pnp_dbg("res cnt %d", res_cnt); | |
873 | while (i < res_cnt) { | |
eca008c8 | 874 | switch(resource->type) { |
50eca3eb | 875 | case ACPI_RESOURCE_TYPE_IRQ: |
1da177e4 | 876 | pnp_dbg("Encode irq"); |
50eca3eb | 877 | pnpacpi_encode_irq(resource, |
1da177e4 LT |
878 | &res_table->irq_resource[irq]); |
879 | irq++; | |
880 | break; | |
881 | ||
50eca3eb | 882 | case ACPI_RESOURCE_TYPE_DMA: |
1da177e4 | 883 | pnp_dbg("Encode dma"); |
50eca3eb | 884 | pnpacpi_encode_dma(resource, |
1da177e4 | 885 | &res_table->dma_resource[dma]); |
1c6e7d0a | 886 | dma++; |
1da177e4 | 887 | break; |
50eca3eb | 888 | case ACPI_RESOURCE_TYPE_IO: |
1da177e4 | 889 | pnp_dbg("Encode io"); |
50eca3eb | 890 | pnpacpi_encode_io(resource, |
1da177e4 | 891 | &res_table->port_resource[port]); |
1c6e7d0a | 892 | port++; |
1da177e4 | 893 | break; |
50eca3eb | 894 | case ACPI_RESOURCE_TYPE_FIXED_IO: |
1da177e4 LT |
895 | pnp_dbg("Encode fixed io"); |
896 | pnpacpi_encode_fixed_io(resource, | |
897 | &res_table->port_resource[port]); | |
1c6e7d0a | 898 | port++; |
1da177e4 | 899 | break; |
50eca3eb | 900 | case ACPI_RESOURCE_TYPE_MEMORY24: |
1da177e4 LT |
901 | pnp_dbg("Encode mem24"); |
902 | pnpacpi_encode_mem24(resource, | |
903 | &res_table->mem_resource[mem]); | |
1c6e7d0a | 904 | mem++; |
1da177e4 | 905 | break; |
50eca3eb | 906 | case ACPI_RESOURCE_TYPE_MEMORY32: |
1da177e4 LT |
907 | pnp_dbg("Encode mem32"); |
908 | pnpacpi_encode_mem32(resource, | |
909 | &res_table->mem_resource[mem]); | |
1c6e7d0a | 910 | mem++; |
1da177e4 | 911 | break; |
50eca3eb | 912 | case ACPI_RESOURCE_TYPE_FIXED_MEMORY32: |
1da177e4 LT |
913 | pnp_dbg("Encode fixed mem32"); |
914 | pnpacpi_encode_fixed_mem32(resource, | |
915 | &res_table->mem_resource[mem]); | |
1c6e7d0a | 916 | mem++; |
1da177e4 | 917 | break; |
0af5853b LB |
918 | case ACPI_RESOURCE_TYPE_EXTENDED_IRQ: |
919 | pnp_dbg("Encode ext irq"); | |
920 | pnpacpi_encode_ext_irq(resource, | |
921 | &res_table->irq_resource[irq]); | |
922 | irq++; | |
923 | break; | |
924 | case ACPI_RESOURCE_TYPE_START_DEPENDENT: | |
925 | case ACPI_RESOURCE_TYPE_END_DEPENDENT: | |
926 | case ACPI_RESOURCE_TYPE_VENDOR: | |
927 | case ACPI_RESOURCE_TYPE_END_TAG: | |
928 | case ACPI_RESOURCE_TYPE_ADDRESS16: | |
929 | case ACPI_RESOURCE_TYPE_ADDRESS32: | |
930 | case ACPI_RESOURCE_TYPE_ADDRESS64: | |
931 | case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64: | |
932 | case ACPI_RESOURCE_TYPE_GENERIC_REGISTER: | |
1da177e4 | 933 | default: /* other type */ |
eca008c8 | 934 | pnp_warn("unknown resource type %d", resource->type); |
1da177e4 LT |
935 | return -EINVAL; |
936 | } | |
1c6e7d0a BH |
937 | resource++; |
938 | i++; | |
1da177e4 LT |
939 | } |
940 | return 0; | |
941 | } |