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_reg: Evaluate _REG method to register OpRegion presence
610 * @handle: ACPI device handle
611 * @space_id: ACPI address space id to register OpRegion presence for
612 * @function: Parameter to pass to _REG one of ACPI_REG_CONNECT or
613 *            ACPI_REG_DISCONNECT
614 *
615 * Evaluate device's _REG method to register OpRegion presence.
616 */
617acpi_status acpi_evaluate_reg(acpi_handle handle, u8 space_id, u32 function)
618{
619	struct acpi_object_list arg_list;
620	union acpi_object params[2];
621
622	params[0].type = ACPI_TYPE_INTEGER;
623	params[0].integer.value = space_id;
624	params[1].type = ACPI_TYPE_INTEGER;
625	params[1].integer.value = function;
626	arg_list.count = 2;
627	arg_list.pointer = params;
628
629	return acpi_evaluate_object(handle, "_REG", &arg_list, NULL);
630}
631EXPORT_SYMBOL(acpi_evaluate_reg);
632
633/**
634 * acpi_evaluate_dsm - evaluate device's _DSM method
635 * @handle: ACPI device handle
636 * @guid: GUID of requested functions, should be 16 bytes
637 * @rev: revision number of requested function
638 * @func: requested function number
639 * @argv4: the function specific parameter
640 *
641 * Evaluate device's _DSM method with specified GUID, revision id and
642 * function number. Caller needs to free the returned object.
643 *
644 * Though ACPI defines the fourth parameter for _DSM should be a package,
645 * some old BIOSes do expect a buffer or an integer etc.
646 */
647union acpi_object *
648acpi_evaluate_dsm(acpi_handle handle, const guid_t *guid, u64 rev, u64 func,
649		  union acpi_object *argv4)
650{
651	acpi_status ret;
652	struct acpi_buffer buf = {ACPI_ALLOCATE_BUFFER, NULL};
653	union acpi_object params[4];
654	struct acpi_object_list input = {
655		.count = 4,
656		.pointer = params,
657	};
658
659	params[0].type = ACPI_TYPE_BUFFER;
660	params[0].buffer.length = 16;
661	params[0].buffer.pointer = (u8 *)guid;
662	params[1].type = ACPI_TYPE_INTEGER;
663	params[1].integer.value = rev;
664	params[2].type = ACPI_TYPE_INTEGER;
665	params[2].integer.value = func;
666	if (argv4) {
667		params[3] = *argv4;
668	} else {
669		params[3].type = ACPI_TYPE_PACKAGE;
670		params[3].package.count = 0;
671		params[3].package.elements = NULL;
672	}
673
674	ret = acpi_evaluate_object(handle, "_DSM", &input, &buf);
675	if (ACPI_SUCCESS(ret))
676		return (union acpi_object *)buf.pointer;
677
678	if (ret != AE_NOT_FOUND)
679		acpi_handle_warn(handle,
680				"failed to evaluate _DSM (0x%x)\n", ret);
681
682	return NULL;
683}
684EXPORT_SYMBOL(acpi_evaluate_dsm);
685
686/**
687 * acpi_check_dsm - check if _DSM method supports requested functions.
688 * @handle: ACPI device handle
689 * @guid: GUID of requested functions, should be 16 bytes at least
690 * @rev: revision number of requested functions
691 * @funcs: bitmap of requested functions
692 *
693 * Evaluate device's _DSM method to check whether it supports requested
694 * functions. Currently only support 64 functions at maximum, should be
695 * enough for now.
696 */
697bool acpi_check_dsm(acpi_handle handle, const guid_t *guid, u64 rev, u64 funcs)
698{
699	int i;
700	u64 mask = 0;
701	union acpi_object *obj;
702
703	if (funcs == 0)
704		return false;
705
706	obj = acpi_evaluate_dsm(handle, guid, rev, 0, NULL);
707	if (!obj)
708		return false;
709
710	/* For compatibility, old BIOSes may return an integer */
711	if (obj->type == ACPI_TYPE_INTEGER)
712		mask = obj->integer.value;
713	else if (obj->type == ACPI_TYPE_BUFFER)
714		for (i = 0; i < obj->buffer.length && i < 8; i++)
715			mask |= (((u64)obj->buffer.pointer[i]) << (i * 8));
716	ACPI_FREE(obj);
717
718	/*
719	 * Bit 0 indicates whether there's support for any functions other than
720	 * function 0 for the specified GUID and revision.
721	 */
722	if ((mask & 0x1) && (mask & funcs) == funcs)
723		return true;
724
725	return false;
726}
727EXPORT_SYMBOL(acpi_check_dsm);
728
729/**
730 * acpi_dev_hid_uid_match - Match device by supplied HID and UID
731 * @adev: ACPI device to match.
732 * @hid2: Hardware ID of the device.
733 * @uid2: Unique ID of the device, pass NULL to not check _UID.
734 *
735 * Matches HID and UID in @adev with given @hid2 and @uid2.
736 * Returns true if matches.
737 */
738bool acpi_dev_hid_uid_match(struct acpi_device *adev,
739			    const char *hid2, const char *uid2)
740{
741	const char *hid1 = acpi_device_hid(adev);
742	const char *uid1 = acpi_device_uid(adev);
743
744	if (strcmp(hid1, hid2))
745		return false;
746
747	if (!uid2)
748		return true;
749
750	return uid1 && !strcmp(uid1, uid2);
751}
752EXPORT_SYMBOL(acpi_dev_hid_uid_match);
753
754/**
755 * acpi_dev_found - Detect presence of a given ACPI device in the namespace.
756 * @hid: Hardware ID of the device.
757 *
758 * Return %true if the device was present at the moment of invocation.
759 * Note that if the device is pluggable, it may since have disappeared.
760 *
761 * For this function to work, acpi_bus_scan() must have been executed
762 * which happens in the subsys_initcall() subsection. Hence, do not
763 * call from a subsys_initcall() or earlier (use acpi_get_devices()
764 * instead). Calling from module_init() is fine (which is synonymous
765 * with device_initcall()).
766 */
767bool acpi_dev_found(const char *hid)
768{
769	struct acpi_device_bus_id *acpi_device_bus_id;
770	bool found = false;
771
772	mutex_lock(&acpi_device_lock);
773	list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node)
774		if (!strcmp(acpi_device_bus_id->bus_id, hid)) {
775			found = true;
776			break;
777		}
778	mutex_unlock(&acpi_device_lock);
779
780	return found;
781}
782EXPORT_SYMBOL(acpi_dev_found);
783
784struct acpi_dev_match_info {
785	struct acpi_device_id hid[2];
786	const char *uid;
787	s64 hrv;
788};
789
790static int acpi_dev_match_cb(struct device *dev, const void *data)
791{
792	struct acpi_device *adev = to_acpi_device(dev);
793	const struct acpi_dev_match_info *match = data;
794	unsigned long long hrv;
795	acpi_status status;
796
797	if (acpi_match_device_ids(adev, match->hid))
798		return 0;
799
800	if (match->uid && (!adev->pnp.unique_id ||
801	    strcmp(adev->pnp.unique_id, match->uid)))
802		return 0;
803
804	if (match->hrv == -1)
805		return 1;
806
807	status = acpi_evaluate_integer(adev->handle, "_HRV", NULL, &hrv);
808	if (ACPI_FAILURE(status))
809		return 0;
810
811	return hrv == match->hrv;
812}
813
814/**
815 * acpi_dev_present - Detect that a given ACPI device is present
816 * @hid: Hardware ID of the device.
817 * @uid: Unique ID of the device, pass NULL to not check _UID
818 * @hrv: Hardware Revision of the device, pass -1 to not check _HRV
819 *
820 * Return %true if a matching device was present at the moment of invocation.
821 * Note that if the device is pluggable, it may since have disappeared.
822 *
823 * Note that unlike acpi_dev_found() this function checks the status
824 * of the device. So for devices which are present in the dsdt, but
825 * which are disabled (their _STA callback returns 0) this function
826 * will return false.
827 *
828 * For this function to work, acpi_bus_scan() must have been executed
829 * which happens in the subsys_initcall() subsection. Hence, do not
830 * call from a subsys_initcall() or earlier (use acpi_get_devices()
831 * instead). Calling from module_init() is fine (which is synonymous
832 * with device_initcall()).
833 */
834bool acpi_dev_present(const char *hid, const char *uid, s64 hrv)
835{
836	struct acpi_dev_match_info match = {};
837	struct device *dev;
838
839	strlcpy(match.hid[0].id, hid, sizeof(match.hid[0].id));
840	match.uid = uid;
841	match.hrv = hrv;
842
843	dev = bus_find_device(&acpi_bus_type, NULL, &match, acpi_dev_match_cb);
844	put_device(dev);
845	return !!dev;
846}
847EXPORT_SYMBOL(acpi_dev_present);
848
849/**
850 * acpi_dev_get_first_match_dev - Return the first match of ACPI device
851 * @hid: Hardware ID of the device.
852 * @uid: Unique ID of the device, pass NULL to not check _UID
853 * @hrv: Hardware Revision of the device, pass -1 to not check _HRV
854 *
855 * Return the first match of ACPI device if a matching device was present
856 * at the moment of invocation, or NULL otherwise.
857 *
858 * The caller is responsible to call put_device() on the returned device.
859 *
860 * See additional information in acpi_dev_present() as well.
861 */
862struct acpi_device *
863acpi_dev_get_first_match_dev(const char *hid, const char *uid, s64 hrv)
864{
865	struct acpi_dev_match_info match = {};
866	struct device *dev;
867
868	strlcpy(match.hid[0].id, hid, sizeof(match.hid[0].id));
869	match.uid = uid;
870	match.hrv = hrv;
871
872	dev = bus_find_device(&acpi_bus_type, NULL, &match, acpi_dev_match_cb);
873	return dev ? to_acpi_device(dev) : NULL;
874}
875EXPORT_SYMBOL(acpi_dev_get_first_match_dev);
876
877/*
878 * acpi_backlight= handling, this is done here rather then in video_detect.c
879 * because __setup cannot be used in modules.
880 */
881char acpi_video_backlight_string[16];
882EXPORT_SYMBOL(acpi_video_backlight_string);
883
884static int __init acpi_backlight(char *str)
885{
886	strlcpy(acpi_video_backlight_string, str,
887		sizeof(acpi_video_backlight_string));
888	return 1;
889}
890__setup("acpi_backlight=", acpi_backlight);
891
892/**
893 * acpi_match_platform_list - Check if the system matches with a given list
894 * @plat: pointer to acpi_platform_list table terminated by a NULL entry
895 *
896 * Return the matched index if the system is found in the platform list.
897 * Otherwise, return a negative error code.
898 */
899int acpi_match_platform_list(const struct acpi_platform_list *plat)
900{
901	struct acpi_table_header hdr;
902	int idx = 0;
903
904	if (acpi_disabled)
905		return -ENODEV;
906
907	for (; plat->oem_id[0]; plat++, idx++) {
908		if (ACPI_FAILURE(acpi_get_table_header(plat->table, 0, &hdr)))
909			continue;
910
911		if (strncmp(plat->oem_id, hdr.oem_id, ACPI_OEM_ID_SIZE))
912			continue;
913
914		if (strncmp(plat->oem_table_id, hdr.oem_table_id, ACPI_OEM_TABLE_ID_SIZE))
915			continue;
916
917		if ((plat->pred == all_versions) ||
918		    (plat->pred == less_than_or_equal && hdr.oem_revision <= plat->oem_revision) ||
919		    (plat->pred == greater_than_or_equal && hdr.oem_revision >= plat->oem_revision) ||
920		    (plat->pred == equal && hdr.oem_revision == plat->oem_revision))
921			return idx;
922	}
923
924	return -ENODEV;
925}
926EXPORT_SYMBOL(acpi_match_platform_list);