/drivers/acpi/utils.c

  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 *  acpi_utils.c - ACPI Utility Functions ($Revision: 10 $)
  4 *
  5 *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
  6 *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
  7 */
  8
  9#include <linux/kernel.h>
 10#include <linux/module.h>
 11#include <linux/slab.h>
 12#include <linux/init.h>
 13#include <linux/types.h>
 14#include <linux/hardirq.h>
 15#include <linux/acpi.h>
 16#include <linux/dynamic_debug.h>
 17
 18#include "internal.h"
 19#include "sleep.h"
 20
 21#define _COMPONENT		ACPI_BUS_COMPONENT
 22ACPI_MODULE_NAME("utils");
 23
 24/* --------------------------------------------------------------------------
 25                            Object Evaluation Helpers
 26   -------------------------------------------------------------------------- */
 27static void
 28acpi_util_eval_error(acpi_handle h, acpi_string p, acpi_status s)
 29{
 30#ifdef ACPI_DEBUG_OUTPUT
 31	char prefix[80] = {'\0'};
 32	struct acpi_buffer buffer = {sizeof(prefix), prefix};
 33	acpi_get_name(h, ACPI_FULL_PATHNAME, &buffer);
 34	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluate [%s.%s]: %s\n",
 35		(char *) prefix, p, acpi_format_exception(s)));
 36#else
 37	return;
 38#endif
 39}
 40
 41acpi_status
 42acpi_extract_package(union acpi_object *package,
 43		     struct acpi_buffer *format, struct acpi_buffer *buffer)
 44{
 45	u32 size_required = 0;
 46	u32 tail_offset = 0;
 47	char *format_string = NULL;
 48	u32 format_count = 0;
 49	u32 i = 0;
 50	u8 *head = NULL;
 51	u8 *tail = NULL;
 52
 53
 54	if (!package || (package->type != ACPI_TYPE_PACKAGE)
 55	    || (package->package.count < 1)) {
 56		printk(KERN_WARNING PREFIX "Invalid package argument\n");
 57		return AE_BAD_PARAMETER;
 58	}
 59
 60	if (!format || !format->pointer || (format->length < 1)) {
 61		printk(KERN_WARNING PREFIX "Invalid format argument\n");
 62		return AE_BAD_PARAMETER;
 63	}
 64
 65	if (!buffer) {
 66		printk(KERN_WARNING PREFIX "Invalid buffer argument\n");
 67		return AE_BAD_PARAMETER;
 68	}
 69
 70	format_count = (format->length / sizeof(char)) - 1;
 71	if (format_count > package->package.count) {
 72		printk(KERN_WARNING PREFIX "Format specifies more objects [%d]"
 73			      " than exist in package [%d].\n",
 74			      format_count, package->package.count);
 75		return AE_BAD_DATA;
 76	}
 77
 78	format_string = format->pointer;
 79
 80	/*
 81	 * Calculate size_required.
 82	 */
 83	for (i = 0; i < format_count; i++) {
 84
 85		union acpi_object *element = &(package->package.elements[i]);
 86
 87		switch (element->type) {
 88
 89		case ACPI_TYPE_INTEGER:
 90			switch (format_string[i]) {
 91			case 'N':
 92				size_required += sizeof(u64);
 93				tail_offset += sizeof(u64);
 94				break;
 95			case 'S':
 96				size_required +=
 97				    sizeof(char *) + sizeof(u64) +
 98				    sizeof(char);
 99				tail_offset += sizeof(char *);
100				break;
101			default:
102				printk(KERN_WARNING PREFIX "Invalid package element"
103					      " [%d]: got number, expecting"
104					      " [%c]\n",
105					      i, format_string[i]);
106				return AE_BAD_DATA;
107				break;
108			}
109			break;
110
111		case ACPI_TYPE_STRING:
112		case ACPI_TYPE_BUFFER:
113			switch (format_string[i]) {
114			case 'S':
115				size_required +=
116				    sizeof(char *) +
117				    (element->string.length * sizeof(char)) +
118				    sizeof(char);
119				tail_offset += sizeof(char *);
120				break;
121			case 'B':
122				size_required +=
123				    sizeof(u8 *) + element->buffer.length;
124				tail_offset += sizeof(u8 *);
125				break;
126			default:
127				printk(KERN_WARNING PREFIX "Invalid package element"
128					      " [%d] got string/buffer,"
129					      " expecting [%c]\n",
130					      i, format_string[i]);
131				return AE_BAD_DATA;
132				break;
133			}
134			break;
135		case ACPI_TYPE_LOCAL_REFERENCE:
136			switch (format_string[i]) {
137			case 'R':
138				size_required += sizeof(void *);
139				tail_offset += sizeof(void *);
140				break;
141			default:
142				printk(KERN_WARNING PREFIX "Invalid package element"
143					      " [%d] got reference,"
144					      " expecting [%c]\n",
145					      i, format_string[i]);
146				return AE_BAD_DATA;
147				break;
148			}
149			break;
150
151		case ACPI_TYPE_PACKAGE:
152		default:
153			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
154					  "Found unsupported element at index=%d\n",
155					  i));
156			/* TBD: handle nested packages... */
157			return AE_SUPPORT;
158			break;
159		}
160	}
161
162	/*
163	 * Validate output buffer.
164	 */
165	if (buffer->length == ACPI_ALLOCATE_BUFFER) {
166		buffer->pointer = ACPI_ALLOCATE_ZEROED(size_required);
167		if (!buffer->pointer)
168			return AE_NO_MEMORY;
169		buffer->length = size_required;
170	} else {
171		if (buffer->length < size_required) {
172			buffer->length = size_required;
173			return AE_BUFFER_OVERFLOW;
174		} else if (buffer->length != size_required ||
175			   !buffer->pointer) {
176			return AE_BAD_PARAMETER;
177		}
178	}
179
180	head = buffer->pointer;
181	tail = buffer->pointer + tail_offset;
182
183	/*
184	 * Extract package data.
185	 */
186	for (i = 0; i < format_count; i++) {
187
188		u8 **pointer = NULL;
189		union acpi_object *element = &(package->package.elements[i]);
190
191		switch (element->type) {
192
193		case ACPI_TYPE_INTEGER:
194			switch (format_string[i]) {
195			case 'N':
196				*((u64 *) head) =
197				    element->integer.value;
198				head += sizeof(u64);
199				break;
200			case 'S':
201				pointer = (u8 **) head;
202				*pointer = tail;
203				*((u64 *) tail) =
204				    element->integer.value;
205				head += sizeof(u64 *);
206				tail += sizeof(u64);
207				/* NULL terminate string */
208				*tail = (char)0;
209				tail += sizeof(char);
210				break;
211			default:
212				/* Should never get here */
213				break;
214			}
215			break;
216
217		case ACPI_TYPE_STRING:
218		case ACPI_TYPE_BUFFER:
219			switch (format_string[i]) {
220			case 'S':
221				pointer = (u8 **) head;
222				*pointer = tail;
223				memcpy(tail, element->string.pointer,
224				       element->string.length);
225				head += sizeof(char *);
226				tail += element->string.length * sizeof(char);
227				/* NULL terminate string */
228				*tail = (char)0;
229				tail += sizeof(char);
230				break;
231			case 'B':
232				pointer = (u8 **) head;
233				*pointer = tail;
234				memcpy(tail, element->buffer.pointer,
235				       element->buffer.length);
236				head += sizeof(u8 *);
237				tail += element->buffer.length;
238				break;
239			default:
240				/* Should never get here */
241				break;
242			}
243			break;
244		case ACPI_TYPE_LOCAL_REFERENCE:
245			switch (format_string[i]) {
246			case 'R':
247				*(void **)head =
248				    (void *)element->reference.handle;
249				head += sizeof(void *);
250				break;
251			default:
252				/* Should never get here */
253				break;
254			}
255			break;
256		case ACPI_TYPE_PACKAGE:
257			/* TBD: handle nested packages... */
258		default:
259			/* Should never get here */
260			break;
261		}
262	}
263
264	return AE_OK;
265}
266
267EXPORT_SYMBOL(acpi_extract_package);
268
269acpi_status
270acpi_evaluate_integer(acpi_handle handle,
271		      acpi_string pathname,
272		      struct acpi_object_list *arguments, unsigned long long *data)
273{
274	acpi_status status = AE_OK;
275	union acpi_object element;
276	struct acpi_buffer buffer = { 0, NULL };
277
278	if (!data)
279		return AE_BAD_PARAMETER;
280
281	buffer.length = sizeof(union acpi_object);
282	buffer.pointer = &element;
283	status = acpi_evaluate_object(handle, pathname, arguments, &buffer);
284	if (ACPI_FAILURE(status)) {
285		acpi_util_eval_error(handle, pathname, status);
286		return status;
287	}
288
289	if (element.type != ACPI_TYPE_INTEGER) {
290		acpi_util_eval_error(handle, pathname, AE_BAD_DATA);
291		return AE_BAD_DATA;
292	}
293
294	*data = element.integer.value;
295
296	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Return value [%llu]\n", *data));
297
298	return AE_OK;
299}
300
301EXPORT_SYMBOL(acpi_evaluate_integer);
302
303acpi_status
304acpi_evaluate_reference(acpi_handle handle,
305			acpi_string pathname,
306			struct acpi_object_list *arguments,
307			struct acpi_handle_list *list)
308{
309	acpi_status status = AE_OK;
310	union acpi_object *package = NULL;
311	union acpi_object *element = NULL;
312	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
313	u32 i = 0;
314
315
316	if (!list) {
317		return AE_BAD_PARAMETER;
318	}
319
320	/* Evaluate object. */
321
322	status = acpi_evaluate_object(handle, pathname, arguments, &buffer);
323	if (ACPI_FAILURE(status))
324		goto end;
325
326	package = buffer.pointer;
327
328	if ((buffer.length == 0) || !package) {
329		status = AE_BAD_DATA;
330		acpi_util_eval_error(handle, pathname, status);
331		goto end;
332	}
333	if (package->type != ACPI_TYPE_PACKAGE) {
334		status = AE_BAD_DATA;
335		acpi_util_eval_error(handle, pathname, status);
336		goto end;
337	}
338	if (!package->package.count) {
339		status = AE_BAD_DATA;
340		acpi_util_eval_error(handle, pathname, status);
341		goto end;
342	}
343
344	if (package->package.count > ACPI_MAX_HANDLES) {
345		kfree(package);
346		return AE_NO_MEMORY;
347	}
348	list->count = package->package.count;
349
350	/* Extract package data. */
351
352	for (i = 0; i < list->count; i++) {
353
354		element = &(package->package.elements[i]);
355
356		if (element->type != ACPI_TYPE_LOCAL_REFERENCE) {
357			status = AE_BAD_DATA;
358			acpi_util_eval_error(handle, pathname, status);
359			break;
360		}
361
362		if (!element->reference.handle) {
363			status = AE_NULL_ENTRY;
364			acpi_util_eval_error(handle, pathname, status);
365			break;
366		}
367		/* Get the  acpi_handle. */
368
369		list->handles[i] = element->reference.handle;
370		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found reference [%p]\n",
371				  list->handles[i]));
372	}
373
374      end:
375	if (ACPI_FAILURE(status)) {
376		list->count = 0;
377		//kfree(list->handles);
378	}
379
380	kfree(buffer.pointer);
381
382	return status;
383}
384
385EXPORT_SYMBOL(acpi_evaluate_reference);
386
387acpi_status
388acpi_get_physical_device_location(acpi_handle handle, struct acpi_pld_info **pld)
389{
390	acpi_status status;
391	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
392	union acpi_object *output;
393
394	status = acpi_evaluate_object(handle, "_PLD", NULL, &buffer);
395
396	if (ACPI_FAILURE(status))
397		return status;
398
399	output = buffer.pointer;
400
401	if (!output || output->type != ACPI_TYPE_PACKAGE
402	    || !output->package.count
403	    || output->package.elements[0].type != ACPI_TYPE_BUFFER
404	    || output->package.elements[0].buffer.length < ACPI_PLD_REV1_BUFFER_SIZE) {
405		status = AE_TYPE;
406		goto out;
407	}
408
409	status = acpi_decode_pld_buffer(
410			output->package.elements[0].buffer.pointer,
411			output->package.elements[0].buffer.length,
412			pld);
413
414out:
415	kfree(buffer.pointer);
416	return status;
417}
418EXPORT_SYMBOL(acpi_get_physical_device_location);
419
420/**
421 * acpi_evaluate_ost: Evaluate _OST for hotplug operations
422 * @handle: ACPI device handle
423 * @source_event: source event code
424 * @status_code: status code
425 * @status_buf: optional detailed information (NULL if none)
426 *
427 * Evaluate _OST for hotplug operations. All ACPI hotplug handlers
428 * must call this function when evaluating _OST for hotplug operations.
429 * When the platform does not support _OST, this function has no effect.
430 */
431acpi_status
432acpi_evaluate_ost(acpi_handle handle, u32 source_event, u32 status_code,
433		  struct acpi_buffer *status_buf)
434{
435	union acpi_object params[3] = {
436		{.type = ACPI_TYPE_INTEGER,},
437		{.type = ACPI_TYPE_INTEGER,},
438		{.type = ACPI_TYPE_BUFFER,}
439	};
440	struct acpi_object_list arg_list = {3, params};
441
442	params[0].integer.value = source_event;
443	params[1].integer.value = status_code;
444	if (status_buf != NULL) {
445		params[2].buffer.pointer = status_buf->pointer;
446		params[2].buffer.length = status_buf->length;
447	} else {
448		params[2].buffer.pointer = NULL;
449		params[2].buffer.length = 0;
450	}
451
452	return acpi_evaluate_object(handle, "_OST", &arg_list, NULL);
453}
454EXPORT_SYMBOL(acpi_evaluate_ost);
455
456/**
457 * acpi_handle_path: Return the object path of handle
458 * @handle: ACPI device handle
459 *
460 * Caller must free the returned buffer
461 */
462static char *acpi_handle_path(acpi_handle handle)
463{
464	struct acpi_buffer buffer = {
465		.length = ACPI_ALLOCATE_BUFFER,
466		.pointer = NULL
467	};
468
469	if (in_interrupt() ||
470	    acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer) != AE_OK)
471		return NULL;
472	return buffer.pointer;
473}
474
475/**
476 * acpi_handle_printk: Print message with ACPI prefix and object path
477 * @level: log level
478 * @handle: ACPI device handle
479 * @fmt: format string
480 *
481 * This function is called through acpi_handle_<level> macros and prints
482 * a message with ACPI prefix and object path.  This function acquires
483 * the global namespace mutex to obtain an object path.  In interrupt
484 * context, it shows the object path as <n/a>.
485 */
486void
487acpi_handle_printk(const char *level, acpi_handle handle, const char *fmt, ...)
488{
489	struct va_format vaf;
490	va_list args;
491	const char *path;
492
493	va_start(args, fmt);
494	vaf.fmt = fmt;
495	vaf.va = &args;
496
497	path = acpi_handle_path(handle);
498	printk("%sACPI: %s: %pV", level, path ? path : "<n/a>" , &vaf);
499
500	va_end(args);
501	kfree(path);
502}
503EXPORT_SYMBOL(acpi_handle_printk);
504
505#if defined(CONFIG_DYNAMIC_DEBUG)
506/**
507 * __acpi_handle_debug: pr_debug with ACPI prefix and object path
508 * @descriptor: Dynamic Debug descriptor
509 * @handle: ACPI device handle
510 * @fmt: format string
511 *
512 * This function is called through acpi_handle_debug macro and debug
513 * prints a message with ACPI prefix and object path. This function
514 * acquires the global namespace mutex to obtain an object path.  In
515 * interrupt context, it shows the object path as <n/a>.
516 */
517void
518__acpi_handle_debug(struct _ddebug *descriptor, acpi_handle handle,
519		    const char *fmt, ...)
520{
521	struct va_format vaf;
522	va_list args;
523	const char *path;
524
525	va_start(args, fmt);
526	vaf.fmt = fmt;
527	vaf.va = &args;
528
529	path = acpi_handle_path(handle);
530	__dynamic_pr_debug(descriptor, "ACPI: %s: %pV", path ? path : "<n/a>", &vaf);
531
532	va_end(args);
533	kfree(path);
534}
535EXPORT_SYMBOL(__acpi_handle_debug);
536#endif
537
538/**
539 * acpi_has_method: Check whether @handle has a method named @name
540 * @handle: ACPI device handle
541 * @name: name of object or method
542 *
543 * Check whether @handle has a method named @name.
544 */
545bool acpi_has_method(acpi_handle handle, char *name)
546{
547	acpi_handle tmp;
548
549	return ACPI_SUCCESS(acpi_get_handle(handle, name, &tmp));
550}
551EXPORT_SYMBOL(acpi_has_method);
552
553acpi_status acpi_execute_simple_method(acpi_handle handle, char *method,
554				       u64 arg)
555{
556	union acpi_object obj = { .type = ACPI_TYPE_INTEGER };
557	struct acpi_object_list arg_list = { .count = 1, .pointer = &obj, };
558
559	obj.integer.value = arg;
560
561	return acpi_evaluate_object(handle, method, &arg_list, NULL);
562}
563EXPORT_SYMBOL(acpi_execute_simple_method);
564
565/**
566 * acpi_evaluate_ej0: Evaluate _EJ0 method for hotplug operations
567 * @handle: ACPI device handle
568 *
569 * Evaluate device's _EJ0 method for hotplug operations.
570 */
571acpi_status acpi_evaluate_ej0(acpi_handle handle)
572{
573	acpi_status status;
574
575	status = acpi_execute_simple_method(handle, "_EJ0", 1);
576	if (status == AE_NOT_FOUND)
577		acpi_handle_warn(handle, "No _EJ0 support for device\n");
578	else if (ACPI_FAILURE(status))
579		acpi_handle_warn(handle, "Eject failed (0x%x)\n", status);
580
581	return status;
582}
583
584/**
585 * acpi_evaluate_lck: Evaluate _LCK method to lock/unlock device
586 * @handle: ACPI device handle
587 * @lock: lock device if non-zero, otherwise unlock device
588 *
589 * Evaluate device's _LCK method if present to lock/unlock device
590 */
591acpi_status acpi_evaluate_lck(acpi_handle handle, int lock)
592{
593	acpi_status status;
594
595	status = acpi_execute_simple_method(handle, "_LCK", !!lock);
596	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
597		if (lock)
598			acpi_handle_warn(handle,
599				"Locking device failed (0x%x)\n", status);
600		else
601			acpi_handle_warn(handle,
602				"Unlocking device failed (0x%x)\n", status);
603	}
604
605	return status;
606}
607
608/**
609 * acpi_evaluate_dsm - evaluate device's _DSM method
610 * @handle: ACPI device handle
611 * @guid: GUID of requested functions, should be 16 bytes
612 * @rev: revision number of requested function
613 * @func: requested function number
614 * @argv4: the function specific parameter
615 *
616 * Evaluate device's _DSM method with specified GUID, revision id and
617 * function number. Caller needs to free the returned object.
618 *
619 * Though ACPI defines the fourth parameter for _DSM should be a package,
620 * some old BIOSes do expect a buffer or an integer etc.
621 */
622union acpi_object *
623acpi_evaluate_dsm(acpi_handle handle, const guid_t *guid, u64 rev, u64 func,
624		  union acpi_object *argv4)
625{
626	acpi_status ret;
627	struct acpi_buffer buf = {ACPI_ALLOCATE_BUFFER, NULL};
628	union acpi_object params[4];
629	struct acpi_object_list input = {
630		.count = 4,
631		.pointer = params,
632	};
633
634	params[0].type = ACPI_TYPE_BUFFER;
635	params[0].buffer.length = 16;
636	params[0].buffer.pointer = (u8 *)guid;
637	params[1].type = ACPI_TYPE_INTEGER;
638	params[1].integer.value = rev;
639	params[2].type = ACPI_TYPE_INTEGER;
640	params[2].integer.value = func;
641	if (argv4) {
642		params[3] = *argv4;
643	} else {
644		params[3].type = ACPI_TYPE_PACKAGE;
645		params[3].package.count = 0;
646		params[3].package.elements = NULL;
647	}
648
649	ret = acpi_evaluate_object(handle, "_DSM", &input, &buf);
650	if (ACPI_SUCCESS(ret))
651		return (union acpi_object *)buf.pointer;
652
653	if (ret != AE_NOT_FOUND)
654		acpi_handle_warn(handle,
655				"failed to evaluate _DSM (0x%x)\n", ret);
656
657	return NULL;
658}
659EXPORT_SYMBOL(acpi_evaluate_dsm);
660
661/**
662 * acpi_check_dsm - check if _DSM method supports requested functions.
663 * @handle: ACPI device handle
664 * @guid: GUID of requested functions, should be 16 bytes at least
665 * @rev: revision number of requested functions
666 * @funcs: bitmap of requested functions
667 *
668 * Evaluate device's _DSM method to check whether it supports requested
669 * functions. Currently only support 64 functions at maximum, should be
670 * enough for now.
671 */
672bool acpi_check_dsm(acpi_handle handle, const guid_t *guid, u64 rev, u64 funcs)
673{
674	int i;
675	u64 mask = 0;
676	union acpi_object *obj;
677
678	if (funcs == 0)
679		return false;
680
681	obj = acpi_evaluate_dsm(handle, guid, rev, 0, NULL);
682	if (!obj)
683		return false;
684
685	/* For compatibility, old BIOSes may return an integer */
686	if (obj->type == ACPI_TYPE_INTEGER)
687		mask = obj->integer.value;
688	else if (obj->type == ACPI_TYPE_BUFFER)
689		for (i = 0; i < obj->buffer.length && i < 8; i++)
690			mask |= (((u64)obj->buffer.pointer[i]) << (i * 8));
691	ACPI_FREE(obj);
692
693	/*
694	 * Bit 0 indicates whether there's support for any functions other than
695	 * function 0 for the specified GUID and revision.
696	 */
697	if ((mask & 0x1) && (mask & funcs) == funcs)
698		return true;
699
700	return false;
701}
702EXPORT_SYMBOL(acpi_check_dsm);
703
704/**
705 * acpi_dev_hid_uid_match - Match device by supplied HID and UID
706 * @adev: ACPI device to match.
707 * @hid2: Hardware ID of the device.
708 * @uid2: Unique ID of the device, pass NULL to not check _UID.
709 *
710 * Matches HID and UID in @adev with given @hid2 and @uid2.
711 * Returns true if matches.
712 */
713bool acpi_dev_hid_uid_match(struct acpi_device *adev,
714			    const char *hid2, const char *uid2)
715{
716	const char *hid1 = acpi_device_hid(adev);
717	const char *uid1 = acpi_device_uid(adev);
718
719	if (strcmp(hid1, hid2))
720		return false;
721
722	if (!uid2)
723		return true;
724
725	return uid1 && !strcmp(uid1, uid2);
726}
727EXPORT_SYMBOL(acpi_dev_hid_uid_match);
728
729/**
730 * acpi_dev_found - Detect presence of a given ACPI device in the namespace.
731 * @hid: Hardware ID of the device.
732 *
733 * Return %true if the device was present at the moment of invocation.
734 * Note that if the device is pluggable, it may since have disappeared.
735 *
736 * For this function to work, acpi_bus_scan() must have been executed
737 * which happens in the subsys_initcall() subsection. Hence, do not
738 * call from a subsys_initcall() or earlier (use acpi_get_devices()
739 * instead). Calling from module_init() is fine (which is synonymous
740 * with device_initcall()).
741 */
742bool acpi_dev_found(const char *hid)
743{
744	struct acpi_device_bus_id *acpi_device_bus_id;
745	bool found = false;
746
747	mutex_lock(&acpi_device_lock);
748	list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node)
749		if (!strcmp(acpi_device_bus_id->bus_id, hid)) {
750			found = true;
751			break;
752		}
753	mutex_unlock(&acpi_device_lock);
754
755	return found;
756}
757EXPORT_SYMBOL(acpi_dev_found);
758
759struct acpi_dev_match_info {
760	struct acpi_device_id hid[2];
761	const char *uid;
762	s64 hrv;
763};
764
765static int acpi_dev_match_cb(struct device *dev, const void *data)
766{
767	struct acpi_device *adev = to_acpi_device(dev);
768	const struct acpi_dev_match_info *match = data;
769	unsigned long long hrv;
770	acpi_status status;
771
772	if (acpi_match_device_ids(adev, match->hid))
773		return 0;
774
775	if (match->uid && (!adev->pnp.unique_id ||
776	    strcmp(adev->pnp.unique_id, match->uid)))
777		return 0;
778
779	if (match->hrv == -1)
780		return 1;
781
782	status = acpi_evaluate_integer(adev->handle, "_HRV", NULL, &hrv);
783	if (ACPI_FAILURE(status))
784		return 0;
785
786	return hrv == match->hrv;
787}
788
789/**
790 * acpi_dev_present - Detect that a given ACPI device is present
791 * @hid: Hardware ID of the device.
792 * @uid: Unique ID of the device, pass NULL to not check _UID
793 * @hrv: Hardware Revision of the device, pass -1 to not check _HRV
794 *
795 * Return %true if a matching device was present at the moment of invocation.
796 * Note that if the device is pluggable, it may since have disappeared.
797 *
798 * Note that unlike acpi_dev_found() this function checks the status
799 * of the device. So for devices which are present in the dsdt, but
800 * which are disabled (their _STA callback returns 0) this function
801 * will return false.
802 *
803 * For this function to work, acpi_bus_scan() must have been executed
804 * which happens in the subsys_initcall() subsection. Hence, do not
805 * call from a subsys_initcall() or earlier (use acpi_get_devices()
806 * instead). Calling from module_init() is fine (which is synonymous
807 * with device_initcall()).
808 */
809bool acpi_dev_present(const char *hid, const char *uid, s64 hrv)
810{
811	struct acpi_dev_match_info match = {};
812	struct device *dev;
813
814	strlcpy(match.hid[0].id, hid, sizeof(match.hid[0].id));
815	match.uid = uid;
816	match.hrv = hrv;
817
818	dev = bus_find_device(&acpi_bus_type, NULL, &match, acpi_dev_match_cb);
819	put_device(dev);
820	return !!dev;
821}
822EXPORT_SYMBOL(acpi_dev_present);
823
824/**
825 * acpi_dev_get_first_match_dev - Return the first match of ACPI device
826 * @hid: Hardware ID of the device.
827 * @uid: Unique ID of the device, pass NULL to not check _UID
828 * @hrv: Hardware Revision of the device, pass -1 to not check _HRV
829 *
830 * Return the first match of ACPI device if a matching device was present
831 * at the moment of invocation, or NULL otherwise.
832 *
833 * The caller is responsible to call put_device() on the returned device.
834 *
835 * See additional information in acpi_dev_present() as well.
836 */
837struct acpi_device *
838acpi_dev_get_first_match_dev(const char *hid, const char *uid, s64 hrv)
839{
840	struct acpi_dev_match_info match = {};
841	struct device *dev;
842
843	strlcpy(match.hid[0].id, hid, sizeof(match.hid[0].id));
844	match.uid = uid;
845	match.hrv = hrv;
846
847	dev = bus_find_device(&acpi_bus_type, NULL, &match, acpi_dev_match_cb);
848	return dev ? to_acpi_device(dev) : NULL;
849}
850EXPORT_SYMBOL(acpi_dev_get_first_match_dev);
851
852/*
853 * acpi_backlight= handling, this is done here rather then in video_detect.c
854 * because __setup cannot be used in modules.
855 */
856char acpi_video_backlight_string[16];
857EXPORT_SYMBOL(acpi_video_backlight_string);
858
859static int __init acpi_backlight(char *str)
860{
861	strlcpy(acpi_video_backlight_string, str,
862		sizeof(acpi_video_backlight_string));
863	return 1;
864}
865__setup("acpi_backlight=", acpi_backlight);
866
867/**
868 * acpi_match_platform_list - Check if the system matches with a given list
869 * @plat: pointer to acpi_platform_list table terminated by a NULL entry
870 *
871 * Return the matched index if the system is found in the platform list.
872 * Otherwise, return a negative error code.
873 */
874int acpi_match_platform_list(const struct acpi_platform_list *plat)
875{
876	struct acpi_table_header hdr;
877	int idx = 0;
878
879	if (acpi_disabled)
880		return -ENODEV;
881
882	for (; plat->oem_id[0]; plat++, idx++) {
883		if (ACPI_FAILURE(acpi_get_table_header(plat->table, 0, &hdr)))
884			continue;
885
886		if (strncmp(plat->oem_id, hdr.oem_id, ACPI_OEM_ID_SIZE))
887			continue;
888
889		if (strncmp(plat->oem_table_id, hdr.oem_table_id, ACPI_OEM_TABLE_ID_SIZE))
890			continue;
891
892		if ((plat->pred == all_versions) ||
893		    (plat->pred == less_than_or_equal && hdr.oem_revision <= plat->oem_revision) ||
894		    (plat->pred == greater_than_or_equal && hdr.oem_revision >= plat->oem_revision) ||
895		    (plat->pred == equal && hdr.oem_revision == plat->oem_revision))
896			return idx;
897	}
898
899	return -ENODEV;
900}
901EXPORT_SYMBOL(acpi_match_platform_list);