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> | |
40ab4f4c BH |
6 | * Copyright (C) 2008 Hewlett-Packard Development Company, L.P. |
7 | * Bjorn Helgaas <bjorn.helgaas@hp.com> | |
50eca3eb | 8 | * |
1da177e4 LT |
9 | * This program is free software; you can redistribute it and/or modify it |
10 | * under the terms of the GNU General Public License as published by the | |
11 | * Free Software Foundation; either version 2, or (at your option) any | |
12 | * later version. | |
13 | * | |
14 | * This program is distributed in the hope that it will be useful, but | |
15 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
17 | * General Public License for more details. | |
18 | * | |
19 | * You should have received a copy of the GNU General Public License | |
20 | * along with this program; if not, write to the Free Software | |
21 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
22 | */ | |
23 | #include <linux/kernel.h> | |
24 | #include <linux/acpi.h> | |
25 | #include <linux/pci.h> | |
02d83b5d BH |
26 | #include <linux/pnp.h> |
27 | #include "../base.h" | |
1da177e4 LT |
28 | #include "pnpacpi.h" |
29 | ||
30 | #ifdef CONFIG_IA64 | |
31 | #define valid_IRQ(i) (1) | |
32 | #else | |
33 | #define valid_IRQ(i) (((i) != 0) && ((i) != 2)) | |
34 | #endif | |
35 | ||
36 | /* | |
37 | * Allocated Resources | |
38 | */ | |
cd7ec927 | 39 | static int irq_flags(int triggering, int polarity, int shareable) |
1da177e4 | 40 | { |
cd7ec927 BH |
41 | int flags; |
42 | ||
50eca3eb | 43 | if (triggering == ACPI_LEVEL_SENSITIVE) { |
1c6e7d0a | 44 | if (polarity == ACPI_ACTIVE_LOW) |
cd7ec927 | 45 | flags = IORESOURCE_IRQ_LOWLEVEL; |
1da177e4 | 46 | else |
cd7ec927 | 47 | flags = IORESOURCE_IRQ_HIGHLEVEL; |
9dd78466 | 48 | } else { |
1c6e7d0a | 49 | if (polarity == ACPI_ACTIVE_LOW) |
cd7ec927 | 50 | flags = IORESOURCE_IRQ_LOWEDGE; |
1da177e4 | 51 | else |
cd7ec927 | 52 | flags = IORESOURCE_IRQ_HIGHEDGE; |
1da177e4 | 53 | } |
cd7ec927 | 54 | |
a993273b | 55 | if (shareable == ACPI_SHARED) |
cd7ec927 BH |
56 | flags |= IORESOURCE_IRQ_SHAREABLE; |
57 | ||
58 | return flags; | |
1da177e4 LT |
59 | } |
60 | ||
e9fe9e18 | 61 | static void decode_irq_flags(struct pnp_dev *dev, int flags, int *triggering, |
a993273b | 62 | int *polarity, int *shareable) |
1da177e4 | 63 | { |
e9fe9e18 BH |
64 | switch (flags & (IORESOURCE_IRQ_LOWLEVEL | IORESOURCE_IRQ_HIGHLEVEL | |
65 | IORESOURCE_IRQ_LOWEDGE | IORESOURCE_IRQ_HIGHEDGE)) { | |
1da177e4 | 66 | case IORESOURCE_IRQ_LOWLEVEL: |
50eca3eb BM |
67 | *triggering = ACPI_LEVEL_SENSITIVE; |
68 | *polarity = ACPI_ACTIVE_LOW; | |
1da177e4 | 69 | break; |
1c6e7d0a | 70 | case IORESOURCE_IRQ_HIGHLEVEL: |
50eca3eb BM |
71 | *triggering = ACPI_LEVEL_SENSITIVE; |
72 | *polarity = ACPI_ACTIVE_HIGH; | |
1da177e4 LT |
73 | break; |
74 | case IORESOURCE_IRQ_LOWEDGE: | |
50eca3eb BM |
75 | *triggering = ACPI_EDGE_SENSITIVE; |
76 | *polarity = ACPI_ACTIVE_LOW; | |
1da177e4 LT |
77 | break; |
78 | case IORESOURCE_IRQ_HIGHEDGE: | |
50eca3eb BM |
79 | *triggering = ACPI_EDGE_SENSITIVE; |
80 | *polarity = ACPI_ACTIVE_HIGH; | |
1da177e4 | 81 | break; |
e9fe9e18 BH |
82 | default: |
83 | dev_err(&dev->dev, "can't encode invalid IRQ mode %#x\n", | |
84 | flags); | |
85 | *triggering = ACPI_EDGE_SENSITIVE; | |
86 | *polarity = ACPI_ACTIVE_HIGH; | |
87 | break; | |
1da177e4 | 88 | } |
a993273b BH |
89 | |
90 | if (flags & IORESOURCE_IRQ_SHAREABLE) | |
91 | *shareable = ACPI_SHARED; | |
92 | else | |
93 | *shareable = ACPI_EXCLUSIVE; | |
1da177e4 LT |
94 | } |
95 | ||
4ab55d8d | 96 | static void pnpacpi_parse_allocated_irqresource(struct pnp_dev *dev, |
07d4e9af BH |
97 | u32 gsi, int triggering, |
98 | int polarity, int shareable) | |
1da177e4 | 99 | { |
dbddd038 | 100 | int irq, flags; |
61fd47e0 | 101 | int p, t; |
dbed12da | 102 | |
5acf9141 BH |
103 | if (!valid_IRQ(gsi)) { |
104 | pnp_add_irq_resource(dev, gsi, IORESOURCE_DISABLED); | |
dbed12da | 105 | return; |
5acf9141 | 106 | } |
dbed12da | 107 | |
61fd47e0 SL |
108 | /* |
109 | * in IO-APIC mode, use overrided attribute. Two reasons: | |
110 | * 1. BIOS bug in DSDT | |
111 | * 2. BIOS uses IO-APIC mode Interrupt Source Override | |
112 | */ | |
113 | if (!acpi_get_override_irq(gsi, &t, &p)) { | |
114 | t = t ? ACPI_LEVEL_SENSITIVE : ACPI_EDGE_SENSITIVE; | |
115 | p = p ? ACPI_ACTIVE_LOW : ACPI_ACTIVE_HIGH; | |
116 | ||
117 | if (triggering != t || polarity != p) { | |
af11cb2d | 118 | dev_warn(&dev->dev, "IRQ %d override to %s, %s\n", |
61fd47e0 SL |
119 | gsi, t ? "edge":"level", p ? "low":"high"); |
120 | triggering = t; | |
121 | polarity = p; | |
122 | } | |
123 | } | |
124 | ||
dbddd038 | 125 | flags = irq_flags(triggering, polarity, shareable); |
a2f809b0 | 126 | irq = acpi_register_gsi(&dev->dev, gsi, triggering, polarity); |
dbddd038 BH |
127 | if (irq >= 0) |
128 | pcibios_penalize_isa_irq(irq, 1); | |
129 | else | |
130 | flags |= IORESOURCE_DISABLED; | |
dbed12da | 131 | |
dbddd038 | 132 | pnp_add_irq_resource(dev, irq, flags); |
1da177e4 LT |
133 | } |
134 | ||
958a1fdd BH |
135 | static int dma_flags(struct pnp_dev *dev, int type, int bus_master, |
136 | int transfer) | |
362ea087 MK |
137 | { |
138 | int flags = 0; | |
139 | ||
140 | if (bus_master) | |
141 | flags |= IORESOURCE_DMA_MASTER; | |
142 | switch (type) { | |
143 | case ACPI_COMPATIBILITY: | |
144 | flags |= IORESOURCE_DMA_COMPATIBLE; | |
145 | break; | |
146 | case ACPI_TYPE_A: | |
147 | flags |= IORESOURCE_DMA_TYPEA; | |
148 | break; | |
149 | case ACPI_TYPE_B: | |
150 | flags |= IORESOURCE_DMA_TYPEB; | |
151 | break; | |
152 | case ACPI_TYPE_F: | |
153 | flags |= IORESOURCE_DMA_TYPEF; | |
154 | break; | |
155 | default: | |
156 | /* Set a default value ? */ | |
157 | flags |= IORESOURCE_DMA_COMPATIBLE; | |
958a1fdd | 158 | dev_err(&dev->dev, "invalid DMA type %d\n", type); |
362ea087 MK |
159 | } |
160 | switch (transfer) { | |
161 | case ACPI_TRANSFER_8: | |
162 | flags |= IORESOURCE_DMA_8BIT; | |
163 | break; | |
164 | case ACPI_TRANSFER_8_16: | |
165 | flags |= IORESOURCE_DMA_8AND16BIT; | |
166 | break; | |
167 | case ACPI_TRANSFER_16: | |
168 | flags |= IORESOURCE_DMA_16BIT; | |
169 | break; | |
170 | default: | |
171 | /* Set a default value ? */ | |
172 | flags |= IORESOURCE_DMA_8AND16BIT; | |
958a1fdd | 173 | dev_err(&dev->dev, "invalid DMA transfer type %d\n", transfer); |
362ea087 MK |
174 | } |
175 | ||
176 | return flags; | |
177 | } | |
178 | ||
cc8c2e30 BH |
179 | static void pnpacpi_parse_allocated_ioresource(struct pnp_dev *dev, u64 start, |
180 | u64 len, int io_decode) | |
1da177e4 | 181 | { |
cc8c2e30 BH |
182 | int flags = 0; |
183 | u64 end = start + len - 1; | |
07d4e9af | 184 | |
cc8c2e30 | 185 | if (io_decode == ACPI_DECODE_16) |
08c9f262 | 186 | flags |= IORESOURCE_IO_16BIT_ADDR; |
cc8c2e30 BH |
187 | if (len == 0 || end >= 0x10003) |
188 | flags |= IORESOURCE_DISABLED; | |
189 | ||
190 | pnp_add_io_resource(dev, start, end, flags); | |
1da177e4 LT |
191 | } |
192 | ||
40ab4f4c BH |
193 | /* |
194 | * Device CSRs that do not appear in PCI config space should be described | |
195 | * via ACPI. This would normally be done with Address Space Descriptors | |
196 | * marked as "consumer-only," but old versions of Windows and Linux ignore | |
197 | * the producer/consumer flag, so HP invented a vendor-defined resource to | |
198 | * describe the location and size of CSR space. | |
199 | */ | |
200 | static struct acpi_vendor_uuid hp_ccsr_uuid = { | |
201 | .subtype = 2, | |
202 | .data = { 0xf9, 0xad, 0xe9, 0x69, 0x4f, 0x92, 0x5f, 0xab, 0xf6, 0x4a, | |
203 | 0x24, 0xd2, 0x01, 0x37, 0x0e, 0xad }, | |
204 | }; | |
205 | ||
206 | static int vendor_resource_matches(struct pnp_dev *dev, | |
207 | struct acpi_resource_vendor_typed *vendor, | |
208 | struct acpi_vendor_uuid *match, | |
209 | int expected_len) | |
210 | { | |
211 | int uuid_len = sizeof(vendor->uuid); | |
212 | u8 uuid_subtype = vendor->uuid_subtype; | |
213 | u8 *uuid = vendor->uuid; | |
214 | int actual_len; | |
215 | ||
216 | /* byte_length includes uuid_subtype and uuid */ | |
217 | actual_len = vendor->byte_length - uuid_len - 1; | |
218 | ||
219 | if (uuid_subtype == match->subtype && | |
220 | uuid_len == sizeof(match->data) && | |
221 | memcmp(uuid, match->data, uuid_len) == 0) { | |
222 | if (expected_len && expected_len != actual_len) { | |
223 | dev_err(&dev->dev, "wrong vendor descriptor size; " | |
224 | "expected %d, found %d bytes\n", | |
225 | expected_len, actual_len); | |
226 | return 0; | |
227 | } | |
228 | ||
229 | return 1; | |
230 | } | |
231 | ||
232 | return 0; | |
233 | } | |
234 | ||
235 | static void pnpacpi_parse_allocated_vendor(struct pnp_dev *dev, | |
236 | struct acpi_resource_vendor_typed *vendor) | |
237 | { | |
238 | if (vendor_resource_matches(dev, vendor, &hp_ccsr_uuid, 16)) { | |
239 | u64 start, length; | |
240 | ||
241 | memcpy(&start, vendor->byte_data, sizeof(start)); | |
242 | memcpy(&length, vendor->byte_data + 8, sizeof(length)); | |
243 | ||
244 | pnp_add_mem_resource(dev, start, start + length - 1, 0); | |
245 | } | |
246 | } | |
247 | ||
4ab55d8d | 248 | static void pnpacpi_parse_allocated_memresource(struct pnp_dev *dev, |
d6180f36 | 249 | u64 start, u64 len, |
07d4e9af | 250 | int write_protect) |
1da177e4 | 251 | { |
d6180f36 BH |
252 | int flags = 0; |
253 | u64 end = start + len - 1; | |
254 | ||
255 | if (len == 0) | |
256 | flags |= IORESOURCE_DISABLED; | |
257 | if (write_protect == ACPI_READ_WRITE_MEMORY) | |
258 | flags |= IORESOURCE_MEM_WRITEABLE; | |
259 | ||
260 | pnp_add_mem_resource(dev, start, end, flags); | |
1da177e4 LT |
261 | } |
262 | ||
4ab55d8d | 263 | static void pnpacpi_parse_allocated_address_space(struct pnp_dev *dev, |
07d4e9af | 264 | struct acpi_resource *res) |
1acfb7f2 BH |
265 | { |
266 | struct acpi_resource_address64 addr, *p = &addr; | |
267 | acpi_status status; | |
268 | ||
269 | status = acpi_resource_to_address64(res, p); | |
270 | if (!ACPI_SUCCESS(status)) { | |
af11cb2d | 271 | dev_warn(&dev->dev, "failed to convert resource type %d\n", |
9dd78466 | 272 | res->type); |
1acfb7f2 BH |
273 | return; |
274 | } | |
275 | ||
2b8de5f5 | 276 | if (p->producer_consumer == ACPI_PRODUCER) |
277 | return; | |
278 | ||
1acfb7f2 | 279 | if (p->resource_type == ACPI_MEMORY_RANGE) |
4ab55d8d | 280 | pnpacpi_parse_allocated_memresource(dev, |
07d4e9af BH |
281 | p->minimum, p->address_length, |
282 | p->info.mem.write_protect); | |
1acfb7f2 | 283 | else if (p->resource_type == ACPI_IO_RANGE) |
4ab55d8d | 284 | pnpacpi_parse_allocated_ioresource(dev, |
07d4e9af BH |
285 | p->minimum, p->address_length, |
286 | p->granularity == 0xfff ? ACPI_DECODE_10 : | |
287 | ACPI_DECODE_16); | |
1acfb7f2 | 288 | } |
1da177e4 | 289 | |
8cb24c8f BH |
290 | static void pnpacpi_parse_allocated_ext_address_space(struct pnp_dev *dev, |
291 | struct acpi_resource *res) | |
292 | { | |
293 | struct acpi_resource_extended_address64 *p = &res->data.ext_address64; | |
294 | ||
295 | if (p->producer_consumer == ACPI_PRODUCER) | |
296 | return; | |
297 | ||
298 | if (p->resource_type == ACPI_MEMORY_RANGE) | |
299 | pnpacpi_parse_allocated_memresource(dev, | |
300 | p->minimum, p->address_length, | |
301 | p->info.mem.write_protect); | |
302 | else if (p->resource_type == ACPI_IO_RANGE) | |
303 | pnpacpi_parse_allocated_ioresource(dev, | |
304 | p->minimum, p->address_length, | |
305 | p->granularity == 0xfff ? ACPI_DECODE_10 : | |
306 | ACPI_DECODE_16); | |
307 | } | |
308 | ||
1da177e4 | 309 | static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res, |
9dd78466 | 310 | void *data) |
1da177e4 | 311 | { |
4ab55d8d | 312 | struct pnp_dev *dev = data; |
9570a20e BH |
313 | struct acpi_resource_irq *irq; |
314 | struct acpi_resource_dma *dma; | |
315 | struct acpi_resource_io *io; | |
316 | struct acpi_resource_fixed_io *fixed_io; | |
40ab4f4c | 317 | struct acpi_resource_vendor_typed *vendor_typed; |
9570a20e BH |
318 | struct acpi_resource_memory24 *memory24; |
319 | struct acpi_resource_memory32 *memory32; | |
320 | struct acpi_resource_fixed_memory32 *fixed_memory32; | |
321 | struct acpi_resource_extended_irq *extended_irq; | |
dc16f5f2 | 322 | int i, flags; |
1da177e4 | 323 | |
eca008c8 | 324 | switch (res->type) { |
50eca3eb | 325 | case ACPI_RESOURCE_TYPE_IRQ: |
dbed12da BH |
326 | /* |
327 | * Per spec, only one interrupt per descriptor is allowed in | |
328 | * _CRS, but some firmware violates this, so parse them all. | |
329 | */ | |
9570a20e | 330 | irq = &res->data.irq; |
5acf9141 BH |
331 | if (irq->interrupt_count == 0) |
332 | pnp_add_irq_resource(dev, 0, IORESOURCE_DISABLED); | |
333 | else { | |
334 | for (i = 0; i < irq->interrupt_count; i++) { | |
335 | pnpacpi_parse_allocated_irqresource(dev, | |
336 | irq->interrupts[i], | |
337 | irq->triggering, | |
338 | irq->polarity, | |
339 | irq->sharable); | |
340 | } | |
341 | ||
342 | /* | |
343 | * The IRQ encoder puts a single interrupt in each | |
344 | * descriptor, so if a _CRS descriptor has more than | |
345 | * one interrupt, we won't be able to re-encode it. | |
346 | */ | |
347 | if (pnp_can_write(dev) && irq->interrupt_count > 1) { | |
348 | dev_warn(&dev->dev, "multiple interrupts in " | |
349 | "_CRS descriptor; configuration can't " | |
350 | "be changed\n"); | |
351 | dev->capabilities &= ~PNP_WRITE; | |
352 | } | |
1da177e4 LT |
353 | } |
354 | break; | |
355 | ||
50eca3eb | 356 | case ACPI_RESOURCE_TYPE_DMA: |
9570a20e | 357 | dma = &res->data.dma; |
5acf9141 | 358 | if (dma->channel_count > 0 && dma->channels[0] != (u8) -1) |
958a1fdd | 359 | flags = dma_flags(dev, dma->type, dma->bus_master, |
dc16f5f2 | 360 | dma->transfer); |
5acf9141 BH |
361 | else |
362 | flags = IORESOURCE_DISABLED; | |
363 | pnp_add_dma_resource(dev, dma->channels[0], flags); | |
1da177e4 | 364 | break; |
0af5853b | 365 | |
50eca3eb | 366 | case ACPI_RESOURCE_TYPE_IO: |
9570a20e | 367 | io = &res->data.io; |
4ab55d8d | 368 | pnpacpi_parse_allocated_ioresource(dev, |
9570a20e BH |
369 | io->minimum, |
370 | io->address_length, | |
371 | io->io_decode); | |
1da177e4 | 372 | break; |
0af5853b LB |
373 | |
374 | case ACPI_RESOURCE_TYPE_START_DEPENDENT: | |
375 | case ACPI_RESOURCE_TYPE_END_DEPENDENT: | |
376 | break; | |
377 | ||
50eca3eb | 378 | case ACPI_RESOURCE_TYPE_FIXED_IO: |
9570a20e | 379 | fixed_io = &res->data.fixed_io; |
4ab55d8d | 380 | pnpacpi_parse_allocated_ioresource(dev, |
9570a20e BH |
381 | fixed_io->address, |
382 | fixed_io->address_length, | |
07d4e9af | 383 | ACPI_DECODE_10); |
1da177e4 | 384 | break; |
0af5853b LB |
385 | |
386 | case ACPI_RESOURCE_TYPE_VENDOR: | |
40ab4f4c BH |
387 | vendor_typed = &res->data.vendor_typed; |
388 | pnpacpi_parse_allocated_vendor(dev, vendor_typed); | |
0af5853b LB |
389 | break; |
390 | ||
391 | case ACPI_RESOURCE_TYPE_END_TAG: | |
392 | break; | |
393 | ||
50eca3eb | 394 | case ACPI_RESOURCE_TYPE_MEMORY24: |
9570a20e | 395 | memory24 = &res->data.memory24; |
4ab55d8d | 396 | pnpacpi_parse_allocated_memresource(dev, |
9570a20e BH |
397 | memory24->minimum, |
398 | memory24->address_length, | |
399 | memory24->write_protect); | |
1da177e4 | 400 | break; |
50eca3eb | 401 | case ACPI_RESOURCE_TYPE_MEMORY32: |
9570a20e | 402 | memory32 = &res->data.memory32; |
4ab55d8d | 403 | pnpacpi_parse_allocated_memresource(dev, |
9570a20e BH |
404 | memory32->minimum, |
405 | memory32->address_length, | |
406 | memory32->write_protect); | |
1da177e4 | 407 | break; |
50eca3eb | 408 | case ACPI_RESOURCE_TYPE_FIXED_MEMORY32: |
9570a20e | 409 | fixed_memory32 = &res->data.fixed_memory32; |
4ab55d8d | 410 | pnpacpi_parse_allocated_memresource(dev, |
9570a20e BH |
411 | fixed_memory32->address, |
412 | fixed_memory32->address_length, | |
413 | fixed_memory32->write_protect); | |
1da177e4 | 414 | break; |
50eca3eb | 415 | case ACPI_RESOURCE_TYPE_ADDRESS16: |
50eca3eb | 416 | case ACPI_RESOURCE_TYPE_ADDRESS32: |
50eca3eb | 417 | case ACPI_RESOURCE_TYPE_ADDRESS64: |
4ab55d8d | 418 | pnpacpi_parse_allocated_address_space(dev, res); |
1da177e4 | 419 | break; |
0af5853b LB |
420 | |
421 | case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64: | |
8cb24c8f | 422 | pnpacpi_parse_allocated_ext_address_space(dev, res); |
0af5853b LB |
423 | break; |
424 | ||
425 | case ACPI_RESOURCE_TYPE_EXTENDED_IRQ: | |
9570a20e | 426 | extended_irq = &res->data.extended_irq; |
2b8de5f5 | 427 | |
5acf9141 BH |
428 | if (extended_irq->interrupt_count == 0) |
429 | pnp_add_irq_resource(dev, 0, IORESOURCE_DISABLED); | |
430 | else { | |
431 | for (i = 0; i < extended_irq->interrupt_count; i++) { | |
432 | pnpacpi_parse_allocated_irqresource(dev, | |
433 | extended_irq->interrupts[i], | |
434 | extended_irq->triggering, | |
435 | extended_irq->polarity, | |
436 | extended_irq->sharable); | |
437 | } | |
438 | ||
439 | /* | |
440 | * The IRQ encoder puts a single interrupt in each | |
441 | * descriptor, so if a _CRS descriptor has more than | |
442 | * one interrupt, we won't be able to re-encode it. | |
443 | */ | |
444 | if (pnp_can_write(dev) && | |
445 | extended_irq->interrupt_count > 1) { | |
446 | dev_warn(&dev->dev, "multiple interrupts in " | |
447 | "_CRS descriptor; configuration can't " | |
448 | "be changed\n"); | |
449 | dev->capabilities &= ~PNP_WRITE; | |
450 | } | |
0af5853b LB |
451 | } |
452 | break; | |
453 | ||
454 | case ACPI_RESOURCE_TYPE_GENERIC_REGISTER: | |
1da177e4 | 455 | break; |
0af5853b | 456 | |
1da177e4 | 457 | default: |
af11cb2d BH |
458 | dev_warn(&dev->dev, "unknown resource type %d in _CRS\n", |
459 | res->type); | |
1da177e4 LT |
460 | return AE_ERROR; |
461 | } | |
1c6e7d0a | 462 | |
1da177e4 LT |
463 | return AE_OK; |
464 | } | |
465 | ||
d152cf5d | 466 | int pnpacpi_parse_allocated_resource(struct pnp_dev *dev) |
1da177e4 | 467 | { |
c4da6940 BH |
468 | struct acpi_device *acpi_dev = dev->data; |
469 | acpi_handle handle = acpi_dev->handle; | |
d152cf5d | 470 | acpi_status status; |
4ab55d8d | 471 | |
2f53432c | 472 | pnp_dbg(&dev->dev, "parse allocated resources\n"); |
72dcc883 | 473 | |
f4490002 | 474 | pnp_init_resources(dev); |
1da177e4 | 475 | |
d152cf5d BH |
476 | status = acpi_walk_resources(handle, METHOD_NAME__CRS, |
477 | pnpacpi_allocated_resource, dev); | |
478 | ||
479 | if (ACPI_FAILURE(status)) { | |
480 | if (status != AE_NOT_FOUND) | |
481 | dev_err(&dev->dev, "can't evaluate _CRS: %d", status); | |
482 | return -EPERM; | |
483 | } | |
484 | return 0; | |
1da177e4 LT |
485 | } |
486 | ||
c1caf06c | 487 | static __init void pnpacpi_parse_dma_option(struct pnp_dev *dev, |
1f32ca31 | 488 | unsigned int option_flags, |
2bb9a6b3 | 489 | struct acpi_resource_dma *p) |
1da177e4 LT |
490 | { |
491 | int i; | |
c227536b | 492 | unsigned char map = 0, flags; |
1da177e4 | 493 | |
50eca3eb | 494 | if (p->channel_count == 0) |
1da177e4 | 495 | return; |
1da177e4 | 496 | |
9dd78466 | 497 | for (i = 0; i < p->channel_count; i++) |
c227536b | 498 | map |= 1 << p->channels[i]; |
1da177e4 | 499 | |
958a1fdd | 500 | flags = dma_flags(dev, p->type, p->bus_master, p->transfer); |
1f32ca31 | 501 | pnp_register_dma_resource(dev, option_flags, map, flags); |
1da177e4 LT |
502 | } |
503 | ||
c1caf06c | 504 | static __init void pnpacpi_parse_irq_option(struct pnp_dev *dev, |
1f32ca31 | 505 | unsigned int option_flags, |
2bb9a6b3 | 506 | struct acpi_resource_irq *p) |
1da177e4 LT |
507 | { |
508 | int i; | |
c227536b BH |
509 | pnp_irq_mask_t map; |
510 | unsigned char flags; | |
1c6e7d0a | 511 | |
50eca3eb | 512 | if (p->interrupt_count == 0) |
1da177e4 | 513 | return; |
1da177e4 | 514 | |
c227536b | 515 | bitmap_zero(map.bits, PNP_IRQ_NR); |
9dd78466 | 516 | for (i = 0; i < p->interrupt_count; i++) |
1da177e4 | 517 | if (p->interrupts[i]) |
c227536b | 518 | __set_bit(p->interrupts[i], map.bits); |
1da177e4 | 519 | |
c227536b | 520 | flags = irq_flags(p->triggering, p->polarity, p->sharable); |
1f32ca31 | 521 | pnp_register_irq_resource(dev, option_flags, &map, flags); |
1da177e4 LT |
522 | } |
523 | ||
c1caf06c | 524 | static __init void pnpacpi_parse_ext_irq_option(struct pnp_dev *dev, |
1f32ca31 | 525 | unsigned int option_flags, |
2bb9a6b3 | 526 | struct acpi_resource_extended_irq *p) |
1da177e4 LT |
527 | { |
528 | int i; | |
c227536b BH |
529 | pnp_irq_mask_t map; |
530 | unsigned char flags; | |
1da177e4 | 531 | |
50eca3eb | 532 | if (p->interrupt_count == 0) |
1da177e4 | 533 | return; |
1da177e4 | 534 | |
c227536b | 535 | bitmap_zero(map.bits, PNP_IRQ_NR); |
fe2cf598 BH |
536 | for (i = 0; i < p->interrupt_count; i++) { |
537 | if (p->interrupts[i]) { | |
538 | if (p->interrupts[i] < PNP_IRQ_NR) | |
539 | __set_bit(p->interrupts[i], map.bits); | |
540 | else | |
541 | dev_err(&dev->dev, "ignoring IRQ %d option " | |
542 | "(too large for %d entry bitmap)\n", | |
543 | p->interrupts[i], PNP_IRQ_NR); | |
544 | } | |
545 | } | |
1da177e4 | 546 | |
c227536b | 547 | flags = irq_flags(p->triggering, p->polarity, p->sharable); |
1f32ca31 | 548 | pnp_register_irq_resource(dev, option_flags, &map, flags); |
1da177e4 LT |
549 | } |
550 | ||
c1caf06c | 551 | static __init void pnpacpi_parse_port_option(struct pnp_dev *dev, |
1f32ca31 | 552 | unsigned int option_flags, |
2bb9a6b3 | 553 | struct acpi_resource_io *io) |
1da177e4 | 554 | { |
c227536b | 555 | unsigned char flags = 0; |
1da177e4 | 556 | |
50eca3eb | 557 | if (io->address_length == 0) |
1da177e4 | 558 | return; |
c227536b BH |
559 | |
560 | if (io->io_decode == ACPI_DECODE_16) | |
561 | flags = IORESOURCE_IO_16BIT_ADDR; | |
1f32ca31 | 562 | pnp_register_port_resource(dev, option_flags, io->minimum, io->maximum, |
c227536b | 563 | io->alignment, io->address_length, flags); |
1da177e4 LT |
564 | } |
565 | ||
c1caf06c | 566 | static __init void pnpacpi_parse_fixed_port_option(struct pnp_dev *dev, |
1f32ca31 | 567 | unsigned int option_flags, |
2bb9a6b3 | 568 | struct acpi_resource_fixed_io *io) |
1da177e4 | 569 | { |
50eca3eb | 570 | if (io->address_length == 0) |
1da177e4 | 571 | return; |
c227536b | 572 | |
1f32ca31 BH |
573 | pnp_register_port_resource(dev, option_flags, io->address, io->address, |
574 | 0, io->address_length, IORESOURCE_IO_FIXED); | |
1da177e4 LT |
575 | } |
576 | ||
c1caf06c | 577 | static __init void pnpacpi_parse_mem24_option(struct pnp_dev *dev, |
1f32ca31 | 578 | unsigned int option_flags, |
2bb9a6b3 | 579 | struct acpi_resource_memory24 *p) |
1da177e4 | 580 | { |
c227536b | 581 | unsigned char flags = 0; |
1da177e4 | 582 | |
50eca3eb | 583 | if (p->address_length == 0) |
1da177e4 | 584 | return; |
1da177e4 | 585 | |
c227536b BH |
586 | if (p->write_protect == ACPI_READ_WRITE_MEMORY) |
587 | flags = IORESOURCE_MEM_WRITEABLE; | |
1f32ca31 | 588 | pnp_register_mem_resource(dev, option_flags, p->minimum, p->maximum, |
c227536b | 589 | p->alignment, p->address_length, flags); |
1da177e4 LT |
590 | } |
591 | ||
c1caf06c | 592 | static __init void pnpacpi_parse_mem32_option(struct pnp_dev *dev, |
1f32ca31 | 593 | unsigned int option_flags, |
2bb9a6b3 | 594 | struct acpi_resource_memory32 *p) |
1da177e4 | 595 | { |
c227536b | 596 | unsigned char flags = 0; |
1da177e4 | 597 | |
50eca3eb | 598 | if (p->address_length == 0) |
1da177e4 | 599 | return; |
1da177e4 | 600 | |
c227536b BH |
601 | if (p->write_protect == ACPI_READ_WRITE_MEMORY) |
602 | flags = IORESOURCE_MEM_WRITEABLE; | |
1f32ca31 | 603 | pnp_register_mem_resource(dev, option_flags, p->minimum, p->maximum, |
c227536b | 604 | p->alignment, p->address_length, flags); |
1da177e4 LT |
605 | } |
606 | ||
c1caf06c | 607 | static __init void pnpacpi_parse_fixed_mem32_option(struct pnp_dev *dev, |
1f32ca31 | 608 | unsigned int option_flags, |
2bb9a6b3 | 609 | struct acpi_resource_fixed_memory32 *p) |
1da177e4 | 610 | { |
c227536b | 611 | unsigned char flags = 0; |
1da177e4 | 612 | |
50eca3eb | 613 | if (p->address_length == 0) |
1da177e4 | 614 | return; |
1da177e4 | 615 | |
c227536b BH |
616 | if (p->write_protect == ACPI_READ_WRITE_MEMORY) |
617 | flags = IORESOURCE_MEM_WRITEABLE; | |
1f32ca31 | 618 | pnp_register_mem_resource(dev, option_flags, p->address, p->address, |
c227536b | 619 | 0, p->address_length, flags); |
1da177e4 LT |
620 | } |
621 | ||
c1caf06c | 622 | static __init void pnpacpi_parse_address_option(struct pnp_dev *dev, |
1f32ca31 | 623 | unsigned int option_flags, |
2bb9a6b3 | 624 | struct acpi_resource *r) |
6f957eaf BH |
625 | { |
626 | struct acpi_resource_address64 addr, *p = &addr; | |
627 | acpi_status status; | |
c227536b | 628 | unsigned char flags = 0; |
6f957eaf BH |
629 | |
630 | status = acpi_resource_to_address64(r, p); | |
958a1fdd BH |
631 | if (ACPI_FAILURE(status)) { |
632 | dev_warn(&dev->dev, "can't convert resource type %d\n", | |
9dd78466 | 633 | r->type); |
6f957eaf BH |
634 | return; |
635 | } | |
636 | ||
637 | if (p->address_length == 0) | |
638 | return; | |
639 | ||
640 | if (p->resource_type == ACPI_MEMORY_RANGE) { | |
c227536b BH |
641 | if (p->info.mem.write_protect == ACPI_READ_WRITE_MEMORY) |
642 | flags = IORESOURCE_MEM_WRITEABLE; | |
1f32ca31 BH |
643 | pnp_register_mem_resource(dev, option_flags, p->minimum, |
644 | p->minimum, 0, p->address_length, | |
645 | flags); | |
c227536b | 646 | } else if (p->resource_type == ACPI_IO_RANGE) |
1f32ca31 BH |
647 | pnp_register_port_resource(dev, option_flags, p->minimum, |
648 | p->minimum, 0, p->address_length, | |
c227536b | 649 | IORESOURCE_IO_FIXED); |
6f957eaf BH |
650 | } |
651 | ||
8cb24c8f BH |
652 | static __init void pnpacpi_parse_ext_address_option(struct pnp_dev *dev, |
653 | unsigned int option_flags, | |
654 | struct acpi_resource *r) | |
655 | { | |
656 | struct acpi_resource_extended_address64 *p = &r->data.ext_address64; | |
657 | unsigned char flags = 0; | |
658 | ||
659 | if (p->address_length == 0) | |
660 | return; | |
661 | ||
662 | if (p->resource_type == ACPI_MEMORY_RANGE) { | |
663 | if (p->info.mem.write_protect == ACPI_READ_WRITE_MEMORY) | |
664 | flags = IORESOURCE_MEM_WRITEABLE; | |
665 | pnp_register_mem_resource(dev, option_flags, p->minimum, | |
666 | p->minimum, 0, p->address_length, | |
667 | flags); | |
668 | } else if (p->resource_type == ACPI_IO_RANGE) | |
669 | pnp_register_port_resource(dev, option_flags, p->minimum, | |
670 | p->minimum, 0, p->address_length, | |
671 | IORESOURCE_IO_FIXED); | |
672 | } | |
673 | ||
1da177e4 | 674 | struct acpipnp_parse_option_s { |
1da177e4 | 675 | struct pnp_dev *dev; |
1f32ca31 | 676 | unsigned int option_flags; |
1da177e4 LT |
677 | }; |
678 | ||
2bb9a6b3 TR |
679 | static __init acpi_status pnpacpi_option_resource(struct acpi_resource *res, |
680 | void *data) | |
1da177e4 | 681 | { |
e2a1a6f1 | 682 | int priority; |
4721a4cc | 683 | struct acpipnp_parse_option_s *parse_data = data; |
1da177e4 | 684 | struct pnp_dev *dev = parse_data->dev; |
1f32ca31 | 685 | unsigned int option_flags = parse_data->option_flags; |
1da177e4 | 686 | |
eca008c8 | 687 | switch (res->type) { |
9dd78466 | 688 | case ACPI_RESOURCE_TYPE_IRQ: |
1f32ca31 | 689 | pnpacpi_parse_irq_option(dev, option_flags, &res->data.irq); |
9dd78466 | 690 | break; |
0af5853b | 691 | |
9dd78466 | 692 | case ACPI_RESOURCE_TYPE_DMA: |
1f32ca31 | 693 | pnpacpi_parse_dma_option(dev, option_flags, &res->data.dma); |
9dd78466 | 694 | break; |
0af5853b | 695 | |
9dd78466 BH |
696 | case ACPI_RESOURCE_TYPE_START_DEPENDENT: |
697 | switch (res->data.start_dpf.compatibility_priority) { | |
698 | case ACPI_GOOD_CONFIGURATION: | |
699 | priority = PNP_RES_PRIORITY_PREFERRED; | |
1da177e4 | 700 | break; |
0af5853b | 701 | |
9dd78466 BH |
702 | case ACPI_ACCEPTABLE_CONFIGURATION: |
703 | priority = PNP_RES_PRIORITY_ACCEPTABLE; | |
b008b8d7 | 704 | break; |
0af5853b | 705 | |
9dd78466 BH |
706 | case ACPI_SUB_OPTIMAL_CONFIGURATION: |
707 | priority = PNP_RES_PRIORITY_FUNCTIONAL; | |
0af5853b | 708 | break; |
9dd78466 BH |
709 | default: |
710 | priority = PNP_RES_PRIORITY_INVALID; | |
0af5853b | 711 | break; |
9dd78466 | 712 | } |
1f32ca31 | 713 | parse_data->option_flags = pnp_new_dependent_set(dev, priority); |
9dd78466 | 714 | break; |
0af5853b | 715 | |
9dd78466 | 716 | case ACPI_RESOURCE_TYPE_END_DEPENDENT: |
1f32ca31 | 717 | parse_data->option_flags = 0; |
9dd78466 | 718 | break; |
0af5853b | 719 | |
9dd78466 | 720 | case ACPI_RESOURCE_TYPE_IO: |
1f32ca31 | 721 | pnpacpi_parse_port_option(dev, option_flags, &res->data.io); |
9dd78466 | 722 | break; |
0af5853b | 723 | |
9dd78466 | 724 | case ACPI_RESOURCE_TYPE_FIXED_IO: |
1f32ca31 | 725 | pnpacpi_parse_fixed_port_option(dev, option_flags, |
c1caf06c | 726 | &res->data.fixed_io); |
9dd78466 | 727 | break; |
0af5853b | 728 | |
9dd78466 BH |
729 | case ACPI_RESOURCE_TYPE_VENDOR: |
730 | case ACPI_RESOURCE_TYPE_END_TAG: | |
731 | break; | |
0af5853b | 732 | |
9dd78466 | 733 | case ACPI_RESOURCE_TYPE_MEMORY24: |
1f32ca31 BH |
734 | pnpacpi_parse_mem24_option(dev, option_flags, |
735 | &res->data.memory24); | |
9dd78466 | 736 | break; |
0af5853b | 737 | |
9dd78466 | 738 | case ACPI_RESOURCE_TYPE_MEMORY32: |
1f32ca31 BH |
739 | pnpacpi_parse_mem32_option(dev, option_flags, |
740 | &res->data.memory32); | |
9dd78466 | 741 | break; |
0af5853b | 742 | |
9dd78466 | 743 | case ACPI_RESOURCE_TYPE_FIXED_MEMORY32: |
1f32ca31 | 744 | pnpacpi_parse_fixed_mem32_option(dev, option_flags, |
9dd78466 BH |
745 | &res->data.fixed_memory32); |
746 | break; | |
0af5853b | 747 | |
9dd78466 BH |
748 | case ACPI_RESOURCE_TYPE_ADDRESS16: |
749 | case ACPI_RESOURCE_TYPE_ADDRESS32: | |
750 | case ACPI_RESOURCE_TYPE_ADDRESS64: | |
1f32ca31 | 751 | pnpacpi_parse_address_option(dev, option_flags, res); |
9dd78466 | 752 | break; |
0af5853b | 753 | |
9dd78466 | 754 | case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64: |
8cb24c8f | 755 | pnpacpi_parse_ext_address_option(dev, option_flags, res); |
9dd78466 BH |
756 | break; |
757 | ||
758 | case ACPI_RESOURCE_TYPE_EXTENDED_IRQ: | |
1f32ca31 | 759 | pnpacpi_parse_ext_irq_option(dev, option_flags, |
c1caf06c | 760 | &res->data.extended_irq); |
9dd78466 BH |
761 | break; |
762 | ||
763 | case ACPI_RESOURCE_TYPE_GENERIC_REGISTER: | |
764 | break; | |
765 | ||
766 | default: | |
af11cb2d BH |
767 | dev_warn(&dev->dev, "unknown resource type %d in _PRS\n", |
768 | res->type); | |
9dd78466 | 769 | return AE_ERROR; |
1da177e4 | 770 | } |
1c6e7d0a | 771 | |
1da177e4 LT |
772 | return AE_OK; |
773 | } | |
774 | ||
d152cf5d | 775 | int __init pnpacpi_parse_resource_option_data(struct pnp_dev *dev) |
1da177e4 | 776 | { |
c4da6940 BH |
777 | struct acpi_device *acpi_dev = dev->data; |
778 | acpi_handle handle = acpi_dev->handle; | |
1da177e4 LT |
779 | acpi_status status; |
780 | struct acpipnp_parse_option_s parse_data; | |
781 | ||
2f53432c | 782 | pnp_dbg(&dev->dev, "parse resource options\n"); |
72dcc883 | 783 | |
1da177e4 | 784 | parse_data.dev = dev; |
1f32ca31 BH |
785 | parse_data.option_flags = 0; |
786 | ||
50eca3eb | 787 | status = acpi_walk_resources(handle, METHOD_NAME__PRS, |
9dd78466 | 788 | pnpacpi_option_resource, &parse_data); |
1da177e4 | 789 | |
d152cf5d BH |
790 | if (ACPI_FAILURE(status)) { |
791 | if (status != AE_NOT_FOUND) | |
792 | dev_err(&dev->dev, "can't evaluate _PRS: %d", status); | |
793 | return -EPERM; | |
794 | } | |
795 | return 0; | |
1da177e4 LT |
796 | } |
797 | ||
b5f2490b | 798 | static int pnpacpi_supported_resource(struct acpi_resource *res) |
1da177e4 | 799 | { |
eca008c8 | 800 | switch (res->type) { |
50eca3eb | 801 | case ACPI_RESOURCE_TYPE_IRQ: |
50eca3eb BM |
802 | case ACPI_RESOURCE_TYPE_DMA: |
803 | case ACPI_RESOURCE_TYPE_IO: | |
804 | case ACPI_RESOURCE_TYPE_FIXED_IO: | |
805 | case ACPI_RESOURCE_TYPE_MEMORY24: | |
806 | case ACPI_RESOURCE_TYPE_MEMORY32: | |
807 | case ACPI_RESOURCE_TYPE_FIXED_MEMORY32: | |
50eca3eb BM |
808 | case ACPI_RESOURCE_TYPE_ADDRESS16: |
809 | case ACPI_RESOURCE_TYPE_ADDRESS32: | |
810 | case ACPI_RESOURCE_TYPE_ADDRESS64: | |
8cb24c8f | 811 | case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64: |
0af5853b | 812 | case ACPI_RESOURCE_TYPE_EXTENDED_IRQ: |
b5f2490b | 813 | return 1; |
1da177e4 | 814 | } |
b5f2490b BH |
815 | return 0; |
816 | } | |
817 | ||
818 | /* | |
819 | * Set resource | |
820 | */ | |
821 | static acpi_status pnpacpi_count_resources(struct acpi_resource *res, | |
9dd78466 | 822 | void *data) |
b5f2490b | 823 | { |
4721a4cc | 824 | int *res_cnt = data; |
b5f2490b BH |
825 | |
826 | if (pnpacpi_supported_resource(res)) | |
827 | (*res_cnt)++; | |
1da177e4 LT |
828 | return AE_OK; |
829 | } | |
830 | ||
1c6e7d0a | 831 | static acpi_status pnpacpi_type_resources(struct acpi_resource *res, void *data) |
1da177e4 | 832 | { |
4721a4cc | 833 | struct acpi_resource **resource = data; |
b5f2490b BH |
834 | |
835 | if (pnpacpi_supported_resource(res)) { | |
eca008c8 | 836 | (*resource)->type = res->type; |
b5f2490b | 837 | (*resource)->length = sizeof(struct acpi_resource); |
36d872a3 BH |
838 | if (res->type == ACPI_RESOURCE_TYPE_IRQ) |
839 | (*resource)->data.irq.descriptor_length = | |
840 | res->data.irq.descriptor_length; | |
1da177e4 | 841 | (*resource)++; |
1da177e4 LT |
842 | } |
843 | ||
844 | return AE_OK; | |
845 | } | |
846 | ||
cdef6254 | 847 | int pnpacpi_build_resource_template(struct pnp_dev *dev, |
9dd78466 | 848 | struct acpi_buffer *buffer) |
1da177e4 | 849 | { |
c4da6940 BH |
850 | struct acpi_device *acpi_dev = dev->data; |
851 | acpi_handle handle = acpi_dev->handle; | |
1da177e4 LT |
852 | struct acpi_resource *resource; |
853 | int res_cnt = 0; | |
854 | acpi_status status; | |
855 | ||
50eca3eb | 856 | status = acpi_walk_resources(handle, METHOD_NAME__CRS, |
9dd78466 | 857 | pnpacpi_count_resources, &res_cnt); |
1da177e4 | 858 | if (ACPI_FAILURE(status)) { |
d152cf5d | 859 | dev_err(&dev->dev, "can't evaluate _CRS: %d\n", status); |
1da177e4 LT |
860 | return -EINVAL; |
861 | } | |
862 | if (!res_cnt) | |
863 | return -EINVAL; | |
864 | buffer->length = sizeof(struct acpi_resource) * (res_cnt + 1) + 1; | |
cd861280 | 865 | buffer->pointer = kzalloc(buffer->length - 1, GFP_KERNEL); |
1da177e4 LT |
866 | if (!buffer->pointer) |
867 | return -ENOMEM; | |
72dcc883 | 868 | |
1da177e4 | 869 | resource = (struct acpi_resource *)buffer->pointer; |
50eca3eb | 870 | status = acpi_walk_resources(handle, METHOD_NAME__CRS, |
9dd78466 | 871 | pnpacpi_type_resources, &resource); |
1da177e4 LT |
872 | if (ACPI_FAILURE(status)) { |
873 | kfree(buffer->pointer); | |
d152cf5d | 874 | dev_err(&dev->dev, "can't evaluate _CRS: %d\n", status); |
1da177e4 LT |
875 | return -EINVAL; |
876 | } | |
877 | /* resource will pointer the end resource now */ | |
50eca3eb | 878 | resource->type = ACPI_RESOURCE_TYPE_END_TAG; |
1da177e4 LT |
879 | |
880 | return 0; | |
881 | } | |
882 | ||
72dcc883 BH |
883 | static void pnpacpi_encode_irq(struct pnp_dev *dev, |
884 | struct acpi_resource *resource, | |
9dd78466 | 885 | struct resource *p) |
1da177e4 | 886 | { |
9570a20e | 887 | struct acpi_resource_irq *irq = &resource->data.irq; |
a993273b | 888 | int triggering, polarity, shareable; |
1c6e7d0a | 889 | |
aee3ad81 BH |
890 | if (!pnp_resource_enabled(p)) { |
891 | irq->interrupt_count = 0; | |
2f53432c | 892 | pnp_dbg(&dev->dev, " encode irq (%s)\n", |
aee3ad81 BH |
893 | p ? "disabled" : "missing"); |
894 | return; | |
895 | } | |
896 | ||
a993273b | 897 | decode_irq_flags(dev, p->flags, &triggering, &polarity, &shareable); |
9570a20e BH |
898 | irq->triggering = triggering; |
899 | irq->polarity = polarity; | |
a993273b | 900 | irq->sharable = shareable; |
9570a20e BH |
901 | irq->interrupt_count = 1; |
902 | irq->interrupts[0] = p->start; | |
72dcc883 | 903 | |
2f53432c | 904 | pnp_dbg(&dev->dev, " encode irq %d %s %s %s (%d-byte descriptor)\n", |
36d872a3 | 905 | (int) p->start, |
72dcc883 BH |
906 | triggering == ACPI_LEVEL_SENSITIVE ? "level" : "edge", |
907 | polarity == ACPI_ACTIVE_LOW ? "low" : "high", | |
36d872a3 BH |
908 | irq->sharable == ACPI_SHARED ? "shared" : "exclusive", |
909 | irq->descriptor_length); | |
1da177e4 LT |
910 | } |
911 | ||
72dcc883 BH |
912 | static void pnpacpi_encode_ext_irq(struct pnp_dev *dev, |
913 | struct acpi_resource *resource, | |
9dd78466 | 914 | struct resource *p) |
1da177e4 | 915 | { |
9570a20e | 916 | struct acpi_resource_extended_irq *extended_irq = &resource->data.extended_irq; |
a993273b | 917 | int triggering, polarity, shareable; |
1c6e7d0a | 918 | |
aee3ad81 BH |
919 | if (!pnp_resource_enabled(p)) { |
920 | extended_irq->interrupt_count = 0; | |
2f53432c | 921 | pnp_dbg(&dev->dev, " encode extended irq (%s)\n", |
aee3ad81 BH |
922 | p ? "disabled" : "missing"); |
923 | return; | |
924 | } | |
925 | ||
a993273b | 926 | decode_irq_flags(dev, p->flags, &triggering, &polarity, &shareable); |
9570a20e BH |
927 | extended_irq->producer_consumer = ACPI_CONSUMER; |
928 | extended_irq->triggering = triggering; | |
929 | extended_irq->polarity = polarity; | |
a993273b | 930 | extended_irq->sharable = shareable; |
9570a20e BH |
931 | extended_irq->interrupt_count = 1; |
932 | extended_irq->interrupts[0] = p->start; | |
72dcc883 | 933 | |
2f53432c | 934 | pnp_dbg(&dev->dev, " encode irq %d %s %s %s\n", (int) p->start, |
72dcc883 BH |
935 | triggering == ACPI_LEVEL_SENSITIVE ? "level" : "edge", |
936 | polarity == ACPI_ACTIVE_LOW ? "low" : "high", | |
937 | extended_irq->sharable == ACPI_SHARED ? "shared" : "exclusive"); | |
1da177e4 LT |
938 | } |
939 | ||
72dcc883 BH |
940 | static void pnpacpi_encode_dma(struct pnp_dev *dev, |
941 | struct acpi_resource *resource, | |
9dd78466 | 942 | struct resource *p) |
1da177e4 | 943 | { |
9570a20e BH |
944 | struct acpi_resource_dma *dma = &resource->data.dma; |
945 | ||
aee3ad81 BH |
946 | if (!pnp_resource_enabled(p)) { |
947 | dma->channel_count = 0; | |
2f53432c | 948 | pnp_dbg(&dev->dev, " encode dma (%s)\n", |
aee3ad81 BH |
949 | p ? "disabled" : "missing"); |
950 | return; | |
951 | } | |
952 | ||
1da177e4 | 953 | /* Note: pnp_assign_dma will copy pnp_dma->flags into p->flags */ |
ccc4c7bb | 954 | switch (p->flags & IORESOURCE_DMA_SPEED_MASK) { |
9dd78466 | 955 | case IORESOURCE_DMA_TYPEA: |
9570a20e | 956 | dma->type = ACPI_TYPE_A; |
9dd78466 BH |
957 | break; |
958 | case IORESOURCE_DMA_TYPEB: | |
9570a20e | 959 | dma->type = ACPI_TYPE_B; |
9dd78466 BH |
960 | break; |
961 | case IORESOURCE_DMA_TYPEF: | |
9570a20e | 962 | dma->type = ACPI_TYPE_F; |
9dd78466 BH |
963 | break; |
964 | default: | |
9570a20e | 965 | dma->type = ACPI_COMPATIBILITY; |
ccc4c7bb VP |
966 | } |
967 | ||
968 | switch (p->flags & IORESOURCE_DMA_TYPE_MASK) { | |
9dd78466 | 969 | case IORESOURCE_DMA_8BIT: |
9570a20e | 970 | dma->transfer = ACPI_TRANSFER_8; |
9dd78466 BH |
971 | break; |
972 | case IORESOURCE_DMA_8AND16BIT: | |
9570a20e | 973 | dma->transfer = ACPI_TRANSFER_8_16; |
9dd78466 BH |
974 | break; |
975 | default: | |
9570a20e | 976 | dma->transfer = ACPI_TRANSFER_16; |
ccc4c7bb VP |
977 | } |
978 | ||
9570a20e BH |
979 | dma->bus_master = !!(p->flags & IORESOURCE_DMA_MASTER); |
980 | dma->channel_count = 1; | |
981 | dma->channels[0] = p->start; | |
72dcc883 | 982 | |
2f53432c | 983 | pnp_dbg(&dev->dev, " encode dma %d " |
72dcc883 BH |
984 | "type %#x transfer %#x master %d\n", |
985 | (int) p->start, dma->type, dma->transfer, dma->bus_master); | |
1da177e4 LT |
986 | } |
987 | ||
72dcc883 BH |
988 | static void pnpacpi_encode_io(struct pnp_dev *dev, |
989 | struct acpi_resource *resource, | |
9dd78466 | 990 | struct resource *p) |
1da177e4 | 991 | { |
9570a20e BH |
992 | struct acpi_resource_io *io = &resource->data.io; |
993 | ||
aee3ad81 BH |
994 | if (pnp_resource_enabled(p)) { |
995 | /* Note: pnp_assign_port copies pnp_port->flags into p->flags */ | |
08c9f262 | 996 | io->io_decode = (p->flags & IORESOURCE_IO_16BIT_ADDR) ? |
aee3ad81 BH |
997 | ACPI_DECODE_16 : ACPI_DECODE_10; |
998 | io->minimum = p->start; | |
999 | io->maximum = p->end; | |
1000 | io->alignment = 0; /* Correct? */ | |
1001 | io->address_length = p->end - p->start + 1; | |
1002 | } else { | |
1003 | io->minimum = 0; | |
1004 | io->address_length = 0; | |
1005 | } | |
72dcc883 | 1006 | |
2f53432c | 1007 | pnp_dbg(&dev->dev, " encode io %#x-%#x decode %#x\n", io->minimum, |
aee3ad81 | 1008 | io->minimum + io->address_length - 1, io->io_decode); |
1da177e4 LT |
1009 | } |
1010 | ||
72dcc883 BH |
1011 | static void pnpacpi_encode_fixed_io(struct pnp_dev *dev, |
1012 | struct acpi_resource *resource, | |
9dd78466 | 1013 | struct resource *p) |
1da177e4 | 1014 | { |
9570a20e BH |
1015 | struct acpi_resource_fixed_io *fixed_io = &resource->data.fixed_io; |
1016 | ||
aee3ad81 BH |
1017 | if (pnp_resource_enabled(p)) { |
1018 | fixed_io->address = p->start; | |
1019 | fixed_io->address_length = p->end - p->start + 1; | |
1020 | } else { | |
1021 | fixed_io->address = 0; | |
1022 | fixed_io->address_length = 0; | |
1023 | } | |
72dcc883 | 1024 | |
2f53432c | 1025 | pnp_dbg(&dev->dev, " encode fixed_io %#x-%#x\n", fixed_io->address, |
aee3ad81 | 1026 | fixed_io->address + fixed_io->address_length - 1); |
1da177e4 LT |
1027 | } |
1028 | ||
72dcc883 BH |
1029 | static void pnpacpi_encode_mem24(struct pnp_dev *dev, |
1030 | struct acpi_resource *resource, | |
9dd78466 | 1031 | struct resource *p) |
1da177e4 | 1032 | { |
9570a20e BH |
1033 | struct acpi_resource_memory24 *memory24 = &resource->data.memory24; |
1034 | ||
aee3ad81 BH |
1035 | if (pnp_resource_enabled(p)) { |
1036 | /* Note: pnp_assign_mem copies pnp_mem->flags into p->flags */ | |
1037 | memory24->write_protect = p->flags & IORESOURCE_MEM_WRITEABLE ? | |
1038 | ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY; | |
1039 | memory24->minimum = p->start; | |
1040 | memory24->maximum = p->end; | |
1041 | memory24->alignment = 0; | |
1042 | memory24->address_length = p->end - p->start + 1; | |
1043 | } else { | |
1044 | memory24->minimum = 0; | |
1045 | memory24->address_length = 0; | |
1046 | } | |
1047 | ||
2f53432c | 1048 | pnp_dbg(&dev->dev, " encode mem24 %#x-%#x write_protect %#x\n", |
aee3ad81 BH |
1049 | memory24->minimum, |
1050 | memory24->minimum + memory24->address_length - 1, | |
72dcc883 | 1051 | memory24->write_protect); |
1da177e4 LT |
1052 | } |
1053 | ||
72dcc883 BH |
1054 | static void pnpacpi_encode_mem32(struct pnp_dev *dev, |
1055 | struct acpi_resource *resource, | |
9dd78466 | 1056 | struct resource *p) |
1da177e4 | 1057 | { |
9570a20e BH |
1058 | struct acpi_resource_memory32 *memory32 = &resource->data.memory32; |
1059 | ||
aee3ad81 BH |
1060 | if (pnp_resource_enabled(p)) { |
1061 | memory32->write_protect = p->flags & IORESOURCE_MEM_WRITEABLE ? | |
1062 | ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY; | |
1063 | memory32->minimum = p->start; | |
1064 | memory32->maximum = p->end; | |
1065 | memory32->alignment = 0; | |
1066 | memory32->address_length = p->end - p->start + 1; | |
1067 | } else { | |
1068 | memory32->minimum = 0; | |
1069 | memory32->alignment = 0; | |
1070 | } | |
72dcc883 | 1071 | |
2f53432c | 1072 | pnp_dbg(&dev->dev, " encode mem32 %#x-%#x write_protect %#x\n", |
aee3ad81 BH |
1073 | memory32->minimum, |
1074 | memory32->minimum + memory32->address_length - 1, | |
72dcc883 | 1075 | memory32->write_protect); |
1da177e4 LT |
1076 | } |
1077 | ||
72dcc883 BH |
1078 | static void pnpacpi_encode_fixed_mem32(struct pnp_dev *dev, |
1079 | struct acpi_resource *resource, | |
9dd78466 | 1080 | struct resource *p) |
1da177e4 | 1081 | { |
9570a20e BH |
1082 | struct acpi_resource_fixed_memory32 *fixed_memory32 = &resource->data.fixed_memory32; |
1083 | ||
aee3ad81 BH |
1084 | if (pnp_resource_enabled(p)) { |
1085 | fixed_memory32->write_protect = | |
1086 | p->flags & IORESOURCE_MEM_WRITEABLE ? | |
1087 | ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY; | |
1088 | fixed_memory32->address = p->start; | |
1089 | fixed_memory32->address_length = p->end - p->start + 1; | |
1090 | } else { | |
1091 | fixed_memory32->address = 0; | |
1092 | fixed_memory32->address_length = 0; | |
1093 | } | |
72dcc883 | 1094 | |
2f53432c | 1095 | pnp_dbg(&dev->dev, " encode fixed_mem32 %#x-%#x write_protect %#x\n", |
aee3ad81 BH |
1096 | fixed_memory32->address, |
1097 | fixed_memory32->address + fixed_memory32->address_length - 1, | |
72dcc883 | 1098 | fixed_memory32->write_protect); |
1da177e4 LT |
1099 | } |
1100 | ||
4ab55d8d | 1101 | int pnpacpi_encode_resources(struct pnp_dev *dev, struct acpi_buffer *buffer) |
1da177e4 LT |
1102 | { |
1103 | int i = 0; | |
1104 | /* pnpacpi_build_resource_template allocates extra mem */ | |
9dd78466 | 1105 | int res_cnt = (buffer->length - 1) / sizeof(struct acpi_resource) - 1; |
4721a4cc | 1106 | struct acpi_resource *resource = buffer->pointer; |
1da177e4 LT |
1107 | int port = 0, irq = 0, dma = 0, mem = 0; |
1108 | ||
2f53432c | 1109 | pnp_dbg(&dev->dev, "encode %d resources\n", res_cnt); |
1da177e4 | 1110 | while (i < res_cnt) { |
9dd78466 | 1111 | switch (resource->type) { |
50eca3eb | 1112 | case ACPI_RESOURCE_TYPE_IRQ: |
72dcc883 | 1113 | pnpacpi_encode_irq(dev, resource, |
7e2cf31f | 1114 | pnp_get_resource(dev, IORESOURCE_IRQ, irq)); |
1da177e4 LT |
1115 | irq++; |
1116 | break; | |
1117 | ||
50eca3eb | 1118 | case ACPI_RESOURCE_TYPE_DMA: |
72dcc883 | 1119 | pnpacpi_encode_dma(dev, resource, |
7e2cf31f | 1120 | pnp_get_resource(dev, IORESOURCE_DMA, dma)); |
1c6e7d0a | 1121 | dma++; |
1da177e4 | 1122 | break; |
50eca3eb | 1123 | case ACPI_RESOURCE_TYPE_IO: |
72dcc883 | 1124 | pnpacpi_encode_io(dev, resource, |
7e2cf31f | 1125 | pnp_get_resource(dev, IORESOURCE_IO, port)); |
1c6e7d0a | 1126 | port++; |
1da177e4 | 1127 | break; |
50eca3eb | 1128 | case ACPI_RESOURCE_TYPE_FIXED_IO: |
72dcc883 | 1129 | pnpacpi_encode_fixed_io(dev, resource, |
7e2cf31f | 1130 | pnp_get_resource(dev, IORESOURCE_IO, port)); |
1c6e7d0a | 1131 | port++; |
1da177e4 | 1132 | break; |
50eca3eb | 1133 | case ACPI_RESOURCE_TYPE_MEMORY24: |
72dcc883 | 1134 | pnpacpi_encode_mem24(dev, resource, |
7e2cf31f | 1135 | pnp_get_resource(dev, IORESOURCE_MEM, mem)); |
1c6e7d0a | 1136 | mem++; |
1da177e4 | 1137 | break; |
50eca3eb | 1138 | case ACPI_RESOURCE_TYPE_MEMORY32: |
72dcc883 | 1139 | pnpacpi_encode_mem32(dev, resource, |
7e2cf31f | 1140 | pnp_get_resource(dev, IORESOURCE_MEM, mem)); |
1c6e7d0a | 1141 | mem++; |
1da177e4 | 1142 | break; |
50eca3eb | 1143 | case ACPI_RESOURCE_TYPE_FIXED_MEMORY32: |
72dcc883 | 1144 | pnpacpi_encode_fixed_mem32(dev, resource, |
7e2cf31f | 1145 | pnp_get_resource(dev, IORESOURCE_MEM, mem)); |
1c6e7d0a | 1146 | mem++; |
1da177e4 | 1147 | break; |
0af5853b | 1148 | case ACPI_RESOURCE_TYPE_EXTENDED_IRQ: |
72dcc883 | 1149 | pnpacpi_encode_ext_irq(dev, resource, |
7e2cf31f | 1150 | pnp_get_resource(dev, IORESOURCE_IRQ, irq)); |
0af5853b LB |
1151 | irq++; |
1152 | break; | |
1153 | case ACPI_RESOURCE_TYPE_START_DEPENDENT: | |
1154 | case ACPI_RESOURCE_TYPE_END_DEPENDENT: | |
1155 | case ACPI_RESOURCE_TYPE_VENDOR: | |
1156 | case ACPI_RESOURCE_TYPE_END_TAG: | |
1157 | case ACPI_RESOURCE_TYPE_ADDRESS16: | |
1158 | case ACPI_RESOURCE_TYPE_ADDRESS32: | |
1159 | case ACPI_RESOURCE_TYPE_ADDRESS64: | |
1160 | case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64: | |
1161 | case ACPI_RESOURCE_TYPE_GENERIC_REGISTER: | |
9dd78466 | 1162 | default: /* other type */ |
af11cb2d BH |
1163 | dev_warn(&dev->dev, "can't encode unknown resource " |
1164 | "type %d\n", resource->type); | |
1da177e4 LT |
1165 | return -EINVAL; |
1166 | } | |
1c6e7d0a BH |
1167 | resource++; |
1168 | i++; | |
1da177e4 LT |
1169 | } |
1170 | return 0; | |
1171 | } |