// SPDX-License-Identifier: GPL-2.0-or-later/* *  button.c - ACPI Button Driver * *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> */ #define pr_fmt(fmt) "ACPI: button: " fmt #include <linux/compiler.h>#include <linux/kernel.h>#include <linux/module.h>#include <linux/init.h>#include <linux/types.h>#include <linux/proc_fs.h>#include <linux/seq_file.h>#include <linux/input.h>#include <linux/slab.h>#include <linux/acpi.h>#include <linux/dmi.h>#include <acpi/button.h> #define ACPI_BUTTON_CLASS		"button"#define ACPI_BUTTON_FILE_STATE		"state"#define ACPI_BUTTON_TYPE_UNKNOWN	0x00#define ACPI_BUTTON_NOTIFY_STATUS	0x80 #define ACPI_BUTTON_SUBCLASS_POWER	"power"#define ACPI_BUTTON_DEVICE_NAME_POWER	"Power Button"#define ACPI_BUTTON_TYPE_POWER		0x01 #define ACPI_BUTTON_SUBCLASS_SLEEP	"sleep"#define ACPI_BUTTON_DEVICE_NAME_SLEEP	"Sleep Button"#define ACPI_BUTTON_TYPE_SLEEP		0x03 #define ACPI_BUTTON_SUBCLASS_LID	"lid"#define ACPI_BUTTON_DEVICE_NAME_LID	"Lid Switch"#define ACPI_BUTTON_TYPE_LID		0x05 enum {	ACPI_BUTTON_LID_INIT_IGNORE,	ACPI_BUTTON_LID_INIT_OPEN,	ACPI_BUTTON_LID_INIT_METHOD,	ACPI_BUTTON_LID_INIT_DISABLED,}; static const char * const lid_init_state_str[] = {	[ACPI_BUTTON_LID_INIT_IGNORE]		= "ignore",	[ACPI_BUTTON_LID_INIT_OPEN]		= "open",	[ACPI_BUTTON_LID_INIT_METHOD]		= "method",	[ACPI_BUTTON_LID_INIT_DISABLED]		= "disabled",}; MODULE_AUTHOR("Paul Diefenbaugh");MODULE_DESCRIPTION("ACPI Button Driver");MODULE_LICENSE("GPL"); static const struct acpi_device_id button_device_ids[] = {	{ACPI_BUTTON_HID_LID,    0},	{ACPI_BUTTON_HID_SLEEP,  0},	{ACPI_BUTTON_HID_SLEEPF, 0},	{ACPI_BUTTON_HID_POWER,  0},	{ACPI_BUTTON_HID_POWERF, 0},	{"", 0},};MODULE_DEVICE_TABLE(acpi, button_device_ids); /* Please keep this list sorted alphabetically by vendor and model */static const struct dmi_system_id dmi_lid_quirks[] = {	{		/* GP-electronic T701, _LID method points to a floating GPIO */		.matches = {			DMI_MATCH(DMI_SYS_VENDOR, "Insyde"),			DMI_MATCH(DMI_PRODUCT_NAME, "T701"),			DMI_MATCH(DMI_BIOS_VERSION, "BYT70A.YNCHENG.WIN.007"),		},		.driver_data = (void *)(long)ACPI_BUTTON_LID_INIT_DISABLED,	},	{		/*		 * Medion Akoya E2215T, notification of the LID device only		 * happens on close, not on open and _LID always returns closed.		 */		.matches = {			DMI_MATCH(DMI_SYS_VENDOR, "MEDION"),			DMI_MATCH(DMI_PRODUCT_NAME, "E2215T"),		},		.driver_data = (void *)(long)ACPI_BUTTON_LID_INIT_OPEN,	},	{		/*		 * Medion Akoya E2228T, notification of the LID device only		 * happens on close, not on open and _LID always returns closed.		 */		.matches = {			DMI_MATCH(DMI_SYS_VENDOR, "MEDION"),			DMI_MATCH(DMI_PRODUCT_NAME, "E2228T"),		},		.driver_data = (void *)(long)ACPI_BUTTON_LID_INIT_OPEN,	},	{		/*		 * Razer Blade Stealth 13 late 2019, notification of the LID device		 * only happens on close, not on open and _LID always returns closed.		 */		.matches = {			DMI_MATCH(DMI_SYS_VENDOR, "Razer"),			DMI_MATCH(DMI_PRODUCT_NAME, "Razer Blade Stealth 13 Late 2019"),		},		.driver_data = (void *)(long)ACPI_BUTTON_LID_INIT_OPEN,	},	{}}; static int acpi_button_add(struct acpi_device *device);static int acpi_button_remove(struct acpi_device *device);static void acpi_button_notify(struct acpi_device *device, u32 event); #ifdef CONFIG_PM_SLEEPstatic int acpi_button_suspend(struct device *dev);static int acpi_button_resume(struct device *dev);#else#define acpi_button_suspend NULL#define acpi_button_resume NULL#endifstatic SIMPLE_DEV_PM_OPS(acpi_button_pm, acpi_button_suspend, acpi_button_resume); static struct acpi_driver acpi_button_driver = {	.name = "button",	.class = ACPI_BUTTON_CLASS,	.ids = button_device_ids,	.ops = {		.add = acpi_button_add,		.remove = acpi_button_remove,		.notify = acpi_button_notify,	},	.drv.pm = &acpi_button_pm,}; struct acpi_button {	unsigned int type;	struct input_dev *input;	char phys[32];			/* for input device */	unsigned long pushed;	int last_state;	ktime_t last_time;	bool suspended;	bool lid_state_initialized;}; static struct acpi_device *lid_device;static long lid_init_state = -1; static unsigned long lid_report_interval __read_mostly = 500;module_param(lid_report_interval, ulong, 0644);MODULE_PARM_DESC(lid_report_interval, "Interval (ms) between lid key events"); /* FS Interface (/proc) */static struct proc_dir_entry *acpi_button_dir;static struct proc_dir_entry *acpi_lid_dir; static int acpi_lid_evaluate_state(struct acpi_device *device){	unsigned long long lid_state;	acpi_status status; 	status = acpi_evaluate_integer(device->handle, "_LID", NULL, &lid_state);	if (ACPI_FAILURE(status))		return -ENODEV; 	return lid_state ? 1 : 0;} static int acpi_lid_notify_state(struct acpi_device *device, int state){	struct acpi_button *button = acpi_driver_data(device);	ktime_t next_report;	bool do_update; 	/*	 * In lid_init_state=ignore mode, if user opens/closes lid	 * frequently with "open" missing, and "last_time" is also updated	 * frequently, "close" cannot be delivered to the userspace.	 * So "last_time" is only updated after a timeout or an actual	 * switch.	 */	if (lid_init_state != ACPI_BUTTON_LID_INIT_IGNORE ||	    button->last_state != !!state)		do_update = true;	else		do_update = false; 	next_report = ktime_add(button->last_time,				ms_to_ktime(lid_report_interval));	if (button->last_state == !!state &&	    ktime_after(ktime_get(), next_report)) {		/* Complain the buggy firmware */		pr_warn_once("The lid device is not compliant to SW_LID.\n"); 		/*		 * Send the unreliable complement switch event:		 *		 * On most platforms, the lid device is reliable. However		 * there are exceptions:		 * 1. Platforms returning initial lid state as "close" by		 *    default after booting/resuming:		 *     https://bugzilla.kernel.org/show_bug.cgi?id=89211		 *     https://bugzilla.kernel.org/show_bug.cgi?id=106151		 * 2. Platforms never reporting "open" events:		 *     https://bugzilla.kernel.org/show_bug.cgi?id=106941		 * On these buggy platforms, the usage model of the ACPI		 * lid device actually is:		 * 1. The initial returning value of _LID may not be		 *    reliable.		 * 2. The open event may not be reliable.		 * 3. The close event is reliable.		 *		 * But SW_LID is typed as input switch event, the input		 * layer checks if the event is redundant. Hence if the		 * state is not switched, the userspace cannot see this		 * platform triggered reliable event. By inserting a		 * complement switch event, it then is guaranteed that the		 * platform triggered reliable one can always be seen by		 * the userspace.		 */		if (lid_init_state == ACPI_BUTTON_LID_INIT_IGNORE) {			do_update = true;			/*			 * Do generate complement switch event for "close"			 * as "close" is reliable and wrong "open" won't			 * trigger unexpected behaviors.			 * Do not generate complement switch event for			 * "open" as "open" is not reliable and wrong			 * "close" will trigger unexpected behaviors.			 */			if (!state) {				input_report_switch(button->input,						    SW_LID, state);				input_sync(button->input);			}		}	}	/* Send the platform triggered reliable event */	if (do_update) {		acpi_handle_debug(device->handle, "ACPI LID %s\n",				  state ? "open" : "closed");		input_report_switch(button->input, SW_LID, !state);		input_sync(button->input);		button->last_state = !!state;		button->last_time = ktime_get();	} 	return 0;} static int __maybe_unused acpi_button_state_seq_show(struct seq_file *seq,						     void *offset){	struct acpi_device *device = seq->private;	int state; 	state = acpi_lid_evaluate_state(device);	seq_printf(seq, "state:      %s\n",		   state < 0 ? "unsupported" : (state ? "open" : "closed"));	return 0;} static int acpi_button_add_fs(struct acpi_device *device){	struct acpi_button *button = acpi_driver_data(device);	struct proc_dir_entry *entry = NULL;	int ret = 0; 	/* procfs I/F for ACPI lid device only */	if (button->type != ACPI_BUTTON_TYPE_LID)		return 0; 	if (acpi_button_dir || acpi_lid_dir) {		pr_info("More than one Lid device found!\n");		return -EEXIST;	} 	/* create /proc/acpi/button */	acpi_button_dir = proc_mkdir(ACPI_BUTTON_CLASS, acpi_root_dir);	if (!acpi_button_dir)		return -ENODEV; 	/* create /proc/acpi/button/lid */	acpi_lid_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);	if (!acpi_lid_dir) {		ret = -ENODEV;		goto remove_button_dir;	} 	/* create /proc/acpi/button/lid/LID/ */	acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), acpi_lid_dir);	if (!acpi_device_dir(device)) {		ret = -ENODEV;		goto remove_lid_dir;	} 	/* create /proc/acpi/button/lid/LID/state */	entry = proc_create_single_data(ACPI_BUTTON_FILE_STATE, S_IRUGO,			acpi_device_dir(device), acpi_button_state_seq_show,			device);	if (!entry) {		ret = -ENODEV;		goto remove_dev_dir;	} done:	return ret; remove_dev_dir:	remove_proc_entry(acpi_device_bid(device),			  acpi_lid_dir);	acpi_device_dir(device) = NULL;remove_lid_dir:	remove_proc_entry(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);	acpi_lid_dir = NULL;remove_button_dir:	remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);	acpi_button_dir = NULL;	goto done;} static int acpi_button_remove_fs(struct acpi_device *device){	struct acpi_button *button = acpi_driver_data(device); 	if (button->type != ACPI_BUTTON_TYPE_LID)		return 0; 	remove_proc_entry(ACPI_BUTTON_FILE_STATE,			  acpi_device_dir(device));	remove_proc_entry(acpi_device_bid(device),			  acpi_lid_dir);	acpi_device_dir(device) = NULL;	remove_proc_entry(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);	acpi_lid_dir = NULL;	remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);	acpi_button_dir = NULL; 	return 0;} /* Driver Interface */int acpi_lid_open(void){	if (!lid_device)		return -ENODEV; 	return acpi_lid_evaluate_state(lid_device);}EXPORT_SYMBOL(acpi_lid_open); static int acpi_lid_update_state(struct acpi_device *device,				 bool signal_wakeup){	int state; 	state = acpi_lid_evaluate_state(device);	if (state < 0)		return state; 	if (state && signal_wakeup)		acpi_pm_wakeup_event(&device->dev); 	return acpi_lid_notify_state(device, state);} static void acpi_lid_initialize_state(struct acpi_device *device){	struct acpi_button *button = acpi_driver_data(device); 	switch (lid_init_state) {	case ACPI_BUTTON_LID_INIT_OPEN:		(void)acpi_lid_notify_state(device, 1);		break;	case ACPI_BUTTON_LID_INIT_METHOD:		(void)acpi_lid_update_state(device, false);		break;	case ACPI_BUTTON_LID_INIT_IGNORE:	default:		break;	} 	button->lid_state_initialized = true;} static void acpi_button_notify(struct acpi_device *device, u32 event){	struct acpi_button *button = acpi_driver_data(device);	struct input_dev *input; 	switch (event) {	case ACPI_FIXED_HARDWARE_EVENT:		event = ACPI_BUTTON_NOTIFY_STATUS;		fallthrough;	case ACPI_BUTTON_NOTIFY_STATUS:		input = button->input;		if (button->type == ACPI_BUTTON_TYPE_LID) {			if (button->lid_state_initialized)				acpi_lid_update_state(device, true);		} else {			int keycode; 			acpi_pm_wakeup_event(&device->dev);			if (button->suspended)				break; 			keycode = test_bit(KEY_SLEEP, input->keybit) ?						KEY_SLEEP : KEY_POWER;			input_report_key(input, keycode, 1);			input_sync(input);			input_report_key(input, keycode, 0);			input_sync(input); 			acpi_bus_generate_netlink_event(					device->pnp.device_class,					dev_name(&device->dev),					event, ++button->pushed);		}		break;	default:		acpi_handle_debug(device->handle, "Unsupported event [0x%x]\n",				  event);		break;	}} #ifdef CONFIG_PM_SLEEPstatic int acpi_button_suspend(struct device *dev){	struct acpi_device *device = to_acpi_device(dev);	struct acpi_button *button = acpi_driver_data(device); 	button->suspended = true;	return 0;} static int acpi_button_resume(struct device *dev){	struct acpi_device *device = to_acpi_device(dev);	struct acpi_button *button = acpi_driver_data(device); 	button->suspended = false;	if (button->type == ACPI_BUTTON_TYPE_LID) {		button->last_state = !!acpi_lid_evaluate_state(device);		button->last_time = ktime_get();		acpi_lid_initialize_state(device);	}	return 0;}#endif static int acpi_lid_input_open(struct input_dev *input){	struct acpi_device *device = input_get_drvdata(input);	struct acpi_button *button = acpi_driver_data(device); 	button->last_state = !!acpi_lid_evaluate_state(device);	button->last_time = ktime_get();	acpi_lid_initialize_state(device); 	return 0;} static int acpi_button_add(struct acpi_device *device){	struct acpi_button *button;	struct input_dev *input;	const char *hid = acpi_device_hid(device);	char *name, *class;	int error; 	if (!strcmp(hid, ACPI_BUTTON_HID_LID) &&	     lid_init_state == ACPI_BUTTON_LID_INIT_DISABLED)		return -ENODEV; 	button = kzalloc(sizeof(struct acpi_button), GFP_KERNEL);	if (!button)		return -ENOMEM; 	device->driver_data = button; 	button->input = input = input_allocate_device();	if (!input) {		error = -ENOMEM;		goto err_free_button;	} 	name = acpi_device_name(device);	class = acpi_device_class(device); 	if (!strcmp(hid, ACPI_BUTTON_HID_POWER) ||	    !strcmp(hid, ACPI_BUTTON_HID_POWERF)) {		button->type = ACPI_BUTTON_TYPE_POWER;		strcpy(name, ACPI_BUTTON_DEVICE_NAME_POWER);

Lines 1–500 of 648. Load more