Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : * pnpacpi -- PnP ACPI driver
4 : : *
5 : : * Copyright (c) 2004 Matthieu Castet <castet.matthieu@free.fr>
6 : : * Copyright (c) 2004 Li Shaohua <shaohua.li@intel.com>
7 : : * Copyright (C) 2008 Hewlett-Packard Development Company, L.P.
8 : : * Bjorn Helgaas <bjorn.helgaas@hp.com>
9 : : */
10 : : #include <linux/kernel.h>
11 : : #include <linux/acpi.h>
12 : : #include <linux/pci.h>
13 : : #include <linux/pnp.h>
14 : : #include <linux/slab.h>
15 : : #include "../base.h"
16 : : #include "pnpacpi.h"
17 : :
18 : 0 : static void decode_irq_flags(struct pnp_dev *dev, int flags, u8 *triggering,
19 : : u8 *polarity, u8 *shareable)
20 : : {
21 [ # # # # : 0 : switch (flags & (IORESOURCE_IRQ_LOWLEVEL | IORESOURCE_IRQ_HIGHLEVEL |
# ]
22 : : IORESOURCE_IRQ_LOWEDGE | IORESOURCE_IRQ_HIGHEDGE)) {
23 : 0 : case IORESOURCE_IRQ_LOWLEVEL:
24 : 0 : *triggering = ACPI_LEVEL_SENSITIVE;
25 : 0 : *polarity = ACPI_ACTIVE_LOW;
26 : 0 : break;
27 : 0 : case IORESOURCE_IRQ_HIGHLEVEL:
28 : 0 : *triggering = ACPI_LEVEL_SENSITIVE;
29 : 0 : *polarity = ACPI_ACTIVE_HIGH;
30 : 0 : break;
31 : 0 : case IORESOURCE_IRQ_LOWEDGE:
32 : 0 : *triggering = ACPI_EDGE_SENSITIVE;
33 : 0 : *polarity = ACPI_ACTIVE_LOW;
34 : 0 : break;
35 : 0 : case IORESOURCE_IRQ_HIGHEDGE:
36 : 0 : *triggering = ACPI_EDGE_SENSITIVE;
37 : 0 : *polarity = ACPI_ACTIVE_HIGH;
38 : 0 : break;
39 : 0 : default:
40 : 0 : dev_err(&dev->dev, "can't encode invalid IRQ mode %#x\n",
41 : : flags);
42 : 0 : *triggering = ACPI_EDGE_SENSITIVE;
43 : 0 : *polarity = ACPI_ACTIVE_HIGH;
44 : 0 : break;
45 : : }
46 : :
47 [ # # ]: 0 : if (flags & IORESOURCE_IRQ_SHAREABLE)
48 : 0 : *shareable = ACPI_SHARED;
49 : : else
50 : 0 : *shareable = ACPI_EXCLUSIVE;
51 : 0 : }
52 : :
53 : 28 : static int dma_flags(struct pnp_dev *dev, int type, int bus_master,
54 : : int transfer)
55 : : {
56 : 28 : int flags = 0;
57 : :
58 [ - + ]: 28 : if (bus_master)
59 : 0 : flags |= IORESOURCE_DMA_MASTER;
60 [ - - - - : 28 : switch (type) {
+ ]
61 : : case ACPI_COMPATIBILITY:
62 : : flags |= IORESOURCE_DMA_COMPATIBLE;
63 : : break;
64 : 0 : case ACPI_TYPE_A:
65 : 0 : flags |= IORESOURCE_DMA_TYPEA;
66 : 0 : break;
67 : 0 : case ACPI_TYPE_B:
68 : 0 : flags |= IORESOURCE_DMA_TYPEB;
69 : 0 : break;
70 : 0 : case ACPI_TYPE_F:
71 : 0 : flags |= IORESOURCE_DMA_TYPEF;
72 : 0 : break;
73 : 0 : default:
74 : : /* Set a default value ? */
75 : 0 : flags |= IORESOURCE_DMA_COMPATIBLE;
76 : 0 : dev_err(&dev->dev, "invalid DMA type %d\n", type);
77 : : }
78 [ - - - + ]: 28 : switch (transfer) {
79 : : case ACPI_TRANSFER_8:
80 : : flags |= IORESOURCE_DMA_8BIT;
81 : : break;
82 : 0 : case ACPI_TRANSFER_8_16:
83 : 0 : flags |= IORESOURCE_DMA_8AND16BIT;
84 : 0 : break;
85 : 0 : case ACPI_TRANSFER_16:
86 : 0 : flags |= IORESOURCE_DMA_16BIT;
87 : 0 : break;
88 : 0 : default:
89 : : /* Set a default value ? */
90 : 0 : flags |= IORESOURCE_DMA_8AND16BIT;
91 : 0 : dev_err(&dev->dev, "invalid DMA transfer type %d\n", transfer);
92 : : }
93 : :
94 : 28 : return flags;
95 : : }
96 : :
97 : : /*
98 : : * Allocated Resources
99 : : */
100 : :
101 : 168 : static void pnpacpi_add_irqresource(struct pnp_dev *dev, struct resource *r)
102 : : {
103 [ + - ]: 168 : if (!(r->flags & IORESOURCE_DISABLED))
104 : 168 : pcibios_penalize_isa_irq(r->start, 1);
105 : :
106 : 168 : pnp_add_resource(dev, r);
107 : 168 : }
108 : :
109 : : /*
110 : : * Device CSRs that do not appear in PCI config space should be described
111 : : * via ACPI. This would normally be done with Address Space Descriptors
112 : : * marked as "consumer-only," but old versions of Windows and Linux ignore
113 : : * the producer/consumer flag, so HP invented a vendor-defined resource to
114 : : * describe the location and size of CSR space.
115 : : */
116 : : static struct acpi_vendor_uuid hp_ccsr_uuid = {
117 : : .subtype = 2,
118 : : .data = { 0xf9, 0xad, 0xe9, 0x69, 0x4f, 0x92, 0x5f, 0xab, 0xf6, 0x4a,
119 : : 0x24, 0xd2, 0x01, 0x37, 0x0e, 0xad },
120 : : };
121 : :
122 : 0 : static int vendor_resource_matches(struct pnp_dev *dev,
123 : : struct acpi_resource_vendor_typed *vendor,
124 : : struct acpi_vendor_uuid *match,
125 : : int expected_len)
126 : : {
127 : 0 : int uuid_len = sizeof(vendor->uuid);
128 : 0 : u8 uuid_subtype = vendor->uuid_subtype;
129 : 0 : u8 *uuid = vendor->uuid;
130 : 0 : int actual_len;
131 : :
132 : : /* byte_length includes uuid_subtype and uuid */
133 : 0 : actual_len = vendor->byte_length - uuid_len - 1;
134 : :
135 [ # # ]: 0 : if (uuid_subtype == match->subtype &&
136 : 0 : uuid_len == sizeof(match->data) &&
137 [ # # ]: 0 : memcmp(uuid, match->data, uuid_len) == 0) {
138 [ # # ]: 0 : if (expected_len && expected_len != actual_len) {
139 : 0 : dev_err(&dev->dev,
140 : : "wrong vendor descriptor size; expected %d, found %d bytes\n",
141 : : expected_len, actual_len);
142 : 0 : return 0;
143 : : }
144 : :
145 : : return 1;
146 : : }
147 : :
148 : : return 0;
149 : : }
150 : :
151 : 0 : static void pnpacpi_parse_allocated_vendor(struct pnp_dev *dev,
152 : : struct acpi_resource_vendor_typed *vendor)
153 : : {
154 [ # # ]: 0 : if (vendor_resource_matches(dev, vendor, &hp_ccsr_uuid, 16)) {
155 : 0 : u64 start, length;
156 : :
157 : 0 : memcpy(&start, vendor->byte_data, sizeof(start));
158 : 0 : memcpy(&length, vendor->byte_data + 8, sizeof(length));
159 : :
160 : 0 : pnp_add_mem_resource(dev, start, start + length - 1, 0);
161 : : }
162 : 0 : }
163 : :
164 : 588 : static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res,
165 : : void *data)
166 : : {
167 : 588 : struct pnp_dev *dev = data;
168 : 588 : struct acpi_resource_dma *dma;
169 : 588 : struct acpi_resource_vendor_typed *vendor_typed;
170 : 588 : struct acpi_resource_gpio *gpio;
171 : 588 : struct resource_win win = {{0}, 0};
172 : 588 : struct resource *r = &win.res;
173 : 588 : int i, flags;
174 : :
175 [ + - ]: 588 : if (acpi_dev_resource_address_space(res, &win)
176 [ - + ]: 588 : || acpi_dev_resource_ext_address_space(res, &win)) {
177 : 0 : pnp_add_resource(dev, &win.res);
178 : 0 : return AE_OK;
179 : : }
180 : :
181 : 588 : r->flags = 0;
182 [ + + ]: 588 : if (acpi_dev_resource_interrupt(res, 0, r)) {
183 : 168 : pnpacpi_add_irqresource(dev, r);
184 [ - + ]: 336 : for (i = 1; acpi_dev_resource_interrupt(res, i, r); i++)
185 : 0 : pnpacpi_add_irqresource(dev, r);
186 : :
187 [ - + ]: 168 : if (i > 1) {
188 : : /*
189 : : * The IRQ encoder puts a single interrupt in each
190 : : * descriptor, so if a _CRS descriptor has more than
191 : : * one interrupt, we won't be able to re-encode it.
192 : : */
193 [ # # # # ]: 0 : if (pnp_can_write(dev)) {
194 : 0 : dev_warn(&dev->dev,
195 : : "multiple interrupts in _CRS descriptor; configuration can't be changed\n");
196 : 0 : dev->capabilities &= ~PNP_WRITE;
197 : : }
198 : : }
199 : 168 : return AE_OK;
200 [ - + ]: 420 : } else if (acpi_gpio_get_irq_resource(res, &gpio)) {
201 : : /*
202 : : * If the resource is GpioInt() type then extract the IRQ
203 : : * from GPIO resource and fill it into IRQ resource type.
204 : : */
205 : : i = acpi_dev_gpio_irq_get(dev->data, 0);
206 : : if (i >= 0) {
207 : : flags = acpi_dev_irq_flags(gpio->triggering,
208 : : gpio->polarity,
209 : : gpio->shareable);
210 : : } else {
211 : : flags = IORESOURCE_DISABLED;
212 : : }
213 : : pnp_add_irq_resource(dev, i, flags);
214 : : return AE_OK;
215 [ - + ]: 420 : } else if (r->flags & IORESOURCE_DISABLED) {
216 : 0 : pnp_add_irq_resource(dev, 0, IORESOURCE_DISABLED);
217 : 0 : return AE_OK;
218 : : }
219 : :
220 [ - + + - : 420 : switch (res->type) {
- + ]
221 : 0 : case ACPI_RESOURCE_TYPE_MEMORY24:
222 : : case ACPI_RESOURCE_TYPE_MEMORY32:
223 : : case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
224 [ # # ]: 0 : if (acpi_dev_resource_memory(res, r))
225 : 0 : pnp_add_resource(dev, r);
226 : : break;
227 : 224 : case ACPI_RESOURCE_TYPE_IO:
228 : : case ACPI_RESOURCE_TYPE_FIXED_IO:
229 [ + - ]: 224 : if (acpi_dev_resource_io(res, r))
230 : 224 : pnp_add_resource(dev, r);
231 : : break;
232 : 28 : case ACPI_RESOURCE_TYPE_DMA:
233 : 28 : dma = &res->data.dma;
234 [ + - + - ]: 28 : if (dma->channel_count > 0 && dma->channels[0] != (u8) -1)
235 : 28 : flags = dma_flags(dev, dma->type, dma->bus_master,
236 : 28 : dma->transfer);
237 : : else
238 : : flags = IORESOURCE_DISABLED;
239 : 28 : pnp_add_dma_resource(dev, dma->channels[0], flags);
240 : 28 : break;
241 : :
242 : : case ACPI_RESOURCE_TYPE_START_DEPENDENT:
243 : : case ACPI_RESOURCE_TYPE_END_DEPENDENT:
244 : : break;
245 : :
246 : 0 : case ACPI_RESOURCE_TYPE_VENDOR:
247 : 0 : vendor_typed = &res->data.vendor_typed;
248 : 0 : pnpacpi_parse_allocated_vendor(dev, vendor_typed);
249 : 0 : break;
250 : :
251 : : case ACPI_RESOURCE_TYPE_END_TAG:
252 : : break;
253 : :
254 : : case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
255 : : break;
256 : :
257 : : case ACPI_RESOURCE_TYPE_SERIAL_BUS:
258 : : /* serial bus connections (I2C/SPI/UART) are not pnp */
259 : : break;
260 : :
261 : 0 : default:
262 : 0 : dev_warn(&dev->dev, "unknown resource type %d in _CRS\n",
263 : : res->type);
264 : 0 : return AE_ERROR;
265 : : }
266 : :
267 : : return AE_OK;
268 : : }
269 : :
270 : 168 : int pnpacpi_parse_allocated_resource(struct pnp_dev *dev)
271 : : {
272 : 168 : struct acpi_device *acpi_dev = dev->data;
273 : 168 : acpi_handle handle = acpi_dev->handle;
274 : 168 : acpi_status status;
275 : :
276 [ - + ]: 168 : pnp_dbg(&dev->dev, "parse allocated resources\n");
277 : :
278 : 168 : pnp_init_resources(dev);
279 : :
280 : 168 : status = acpi_walk_resources(handle, METHOD_NAME__CRS,
281 : : pnpacpi_allocated_resource, dev);
282 : :
283 [ - + ]: 168 : if (ACPI_FAILURE(status)) {
284 [ # # ]: 0 : if (status != AE_NOT_FOUND)
285 : 0 : dev_err(&dev->dev, "can't evaluate _CRS: %d", status);
286 : 0 : return -EPERM;
287 : : }
288 : : return 0;
289 : : }
290 : :
291 : 0 : static __init void pnpacpi_parse_dma_option(struct pnp_dev *dev,
292 : : unsigned int option_flags,
293 : : struct acpi_resource_dma *p)
294 : : {
295 : 0 : int i;
296 : 0 : unsigned char map = 0, flags;
297 : :
298 [ # # ]: 0 : for (i = 0; i < p->channel_count; i++)
299 : 0 : map |= 1 << p->channels[i];
300 : :
301 : 0 : flags = dma_flags(dev, p->type, p->bus_master, p->transfer);
302 : 0 : pnp_register_dma_resource(dev, option_flags, map, flags);
303 : 0 : }
304 : :
305 : 0 : static __init void pnpacpi_parse_irq_option(struct pnp_dev *dev,
306 : : unsigned int option_flags,
307 : : struct acpi_resource_irq *p)
308 : : {
309 : 0 : int i;
310 : 0 : pnp_irq_mask_t map;
311 : 0 : unsigned char flags;
312 : :
313 : 0 : bitmap_zero(map.bits, PNP_IRQ_NR);
314 [ # # ]: 0 : for (i = 0; i < p->interrupt_count; i++)
315 [ # # ]: 0 : if (p->interrupts[i])
316 : 0 : __set_bit(p->interrupts[i], map.bits);
317 : :
318 : 0 : flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->shareable);
319 : 0 : pnp_register_irq_resource(dev, option_flags, &map, flags);
320 : 0 : }
321 : :
322 : 0 : static __init void pnpacpi_parse_ext_irq_option(struct pnp_dev *dev,
323 : : unsigned int option_flags,
324 : : struct acpi_resource_extended_irq *p)
325 : : {
326 : 0 : int i;
327 : 0 : pnp_irq_mask_t map;
328 : 0 : unsigned char flags;
329 : :
330 : 0 : bitmap_zero(map.bits, PNP_IRQ_NR);
331 [ # # ]: 0 : for (i = 0; i < p->interrupt_count; i++) {
332 [ # # ]: 0 : if (p->interrupts[i]) {
333 [ # # ]: 0 : if (p->interrupts[i] < PNP_IRQ_NR)
334 : 0 : __set_bit(p->interrupts[i], map.bits);
335 : : else
336 : 0 : dev_err(&dev->dev,
337 : : "ignoring IRQ %d option (too large for %d entry bitmap)\n",
338 : : p->interrupts[i], PNP_IRQ_NR);
339 : : }
340 : : }
341 : :
342 : 0 : flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->shareable);
343 : 0 : pnp_register_irq_resource(dev, option_flags, &map, flags);
344 : 0 : }
345 : :
346 : 0 : static __init void pnpacpi_parse_port_option(struct pnp_dev *dev,
347 : : unsigned int option_flags,
348 : : struct acpi_resource_io *io)
349 : : {
350 : 0 : unsigned char flags = 0;
351 : :
352 [ # # ]: 0 : if (io->io_decode == ACPI_DECODE_16)
353 : 0 : flags = IORESOURCE_IO_16BIT_ADDR;
354 : 0 : pnp_register_port_resource(dev, option_flags, io->minimum, io->maximum,
355 : 0 : io->alignment, io->address_length, flags);
356 : 0 : }
357 : :
358 : 0 : static __init void pnpacpi_parse_fixed_port_option(struct pnp_dev *dev,
359 : : unsigned int option_flags,
360 : : struct acpi_resource_fixed_io *io)
361 : : {
362 : 0 : pnp_register_port_resource(dev, option_flags, io->address, io->address,
363 : 0 : 0, io->address_length, IORESOURCE_IO_FIXED);
364 : 0 : }
365 : :
366 : 0 : static __init void pnpacpi_parse_mem24_option(struct pnp_dev *dev,
367 : : unsigned int option_flags,
368 : : struct acpi_resource_memory24 *p)
369 : : {
370 : 0 : unsigned char flags = 0;
371 : :
372 [ # # ]: 0 : if (p->write_protect == ACPI_READ_WRITE_MEMORY)
373 : 0 : flags = IORESOURCE_MEM_WRITEABLE;
374 : 0 : pnp_register_mem_resource(dev, option_flags, p->minimum, p->maximum,
375 : 0 : p->alignment, p->address_length, flags);
376 : 0 : }
377 : :
378 : 0 : static __init void pnpacpi_parse_mem32_option(struct pnp_dev *dev,
379 : : unsigned int option_flags,
380 : : struct acpi_resource_memory32 *p)
381 : : {
382 : 0 : unsigned char flags = 0;
383 : :
384 [ # # ]: 0 : if (p->write_protect == ACPI_READ_WRITE_MEMORY)
385 : 0 : flags = IORESOURCE_MEM_WRITEABLE;
386 : 0 : pnp_register_mem_resource(dev, option_flags, p->minimum, p->maximum,
387 : 0 : p->alignment, p->address_length, flags);
388 : 0 : }
389 : :
390 : 0 : static __init void pnpacpi_parse_fixed_mem32_option(struct pnp_dev *dev,
391 : : unsigned int option_flags,
392 : : struct acpi_resource_fixed_memory32 *p)
393 : : {
394 : 0 : unsigned char flags = 0;
395 : :
396 [ # # ]: 0 : if (p->write_protect == ACPI_READ_WRITE_MEMORY)
397 : 0 : flags = IORESOURCE_MEM_WRITEABLE;
398 : 0 : pnp_register_mem_resource(dev, option_flags, p->address, p->address,
399 : 0 : 0, p->address_length, flags);
400 : 0 : }
401 : :
402 : 0 : static __init void pnpacpi_parse_address_option(struct pnp_dev *dev,
403 : : unsigned int option_flags,
404 : : struct acpi_resource *r)
405 : : {
406 : 0 : struct acpi_resource_address64 addr, *p = &addr;
407 : 0 : acpi_status status;
408 : 0 : unsigned char flags = 0;
409 : :
410 : 0 : status = acpi_resource_to_address64(r, p);
411 [ # # ]: 0 : if (ACPI_FAILURE(status)) {
412 : 0 : dev_warn(&dev->dev, "can't convert resource type %d\n",
413 : : r->type);
414 : 0 : return;
415 : : }
416 : :
417 [ # # ]: 0 : if (p->resource_type == ACPI_MEMORY_RANGE) {
418 [ # # ]: 0 : if (p->info.mem.write_protect == ACPI_READ_WRITE_MEMORY)
419 : 0 : flags = IORESOURCE_MEM_WRITEABLE;
420 : 0 : pnp_register_mem_resource(dev, option_flags, p->address.minimum,
421 : : p->address.minimum, 0, p->address.address_length,
422 : : flags);
423 [ # # ]: 0 : } else if (p->resource_type == ACPI_IO_RANGE)
424 : 0 : pnp_register_port_resource(dev, option_flags, p->address.minimum,
425 : : p->address.minimum, 0, p->address.address_length,
426 : : IORESOURCE_IO_FIXED);
427 : : }
428 : :
429 : 0 : static __init void pnpacpi_parse_ext_address_option(struct pnp_dev *dev,
430 : : unsigned int option_flags,
431 : : struct acpi_resource *r)
432 : : {
433 : 0 : struct acpi_resource_extended_address64 *p = &r->data.ext_address64;
434 : 0 : unsigned char flags = 0;
435 : :
436 [ # # ]: 0 : if (p->resource_type == ACPI_MEMORY_RANGE) {
437 [ # # ]: 0 : if (p->info.mem.write_protect == ACPI_READ_WRITE_MEMORY)
438 : 0 : flags = IORESOURCE_MEM_WRITEABLE;
439 : 0 : pnp_register_mem_resource(dev, option_flags, p->address.minimum,
440 : : p->address.minimum, 0, p->address.address_length,
441 : : flags);
442 [ # # ]: 0 : } else if (p->resource_type == ACPI_IO_RANGE)
443 : 0 : pnp_register_port_resource(dev, option_flags, p->address.minimum,
444 : : p->address.minimum, 0, p->address.address_length,
445 : : IORESOURCE_IO_FIXED);
446 : 0 : }
447 : :
448 : : struct acpipnp_parse_option_s {
449 : : struct pnp_dev *dev;
450 : : unsigned int option_flags;
451 : : };
452 : :
453 : 0 : static __init acpi_status pnpacpi_option_resource(struct acpi_resource *res,
454 : : void *data)
455 : : {
456 : 0 : int priority;
457 : 0 : struct acpipnp_parse_option_s *parse_data = data;
458 : 0 : struct pnp_dev *dev = parse_data->dev;
459 : 0 : unsigned int option_flags = parse_data->option_flags;
460 : :
461 [ # # # # : 0 : switch (res->type) {
# # # # #
# # # #
# ]
462 : 0 : case ACPI_RESOURCE_TYPE_IRQ:
463 : 0 : pnpacpi_parse_irq_option(dev, option_flags, &res->data.irq);
464 : 0 : break;
465 : :
466 : 0 : case ACPI_RESOURCE_TYPE_DMA:
467 : 0 : pnpacpi_parse_dma_option(dev, option_flags, &res->data.dma);
468 : 0 : break;
469 : :
470 : 0 : case ACPI_RESOURCE_TYPE_START_DEPENDENT:
471 [ # # ]: 0 : switch (res->data.start_dpf.compatibility_priority) {
472 : : case ACPI_GOOD_CONFIGURATION:
473 : : priority = PNP_RES_PRIORITY_PREFERRED;
474 : : break;
475 : :
476 : : case ACPI_ACCEPTABLE_CONFIGURATION:
477 : : priority = PNP_RES_PRIORITY_ACCEPTABLE;
478 : : break;
479 : :
480 : : case ACPI_SUB_OPTIMAL_CONFIGURATION:
481 : : priority = PNP_RES_PRIORITY_FUNCTIONAL;
482 : : break;
483 : : default:
484 : : priority = PNP_RES_PRIORITY_INVALID;
485 : : break;
486 : : }
487 : 0 : parse_data->option_flags = pnp_new_dependent_set(dev, priority);
488 : 0 : break;
489 : :
490 : 0 : case ACPI_RESOURCE_TYPE_END_DEPENDENT:
491 : 0 : parse_data->option_flags = 0;
492 : 0 : break;
493 : :
494 : 0 : case ACPI_RESOURCE_TYPE_IO:
495 : 0 : pnpacpi_parse_port_option(dev, option_flags, &res->data.io);
496 : 0 : break;
497 : :
498 : 0 : case ACPI_RESOURCE_TYPE_FIXED_IO:
499 : 0 : pnpacpi_parse_fixed_port_option(dev, option_flags,
500 : : &res->data.fixed_io);
501 : 0 : break;
502 : :
503 : : case ACPI_RESOURCE_TYPE_VENDOR:
504 : : case ACPI_RESOURCE_TYPE_END_TAG:
505 : : break;
506 : :
507 : 0 : case ACPI_RESOURCE_TYPE_MEMORY24:
508 : 0 : pnpacpi_parse_mem24_option(dev, option_flags,
509 : : &res->data.memory24);
510 : 0 : break;
511 : :
512 : 0 : case ACPI_RESOURCE_TYPE_MEMORY32:
513 : 0 : pnpacpi_parse_mem32_option(dev, option_flags,
514 : : &res->data.memory32);
515 : 0 : break;
516 : :
517 : 0 : case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
518 : 0 : pnpacpi_parse_fixed_mem32_option(dev, option_flags,
519 : : &res->data.fixed_memory32);
520 : 0 : break;
521 : :
522 : 0 : case ACPI_RESOURCE_TYPE_ADDRESS16:
523 : : case ACPI_RESOURCE_TYPE_ADDRESS32:
524 : : case ACPI_RESOURCE_TYPE_ADDRESS64:
525 : 0 : pnpacpi_parse_address_option(dev, option_flags, res);
526 : 0 : break;
527 : :
528 : 0 : case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
529 : 0 : pnpacpi_parse_ext_address_option(dev, option_flags, res);
530 : 0 : break;
531 : :
532 : 0 : case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
533 : 0 : pnpacpi_parse_ext_irq_option(dev, option_flags,
534 : : &res->data.extended_irq);
535 : 0 : break;
536 : :
537 : : case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
538 : : break;
539 : :
540 : 0 : default:
541 : 0 : dev_warn(&dev->dev, "unknown resource type %d in _PRS\n",
542 : : res->type);
543 : 0 : return AE_ERROR;
544 : : }
545 : :
546 : : return AE_OK;
547 : : }
548 : :
549 : 0 : int __init pnpacpi_parse_resource_option_data(struct pnp_dev *dev)
550 : : {
551 : 0 : struct acpi_device *acpi_dev = dev->data;
552 : 0 : acpi_handle handle = acpi_dev->handle;
553 : 0 : acpi_status status;
554 : 0 : struct acpipnp_parse_option_s parse_data;
555 : :
556 [ # # ]: 0 : pnp_dbg(&dev->dev, "parse resource options\n");
557 : :
558 : 0 : parse_data.dev = dev;
559 : 0 : parse_data.option_flags = 0;
560 : :
561 : 0 : status = acpi_walk_resources(handle, METHOD_NAME__PRS,
562 : : pnpacpi_option_resource, &parse_data);
563 : :
564 [ # # ]: 0 : if (ACPI_FAILURE(status)) {
565 [ # # ]: 0 : if (status != AE_NOT_FOUND)
566 : 0 : dev_err(&dev->dev, "can't evaluate _PRS: %d", status);
567 : 0 : return -EPERM;
568 : : }
569 : : return 0;
570 : : }
571 : :
572 : 0 : static int pnpacpi_supported_resource(struct acpi_resource *res)
573 : : {
574 : 0 : switch (res->type) {
575 : : case ACPI_RESOURCE_TYPE_IRQ:
576 : : case ACPI_RESOURCE_TYPE_DMA:
577 : : case ACPI_RESOURCE_TYPE_IO:
578 : : case ACPI_RESOURCE_TYPE_FIXED_IO:
579 : : case ACPI_RESOURCE_TYPE_MEMORY24:
580 : : case ACPI_RESOURCE_TYPE_MEMORY32:
581 : : case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
582 : : case ACPI_RESOURCE_TYPE_ADDRESS16:
583 : : case ACPI_RESOURCE_TYPE_ADDRESS32:
584 : : case ACPI_RESOURCE_TYPE_ADDRESS64:
585 : : case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
586 : : case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
587 : : return 1;
588 : : }
589 : : return 0;
590 : : }
591 : :
592 : : /*
593 : : * Set resource
594 : : */
595 : 0 : static acpi_status pnpacpi_count_resources(struct acpi_resource *res,
596 : : void *data)
597 : : {
598 : 0 : int *res_cnt = data;
599 : :
600 [ # # ]: 0 : if (pnpacpi_supported_resource(res))
601 : 0 : (*res_cnt)++;
602 : 0 : return AE_OK;
603 : : }
604 : :
605 : 0 : static acpi_status pnpacpi_type_resources(struct acpi_resource *res, void *data)
606 : : {
607 : 0 : struct acpi_resource **resource = data;
608 : :
609 [ # # ]: 0 : if (pnpacpi_supported_resource(res)) {
610 : 0 : (*resource)->type = res->type;
611 : 0 : (*resource)->length = sizeof(struct acpi_resource);
612 [ # # ]: 0 : if (res->type == ACPI_RESOURCE_TYPE_IRQ)
613 : 0 : (*resource)->data.irq.descriptor_length =
614 : 0 : res->data.irq.descriptor_length;
615 : 0 : (*resource)++;
616 : : }
617 : :
618 : 0 : return AE_OK;
619 : : }
620 : :
621 : 0 : int pnpacpi_build_resource_template(struct pnp_dev *dev,
622 : : struct acpi_buffer *buffer)
623 : : {
624 : 0 : struct acpi_device *acpi_dev = dev->data;
625 : 0 : acpi_handle handle = acpi_dev->handle;
626 : 0 : struct acpi_resource *resource;
627 : 0 : int res_cnt = 0;
628 : 0 : acpi_status status;
629 : :
630 : 0 : status = acpi_walk_resources(handle, METHOD_NAME__CRS,
631 : : pnpacpi_count_resources, &res_cnt);
632 [ # # ]: 0 : if (ACPI_FAILURE(status)) {
633 : 0 : dev_err(&dev->dev, "can't evaluate _CRS: %d\n", status);
634 : 0 : return -EINVAL;
635 : : }
636 [ # # ]: 0 : if (!res_cnt)
637 : : return -EINVAL;
638 : 0 : buffer->length = sizeof(struct acpi_resource) * (res_cnt + 1) + 1;
639 : 0 : buffer->pointer = kzalloc(buffer->length - 1, GFP_KERNEL);
640 [ # # ]: 0 : if (!buffer->pointer)
641 : : return -ENOMEM;
642 : :
643 : 0 : resource = (struct acpi_resource *)buffer->pointer;
644 : 0 : status = acpi_walk_resources(handle, METHOD_NAME__CRS,
645 : : pnpacpi_type_resources, &resource);
646 [ # # ]: 0 : if (ACPI_FAILURE(status)) {
647 : 0 : kfree(buffer->pointer);
648 : 0 : dev_err(&dev->dev, "can't evaluate _CRS: %d\n", status);
649 : 0 : return -EINVAL;
650 : : }
651 : : /* resource will pointer the end resource now */
652 : 0 : resource->type = ACPI_RESOURCE_TYPE_END_TAG;
653 : 0 : resource->length = sizeof(struct acpi_resource);
654 : :
655 : 0 : return 0;
656 : : }
657 : :
658 : 0 : static void pnpacpi_encode_irq(struct pnp_dev *dev,
659 : : struct acpi_resource *resource,
660 : : struct resource *p)
661 : : {
662 : 0 : struct acpi_resource_irq *irq = &resource->data.irq;
663 : 0 : u8 triggering, polarity, shareable;
664 : :
665 [ # # ]: 0 : if (!pnp_resource_enabled(p)) {
666 : 0 : irq->interrupt_count = 0;
667 [ # # # # ]: 0 : pnp_dbg(&dev->dev, " encode irq (%s)\n",
668 : : p ? "disabled" : "missing");
669 : 0 : return;
670 : : }
671 : :
672 : 0 : decode_irq_flags(dev, p->flags, &triggering, &polarity, &shareable);
673 : 0 : irq->triggering = triggering;
674 : 0 : irq->polarity = polarity;
675 : 0 : irq->shareable = shareable;
676 : 0 : irq->interrupt_count = 1;
677 : 0 : irq->interrupts[0] = p->start;
678 : :
679 [ # # # # : 0 : pnp_dbg(&dev->dev, " encode irq %d %s %s %s (%d-byte descriptor)\n",
# # # # ]
680 : : (int) p->start,
681 : : triggering == ACPI_LEVEL_SENSITIVE ? "level" : "edge",
682 : : polarity == ACPI_ACTIVE_LOW ? "low" : "high",
683 : : irq->shareable == ACPI_SHARED ? "shared" : "exclusive",
684 : : irq->descriptor_length);
685 : : }
686 : :
687 : 0 : static void pnpacpi_encode_ext_irq(struct pnp_dev *dev,
688 : : struct acpi_resource *resource,
689 : : struct resource *p)
690 : : {
691 : 0 : struct acpi_resource_extended_irq *extended_irq = &resource->data.extended_irq;
692 : 0 : u8 triggering, polarity, shareable;
693 : :
694 [ # # ]: 0 : if (!pnp_resource_enabled(p)) {
695 : 0 : extended_irq->interrupt_count = 0;
696 [ # # # # ]: 0 : pnp_dbg(&dev->dev, " encode extended irq (%s)\n",
697 : : p ? "disabled" : "missing");
698 : 0 : return;
699 : : }
700 : :
701 : 0 : decode_irq_flags(dev, p->flags, &triggering, &polarity, &shareable);
702 : 0 : extended_irq->producer_consumer = ACPI_CONSUMER;
703 : 0 : extended_irq->triggering = triggering;
704 : 0 : extended_irq->polarity = polarity;
705 : 0 : extended_irq->shareable = shareable;
706 : 0 : extended_irq->interrupt_count = 1;
707 : 0 : extended_irq->interrupts[0] = p->start;
708 : :
709 [ # # # # : 0 : pnp_dbg(&dev->dev, " encode irq %d %s %s %s\n", (int) p->start,
# # # # ]
710 : : triggering == ACPI_LEVEL_SENSITIVE ? "level" : "edge",
711 : : polarity == ACPI_ACTIVE_LOW ? "low" : "high",
712 : : extended_irq->shareable == ACPI_SHARED ? "shared" : "exclusive");
713 : : }
714 : :
715 : 0 : static void pnpacpi_encode_dma(struct pnp_dev *dev,
716 : : struct acpi_resource *resource,
717 : : struct resource *p)
718 : : {
719 : 0 : struct acpi_resource_dma *dma = &resource->data.dma;
720 : :
721 [ # # ]: 0 : if (!pnp_resource_enabled(p)) {
722 : 0 : dma->channel_count = 0;
723 [ # # # # ]: 0 : pnp_dbg(&dev->dev, " encode dma (%s)\n",
724 : : p ? "disabled" : "missing");
725 : 0 : return;
726 : : }
727 : :
728 : : /* Note: pnp_assign_dma will copy pnp_dma->flags into p->flags */
729 [ # # # # ]: 0 : switch (p->flags & IORESOURCE_DMA_SPEED_MASK) {
730 : 0 : case IORESOURCE_DMA_TYPEA:
731 : 0 : dma->type = ACPI_TYPE_A;
732 : 0 : break;
733 : 0 : case IORESOURCE_DMA_TYPEB:
734 : 0 : dma->type = ACPI_TYPE_B;
735 : 0 : break;
736 : 0 : case IORESOURCE_DMA_TYPEF:
737 : 0 : dma->type = ACPI_TYPE_F;
738 : 0 : break;
739 : 0 : default:
740 : 0 : dma->type = ACPI_COMPATIBILITY;
741 : : }
742 : :
743 [ # # # ]: 0 : switch (p->flags & IORESOURCE_DMA_TYPE_MASK) {
744 : 0 : case IORESOURCE_DMA_8BIT:
745 : 0 : dma->transfer = ACPI_TRANSFER_8;
746 : 0 : break;
747 : 0 : case IORESOURCE_DMA_8AND16BIT:
748 : 0 : dma->transfer = ACPI_TRANSFER_8_16;
749 : 0 : break;
750 : 0 : default:
751 : 0 : dma->transfer = ACPI_TRANSFER_16;
752 : : }
753 : :
754 : 0 : dma->bus_master = !!(p->flags & IORESOURCE_DMA_MASTER);
755 : 0 : dma->channel_count = 1;
756 : 0 : dma->channels[0] = p->start;
757 : :
758 [ # # ]: 0 : pnp_dbg(&dev->dev, " encode dma %d "
759 : : "type %#x transfer %#x master %d\n",
760 : : (int) p->start, dma->type, dma->transfer, dma->bus_master);
761 : : }
762 : :
763 : 0 : static void pnpacpi_encode_io(struct pnp_dev *dev,
764 : : struct acpi_resource *resource,
765 : : struct resource *p)
766 : : {
767 : 0 : struct acpi_resource_io *io = &resource->data.io;
768 : :
769 [ # # ]: 0 : if (pnp_resource_enabled(p)) {
770 : : /* Note: pnp_assign_port copies pnp_port->flags into p->flags */
771 : 0 : io->io_decode = (p->flags & IORESOURCE_IO_16BIT_ADDR) ?
772 : 0 : ACPI_DECODE_16 : ACPI_DECODE_10;
773 : 0 : io->minimum = p->start;
774 : 0 : io->maximum = p->end;
775 : 0 : io->alignment = 0; /* Correct? */
776 : 0 : io->address_length = resource_size(p);
777 : : } else {
778 : 0 : io->minimum = 0;
779 : 0 : io->address_length = 0;
780 : : }
781 : :
782 [ # # ]: 0 : pnp_dbg(&dev->dev, " encode io %#x-%#x decode %#x\n", io->minimum,
783 : : io->minimum + io->address_length - 1, io->io_decode);
784 : 0 : }
785 : :
786 : 0 : static void pnpacpi_encode_fixed_io(struct pnp_dev *dev,
787 : : struct acpi_resource *resource,
788 : : struct resource *p)
789 : : {
790 : 0 : struct acpi_resource_fixed_io *fixed_io = &resource->data.fixed_io;
791 : :
792 [ # # ]: 0 : if (pnp_resource_enabled(p)) {
793 : 0 : fixed_io->address = p->start;
794 : 0 : fixed_io->address_length = resource_size(p);
795 : : } else {
796 : 0 : fixed_io->address = 0;
797 : 0 : fixed_io->address_length = 0;
798 : : }
799 : :
800 [ # # ]: 0 : pnp_dbg(&dev->dev, " encode fixed_io %#x-%#x\n", fixed_io->address,
801 : : fixed_io->address + fixed_io->address_length - 1);
802 : 0 : }
803 : :
804 : 0 : static void pnpacpi_encode_mem24(struct pnp_dev *dev,
805 : : struct acpi_resource *resource,
806 : : struct resource *p)
807 : : {
808 : 0 : struct acpi_resource_memory24 *memory24 = &resource->data.memory24;
809 : :
810 [ # # ]: 0 : if (pnp_resource_enabled(p)) {
811 : : /* Note: pnp_assign_mem copies pnp_mem->flags into p->flags */
812 : 0 : memory24->write_protect = p->flags & IORESOURCE_MEM_WRITEABLE ?
813 : 0 : ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
814 : 0 : memory24->minimum = p->start;
815 : 0 : memory24->maximum = p->end;
816 : 0 : memory24->alignment = 0;
817 : 0 : memory24->address_length = resource_size(p);
818 : : } else {
819 : 0 : memory24->minimum = 0;
820 : 0 : memory24->address_length = 0;
821 : : }
822 : :
823 [ # # ]: 0 : pnp_dbg(&dev->dev, " encode mem24 %#x-%#x write_protect %#x\n",
824 : : memory24->minimum,
825 : : memory24->minimum + memory24->address_length - 1,
826 : : memory24->write_protect);
827 : 0 : }
828 : :
829 : 0 : static void pnpacpi_encode_mem32(struct pnp_dev *dev,
830 : : struct acpi_resource *resource,
831 : : struct resource *p)
832 : : {
833 : 0 : struct acpi_resource_memory32 *memory32 = &resource->data.memory32;
834 : :
835 [ # # ]: 0 : if (pnp_resource_enabled(p)) {
836 : 0 : memory32->write_protect = p->flags & IORESOURCE_MEM_WRITEABLE ?
837 : 0 : ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
838 : 0 : memory32->minimum = p->start;
839 : 0 : memory32->maximum = p->end;
840 : 0 : memory32->alignment = 0;
841 : 0 : memory32->address_length = resource_size(p);
842 : : } else {
843 : 0 : memory32->minimum = 0;
844 : 0 : memory32->alignment = 0;
845 : : }
846 : :
847 [ # # ]: 0 : pnp_dbg(&dev->dev, " encode mem32 %#x-%#x write_protect %#x\n",
848 : : memory32->minimum,
849 : : memory32->minimum + memory32->address_length - 1,
850 : : memory32->write_protect);
851 : 0 : }
852 : :
853 : 0 : static void pnpacpi_encode_fixed_mem32(struct pnp_dev *dev,
854 : : struct acpi_resource *resource,
855 : : struct resource *p)
856 : : {
857 : 0 : struct acpi_resource_fixed_memory32 *fixed_memory32 = &resource->data.fixed_memory32;
858 : :
859 [ # # ]: 0 : if (pnp_resource_enabled(p)) {
860 : 0 : fixed_memory32->write_protect =
861 : : p->flags & IORESOURCE_MEM_WRITEABLE ?
862 : 0 : ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
863 : 0 : fixed_memory32->address = p->start;
864 : 0 : fixed_memory32->address_length = resource_size(p);
865 : : } else {
866 : 0 : fixed_memory32->address = 0;
867 : 0 : fixed_memory32->address_length = 0;
868 : : }
869 : :
870 [ # # ]: 0 : pnp_dbg(&dev->dev, " encode fixed_mem32 %#x-%#x write_protect %#x\n",
871 : : fixed_memory32->address,
872 : : fixed_memory32->address + fixed_memory32->address_length - 1,
873 : : fixed_memory32->write_protect);
874 : 0 : }
875 : :
876 : 0 : int pnpacpi_encode_resources(struct pnp_dev *dev, struct acpi_buffer *buffer)
877 : : {
878 : 0 : int i = 0;
879 : : /* pnpacpi_build_resource_template allocates extra mem */
880 : 0 : int res_cnt = (buffer->length - 1) / sizeof(struct acpi_resource) - 1;
881 : 0 : struct acpi_resource *resource = buffer->pointer;
882 : 0 : unsigned int port = 0, irq = 0, dma = 0, mem = 0;
883 : :
884 [ # # ]: 0 : pnp_dbg(&dev->dev, "encode %d resources\n", res_cnt);
885 [ # # ]: 0 : while (i < res_cnt) {
886 [ # # # # : 0 : switch (resource->type) {
# # # #
# ]
887 : 0 : case ACPI_RESOURCE_TYPE_IRQ:
888 : 0 : pnpacpi_encode_irq(dev, resource,
889 : : pnp_get_resource(dev, IORESOURCE_IRQ, irq));
890 : 0 : irq++;
891 : 0 : break;
892 : :
893 : 0 : case ACPI_RESOURCE_TYPE_DMA:
894 : 0 : pnpacpi_encode_dma(dev, resource,
895 : : pnp_get_resource(dev, IORESOURCE_DMA, dma));
896 : 0 : dma++;
897 : 0 : break;
898 : 0 : case ACPI_RESOURCE_TYPE_IO:
899 : 0 : pnpacpi_encode_io(dev, resource,
900 : : pnp_get_resource(dev, IORESOURCE_IO, port));
901 : 0 : port++;
902 : 0 : break;
903 : 0 : case ACPI_RESOURCE_TYPE_FIXED_IO:
904 : 0 : pnpacpi_encode_fixed_io(dev, resource,
905 : : pnp_get_resource(dev, IORESOURCE_IO, port));
906 : 0 : port++;
907 : 0 : break;
908 : 0 : case ACPI_RESOURCE_TYPE_MEMORY24:
909 : 0 : pnpacpi_encode_mem24(dev, resource,
910 : : pnp_get_resource(dev, IORESOURCE_MEM, mem));
911 : 0 : mem++;
912 : 0 : break;
913 : 0 : case ACPI_RESOURCE_TYPE_MEMORY32:
914 : 0 : pnpacpi_encode_mem32(dev, resource,
915 : : pnp_get_resource(dev, IORESOURCE_MEM, mem));
916 : 0 : mem++;
917 : 0 : break;
918 : 0 : case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
919 : 0 : pnpacpi_encode_fixed_mem32(dev, resource,
920 : : pnp_get_resource(dev, IORESOURCE_MEM, mem));
921 : 0 : mem++;
922 : 0 : break;
923 : 0 : case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
924 : 0 : pnpacpi_encode_ext_irq(dev, resource,
925 : : pnp_get_resource(dev, IORESOURCE_IRQ, irq));
926 : 0 : irq++;
927 : 0 : break;
928 : 0 : case ACPI_RESOURCE_TYPE_START_DEPENDENT:
929 : : case ACPI_RESOURCE_TYPE_END_DEPENDENT:
930 : : case ACPI_RESOURCE_TYPE_VENDOR:
931 : : case ACPI_RESOURCE_TYPE_END_TAG:
932 : : case ACPI_RESOURCE_TYPE_ADDRESS16:
933 : : case ACPI_RESOURCE_TYPE_ADDRESS32:
934 : : case ACPI_RESOURCE_TYPE_ADDRESS64:
935 : : case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
936 : : case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
937 : : default: /* other type */
938 : 0 : dev_warn(&dev->dev,
939 : : "can't encode unknown resource type %d\n",
940 : : resource->type);
941 : 0 : return -EINVAL;
942 : : }
943 : 0 : resource++;
944 : 0 : i++;
945 : : }
946 : : return 0;
947 : : }
|
