static void notify_handler(acpi_handle handle, u32 event, void *context) { struct platform_device *device = context; struct intel_hid_priv *priv = dev_get_drvdata(&device->dev); unsigned long long ev_index; acpi_status status; /* 0xC0 is for HID events, other values are for 5 button array */ if (event != 0xc0) { if (!priv->array || !sparse_keymap_report_event(priv->array, event, 1, true)) dev_info(&device->dev, "unknown event 0x%x\n", event); return; } status = acpi_evaluate_integer(handle, "HDEM", NULL, &ev_index); if (ACPI_FAILURE(status)) { dev_warn(&device->dev, "failed to get event index\n"); return; } if (!sparse_keymap_report_event(priv->input_dev, ev_index, 1, true)) dev_info(&device->dev, "unknown event index 0x%llx\n", ev_index); }
static void notify_handler(acpi_handle handle, u32 event, void *context) { struct platform_device *device = context; struct intel_vbtn_priv *priv = dev_get_drvdata(&device->dev); unsigned int val = !(event & 1); /* Even=press, Odd=release */ const struct key_entry *ke_rel; bool autorelease; if (priv->wakeup_mode) { if (sparse_keymap_entry_from_scancode(priv->input_dev, event)) { pm_wakeup_hard_event(&device->dev); return; } goto out_unknown; } /* * Even press events are autorelease if there is no corresponding odd * release event, or if the odd event is KE_IGNORE. */ ke_rel = sparse_keymap_entry_from_scancode(priv->input_dev, event | 1); autorelease = val && (!ke_rel || ke_rel->type == KE_IGNORE); if (sparse_keymap_report_event(priv->input_dev, event, val, autorelease)) return; out_unknown: dev_dbg(&device->dev, "unknown event index 0x%x\n", event); }
static void asus_input_notify(struct asus_laptop *asus, int event) { if (!asus->inputdev) return ; if (!sparse_keymap_report_event(asus->inputdev, event, 1, true)) pr_info("Unknown key %x pressed\n", event); }
static void dell_wmi_aio_notify(u32 value, void *context) { struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL }; union acpi_object *obj; struct dell_wmi_event *event; acpi_status status; status = wmi_get_event_data(value, &response); if (status != AE_OK) { pr_info("bad event status 0x%x\n", status); return; } obj = (union acpi_object *)response.pointer; if (obj) { unsigned int scancode = 0; switch (obj->type) { case ACPI_TYPE_INTEGER: /* Most All-In-One correctly return integer scancode */ scancode = obj->integer.value; sparse_keymap_report_event(dell_wmi_aio_input_dev, scancode, 1, true); break; case ACPI_TYPE_BUFFER: if (dell_wmi_aio_event_check(obj->buffer.pointer, obj->buffer.length)) { event = (struct dell_wmi_event *) obj->buffer.pointer; scancode = event->event[0]; } else { /* Broken machines return the scancode in a buffer */ if (obj->buffer.pointer && obj->buffer.length > 0) scancode = obj->buffer.pointer[0]; } if (scancode) sparse_keymap_report_event( dell_wmi_aio_input_dev, scancode, 1, true); break; } } kfree(obj); }
static void notify_handler(acpi_handle handle, u32 event, void *context) { struct platform_device *device = context; struct intel_vbtn_priv *priv = dev_get_drvdata(&device->dev); if (!sparse_keymap_report_event(priv->input_dev, event, 1, true)) dev_info(&device->dev, "unknown event index 0x%x\n", event); }
static void toshiba_acpi_report_hotkey(struct toshiba_acpi_dev *dev, int scancode) { if (scancode == 0x100) return; /* */ if (scancode & 0x80) return; if (!sparse_keymap_report_event(dev->hotkey_dev, scancode, 1, true)) pr_info("Unknown key %x\n", scancode); }
static void msi_send_touchpad_key(struct work_struct *ignored) { u8 rdata; int result; result = ec_read(MSI_STANDARD_EC_FUNCTIONS_ADDRESS, &rdata); if (result < 0) return; sparse_keymap_report_event(msi_laptop_input_dev, (rdata & MSI_STANDARD_EC_TOUCHPAD_MASK) ? KEY_TOUCHPAD_ON : KEY_TOUCHPAD_OFF, 1, true); }
static void dell_wmi_aio_notify(u32 value, void *context) { struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL }; union acpi_object *obj; acpi_status status; status = wmi_get_event_data(value, &response); if (status != AE_OK) { pr_info("bad event status 0x%x\n", status); return; } obj = (union acpi_object *)response.pointer; if (obj) { unsigned int scancode; switch (obj->type) { case ACPI_TYPE_INTEGER: /* */ scancode = obj->integer.value; sparse_keymap_report_event(dell_wmi_aio_input_dev, scancode, 1, true); break; case ACPI_TYPE_BUFFER: /* */ if (obj->buffer.pointer && obj->buffer.length > 0) { scancode = obj->buffer.pointer[0]; sparse_keymap_report_event( dell_wmi_aio_input_dev, scancode, 1, true); } break; } } kfree(obj); }
static void acpi_topstar_notify(struct acpi_device *device, u32 event) { static bool dup_evnt[2]; bool *dup; struct topstar_hkey *hkey = acpi_driver_data(device); /* 0x83 and 0x84 key events comes duplicated... */ if (event == 0x83 || event == 0x84) { dup = &dup_evnt[event - 0x83]; if (*dup) { *dup = false; return; } *dup = true; } if (!sparse_keymap_report_event(hkey->inputdev, event, 1, true)) pr_info("unknown event = 0x%02x\n", event); }
static void notify_handler(acpi_handle handle, u32 event, void *context) { struct platform_device *device = context; struct intel_hid_priv *priv = dev_get_drvdata(&device->dev); unsigned long long ev_index; acpi_status status; /* The platform spec only defines one event code: 0xC0. */ if (event != 0xc0) { dev_warn(&device->dev, "received unknown event (0x%x)\n", event); return; } status = acpi_evaluate_integer(handle, "HDEM", NULL, &ev_index); if (!ACPI_SUCCESS(status)) { dev_warn(&device->dev, "failed to get event index\n"); return; } if (!sparse_keymap_report_event(priv->input_dev, ev_index, 1, true)) dev_info(&device->dev, "unknown event index 0x%llx\n", ev_index); }
/* * Input device (i.e. hotkeys) */ static void asus_input_notify(struct asus_laptop *asus, int event) { if (asus->inputdev) sparse_keymap_report_event(asus->inputdev, event, 1, true); }
static void notify_handler(acpi_handle handle, u32 event, void *context) { struct platform_device *device = context; struct intel_hid_priv *priv = dev_get_drvdata(&device->dev); unsigned long long ev_index; if (priv->wakeup_mode) { /* * Needed for wakeup from suspend-to-idle to work on some * platforms that don't expose the 5-button array, but still * send notifies with the power button event code to this * device object on power button actions while suspended. */ if (event == 0xce) goto wakeup; /* Wake up on 5-button array events only. */ if (event == 0xc0 || !priv->array) return; if (!sparse_keymap_entry_from_scancode(priv->array, event)) { dev_info(&device->dev, "unknown event 0x%x\n", event); return; } wakeup: pm_wakeup_hard_event(&device->dev); return; } /* * Needed for suspend to work on some platforms that don't expose * the 5-button array, but still send notifies with power button * event code to this device object on power button actions. * * Report the power button press; catch and ignore the button release. */ if (!priv->array) { if (event == 0xce) { input_report_key(priv->input_dev, KEY_POWER, 1); input_sync(priv->input_dev); return; } if (event == 0xcf) return; } /* 0xC0 is for HID events, other values are for 5 button array */ if (event != 0xc0) { if (!priv->array || !sparse_keymap_report_event(priv->array, event, 1, true)) dev_dbg(&device->dev, "unknown event 0x%x\n", event); return; } if (!intel_hid_evaluate_method(handle, INTEL_HID_DSM_HDEM_FN, &ev_index)) { dev_warn(&device->dev, "failed to get event index\n"); return; } if (!sparse_keymap_report_event(priv->input_dev, ev_index, 1, true)) dev_dbg(&device->dev, "unknown event index 0x%llx\n", ev_index); }
static void hp_wmi_notify(u32 value, void *context) { struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL }; u32 event_id, event_data; union acpi_object *obj; acpi_status status; u32 *location; int key_code; status = wmi_get_event_data(value, &response); if (status != AE_OK) { pr_info("bad event status 0x%x\n", status); return; } obj = (union acpi_object *)response.pointer; if (!obj) return; if (obj->type != ACPI_TYPE_BUFFER) { pr_info("Unknown response received %d\n", obj->type); kfree(obj); return; } /* * Depending on ACPI version the concatenation of id and event data * inside _WED function will result in a 8 or 16 byte buffer. */ location = (u32 *)obj->buffer.pointer; if (obj->buffer.length == 8) { event_id = *location; event_data = *(location + 1); } else if (obj->buffer.length == 16) { event_id = *location; event_data = *(location + 2); } else { pr_info("Unknown buffer length %d\n", obj->buffer.length); kfree(obj); return; } kfree(obj); switch (event_id) { case HPWMI_DOCK_EVENT: if (test_bit(SW_DOCK, hp_wmi_input_dev->swbit)) input_report_switch(hp_wmi_input_dev, SW_DOCK, hp_wmi_hw_state(HPWMI_DOCK_MASK)); if (test_bit(SW_TABLET_MODE, hp_wmi_input_dev->swbit)) input_report_switch(hp_wmi_input_dev, SW_TABLET_MODE, hp_wmi_hw_state(HPWMI_TABLET_MASK)); input_sync(hp_wmi_input_dev); break; case HPWMI_PARK_HDD: break; case HPWMI_SMART_ADAPTER: break; case HPWMI_BEZEL_BUTTON: key_code = hp_wmi_read_int(HPWMI_HOTKEY_QUERY); if (key_code < 0) break; if (!sparse_keymap_report_event(hp_wmi_input_dev, key_code, 1, true)) pr_info("Unknown key code - 0x%x\n", key_code); break; case HPWMI_WIRELESS: if (rfkill2_count) { hp_wmi_rfkill2_refresh(); break; } if (wifi_rfkill) rfkill_set_states(wifi_rfkill, hp_wmi_get_sw_state(HPWMI_WIFI), hp_wmi_get_hw_state(HPWMI_WIFI)); if (bluetooth_rfkill) rfkill_set_states(bluetooth_rfkill, hp_wmi_get_sw_state(HPWMI_BLUETOOTH), hp_wmi_get_hw_state(HPWMI_BLUETOOTH)); if (wwan_rfkill) rfkill_set_states(wwan_rfkill, hp_wmi_get_sw_state(HPWMI_WWAN), hp_wmi_get_hw_state(HPWMI_WWAN)); break; case HPWMI_CPU_BATTERY_THROTTLE: pr_info("Unimplemented CPU throttle because of 3 Cell battery event detected\n"); break; case HPWMI_LOCK_SWITCH: break; case HPWMI_LID_SWITCH: break; case HPWMI_SCREEN_ROTATION: break; case HPWMI_COOLSENSE_SYSTEM_MOBILE: break; case HPWMI_COOLSENSE_SYSTEM_HOT: break; case HPWMI_PROXIMITY_SENSOR: break; case HPWMI_BACKLIT_KB_BRIGHTNESS: break; case HPWMI_PEAKSHIFT_PERIOD: break; case HPWMI_BATTERY_CHARGE_PERIOD: break; default: pr_info("Unknown event_id - %d - 0x%x\n", event_id, event_data); break; } }