Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
Perry Yuan | 1243 | 76.82% | 1 | 4.00% |
Andrew Lutomirski | 156 | 9.64% | 4 | 16.00% |
Hans de Goede | 84 | 5.19% | 4 | 16.00% |
Matthew Garrett | 54 | 3.34% | 2 | 8.00% |
Y Paritcher | 13 | 0.80% | 1 | 4.00% |
Dmitry Torokhov | 12 | 0.74% | 1 | 4.00% |
Greg Kroah-Hartman | 11 | 0.68% | 1 | 4.00% |
Pali Rohár | 9 | 0.56% | 2 | 8.00% |
Mario Limonciello | 8 | 0.49% | 2 | 8.00% |
Colin Ian King | 7 | 0.43% | 1 | 4.00% |
Gabriele Mazzotta | 6 | 0.37% | 1 | 4.00% |
AceLan Kao | 5 | 0.31% | 1 | 4.00% |
Mattias Jacobsson | 5 | 0.31% | 1 | 4.00% |
Rezwanul Kabir | 3 | 0.19% | 1 | 4.00% |
Thomas Gleixner | 1 | 0.06% | 1 | 4.00% |
Michał Kępień | 1 | 0.06% | 1 | 4.00% |
Total | 1618 | 25 |
// SPDX-License-Identifier: GPL-2.0-only /* * Dell privacy notification driver * * Copyright (C) 2021 Dell Inc. All Rights Reserved. */ #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #include <linux/acpi.h> #include <linux/bitops.h> #include <linux/input.h> #include <linux/input/sparse-keymap.h> #include <linux/list.h> #include <linux/leds.h> #include <linux/module.h> #include <linux/wmi.h> #include "dell-wmi-privacy.h" #define DELL_PRIVACY_GUID "6932965F-1671-4CEB-B988-D3AB0A901919" #define MICROPHONE_STATUS BIT(0) #define CAMERA_STATUS BIT(1) #define DELL_PRIVACY_AUDIO_EVENT 0x1 #define DELL_PRIVACY_CAMERA_EVENT 0x2 #define led_to_priv(c) container_of(c, struct privacy_wmi_data, cdev) /* * The wmi_list is used to store the privacy_priv struct with mutex protecting */ static LIST_HEAD(wmi_list); static DEFINE_MUTEX(list_mutex); struct privacy_wmi_data { struct input_dev *input_dev; struct wmi_device *wdev; struct list_head list; struct led_classdev cdev; u32 features_present; u32 last_status; }; /* DELL Privacy Type */ enum dell_hardware_privacy_type { DELL_PRIVACY_TYPE_AUDIO = 0, DELL_PRIVACY_TYPE_CAMERA, DELL_PRIVACY_TYPE_SCREEN, DELL_PRIVACY_TYPE_MAX, }; static const char * const privacy_types[DELL_PRIVACY_TYPE_MAX] = { [DELL_PRIVACY_TYPE_AUDIO] = "Microphone", [DELL_PRIVACY_TYPE_CAMERA] = "Camera Shutter", [DELL_PRIVACY_TYPE_SCREEN] = "ePrivacy Screen", }; /* * Keymap for WMI privacy events of type 0x0012 */ static const struct key_entry dell_wmi_keymap_type_0012[] = { /* privacy mic mute */ { KE_KEY, 0x0001, { KEY_MICMUTE } }, /* privacy camera mute */ { KE_VSW, 0x0002, { SW_CAMERA_LENS_COVER } }, { KE_END, 0}, }; bool dell_privacy_has_mic_mute(void) { struct privacy_wmi_data *priv; mutex_lock(&list_mutex); priv = list_first_entry_or_null(&wmi_list, struct privacy_wmi_data, list); mutex_unlock(&list_mutex); return priv && (priv->features_present & BIT(DELL_PRIVACY_TYPE_AUDIO)); } EXPORT_SYMBOL_GPL(dell_privacy_has_mic_mute); /* * The flow of privacy event: * 1) User presses key. HW does stuff with this key (timeout is started) * 2) WMI event is emitted from BIOS * 3) WMI event is received by dell-privacy * 4) KEY_MICMUTE emitted from dell-privacy * 5) Userland picks up key and modifies kcontrol for SW mute * 6) Codec kernel driver catches and calls ledtrig_audio_set which will call * led_set_brightness() on the LED registered by dell_privacy_leds_setup() * 7) dell-privacy notifies EC, the timeout is cancelled and the HW mute activates. * If the EC is not notified then the HW mic mute will activate when the timeout * triggers, just a bit later than with the active ack. */ bool dell_privacy_process_event(int type, int code, int status) { struct privacy_wmi_data *priv; const struct key_entry *key; bool ret = false; mutex_lock(&list_mutex); priv = list_first_entry_or_null(&wmi_list, struct privacy_wmi_data, list); if (!priv) goto error; key = sparse_keymap_entry_from_scancode(priv->input_dev, (type << 16) | code); if (!key) { dev_warn(&priv->wdev->dev, "Unknown key with type 0x%04x and code 0x%04x pressed\n", type, code); goto error; } dev_dbg(&priv->wdev->dev, "Key with type 0x%04x and code 0x%04x pressed\n", type, code); switch (code) { case DELL_PRIVACY_AUDIO_EVENT: /* Mic mute */ priv->last_status = status; sparse_keymap_report_entry(priv->input_dev, key, 1, true); ret = true; break; case DELL_PRIVACY_CAMERA_EVENT: /* Camera mute */ priv->last_status = status; sparse_keymap_report_entry(priv->input_dev, key, !(status & CAMERA_STATUS), false); ret = true; break; default: dev_dbg(&priv->wdev->dev, "unknown event type 0x%04x 0x%04x\n", type, code); } error: mutex_unlock(&list_mutex); return ret; } static ssize_t dell_privacy_supported_type_show(struct device *dev, struct device_attribute *attr, char *buf) { struct privacy_wmi_data *priv = dev_get_drvdata(dev); enum dell_hardware_privacy_type type; u32 privacy_list; int len = 0; privacy_list = priv->features_present; for (type = DELL_PRIVACY_TYPE_AUDIO; type < DELL_PRIVACY_TYPE_MAX; type++) { if (privacy_list & BIT(type)) len += sysfs_emit_at(buf, len, "[%s] [supported]\n", privacy_types[type]); else len += sysfs_emit_at(buf, len, "[%s] [unsupported]\n", privacy_types[type]); } return len; } static ssize_t dell_privacy_current_state_show(struct device *dev, struct device_attribute *attr, char *buf) { struct privacy_wmi_data *priv = dev_get_drvdata(dev); u32 privacy_supported = priv->features_present; enum dell_hardware_privacy_type type; u32 privacy_state = priv->last_status; int len = 0; for (type = DELL_PRIVACY_TYPE_AUDIO; type < DELL_PRIVACY_TYPE_MAX; type++) { if (privacy_supported & BIT(type)) { if (privacy_state & BIT(type)) len += sysfs_emit_at(buf, len, "[%s] [unmuted]\n", privacy_types[type]); else len += sysfs_emit_at(buf, len, "[%s] [muted]\n", privacy_types[type]); } } return len; } static DEVICE_ATTR_RO(dell_privacy_supported_type); static DEVICE_ATTR_RO(dell_privacy_current_state); static struct attribute *privacy_attrs[] = { &dev_attr_dell_privacy_supported_type.attr, &dev_attr_dell_privacy_current_state.attr, NULL, }; ATTRIBUTE_GROUPS(privacy); /* * Describes the Device State class exposed by BIOS which can be consumed by * various applications interested in knowing the Privacy feature capabilities. * class DeviceState * { * [key, read] string InstanceName; * [read] boolean ReadOnly; * * [WmiDataId(1), read] uint32 DevicesSupported; * 0 - None; 0x1 - Microphone; 0x2 - Camera; 0x4 - ePrivacy Screen * * [WmiDataId(2), read] uint32 CurrentState; * 0 - Off; 1 - On; Bit0 - Microphone; Bit1 - Camera; Bit2 - ePrivacyScreen * }; */ static int get_current_status(struct wmi_device *wdev) { struct privacy_wmi_data *priv = dev_get_drvdata(&wdev->dev); union acpi_object *obj_present; u32 *buffer; int ret = 0; if (!priv) { dev_err(&wdev->dev, "dell privacy priv is NULL\n"); return -EINVAL; } /* check privacy support features and device states */ obj_present = wmidev_block_query(wdev, 0); if (!obj_present) { dev_err(&wdev->dev, "failed to read Binary MOF\n"); return -EIO; } if (obj_present->type != ACPI_TYPE_BUFFER) { dev_err(&wdev->dev, "Binary MOF is not a buffer!\n"); ret = -EIO; goto obj_free; } /* Although it's not technically a failure, this would lead to * unexpected behavior */ if (obj_present->buffer.length != 8) { dev_err(&wdev->dev, "Dell privacy buffer has unexpected length (%d)!\n", obj_present->buffer.length); ret = -EINVAL; goto obj_free; } buffer = (u32 *)obj_present->buffer.pointer; priv->features_present = buffer[0]; priv->last_status = buffer[1]; obj_free: kfree(obj_present); return ret; } static int dell_privacy_micmute_led_set(struct led_classdev *led_cdev, enum led_brightness brightness) { struct privacy_wmi_data *priv = led_to_priv(led_cdev); static char *acpi_method = (char *)"ECAK"; acpi_status status; acpi_handle handle; handle = ec_get_handle(); if (!handle) return -EIO; if (!acpi_has_method(handle, acpi_method)) return -EIO; status = acpi_evaluate_object(handle, acpi_method, NULL, NULL); if (ACPI_FAILURE(status)) { dev_err(&priv->wdev->dev, "Error setting privacy EC ack value: %s\n", acpi_format_exception(status)); return -EIO; } return 0; } /* * Pressing the mute key activates a time delayed circuit to physically cut * off the mute. The LED is in the same circuit, so it reflects the true * state of the HW mute. The reason for the EC "ack" is so that software * can first invoke a SW mute before the HW circuit is cut off. Without SW * cutting this off first does not affect the time delayed muting or status * of the LED but there is a possibility of a "popping" noise. * * If the EC receives the SW ack, the circuit will be activated before the * delay completed. * * Exposing as an LED device allows the codec drivers notification path to * EC ACK to work */ static int dell_privacy_leds_setup(struct device *dev) { struct privacy_wmi_data *priv = dev_get_drvdata(dev); priv->cdev.name = "dell-privacy::micmute"; priv->cdev.max_brightness = 1; priv->cdev.brightness_set_blocking = dell_privacy_micmute_led_set; priv->cdev.default_trigger = "audio-micmute"; return devm_led_classdev_register(dev, &priv->cdev); } static int dell_privacy_wmi_probe(struct wmi_device *wdev, const void *context) { struct privacy_wmi_data *priv; struct key_entry *keymap; int ret, i, j; priv = devm_kzalloc(&wdev->dev, sizeof(*priv), GFP_KERNEL); if (!priv) return -ENOMEM; dev_set_drvdata(&wdev->dev, priv); priv->wdev = wdev; ret = get_current_status(priv->wdev); if (ret) return ret; /* create evdev passing interface */ priv->input_dev = devm_input_allocate_device(&wdev->dev); if (!priv->input_dev) return -ENOMEM; /* remap the wmi keymap event to new keymap */ keymap = kcalloc(ARRAY_SIZE(dell_wmi_keymap_type_0012), sizeof(struct key_entry), GFP_KERNEL); if (!keymap) return -ENOMEM; /* remap the keymap code with Dell privacy key type 0x12 as prefix * KEY_MICMUTE scancode will be reported as 0x120001 */ for (i = 0, j = 0; i < ARRAY_SIZE(dell_wmi_keymap_type_0012); i++) { /* * Unlike keys where only presses matter, userspace may act * on switches in both of their positions. Only register * SW_CAMERA_LENS_COVER if it is actually there. */ if (dell_wmi_keymap_type_0012[i].type == KE_VSW && dell_wmi_keymap_type_0012[i].sw.code == SW_CAMERA_LENS_COVER && !(priv->features_present & BIT(DELL_PRIVACY_TYPE_CAMERA))) continue; keymap[j] = dell_wmi_keymap_type_0012[i]; keymap[j].code |= (0x0012 << 16); j++; } ret = sparse_keymap_setup(priv->input_dev, keymap, NULL); kfree(keymap); if (ret) return ret; priv->input_dev->dev.parent = &wdev->dev; priv->input_dev->name = "Dell Privacy Driver"; priv->input_dev->id.bustype = BUS_HOST; /* Report initial camera-cover status */ if (priv->features_present & BIT(DELL_PRIVACY_TYPE_CAMERA)) input_report_switch(priv->input_dev, SW_CAMERA_LENS_COVER, !(priv->last_status & CAMERA_STATUS)); ret = input_register_device(priv->input_dev); if (ret) return ret; if (priv->features_present & BIT(DELL_PRIVACY_TYPE_AUDIO)) { ret = dell_privacy_leds_setup(&priv->wdev->dev); if (ret) return ret; } mutex_lock(&list_mutex); list_add_tail(&priv->list, &wmi_list); mutex_unlock(&list_mutex); return 0; } static void dell_privacy_wmi_remove(struct wmi_device *wdev) { struct privacy_wmi_data *priv = dev_get_drvdata(&wdev->dev); mutex_lock(&list_mutex); list_del(&priv->list); mutex_unlock(&list_mutex); } static const struct wmi_device_id dell_wmi_privacy_wmi_id_table[] = { { .guid_string = DELL_PRIVACY_GUID }, { }, }; static struct wmi_driver dell_privacy_wmi_driver = { .driver = { .name = "dell-privacy", .dev_groups = privacy_groups, }, .probe = dell_privacy_wmi_probe, .remove = dell_privacy_wmi_remove, .id_table = dell_wmi_privacy_wmi_id_table, }; int dell_privacy_register_driver(void) { return wmi_driver_register(&dell_privacy_wmi_driver); } void dell_privacy_unregister_driver(void) { wmi_driver_unregister(&dell_privacy_wmi_driver); }
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1