xref: /openbmc/linux/drivers/acpi/resource.c (revision 13a9d0be)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * drivers/acpi/resource.c - ACPI device resources interpretation.
4  *
5  * Copyright (C) 2012, Intel Corp.
6  * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
7  *
8  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
9  *
10  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
11  */
12 
13 #include <linux/acpi.h>
14 #include <linux/device.h>
15 #include <linux/export.h>
16 #include <linux/ioport.h>
17 #include <linux/slab.h>
18 #include <linux/irq.h>
19 #include <linux/dmi.h>
20 
21 #ifdef CONFIG_X86
22 #define valid_IRQ(i) (((i) != 0) && ((i) != 2))
23 static inline bool acpi_iospace_resource_valid(struct resource *res)
24 {
25 	/* On X86 IO space is limited to the [0 - 64K] IO port range */
26 	return res->end < 0x10003;
27 }
28 #else
29 #define valid_IRQ(i) (true)
30 /*
31  * ACPI IO descriptors on arches other than X86 contain MMIO CPU physical
32  * addresses mapping IO space in CPU physical address space, IO space
33  * resources can be placed anywhere in the 64-bit physical address space.
34  */
35 static inline bool
36 acpi_iospace_resource_valid(struct resource *res) { return true; }
37 #endif
38 
39 #if IS_ENABLED(CONFIG_ACPI_GENERIC_GSI)
40 static inline bool is_gsi(struct acpi_resource_extended_irq *ext_irq)
41 {
42 	return ext_irq->resource_source.string_length == 0 &&
43 	       ext_irq->producer_consumer == ACPI_CONSUMER;
44 }
45 #else
46 static inline bool is_gsi(struct acpi_resource_extended_irq *ext_irq)
47 {
48 	return true;
49 }
50 #endif
51 
52 static bool acpi_dev_resource_len_valid(u64 start, u64 end, u64 len, bool io)
53 {
54 	u64 reslen = end - start + 1;
55 
56 	/*
57 	 * CHECKME: len might be required to check versus a minimum
58 	 * length as well. 1 for io is fine, but for memory it does
59 	 * not make any sense at all.
60 	 * Note: some BIOSes report incorrect length for ACPI address space
61 	 * descriptor, so remove check of 'reslen == len' to avoid regression.
62 	 */
63 	if (len && reslen && start <= end)
64 		return true;
65 
66 	pr_debug("ACPI: invalid or unassigned resource %s [%016llx - %016llx] length [%016llx]\n",
67 		io ? "io" : "mem", start, end, len);
68 
69 	return false;
70 }
71 
72 static void acpi_dev_memresource_flags(struct resource *res, u64 len,
73 				       u8 write_protect)
74 {
75 	res->flags = IORESOURCE_MEM;
76 
77 	if (!acpi_dev_resource_len_valid(res->start, res->end, len, false))
78 		res->flags |= IORESOURCE_DISABLED | IORESOURCE_UNSET;
79 
80 	if (write_protect == ACPI_READ_WRITE_MEMORY)
81 		res->flags |= IORESOURCE_MEM_WRITEABLE;
82 }
83 
84 static void acpi_dev_get_memresource(struct resource *res, u64 start, u64 len,
85 				     u8 write_protect)
86 {
87 	res->start = start;
88 	res->end = start + len - 1;
89 	acpi_dev_memresource_flags(res, len, write_protect);
90 }
91 
92 /**
93  * acpi_dev_resource_memory - Extract ACPI memory resource information.
94  * @ares: Input ACPI resource object.
95  * @res: Output generic resource object.
96  *
97  * Check if the given ACPI resource object represents a memory resource and
98  * if that's the case, use the information in it to populate the generic
99  * resource object pointed to by @res.
100  *
101  * Return:
102  * 1) false with res->flags setting to zero: not the expected resource type
103  * 2) false with IORESOURCE_DISABLED in res->flags: valid unassigned resource
104  * 3) true: valid assigned resource
105  */
106 bool acpi_dev_resource_memory(struct acpi_resource *ares, struct resource *res)
107 {
108 	struct acpi_resource_memory24 *memory24;
109 	struct acpi_resource_memory32 *memory32;
110 	struct acpi_resource_fixed_memory32 *fixed_memory32;
111 
112 	switch (ares->type) {
113 	case ACPI_RESOURCE_TYPE_MEMORY24:
114 		memory24 = &ares->data.memory24;
115 		acpi_dev_get_memresource(res, memory24->minimum << 8,
116 					 memory24->address_length << 8,
117 					 memory24->write_protect);
118 		break;
119 	case ACPI_RESOURCE_TYPE_MEMORY32:
120 		memory32 = &ares->data.memory32;
121 		acpi_dev_get_memresource(res, memory32->minimum,
122 					 memory32->address_length,
123 					 memory32->write_protect);
124 		break;
125 	case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
126 		fixed_memory32 = &ares->data.fixed_memory32;
127 		acpi_dev_get_memresource(res, fixed_memory32->address,
128 					 fixed_memory32->address_length,
129 					 fixed_memory32->write_protect);
130 		break;
131 	default:
132 		res->flags = 0;
133 		return false;
134 	}
135 
136 	return !(res->flags & IORESOURCE_DISABLED);
137 }
138 EXPORT_SYMBOL_GPL(acpi_dev_resource_memory);
139 
140 static void acpi_dev_ioresource_flags(struct resource *res, u64 len,
141 				      u8 io_decode, u8 translation_type)
142 {
143 	res->flags = IORESOURCE_IO;
144 
145 	if (!acpi_dev_resource_len_valid(res->start, res->end, len, true))
146 		res->flags |= IORESOURCE_DISABLED | IORESOURCE_UNSET;
147 
148 	if (!acpi_iospace_resource_valid(res))
149 		res->flags |= IORESOURCE_DISABLED | IORESOURCE_UNSET;
150 
151 	if (io_decode == ACPI_DECODE_16)
152 		res->flags |= IORESOURCE_IO_16BIT_ADDR;
153 	if (translation_type == ACPI_SPARSE_TRANSLATION)
154 		res->flags |= IORESOURCE_IO_SPARSE;
155 }
156 
157 static void acpi_dev_get_ioresource(struct resource *res, u64 start, u64 len,
158 				    u8 io_decode)
159 {
160 	res->start = start;
161 	res->end = start + len - 1;
162 	acpi_dev_ioresource_flags(res, len, io_decode, 0);
163 }
164 
165 /**
166  * acpi_dev_resource_io - Extract ACPI I/O resource information.
167  * @ares: Input ACPI resource object.
168  * @res: Output generic resource object.
169  *
170  * Check if the given ACPI resource object represents an I/O resource and
171  * if that's the case, use the information in it to populate the generic
172  * resource object pointed to by @res.
173  *
174  * Return:
175  * 1) false with res->flags setting to zero: not the expected resource type
176  * 2) false with IORESOURCE_DISABLED in res->flags: valid unassigned resource
177  * 3) true: valid assigned resource
178  */
179 bool acpi_dev_resource_io(struct acpi_resource *ares, struct resource *res)
180 {
181 	struct acpi_resource_io *io;
182 	struct acpi_resource_fixed_io *fixed_io;
183 
184 	switch (ares->type) {
185 	case ACPI_RESOURCE_TYPE_IO:
186 		io = &ares->data.io;
187 		acpi_dev_get_ioresource(res, io->minimum,
188 					io->address_length,
189 					io->io_decode);
190 		break;
191 	case ACPI_RESOURCE_TYPE_FIXED_IO:
192 		fixed_io = &ares->data.fixed_io;
193 		acpi_dev_get_ioresource(res, fixed_io->address,
194 					fixed_io->address_length,
195 					ACPI_DECODE_10);
196 		break;
197 	default:
198 		res->flags = 0;
199 		return false;
200 	}
201 
202 	return !(res->flags & IORESOURCE_DISABLED);
203 }
204 EXPORT_SYMBOL_GPL(acpi_dev_resource_io);
205 
206 static bool acpi_decode_space(struct resource_win *win,
207 			      struct acpi_resource_address *addr,
208 			      struct acpi_address64_attribute *attr)
209 {
210 	u8 iodec = attr->granularity == 0xfff ? ACPI_DECODE_10 : ACPI_DECODE_16;
211 	bool wp = addr->info.mem.write_protect;
212 	u64 len = attr->address_length;
213 	u64 start, end, offset = 0;
214 	struct resource *res = &win->res;
215 
216 	/*
217 	 * Filter out invalid descriptor according to ACPI Spec 5.0, section
218 	 * 6.4.3.5 Address Space Resource Descriptors.
219 	 */
220 	if ((addr->min_address_fixed != addr->max_address_fixed && len) ||
221 	    (addr->min_address_fixed && addr->max_address_fixed && !len))
222 		pr_debug("ACPI: Invalid address space min_addr_fix %d, max_addr_fix %d, len %llx\n",
223 			 addr->min_address_fixed, addr->max_address_fixed, len);
224 
225 	/*
226 	 * For bridges that translate addresses across the bridge,
227 	 * translation_offset is the offset that must be added to the
228 	 * address on the secondary side to obtain the address on the
229 	 * primary side. Non-bridge devices must list 0 for all Address
230 	 * Translation offset bits.
231 	 */
232 	if (addr->producer_consumer == ACPI_PRODUCER)
233 		offset = attr->translation_offset;
234 	else if (attr->translation_offset)
235 		pr_debug("ACPI: translation_offset(%lld) is invalid for non-bridge device.\n",
236 			 attr->translation_offset);
237 	start = attr->minimum + offset;
238 	end = attr->maximum + offset;
239 
240 	win->offset = offset;
241 	res->start = start;
242 	res->end = end;
243 	if (sizeof(resource_size_t) < sizeof(u64) &&
244 	    (offset != win->offset || start != res->start || end != res->end)) {
245 		pr_warn("acpi resource window ([%#llx-%#llx] ignored, not CPU addressable)\n",
246 			attr->minimum, attr->maximum);
247 		return false;
248 	}
249 
250 	switch (addr->resource_type) {
251 	case ACPI_MEMORY_RANGE:
252 		acpi_dev_memresource_flags(res, len, wp);
253 		break;
254 	case ACPI_IO_RANGE:
255 		acpi_dev_ioresource_flags(res, len, iodec,
256 					  addr->info.io.translation_type);
257 		break;
258 	case ACPI_BUS_NUMBER_RANGE:
259 		res->flags = IORESOURCE_BUS;
260 		break;
261 	default:
262 		return false;
263 	}
264 
265 	if (addr->producer_consumer == ACPI_PRODUCER)
266 		res->flags |= IORESOURCE_WINDOW;
267 
268 	if (addr->info.mem.caching == ACPI_PREFETCHABLE_MEMORY)
269 		res->flags |= IORESOURCE_PREFETCH;
270 
271 	return !(res->flags & IORESOURCE_DISABLED);
272 }
273 
274 /**
275  * acpi_dev_resource_address_space - Extract ACPI address space information.
276  * @ares: Input ACPI resource object.
277  * @win: Output generic resource object.
278  *
279  * Check if the given ACPI resource object represents an address space resource
280  * and if that's the case, use the information in it to populate the generic
281  * resource object pointed to by @win.
282  *
283  * Return:
284  * 1) false with win->res.flags setting to zero: not the expected resource type
285  * 2) false with IORESOURCE_DISABLED in win->res.flags: valid unassigned
286  *    resource
287  * 3) true: valid assigned resource
288  */
289 bool acpi_dev_resource_address_space(struct acpi_resource *ares,
290 				     struct resource_win *win)
291 {
292 	struct acpi_resource_address64 addr;
293 
294 	win->res.flags = 0;
295 	if (ACPI_FAILURE(acpi_resource_to_address64(ares, &addr)))
296 		return false;
297 
298 	return acpi_decode_space(win, (struct acpi_resource_address *)&addr,
299 				 &addr.address);
300 }
301 EXPORT_SYMBOL_GPL(acpi_dev_resource_address_space);
302 
303 /**
304  * acpi_dev_resource_ext_address_space - Extract ACPI address space information.
305  * @ares: Input ACPI resource object.
306  * @win: Output generic resource object.
307  *
308  * Check if the given ACPI resource object represents an extended address space
309  * resource and if that's the case, use the information in it to populate the
310  * generic resource object pointed to by @win.
311  *
312  * Return:
313  * 1) false with win->res.flags setting to zero: not the expected resource type
314  * 2) false with IORESOURCE_DISABLED in win->res.flags: valid unassigned
315  *    resource
316  * 3) true: valid assigned resource
317  */
318 bool acpi_dev_resource_ext_address_space(struct acpi_resource *ares,
319 					 struct resource_win *win)
320 {
321 	struct acpi_resource_extended_address64 *ext_addr;
322 
323 	win->res.flags = 0;
324 	if (ares->type != ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64)
325 		return false;
326 
327 	ext_addr = &ares->data.ext_address64;
328 
329 	return acpi_decode_space(win, (struct acpi_resource_address *)ext_addr,
330 				 &ext_addr->address);
331 }
332 EXPORT_SYMBOL_GPL(acpi_dev_resource_ext_address_space);
333 
334 /**
335  * acpi_dev_irq_flags - Determine IRQ resource flags.
336  * @triggering: Triggering type as provided by ACPI.
337  * @polarity: Interrupt polarity as provided by ACPI.
338  * @shareable: Whether or not the interrupt is shareable.
339  * @wake_capable: Wake capability as provided by ACPI.
340  */
341 unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable, u8 wake_capable)
342 {
343 	unsigned long flags;
344 
345 	if (triggering == ACPI_LEVEL_SENSITIVE)
346 		flags = polarity == ACPI_ACTIVE_LOW ?
347 			IORESOURCE_IRQ_LOWLEVEL : IORESOURCE_IRQ_HIGHLEVEL;
348 	else
349 		flags = polarity == ACPI_ACTIVE_LOW ?
350 			IORESOURCE_IRQ_LOWEDGE : IORESOURCE_IRQ_HIGHEDGE;
351 
352 	if (shareable == ACPI_SHARED)
353 		flags |= IORESOURCE_IRQ_SHAREABLE;
354 
355 	if (wake_capable == ACPI_WAKE_CAPABLE)
356 		flags |= IORESOURCE_IRQ_WAKECAPABLE;
357 
358 	return flags | IORESOURCE_IRQ;
359 }
360 EXPORT_SYMBOL_GPL(acpi_dev_irq_flags);
361 
362 /**
363  * acpi_dev_get_irq_type - Determine irq type.
364  * @triggering: Triggering type as provided by ACPI.
365  * @polarity: Interrupt polarity as provided by ACPI.
366  */
367 unsigned int acpi_dev_get_irq_type(int triggering, int polarity)
368 {
369 	switch (polarity) {
370 	case ACPI_ACTIVE_LOW:
371 		return triggering == ACPI_EDGE_SENSITIVE ?
372 		       IRQ_TYPE_EDGE_FALLING :
373 		       IRQ_TYPE_LEVEL_LOW;
374 	case ACPI_ACTIVE_HIGH:
375 		return triggering == ACPI_EDGE_SENSITIVE ?
376 		       IRQ_TYPE_EDGE_RISING :
377 		       IRQ_TYPE_LEVEL_HIGH;
378 	case ACPI_ACTIVE_BOTH:
379 		if (triggering == ACPI_EDGE_SENSITIVE)
380 			return IRQ_TYPE_EDGE_BOTH;
381 		fallthrough;
382 	default:
383 		return IRQ_TYPE_NONE;
384 	}
385 }
386 EXPORT_SYMBOL_GPL(acpi_dev_get_irq_type);
387 
388 static const struct dmi_system_id medion_laptop[] = {
389 	{
390 		.ident = "MEDION P15651",
391 		.matches = {
392 			DMI_MATCH(DMI_SYS_VENDOR, "MEDION"),
393 			DMI_MATCH(DMI_BOARD_NAME, "M15T"),
394 		},
395 	},
396 	{
397 		.ident = "MEDION S17405",
398 		.matches = {
399 			DMI_MATCH(DMI_SYS_VENDOR, "MEDION"),
400 			DMI_MATCH(DMI_BOARD_NAME, "M17T"),
401 		},
402 	},
403 	{ }
404 };
405 
406 static const struct dmi_system_id asus_laptop[] = {
407 	{
408 		.ident = "Asus Vivobook K3402ZA",
409 		.matches = {
410 			DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
411 			DMI_MATCH(DMI_BOARD_NAME, "K3402ZA"),
412 		},
413 	},
414 	{
415 		.ident = "Asus Vivobook K3502ZA",
416 		.matches = {
417 			DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
418 			DMI_MATCH(DMI_BOARD_NAME, "K3502ZA"),
419 		},
420 	},
421 	{
422 		.ident = "Asus Vivobook S5402ZA",
423 		.matches = {
424 			DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
425 			DMI_MATCH(DMI_BOARD_NAME, "S5402ZA"),
426 		},
427 	},
428 	{
429 		.ident = "Asus Vivobook S5602ZA",
430 		.matches = {
431 			DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
432 			DMI_MATCH(DMI_BOARD_NAME, "S5602ZA"),
433 		},
434 	},
435 	{
436 		.ident = "Asus ExpertBook B2402CBA",
437 		.matches = {
438 			DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
439 			DMI_MATCH(DMI_BOARD_NAME, "B2402CBA"),
440 		},
441 	},
442 	{
443 		.ident = "Asus ExpertBook B2402FBA",
444 		.matches = {
445 			DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
446 			DMI_MATCH(DMI_BOARD_NAME, "B2402FBA"),
447 		},
448 	},
449 	{
450 		.ident = "Asus ExpertBook B2502",
451 		.matches = {
452 			DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
453 			DMI_MATCH(DMI_BOARD_NAME, "B2502CBA"),
454 		},
455 	},
456 	{ }
457 };
458 
459 static const struct dmi_system_id lenovo_laptop[] = {
460 	{
461 		.ident = "LENOVO IdeaPad Flex 5 14ALC7",
462 		.matches = {
463 			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
464 			DMI_MATCH(DMI_PRODUCT_NAME, "82R9"),
465 		},
466 	},
467 	{
468 		.ident = "LENOVO IdeaPad Flex 5 16ALC7",
469 		.matches = {
470 			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
471 			DMI_MATCH(DMI_PRODUCT_NAME, "82RA"),
472 		},
473 	},
474 	{ }
475 };
476 
477 static const struct dmi_system_id tongfang_gm_rg[] = {
478 	{
479 		.ident = "TongFang GMxRGxx/XMG CORE 15 (M22)/TUXEDO Stellaris 15 Gen4 AMD",
480 		.matches = {
481 			DMI_MATCH(DMI_BOARD_NAME, "GMxRGxx"),
482 		},
483 	},
484 	{ }
485 };
486 
487 static const struct dmi_system_id maingear_laptop[] = {
488 	{
489 		.ident = "MAINGEAR Vector Pro 2 15",
490 		.matches = {
491 			DMI_MATCH(DMI_SYS_VENDOR, "Micro Electronics Inc"),
492 			DMI_MATCH(DMI_PRODUCT_NAME, "MG-VCP2-15A3070T"),
493 		}
494 	},
495 	{
496 		.ident = "MAINGEAR Vector Pro 2 17",
497 		.matches = {
498 			DMI_MATCH(DMI_SYS_VENDOR, "Micro Electronics Inc"),
499 			DMI_MATCH(DMI_PRODUCT_NAME, "MG-VCP2-17A3070T"),
500 		},
501 	},
502 	{ }
503 };
504 
505 struct irq_override_cmp {
506 	const struct dmi_system_id *system;
507 	unsigned char irq;
508 	unsigned char triggering;
509 	unsigned char polarity;
510 	unsigned char shareable;
511 	bool override;
512 };
513 
514 static const struct irq_override_cmp override_table[] = {
515 	{ medion_laptop, 1, ACPI_LEVEL_SENSITIVE, ACPI_ACTIVE_LOW, 0, false },
516 	{ asus_laptop, 1, ACPI_LEVEL_SENSITIVE, ACPI_ACTIVE_LOW, 0, false },
517 	{ lenovo_laptop, 6, ACPI_LEVEL_SENSITIVE, ACPI_ACTIVE_LOW, 0, true },
518 	{ lenovo_laptop, 10, ACPI_LEVEL_SENSITIVE, ACPI_ACTIVE_LOW, 0, true },
519 	{ tongfang_gm_rg, 1, ACPI_EDGE_SENSITIVE, ACPI_ACTIVE_LOW, 1, true },
520 	{ maingear_laptop, 1, ACPI_EDGE_SENSITIVE, ACPI_ACTIVE_LOW, 1, true },
521 };
522 
523 static bool acpi_dev_irq_override(u32 gsi, u8 triggering, u8 polarity,
524 				  u8 shareable)
525 {
526 	int i;
527 
528 	for (i = 0; i < ARRAY_SIZE(override_table); i++) {
529 		const struct irq_override_cmp *entry = &override_table[i];
530 
531 		if (dmi_check_system(entry->system) &&
532 		    entry->irq == gsi &&
533 		    entry->triggering == triggering &&
534 		    entry->polarity == polarity &&
535 		    entry->shareable == shareable)
536 			return entry->override;
537 	}
538 
539 #ifdef CONFIG_X86
540 	/*
541 	 * IRQ override isn't needed on modern AMD Zen systems and
542 	 * this override breaks active low IRQs on AMD Ryzen 6000 and
543 	 * newer systems. Skip it.
544 	 */
545 	if (boot_cpu_has(X86_FEATURE_ZEN))
546 		return false;
547 #endif
548 
549 	return true;
550 }
551 
552 static void acpi_dev_get_irqresource(struct resource *res, u32 gsi,
553 				     u8 triggering, u8 polarity, u8 shareable,
554 				     u8 wake_capable, bool check_override)
555 {
556 	int irq, p, t;
557 
558 	if (!valid_IRQ(gsi)) {
559 		irqresource_disabled(res, gsi);
560 		return;
561 	}
562 
563 	/*
564 	 * In IO-APIC mode, use overridden attribute. Two reasons:
565 	 * 1. BIOS bug in DSDT
566 	 * 2. BIOS uses IO-APIC mode Interrupt Source Override
567 	 *
568 	 * We do this only if we are dealing with IRQ() or IRQNoFlags()
569 	 * resource (the legacy ISA resources). With modern ACPI 5 devices
570 	 * using extended IRQ descriptors we take the IRQ configuration
571 	 * from _CRS directly.
572 	 */
573 	if (check_override &&
574 	    acpi_dev_irq_override(gsi, triggering, polarity, shareable) &&
575 	    !acpi_get_override_irq(gsi, &t, &p)) {
576 		u8 trig = t ? ACPI_LEVEL_SENSITIVE : ACPI_EDGE_SENSITIVE;
577 		u8 pol = p ? ACPI_ACTIVE_LOW : ACPI_ACTIVE_HIGH;
578 
579 		if (triggering != trig || polarity != pol) {
580 			pr_warn("ACPI: IRQ %d override to %s%s, %s%s\n", gsi,
581 				t ? "level" : "edge",
582 				trig == triggering ? "" : "(!)",
583 				p ? "low" : "high",
584 				pol == polarity ? "" : "(!)");
585 			triggering = trig;
586 			polarity = pol;
587 		}
588 	}
589 
590 	res->flags = acpi_dev_irq_flags(triggering, polarity, shareable, wake_capable);
591 	irq = acpi_register_gsi(NULL, gsi, triggering, polarity);
592 	if (irq >= 0) {
593 		res->start = irq;
594 		res->end = irq;
595 	} else {
596 		irqresource_disabled(res, gsi);
597 	}
598 }
599 
600 /**
601  * acpi_dev_resource_interrupt - Extract ACPI interrupt resource information.
602  * @ares: Input ACPI resource object.
603  * @index: Index into the array of GSIs represented by the resource.
604  * @res: Output generic resource object.
605  *
606  * Check if the given ACPI resource object represents an interrupt resource
607  * and @index does not exceed the resource's interrupt count (true is returned
608  * in that case regardless of the results of the other checks)).  If that's the
609  * case, register the GSI corresponding to @index from the array of interrupts
610  * represented by the resource and populate the generic resource object pointed
611  * to by @res accordingly.  If the registration of the GSI is not successful,
612  * IORESOURCE_DISABLED will be set it that object's flags.
613  *
614  * Return:
615  * 1) false with res->flags setting to zero: not the expected resource type
616  * 2) false with IORESOURCE_DISABLED in res->flags: valid unassigned resource
617  * 3) true: valid assigned resource
618  */
619 bool acpi_dev_resource_interrupt(struct acpi_resource *ares, int index,
620 				 struct resource *res)
621 {
622 	struct acpi_resource_irq *irq;
623 	struct acpi_resource_extended_irq *ext_irq;
624 
625 	switch (ares->type) {
626 	case ACPI_RESOURCE_TYPE_IRQ:
627 		/*
628 		 * Per spec, only one interrupt per descriptor is allowed in
629 		 * _CRS, but some firmware violates this, so parse them all.
630 		 */
631 		irq = &ares->data.irq;
632 		if (index >= irq->interrupt_count) {
633 			irqresource_disabled(res, 0);
634 			return false;
635 		}
636 		acpi_dev_get_irqresource(res, irq->interrupts[index],
637 					 irq->triggering, irq->polarity,
638 					 irq->shareable, irq->wake_capable,
639 					 true);
640 		break;
641 	case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
642 		ext_irq = &ares->data.extended_irq;
643 		if (index >= ext_irq->interrupt_count) {
644 			irqresource_disabled(res, 0);
645 			return false;
646 		}
647 		if (is_gsi(ext_irq))
648 			acpi_dev_get_irqresource(res, ext_irq->interrupts[index],
649 					 ext_irq->triggering, ext_irq->polarity,
650 					 ext_irq->shareable, ext_irq->wake_capable,
651 					 false);
652 		else
653 			irqresource_disabled(res, 0);
654 		break;
655 	default:
656 		res->flags = 0;
657 		return false;
658 	}
659 
660 	return true;
661 }
662 EXPORT_SYMBOL_GPL(acpi_dev_resource_interrupt);
663 
664 /**
665  * acpi_dev_free_resource_list - Free resource from %acpi_dev_get_resources().
666  * @list: The head of the resource list to free.
667  */
668 void acpi_dev_free_resource_list(struct list_head *list)
669 {
670 	resource_list_free(list);
671 }
672 EXPORT_SYMBOL_GPL(acpi_dev_free_resource_list);
673 
674 struct res_proc_context {
675 	struct list_head *list;
676 	int (*preproc)(struct acpi_resource *, void *);
677 	void *preproc_data;
678 	int count;
679 	int error;
680 };
681 
682 static acpi_status acpi_dev_new_resource_entry(struct resource_win *win,
683 					       struct res_proc_context *c)
684 {
685 	struct resource_entry *rentry;
686 
687 	rentry = resource_list_create_entry(NULL, 0);
688 	if (!rentry) {
689 		c->error = -ENOMEM;
690 		return AE_NO_MEMORY;
691 	}
692 	*rentry->res = win->res;
693 	rentry->offset = win->offset;
694 	resource_list_add_tail(rentry, c->list);
695 	c->count++;
696 	return AE_OK;
697 }
698 
699 static acpi_status acpi_dev_process_resource(struct acpi_resource *ares,
700 					     void *context)
701 {
702 	struct res_proc_context *c = context;
703 	struct resource_win win;
704 	struct resource *res = &win.res;
705 	int i;
706 
707 	if (c->preproc) {
708 		int ret;
709 
710 		ret = c->preproc(ares, c->preproc_data);
711 		if (ret < 0) {
712 			c->error = ret;
713 			return AE_ABORT_METHOD;
714 		} else if (ret > 0) {
715 			return AE_OK;
716 		}
717 	}
718 
719 	memset(&win, 0, sizeof(win));
720 
721 	if (acpi_dev_resource_memory(ares, res)
722 	    || acpi_dev_resource_io(ares, res)
723 	    || acpi_dev_resource_address_space(ares, &win)
724 	    || acpi_dev_resource_ext_address_space(ares, &win))
725 		return acpi_dev_new_resource_entry(&win, c);
726 
727 	for (i = 0; acpi_dev_resource_interrupt(ares, i, res); i++) {
728 		acpi_status status;
729 
730 		status = acpi_dev_new_resource_entry(&win, c);
731 		if (ACPI_FAILURE(status))
732 			return status;
733 	}
734 
735 	return AE_OK;
736 }
737 
738 static int __acpi_dev_get_resources(struct acpi_device *adev,
739 				    struct list_head *list,
740 				    int (*preproc)(struct acpi_resource *, void *),
741 				    void *preproc_data, char *method)
742 {
743 	struct res_proc_context c;
744 	acpi_status status;
745 
746 	if (!adev || !adev->handle || !list_empty(list))
747 		return -EINVAL;
748 
749 	if (!acpi_has_method(adev->handle, method))
750 		return 0;
751 
752 	c.list = list;
753 	c.preproc = preproc;
754 	c.preproc_data = preproc_data;
755 	c.count = 0;
756 	c.error = 0;
757 	status = acpi_walk_resources(adev->handle, method,
758 				     acpi_dev_process_resource, &c);
759 	if (ACPI_FAILURE(status)) {
760 		acpi_dev_free_resource_list(list);
761 		return c.error ? c.error : -EIO;
762 	}
763 
764 	return c.count;
765 }
766 
767 /**
768  * acpi_dev_get_resources - Get current resources of a device.
769  * @adev: ACPI device node to get the resources for.
770  * @list: Head of the resultant list of resources (must be empty).
771  * @preproc: The caller's preprocessing routine.
772  * @preproc_data: Pointer passed to the caller's preprocessing routine.
773  *
774  * Evaluate the _CRS method for the given device node and process its output by
775  * (1) executing the @preproc() routine provided by the caller, passing the
776  * resource pointer and @preproc_data to it as arguments, for each ACPI resource
777  * returned and (2) converting all of the returned ACPI resources into struct
778  * resource objects if possible.  If the return value of @preproc() in step (1)
779  * is different from 0, step (2) is not applied to the given ACPI resource and
780  * if that value is negative, the whole processing is aborted and that value is
781  * returned as the final error code.
782  *
783  * The resultant struct resource objects are put on the list pointed to by
784  * @list, that must be empty initially, as members of struct resource_entry
785  * objects.  Callers of this routine should use %acpi_dev_free_resource_list() to
786  * free that list.
787  *
788  * The number of resources in the output list is returned on success, an error
789  * code reflecting the error condition is returned otherwise.
790  */
791 int acpi_dev_get_resources(struct acpi_device *adev, struct list_head *list,
792 			   int (*preproc)(struct acpi_resource *, void *),
793 			   void *preproc_data)
794 {
795 	return __acpi_dev_get_resources(adev, list, preproc, preproc_data,
796 					METHOD_NAME__CRS);
797 }
798 EXPORT_SYMBOL_GPL(acpi_dev_get_resources);
799 
800 static int is_memory(struct acpi_resource *ares, void *not_used)
801 {
802 	struct resource_win win;
803 	struct resource *res = &win.res;
804 
805 	memset(&win, 0, sizeof(win));
806 
807 	if (acpi_dev_filter_resource_type(ares, IORESOURCE_MEM))
808 		return 1;
809 
810 	return !(acpi_dev_resource_memory(ares, res)
811 	       || acpi_dev_resource_address_space(ares, &win)
812 	       || acpi_dev_resource_ext_address_space(ares, &win));
813 }
814 
815 /**
816  * acpi_dev_get_dma_resources - Get current DMA resources of a device.
817  * @adev: ACPI device node to get the resources for.
818  * @list: Head of the resultant list of resources (must be empty).
819  *
820  * Evaluate the _DMA method for the given device node and process its
821  * output.
822  *
823  * The resultant struct resource objects are put on the list pointed to
824  * by @list, that must be empty initially, as members of struct
825  * resource_entry objects.  Callers of this routine should use
826  * %acpi_dev_free_resource_list() to free that list.
827  *
828  * The number of resources in the output list is returned on success,
829  * an error code reflecting the error condition is returned otherwise.
830  */
831 int acpi_dev_get_dma_resources(struct acpi_device *adev, struct list_head *list)
832 {
833 	return __acpi_dev_get_resources(adev, list, is_memory, NULL,
834 					METHOD_NAME__DMA);
835 }
836 EXPORT_SYMBOL_GPL(acpi_dev_get_dma_resources);
837 
838 /**
839  * acpi_dev_get_memory_resources - Get current memory resources of a device.
840  * @adev: ACPI device node to get the resources for.
841  * @list: Head of the resultant list of resources (must be empty).
842  *
843  * This is a helper function that locates all memory type resources of @adev
844  * with acpi_dev_get_resources().
845  *
846  * The number of resources in the output list is returned on success, an error
847  * code reflecting the error condition is returned otherwise.
848  */
849 int acpi_dev_get_memory_resources(struct acpi_device *adev, struct list_head *list)
850 {
851 	return acpi_dev_get_resources(adev, list, is_memory, NULL);
852 }
853 EXPORT_SYMBOL_GPL(acpi_dev_get_memory_resources);
854 
855 /**
856  * acpi_dev_filter_resource_type - Filter ACPI resource according to resource
857  *				   types
858  * @ares: Input ACPI resource object.
859  * @types: Valid resource types of IORESOURCE_XXX
860  *
861  * This is a helper function to support acpi_dev_get_resources(), which filters
862  * ACPI resource objects according to resource types.
863  */
864 int acpi_dev_filter_resource_type(struct acpi_resource *ares,
865 				  unsigned long types)
866 {
867 	unsigned long type = 0;
868 
869 	switch (ares->type) {
870 	case ACPI_RESOURCE_TYPE_MEMORY24:
871 	case ACPI_RESOURCE_TYPE_MEMORY32:
872 	case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
873 		type = IORESOURCE_MEM;
874 		break;
875 	case ACPI_RESOURCE_TYPE_IO:
876 	case ACPI_RESOURCE_TYPE_FIXED_IO:
877 		type = IORESOURCE_IO;
878 		break;
879 	case ACPI_RESOURCE_TYPE_IRQ:
880 	case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
881 		type = IORESOURCE_IRQ;
882 		break;
883 	case ACPI_RESOURCE_TYPE_DMA:
884 	case ACPI_RESOURCE_TYPE_FIXED_DMA:
885 		type = IORESOURCE_DMA;
886 		break;
887 	case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
888 		type = IORESOURCE_REG;
889 		break;
890 	case ACPI_RESOURCE_TYPE_ADDRESS16:
891 	case ACPI_RESOURCE_TYPE_ADDRESS32:
892 	case ACPI_RESOURCE_TYPE_ADDRESS64:
893 	case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
894 		if (ares->data.address.resource_type == ACPI_MEMORY_RANGE)
895 			type = IORESOURCE_MEM;
896 		else if (ares->data.address.resource_type == ACPI_IO_RANGE)
897 			type = IORESOURCE_IO;
898 		else if (ares->data.address.resource_type ==
899 			 ACPI_BUS_NUMBER_RANGE)
900 			type = IORESOURCE_BUS;
901 		break;
902 	default:
903 		break;
904 	}
905 
906 	return (type & types) ? 0 : 1;
907 }
908 EXPORT_SYMBOL_GPL(acpi_dev_filter_resource_type);
909 
910 static int acpi_dev_consumes_res(struct acpi_device *adev, struct resource *res)
911 {
912 	struct list_head resource_list;
913 	struct resource_entry *rentry;
914 	int ret, found = 0;
915 
916 	INIT_LIST_HEAD(&resource_list);
917 	ret = acpi_dev_get_resources(adev, &resource_list, NULL, NULL);
918 	if (ret < 0)
919 		return 0;
920 
921 	list_for_each_entry(rentry, &resource_list, node) {
922 		if (resource_contains(rentry->res, res)) {
923 			found = 1;
924 			break;
925 		}
926 
927 	}
928 
929 	acpi_dev_free_resource_list(&resource_list);
930 	return found;
931 }
932 
933 static acpi_status acpi_res_consumer_cb(acpi_handle handle, u32 depth,
934 					 void *context, void **ret)
935 {
936 	struct resource *res = context;
937 	struct acpi_device **consumer = (struct acpi_device **) ret;
938 	struct acpi_device *adev = acpi_fetch_acpi_dev(handle);
939 
940 	if (!adev)
941 		return AE_OK;
942 
943 	if (acpi_dev_consumes_res(adev, res)) {
944 		*consumer = adev;
945 		return AE_CTRL_TERMINATE;
946 	}
947 
948 	return AE_OK;
949 }
950 
951 /**
952  * acpi_resource_consumer - Find the ACPI device that consumes @res.
953  * @res: Resource to search for.
954  *
955  * Search the current resource settings (_CRS) of every ACPI device node
956  * for @res.  If we find an ACPI device whose _CRS includes @res, return
957  * it.  Otherwise, return NULL.
958  */
959 struct acpi_device *acpi_resource_consumer(struct resource *res)
960 {
961 	struct acpi_device *consumer = NULL;
962 
963 	acpi_get_devices(NULL, acpi_res_consumer_cb, res, (void **) &consumer);
964 	return consumer;
965 }
966