* [PATCH v8 1/2] HID: add driver for Valve Steam Controller
From: Rodrigo Rivas Costa @ 2018-04-02 18:28 UTC (permalink / raw)
To: Benjamin Tissoires, Pierre-Loup A. Griffais,
Clément VUCHENER, Jiri Kosina, Cameron Gutman, lkml,
linux-input
Cc: Rodrigo Rivas Costa
In-Reply-To: <20180402182807.19878-1-rodrigorivascosta@gmail.com>
There are two ways to connect the Steam Controller: directly to the USB
or with the USB wireless adapter. Both methods are similar, but the
wireless adapter can connect up to 4 devices at the same time.
The wired device will appear as 3 interfaces: a virtual mouse, a virtual
keyboard and a custom HID device.
The wireless device will appear as 5 interfaces: a virtual keyboard and
4 custom HID devices, that will remain silent until a device is actually
connected.
The custom HID device has a report descriptor with all vendor specific
usages, so the hid-generic is not very useful. In a PC/SteamBox Valve
Steam Client provices a software translation by using hidraw and a
creates a uinput virtual gamepad and XTest keyboard/mouse.
This driver intercepts the hidraw usage, so it can get out of the way
when the Steam Client is in use.
Signed-off-by: Rodrigo Rivas Costa <rodrigorivascosta@gmail.com>
---
drivers/hid/Kconfig | 8 +
drivers/hid/Makefile | 1 +
drivers/hid/hid-ids.h | 4 +
drivers/hid/hid-steam.c | 973 ++++++++++++++++++++++++++++++++++++++++++++++++
include/linux/hid.h | 1 +
5 files changed, 987 insertions(+)
create mode 100644 drivers/hid/hid-steam.c
diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
index 779c5ae47f36..de5f4849bfe4 100644
--- a/drivers/hid/Kconfig
+++ b/drivers/hid/Kconfig
@@ -811,6 +811,14 @@ config HID_SPEEDLINK
---help---
Support for Speedlink Vicious and Divine Cezanne mouse.
+config HID_STEAM
+ tristate "Steam Controller support"
+ depends on HID
+ ---help---
+ Say Y here if you have a Steam Controller if you want to use it
+ without running the Steam Client. It supports both the wired and
+ the wireless adaptor.
+
config HID_STEELSERIES
tristate "Steelseries SRW-S1 steering wheel support"
depends on HID
diff --git a/drivers/hid/Makefile b/drivers/hid/Makefile
index 235bd2a7b333..e146c257285a 100644
--- a/drivers/hid/Makefile
+++ b/drivers/hid/Makefile
@@ -94,6 +94,7 @@ obj-$(CONFIG_HID_SAMSUNG) += hid-samsung.o
obj-$(CONFIG_HID_SMARTJOYPLUS) += hid-sjoy.o
obj-$(CONFIG_HID_SONY) += hid-sony.o
obj-$(CONFIG_HID_SPEEDLINK) += hid-speedlink.o
+obj-$(CONFIG_HID_STEAM) += hid-steam.o
obj-$(CONFIG_HID_STEELSERIES) += hid-steelseries.o
obj-$(CONFIG_HID_SUNPLUS) += hid-sunplus.o
obj-$(CONFIG_HID_GREENASIA) += hid-gaff.o
diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
index a0baa5ba5b84..3014991e5d4b 100644
--- a/drivers/hid/hid-ids.h
+++ b/drivers/hid/hid-ids.h
@@ -987,6 +987,10 @@
#define USB_VENDOR_ID_STANTUM_SITRONIX 0x1403
#define USB_DEVICE_ID_MTP_SITRONIX 0x5001
+#define USB_VENDOR_ID_VALVE 0x28de
+#define USB_DEVICE_ID_STEAM_CONTROLLER 0x1102
+#define USB_DEVICE_ID_STEAM_CONTROLLER_WIRELESS 0x1142
+
#define USB_VENDOR_ID_STEELSERIES 0x1038
#define USB_DEVICE_ID_STEELSERIES_SRWS1 0x1410
diff --git a/drivers/hid/hid-steam.c b/drivers/hid/hid-steam.c
new file mode 100644
index 000000000000..1e496075acbc
--- /dev/null
+++ b/drivers/hid/hid-steam.c
@@ -0,0 +1,973 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * HID driver for Valve Steam Controller
+ *
+ * Copyright (c) 2018 Rodrigo Rivas Costa <rodrigorivascosta@gmail.com>
+ *
+ * Supports both the wired and wireless interfaces.
+ *
+ * This controller has a builtin emulation of mouse and keyboard: the right pad
+ * can be used as a mouse, the shoulder buttons are mouse buttons, A and B
+ * buttons are ENTER and ESCAPE, and so on. This is implemented as additional
+ * HID interfaces.
+ *
+ * This is known as the "lizard mode", because apparently lizards like to use
+ * the computer from the coach, without a proper mouse and keyboard.
+ *
+ * This driver will disable the lizard mode when the input device is opened
+ * and re-enable it when the input device is closed, so as not to break user
+ * mode behaviour. The lizard_mode parameter can be used to change that.
+ *
+ * There are a few user space applications (notably Steam Client) that use
+ * the hidraw interface directly to create input devices (XTest, uinput...).
+ * In order to avoid breaking them this driver creates a layered hidraw device,
+ * so it can detect when the client is running and then:
+ * - it will not send any command to the controller.
+ * - this input device will be disabled, to avoid double input of the same
+ * user action.
+ *
+ * For additional functions, such as changing the right-pad margin or switching
+ * the led, you can use the user-space tool at:
+ *
+ * https://github.com/rodrigorc/steamctrl
+ */
+
+#include <linux/device.h>
+#include <linux/input.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+#include <linux/workqueue.h>
+#include <linux/mutex.h>
+#include <linux/rcupdate.h>
+#include <linux/delay.h>
+#include "hid-ids.h"
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Rodrigo Rivas Costa <rodrigorivascosta@gmail.com>");
+
+static bool lizard_mode = true;
+
+static DEFINE_MUTEX(steam_devices_lock);
+static LIST_HEAD(steam_devices);
+
+#define STEAM_QUIRK_WIRELESS BIT(0)
+
+/* Touch pads are 40 mm in diameter and 65535 units */
+#define STEAM_PAD_RESOLUTION 1638
+/* Trigger runs are about 5 mm and 256 units */
+#define STEAM_TRIGGER_RESOLUTION 51
+/* Joystick runs are about 5 mm and 256 units */
+#define STEAM_JOYSTICK_RESOLUTION 51
+
+#define STEAM_PAD_FUZZ 256
+
+/* Several commands can be sent in a feature report */
+#define STEAM_CMD_DISABLE_KEYS_CURSOR 0x81
+#define STEAM_CMD_GET_VERSION 0x83
+#define STEAM_CMD_ENABLE_KEYS_CURSOR 0x85
+#define STEAM_CMD_WRITE_REGISTER 0x87
+#define STEAM_CMD_ENABLE_MOUSE 0x8e
+#define STEAM_CMD_FORCEFEEDBAK 0x8f
+#define STEAM_CMD_REQUEST_COMM_STATUS 0xb4
+#define STEAM_CMD_GET_SERIAL 0xae
+
+/* Registers for command 0x87 */
+#define STEAM_REG_CURSOR_EMULATION 0x07
+#define STEAM_REG_MOUSE_EMULATION 0x08
+#define STEAM_REG_RPAD_MARGIN 0x18
+#define STEAM_REG_LED 0x2d
+#define STEAM_REG_GYRO_MODE 0x30
+
+/* Raw event identifiers */
+#define STEAM_EV_INPUT_DATA 0x01
+#define STEAM_EV_CONNECT 0x03
+#define STEAM_EV_BATTERY 0x04
+
+/* Values for GYRO_MODE (bitmask) */
+#define STEAM_GYRO_MODE_OFF 0x0000
+#define STEAM_GYRO_MODE_STEERING 0x0001
+#define STEAM_GYRO_MODE_TILT 0x0002
+#define STEAM_GYRO_MODE_SEND_ORIENTATION 0x0004
+#define STEAM_GYRO_MODE_SEND_RAW_ACCEL 0x0008
+#define STEAM_GYRO_MODE_SEND_RAW_GYRO 0x0010
+
+/* Other random constants */
+#define STEAM_SERIAL_LEN 10
+
+struct steam_device {
+ struct list_head list;
+ spinlock_t lock;
+ struct hid_device *hdev, *client_hdev;
+ struct mutex mutex;
+ bool client_opened, input_opened;
+ struct input_dev __rcu *input;
+ unsigned long quirks;
+ struct work_struct work_connect;
+ bool connected;
+ char serial_no[STEAM_SERIAL_LEN + 1];
+};
+
+static int steam_recv_report(struct steam_device *steam,
+ u8 *data, int size)
+{
+ struct hid_report *r;
+ u8 *buf;
+ int ret;
+
+ r = steam->hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[0];
+ if (hid_report_len(r) < 64)
+ return -EINVAL;
+
+ buf = hid_alloc_report_buf(r, GFP_KERNEL);
+ if (!buf)
+ return -ENOMEM;
+
+ /*
+ * The report ID is always 0, so strip the first byte from the output.
+ * hid_report_len() is not counting the report ID, so +1 to the length
+ * or else we get a EOVERFLOW. We are safe from a buffer overflow
+ * because hid_alloc_report_buf() allocates +7 bytes.
+ */
+ ret = hid_hw_raw_request(steam->hdev, 0x00,
+ buf, hid_report_len(r) + 1,
+ HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
+ if (ret > 0)
+ memcpy(data, buf + 1, min(size, ret - 1));
+ kfree(buf);
+ return ret;
+}
+
+static int steam_send_report(struct steam_device *steam,
+ u8 *cmd, int size)
+{
+ struct hid_report *r;
+ u8 *buf;
+ unsigned int retries = 10;
+ int ret;
+
+ r = steam->hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[0];
+ if (hid_report_len(r) < 64)
+ return -EINVAL;
+
+ buf = hid_alloc_report_buf(r, GFP_KERNEL);
+ if (!buf)
+ return -ENOMEM;
+
+ /* The report ID is always 0 */
+ memcpy(buf + 1, cmd, size);
+
+ /*
+ * Sometimes the wireless controller fails with EPIPE
+ * when sending a feature report.
+ * Doing a HID_REQ_GET_REPORT and waiting for a while
+ * seems to fix that.
+ */
+ do {
+ ret = hid_hw_raw_request(steam->hdev, 0,
+ buf, size + 1,
+ HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
+ if (ret != -EPIPE)
+ break;
+ steam_recv_report(steam, NULL, 0);
+ msleep(50);
+ } while (--retries);
+
+ kfree(buf);
+ if (ret < 0)
+ hid_err(steam->hdev, "%s: error %d (%*ph)\n", __func__,
+ ret, size, cmd);
+ return ret;
+}
+
+static inline int steam_send_report_byte(struct steam_device *steam, u8 cmd)
+{
+ return steam_send_report(steam, &cmd, 1);
+}
+
+static int steam_write_registers(struct steam_device *steam,
+ /* u8 reg, u16 val */...)
+{
+ /* Send: 0x87 len (reg valLo valHi)* */
+ u8 reg;
+ u16 val;
+ u8 cmd[64] = {STEAM_CMD_WRITE_REGISTER, 0x00};
+ va_list args;
+
+ va_start(args, steam);
+ for (;;) {
+ reg = va_arg(args, int);
+ if (reg == 0)
+ break;
+ val = va_arg(args, int);
+ cmd[cmd[1] + 2] = reg;
+ cmd[cmd[1] + 3] = val & 0xff;
+ cmd[cmd[1] + 4] = val >> 8;
+ cmd[1] += 3;
+ }
+ va_end(args);
+
+ return steam_send_report(steam, cmd, sizeof(cmd));
+}
+
+static int steam_get_serial(struct steam_device *steam)
+{
+ /*
+ * Send: 0xae 0x15 0x01
+ * Recv: 0xae 0x15 0x01 serialnumber (10 chars)
+ */
+ int ret;
+ u8 cmd[] = {STEAM_CMD_GET_SERIAL, 0x15, 0x01};
+ u8 reply[3 + STEAM_SERIAL_LEN + 1];
+
+ ret = steam_send_report(steam, cmd, sizeof(cmd));
+ if (ret < 0)
+ return ret;
+ ret = steam_recv_report(steam, reply, sizeof(reply));
+ if (ret < 0)
+ return ret;
+ reply[3 + STEAM_SERIAL_LEN] = 0;
+ strlcpy(steam->serial_no, reply + 3, sizeof(steam->serial_no));
+ return 0;
+}
+
+/*
+ * This command requests the wireless adaptor to post an event
+ * with the connection status. Useful if this driver is loaded when
+ * the controller is already connected.
+ */
+static inline int steam_request_conn_status(struct steam_device *steam)
+{
+ return steam_send_report_byte(steam, STEAM_CMD_REQUEST_COMM_STATUS);
+}
+
+static void steam_set_lizard_mode(struct steam_device *steam, bool enable)
+{
+ if (enable) {
+ /* enable esc, enter, cursors */
+ steam_send_report_byte(steam, STEAM_CMD_ENABLE_KEYS_CURSOR);
+ /* enable mouse */
+ steam_send_report_byte(steam, STEAM_CMD_ENABLE_MOUSE);
+ steam_write_registers(steam,
+ STEAM_REG_RPAD_MARGIN, 0x01, /* enable margin */
+ 0);
+ } else {
+ /* disable esc, enter, cursor */
+ steam_send_report_byte(steam, STEAM_CMD_DISABLE_KEYS_CURSOR);
+ steam_write_registers(steam,
+ STEAM_REG_MOUSE_EMULATION, 0x07, /* disable mouse */
+ STEAM_REG_RPAD_MARGIN, 0x00, /* disable margin */
+ 0);
+ }
+}
+
+static void steam_update_lizard_mode(struct steam_device *steam)
+{
+ mutex_lock(&steam->mutex);
+ if (!steam->client_opened) {
+ if (steam->input_opened)
+ steam_set_lizard_mode(steam, false);
+ else
+ steam_set_lizard_mode(steam, lizard_mode);
+ }
+ mutex_unlock(&steam->mutex);
+}
+
+static int steam_input_open(struct input_dev *dev)
+{
+ struct steam_device *steam = input_get_drvdata(dev);
+ int ret;
+
+ ret = hid_hw_open(steam->hdev);
+ if (ret)
+ return ret;
+
+ mutex_lock(&steam->mutex);
+ steam->input_opened = true;
+ if (!steam->client_opened && lizard_mode)
+ steam_set_lizard_mode(steam, false);
+ mutex_unlock(&steam->mutex);
+ return 0;
+}
+
+static void steam_input_close(struct input_dev *dev)
+{
+ struct steam_device *steam = input_get_drvdata(dev);
+
+ mutex_lock(&steam->mutex);
+ steam->input_opened = false;
+ if (!steam->client_opened && lizard_mode)
+ steam_set_lizard_mode(steam, true);
+ mutex_unlock(&steam->mutex);
+
+ hid_hw_close(steam->hdev);
+}
+
+static int steam_register(struct steam_device *steam)
+{
+ struct hid_device *hdev = steam->hdev;
+ struct input_dev *input;
+ int ret;
+
+ rcu_read_lock();
+ input = rcu_dereference(steam->input);
+ rcu_read_unlock();
+ if (input) {
+ dbg_hid("%s: already connected\n", __func__);
+ return 0;
+ }
+
+ ret = steam_get_serial(steam);
+ if (ret)
+ return ret;
+
+ hid_info(hdev, "Steam Controller '%s' connected",
+ steam->serial_no);
+
+ input = input_allocate_device();
+ if (!input)
+ return -ENOMEM;
+
+ input_set_drvdata(input, steam);
+ input->dev.parent = &hdev->dev;
+ input->open = steam_input_open;
+ input->close = steam_input_close;
+
+ input->name = (steam->quirks & STEAM_QUIRK_WIRELESS) ?
+ "Wireless Steam Controller" :
+ "Steam Controller";
+ input->phys = hdev->phys;
+ input->uniq = steam->serial_no;
+ input->id.bustype = hdev->bus;
+ input->id.vendor = hdev->vendor;
+ input->id.product = hdev->product;
+ input->id.version = hdev->version;
+
+ input_set_capability(input, EV_KEY, BTN_TR2);
+ input_set_capability(input, EV_KEY, BTN_TL2);
+ input_set_capability(input, EV_KEY, BTN_TR);
+ input_set_capability(input, EV_KEY, BTN_TL);
+ input_set_capability(input, EV_KEY, BTN_Y);
+ input_set_capability(input, EV_KEY, BTN_B);
+ input_set_capability(input, EV_KEY, BTN_X);
+ input_set_capability(input, EV_KEY, BTN_A);
+ input_set_capability(input, EV_KEY, BTN_DPAD_UP);
+ input_set_capability(input, EV_KEY, BTN_DPAD_RIGHT);
+ input_set_capability(input, EV_KEY, BTN_DPAD_LEFT);
+ input_set_capability(input, EV_KEY, BTN_DPAD_DOWN);
+ input_set_capability(input, EV_KEY, BTN_SELECT);
+ input_set_capability(input, EV_KEY, BTN_MODE);
+ input_set_capability(input, EV_KEY, BTN_START);
+ input_set_capability(input, EV_KEY, BTN_GEAR_DOWN);
+ input_set_capability(input, EV_KEY, BTN_GEAR_UP);
+ input_set_capability(input, EV_KEY, BTN_THUMBR);
+ input_set_capability(input, EV_KEY, BTN_THUMBL);
+ input_set_capability(input, EV_KEY, BTN_THUMB);
+ input_set_capability(input, EV_KEY, BTN_THUMB2);
+
+ input_set_abs_params(input, ABS_HAT2Y, 0, 255, 0, 0);
+ input_set_abs_params(input, ABS_HAT2X, 0, 255, 0, 0);
+ input_set_abs_params(input, ABS_X, -32767, 32767, 0, 0);
+ input_set_abs_params(input, ABS_Y, -32767, 32767, 0, 0);
+ input_set_abs_params(input, ABS_RX, -32767, 32767,
+ STEAM_PAD_FUZZ, 0);
+ input_set_abs_params(input, ABS_RY, -32767, 32767,
+ STEAM_PAD_FUZZ, 0);
+ input_set_abs_params(input, ABS_HAT0X, -32767, 32767,
+ STEAM_PAD_FUZZ, 0);
+ input_set_abs_params(input, ABS_HAT0Y, -32767, 32767,
+ STEAM_PAD_FUZZ, 0);
+ input_abs_set_res(input, ABS_X, STEAM_JOYSTICK_RESOLUTION);
+ input_abs_set_res(input, ABS_Y, STEAM_JOYSTICK_RESOLUTION);
+ input_abs_set_res(input, ABS_RX, STEAM_PAD_RESOLUTION);
+ input_abs_set_res(input, ABS_RY, STEAM_PAD_RESOLUTION);
+ input_abs_set_res(input, ABS_HAT0X, STEAM_PAD_RESOLUTION);
+ input_abs_set_res(input, ABS_HAT0Y, STEAM_PAD_RESOLUTION);
+ input_abs_set_res(input, ABS_HAT2Y, STEAM_TRIGGER_RESOLUTION);
+ input_abs_set_res(input, ABS_HAT2X, STEAM_TRIGGER_RESOLUTION);
+
+ ret = input_register_device(input);
+ if (ret)
+ goto input_register_fail;
+
+ rcu_assign_pointer(steam->input, input);
+
+ return 0;
+
+input_register_fail:
+ input_free_device(input);
+ return ret;
+}
+
+static void steam_unregister(struct steam_device *steam)
+{
+ struct input_dev *input;
+
+ rcu_read_lock();
+ input = rcu_dereference(steam->input);
+ rcu_read_unlock();
+
+ if (input) {
+ RCU_INIT_POINTER(steam->input, NULL);
+ synchronize_rcu();
+ hid_info(steam->hdev, "Steam Controller '%s' disconnected",
+ steam->serial_no);
+ input_unregister_device(input);
+ }
+}
+
+static void steam_work_connect_cb(struct work_struct *work)
+{
+ struct steam_device *steam = container_of(work, struct steam_device,
+ work_connect);
+ unsigned long flags;
+ bool connected;
+ int ret;
+
+ spin_lock_irqsave(&steam->lock, flags);
+ connected = steam->connected;
+ spin_unlock_irqrestore(&steam->lock, flags);
+
+ if (connected) {
+ ret = steam_register(steam);
+ if (ret) {
+ hid_err(steam->hdev,
+ "%s:steam_register failed with error %d\n",
+ __func__, ret);
+ }
+ } else {
+ steam_unregister(steam);
+ }
+}
+
+static bool steam_is_valve_interface(struct hid_device *hdev)
+{
+ struct hid_report_enum *rep_enum;
+
+ /*
+ * The wired device creates 3 interfaces:
+ * 0: emulated mouse.
+ * 1: emulated keyboard.
+ * 2: the real game pad.
+ * The wireless device creates 5 interfaces:
+ * 0: emulated keyboard.
+ * 1-4: slots where up to 4 real game pads will be connected to.
+ * We know which one is the real gamepad interface because they are the
+ * only ones with a feature report.
+ */
+ rep_enum = &hdev->report_enum[HID_FEATURE_REPORT];
+ return !list_empty(&rep_enum->report_list);
+}
+
+static int steam_client_ll_parse(struct hid_device *hdev)
+{
+ struct steam_device *steam = hid_get_drvdata(hdev);
+
+ return hid_parse_report(hdev, steam->hdev->dev_rdesc,
+ steam->hdev->dev_rsize);
+}
+
+static int steam_client_ll_start(struct hid_device *hdev)
+{
+ return 0;
+}
+
+static void steam_client_ll_stop(struct hid_device *hdev)
+{
+}
+
+static int steam_client_ll_open(struct hid_device *hdev)
+{
+ struct steam_device *steam = hid_get_drvdata(hdev);
+ int ret;
+
+ ret = hid_hw_open(steam->hdev);
+ if (ret)
+ return ret;
+
+ mutex_lock(&steam->mutex);
+ steam->client_opened = true;
+ mutex_unlock(&steam->mutex);
+ return ret;
+}
+
+static void steam_client_ll_close(struct hid_device *hdev)
+{
+ struct steam_device *steam = hid_get_drvdata(hdev);
+
+ mutex_lock(&steam->mutex);
+ steam->client_opened = false;
+ if (steam->input_opened)
+ steam_set_lizard_mode(steam, false);
+ else
+ steam_set_lizard_mode(steam, lizard_mode);
+ mutex_unlock(&steam->mutex);
+
+ hid_hw_close(steam->hdev);
+}
+
+static int steam_client_ll_raw_request(struct hid_device *hdev,
+ unsigned char reportnum, u8 *buf,
+ size_t count, unsigned char report_type,
+ int reqtype)
+{
+ struct steam_device *steam = hid_get_drvdata(hdev);
+
+ return hid_hw_raw_request(steam->hdev, reportnum, buf, count,
+ report_type, reqtype);
+}
+
+static struct hid_ll_driver steam_client_ll_driver = {
+ .parse = steam_client_ll_parse,
+ .start = steam_client_ll_start,
+ .stop = steam_client_ll_stop,
+ .open = steam_client_ll_open,
+ .close = steam_client_ll_close,
+ .raw_request = steam_client_ll_raw_request,
+};
+
+static struct hid_device *steam_create_client_hid(struct hid_device *hdev)
+{
+ struct hid_device *client_hdev;
+
+ client_hdev = hid_allocate_device();
+ if (IS_ERR(client_hdev))
+ return client_hdev;
+
+ client_hdev->ll_driver = &steam_client_ll_driver;
+ client_hdev->dev.parent = hdev->dev.parent;
+ client_hdev->bus = hdev->bus;
+ client_hdev->vendor = hdev->vendor;
+ client_hdev->product = hdev->product;
+ strlcpy(client_hdev->name, hdev->name,
+ sizeof(client_hdev->name));
+ strlcpy(client_hdev->phys, hdev->phys,
+ sizeof(client_hdev->phys));
+ /*
+ * Since we use the same device info than the real interface to
+ * trick userspace, we will be calling steam_probe recursively.
+ * We need to recognize the client interface somehow.
+ */
+ client_hdev->group = HID_GROUP_STEAM;
+ return client_hdev;
+}
+
+static int steam_probe(struct hid_device *hdev,
+ const struct hid_device_id *id)
+{
+ struct steam_device *steam;
+ int ret;
+
+ ret = hid_parse(hdev);
+ if (ret) {
+ hid_err(hdev,
+ "%s:parse of hid interface failed\n", __func__);
+ return ret;
+ }
+
+ /*
+ * The virtual client_dev is only used for hidraw.
+ * Also avoid the recursive probe.
+ */
+ if (hdev->group == HID_GROUP_STEAM)
+ return hid_hw_start(hdev, HID_CONNECT_HIDRAW);
+ /*
+ * The non-valve interfaces (mouse and keyboard emulation) are
+ * connected without changes.
+ */
+ if (!steam_is_valve_interface(hdev))
+ return hid_hw_start(hdev, HID_CONNECT_DEFAULT);
+
+ steam = devm_kzalloc(&hdev->dev, sizeof(*steam), GFP_KERNEL);
+ if (!steam) {
+ ret = -ENOMEM;
+ goto steam_alloc_fail;
+ }
+ steam->hdev = hdev;
+ hid_set_drvdata(hdev, steam);
+ spin_lock_init(&steam->lock);
+ mutex_init(&steam->mutex);
+ steam->quirks = id->driver_data;
+ INIT_WORK(&steam->work_connect, steam_work_connect_cb);
+
+ steam->client_hdev = steam_create_client_hid(hdev);
+ if (IS_ERR(steam->client_hdev)) {
+ ret = PTR_ERR(steam->client_hdev);
+ goto client_hdev_fail;
+ }
+ hid_set_drvdata(steam->client_hdev, steam);
+
+ /*
+ * With the real steam controller interface, do not connect hidraw.
+ * Instead, create the client_hid and connect that.
+ */
+ ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_HIDRAW);
+ if (ret)
+ goto hid_hw_start_fail;
+
+ ret = hid_add_device(steam->client_hdev);
+ if (ret)
+ goto client_hdev_add_fail;
+
+ if (steam->quirks & STEAM_QUIRK_WIRELESS) {
+ ret = hid_hw_open(hdev);
+ if (ret) {
+ hid_err(hdev,
+ "%s:hid_hw_open for wireless\n",
+ __func__);
+ goto hid_hw_open_fail;
+ }
+ hid_info(hdev, "Steam wireless receiver connected");
+ steam_request_conn_status(steam);
+ } else {
+ ret = steam_register(steam);
+ if (ret) {
+ hid_err(hdev,
+ "%s:steam_register failed with error %d\n",
+ __func__, ret);
+ goto input_register_fail;
+ }
+ }
+
+ mutex_lock(&steam_devices_lock);
+ steam_update_lizard_mode(steam);
+ list_add(&steam->list, &steam_devices);
+ mutex_unlock(&steam_devices_lock);
+
+ return 0;
+
+hid_hw_open_fail:
+input_register_fail:
+client_hdev_add_fail:
+ hid_hw_stop(hdev);
+hid_hw_start_fail:
+ hid_destroy_device(steam->client_hdev);
+client_hdev_fail:
+ cancel_work_sync(&steam->work_connect);
+steam_alloc_fail:
+ hid_err(hdev, "%s: failed with error %d\n",
+ __func__, ret);
+ return ret;
+}
+
+static void steam_remove(struct hid_device *hdev)
+{
+ struct steam_device *steam = hid_get_drvdata(hdev);
+
+ if (!steam || hdev->group == HID_GROUP_STEAM) {
+ hid_hw_stop(hdev);
+ return;
+ }
+
+ mutex_lock(&steam_devices_lock);
+ list_del(&steam->list);
+ mutex_unlock(&steam_devices_lock);
+
+ hid_destroy_device(steam->client_hdev);
+ steam->client_opened = false;
+ cancel_work_sync(&steam->work_connect);
+ if (steam->quirks & STEAM_QUIRK_WIRELESS) {
+ hid_info(hdev, "Steam wireless receiver disconnected");
+ hid_hw_close(hdev);
+ }
+ hid_hw_stop(hdev);
+ steam_unregister(steam);
+}
+
+static void steam_do_connect_event(struct steam_device *steam, bool connected)
+{
+ unsigned long flags;
+
+ spin_lock_irqsave(&steam->lock, flags);
+ steam->connected = connected;
+ spin_unlock_irqrestore(&steam->lock, flags);
+
+ if (schedule_work(&steam->work_connect) == 0)
+ dbg_hid("%s: connected=%d event already queued\n",
+ __func__, connected);
+}
+
+/*
+ * Some input data in the protocol has the opposite sign.
+ * Clamp the values to 32767..-32767 so that the range is
+ * symmetrical and can be negated safely.
+ */
+static inline s16 steam_le16(u8 *data)
+{
+ s16 x = (s16) le16_to_cpup((__le16 *)data);
+
+ return x == -32768 ? -32767 : x;
+}
+
+/*
+ * The size for this message payload is 60.
+ * The known values are:
+ * (* values are not sent through wireless)
+ * (* accelerator/gyro is disabled by default)
+ * Offset| Type | Mapped to |Meaning
+ * -------+-------+-----------+--------------------------
+ * 4-7 | u32 | -- | sequence number
+ * 8-10 | 24bit | see below | buttons
+ * 11 | u8 | ABS_HAT2Y | left trigger
+ * 12 | u8 | ABS_HAT2X | right trigger
+ * 13-15 | -- | -- | always 0
+ * 16-17 | s16 | ABS_X/ABS_HAT0X | X value
+ * 18-19 | s16 | ABS_Y/ABS_HAT0Y | Y value
+ * 20-21 | s16 | ABS_RX | right-pad X value
+ * 22-23 | s16 | ABS_RY | right-pad Y value
+ * 24-25 | s16 | -- | * left trigger
+ * 26-27 | s16 | -- | * right trigger
+ * 28-29 | s16 | -- | * accelerometer X value
+ * 30-31 | s16 | -- | * accelerometer Y value
+ * 32-33 | s16 | -- | * accelerometer Z value
+ * 34-35 | s16 | -- | gyro X value
+ * 36-36 | s16 | -- | gyro Y value
+ * 38-39 | s16 | -- | gyro Z value
+ * 40-41 | s16 | -- | quaternion W value
+ * 42-43 | s16 | -- | quaternion X value
+ * 44-45 | s16 | -- | quaternion Y value
+ * 46-47 | s16 | -- | quaternion Z value
+ * 48-49 | -- | -- | always 0
+ * 50-51 | s16 | -- | * left trigger (uncalibrated)
+ * 52-53 | s16 | -- | * right trigger (uncalibrated)
+ * 54-55 | s16 | -- | * joystick X value (uncalibrated)
+ * 56-57 | s16 | -- | * joystick Y value (uncalibrated)
+ * 58-59 | s16 | -- | * left-pad X value
+ * 60-61 | s16 | -- | * left-pad Y value
+ * 62-63 | u16 | -- | * battery voltage
+ *
+ * The buttons are:
+ * Bit | Mapped to | Description
+ * ------+------------+--------------------------------
+ * 8.0 | BTN_TR2 | right trigger fully pressed
+ * 8.1 | BTN_TL2 | left trigger fully pressed
+ * 8.2 | BTN_TR | right shoulder
+ * 8.3 | BTN_TL | left shoulder
+ * 8.4 | BTN_Y | button Y
+ * 8.5 | BTN_B | button B
+ * 8.6 | BTN_X | button X
+ * 8.7 | BTN_A | button A
+ * 9.0 | BTN_DPAD_UP | lef-pad up (but see diagonal issue below)
+ * 9.1 | BTN_DPAD_RIGHT | lef-pad right (ditto)
+ * 9.2 | BTN_DPAD_LEFT | lef-pad left (ditto)
+ * 9.3 | BTN_DPAD_DOWN | lef-pad down (ditto)
+ * 9.4 | BTN_SELECT | menu left
+ * 9.5 | BTN_MODE | steam logo
+ * 9.6 | BTN_START | menu right
+ * 9.7 | BTN_GEAR_DOWN | left back lever
+ * 10.0 | BTN_GEAR_UP | right back lever
+ * 10.1 | -- | left-pad clicked
+ * 10.2 | BTN_THUMBR | right-pad clicked
+ * 10.3 | BTN_THUMB | left-pad touched (but see explanation below)
+ * 10.4 | BTN_THUMB2 | right-pad touched
+ * 10.5 | -- | unknown
+ * 10.6 | BTN_THUMBL | joystick clicked
+ * 10.7 | -- | lpad_and_joy
+ */
+
+static void steam_do_input_event(struct steam_device *steam,
+ struct input_dev *input, u8 *data)
+{
+ /* 24 bits of buttons */
+ u8 b8, b9, b10;
+ s16 x, y;
+ bool lpad_touched, lpad_and_joy;
+
+ b8 = data[8];
+ b9 = data[9];
+ b10 = data[10];
+
+ input_report_abs(input, ABS_HAT2Y, data[11]);
+ input_report_abs(input, ABS_HAT2X, data[12]);
+
+ /*
+ * These two bits tells how to interpret the values X and Y.
+ * lpad_and_joy tells that the joystick and the lpad are used at the
+ * same time.
+ * lpad_touched tells whether X/Y are to be read as lpad coord or
+ * joystick values.
+ * (lpad_touched || lpad_and_joy) tells if the lpad is really touched.
+ */
+ lpad_touched = b10 & BIT(3);
+ lpad_and_joy = b10 & BIT(7);
+ x = steam_le16(data + 16);
+ y = -steam_le16(data + 18);
+
+ input_report_abs(input, lpad_touched ? ABS_HAT0X : ABS_X, x);
+ input_report_abs(input, lpad_touched ? ABS_HAT0Y : ABS_Y, y);
+ /* Check if joystick is centered */
+ if (lpad_touched && !lpad_and_joy) {
+ input_report_abs(input, ABS_X, 0);
+ input_report_abs(input, ABS_Y, 0);
+ }
+ /* Check if lpad is untouched */
+ if (!(lpad_touched || lpad_and_joy)) {
+ input_report_abs(input, ABS_HAT0X, 0);
+ input_report_abs(input, ABS_HAT0Y, 0);
+ }
+
+ input_report_abs(input, ABS_RX, steam_le16(data + 20));
+ input_report_abs(input, ABS_RY, -steam_le16(data + 22));
+
+ input_event(input, EV_KEY, BTN_TR2, !!(b8 & BIT(0)));
+ input_event(input, EV_KEY, BTN_TL2, !!(b8 & BIT(1)));
+ input_event(input, EV_KEY, BTN_TR, !!(b8 & BIT(2)));
+ input_event(input, EV_KEY, BTN_TL, !!(b8 & BIT(3)));
+ input_event(input, EV_KEY, BTN_Y, !!(b8 & BIT(4)));
+ input_event(input, EV_KEY, BTN_B, !!(b8 & BIT(5)));
+ input_event(input, EV_KEY, BTN_X, !!(b8 & BIT(6)));
+ input_event(input, EV_KEY, BTN_A, !!(b8 & BIT(7)));
+ input_event(input, EV_KEY, BTN_SELECT, !!(b9 & BIT(4)));
+ input_event(input, EV_KEY, BTN_MODE, !!(b9 & BIT(5)));
+ input_event(input, EV_KEY, BTN_START, !!(b9 & BIT(6)));
+ input_event(input, EV_KEY, BTN_GEAR_DOWN, !!(b9 & BIT(7)));
+ input_event(input, EV_KEY, BTN_GEAR_UP, !!(b10 & BIT(0)));
+ input_event(input, EV_KEY, BTN_THUMBR, !!(b10 & BIT(2)));
+ input_event(input, EV_KEY, BTN_THUMBL, !!(b10 & BIT(6)));
+ input_event(input, EV_KEY, BTN_THUMB, lpad_touched || lpad_and_joy);
+ input_event(input, EV_KEY, BTN_THUMB2, !!(b10 & BIT(4)));
+
+ /*
+ * I would like to map b9.0 to b9.3 to the BTN_DPAD_* but
+ * unfortunately they do not generate diagonals, and a DPAD
+ * without diagonals is worthless. So we synthesize the DPAD
+ * from the lpad coords and lpad_clicked
+ */
+ if (b10 & BIT(1)) {
+ if (lpad_touched) {
+ s16 x2 = abs(x / 2), y2 = abs(y / 2);
+
+ input_event(input, EV_KEY, BTN_DPAD_UP, y > x2);
+ input_event(input, EV_KEY, BTN_DPAD_RIGHT, x > y2);
+ input_event(input, EV_KEY, BTN_DPAD_LEFT, x < -y2);
+ input_event(input, EV_KEY, BTN_DPAD_DOWN, y < -x2);
+ }
+ } else {
+ input_event(input, EV_KEY, BTN_DPAD_UP, 0);
+ input_event(input, EV_KEY, BTN_DPAD_RIGHT, 0);
+ input_event(input, EV_KEY, BTN_DPAD_LEFT, 0);
+ input_event(input, EV_KEY, BTN_DPAD_DOWN, 0);
+ }
+
+ input_sync(input);
+}
+
+static int steam_raw_event(struct hid_device *hdev,
+ struct hid_report *report, u8 *data,
+ int size)
+{
+ struct steam_device *steam = hid_get_drvdata(hdev);
+ struct input_dev *input;
+
+ if (!steam)
+ return 0;
+
+ if (steam->client_opened)
+ hid_input_report(steam->client_hdev, HID_FEATURE_REPORT,
+ data, size, 0);
+ /*
+ * All messages are size=64, all values little-endian.
+ * The format is:
+ * Offset| Meaning
+ * -------+--------------------------------------------
+ * 0-1 | always 0x01, 0x00, maybe protocol version?
+ * 2 | type of message
+ * 3 | length of the real payload (not checked)
+ * 4-n | payload data, depends on the type
+ *
+ * There are these known types of message:
+ * 0x01: input data (60 bytes)
+ * 0x03: wireless connect/disconnect (1 byte)
+ * 0x04: battery status (11 bytes)
+ */
+
+ if (size != 64 || data[0] != 1 || data[1] != 0)
+ return 0;
+
+ switch (data[2]) {
+ case STEAM_EV_INPUT_DATA:
+ if (steam->client_opened)
+ return 0;
+ rcu_read_lock();
+ input = rcu_dereference(steam->input);
+ if (likely(input)) {
+ steam_do_input_event(steam, input, data);
+ } else {
+ dbg_hid("%s: input data without connect event\n",
+ __func__);
+ steam_do_connect_event(steam, true);
+ }
+ rcu_read_unlock();
+ break;
+ case STEAM_EV_CONNECT:
+ /*
+ * The payload of this event is a single byte:
+ * 0x01: disconnected.
+ * 0x02: connected.
+ */
+ switch (data[4]) {
+ case 0x01:
+ steam_do_connect_event(steam, false);
+ break;
+ case 0x02:
+ steam_do_connect_event(steam, true);
+ break;
+ }
+ break;
+ case STEAM_EV_BATTERY:
+ /* TODO: battery info */
+ break;
+ }
+ return 0;
+}
+
+static int steam_param_set_lizard_mode(const char *val,
+ const struct kernel_param *kp)
+{
+ struct steam_device *steam;
+ int ret;
+
+ ret = param_set_bool(val, kp);
+ if (ret)
+ return ret;
+
+ mutex_lock(&steam_devices_lock);
+ list_for_each_entry(steam, &steam_devices, list) {
+ steam_update_lizard_mode(steam);
+ }
+ mutex_unlock(&steam_devices_lock);
+ return 0;
+}
+
+static const struct kernel_param_ops steam_lizard_mode_ops = {
+ .set = steam_param_set_lizard_mode,
+ .get = param_get_bool,
+};
+
+module_param_cb(lizard_mode, &steam_lizard_mode_ops, &lizard_mode, 0644);
+MODULE_PARM_DESC(lizard_mode,
+ "Enable mouse and keyboard emulation (lizard mode) when the gamepad is not in use");
+
+static const struct hid_device_id steam_controllers[] = {
+ { /* Wired Steam Controller */
+ HID_USB_DEVICE(USB_VENDOR_ID_VALVE,
+ USB_DEVICE_ID_STEAM_CONTROLLER)
+ },
+ { /* Wireless Steam Controller */
+ HID_USB_DEVICE(USB_VENDOR_ID_VALVE,
+ USB_DEVICE_ID_STEAM_CONTROLLER_WIRELESS),
+ .driver_data = STEAM_QUIRK_WIRELESS
+ },
+ {}
+};
+
+MODULE_DEVICE_TABLE(hid, steam_controllers);
+
+static struct hid_driver steam_controller_driver = {
+ .name = "hid-steam",
+ .id_table = steam_controllers,
+ .probe = steam_probe,
+ .remove = steam_remove,
+ .raw_event = steam_raw_event,
+};
+
+module_hid_driver(steam_controller_driver);
diff --git a/include/linux/hid.h b/include/linux/hid.h
index d491027a7c22..5e5d76589954 100644
--- a/include/linux/hid.h
+++ b/include/linux/hid.h
@@ -364,6 +364,7 @@ struct hid_item {
#define HID_GROUP_RMI 0x0100
#define HID_GROUP_WACOM 0x0101
#define HID_GROUP_LOGITECH_DJ_DEVICE 0x0102
+#define HID_GROUP_STEAM 0x0103
/*
* HID protocol status
--
2.16.3
^ permalink raw reply related
* [PATCH v8 0/2] hid-steam driver with user mode client dection
From: Rodrigo Rivas Costa @ 2018-04-02 18:28 UTC (permalink / raw)
To: Benjamin Tissoires, Pierre-Loup A. Griffais,
Clément VUCHENER, Jiri Kosina, Cameron Gutman, lkml,
linux-input
Cc: Rodrigo Rivas Costa
Another reroll of the Steam Controller driver.
This time there is a complete rewrite of steam_probe(), that had been
growing _organically_. I gave up on trying to initialize the hidraw
device on partial probe failure, it makes the code much more complicated
and for little gain.
Maybe it is not to appropriate to add features on reroll 8, but...
now that we are, I think, race-free regarding to the Steam Client, and
I've been playing with a few games, I noticed a couple of issues:
* The right pad has a dead margin, I don't know what its use is, but
Steam Client disables it, so I'm doing the same in game-pad mode. It
just serves no function (left pad does not have it). I enable it
together with lizard-mode, of course.
* The DPAD (clicking on the border of the left pad) cannot emit
diagonals. That's not nice, so I'm currently synthesizing them from
the lpad coordinates. I don't know if it is appropriate... if not,
just let me know. This is register 0x18.
Since now there are quite a few registers and commands, I've added names
for the major constants in the protocol.
Also there was an overflow when any Y coordinate reached -32768, fixed.
And I changed the lizard_mode to a boolean parameter, but with a
callback. I've added a global list of steam_device to be able to do the
runtime change. The meaning of this parameter is now:
* When hidraw is in use, nothing is done.
* When the gamepad is in use, lizard_mode is always disabled.
* When the gamepad is not in use:
- lizard_mode=N: mouse/keyboard emulation disabled.
- lizard_mode=Y (default): mouse/keyboard emulation enabled.
Changes in v8:
* Add constants for the protocol major magic numbers.
* Disable/Enable margin of the rpad, together with the lizard-mode.
* Synthesize diagonals for the DPAD.
* Fix overflow with Y=-32768.
* Make lizard_mode parameter a bool, dynamically updatable.
Changes in v7:
* All the automatic lizard_mode stuff.
* Added the lizard_mode parameter.
* The patchset is reduced to 2 commits. The separation of the
steam_get_serial command no longer makes sense, since I need the
steam_send_cmd in the first commit to implement the lizard mode.
* Change the input mapping to conform to Documentation/gamepad.rst.
(v6 was a RFC, it does not count).
Changes in v5:
* Fix license SPDX to GPL-2.0+.
* Minor stylistic changes (BIT(3) instead 0x08 and so on).
Changes in v4:
* Add command to check the wireless connection status on probe, without
waiting for a message (thanks to Clément Vuchener for the tip).
* Removed the error code on redundant connection/disconnection messages. That
was harmless but polluted dmesg.
* Added buttons for touching the left-pad and right-pad.
* Fixed a misplaced #include from 2/4 to 1/4.
Changes in v3:
* Use RCU to do the dynamic connec/disconnect of wireless devices.
* Remove entries in hid-quirks.c as they are no longer needed. This allows
this module to be blacklisted without side effects.
* Do not bypass the virtual keyboard/mouse HID devices to avoid breaking
existing use cases (lizard mode). A user-space tool to do that is
linked.
* Fully separated axes for joystick and left-pad. As it happens.
* Add fuzz values for left/right pad axes, they are a little wiggly.
Changes in v2:
* Remove references to USB. Now the interesting interfaces are selected by
looking for the ones with feature reports.
* Feature reports buffers are allocated with hid_alloc_report_buf().
* Feature report length is checked, to avoid overflows in case of
corrupt/malicius USB devices.
* Resolution added to the ABS axes.
* A lot of minor cleanups.
Rodrigo Rivas Costa (2):
HID: add driver for Valve Steam Controller
HID: steam: add battery device.
drivers/hid/Kconfig | 8 +
drivers/hid/Makefile | 1 +
drivers/hid/hid-ids.h | 4 +
drivers/hid/hid-steam.c | 1112 +++++++++++++++++++++++++++++++++++++++++++++++
include/linux/hid.h | 1 +
5 files changed, 1126 insertions(+)
create mode 100644 drivers/hid/hid-steam.c
--
2.16.3
^ permalink raw reply
* Re: [v3,4/4] watchdog: add Gateworks System Controller support
From: Andrew Lunn @ 2018-04-02 16:32 UTC (permalink / raw)
To: Tim Harvey
Cc: Guenter Roeck, Mark Rutland, devicetree, linux-watchdog,
Dmitry Torokhov, linux-kernel, Rob Herring, Wim Van Sebroeck,
Mark Brown, linux-input, linux-hwmon, Lee Jones, linux-arm-kernel
In-Reply-To: <CAJ+vNU1f+SH16hs3heMA_A2KcbzbXXmJtPxi0uiL4+4tNWgYoQ@mail.gmail.com>
> The 'use case' we have been using this in for a couple years is that
> users who want to use this watchdog will enable it externally (we have
> a command in the bootloader) and if enabled the kernel driver (that
> I'm proposing here which we've been using out-of-tree) will register
> the watchdog device and the userspace watchdog process can open the
> device and start tickling it. If the watchdog is never enabled (or
> disabled via the bootloader command) the kernel driver fails to probe
> and the SoC's watchdog can be used.
Hi Tim
Is there any reason not to give the user the choice to use both
watchdogs? Normally you write drivers to expose the hardware, and then
let the users choice if they want to use it.
Andrew
^ permalink raw reply
* Re: [v3,4/4] watchdog: add Gateworks System Controller support
From: Tim Harvey @ 2018-04-02 16:07 UTC (permalink / raw)
To: Guenter Roeck
Cc: Lee Jones, Rob Herring, Mark Rutland, Mark Brown, Dmitry Torokhov,
Wim Van Sebroeck, linux-kernel, devicetree, linux-arm-kernel,
linux-hwmon, linux-input, linux-watchdog
In-Reply-To: <20180330181954.GA17580@roeck-us.net>
On Fri, Mar 30, 2018 at 11:19 AM, Guenter Roeck <linux@roeck-us.net> wrote:
> On Fri, Mar 30, 2018 at 10:49:38AM -0700, Tim Harvey wrote:
>> On Thu, Mar 29, 2018 at 6:07 PM, Guenter Roeck <linux@roeck-us.net> wrote:
>> > On Wed, Mar 28, 2018 at 08:14:03AM -0700, Tim Harvey wrote:
>> >> Signed-off-by: Tim Harvey <tharvey@gateworks.com>
>> >> ---
>> >> drivers/watchdog/Kconfig | 10 ++++
>> >> drivers/watchdog/Makefile | 1 +
>> >> drivers/watchdog/gsc_wdt.c | 146 +++++++++++++++++++++++++++++++++++++++++++++
>> >> 3 files changed, 157 insertions(+)
>> >> create mode 100644 drivers/watchdog/gsc_wdt.c
>> >>
>> <snip>
>> >> +
>> >> +static const struct watchdog_info gsc_wdt_info = {
>> >> + .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
>> >
>> > Please confirm that WDIOF_MAGICCLOSE is not set on purpose.
>> >
>> >> + .identity = "GSC Watchdog"
>> >> +};
>> >> +
>> <snip>
>> >> +
>> >> +static int gsc_wdt_probe(struct platform_device *pdev)
>> >> +{
>> >> + struct gsc_dev *gsc = dev_get_drvdata(pdev->dev.parent);
>> >> + struct device *dev = &pdev->dev;
>> >> + struct gsc_wdt *wdt;
>> >> + int ret;
>> >> + unsigned int reg;
>> >> +
>> <snip>
>> >> + /* ensure WD bit enabled */
>> >> + if (regmap_read(gsc->regmap, GSC_CTRL_1, ®))
>> >> + return -EIO;
>> >> + if (!(reg & (1 << GSC_CTRL_1_WDT_ENABLE))) {
>> >
>> > BIT()
>> >
>> >> + dev_err(dev, "not enabled - must be manually enabled\n");
>> >
>> > This doesn't make sense. Bail out if the watchdog is disabled ? Why ?
>> >
>> >> + return -EINVAL;
>> >> + }
>> >> +
>> <snip>
>> >> +
>> >> + watchdog_set_nowayout(&wdt->wdt_dev, 1);
>> >
>> > WATCHDOG_NOWAYOUT ?
>> >
>>
>> Guenter,
>>
>> Thanks for the review!
>>
>> The watchdog implementation of the GSC is such that it is enabled and
>> reset via a single non-volatile I2C register bit. If this bit is set
>> the watchdog will start ticking down automatically on board power up.
>> The register definitions don't provide a condition where it can be
>> enabled in a volatile way such that after board power-cycle it is
>> disabled again nor do they provide a separate register for enable vs
>> reset.
>>
>> In the typical case the user boots the board, driver registers
>> watchdog, userspace watchdog daemon enables watchdog and it starts
>> ticking. User now powers down the board and later powers it back up.
>> The watchdog was enabled previously by userspace and the register is
>> non-volatile so the watchdog starts ticking before the kernel driver
>> and watchdog daemon yet the user breaks out into the bootloader or
>> boots a different OS without a watchdog daemon and the board resets
>> without them expecting it. The feature that the watchdog starts
>> ticking at board power-up before the CPU has even fetched code was
>> part of its design and was put there to work around some SoC errata
>> that can cause the CPU to fail to fetch boot code. This has caused me
>> to implement a watchdog driver that never actually 'enables' or
>> 'disables' the watchdog which is why there is no MAGIC CLOSE and why I
>
> Yet the driver does enable and disable the watchdog in its start and stop
> functions. And I have no idea what that has to do with the MAGICCLOSE
> functionality, which is quite orthogonal to the start/stop functionality.
>
>> always set nowayout. Its possible this is a fairly unique case of a
>> watchdog. The probe failure if the watchdog isn't enabled is because I
>> don't want a non-enabled watchdog to get enabled just because the
>> driver/daemon were there.
>>
> Huh ? The whole purpose of a watchdog is for it to be enabled when
> the watchdog device is opened.
>
>> I agree it's a very strange behavior and I'm not sure how to best
>> document or support it with the Linux watchdog API. I welcome any
>> recomendations!
>>
>
> Sorry, I fail to understand your logic.
>
> You do not explain why your code bails out if the watchdog is not already
> running. That does not make sense.
>
> You are saying that you don't want the watchdog driver to enable the watchdog.
> Since its whole purpose is to enable the watchdog if/when the watchdog device
> is opened, that doesn't make sense either.
>
> At the same time, you do not tell the watchdog core that the watchdog is
> already running, meaning the system _will_ reboot unless the watchdog
> device is opened within the watchdog timeout period. Again, that does not
> make sense.
>
> Maybe it all makes sense to you, but not to me, sorry.
Guenter,
Right, I'm likely not explaining it well. Let me show the registers
and describe the feature from the GSC perspective:
I2C registers: non-volatile registers (battery backed)
0x01: GSC_CTRL_1: Sleep Wakeup Timer Control
bit 4: WATCHDOG_TIME: 0=30 second timeout, 1=60 second timeout
bit 5: WATCHDOG_ENABLE: 0=disable watchdog, 1=enable/reset watchdog timer
The GSC has the ability to enable/disable the primary board power
supply. In the event that the watchdog timer is enabled and reaches 0
it will power cycle the board by disabling the primary power supply
for 1 second then enabling it again. The GSC_CTRL_1 bits retain their
state during power cycles thus if WATCHDOG_ENABLE=1 and the board
power cycles the watchdog starts counting down immediately and host
software must either disable it or start resetting it before the
timeout period.
The 'use case' we have been using this in for a couple years is that
users who want to use this watchdog will enable it externally (we have
a command in the bootloader) and if enabled the kernel driver (that
I'm proposing here which we've been using out-of-tree) will register
the watchdog device and the userspace watchdog process can open the
device and start tickling it. If the watchdog is never enabled (or
disabled via the bootloader command) the kernel driver fails to probe
and the SoC's watchdog can be used. The reason this feature was added
to the GSC is that we had some errata with one of the SoC's we use
such that it's internal reset was not resetting enough of the chip and
in some cases we also wanted an external PMIC to be reset as well
which is accomplished by cycling the primary power supply.
What I'm proposing here is a watchdog driver that only has the ability
to 'reset' the watchdog timer 'if enabled'. Because the same register
is used to enable as well as reset the timer I don't want to
enable/reset it if it isn't already enabled.
Because start/stop are mandatory I suppose I could make stop a nop and
make start only set WATCHDOG_TIME if it's already set. I was thinking
that I would simply have the driver probe fail if the watchdog wasn't
externally already enabled and let /dev/watchdog0 be the sometimes
lesser valued SoC watchdog.
Regards,
Tim
^ permalink raw reply
* [PATCH] Input: synaptics-rmi4 - Fix an unchecked out of memory error path
From: Christophe JAILLET @ 2018-04-02 14:03 UTC (permalink / raw)
To: dmitry.torokhov, benjamin.tissoires, gregkh
Cc: linux-input, linux-kernel, kernel-janitors, Christophe JAILLET
When extending the rmi_spi buffers, we must check that no out of memory
error occurs, otherwise we may access data above the currently allocated
memory.
Propagate the error code returned by 'rmi_spi_manage_pools()' instead.
Signed-off-by: Christophe JAILLET <christophe.jaillet@wanadoo.fr>
---
drivers/input/rmi4/rmi_spi.c | 7 +++++--
1 file changed, 5 insertions(+), 2 deletions(-)
diff --git a/drivers/input/rmi4/rmi_spi.c b/drivers/input/rmi4/rmi_spi.c
index 76edbf2c1bce..082defc329a8 100644
--- a/drivers/input/rmi4/rmi_spi.c
+++ b/drivers/input/rmi4/rmi_spi.c
@@ -147,8 +147,11 @@ static int rmi_spi_xfer(struct rmi_spi_xport *rmi_spi,
if (len > RMI_SPI_XFER_SIZE_LIMIT)
return -EINVAL;
- if (rmi_spi->xfer_buf_size < len)
- rmi_spi_manage_pools(rmi_spi, len);
+ if (rmi_spi->xfer_buf_size < len) {
+ ret = rmi_spi_manage_pools(rmi_spi, len);
+ if (ret < 0)
+ return ret;
+ }
if (addr == 0)
/*
--
2.14.1
^ permalink raw reply related
* [PATCH 2/2] Documentation: devices.txt: remove the mk712 touchscreen device from the list
From: Martin Kepplinger @ 2018-04-02 12:55 UTC (permalink / raw)
To: corbet, dmitry.torokhov
Cc: gregkh, logang, stefanha, linux-doc, linux-kernel, linux-input,
Martin Kepplinger
In-Reply-To: <20180402125551.13641-1-martink@posteo.de>
The input/touchscreen/mk712.c driver has been rewritten for the common
input event system. in 2005. There shouldn't a special device node be
created anymore.
Signed-off-by: Martin Kepplinger <martink@posteo.de>
---
Please review this by looking at the driver too. Thanks,
martin
Documentation/admin-guide/devices.txt | 1 -
1 file changed, 1 deletion(-)
diff --git a/Documentation/admin-guide/devices.txt b/Documentation/admin-guide/devices.txt
index 4ec843123cc3..fb39bbf0789a 100644
--- a/Documentation/admin-guide/devices.txt
+++ b/Documentation/admin-guide/devices.txt
@@ -259,7 +259,6 @@
11 = /dev/vrtpanel Vr41xx embedded touch panel
13 = /dev/vpcmouse Connectix Virtual PC Mouse
14 = /dev/touchscreen/ucb1x00 UCB 1x00 touchscreen
- 15 = /dev/touchscreen/mk712 MK712 touchscreen
128 = /dev/beep Fancy beep device
129 =
130 = /dev/watchdog Watchdog timer port
--
2.16.2
^ permalink raw reply related
* [PATCH 1/2] Input: mk712: update documentation web link
From: Martin Kepplinger @ 2018-04-02 12:55 UTC (permalink / raw)
To: corbet, dmitry.torokhov
Cc: gregkh, logang, stefanha, linux-doc, linux-kernel, linux-input,
Martin Kepplinger
At the mentioned address there's nothing found. By searching information
on the controller chip still can be found, so update the link to the
resulting page.
Signed-off-by: Martin Kepplinger <martink@posteo.de>
---
drivers/input/touchscreen/mk712.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/drivers/input/touchscreen/mk712.c b/drivers/input/touchscreen/mk712.c
index bd5352824f77..c179060525ae 100644
--- a/drivers/input/touchscreen/mk712.c
+++ b/drivers/input/touchscreen/mk712.c
@@ -17,7 +17,7 @@
* found in Gateway AOL Connected Touchpad computers.
*
* Documentation for ICS MK712 can be found at:
- * http://www.idt.com/products/getDoc.cfm?docID=18713923
+ * https://www.idt.com/general-parts/mk712-touch-screen-controller
*/
/*
--
2.16.2
^ permalink raw reply related
* Sony Vaio VGN-CS31S touch sensor buttons breaking touchpad
From: Ondrej Zary @ 2018-04-01 21:21 UTC (permalink / raw)
To: Dmitry Torokhov; +Cc: linux-input, linux-kernel
Hello,
I got a Sony Vaio VGN-CS31S laptop with Synaptics touchpad that exhibits weird
behavior. It seems to work until I touch the "Touch Sensor Buttons" bar above
the keyboard - then the buttons start to act weirdly: click or remain pressed
(sometimes it breaks even without touching the bar).
It seems to be a known problem with VGN-CS series:
https://bugs.launchpad.net/ubuntu/+source/xserver-xorg-input-synaptics/+bug/774877
https://wiki.freegeekvancouver.org/article/Laptop_Troubleshooting
(mentions nasty partial workaround: psmouse.resetafter=1)
Many models of the VGN-CS series have the Touch Sensor Buttons:
ftp://124.40.41.224/PUB/MANUALS/SWT/Z009/Z009690111.PDF
From the hardware side (can be found in MBX-196 Quanta GD2 schematic), the
touch bar is a separate PS/2 device connected to third PS/2 port of the EC
(Embedded Controller) WPC775L. The touchpad is on the 1st PS/2 port, 2nd port
is unused. However, the i8042 does not seem to support multiplexing, the
firmware probably combines the data internally somehow.
In plain PS/2 mode, the touch bar does not interfere with touchpad.
In Windows, the touch bar starts to work only after installing the Synaptics
touchpad driver - the correct one from Sony. Using generic Synaptics touchpad
driver causes problems similar to the Linux problems.
The touchpad is:
psmouse serio1: synaptics: Touchpad model: 1, fw: 7.0, id: 0x1c0b1, caps: 0xd04711/0xa00000/0x20000/0x0, board id: 0, fw id: 544294
Did some experiments with i8042.debug=1. The driver loses sync because the
packet format does not look right:
Apr 1 21:06:30 test kernel: [ 67.145676] i8042: [16635] 80 <- i8042 (interrupt, 1, 12)
Apr 1 21:06:30 test kernel: [ 67.151115] i8042: [16636] 00 <- i8042 (interrupt, 1, 12)
Apr 1 21:06:30 test kernel: [ 67.155446] i8042: [16637] 00 <- i8042 (interrupt, 1, 12)
Apr 1 21:06:30 test kernel: [ 67.156883] i8042: [16638] c0 <- i8042 (interrupt, 1, 12)
Apr 1 21:06:30 test kernel: [ 67.160885] i8042: [16639] 00 <- i8042 (interrupt, 1, 12)
Apr 1 21:06:30 test kernel: [ 67.165449] i8042: [16640] 00 <- i8042 (interrupt, 1, 12)
Apr 1 21:06:30 test kernel: [ 67.166884] i8042: [16640] 80 <- i8042 (interrupt, 1, 12)
Apr 1 21:06:30 test kernel: [ 67.171182] i8042: [16641] 00 <- i8042 (interrupt, 1, 12)
Apr 1 21:06:30 test kernel: [ 67.175507] i8042: [16642] 00 <- i8042 (interrupt, 1, 12)
Apr 1 21:06:30 test kernel: [ 67.176881] i8042: [16643] 80 <- i8042 (interrupt, 1, 12)
Apr 1 21:06:30 test kernel: [ 67.177525] psmouse serio1: TouchPad at isa0060/serio1/input0 lost sync at byte 4
Apr 1 21:06:30 test kernel: [ 67.180885] i8042: [16644] 00 <- i8042 (interrupt, 1, 12)
Apr 1 21:06:30 test kernel: [ 67.181635] psmouse serio1: TouchPad at isa0060/serio1/input0 lost sync at byte 1
Apr 1 21:06:30 test kernel: [ 67.182392] i8042: [16644] 00 <- i8042 (interrupt, 1, 12)
Apr 1 21:06:30 test kernel: [ 67.183171] psmouse serio1: TouchPad at isa0060/serio1/input0 lost sync at byte 1
Apr 1 21:06:30 test kernel: [ 67.185486] i8042: [16645] c0 <- i8042 (interrupt, 1, 12)
Apr 1 21:06:30 test kernel: [ 67.186453] psmouse serio1: TouchPad at isa0060/serio1/input0 lost sync at byte 1
Apr 1 21:06:30 test kernel: [ 67.187427] i8042: [16645] 00 <- i8042 (interrupt, 1, 12)
Apr 1 21:06:30 test kernel: [ 67.188420] psmouse serio1: TouchPad at isa0060/serio1/input0 lost sync at byte 1
Apr 1 21:06:30 test kernel: [ 67.189486] psmouse serio1: issuing reconnect request
Apr 1 21:06:43 test kernel: [ 79.895504] i8042: [19822] 80 <- i8042 (interrupt, 1, 12)
Apr 1 21:06:43 test kernel: [ 79.899991] i8042: [19823] 00 <- i8042 (interrupt, 1, 12)
Apr 1 21:06:43 test kernel: [ 79.905554] i8042: [19825] 00 <- i8042 (interrupt, 1, 12)
Apr 1 21:06:43 test kernel: [ 79.909992] i8042: [19826] 90 <- i8042 (interrupt, 1, 12)
Apr 1 21:06:43 test kernel: [ 79.910673] psmouse serio1: TouchPad at isa0060/serio1/input0 lost sync at byte 4
Apr 1 21:06:43 test kernel: [ 79.915454] i8042: [19827] ab <- i8042 (interrupt, 1, 12)
Apr 1 21:06:43 test kernel: [ 79.916254] psmouse serio1: TouchPad at isa0060/serio1/input0 lost sync at byte 1
Apr 1 21:06:43 test kernel: [ 79.919989] i8042: [19828] 57 <- i8042 (interrupt, 1, 12)
Apr 1 21:06:43 test kernel: [ 79.920874] psmouse serio1: TouchPad at isa0060/serio1/input0 lost sync at byte 1
Apr 1 21:06:43 test kernel: [ 79.925551] i8042: [19830] c0 <- i8042 (interrupt, 1, 12)
Apr 1 21:06:43 test kernel: [ 79.926540] psmouse serio1: TouchPad at isa0060/serio1/input0 lost sync at byte 1
Apr 1 21:06:43 test kernel: [ 79.929992] i8042: [19831] c7 <- i8042 (interrupt, 1, 12)
Apr 1 21:06:43 test kernel: [ 79.931097] psmouse serio1: TouchPad at isa0060/serio1/input0 lost sync at byte 1
Apr 1 21:06:43 test kernel: [ 79.932184] psmouse serio1: issuing reconnect request
Modified synaptics.c to force SYN_NEWABS_RELAXED check
normal touchpad touch:
Apr 1 23:00:27 test kernel: [ 6041.792418] i8042: [1510297] 90 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.793860] i8042: [1510297] df <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.796976] i8042: [1510298] 21 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.801655] i8042: [1510299] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.806975] i8042: [1510300] 20 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.808348] i8042: [1510301] 2f <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.811710] i8042: [1510301] 90 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.816971] i8042: [1510303] df <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.821647] i8042: [1510304] 2e <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.826974] i8042: [1510305] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.828347] i8042: [1510306] 1c <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.831648] i8042: [1510306] 27 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.837019] i8042: [1510308] 90 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.838342] i8042: [1510308] cf <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.841673] i8042: [1510309] 32 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.846974] i8042: [1510310] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.848343] i8042: [1510311] 17 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.851678] i8042: [1510311] f0 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.857026] i8042: [1510313] 90 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.858341] i8042: [1510313] cf <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.861688] i8042: [1510314] 38 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.867009] i8042: [1510315] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.868338] i8042: [1510316] 13 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.871682] i8042: [1510316] 84 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.877204] i8042: [1510318] 90 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.881691] i8042: [1510319] cf <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.887021] i8042: [1510320] 38 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.888337] i8042: [1510321] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.889798] i8042: [1510321] 12 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.892374] i8042: [1510322] 3e <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.893921] i8042: [1510322] 90 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.897957] i8042: [1510323] cf <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.902569] i8042: [1510324] 38 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.907954] i8042: [1510325] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.912579] i8042: [1510327] 12 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.917956] i8042: [1510328] 2a <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.922668] i8042: [1510329] 90 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.927952] i8042: [1510330] cf <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.932421] i8042: [1510332] 27 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.933923] i8042: [1510332] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.937951] i8042: [1510333] 1a <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.942593] i8042: [1510334] 12 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.948000] i8042: [1510335] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.949323] i8042: [1510336] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.952605] i8042: [1510337] 02 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.957945] i8042: [1510338] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.962612] i8042: [1510339] 01 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.967946] i8042: [1510340] 01 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.969323] i8042: [1510341] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.970770] i8042: [1510341] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.973382] i8042: [1510342] 01 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.974849] i8042: [1510342] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.978943] i8042: [1510343] 01 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.983554] i8042: [1510344] 01 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.988943] i8042: [1510346] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.993558] i8042: [1510347] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6041.998942] i8042: [1510348] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6042.003575] i8042: [1510349] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6042.008939] i8042: [1510351] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6042.013565] i8042: [1510352] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6042.018936] i8042: [1510353] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6042.020316] i8042: [1510354] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6042.023573] i8042: [1510354] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6042.028938] i8042: [1510356] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6042.033591] i8042: [1510357] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:00:27 test kernel: [ 6042.038933] i8042: [1510358] 00 <- i8042 (interrupt, 1, 12)
touch bar touch:
Apr 1 23:03:27 test kernel: [ 6221.856377] i8042: [1555313] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.859577] i8042: [1555313] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.860921] i8042: [1555314] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.862280] i8042: [1555314] c4 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.865071] i8042: [1555315] 0f <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.866424] i8042: [1555315] aa <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.870708] i8042: [1555316] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.872049] i8042: [1555317] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.875087] i8042: [1555317] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.876446] i8042: [1555318] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.877793] i8042: [1555318] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.881005] i8042: [1555319] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.882446] i8042: [1555319] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.883797] i8042: [1555319] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.886578] i8042: [1555320] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.887940] i8042: [1555320] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.889279] i8042: [1555321] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.892657] i8042: [1555322] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.894097] i8042: [1555322] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.897087] i8042: [1555323] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.898428] i8042: [1555323] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.899789] i8042: [1555323] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.903004] i8042: [1555324] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.904354] i8042: [1555325] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.907681] i8042: [1555325] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.909029] i8042: [1555326] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.910370] i8042: [1555326] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.913704] i8042: [1555327] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.915044] i8042: [1555327] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.916395] i8042: [1555328] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.919296] i8042: [1555328] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.920646] i8042: [1555329] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.921993] i8042: [1555329] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.925230] i8042: [1555330] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.926568] i8042: [1555330] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.927913] i8042: [1555330] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.931855] i8042: [1555331] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.933204] i8042: [1555332] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.936503] i8042: [1555333] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.937868] i8042: [1555333] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.939210] i8042: [1555333] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.942000] i8042: [1555334] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.944494] i8042: [1555335] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.947702] i8042: [1555335] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.949041] i8042: [1555336] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.950403] i8042: [1555336] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.953197] i8042: [1555337] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.954548] i8042: [1555337] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.958829] i8042: [1555338] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.960171] i8042: [1555339] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.963207] i8042: [1555339] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.964568] i8042: [1555340] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.965917] i8042: [1555340] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.969156] i8042: [1555341] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.970598] i8042: [1555341] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.971944] i8042: [1555341] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.974732] i8042: [1555342] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.976093] i8042: [1555343] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.977436] i8042: [1555343] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.980759] i8042: [1555344] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.982201] i8042: [1555344] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.985236] i8042: [1555345] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.986579] i8042: [1555345] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.987941] i8042: [1555345] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.991157] i8042: [1555346] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.992507] i8042: [1555347] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.995833] i8042: [1555347] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.997181] i8042: [1555348] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6221.998520] i8042: [1555348] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.001908] i8042: [1555349] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.003250] i8042: [1555349] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.006331] i8042: [1555350] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.007772] i8042: [1555350] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.009122] i8042: [1555351] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.012320] i8042: [1555352] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.013683] i8042: [1555352] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.015024] i8042: [1555352] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.017823] i8042: [1555353] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.020317] i8042: [1555354] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.023623] i8042: [1555354] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.024964] i8042: [1555355] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.026326] i8042: [1555355] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.029118] i8042: [1555356] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.030469] i8042: [1555356] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.034643] i8042: [1555357] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.036366] i8042: [1555358] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.039124] i8042: [1555358] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.040484] i8042: [1555359] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.041836] i8042: [1555359] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.045172] i8042: [1555360] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.046613] i8042: [1555360] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.049649] i8042: [1555361] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.050990] i8042: [1555361] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.052352] i8042: [1555362] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.055571] i8042: [1555362] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.056922] i8042: [1555363] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.058363] i8042: [1555363] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.061146] i8042: [1555364] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.062486] i8042: [1555364] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.063848] i8042: [1555364] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.067175] i8042: [1555365] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.068525] i8042: [1555366] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.071681] i8042: [1555366] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.073021] i8042: [1555367] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.074363] i8042: [1555367] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.077611] i8042: [1555368] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.078959] i8042: [1555368] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.080309] i8042: [1555369] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.083181] i8042: [1555369] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.084531] i8042: [1555370] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.085874] i8042: [1555370] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.089214] i8042: [1555371] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.090556] i8042: [1555371] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.091907] i8042: [1555371] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.094807] i8042: [1555372] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.096156] i8042: [1555373] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.097504] i8042: [1555373] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.100741] i8042: [1555374] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.102081] i8042: [1555374] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.103422] i8042: [1555374] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.107366] i8042: [1555375] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.108716] i8042: [1555376] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.112071] i8042: [1555377] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.113434] i8042: [1555377] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.116512] i8042: [1555378] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.117863] i8042: [1555378] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.122036] i8042: [1555379] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.123377] i8042: [1555379] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.124717] i8042: [1555380] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.127532] i8042: [1555380] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.128876] i8042: [1555381] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.130227] i8042: [1555381] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.133626] i8042: [1555382] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.134974] i8042: [1555382] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.138018] i8042: [1555383] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.139379] i8042: [1555383] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.140718] i8042: [1555384] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.143935] i8042: [1555384] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.145376] i8042: [1555385] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.146724] i8042: [1555385] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.149508] i8042: [1555386] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.150870] i8042: [1555386] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.152210] i8042: [1555387] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.155539] i8042: [1555387] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.158031] i8042: [1555388] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.160834] i8042: [1555389] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.162174] i8042: [1555389] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.163536] i8042: [1555389] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.166759] i8042: [1555390] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.168111] i8042: [1555391] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.171437] i8042: [1555391] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.172783] i8042: [1555392] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.174124] i8042: [1555392] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.177456] i8042: [1555393] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.178798] i8042: [1555393] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.180149] i8042: [1555394] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.183050] i8042: [1555394] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.184399] i8042: [1555395] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.185742] i8042: [1555395] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.189005] i8042: [1555396] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.190342] i8042: [1555396] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.191686] i8042: [1555396] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.195615] i8042: [1555397] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.197150] i8042: [1555398] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.200279] i8042: [1555399] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.201636] i8042: [1555399] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.203151] i8042: [1555399] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.205767] i8042: [1555400] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.208435] i8042: [1555401] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.211470] i8042: [1555401] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.212799] i8042: [1555402] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.214345] i8042: [1555402] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.216960] i8042: [1555403] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.218315] i8042: [1555403] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.222805] i8042: [1555404] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.227150] i8042: [1555405] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.232422] i8042: [1555407] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.233805] i8042: [1555407] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.235314] i8042: [1555407] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.238096] i8042: [1555408] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.243564] i8042: [1555409] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.245088] i8042: [1555410] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.248123] i8042: [1555411] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.253384] i8042: [1555412] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.254743] i8042: [1555412] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.256073] i8042: [1555413] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.258987] i8042: [1555413] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.260336] i8042: [1555414] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.261675] i8042: [1555414] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.265190] i8042: [1555415] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.269670] i8042: [1555416] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.274896] i8042: [1555417] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.276348] i8042: [1555418] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.277668] i8042: [1555418] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.280461] i8042: [1555419] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.281833] i8042: [1555419] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.283180] i8042: [1555419] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.286501] i8042: [1555420] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.287936] i8042: [1555420] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.290993] i8042: [1555421] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.292341] i8042: [1555422] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.293696] i8042: [1555422] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.296943] i8042: [1555423] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.298287] i8042: [1555423] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.299722] i8042: [1555423] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.302513] i8042: [1555424] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.303853] i8042: [1555424] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.305227] i8042: [1555425] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.308543] i8042: [1555426] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.309901] i8042: [1555426] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.313048] i8042: [1555427] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.314390] i8042: [1555427] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.315729] i8042: [1555427] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.318968] i8042: [1555428] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.320317] i8042: [1555429] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.321667] i8042: [1555429] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.324724] i8042: [1555430] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.330050] i8042: [1555431] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.331412] i8042: [1555431] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.334680] i8042: [1555432] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.340082] i8042: [1555434] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.344498] i8042: [1555435] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.345916] i8042: [1555435] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.347277] i8042: [1555435] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.350614] i8042: [1555436] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.351978] i8042: [1555436] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.353413] i8042: [1555437] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.356102] i8042: [1555438] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.358602] i8042: [1555438] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.361812] i8042: [1555439] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.363152] i8042: [1555439] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.364502] i8042: [1555440] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.367285] i8042: [1555440] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.368650] i8042: [1555441] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.372932] i8042: [1555442] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.374273] i8042: [1555442] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.377309] i8042: [1555443] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.378677] i8042: [1555443] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.380021] i8042: [1555444] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.383227] i8042: [1555444] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.384671] i8042: [1555445] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.386025] i8042: [1555445] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.388810] i8042: [1555446] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.390170] i8042: [1555446] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.391512] i8042: [1555446] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.395010] i8042: [1555447] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.399406] i8042: [1555448] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.400746] i8042: [1555449] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.402085] i8042: [1555449] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.405409] i8042: [1555450] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.409864] i8042: [1555451] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.411222] i8042: [1555451] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.412781] i8042: [1555452] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.416151] i8042: [1555453] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.420475] i8042: [1555454] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.421844] i8042: [1555454] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.423366] i8042: [1555454] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.426396] i8042: [1555455] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.427832] i8042: [1555455] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.429167] i8042: [1555456] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.431959] i8042: [1555456] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.433329] i8042: [1555457] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.434679] i8042: [1555457] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.440623] i8042: [1555459] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.443529] i8042: [1555459] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.444881] i8042: [1555460] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.446212] i8042: [1555460] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.449453] i8042: [1555461] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.450798] i8042: [1555461] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.452136] i8042: [1555462] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.455004] i8042: [1555462] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.456363] i8042: [1555463] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.457704] i8042: [1555463] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.461057] i8042: [1555464] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.462415] i8042: [1555464] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.463737] i8042: [1555464] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.466597] i8042: [1555465] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.467953] i8042: [1555465] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.469303] i8042: [1555466] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.472560] i8042: [1555467] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.473910] i8042: [1555467] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.475250] i8042: [1555467] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.478144] i8042: [1555468] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.479482] i8042: [1555468] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.480836] i8042: [1555469] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.484345] i8042: [1555470] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.488667] i8042: [1555471] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.494244] i8042: [1555472] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.498772] i8042: [1555473] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.504342] i8042: [1555475] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.508662] i8042: [1555476] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.510027] i8042: [1555476] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.511370] i8042: [1555476] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.514575] i8042: [1555477] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.516005] i8042: [1555477] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.517347] i8042: [1555478] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.520144] i8042: [1555479] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.521513] i8042: [1555479] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.522861] i8042: [1555479] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.526180] i8042: [1555480] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.527612] i8042: [1555480] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.530674] i8042: [1555481] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.532017] i8042: [1555482] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.533405] i8042: [1555482] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.536620] i8042: [1555483] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.537948] i8042: [1555483] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.539388] i8042: [1555483] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.542197] i8042: [1555484] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.543542] i8042: [1555484] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.544916] i8042: [1555485] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.548322] i8042: [1555486] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.549653] i8042: [1555486] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.552740] i8042: [1555487] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.554102] i8042: [1555487] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.555420] i8042: [1555487] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.558670] i8042: [1555488] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.560023] i8042: [1555489] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.561371] i8042: [1555489] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.564251] i8042: [1555490] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.565585] i8042: [1555490] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.566930] i8042: [1555490] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.570277] i8042: [1555491] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.571624] i8042: [1555491] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.572985] i8042: [1555492] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.575843] i8042: [1555492] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.577175] i8042: [1555493] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.578533] i8042: [1555493] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.581769] i8042: [1555494] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.583119] i8042: [1555494] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.584470] i8042: [1555495] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.587379] i8042: [1555495] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.588694] i8042: [1555496] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.590035] i8042: [1555496] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.593365] i8042: [1555497] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.594716] i8042: [1555497] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.596073] i8042: [1555498] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.598954] i8042: [1555498] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.600298] i8042: [1555499] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.601637] i8042: [1555499] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.604887] i8042: [1555500] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.606245] i8042: [1555500] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.607575] i8042: [1555500] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.610478] i8042: [1555501] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.611839] i8042: [1555501] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.613170] i8042: [1555502] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.616518] i8042: [1555503] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.617863] i8042: [1555503] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.619213] i8042: [1555503] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.622116] i8042: [1555504] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.623641] i8042: [1555504] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.627463] i8042: [1555505] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.628806] i8042: [1555506] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.630164] i8042: [1555506] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.632943] i8042: [1555507] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.635438] i8042: [1555507] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.638749] i8042: [1555508] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.640095] i8042: [1555509] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.641454] i8042: [1555509] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.644230] i8042: [1555510] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.645602] i8042: [1555510] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.649774] i8042: [1555511] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.651115] i8042: [1555511] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.652628] i8042: [1555512] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.655369] i8042: [1555512] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.660866] i8042: [1555514] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.662215] i8042: [1555514] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.665373] i8042: [1555515] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.670745] i8042: [1555516] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.675365] i8042: [1555517] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.680828] i8042: [1555519] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.682180] i8042: [1555519] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.683511] i8042: [1555519] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.686394] i8042: [1555520] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.687747] i8042: [1555520] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.689077] i8042: [1555521] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.692344] i8042: [1555522] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:27 test kernel: [ 6222.693687] i8042: [1555522] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.695038] i8042: [1555522] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.697920] i8042: [1555523] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.699264] i8042: [1555523] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.700603] i8042: [1555524] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.703945] i8042: [1555524] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.705287] i8042: [1555525] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.706635] i8042: [1555525] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.710563] i8042: [1555526] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.711907] i8042: [1555526] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.715117] i8042: [1555527] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.716479] i8042: [1555528] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.717819] i8042: [1555528] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.720611] i8042: [1555529] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.723104] i8042: [1555529] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.726411] i8042: [1555530] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.727748] i8042: [1555530] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.729114] i8042: [1555531] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.731905] i8042: [1555531] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.733360] i8042: [1555532] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.737437] i8042: [1555533] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.738769] i8042: [1555533] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.740111] i8042: [1555534] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.742937] i8042: [1555534] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.744264] i8042: [1555535] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.745634] i8042: [1555535] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.749031] i8042: [1555536] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.750377] i8042: [1555536] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.753590] i8042: [1555537] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.758885] i8042: [1555538] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.760235] i8042: [1555539] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.761583] i8042: [1555539] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.764626] i8042: [1555540] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.770155] i8042: [1555541] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.774395] i8042: [1555542] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.775778] i8042: [1555542] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.777272] i8042: [1555543] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.780325] i8042: [1555544] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.781758] i8042: [1555544] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.783279] i8042: [1555544] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.785919] i8042: [1555545] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.787288] i8042: [1555545] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.788628] i8042: [1555546] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.791954] i8042: [1555546] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.793404] i8042: [1555547] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.796629] i8042: [1555548] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.801877] i8042: [1555549] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.803347] i8042: [1555549] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.806625] i8042: [1555550] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.812164] i8042: [1555552] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.816722] i8042: [1555553] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.822072] i8042: [1555554] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.826640] i8042: [1555555] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.832029] i8042: [1555557] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.833398] i8042: [1555557] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.834729] i8042: [1555557] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.837722] i8042: [1555558] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.843118] i8042: [1555559] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.847704] i8042: [1555560] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.853056] i8042: [1555562] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.854405] i8042: [1555562] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.855745] i8042: [1555562] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.858717] i8042: [1555563] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.863999] i8042: [1555564] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.865322] i8042: [1555565] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.866694] i8042: [1555565] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.869491] i8042: [1555566] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6222.870821] i8042: [1555566] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.086255] i8042: [1555620] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.087603] i8042: [1555620] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.090388] i8042: [1555621] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.091751] i8042: [1555621] c4 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.093090] i8042: [1555622] 0f <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.096417] i8042: [1555623] 9a <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.100984] i8042: [1555624] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.102332] i8042: [1555624] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.103664] i8042: [1555624] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.106906] i8042: [1555625] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.108262] i8042: [1555626] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.109613] i8042: [1555626] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.112486] i8042: [1555627] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.113839] i8042: [1555627] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.115179] i8042: [1555627] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.118519] i8042: [1555628] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.119857] i8042: [1555628] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.121211] i8042: [1555629] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.124083] i8042: [1555630] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.125429] i8042: [1555630] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.126778] i8042: [1555630] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.130016] i8042: [1555631] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.131355] i8042: [1555631] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.132875] i8042: [1555632] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.136628] i8042: [1555633] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.137987] i8042: [1555633] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.141297] i8042: [1555634] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.142641] i8042: [1555634] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.143990] i8042: [1555634] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.146794] i8042: [1555635] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.152317] i8042: [1555637] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.153659] i8042: [1555637] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.154980] i8042: [1555637] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.157811] i8042: [1555638] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.159162] i8042: [1555638] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.160516] i8042: [1555639] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.163941] i8042: [1555639] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.165297] i8042: [1555640] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.168333] i8042: [1555641] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.169714] i8042: [1555641] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.171033] i8042: [1555641] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.174246] i8042: [1555642] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.175691] i8042: [1555642] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.177034] i8042: [1555643] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.179818] i8042: [1555643] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.181184] i8042: [1555644] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.182520] i8042: [1555644] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.185922] i8042: [1555645] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.187360] i8042: [1555645] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.190360] i8042: [1555646] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.191700] i8042: [1555646] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.193059] i8042: [1555647] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.196280] i8042: [1555648] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.197627] i8042: [1555648] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.200956] i8042: [1555649] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.202297] i8042: [1555649] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.203637] i8042: [1555649] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.206977] i8042: [1555650] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.208320] i8042: [1555651] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.209670] i8042: [1555651] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.212568] i8042: [1555652] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.213919] i8042: [1555652] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.215259] i8042: [1555652] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.218502] i8042: [1555653] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.219843] i8042: [1555653] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.221194] i8042: [1555654] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.225291] i8042: [1555655] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.229667] i8042: [1555656] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.234180] i8042: [1555657] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.239634] i8042: [1555658] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.244181] i8042: [1555660] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.249667] i8042: [1555661] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.254276] i8042: [1555662] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.259632] i8042: [1555663] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.264035] i8042: [1555665] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.265569] i8042: [1555665] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.269663] i8042: [1555666] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.274214] i8042: [1555667] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.279663] i8042: [1555668] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.284128] i8042: [1555670] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.289657] i8042: [1555671] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.291012] i8042: [1555671] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.294222] i8042: [1555672] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.299658] i8042: [1555673] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.304139] i8042: [1555675] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.305476] i8042: [1555675] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.306818] i8042: [1555675] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.310140] i8042: [1555676] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.311501] i8042: [1555676] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.312851] i8042: [1555677] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.315904] i8042: [1555677] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.321257] i8042: [1555679] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.325692] i8042: [1555680] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.327213] i8042: [1555680] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.331279] i8042: [1555681] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.335696] i8042: [1555682] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.337276] i8042: [1555683] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.341098] i8042: [1555684] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.342447] i8042: [1555684] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.343785] i8042: [1555684] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.346651] i8042: [1555685] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.352125] i8042: [1555687] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.353647] i8042: [1555687] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.356651] i8042: [1555688] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.362047] i8042: [1555689] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.363587] i8042: [1555689] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.366603] i8042: [1555690] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.367940] i8042: [1555690] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.369370] i8042: [1555691] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.372683] i8042: [1555692] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.374033] i8042: [1555692] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.375405] i8042: [1555692] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.378191] i8042: [1555693] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.379531] i8042: [1555693] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.380965] i8042: [1555694] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.384175] i8042: [1555695] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.385524] i8042: [1555695] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.386896] i8042: [1555695] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.389702] i8042: [1555696] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.391041] i8042: [1555696] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.392471] i8042: [1555697] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.395875] i8042: [1555697] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.397229] i8042: [1555698] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.400308] i8042: [1555699] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.401675] i8042: [1555699] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.403005] i8042: [1555699] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.406305] i8042: [1555700] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.407656] i8042: [1555700] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.409007] i8042: [1555701] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.411819] i8042: [1555701] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.413154] i8042: [1555702] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.414640] i8042: [1555702] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.417923] i8042: [1555703] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.419259] i8042: [1555703] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.422324] i8042: [1555704] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.423699] i8042: [1555704] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.425052] i8042: [1555705] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.428266] i8042: [1555706] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.429691] i8042: [1555706] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.431028] i8042: [1555706] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.433801] i8042: [1555707] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.435181] i8042: [1555707] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.436545] i8042: [1555708] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.439872] i8042: [1555708] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.441307] i8042: [1555709] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.444528] i8042: [1555710] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.449798] i8042: [1555711] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.451169] i8042: [1555711] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.452513] i8042: [1555712] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.455305] i8042: [1555712] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.456732] i8042: [1555713] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.458071] i8042: [1555713] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.461384] i8042: [1555714] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.462760] i8042: [1555714] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.464113] i8042: [1555715] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.466894] i8042: [1555715] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.468325] i8042: [1555716] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.469663] i8042: [1555716] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.472884] i8042: [1555717] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.474240] i8042: [1555717] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.475601] i8042: [1555717] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.478401] i8042: [1555718] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.479833] i8042: [1555718] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.481168] i8042: [1555719] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.484632] i8042: [1555720] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.488998] i8042: [1555721] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.490351] i8042: [1555721] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.491678] i8042: [1555721] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.495168] i8042: [1555722] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.499631] i8042: [1555723] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.507602] i8042: [1555725] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.510441] i8042: [1555726] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.511788] i8042: [1555726] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.513250] i8042: [1555727] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.516625] i8042: [1555728] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.520945] i8042: [1555729] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.522289] i8042: [1555729] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.523655] i8042: [1555729] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.526991] i8042: [1555730] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.528346] i8042: [1555731] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.531491] i8042: [1555731] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.533004] i8042: [1555732] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.537086] i8042: [1555733] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.541502] i8042: [1555734] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.543016] i8042: [1555734] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.547186] i8042: [1555735] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.551590] i8042: [1555736] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.552938] i8042: [1555737] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.554281] i8042: [1555737] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.557508] i8042: [1555738] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.558850] i8042: [1555738] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.560201] i8042: [1555739] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.564135] i8042: [1555740] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.565478] i8042: [1555740] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.568787] i8042: [1555741] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.570147] i8042: [1555741] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.571489] i8042: [1555741] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.574299] i8042: [1555742] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.576775] i8042: [1555743] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.579980] i8042: [1555743] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.581320] i8042: [1555744] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.582682] i8042: [1555744] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.585483] i8042: [1555745] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.586831] i8042: [1555745] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.591105] i8042: [1555746] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.592450] i8042: [1555747] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.595487] i8042: [1555747] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.596850] i8042: [1555748] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.598198] i8042: [1555748] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.601437] i8042: [1555749] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.603049] i8042: [1555749] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.606015] i8042: [1555750] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.607355] i8042: [1555750] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.608720] i8042: [1555751] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.612109] i8042: [1555752] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.613457] i8042: [1555752] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.616539] i8042: [1555753] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.617876] i8042: [1555753] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.619218] i8042: [1555753] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.622446] i8042: [1555754] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.623961] i8042: [1555754] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.627015] i8042: [1555755] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.628458] i8042: [1555756] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.629798] i8042: [1555756] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.633233] i8042: [1555757] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.637648] i8042: [1555758] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.638977] i8042: [1555758] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.640328] i8042: [1555759] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.643643] i8042: [1555759] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.644963] i8042: [1555760] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.646304] i8042: [1555760] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.649119] i8042: [1555761] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.650470] i8042: [1555761] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.651820] i8042: [1555761] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.655226] i8042: [1555762] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.656566] i8042: [1555763] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.659624] i8042: [1555763] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.660998] i8042: [1555764] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.662346] i8042: [1555764] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.665574] i8042: [1555765] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.667006] i8042: [1555765] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.668348] i8042: [1555766] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.671147] i8042: [1555766] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.672509] i8042: [1555767] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.673862] i8042: [1555767] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.677178] i8042: [1555768] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.678616] i8042: [1555768] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.681655] i8042: [1555769] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.682996] i8042: [1555769] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.684361] i8042: [1555770] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.687577] i8042: [1555770] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.688930] i8042: [1555771] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.690369] i8042: [1555771] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:28 test kernel: [ 6223.693152] i8042: [1555772] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.694492] i8042: [1555772] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.695854] i8042: [1555772] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.699172] i8042: [1555773] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.700529] i8042: [1555774] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.703684] i8042: [1555774] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.705031] i8042: [1555775] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.706366] i8042: [1555775] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.709616] i8042: [1555776] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.710965] i8042: [1555776] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.712316] i8042: [1555777] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.715223] i8042: [1555777] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.716572] i8042: [1555778] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.717907] i8042: [1555778] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.721324] i8042: [1555779] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.722837] i8042: [1555779] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.725728] i8042: [1555780] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.727167] i8042: [1555780] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.728518] i8042: [1555781] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.731718] i8042: [1555781] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.733218] i8042: [1555782] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.736487] i8042: [1555783] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.741844] i8042: [1555784] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.743445] i8042: [1555784] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.746312] i8042: [1555785] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.747652] i8042: [1555785] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.749026] i8042: [1555786] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.752264] i8042: [1555787] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.753635] i8042: [1555787] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.755215] i8042: [1555787] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.757949] i8042: [1555788] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.763557] i8042: [1555789] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.768055] i8042: [1555791] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.773289] i8042: [1555792] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.774660] i8042: [1555792] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.776083] i8042: [1555793] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.778872] i8042: [1555793] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.780214] i8042: [1555794] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.781574] i8042: [1555794] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.784878] i8042: [1555795] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.786231] i8042: [1555795] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.789397] i8042: [1555796] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.790746] i8042: [1555796] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.792092] i8042: [1555797] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.795330] i8042: [1555797] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.796842] i8042: [1555798] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.799901] i8042: [1555798] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.801345] i8042: [1555799] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.802867] i8042: [1555799] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.806199] i8042: [1555800] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.810530] i8042: [1555801] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.811883] i8042: [1555801] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.813363] i8042: [1555802] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.816554] i8042: [1555803] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.817888] i8042: [1555803] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.819226] i8042: [1555803] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.822023] i8042: [1555804] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.823541] i8042: [1555804] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.827632] i8042: [1555805] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.829071] i8042: [1555806] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.832056] i8042: [1555807] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.833567] i8042: [1555807] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.837584] i8042: [1555808] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.842073] i8042: [1555809] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.843579] i8042: [1555809] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.847854] i8042: [1555810] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.852082] i8042: [1555812] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.853579] i8042: [1555812] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.857580] i8042: [1555813] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.862087] i8042: [1555814] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.863579] i8042: [1555814] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.867703] i8042: [1555815] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.869044] i8042: [1555816] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.872087] i8042: [1555817] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.873575] i8042: [1555817] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.877576] i8042: [1555818] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.882096] i8042: [1555819] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.883575] i8042: [1555819] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.887640] i8042: [1555820] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.888986] i8042: [1555821] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.890358] i8042: [1555821] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.893197] i8042: [1555822] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.898574] i8042: [1555823] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.900015] i8042: [1555824] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.901364] i8042: [1555824] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.904197] i8042: [1555825] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.909882] i8042: [1555826] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.914194] i8042: [1555827] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.915572] i8042: [1555827] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.919685] i8042: [1555828] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.921028] i8042: [1555829] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.922365] i8042: [1555829] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.925193] i8042: [1555830] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.926569] i8042: [1555830] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.930755] i8042: [1555831] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.932182] i8042: [1555832] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.935161] i8042: [1555832] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.936500] i8042: [1555833] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.937868] i8042: [1555833] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.941109] i8042: [1555834] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.942460] i8042: [1555834] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.943890] i8042: [1555834] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.946682] i8042: [1555835] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.948027] i8042: [1555836] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.949393] i8042: [1555836] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.952708] i8042: [1555837] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.954064] i8042: [1555837] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.957209] i8042: [1555838] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.958550] i8042: [1555838] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.959892] i8042: [1555838] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.963128] i8042: [1555839] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.964480] i8042: [1555840] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.965830] i8042: [1555840] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.968710] i8042: [1555841] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.970049] i8042: [1555841] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.971381] i8042: [1555841] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.974724] i8042: [1555842] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.976083] i8042: [1555843] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.977431] i8042: [1555843] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.980487] i8042: [1555844] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.985662] i8042: [1555845] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.986997] i8042: [1555845] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.988381] i8042: [1555846] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.991174] i8042: [1555846] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.992526] i8042: [1555847] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.993961] i8042: [1555847] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.997285] i8042: [1555848] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.998616] i8042: [1555848] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6223.999989] i8042: [1555848] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.002809] i8042: [1555849] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.004162] i8042: [1555850] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.005591] i8042: [1555850] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.008810] i8042: [1555851] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.010144] i8042: [1555851] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.011506] i8042: [1555851] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.014313] i8042: [1555852] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.015664] i8042: [1555852] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.017107] i8042: [1555853] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.020413] i8042: [1555854] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.021743] i8042: [1555854] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.023108] i8042: [1555854] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.025905] i8042: [1555855] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.027260] i8042: [1555855] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.028689] i8042: [1555856] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.031902] i8042: [1555856] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.033420] i8042: [1555857] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.036555] i8042: [1555858] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.042108] i8042: [1555859] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.043452] i8042: [1555859] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.046521] i8042: [1555860] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.048037] i8042: [1555861] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.051934] i8042: [1555861] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.053485] i8042: [1555862] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.056510] i8042: [1555863] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.058023] i8042: [1555863] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.062133] i8042: [1555864] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.063476] i8042: [1555864] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.066550] i8042: [1555865] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.068072] i8042: [1555866] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.071939] i8042: [1555866] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.073461] i8042: [1555867] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.076621] i8042: [1555868] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.077978] i8042: [1555868] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.079313] i8042: [1555868] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.082672] i8042: [1555869] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.084171] i8042: [1555870] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.087168] i8042: [1555870] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.088592] i8042: [1555871] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.089927] i8042: [1555871] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.093156] i8042: [1555872] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.094509] i8042: [1555872] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.095857] i8042: [1555872] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:29 test kernel: [ 6224.098627] i8042: [1555873] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.415262] i8042: [1556202] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.416609] i8042: [1556203] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.417958] i8042: [1556203] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.420753] i8042: [1556204] c4 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.422083] i8042: [1556204] 0f <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.423430] i8042: [1556204] a3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.427901] i8042: [1556205] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.429249] i8042: [1556206] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.432038] i8042: [1556207] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.433411] i8042: [1556207] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.434749] i8042: [1556207] 0f <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.437978] i8042: [1556208] b7 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.442655] i8042: [1556209] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.443995] i8042: [1556209] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.445337] i8042: [1556210] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.448745] i8042: [1556211] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.450095] i8042: [1556211] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.453152] i8042: [1556212] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.454592] i8042: [1556212] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.455938] i8042: [1556212] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.459145] i8042: [1556213] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.460506] i8042: [1556214] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.461848] i8042: [1556214] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.464647] i8042: [1556215] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.466086] i8042: [1556215] 81 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.467438] i8042: [1556215] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.470745] i8042: [1556216] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.472097] i8042: [1556217] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.473449] i8042: [1556217] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.476241] i8042: [1556218] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.478733] i8042: [1556218] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.481941] i8042: [1556219] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.483283] i8042: [1556219] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.484645] i8042: [1556220] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.487434] i8042: [1556220] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.488792] i8042: [1556221] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.493075] i8042: [1556222] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.494410] i8042: [1556222] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.497449] i8042: [1556223] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.498810] i8042: [1556223] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.500162] i8042: [1556224] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.503398] i8042: [1556224] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.504838] i8042: [1556225] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.506180] i8042: [1556225] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.508973] i8042: [1556226] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.510335] i8042: [1556226] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.511674] i8042: [1556226] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.515000] i8042: [1556227] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.516440] i8042: [1556228] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.519482] i8042: [1556228] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.520820] i8042: [1556229] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.522182] i8042: [1556229] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.525403] i8042: [1556230] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.526751] i8042: [1556230] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.530074] i8042: [1556231] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.531416] i8042: [1556231] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.532757] i8042: [1556232] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.536096] i8042: [1556233] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.537442] i8042: [1556233] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.538790] i8042: [1556233] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.541691] i8042: [1556234] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.543040] i8042: [1556234] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.544381] i8042: [1556235] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.547621] i8042: [1556235] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.548962] i8042: [1556236] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.550313] i8042: [1556236] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.554248] i8042: [1556237] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.555589] i8042: [1556237] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.561486] i8042: [1556239] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.564295] i8042: [1556240] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.565643] i8042: [1556240] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.566993] i8042: [1556240] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.570301] i8042: [1556241] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.571639] i8042: [1556241] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.572982] i8042: [1556242] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.575797] i8042: [1556242] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.577324] i8042: [1556243] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.581338] i8042: [1556244] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.582917] i8042: [1556244] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.585959] i8042: [1556245] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.591338] i8042: [1556246] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.595961] i8042: [1556247] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.601343] i8042: [1556249] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.602862] i8042: [1556249] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.605909] i8042: [1556250] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.607247] i8042: [1556250] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.608760] i8042: [1556251] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.611957] i8042: [1556251] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.616407] i8042: [1556253] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.617749] i8042: [1556253] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.619189] i8042: [1556253] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.622674] i8042: [1556254] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.627012] i8042: [1556255] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.628385] i8042: [1556256] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.629886] i8042: [1556256] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.632917] i8042: [1556257] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.634369] i8042: [1556257] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.635863] i8042: [1556257] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.638660] i8042: [1556258] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.644214] i8042: [1556260] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.648668] i8042: [1556261] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.653951] i8042: [1556262] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.655397] i8042: [1556262] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.656890] i8042: [1556263] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.659671] i8042: [1556263] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.665141] i8042: [1556265] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.666494] i8042: [1556265] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.669522] i8042: [1556266] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.670949] i8042: [1556266] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.672271] i8042: [1556267] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.675493] i8042: [1556267] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.676868] i8042: [1556268] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.678218] i8042: [1556268] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.681013] i8042: [1556269] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.682441] i8042: [1556269] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.683791] i8042: [1556269] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.687080] i8042: [1556270] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.688443] i8042: [1556271] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.689794] i8042: [1556271] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:30 test kernel: [ 6225.692785] i8042: [1556272] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.698312] i8042: [1556273] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.702808] i8042: [1556274] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.708321] i8042: [1556276] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.712644] i8042: [1556277] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.713993] i8042: [1556277] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.715343] i8042: [1556277] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.718843] i8042: [1556278] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.723319] i8042: [1556279] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.728876] i8042: [1556281] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.733316] i8042: [1556282] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.738784] i8042: [1556283] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.743315] i8042: [1556284] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.748941] i8042: [1556286] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.753315] i8042: [1556287] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.758789] i8042: [1556288] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.763312] i8042: [1556289] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.768938] i8042: [1556291] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.773184] i8042: [1556292] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.774619] i8042: [1556292] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.775966] i8042: [1556292] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.779203] i8042: [1556293] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.780576] i8042: [1556294] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.781923] i8042: [1556294] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.784728] i8042: [1556295] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.786145] i8042: [1556295] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.787484] i8042: [1556295] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.790806] i8042: [1556296] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.792176] i8042: [1556297] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.793708] i8042: [1556297] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.796322] i8042: [1556298] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.797919] i8042: [1556298] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.801762] i8042: [1556299] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.803292] i8042: [1556299] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.806372] i8042: [1556300] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.807711] i8042: [1556300] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.809039] i8042: [1556301] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.812637] i8042: [1556302] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.816931] i8042: [1556303] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.822306] i8042: [1556304] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.823830] i8042: [1556304] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.826878] i8042: [1556305] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.828225] i8042: [1556306] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.829663] i8042: [1556306] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.832995] i8042: [1556307] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.834306] i8042: [1556307] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.835847] i8042: [1556307] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.838639] i8042: [1556308] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.843927] i8042: [1556309] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.845359] i8042: [1556310] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.846852] i8042: [1556310] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.849649] i8042: [1556311] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.855216] i8042: [1556312] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.859664] i8042: [1556313] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.864937] i8042: [1556315] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.866364] i8042: [1556315] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.867715] i8042: [1556315] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.870485] i8042: [1556316] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.871837] i8042: [1556316] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.873188] i8042: [1556317] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.876585] i8042: [1556318] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.878024] i8042: [1556318] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.881037] i8042: [1556319] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.882380] i8042: [1556319] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.883741] i8042: [1556319] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.886969] i8042: [1556320] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.888309] i8042: [1556321] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.889749] i8042: [1556321] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.892559] i8042: [1556322] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.893910] i8042: [1556322] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.895275] i8042: [1556322] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.898602] i8042: [1556323] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.899941] i8042: [1556323] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.903114] i8042: [1556324] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.904467] i8042: [1556325] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.905815] i8042: [1556325] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.909048] i8042: [1556326] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.910384] i8042: [1556326] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.911726] i8042: [1556326] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.914616] i8042: [1556327] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.915966] i8042: [1556327] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.917316] i8042: [1556328] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.920649] i8042: [1556329] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.921989] i8042: [1556329] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.923329] i8042: [1556329] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.926204] i8042: [1556330] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.927733] i8042: [1556330] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.931746] i8042: [1556331] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.936292] i8042: [1556333] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.941854] i8042: [1556334] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.946142] i8042: [1556335] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.947569] i8042: [1556335] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.948910] i8042: [1556336] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.952123] i8042: [1556337] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.953491] i8042: [1556337] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.954841] i8042: [1556337] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.957819] i8042: [1556338] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.963270] i8042: [1556339] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.964792] i8042: [1556340] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.967841] i8042: [1556340] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.973120] i8042: [1556342] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.974622] i8042: [1556342] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.977850] i8042: [1556343] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.983529] i8042: [1556344] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.987850] i8042: [1556345] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.993279] i8042: [1556347] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6225.997882] i8042: [1556348] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.003279] i8042: [1556349] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.007877] i8042: [1556350] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.013279] i8042: [1556352] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.017883] i8042: [1556353] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.023275] i8042: [1556354] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.027900] i8042: [1556355] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.033275] i8042: [1556357] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.037892] i8042: [1556358] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.043517] i8042: [1556359] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.047899] i8042: [1556360] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.053271] i8042: [1556362] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.057893] i8042: [1556363] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.063244] i8042: [1556364] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.064780] i8042: [1556365] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.067893] i8042: [1556365] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.073270] i8042: [1556367] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.077896] i8042: [1556368] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.083548] i8042: [1556369] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.087890] i8042: [1556370] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.093267] i8042: [1556372] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.097890] i8042: [1556373] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.103479] i8042: [1556374] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.107892] i8042: [1556375] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.113263] i8042: [1556377] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.117888] i8042: [1556378] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.123316] i8042: [1556379] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.124888] i8042: [1556380] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.127885] i8042: [1556380] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.133263] i8042: [1556382] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.134767] i8042: [1556382] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.137887] i8042: [1556383] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.143339] i8042: [1556384] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.144781] i8042: [1556385] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.147881] i8042: [1556385] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.153252] i8042: [1556387] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.154795] i8042: [1556387] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.157884] i8042: [1556388] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.163520] i8042: [1556389] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.167947] i8042: [1556390] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.169294] i8042: [1556391] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.170627] i8042: [1556391] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.173878] i8042: [1556392] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.175256] i8042: [1556392] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.178593] i8042: [1556393] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.184085] i8042: [1556395] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.185445] i8042: [1556395] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.188624] i8042: [1556396] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.193934] i8042: [1556397] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.195286] i8042: [1556397] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.196783] i8042: [1556398] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.199655] i8042: [1556398] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.205119] i8042: [1556400] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.209589] i8042: [1556401] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.214875] i8042: [1556402] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.216206] i8042: [1556403] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.217742] i8042: [1556403] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.220456] i8042: [1556404] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.221798] i8042: [1556404] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.223250] i8042: [1556404] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.226463] i8042: [1556405] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.227873] i8042: [1556405] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.230918] i8042: [1556406] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.232546] i8042: [1556407] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.236486] i8042: [1556408] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.240950] i8042: [1556409] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.242301] i8042: [1556409] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.243658] i8042: [1556409] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.247142] i8042: [1556410] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.251724] i8042: [1556411] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.256908] i8042: [1556413] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.258253] i8042: [1556413] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.259786] i8042: [1556413] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.262407] i8042: [1556414] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.263866] i8042: [1556414] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.268222] i8042: [1556416] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.272424] i8042: [1556417] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.273866] i8042: [1556417] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.277903] i8042: [1556418] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.279239] i8042: [1556418] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.280584] i8042: [1556419] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.283471] i8042: [1556419] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.284813] i8042: [1556420] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.286153] i8042: [1556420] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.289742] i8042: [1556421] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.294147] i8042: [1556422] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.299400] i8042: [1556423] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.300809] i8042: [1556424] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.302169] i8042: [1556424] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.305125] i8042: [1556425] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.310677] i8042: [1556426] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.315132] i8042: [1556427] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.320577] i8042: [1556429] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.325230] i8042: [1556430] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.330493] i8042: [1556431] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.331847] i8042: [1556431] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.333235] i8042: [1556432] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.336181] i8042: [1556433] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.341627] i8042: [1556434] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.346125] i8042: [1556435] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.347462] i8042: [1556435] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.348802] i8042: [1556436] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.352143] i8042: [1556437] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.353489] i8042: [1556437] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.354841] i8042: [1556437] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.357735] i8042: [1556438] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.359084] i8042: [1556438] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.360424] i8042: [1556439] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.363670] i8042: [1556439] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.365008] i8042: [1556440] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.366357] i8042: [1556440] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.370291] i8042: [1556441] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.371641] i8042: [1556441] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.374946] i8042: [1556442] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.376310] i8042: [1556443] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.377647] i8042: [1556443] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.380442] i8042: [1556444] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.381881] i8042: [1556444] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.383230] i8042: [1556444] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.386441] i8042: [1556445] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.387802] i8042: [1556445] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.389143] i8042: [1556446] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.391942] i8042: [1556446] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.394434] i8042: [1556447] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.397812] i8042: [1556448] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.399150] i8042: [1556448] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.402232] i8042: [1556449] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.403593] i8042: [1556449] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.404948] i8042: [1556450] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.408268] i8042: [1556451] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.409612] i8042: [1556451] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.410951] i8042: [1556451] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.413769] i8042: [1556452] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.415111] i8042: [1556452] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:03:31 test kernel: [ 6226.416462] i8042: [1556453] 00 <- i8042 (interrupt, 1, 12)
swipe from left to right of the touch bar:
Apr 1 23:09:20 test kernel: [ 6575.632331] i8042: [1643757] 85 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:20 test kernel: [ 6575.636840] i8042: [1643758] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:20 test kernel: [ 6575.642323] i8042: [1643759] 26 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:20 test kernel: [ 6575.646868] i8042: [1643760] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:20 test kernel: [ 6575.652281] i8042: [1643762] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:20 test kernel: [ 6575.656867] i8042: [1643763] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:20 test kernel: [ 6575.662328] i8042: [1643764] 9a <- i8042 (interrupt, 1, 12)
Apr 1 23:09:20 test kernel: [ 6575.666874] i8042: [1643765] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:20 test kernel: [ 6575.672297] i8042: [1643767] 10 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:20 test kernel: [ 6575.676883] i8042: [1643768] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:20 test kernel: [ 6575.682324] i8042: [1643769] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:20 test kernel: [ 6575.686882] i8042: [1643770] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:20 test kernel: [ 6575.692326] i8042: [1643772] 9c <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.696883] i8042: [1643773] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.702323] i8042: [1643774] 1a <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.706880] i8042: [1643775] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.712325] i8042: [1643777] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.716879] i8042: [1643778] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.724878] i8042: [1643780] 9c <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.727797] i8042: [1643780] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.733240] i8042: [1643782] 32 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.737835] i8042: [1643783] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.743290] i8042: [1643784] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.747819] i8042: [1643785] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.753349] i8042: [1643787] 9e <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.757839] i8042: [1643788] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.763295] i8042: [1643789] 58 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.767866] i8042: [1643790] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.773264] i8042: [1643792] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.777846] i8042: [1643793] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.783415] i8042: [1643794] a0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.787851] i8042: [1643795] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.793292] i8042: [1643797] bb <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.797870] i8042: [1643798] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.803334] i8042: [1643799] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.807870] i8042: [1643800] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.813392] i8042: [1643802] 9e <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.817867] i8042: [1643803] 01 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.823269] i8042: [1643804] 38 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.827867] i8042: [1643805] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.833327] i8042: [1643807] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.837868] i8042: [1643808] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.843466] i8042: [1643809] a3 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.847864] i8042: [1643810] 01 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.853340] i8042: [1643812] d8 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.857865] i8042: [1643813] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.863382] i8042: [1643814] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.867865] i8042: [1643815] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.873445] i8042: [1643817] 9d <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.877861] i8042: [1643818] 02 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.883410] i8042: [1643819] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.887861] i8042: [1643820] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.893379] i8042: [1643822] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.897862] i8042: [1643823] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.903480] i8042: [1643824] a0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.907858] i8042: [1643825] 03 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.913387] i8042: [1643827] 78 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.917858] i8042: [1643828] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.923452] i8042: [1643829] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.927856] i8042: [1643830] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.933477] i8042: [1643832] a0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.937855] i8042: [1643833] 04 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.943461] i8042: [1643834] a7 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.947855] i8042: [1643835] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.949356] i8042: [1643836] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.953419] i8042: [1643837] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.957930] i8042: [1643838] 9b <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.959450] i8042: [1643838] 05 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.963469] i8042: [1643839] 4b <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.967852] i8042: [1643840] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.969391] i8042: [1643841] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.973439] i8042: [1643842] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.978107] i8042: [1643843] 9c <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.983474] i8042: [1643844] 05 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.987856] i8042: [1643845] c9 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.989388] i8042: [1643846] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.993466] i8042: [1643847] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.997868] i8042: [1643848] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6575.999468] i8042: [1643848] 9a <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.003470] i8042: [1643849] 06 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.007902] i8042: [1643850] b3 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.009425] i8042: [1643851] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.013470] i8042: [1643852] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.017909] i8042: [1643853] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.019468] i8042: [1643853] 9b <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.023467] i8042: [1643854] 07 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.027907] i8042: [1643855] 3b <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.029425] i8042: [1643856] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.033467] i8042: [1643857] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.037899] i8042: [1643858] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.039469] i8042: [1643858] 99 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.043468] i8042: [1643859] 08 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.048085] i8042: [1643861] 06 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.053464] i8042: [1643862] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.058093] i8042: [1643863] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.063464] i8042: [1643864] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.068192] i8042: [1643866] 99 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.073464] i8042: [1643867] 09 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.077933] i8042: [1643868] 03 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.079461] i8042: [1643868] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.083460] i8042: [1643869] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.088109] i8042: [1643871] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.093470] i8042: [1643872] 98 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.094835] i8042: [1643872] 09 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.096196] i8042: [1643872] fd <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.099162] i8042: [1643873] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.104463] i8042: [1643875] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.105836] i8042: [1643875] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.107423] i8042: [1643875] 9a <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.110238] i8042: [1643876] 0a <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.115509] i8042: [1643877] 6a <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.116878] i8042: [1643878] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.118380] i8042: [1643878] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.121183] i8042: [1643879] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.126772] i8042: [1643880] 96 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.131206] i8042: [1643881] 0b <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.136461] i8042: [1643883] 1f <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.137831] i8042: [1643883] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.139327] i8042: [1643883] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.141960] i8042: [1643884] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.143456] i8042: [1643884] 98 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.147456] i8042: [1643885] 0b <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.148833] i8042: [1643886] a2 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.152148] i8042: [1643887] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.157454] i8042: [1643888] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.162137] i8042: [1643889] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.167518] i8042: [1643890] 95 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.168865] i8042: [1643891] 0c <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.171975] i8042: [1643891] 94 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.173338] i8042: [1643892] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.174674] i8042: [1643892] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.177911] i8042: [1643893] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.179328] i8042: [1643893] 98 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.180688] i8042: [1643894] 0d <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.183500] i8042: [1643894] 19 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.184872] i8042: [1643895] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.186204] i8042: [1643895] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.189482] i8042: [1643896] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.190899] i8042: [1643896] 99 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.192244] i8042: [1643897] 0d <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.195055] i8042: [1643897] 7d <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.196452] i8042: [1643898] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.197824] i8042: [1643898] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.201185] i8042: [1643899] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.205824] i8042: [1643900] 97 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.211076] i8042: [1643901] 0d <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.212420] i8042: [1643902] eb <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.213825] i8042: [1643902] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.216747] i8042: [1643903] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.222197] i8042: [1643904] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.226673] i8042: [1643905] 97 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.228017] i8042: [1643905] 0e <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.229357] i8042: [1643906] f8 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.232637] i8042: [1643907] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.234001] i8042: [1643907] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.235344] i8042: [1643907] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.238220] i8042: [1643908] 95 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.239561] i8042: [1643908] 0f <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.240898] i8042: [1643909] 58 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.244144] i8042: [1643910] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.245495] i8042: [1643910] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.246841] i8042: [1643910] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.249723] i8042: [1643911] 97 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.251062] i8042: [1643911] 0f <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.252401] i8042: [1643912] ab <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.255704] i8042: [1643912] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.257033] i8042: [1643913] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.258398] i8042: [1643913] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.261262] i8042: [1643914] 95 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.262630] i8042: [1643914] 0f <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.263954] i8042: [1643914] d5 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.267363] i8042: [1643915] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.271819] i8042: [1643916] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.277396] i8042: [1643918] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.281863] i8042: [1643919] 91 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.283386] i8042: [1643919] 0f <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.287365] i8042: [1643920] ea <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.291814] i8042: [1643921] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.293313] i8042: [1643922] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.297426] i8042: [1643923] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.301869] i8042: [1643924] 86 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.303378] i8042: [1643924] 0f <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.307395] i8042: [1643925] ff <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.311800] i8042: [1643926] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.313321] i8042: [1643927] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.317433] i8042: [1643928] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.321883] i8042: [1643929] 83 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.323248] i8042: [1643929] 0f <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.324575] i8042: [1643930] ff <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.327816] i8042: [1643930] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.329141] i8042: [1643931] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.330489] i8042: [1643931] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.334426] i8042: [1643932] 82 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.335773] i8042: [1643932] 0f <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.339227] i8042: [1643933] ff <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.343783] i8042: [1643934] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.349191] i8042: [1643936] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.353575] i8042: [1643937] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.355193] i8042: [1643937] 82 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.359245] i8042: [1643938] 0f <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.363772] i8042: [1643939] ff <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.369234] i8042: [1643941] c8 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.373788] i8042: [1643942] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.379249] i8042: [1643943] 01 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.383807] i8042: [1643944] 81 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.389219] i8042: [1643946] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.393631] i8042: [1643947] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.395182] i8042: [1643947] d0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.399279] i8042: [1643948] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.403803] i8042: [1643949] 20 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.409342] i8042: [1643951] 81 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.413804] i8042: [1643952] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.419299] i8042: [1643953] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.423800] i8042: [1643954] d4 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.429257] i8042: [1643956] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.433801] i8042: [1643957] 8d <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.439415] i8042: [1643958] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.443801] i8042: [1643959] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.449284] i8042: [1643961] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.453797] i8042: [1643962] d8 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.459334] i8042: [1643963] 01 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.463797] i8042: [1643964] b1 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.469394] i8042: [1643966] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.473798] i8042: [1643967] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.479343] i8042: [1643968] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.483794] i8042: [1643969] d5 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.489312] i8042: [1643971] 02 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.493794] i8042: [1643972] b6 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.499420] i8042: [1643973] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.503795] i8042: [1643974] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.509336] i8042: [1643976] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.513791] i8042: [1643977] da <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.519386] i8042: [1643978] 04 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.523791] i8042: [1643979] 69 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.529417] i8042: [1643981] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.533792] i8042: [1643982] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.539414] i8042: [1643983] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.543788] i8042: [1643984] d7 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.545311] i8042: [1643985] 05 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.549371] i8042: [1643986] 3b <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.554027] i8042: [1643987] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.559414] i8042: [1643988] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.563789] i8042: [1643989] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.565307] i8042: [1643990] d9 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.569387] i8042: [1643991] 06 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.573793] i8042: [1643992] 28 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.575398] i8042: [1643992] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.579411] i8042: [1643993] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.583820] i8042: [1643994] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.585346] i8042: [1643995] d8 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.589396] i8042: [1643996] 07 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.593825] i8042: [1643997] 0e <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.595406] i8042: [1643997] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.599407] i8042: [1643998] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.603789] i8042: [1643999] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.605341] i8042: [1644000] da <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.609408] i8042: [1644001] 07 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.613817] i8042: [1644002] 79 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.615406] i8042: [1644002] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.619408] i8042: [1644003] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.624011] i8042: [1644005] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.629404] i8042: [1644006] d7 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.634013] i8042: [1644007] 08 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.639402] i8042: [1644008] 1d <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.644108] i8042: [1644010] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.649405] i8042: [1644011] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.653853] i8042: [1644012] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.655384] i8042: [1644012] d7 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.659401] i8042: [1644013] 08 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.664031] i8042: [1644015] f3 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.669401] i8042: [1644016] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.670773] i8042: [1644016] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.674049] i8042: [1644017] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.679402] i8042: [1644018] d5 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.684058] i8042: [1644020] 09 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:21 test kernel: [ 6576.689398] i8042: [1644021] 9c <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.694150] i8042: [1644022] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.699399] i8042: [1644023] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.704063] i8042: [1644025] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.709395] i8042: [1644026] d8 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.714073] i8042: [1644027] 0a <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.719395] i8042: [1644028] 60 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.720841] i8042: [1644029] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.724094] i8042: [1644030] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.729395] i8042: [1644031] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.734124] i8042: [1644032] d7 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.742105] i8042: [1644034] 0a <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.744768] i8042: [1644035] da <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.750392] i8042: [1644036] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.754768] i8042: [1644037] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.760382] i8042: [1644039] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.764766] i8042: [1644040] d6 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.766273] i8042: [1644040] 0b <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.770355] i8042: [1644041] cf <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.775018] i8042: [1644042] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.780390] i8042: [1644044] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.784770] i8042: [1644045] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.786311] i8042: [1644045] d4 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.790363] i8042: [1644046] 0c <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.794795] i8042: [1644047] 59 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.796387] i8042: [1644048] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.800235] i8042: [1644049] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.801754] i8042: [1644049] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.804813] i8042: [1644050] d4 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.806308] i8042: [1644050] 0c <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.810386] i8042: [1644051] bc <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.815042] i8042: [1644052] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.820383] i8042: [1644054] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.824822] i8042: [1644055] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.826336] i8042: [1644055] d7 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.830383] i8042: [1644056] 0d <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.834828] i8042: [1644057] 69 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.836384] i8042: [1644058] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.840384] i8042: [1644059] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.844832] i8042: [1644060] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.846355] i8042: [1644060] d7 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.850379] i8042: [1644061] 0d <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.854989] i8042: [1644062] ee <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.860391] i8042: [1644064] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.861756] i8042: [1644064] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.865000] i8042: [1644065] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.870380] i8042: [1644066] d6 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.875013] i8042: [1644067] 0e <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.880377] i8042: [1644069] 74 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.885113] i8042: [1644070] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.890377] i8042: [1644071] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.895025] i8042: [1644072] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.900378] i8042: [1644074] d5 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.901749] i8042: [1644074] 0e <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.905031] i8042: [1644075] a8 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.910410] i8042: [1644076] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.911749] i8042: [1644076] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.913263] i8042: [1644077] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.916055] i8042: [1644078] d6 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.921374] i8042: [1644079] 0e <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.922747] i8042: [1644079] df <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.926155] i8042: [1644080] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.931371] i8042: [1644081] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.936075] i8042: [1644083] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.941422] i8042: [1644084] d6 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.942747] i8042: [1644084] 0e <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.944254] i8042: [1644085] ee <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.947135] i8042: [1644085] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.952324] i8042: [1644087] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.953745] i8042: [1644087] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.957076] i8042: [1644088] d6 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.962363] i8042: [1644089] 0e <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.963744] i8042: [1644089] f7 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.965317] i8042: [1644090] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.968094] i8042: [1644091] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.973373] i8042: [1644092] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.974746] i8042: [1644092] d7 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.976267] i8042: [1644093] 0f <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.979046] i8042: [1644093] 68 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.984628] i8042: [1644095] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.989079] i8042: [1644096] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.994365] i8042: [1644097] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6576.999105] i8042: [1644098] d8 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.004396] i8042: [1644100] 0f <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.005740] i8042: [1644100] af <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.007314] i8042: [1644100] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.010122] i8042: [1644101] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.015399] i8042: [1644102] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.016746] i8042: [1644103] cd <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.018253] i8042: [1644103] 0f <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.021042] i8042: [1644104] eb <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.026614] i8042: [1644105] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.031054] i8042: [1644106] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.036362] i8042: [1644108] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.041085] i8042: [1644109] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.046409] i8042: [1644110] 0f <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.047740] i8042: [1644110] ff <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.051105] i8042: [1644111] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.056359] i8042: [1644113] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.057735] i8042: [1644113] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.061109] i8042: [1644114] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.066398] i8042: [1644115] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.067731] i8042: [1644115] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.069323] i8042: [1644116] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.072129] i8042: [1644117] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.077407] i8042: [1644118] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.078766] i8042: [1644118] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.080261] i8042: [1644119] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.083040] i8042: [1644119] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.088619] i8042: [1644121] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.093055] i8042: [1644122] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.098354] i8042: [1644123] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.099730] i8042: [1644123] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.103067] i8042: [1644124] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.108389] i8042: [1644126] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.109811] i8042: [1644126] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.113082] i8042: [1644127] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.118354] i8042: [1644128] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.119726] i8042: [1644128] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.121218] i8042: [1644129] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.123999] i8042: [1644129] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.129408] i8042: [1644131] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.130728] i8042: [1644131] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.132196] i8042: [1644131] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.135066] i8042: [1644132] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.140349] i8042: [1644134] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.145053] i8042: [1644135] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.150642] i8042: [1644136] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.155062] i8042: [1644137] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.160350] i8042: [1644139] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.161721] i8042: [1644139] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.163226] i8042: [1644139] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.165854] i8042: [1644140] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.167345] i8042: [1644140] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.171346] i8042: [1644141] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.172691] i8042: [1644142] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.174216] i8042: [1644142] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.177004] i8042: [1644143] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.182328] i8042: [1644144] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.187110] i8042: [1644145] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.192324] i8042: [1644147] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.193720] i8042: [1644147] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.197051] i8042: [1644148] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.202324] i8042: [1644149] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.207029] i8042: [1644150] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.212423] i8042: [1644152] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.213780] i8042: [1644152] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.217037] i8042: [1644153] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.222325] i8042: [1644154] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.223717] i8042: [1644154] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.227060] i8042: [1644155] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.232432] i8042: [1644157] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.233948] i8042: [1644157] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.237064] i8042: [1644158] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.242326] i8042: [1644159] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.243713] i8042: [1644159] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.247072] i8042: [1644160] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.252475] i8042: [1644162] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.253838] i8042: [1644162] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.257072] i8042: [1644163] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.262358] i8042: [1644164] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.263713] i8042: [1644164] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.265233] i8042: [1644165] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.268103] i8042: [1644166] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.273336] i8042: [1644167] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.274711] i8042: [1644167] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.276230] i8042: [1644168] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.279030] i8042: [1644168] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.284336] i8042: [1644170] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.285747] i8042: [1644170] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.287267] i8042: [1644170] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.290056] i8042: [1644171] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.295396] i8042: [1644172] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.296745] i8042: [1644173] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.298240] i8042: [1644173] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.301130] i8042: [1644174] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.306334] i8042: [1644175] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.311062] i8042: [1644176] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.316390] i8042: [1644178] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.317714] i8042: [1644178] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.319223] i8042: [1644178] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.322120] i8042: [1644179] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.327333] i8042: [1644180] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.328706] i8042: [1644181] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.332067] i8042: [1644182] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.337373] i8042: [1644183] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.338705] i8042: [1644183] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.340319] i8042: [1644184] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.343112] i8042: [1644184] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.348565] i8042: [1644186] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.353158] i8042: [1644187] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.358619] i8042: [1644188] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.363143] i8042: [1644189] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.368657] i8042: [1644191] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.373155] i8042: [1644192] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.378623] i8042: [1644193] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.383174] i8042: [1644194] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.388600] i8042: [1644196] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.393163] i8042: [1644197] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.398700] i8042: [1644198] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.403179] i8042: [1644199] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.408605] i8042: [1644201] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.413209] i8042: [1644202] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.418651] i8042: [1644203] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.423198] i8042: [1644204] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.428698] i8042: [1644206] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.433199] i8042: [1644207] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.438678] i8042: [1644208] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.443226] i8042: [1644209] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.448648] i8042: [1644211] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.453222] i8042: [1644212] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.458694] i8042: [1644213] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.463234] i8042: [1644214] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.468656] i8042: [1644216] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.473261] i8042: [1644217] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.478691] i8042: [1644218] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.483239] i8042: [1644219] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.488691] i8042: [1644221] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.493246] i8042: [1644222] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.498687] i8042: [1644223] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.503289] i8042: [1644224] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.508688] i8042: [1644226] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.513274] i8042: [1644227] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.518652] i8042: [1644228] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.520165] i8042: [1644229] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.523286] i8042: [1644229] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.528682] i8042: [1644231] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.533282] i8042: [1644232] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.538682] i8042: [1644233] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.543306] i8042: [1644234] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.548685] i8042: [1644236] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.553306] i8042: [1644237] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.558681] i8042: [1644238] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.563302] i8042: [1644239] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.568682] i8042: [1644241] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.573302] i8042: [1644242] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.578682] i8042: [1644243] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.583303] i8042: [1644244] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.588678] i8042: [1644246] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.593299] i8042: [1644247] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.598678] i8042: [1644248] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.603299] i8042: [1644249] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.604679] i8042: [1644250] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.608679] i8042: [1644251] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.613300] i8042: [1644252] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.618675] i8042: [1644253] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.620164] i8042: [1644254] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.623296] i8042: [1644254] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.624676] i8042: [1644255] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.628673] i8042: [1644256] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.633296] i8042: [1644257] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.638681] i8042: [1644258] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.640203] i8042: [1644259] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.643296] i8042: [1644259] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.644672] i8042: [1644260] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.648672] i8042: [1644261] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.650190] i8042: [1644261] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.653293] i8042: [1644262] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.658724] i8042: [1644263] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.660295] i8042: [1644264] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.663293] i8042: [1644264] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.668673] i8042: [1644266] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.670186] i8042: [1644266] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.673293] i8042: [1644267] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.678734] i8042: [1644268] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.680292] i8042: [1644269] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.683290] i8042: [1644269] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.688703] i8042: [1644271] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.690226] i8042: [1644271] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:22 test kernel: [ 6577.693290] i8042: [1644272] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.698901] i8042: [1644273] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.703529] i8042: [1644274] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.708708] i8042: [1644276] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.710199] i8042: [1644276] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.713299] i8042: [1644277] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.714664] i8042: [1644277] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.716172] i8042: [1644278] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.719352] i8042: [1644278] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.720676] i8042: [1644279] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.722185] i8042: [1644279] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.724995] i8042: [1644280] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.730287] i8042: [1644281] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.734981] i8042: [1644282] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.740553] i8042: [1644284] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.744991] i8042: [1644285] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.750283] i8042: [1644286] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.751659] i8042: [1644286] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.753149] i8042: [1644287] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.755932] i8042: [1644287] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.764048] i8042: [1644290] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.766670] i8042: [1644290] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.768182] i8042: [1644291] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.772281] i8042: [1644292] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.776705] i8042: [1644293] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.778207] i8042: [1644293] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.782281] i8042: [1644294] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.786714] i8042: [1644295] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.788216] i8042: [1644296] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.792281] i8042: [1644297] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.796712] i8042: [1644298] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.798157] i8042: [1644298] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.802278] i8042: [1644299] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.803655] i8042: [1644299] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.806722] i8042: [1644300] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.808236] i8042: [1644301] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.812278] i8042: [1644302] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.816895] i8042: [1644303] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.822278] i8042: [1644304] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.823630] i8042: [1644304] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.825135] i8042: [1644305] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.827947] i8042: [1644305] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.833274] i8042: [1644307] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.837793] i8042: [1644308] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.839275] i8042: [1644308] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.843274] i8042: [1644309] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.847946] i8042: [1644310] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.853271] i8042: [1644312] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.857954] i8042: [1644313] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.863281] i8042: [1644314] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.864890] i8042: [1644315] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.867963] i8042: [1644315] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.873271] i8042: [1644317] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.877998] i8042: [1644318] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.883268] i8042: [1644319] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.884647] i8042: [1644320] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.888077] i8042: [1644321] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.893268] i8042: [1644322] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.894646] i8042: [1644322] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.898008] i8042: [1644323] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.903313] i8042: [1644324] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.904648] i8042: [1644325] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.906244] i8042: [1644325] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.909025] i8042: [1644326] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.914322] i8042: [1644327] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.915693] i8042: [1644327] c0 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.917197] i8042: [1644328] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.919974] i8042: [1644328] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.925561] i8042: [1644330] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.930007] i8042: [1644331] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.935263] i8042: [1644332] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.936643] i8042: [1644333] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.938142] i8042: [1644333] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.940950] i8042: [1644334] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.946509] i8042: [1644335] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.950970] i8042: [1644336] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.956262] i8042: [1644338] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.960989] i8042: [1644339] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.966315] i8042: [1644340] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.967647] i8042: [1644340] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.970997] i8042: [1644341] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.976263] i8042: [1644343] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.977635] i8042: [1644343] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.981009] i8042: [1644344] c1 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.986302] i8042: [1644345] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.987635] i8042: [1644345] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.989246] i8042: [1644346] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.992033] i8042: [1644347] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.997312] i8042: [1644348] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6577.998669] i8042: [1644348] c2 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6578.000173] i8042: [1644349] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6578.002986] i8042: [1644349] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6578.008547] i8042: [1644351] 80 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6578.013006] i8042: [1644352] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6578.018263] i8042: [1644353] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6578.019630] i8042: [1644353] c3 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6578.021134] i8042: [1644354] 00 <- i8042 (interrupt, 1, 12)
Apr 1 23:09:23 test kernel: [ 6578.023906] i8042: [1644354] 00 <- i8042 (interrupt, 1, 12)
I'm unable to find out the data format and how it's interleaved with touchpad.
Anyone with more synaptics and PS/2 experience?
--
Ondrej Zary
^ permalink raw reply
* [PATCH 3/3] input: gamecon: avoid using __set_bit() for capabilities
From: Marcus Folkesson @ 2018-03-31 11:21 UTC (permalink / raw)
To: Dmitry Torokhov; +Cc: Marcus Folkesson, linux-input, linux-kernel
In-Reply-To: <20180331112143.18768-1-marcus.folkesson@gmail.com>
input_set_capability() and input_set_abs_param() will do it for you.
Signed-off-by: Marcus Folkesson <marcus.folkesson@gmail.com>
---
drivers/input/joystick/gamecon.c | 26 ++++++++++++++------------
1 file changed, 14 insertions(+), 12 deletions(-)
diff --git a/drivers/input/joystick/gamecon.c b/drivers/input/joystick/gamecon.c
index 2ffb2e8bdc3b..e3a9ef3d5f5a 100644
--- a/drivers/input/joystick/gamecon.c
+++ b/drivers/input/joystick/gamecon.c
@@ -862,7 +862,7 @@ static int gc_setup_pad(struct gc *gc, int idx, int pad_type)
case GC_N64:
for (i = 0; i < 10; i++)
- __set_bit(gc_n64_btn[i], input_dev->keybit);
+ input_set_capability(input_dev, EV_KEY, gc_n64_btn[i]);
for (i = 0; i < 2; i++) {
input_set_abs_params(input_dev, ABS_X + i, -127, 126, 0, 2);
@@ -879,26 +879,27 @@ static int gc_setup_pad(struct gc *gc, int idx, int pad_type)
break;
case GC_SNESMOUSE:
- __set_bit(BTN_LEFT, input_dev->keybit);
- __set_bit(BTN_RIGHT, input_dev->keybit);
- __set_bit(REL_X, input_dev->relbit);
- __set_bit(REL_Y, input_dev->relbit);
+ input_set_capability(input_dev, EV_KEY, BTN_LEFT);
+ input_set_capability(input_dev, EV_KEY, BTN_RIGHT);
+ input_set_capability(input_dev, EV_REL, REL_X);
+ input_set_capability(input_dev, EV_REL, REL_Y);
break;
case GC_SNES:
for (i = 4; i < 8; i++)
- __set_bit(gc_snes_btn[i], input_dev->keybit);
+ input_set_capability(input_dev, EV_KEY, gc_snes_btn[i]);
/* fall through */
case GC_NES:
for (i = 0; i < 4; i++)
- __set_bit(gc_snes_btn[i], input_dev->keybit);
+ input_set_capability(input_dev, EV_KEY, gc_snes_btn[i]);
break;
case GC_MULTI2:
- __set_bit(BTN_THUMB, input_dev->keybit);
+ input_set_capability(input_dev, EV_KEY, BTN_THUMB);
/* fall through */
case GC_MULTI:
- __set_bit(BTN_TRIGGER, input_dev->keybit);
+ input_set_capability(input_dev, EV_KEY, BTN_TRIGGER);
+ /* fall through */
break;
case GC_PSX:
@@ -906,15 +907,16 @@ static int gc_setup_pad(struct gc *gc, int idx, int pad_type)
input_set_abs_params(input_dev,
gc_psx_abs[i], 4, 252, 0, 2);
for (i = 0; i < 12; i++)
- __set_bit(gc_psx_btn[i], input_dev->keybit);
+ input_set_capability(input_dev, EV_KEY, gc_psx_btn[i]);
+ break;
break;
case GC_DDR:
for (i = 0; i < 4; i++)
- __set_bit(gc_psx_ddr_btn[i], input_dev->keybit);
+ input_set_capability(input_dev, EV_KEY, gc_psx_ddr_btn[i]);
for (i = 0; i < 12; i++)
- __set_bit(gc_psx_btn[i], input_dev->keybit);
+ input_set_capability(input_dev, EV_KEY, gc_psx_btn[i]);
break;
}
--
2.16.2
^ permalink raw reply related
* [PATCH 2/3] input: as5011: avoid using __set_bit() for capabilities
From: Marcus Folkesson @ 2018-03-31 11:21 UTC (permalink / raw)
To: Dmitry Torokhov; +Cc: Marcus Folkesson, linux-input, linux-kernel
In-Reply-To: <20180331112143.18768-1-marcus.folkesson@gmail.com>
input_set_capability() and input_set_abs_param() will do it for you.
Signed-off-by: Marcus Folkesson <marcus.folkesson@gmail.com>
---
drivers/input/joystick/as5011.c | 4 +---
1 file changed, 1 insertion(+), 3 deletions(-)
diff --git a/drivers/input/joystick/as5011.c b/drivers/input/joystick/as5011.c
index 005d852a06e9..f051993c568e 100644
--- a/drivers/input/joystick/as5011.c
+++ b/drivers/input/joystick/as5011.c
@@ -269,9 +269,7 @@ static int as5011_probe(struct i2c_client *client,
input_dev->id.bustype = BUS_I2C;
input_dev->dev.parent = &client->dev;
- __set_bit(EV_KEY, input_dev->evbit);
- __set_bit(EV_ABS, input_dev->evbit);
- __set_bit(BTN_JOYSTICK, input_dev->keybit);
+ input_set_capability(input_dev, EV_KEY, BTN_JOYSTICK);
input_set_abs_params(input_dev, ABS_X,
AS5011_MIN_AXIS, AS5011_MAX_AXIS, AS5011_FUZZ, AS5011_FLAT);
--
2.16.2
^ permalink raw reply related
* [PATCH 1/3] input: xpad: avoid using __set_bit() for capabilities
From: Marcus Folkesson @ 2018-03-31 11:21 UTC (permalink / raw)
To: Dmitry Torokhov; +Cc: Marcus Folkesson, linux-input, linux-kernel
input_set_capability() and input_set_abs_param() will do it for you.
Signed-off-by: Marcus Folkesson <marcus.folkesson@gmail.com>
---
drivers/input/joystick/xpad.c | 15 ++++++---------
1 file changed, 6 insertions(+), 9 deletions(-)
diff --git a/drivers/input/joystick/xpad.c b/drivers/input/joystick/xpad.c
index 9d2688f3f961..cbf54082281d 100644
--- a/drivers/input/joystick/xpad.c
+++ b/drivers/input/joystick/xpad.c
@@ -1568,7 +1568,6 @@ static void xpad_close(struct input_dev *dev)
static void xpad_set_up_abs(struct input_dev *input_dev, signed short abs)
{
struct usb_xpad *xpad = input_get_drvdata(input_dev);
- set_bit(abs, input_dev->absbit);
switch (abs) {
case ABS_X:
@@ -1628,10 +1627,7 @@ static int xpad_init_input(struct usb_xpad *xpad)
input_dev->close = xpad_close;
}
- __set_bit(EV_KEY, input_dev->evbit);
-
if (!(xpad->mapping & MAP_STICKS_TO_NULL)) {
- __set_bit(EV_ABS, input_dev->evbit);
/* set up axes */
for (i = 0; xpad_abs[i] >= 0; i++)
xpad_set_up_abs(input_dev, xpad_abs[i]);
@@ -1639,21 +1635,21 @@ static int xpad_init_input(struct usb_xpad *xpad)
/* set up standard buttons */
for (i = 0; xpad_common_btn[i] >= 0; i++)
- __set_bit(xpad_common_btn[i], input_dev->keybit);
+ input_set_capability(input_dev, EV_KEY, xpad_common_btn[i]);
/* set up model-specific ones */
if (xpad->xtype == XTYPE_XBOX360 || xpad->xtype == XTYPE_XBOX360W ||
xpad->xtype == XTYPE_XBOXONE) {
for (i = 0; xpad360_btn[i] >= 0; i++)
- __set_bit(xpad360_btn[i], input_dev->keybit);
+ input_set_capability(input_dev, EV_KEY, xpad360_btn[i]);
} else {
for (i = 0; xpad_btn[i] >= 0; i++)
- __set_bit(xpad_btn[i], input_dev->keybit);
+ input_set_capability(input_dev, EV_KEY, xpad_btn[i]);
}
if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
for (i = 0; xpad_btn_pad[i] >= 0; i++)
- __set_bit(xpad_btn_pad[i], input_dev->keybit);
+ input_set_capability(input_dev, EV_KEY, xpad_btn_pad[i]);
}
/*
@@ -1670,7 +1666,8 @@ static int xpad_init_input(struct usb_xpad *xpad)
if (xpad->mapping & MAP_TRIGGERS_TO_BUTTONS) {
for (i = 0; xpad_btn_triggers[i] >= 0; i++)
- __set_bit(xpad_btn_triggers[i], input_dev->keybit);
+ input_set_capability(input_dev, EV_KEY,
+ xpad_btn_triggers[i]);
} else {
for (i = 0; xpad_abs_triggers[i] >= 0; i++)
xpad_set_up_abs(input_dev, xpad_abs_triggers[i]);
--
2.16.2
^ permalink raw reply related
* Re: [v3,4/4] watchdog: add Gateworks System Controller support
From: Guenter Roeck @ 2018-03-30 18:19 UTC (permalink / raw)
To: Tim Harvey
Cc: Lee Jones, Rob Herring, Mark Rutland, Mark Brown, Dmitry Torokhov,
Wim Van Sebroeck, linux-kernel, devicetree, linux-arm-kernel,
linux-hwmon, linux-input, linux-watchdog
In-Reply-To: <CAJ+vNU3ARKLK5AcssEP-_P8AmwnAnS8VtAEO1ppwum2jpCqAYQ@mail.gmail.com>
On Fri, Mar 30, 2018 at 10:49:38AM -0700, Tim Harvey wrote:
> On Thu, Mar 29, 2018 at 6:07 PM, Guenter Roeck <linux@roeck-us.net> wrote:
> > On Wed, Mar 28, 2018 at 08:14:03AM -0700, Tim Harvey wrote:
> >> Signed-off-by: Tim Harvey <tharvey@gateworks.com>
> >> ---
> >> drivers/watchdog/Kconfig | 10 ++++
> >> drivers/watchdog/Makefile | 1 +
> >> drivers/watchdog/gsc_wdt.c | 146 +++++++++++++++++++++++++++++++++++++++++++++
> >> 3 files changed, 157 insertions(+)
> >> create mode 100644 drivers/watchdog/gsc_wdt.c
> >>
> <snip>
> >> +
> >> +static const struct watchdog_info gsc_wdt_info = {
> >> + .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
> >
> > Please confirm that WDIOF_MAGICCLOSE is not set on purpose.
> >
> >> + .identity = "GSC Watchdog"
> >> +};
> >> +
> <snip>
> >> +
> >> +static int gsc_wdt_probe(struct platform_device *pdev)
> >> +{
> >> + struct gsc_dev *gsc = dev_get_drvdata(pdev->dev.parent);
> >> + struct device *dev = &pdev->dev;
> >> + struct gsc_wdt *wdt;
> >> + int ret;
> >> + unsigned int reg;
> >> +
> <snip>
> >> + /* ensure WD bit enabled */
> >> + if (regmap_read(gsc->regmap, GSC_CTRL_1, ®))
> >> + return -EIO;
> >> + if (!(reg & (1 << GSC_CTRL_1_WDT_ENABLE))) {
> >
> > BIT()
> >
> >> + dev_err(dev, "not enabled - must be manually enabled\n");
> >
> > This doesn't make sense. Bail out if the watchdog is disabled ? Why ?
> >
> >> + return -EINVAL;
> >> + }
> >> +
> <snip>
> >> +
> >> + watchdog_set_nowayout(&wdt->wdt_dev, 1);
> >
> > WATCHDOG_NOWAYOUT ?
> >
>
> Guenter,
>
> Thanks for the review!
>
> The watchdog implementation of the GSC is such that it is enabled and
> reset via a single non-volatile I2C register bit. If this bit is set
> the watchdog will start ticking down automatically on board power up.
> The register definitions don't provide a condition where it can be
> enabled in a volatile way such that after board power-cycle it is
> disabled again nor do they provide a separate register for enable vs
> reset.
>
> In the typical case the user boots the board, driver registers
> watchdog, userspace watchdog daemon enables watchdog and it starts
> ticking. User now powers down the board and later powers it back up.
> The watchdog was enabled previously by userspace and the register is
> non-volatile so the watchdog starts ticking before the kernel driver
> and watchdog daemon yet the user breaks out into the bootloader or
> boots a different OS without a watchdog daemon and the board resets
> without them expecting it. The feature that the watchdog starts
> ticking at board power-up before the CPU has even fetched code was
> part of its design and was put there to work around some SoC errata
> that can cause the CPU to fail to fetch boot code. This has caused me
> to implement a watchdog driver that never actually 'enables' or
> 'disables' the watchdog which is why there is no MAGIC CLOSE and why I
Yet the driver does enable and disable the watchdog in its start and stop
functions. And I have no idea what that has to do with the MAGICCLOSE
functionality, which is quite orthogonal to the start/stop functionality.
> always set nowayout. Its possible this is a fairly unique case of a
> watchdog. The probe failure if the watchdog isn't enabled is because I
> don't want a non-enabled watchdog to get enabled just because the
> driver/daemon were there.
>
Huh ? The whole purpose of a watchdog is for it to be enabled when
the watchdog device is opened.
> I agree it's a very strange behavior and I'm not sure how to best
> document or support it with the Linux watchdog API. I welcome any
> recomendations!
>
Sorry, I fail to understand your logic.
You do not explain why your code bails out if the watchdog is not already
running. That does not make sense.
You are saying that you don't want the watchdog driver to enable the watchdog.
Since its whole purpose is to enable the watchdog if/when the watchdog device
is opened, that doesn't make sense either.
At the same time, you do not tell the watchdog core that the watchdog is
already running, meaning the system _will_ reboot unless the watchdog
device is opened within the watchdog timeout period. Again, that does not
make sense.
Maybe it all makes sense to you, but not to me, sorry.
Guenter
^ permalink raw reply
* Re: [PATCH] Input: add bu21029 touch driver
From: Dmitry Torokhov @ 2018-03-30 18:19 UTC (permalink / raw)
To: Jonas Mark (BT-FIR/ENG1)
Cc: Rob Herring, Mark Rutland, linux-input@vger.kernel.org,
devicetree@vger.kernel.org, linux-kernel@vger.kernel.org,
hs@denx.de, ZHU Yi (BT-FIR/ENG1-Zhu)
In-Reply-To: <7ab56efbafd34c11968d8cef2369c6a5@de.bosch.com>
On Tue, Mar 27, 2018 at 06:57:42AM +0000, Jonas Mark (BT-FIR/ENG1) wrote:
> > > + /* calculate Rz (pressure resistance value) by equation:
> > > + * Rz = Rx * (x/Q) * ((z2/z1) - 1), where
> > > + * Rx is x-plate resistance,
> > > + * Q is the touch screen resolution (8bit = 256, 12bit = 4096)
> > > + * x, z1, z2 are the measured positions.
> > > + */
> > > + rz = z2 - z1;
> > > + rz *= x;
> > > + rz *= bu21029->x_plate_ohms;
> > > + rz /= z1;
> > > + rz = DIV_ROUND_CLOSEST(rz, SCALE_12BIT);
> > > + if (rz <= bu21029->max_pressure) {
> > > + input_report_abs(bu21029->in_dev, ABS_X, x);
> > > + input_report_abs(bu21029->in_dev, ABS_Y, y);
> > > + input_report_abs(bu21029->in_dev, ABS_PRESSURE, rz);
> >
> > What is the values of pressure reported when finger is touching the
> > surface? IOW is 'rz' pressure or resistance?
>
> Rz is pressure measured in Ohms. That is, it is a resistance which
> correlates with finger pressure.
>
> I fear that I do not understand your question. Does ABS_PRESSURE have
> to be reported in a specific unit, e.g. milli Newton? We thought that
> it is a device specific scale and that it will be converted into a
> calibrated value (just like the coordinates) in user space.
What I was trying to say is that it is expected that ABS_PRESSURE values
grow the harder you press on the screen, and reduce back to 0 when
finger is about to be removed from the surface. Here, it seems, we have
the opposite case, where resistance decreases the harder you press and
increases up to some maximum value when you remove the finger.
IOW, I think you want to report:
input_report_abs(bu21029->in_dev, ABS_PRESSURE,
bu21029->max_pressure - rz);
Thanks.
--
Dmitry
^ permalink raw reply
* Re: [PATCH v2 07/10] input: touchscreen: touch_adc: add generic resistive ADC touchscreen
From: Dmitry Torokhov @ 2018-03-30 18:09 UTC (permalink / raw)
To: Jonathan Cameron
Cc: Eugen Hristev, ludovic.desroches, alexandre.belloni,
linux-arm-kernel, devicetree, linux-kernel, linux-iio,
linux-input, nicolas.ferre
In-Reply-To: <20180330135835.6a8f57f1@archlinux>
On Fri, Mar 30, 2018 at 01:58:35PM +0100, Jonathan Cameron wrote:
> On Tue, 27 Mar 2018 15:32:40 +0300
> Eugen Hristev <eugen.hristev@microchip.com> wrote:
>
> > This adds a generic resistive touchscreen (GRTS) driver, which is based
> > on an IIO device (an ADC). It must be connected to the channels of an ADC
> > to receive touch data. Then it will feed the data into the input subsystem
> > where it registers an input device.
> > It uses an IIO callback buffer to register to the IIO device
> >
> > Some parts of this patch are based on initial original work by
> > Mohamed Jamsheeth Hajanajubudeen and Bandaru Venkateswara Swamy
> >
> > Signed-off-by: Eugen Hristev <eugen.hristev@microchip.com>
> I like this a lot!
>
> A few minor bits and bobs inline. Over to Dmitry for the input
> side of things.
>
> Jonathan
>
> > ---
> > Changes in v2:
> > - this is now a generic resistive adc touchscreen driver
> >
> > drivers/input/touchscreen/Kconfig | 13 +++
> > drivers/input/touchscreen/Makefile | 1 +
> > drivers/input/touchscreen/touch_adc.c | 199 ++++++++++++++++++++++++++++++++++
> > 3 files changed, 213 insertions(+)
> > create mode 100644 drivers/input/touchscreen/touch_adc.c
> >
> > diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
> > index 4f15496..afd879f 100644
> > --- a/drivers/input/touchscreen/Kconfig
> > +++ b/drivers/input/touchscreen/Kconfig
> > @@ -92,6 +92,19 @@ config TOUCHSCREEN_AD7879_SPI
> > To compile this driver as a module, choose M here: the
> > module will be called ad7879-spi.
> >
> > +config TOUCHSCREEN_ADC
> > + tristate "Generic ADC based resistive touchscreen"
> > + depends on IIO
> > + select IIO_BUFFER_CB
> > + help
> > + Say Y here if you want to use the generic ADC
> > + resistive touchscreen driver.
> > +
> > + If unsure, say N (but it's safe to say "Y").
> > +
> > + To compile this driver as a module, choose M here: the
> > + module will be called touch_adc.ko.
> > +
> > config TOUCHSCREEN_AR1021_I2C
> > tristate "Microchip AR1020/1021 i2c touchscreen"
> > depends on I2C && OF
> > diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
> > index dddae79..cbe6121 100644
> > --- a/drivers/input/touchscreen/Makefile
> > +++ b/drivers/input/touchscreen/Makefile
> > @@ -13,6 +13,7 @@ obj-$(CONFIG_TOUCHSCREEN_AD7877) += ad7877.o
> > obj-$(CONFIG_TOUCHSCREEN_AD7879) += ad7879.o
> > obj-$(CONFIG_TOUCHSCREEN_AD7879_I2C) += ad7879-i2c.o
> > obj-$(CONFIG_TOUCHSCREEN_AD7879_SPI) += ad7879-spi.o
> > +obj-$(CONFIG_TOUCHSCREEN_ADC) += touch_adc.o
> > obj-$(CONFIG_TOUCHSCREEN_ADS7846) += ads7846.o
> > obj-$(CONFIG_TOUCHSCREEN_AR1021_I2C) += ar1021_i2c.o
> > obj-$(CONFIG_TOUCHSCREEN_ATMEL_MXT) += atmel_mxt_ts.o
> > diff --git a/drivers/input/touchscreen/touch_adc.c b/drivers/input/touchscreen/touch_adc.c
> > new file mode 100644
> > index 0000000..de4b929
> > --- /dev/null
> > +++ b/drivers/input/touchscreen/touch_adc.c
> > @@ -0,0 +1,199 @@
> > +// SPDX-License-Identifier: GPL-2.0
> > +/*
> > + * ADC generic resistive touchscreen (GRTS)
> > + *
> > + * Copyright (C) 2017,2018 Microchip Technology,
> > + * Author: Eugen Hristev <eugen.hristev@microchip.com>
> > + *
> > + */
> > +#include <linux/input.h>
> > +#include <linux/of.h>
> > +#include <linux/of_device.h>
> > +#include <linux/platform_device.h>
> > +#include <linux/iio/consumer.h>
> > +#include <linux/iio/iio.h>
> > +#include <linux/module.h>
> > +
> > +#define DRIVER_NAME "touch_adc"
> > +#define GRTS_DEFAULT_PRESSURE_THRESHOLD 10000
> > +#define MAX_POS_MASK GENMASK(11, 0)
> > +
> > +/**
> > + * grts_state - generic resistive touch screen information struct
> > + * @pressure_threshold: number representing the threshold for the pressure
> > + * @pressure: are we getting pressure info or not
> > + * @iio_chans: list of channels acquired
> > + * @iio_cb: iio_callback buffer for the data
> > + * @input: the input device structure that we register
> > + */
> > +struct grts_state {
> > + u32 pressure_threshold;
> > + bool pressure;
> > + struct iio_channel *iio_chans;
> > + struct iio_cb_buffer *iio_cb;
> > + struct input_dev *input;
> > +};
> > +
> > +static int grts_cb(const void *data, void *private)
> > +{
> > + const u16 *touch_info = data;
> > + struct grts_state *st = private;
> > +
> > + unsigned int x, y, press = 0xFFFF;
> > +
> > + /* channel data coming in buffer in the order below */
> > + x = touch_info[0];
> > + y = touch_info[1];
> > + if (st->pressure)
> > + press = touch_info[2];
> > +
> > + if ((!x && !y) || (st->pressure && (press > st->pressure_threshold))) {
> Ah, clearly pressure is the other way around to I assumed and gets larger as
> the pressure is reduced. hmm.
OK, in this case it should not be reported directly as ABS_PRESSURE, as
ABSP_RESSURE value is expected to grow the firmer the finger touches the
surface, and reduce to 0 when finger is about to be lifted.
>
> > + /* report end of touch */
> > + input_report_key(st->input, BTN_TOUCH, 0);
> > + input_sync(st->input);
> > + return 0;
> > + }
> > +
> > + /* report proper touch to subsystem*/
> > + input_report_abs(st->input, ABS_X, x);
> > + input_report_abs(st->input, ABS_Y, y);
> > + if (st->pressure)
> > + input_report_abs(st->input, ABS_PRESSURE, press);
> > + input_report_key(st->input, BTN_TOUCH, 1);
> > + input_sync(st->input);
> blank line preferred here.
>
> > + return 0;
> > +}
> > +
> > +static int grts_open(struct input_dev *dev)
> > +{
> > + int ret;
> > + struct grts_state *st = input_get_drvdata(dev);
> > +
> > + ret = iio_channel_start_all_cb(st->iio_cb);
> > + if (ret) {
> > + dev_err(dev->dev.parent, "failed to start callback buffer.\n");
> > + return ret;
> Drop the return ret out of the brackets.
Actually I prefer explicit "success" return path. But I would
appreciate if we called this "ret" variable "error".
>
> > + }
> > + return 0;
> > +}
> > +
> > +static void grts_close(struct input_dev *dev)
> > +{
> > + struct grts_state *st = input_get_drvdata(dev);
> > +
> > + iio_channel_stop_all_cb(st->iio_cb);
> > +}
> > +
> > +static int grts_probe(struct platform_device *pdev)
> > +{
> > + struct grts_state *st;
> > + struct input_dev *input;
> > + struct device *dev = &pdev->dev;
> > + struct device_node *node = dev->of_node;
> > + struct iio_channel *chan;
> > + int ret = 0;
> > +
> > + st = devm_kzalloc(dev, sizeof(struct grts_state), GFP_KERNEL);
> > + if (!st)
> > + return -ENOMEM;
> > +
> > + ret = of_property_read_u32(node,
> > + "generic-adc-resistive-touchscreen,pressure-threshold",
> > + &st->pressure_threshold);
> > + if (ret < 0) {
> > + dev_dbg(dev, "can't get touchscreen pressure threshold property.\n");
> > + st->pressure_threshold = GRTS_DEFAULT_PRESSURE_THRESHOLD;
> > + }
> > +
> > + /* get the channels from IIO device */
> > + st->iio_chans = devm_iio_channel_get_all(dev);
> > +
> > + if (IS_ERR(st->iio_chans)) {
> > + if (PTR_ERR(st->iio_chans) != -EPROBE_DEFER)
> > + dev_err(dev, "can't get iio channels.\n");
> > + return PTR_ERR(st->iio_chans);
> > + }
> > +
> > + chan = &st->iio_chans[0];
> > + st->pressure = false;
> > + while (chan && chan->indio_dev) {
> > + if (!strcmp(chan->channel->datasheet_name, "pressure"))
> > + st->pressure = true;
> > + chan++;
> > + }
> > +
> > + input = devm_input_allocate_device(dev);
> > + if (!input) {
> > + dev_err(dev, "failed to allocate input device.\n");
> > + return -ENOMEM;
> > + }
> > +
> > + input->name = DRIVER_NAME;
> > + input->id.bustype = BUS_HOST;
> > + input->dev.parent = dev;
This is already being set by devm_input_allocate_device().
> > + input->open = grts_open;
> > + input->close = grts_close;
> > +
> > + input_set_abs_params(input, ABS_X, 0, MAX_POS_MASK - 1, 0, 0);
> > + input_set_abs_params(input, ABS_Y, 0, MAX_POS_MASK - 1, 0, 0);
> > + if (st->pressure)
> > + input_set_abs_params(input, ABS_PRESSURE, 0, 0xffffff, 0, 0);
It would be good if you used the API from
include/linux/input/touchscreen.h to parse standard touchscreen
properties and implement sizing, flippign and rotation of the screen.
> > +
> > + input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
> > + input->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
> > +
> > + st->input = input;
> > + input_set_drvdata(input, st);
> > +
> > + ret = input_register_device(input);
> > + if (ret) {
> > + dev_err(dev, "failed to register input device.");
> > + return ret;
> > + }
> > +
> > + st->iio_cb = iio_channel_get_all_cb(&pdev->dev, grts_cb, st);
Hmm, we don't have devm-variant for this? Then you could use
devm_add_action_or_reset() to add cleanup action and completely remove
grts_remove().
> > +
> > + if (IS_ERR(st->iio_cb)) {
> > + dev_err(dev, "failed to allocate callback buffer.\n");
> > + ret = PTR_ERR(st->iio_cb);
> > + return ret;
> > + }
> > +
> > + platform_set_drvdata(pdev, st);
> > +
> > + return ret;
> > +}
> > +
> > +static int grts_remove(struct platform_device *pdev)
> > +{
> > + struct grts_state *st = platform_get_drvdata(pdev);
> > +
> > + iio_channel_release_all_cb(st->iio_cb);
> > + input_unregister_device(st->input);
This call is not needed since you are using managed input device.
> blank line preferred before simple returns.
>
> > + return 0;
> > +}
> > +
> > +static const struct of_device_id grts_of_match[] = {
> > + {
> > + .compatible = "generic-resistive-adc-touch",
> > + }, {
> > + /* sentinel */
> > + },
> > +};
> > +
> > +MODULE_DEVICE_TABLE(of, grts_of_match);
> > +
> > +static struct platform_driver grts_driver = {
> > + .probe = grts_probe,
> > + .remove = grts_remove,
> > + .driver = {
> > + .name = DRIVER_NAME,
> > + .of_match_table = of_match_ptr(grts_of_match),
> > + },
> > +};
> > +
> > +module_platform_driver(grts_driver);
> > +
> > +MODULE_AUTHOR("Eugen Hristev <eugen.hristev@microchip.com>");
> > +MODULE_DESCRIPTION("Generic ADC Resistive Touch Driver");
> > +MODULE_LICENSE("GPL v2");
>
Thanks.
--
Dmitry
^ permalink raw reply
* Re: [v3,4/4] watchdog: add Gateworks System Controller support
From: Tim Harvey @ 2018-03-30 17:49 UTC (permalink / raw)
To: Guenter Roeck
Cc: Lee Jones, Rob Herring, Mark Rutland, Mark Brown, Dmitry Torokhov,
Wim Van Sebroeck, linux-kernel, devicetree, linux-arm-kernel,
linux-hwmon, linux-input, linux-watchdog
In-Reply-To: <20180330010757.GA12896@roeck-us.net>
On Thu, Mar 29, 2018 at 6:07 PM, Guenter Roeck <linux@roeck-us.net> wrote:
> On Wed, Mar 28, 2018 at 08:14:03AM -0700, Tim Harvey wrote:
>> Signed-off-by: Tim Harvey <tharvey@gateworks.com>
>> ---
>> drivers/watchdog/Kconfig | 10 ++++
>> drivers/watchdog/Makefile | 1 +
>> drivers/watchdog/gsc_wdt.c | 146 +++++++++++++++++++++++++++++++++++++++++++++
>> 3 files changed, 157 insertions(+)
>> create mode 100644 drivers/watchdog/gsc_wdt.c
>>
<snip>
>> +
>> +static const struct watchdog_info gsc_wdt_info = {
>> + .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
>
> Please confirm that WDIOF_MAGICCLOSE is not set on purpose.
>
>> + .identity = "GSC Watchdog"
>> +};
>> +
<snip>
>> +
>> +static int gsc_wdt_probe(struct platform_device *pdev)
>> +{
>> + struct gsc_dev *gsc = dev_get_drvdata(pdev->dev.parent);
>> + struct device *dev = &pdev->dev;
>> + struct gsc_wdt *wdt;
>> + int ret;
>> + unsigned int reg;
>> +
<snip>
>> + /* ensure WD bit enabled */
>> + if (regmap_read(gsc->regmap, GSC_CTRL_1, ®))
>> + return -EIO;
>> + if (!(reg & (1 << GSC_CTRL_1_WDT_ENABLE))) {
>
> BIT()
>
>> + dev_err(dev, "not enabled - must be manually enabled\n");
>
> This doesn't make sense. Bail out if the watchdog is disabled ? Why ?
>
>> + return -EINVAL;
>> + }
>> +
<snip>
>> +
>> + watchdog_set_nowayout(&wdt->wdt_dev, 1);
>
> WATCHDOG_NOWAYOUT ?
>
Guenter,
Thanks for the review!
The watchdog implementation of the GSC is such that it is enabled and
reset via a single non-volatile I2C register bit. If this bit is set
the watchdog will start ticking down automatically on board power up.
The register definitions don't provide a condition where it can be
enabled in a volatile way such that after board power-cycle it is
disabled again nor do they provide a separate register for enable vs
reset.
In the typical case the user boots the board, driver registers
watchdog, userspace watchdog daemon enables watchdog and it starts
ticking. User now powers down the board and later powers it back up.
The watchdog was enabled previously by userspace and the register is
non-volatile so the watchdog starts ticking before the kernel driver
and watchdog daemon yet the user breaks out into the bootloader or
boots a different OS without a watchdog daemon and the board resets
without them expecting it. The feature that the watchdog starts
ticking at board power-up before the CPU has even fetched code was
part of its design and was put there to work around some SoC errata
that can cause the CPU to fail to fetch boot code. This has caused me
to implement a watchdog driver that never actually 'enables' or
'disables' the watchdog which is why there is no MAGIC CLOSE and why I
always set nowayout. Its possible this is a fairly unique case of a
watchdog. The probe failure if the watchdog isn't enabled is because I
don't want a non-enabled watchdog to get enabled just because the
driver/daemon were there.
I agree it's a very strange behavior and I'm not sure how to best
document or support it with the Linux watchdog API. I welcome any
recomendations!
Regards,
Tim
^ permalink raw reply
* Re: [v3,4/4] watchdog: add Gateworks System Controller support
From: Dmitry Torokhov @ 2018-03-30 17:48 UTC (permalink / raw)
To: Guenter Roeck
Cc: Tim Harvey, Lee Jones, Rob Herring, Mark Rutland, Mark Brown,
Wim Van Sebroeck, linux-kernel, devicetree, linux-arm-kernel,
linux-hwmon, linux-input, linux-watchdog
In-Reply-To: <20180330010757.GA12896@roeck-us.net>
On Thu, Mar 29, 2018 at 06:07:57PM -0700, Guenter Roeck wrote:
> On Wed, Mar 28, 2018 at 08:14:03AM -0700, Tim Harvey wrote:
> > Signed-off-by: Tim Harvey <tharvey@gateworks.com>
> > ---
> > drivers/watchdog/Kconfig | 10 ++++
> > drivers/watchdog/Makefile | 1 +
> > drivers/watchdog/gsc_wdt.c | 146 +++++++++++++++++++++++++++++++++++++++++++++
> > 3 files changed, 157 insertions(+)
> > create mode 100644 drivers/watchdog/gsc_wdt.c
> >
> > diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig
> > index ca200d1..c9d4b2e 100644
> > --- a/drivers/watchdog/Kconfig
> > +++ b/drivers/watchdog/Kconfig
> > @@ -150,6 +150,16 @@ config GPIO_WATCHDOG_ARCH_INITCALL
> > arch_initcall.
> > If in doubt, say N.
> >
> > +config GSC_WATCHDOG
> > + tristate "Gateworks System Controller (GSC) Watchdog support"
> > + depends on MFD_GATEWORKS_GSC
> > + select WATCHDOG_CORE
> > + help
> > + Say Y here to include support for the GSC Watchdog.
> > +
> > + This driver can also be built as a module. If so the module
> > + will be called gsc_wdt.
> > +
> > config MENF21BMC_WATCHDOG
> > tristate "MEN 14F021P00 BMC Watchdog"
> > depends on MFD_MENF21BMC || COMPILE_TEST
> > diff --git a/drivers/watchdog/Makefile b/drivers/watchdog/Makefile
> > index 715a210..499327e 100644
> > --- a/drivers/watchdog/Makefile
> > +++ b/drivers/watchdog/Makefile
> > @@ -215,6 +215,7 @@ obj-$(CONFIG_DA9055_WATCHDOG) += da9055_wdt.o
> > obj-$(CONFIG_DA9062_WATCHDOG) += da9062_wdt.o
> > obj-$(CONFIG_DA9063_WATCHDOG) += da9063_wdt.o
> > obj-$(CONFIG_GPIO_WATCHDOG) += gpio_wdt.o
> > +obj-$(CONFIG_GSC_WATCHDOG) += gsc_wdt.o
> > obj-$(CONFIG_TANGOX_WATCHDOG) += tangox_wdt.o
> > obj-$(CONFIG_WDAT_WDT) += wdat_wdt.o
> > obj-$(CONFIG_WM831X_WATCHDOG) += wm831x_wdt.o
> > diff --git a/drivers/watchdog/gsc_wdt.c b/drivers/watchdog/gsc_wdt.c
> > new file mode 100644
> > index 0000000..b43d083
> > --- /dev/null
> > +++ b/drivers/watchdog/gsc_wdt.c
> > @@ -0,0 +1,146 @@
> > +/* SPDX-License-Identifier: GPL-2.0
> > + *
> > + * Copyright (C) 2018 Gateworks Corporation
> > + *
> > + * This driver registers a Linux Watchdog for the GSC
> > + */
> > +#include <linux/mfd/gsc.h>
> > +#include <linux/module.h>
> > +#include <linux/platform_device.h>
> > +#include <linux/regmap.h>
> > +#include <linux/watchdog.h>
> > +
> > +#define WDT_DEFAULT_TIMEOUT 60
> > +
> > +struct gsc_wdt {
> > + struct watchdog_device wdt_dev;
> > + struct gsc_dev *gsc;
> > +};
> > +
> > +static int gsc_wdt_start(struct watchdog_device *wdd)
> > +{
> > + struct gsc_wdt *wdt = watchdog_get_drvdata(wdd);
> > + unsigned int reg = (1 << GSC_CTRL_1_WDT_ENABLE);
>
> Please use BIT().
>
> > + int ret;
> > +
> > + dev_dbg(wdd->parent, "%s timeout=%d\n", __func__, wdd->timeout);
>
> I don't think those debug messages add any value.
>
> > +
> > + /* clear first as regmap_update_bits will not write if no change */
> > + ret = regmap_update_bits(wdt->gsc->regmap, GSC_CTRL_1, reg, 0);
> > + if (ret)
> > + return ret;
> > + return regmap_update_bits(wdt->gsc->regmap, GSC_CTRL_1, reg, reg);
> > +}
> > +
> > +static int gsc_wdt_stop(struct watchdog_device *wdd)
> > +{
> > + struct gsc_wdt *wdt = watchdog_get_drvdata(wdd);
> > + unsigned int reg = (1 << GSC_CTRL_1_WDT_ENABLE);
> > +
>
> BIT(). You might as well drop the variable and just use
> BIT(GSC_CTRL_1_WDT_ENABLE) below.
>
> > + dev_dbg(wdd->parent, "%s\n", __func__);
> > +
> > + return regmap_update_bits(wdt->gsc->regmap, GSC_CTRL_1, reg, 0);
> > +}
> > +
> > +static int gsc_wdt_set_timeout(struct watchdog_device *wdd,
> > + unsigned int timeout)
> > +{
> > + struct gsc_wdt *wdt = watchdog_get_drvdata(wdd);
> > + unsigned int long_sel = 0;
> > +
> > + dev_dbg(wdd->parent, "%s: %d\n", __func__, timeout);
> > +
> > + switch (timeout) {
> > + case 60:
> > + long_sel = (1 << GSC_CTRL_1_WDT_TIME);
> > + case 30:
> > + regmap_update_bits(wdt->gsc->regmap, GSC_CTRL_1,
> > + (1 << GSC_CTRL_1_WDT_TIME),
>
> BIT()
>
> > + (long_sel << GSC_CTRL_1_WDT_TIME));
This looks wrong. Are you sure that in case of 60 timeout you want to
actually write
((1 << GSC_CTRL_1_WDT_TIME) << GSC_CTRL_1_WDT_TIME)
to the register?
Or you meant to write:
long_sel = timeout > 30;
regmap_update_bits(wdt->gsc->regmap, GSC_CTRL_1,
(long_sel << GSC_CTRL_1_WDT_TIME),
Thanks.
--
Dmitry
^ permalink raw reply
* Re: [PATCH v2 00/10] Add support for SAMA5D2 touchscreen
From: Jonathan Cameron @ 2018-03-30 13:02 UTC (permalink / raw)
To: Eugen Hristev
Cc: ludovic.desroches, alexandre.belloni, linux-arm-kernel,
devicetree, linux-kernel, linux-iio, linux-input, nicolas.ferre,
dmitry.torokhov
In-Reply-To: <1522153963-1121-1-git-send-email-eugen.hristev@microchip.com>
On Tue, 27 Mar 2018 15:32:33 +0300
Eugen Hristev <eugen.hristev@microchip.com> wrote:
> Hello,
>
> This patch series is a rework of my previous series named:
> [PATCH 00/14] iio: triggers: add consumer support
>
> In few words, this is the implementation of splitting the functionality
> of the IP block ADC device in SAMA5D2 SoC from ADC with touchscreen
> support. In order to avoid having a MFD device, two separate
> drivers that would work on same register base and split the IRQ,etc,
> as advised on the mailing list, I created a consumer driver for the
> channels, that will connect to the ADC as described in the device tree.
>
> I have collected feedback from everyone and here is the result:
> I have added a new generic resistive touchscreen driver, which acts
> as a iio consumer for the given channels and will create an input
> device and report the events. It uses a callback buffer to register
> to the IIO device and waits for data to be pushed.
> Inside the IIO device, I have kept a similar approach with the first version
> of the series, except that now the driver can take multiple buffers, and
> will configure the touchscreen part of the hardware device if the specific
> channels are requested.
>
> The SAMA5D2 ADC driver registers three new channels: two for the
> position on the X and Y axis, and one for the touch pressure.
> When channels are requested, it will check if the touchscreen channel mask
> includes the requested channels (it is possible that the consumer driver
> will not request pressure for example). If it's the case, it will work
> in touchscreen mode, and will refuse to do usual analog-digital conversion,
> because we have a single trigger and the touchscreen needs it.
> When the scan mask will include only old channels, the driver will function
> in the same way as before. If the scan mask somehow is a mix of the two (the
> masks intersect), the driver will refuse to work whatsoever (cannot have both
> in the same time).
> The driver allows reading raw data for the new channels, if claim direct
> mode works: no touchscreen driver requested anything. The new channels can
> act like the old ones. However, when requesting these channels, the usual
> trigger will not work and will not be enabled. The touchscreen channels
> require special trigger and irq configuration: pen detect, no pen detect
> and a periodic trigger to sample the touchscreen position and pressure.
> If the user attempts to use another trigger while there is a buffer
> that already requested the touchscreen channels (thus the trigger), the
> driver will refuse to comply.
>
> In order to have defines for the channel numbers, I added a bindings include
> file that goes on a separate commit :
> dt-bindings: iio: adc: at91-sama5d2_adc: add channel specific consumer info
> This should go in the same tree with the following commits :
> ARM: dts: at91: sama5d2: add channel cells for ADC device
> ARM: dts: at91: sama5d2: Add resistive touch device
>
> as build will break because these commits depend on the binding one
> which creates the included header file.
>
> After the discussions earlier this year on the mailing list, I hope this
> rework of the patches is much better and fulfills all the requirements
> for this implementation.
As I said in one of the later patches, I like this a lot.
It is a good blend of the moderately nasty handling needed in the ADC
driver with a lovely generic input driver.
Very nice! Hope everyone else agrees ;)
Jonathan
>
> Eugen Hristev (10):
> MAINTAINERS: add generic resistive touchscreen adc
> iio: Add channel for Position Relative
> dt-bindings: input: touchscreen: touch_adc: create bindings
> iio: inkern: add module put/get on iio dev module when requesting
> channels
> iio: adc: at91-sama5d2_adc: fix channel configuration for differential
> channels
> iio: adc: at91-sama5d2_adc: add support for position and pressure
> channels
> input: touchscreen: touch_adc: add generic resistive ADC touchscreen
> dt-bindings: iio: adc: at91-sama5d2_adc: add channel specific consumer
> info
> ARM: dts: at91: sama5d2: add channel cells for ADC device
> ARM: dts: at91: sama5d2: Add resistive touch device
>
> Documentation/ABI/testing/sysfs-bus-iio | 12 +
> .../bindings/iio/adc/at91-sama5d2_adc.txt | 9 +
> .../bindings/input/touchscreen/touch_adc.txt | 33 ++
> MAINTAINERS | 6 +
> arch/arm/boot/dts/sama5d2.dtsi | 12 +
> drivers/iio/adc/at91-sama5d2_adc.c | 491 ++++++++++++++++++++-
> drivers/iio/industrialio-core.c | 1 +
> drivers/iio/inkern.c | 8 +-
> drivers/input/touchscreen/Kconfig | 13 +
> drivers/input/touchscreen/Makefile | 1 +
> drivers/input/touchscreen/touch_adc.c | 199 +++++++++
> include/dt-bindings/iio/adc/at91-sama5d2_adc.h | 16 +
> include/uapi/linux/iio/types.h | 1 +
> tools/iio/iio_event_monitor.c | 2 +
> 14 files changed, 791 insertions(+), 13 deletions(-)
> create mode 100644 Documentation/devicetree/bindings/input/touchscreen/touch_adc.txt
> create mode 100644 drivers/input/touchscreen/touch_adc.c
> create mode 100644 include/dt-bindings/iio/adc/at91-sama5d2_adc.h
>
^ permalink raw reply
* Re: [PATCH v2 07/10] input: touchscreen: touch_adc: add generic resistive ADC touchscreen
From: Jonathan Cameron @ 2018-03-30 12:58 UTC (permalink / raw)
To: Eugen Hristev
Cc: ludovic.desroches, alexandre.belloni, linux-arm-kernel,
devicetree, linux-kernel, linux-iio, linux-input, nicolas.ferre,
dmitry.torokhov
In-Reply-To: <1522153963-1121-8-git-send-email-eugen.hristev@microchip.com>
On Tue, 27 Mar 2018 15:32:40 +0300
Eugen Hristev <eugen.hristev@microchip.com> wrote:
> This adds a generic resistive touchscreen (GRTS) driver, which is based
> on an IIO device (an ADC). It must be connected to the channels of an ADC
> to receive touch data. Then it will feed the data into the input subsystem
> where it registers an input device.
> It uses an IIO callback buffer to register to the IIO device
>
> Some parts of this patch are based on initial original work by
> Mohamed Jamsheeth Hajanajubudeen and Bandaru Venkateswara Swamy
>
> Signed-off-by: Eugen Hristev <eugen.hristev@microchip.com>
I like this a lot!
A few minor bits and bobs inline. Over to Dmitry for the input
side of things.
Jonathan
> ---
> Changes in v2:
> - this is now a generic resistive adc touchscreen driver
>
> drivers/input/touchscreen/Kconfig | 13 +++
> drivers/input/touchscreen/Makefile | 1 +
> drivers/input/touchscreen/touch_adc.c | 199 ++++++++++++++++++++++++++++++++++
> 3 files changed, 213 insertions(+)
> create mode 100644 drivers/input/touchscreen/touch_adc.c
>
> diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
> index 4f15496..afd879f 100644
> --- a/drivers/input/touchscreen/Kconfig
> +++ b/drivers/input/touchscreen/Kconfig
> @@ -92,6 +92,19 @@ config TOUCHSCREEN_AD7879_SPI
> To compile this driver as a module, choose M here: the
> module will be called ad7879-spi.
>
> +config TOUCHSCREEN_ADC
> + tristate "Generic ADC based resistive touchscreen"
> + depends on IIO
> + select IIO_BUFFER_CB
> + help
> + Say Y here if you want to use the generic ADC
> + resistive touchscreen driver.
> +
> + If unsure, say N (but it's safe to say "Y").
> +
> + To compile this driver as a module, choose M here: the
> + module will be called touch_adc.ko.
> +
> config TOUCHSCREEN_AR1021_I2C
> tristate "Microchip AR1020/1021 i2c touchscreen"
> depends on I2C && OF
> diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
> index dddae79..cbe6121 100644
> --- a/drivers/input/touchscreen/Makefile
> +++ b/drivers/input/touchscreen/Makefile
> @@ -13,6 +13,7 @@ obj-$(CONFIG_TOUCHSCREEN_AD7877) += ad7877.o
> obj-$(CONFIG_TOUCHSCREEN_AD7879) += ad7879.o
> obj-$(CONFIG_TOUCHSCREEN_AD7879_I2C) += ad7879-i2c.o
> obj-$(CONFIG_TOUCHSCREEN_AD7879_SPI) += ad7879-spi.o
> +obj-$(CONFIG_TOUCHSCREEN_ADC) += touch_adc.o
> obj-$(CONFIG_TOUCHSCREEN_ADS7846) += ads7846.o
> obj-$(CONFIG_TOUCHSCREEN_AR1021_I2C) += ar1021_i2c.o
> obj-$(CONFIG_TOUCHSCREEN_ATMEL_MXT) += atmel_mxt_ts.o
> diff --git a/drivers/input/touchscreen/touch_adc.c b/drivers/input/touchscreen/touch_adc.c
> new file mode 100644
> index 0000000..de4b929
> --- /dev/null
> +++ b/drivers/input/touchscreen/touch_adc.c
> @@ -0,0 +1,199 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * ADC generic resistive touchscreen (GRTS)
> + *
> + * Copyright (C) 2017,2018 Microchip Technology,
> + * Author: Eugen Hristev <eugen.hristev@microchip.com>
> + *
> + */
> +#include <linux/input.h>
> +#include <linux/of.h>
> +#include <linux/of_device.h>
> +#include <linux/platform_device.h>
> +#include <linux/iio/consumer.h>
> +#include <linux/iio/iio.h>
> +#include <linux/module.h>
> +
> +#define DRIVER_NAME "touch_adc"
> +#define GRTS_DEFAULT_PRESSURE_THRESHOLD 10000
> +#define MAX_POS_MASK GENMASK(11, 0)
> +
> +/**
> + * grts_state - generic resistive touch screen information struct
> + * @pressure_threshold: number representing the threshold for the pressure
> + * @pressure: are we getting pressure info or not
> + * @iio_chans: list of channels acquired
> + * @iio_cb: iio_callback buffer for the data
> + * @input: the input device structure that we register
> + */
> +struct grts_state {
> + u32 pressure_threshold;
> + bool pressure;
> + struct iio_channel *iio_chans;
> + struct iio_cb_buffer *iio_cb;
> + struct input_dev *input;
> +};
> +
> +static int grts_cb(const void *data, void *private)
> +{
> + const u16 *touch_info = data;
> + struct grts_state *st = private;
> +
> + unsigned int x, y, press = 0xFFFF;
> +
> + /* channel data coming in buffer in the order below */
> + x = touch_info[0];
> + y = touch_info[1];
> + if (st->pressure)
> + press = touch_info[2];
> +
> + if ((!x && !y) || (st->pressure && (press > st->pressure_threshold))) {
Ah, clearly pressure is the other way around to I assumed and gets larger as
the pressure is reduced. hmm.
> + /* report end of touch */
> + input_report_key(st->input, BTN_TOUCH, 0);
> + input_sync(st->input);
> + return 0;
> + }
> +
> + /* report proper touch to subsystem*/
> + input_report_abs(st->input, ABS_X, x);
> + input_report_abs(st->input, ABS_Y, y);
> + if (st->pressure)
> + input_report_abs(st->input, ABS_PRESSURE, press);
> + input_report_key(st->input, BTN_TOUCH, 1);
> + input_sync(st->input);
blank line preferred here.
> + return 0;
> +}
> +
> +static int grts_open(struct input_dev *dev)
> +{
> + int ret;
> + struct grts_state *st = input_get_drvdata(dev);
> +
> + ret = iio_channel_start_all_cb(st->iio_cb);
> + if (ret) {
> + dev_err(dev->dev.parent, "failed to start callback buffer.\n");
> + return ret;
Drop the return ret out of the brackets.
> + }
> + return 0;
> +}
> +
> +static void grts_close(struct input_dev *dev)
> +{
> + struct grts_state *st = input_get_drvdata(dev);
> +
> + iio_channel_stop_all_cb(st->iio_cb);
> +}
> +
> +static int grts_probe(struct platform_device *pdev)
> +{
> + struct grts_state *st;
> + struct input_dev *input;
> + struct device *dev = &pdev->dev;
> + struct device_node *node = dev->of_node;
> + struct iio_channel *chan;
> + int ret = 0;
> +
> + st = devm_kzalloc(dev, sizeof(struct grts_state), GFP_KERNEL);
> + if (!st)
> + return -ENOMEM;
> +
> + ret = of_property_read_u32(node,
> + "generic-adc-resistive-touchscreen,pressure-threshold",
> + &st->pressure_threshold);
> + if (ret < 0) {
> + dev_dbg(dev, "can't get touchscreen pressure threshold property.\n");
> + st->pressure_threshold = GRTS_DEFAULT_PRESSURE_THRESHOLD;
> + }
> +
> + /* get the channels from IIO device */
> + st->iio_chans = devm_iio_channel_get_all(dev);
> +
> + if (IS_ERR(st->iio_chans)) {
> + if (PTR_ERR(st->iio_chans) != -EPROBE_DEFER)
> + dev_err(dev, "can't get iio channels.\n");
> + return PTR_ERR(st->iio_chans);
> + }
> +
> + chan = &st->iio_chans[0];
> + st->pressure = false;
> + while (chan && chan->indio_dev) {
> + if (!strcmp(chan->channel->datasheet_name, "pressure"))
> + st->pressure = true;
> + chan++;
> + }
> +
> + input = devm_input_allocate_device(dev);
> + if (!input) {
> + dev_err(dev, "failed to allocate input device.\n");
> + return -ENOMEM;
> + }
> +
> + input->name = DRIVER_NAME;
> + input->id.bustype = BUS_HOST;
> + input->dev.parent = dev;
> + input->open = grts_open;
> + input->close = grts_close;
> +
> + input_set_abs_params(input, ABS_X, 0, MAX_POS_MASK - 1, 0, 0);
> + input_set_abs_params(input, ABS_Y, 0, MAX_POS_MASK - 1, 0, 0);
> + if (st->pressure)
> + input_set_abs_params(input, ABS_PRESSURE, 0, 0xffffff, 0, 0);
> +
> + input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
> + input->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
> +
> + st->input = input;
> + input_set_drvdata(input, st);
> +
> + ret = input_register_device(input);
> + if (ret) {
> + dev_err(dev, "failed to register input device.");
> + return ret;
> + }
> +
> + st->iio_cb = iio_channel_get_all_cb(&pdev->dev, grts_cb, st);
> +
> + if (IS_ERR(st->iio_cb)) {
> + dev_err(dev, "failed to allocate callback buffer.\n");
> + ret = PTR_ERR(st->iio_cb);
> + return ret;
> + }
> +
> + platform_set_drvdata(pdev, st);
> +
> + return ret;
> +}
> +
> +static int grts_remove(struct platform_device *pdev)
> +{
> + struct grts_state *st = platform_get_drvdata(pdev);
> +
> + iio_channel_release_all_cb(st->iio_cb);
> + input_unregister_device(st->input);
blank line preferred before simple returns.
> + return 0;
> +}
> +
> +static const struct of_device_id grts_of_match[] = {
> + {
> + .compatible = "generic-resistive-adc-touch",
> + }, {
> + /* sentinel */
> + },
> +};
> +
> +MODULE_DEVICE_TABLE(of, grts_of_match);
> +
> +static struct platform_driver grts_driver = {
> + .probe = grts_probe,
> + .remove = grts_remove,
> + .driver = {
> + .name = DRIVER_NAME,
> + .of_match_table = of_match_ptr(grts_of_match),
> + },
> +};
> +
> +module_platform_driver(grts_driver);
> +
> +MODULE_AUTHOR("Eugen Hristev <eugen.hristev@microchip.com>");
> +MODULE_DESCRIPTION("Generic ADC Resistive Touch Driver");
> +MODULE_LICENSE("GPL v2");
^ permalink raw reply
* Re: [PATCH v2 06/10] iio: adc: at91-sama5d2_adc: add support for position and pressure channels
From: Jonathan Cameron @ 2018-03-30 12:47 UTC (permalink / raw)
To: Eugen Hristev
Cc: ludovic.desroches, alexandre.belloni, linux-arm-kernel,
devicetree, linux-kernel, linux-iio, linux-input, nicolas.ferre,
dmitry.torokhov
In-Reply-To: <1522153963-1121-7-git-send-email-eugen.hristev@microchip.com>
On Tue, 27 Mar 2018 15:32:39 +0300
Eugen Hristev <eugen.hristev@microchip.com> wrote:
> This implements the support for position and pressure for the included
> touchscreen support in the SAMA5D2 SOC ADC block.
> Two position channels are added and one for pressure.
> They can be read in raw format, or through a buffer.
> A normal use case is for a consumer driver to register a callback buffer
> for these channels.
> When the touchscreen channels are in the active scan mask,
> the driver will start the touchscreen sampling and push the data to the
> buffer.
>
> Some parts of this patch are based on initial original work by
> Mohamed Jamsheeth Hajanajubudeen and Bandaru Venkateswara Swamy
>
> Signed-off-by: Eugen Hristev <eugen.hristev@microchip.com>
Looks pretty good to me. A few minor comments inline.
Jonathan
> ---
> Changes in v2:
> - the support is now based on callback buffer.
>
> drivers/iio/adc/at91-sama5d2_adc.c | 452 ++++++++++++++++++++++++++++++++++++-
> 1 file changed, 443 insertions(+), 9 deletions(-)
>
> diff --git a/drivers/iio/adc/at91-sama5d2_adc.c b/drivers/iio/adc/at91-sama5d2_adc.c
> index 8729d65..29a7fb9 100644
> --- a/drivers/iio/adc/at91-sama5d2_adc.c
> +++ b/drivers/iio/adc/at91-sama5d2_adc.c
> @@ -102,14 +102,26 @@
> #define AT91_SAMA5D2_LCDR 0x20
> /* Interrupt Enable Register */
> #define AT91_SAMA5D2_IER 0x24
> +/* Interrupt Enable Register - TS X measurement ready */
> +#define AT91_SAMA5D2_IER_XRDY BIT(20)
> +/* Interrupt Enable Register - TS Y measurement ready */
> +#define AT91_SAMA5D2_IER_YRDY BIT(21)
> +/* Interrupt Enable Register - TS pressure measurement ready */
> +#define AT91_SAMA5D2_IER_PRDY BIT(22)
> /* Interrupt Enable Register - general overrun error */
> #define AT91_SAMA5D2_IER_GOVRE BIT(25)
> +/* Interrupt Enable Register - Pen detect */
> +#define AT91_SAMA5D2_IER_PEN BIT(29)
> +/* Interrupt Enable Register - No pen detect */
> +#define AT91_SAMA5D2_IER_NOPEN BIT(30)
> /* Interrupt Disable Register */
> #define AT91_SAMA5D2_IDR 0x28
> /* Interrupt Mask Register */
> #define AT91_SAMA5D2_IMR 0x2c
> /* Interrupt Status Register */
> #define AT91_SAMA5D2_ISR 0x30
> +/* Interrupt Status Register - Pen touching sense status */
> +#define AT91_SAMA5D2_ISR_PENS BIT(31)
> /* Last Channel Trigger Mode Register */
> #define AT91_SAMA5D2_LCTMR 0x34
> /* Last Channel Compare Window Register */
> @@ -131,8 +143,38 @@
> #define AT91_SAMA5D2_CDR0 0x50
> /* Analog Control Register */
> #define AT91_SAMA5D2_ACR 0x94
> +/* Analog Control Register - Pen detect sensitivity mask */
> +#define AT91_SAMA5D2_ACR_PENDETSENS_MASK GENMASK(1, 0)
> +
> /* Touchscreen Mode Register */
> #define AT91_SAMA5D2_TSMR 0xb0
> +/* Touchscreen Mode Register - No touch mode */
> +#define AT91_SAMA5D2_TSMR_TSMODE_NONE 0
> +/* Touchscreen Mode Register - 4 wire screen, no pressure measurement */
> +#define AT91_SAMA5D2_TSMR_TSMODE_4WIRE_NO_PRESS 1
> +/* Touchscreen Mode Register - 4 wire screen, pressure measurement */
> +#define AT91_SAMA5D2_TSMR_TSMODE_4WIRE_PRESS 2
> +/* Touchscreen Mode Register - 5 wire screen */
> +#define AT91_SAMA5D2_TSMR_TSMODE_5WIRE 3
> +/* Touchscreen Mode Register - Average samples mask */
> +#define AT91_SAMA5D2_TSMR_TSAV_MASK GENMASK(5, 4)
> +/* Touchscreen Mode Register - Average samples */
> +#define AT91_SAMA5D2_TSMR_TSAV(x) ((x) << 4)
> +/* Touchscreen Mode Register - Touch/trigger frequency ratio mask */
> +#define AT91_SAMA5D2_TSMR_TSFREQ_MASK GENMASK(11, 8)
> +/* Touchscreen Mode Register - Touch/trigger frequency ratio */
> +#define AT91_SAMA5D2_TSMR_TSFREQ(x) ((x) << 8)
> +/* Touchscreen Mode Register - Pen Debounce Time mask */
> +#define AT91_SAMA5D2_TSMR_PENDBC_MASK GENMASK(31, 28)
> +/* Touchscreen Mode Register - Pen Debounce Time */
> +#define AT91_SAMA5D2_TSMR_PENDBC(x) ((x) << 28)
> +/* Touchscreen Mode Register - No DMA for touch measurements */
> +#define AT91_SAMA5D2_TSMR_NOTSDMA BIT(22)
> +/* Touchscreen Mode Register - Disable pen detection */
> +#define AT91_SAMA5D2_TSMR_PENDET_DIS (0 << 24)
> +/* Touchscreen Mode Register - Enable pen detection */
> +#define AT91_SAMA5D2_TSMR_PENDET_ENA BIT(24)
> +
> /* Touchscreen X Position Register */
> #define AT91_SAMA5D2_XPOSR 0xb4
> /* Touchscreen Y Position Register */
> @@ -151,6 +193,12 @@
> #define AT91_SAMA5D2_TRGR_TRGMOD_EXT_TRIG_FALL 2
> /* Trigger Mode external trigger any edge */
> #define AT91_SAMA5D2_TRGR_TRGMOD_EXT_TRIG_ANY 3
> +/* Trigger Mode internal periodic */
> +#define AT91_SAMA5D2_TRGR_TRGMOD_PERIODIC 5
> +/* Trigger Mode - trigger period mask */
> +#define AT91_SAMA5D2_TRGR_TRGPER_MASK GENMASK(31, 16)
> +/* Trigger Mode - trigger period */
> +#define AT91_SAMA5D2_TRGR_TRGPER(x) ((x) << 16)
>
> /* Correction Select Register */
> #define AT91_SAMA5D2_COSR 0xd0
> @@ -169,6 +217,22 @@
> #define AT91_SAMA5D2_SINGLE_CHAN_CNT 12
> #define AT91_SAMA5D2_DIFF_CHAN_CNT 6
>
> +#define AT91_SAMA5D2_TIMESTAMP_CHAN_IDX (AT91_SAMA5D2_SINGLE_CHAN_CNT + \
> + AT91_SAMA5D2_DIFF_CHAN_CNT + 1)
> +
> +#define AT91_SAMA5D2_TOUCH_X_CHAN_IDX (AT91_SAMA5D2_SINGLE_CHAN_CNT + \
> + AT91_SAMA5D2_DIFF_CHAN_CNT * 2)
> +#define AT91_SAMA5D2_TOUCH_Y_CHAN_IDX (AT91_SAMA5D2_TOUCH_X_CHAN_IDX + 1)
> +#define AT91_SAMA5D2_TOUCH_P_CHAN_IDX (AT91_SAMA5D2_TOUCH_Y_CHAN_IDX + 1)
> +#define AT91_SAMA5D2_MAX_CHAN_IDX AT91_SAMA5D2_TOUCH_P_CHAN_IDX
> +
> +#define TOUCH_SAMPLE_PERIOD_US 2000 /* 2ms */
> +#define TOUCH_PEN_DETECT_DEBOUNCE_US 200
> +
> +#define XYZ_MASK GENMASK(11, 0)
> +
> +#define MAX_POS_BITS 12
> +
Please prefix these defines as the chances of a clash with these generic names
is very high.
> /*
> * Maximum number of bytes to hold conversion from all channels
> * without the timestamp.
> @@ -222,6 +286,37 @@
> .indexed = 1, \
> }
>
> +#define AT91_SAMA5D2_CHAN_TOUCH(num, name, mod) \
> + { \
> + .type = IIO_POSITIONRELATIVE, \
> + .modified = 1, \
> + .channel = num, \
> + .channel2 = mod, \
> + .scan_index = num, \
> + .scan_type = { \
> + .sign = 'u', \
> + .realbits = 12, \
> + .storagebits = 16, \
> + }, \
> + .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
> + .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),\
> + .datasheet_name = name, \
> + }
> +#define AT91_SAMA5D2_CHAN_PRESSURE(num, name) \
> + { \
> + .type = IIO_PRESSURE, \
> + .channel = num, \
> + .scan_index = num, \
> + .scan_type = { \
> + .sign = 'u', \
> + .realbits = 12, \
> + .storagebits = 16, \
> + }, \
> + .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
> + .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),\
> + .datasheet_name = name, \
> + }
> +
> #define at91_adc_readl(st, reg) readl_relaxed(st->base + reg)
> #define at91_adc_writel(st, reg, val) writel_relaxed(val, st->base + reg)
>
> @@ -260,6 +355,22 @@ struct at91_adc_dma {
> s64 dma_ts;
> };
>
> +/**
> + * at91_adc_touch - at91-sama5d2 touchscreen information struct
> + * @sample_period_val: the value for periodic trigger interval
> + * @touching: is the pen touching the screen or not
> + * @x_pos: temporary placeholder for pressure computation
> + * @channels_bitmask: bitmask with the touchscreen channels enabled
> + * @workq: workqueue for buffer data pushing
> + */
> +struct at91_adc_touch {
> + u16 sample_period_val;
> + bool touching;
> + u16 x_pos;
> + unsigned long channels_bitmask;
> + struct work_struct workq;
> +};
> +
> struct at91_adc_state {
> void __iomem *base;
> int irq;
> @@ -267,6 +378,7 @@ struct at91_adc_state {
> struct regulator *reg;
> struct regulator *vref;
> int vref_uv;
> + unsigned int current_sample_rate;
> struct iio_trigger *trig;
> const struct at91_adc_trigger *selected_trig;
> const struct iio_chan_spec *chan;
> @@ -275,6 +387,7 @@ struct at91_adc_state {
> struct at91_adc_soc_info soc_info;
> wait_queue_head_t wq_data_available;
> struct at91_adc_dma dma_st;
> + struct at91_adc_touch touch_st;
> u16 buffer[AT91_BUFFER_MAX_HWORDS];
> /*
> * lock to prevent concurrent 'single conversion' requests through
> @@ -329,8 +442,10 @@ static const struct iio_chan_spec at91_adc_channels[] = {
> AT91_SAMA5D2_CHAN_DIFF(6, 7, 0x68),
> AT91_SAMA5D2_CHAN_DIFF(8, 9, 0x70),
> AT91_SAMA5D2_CHAN_DIFF(10, 11, 0x78),
> - IIO_CHAN_SOFT_TIMESTAMP(AT91_SAMA5D2_SINGLE_CHAN_CNT
> - + AT91_SAMA5D2_DIFF_CHAN_CNT + 1),
> + IIO_CHAN_SOFT_TIMESTAMP(AT91_SAMA5D2_TIMESTAMP_CHAN_IDX),
> + AT91_SAMA5D2_CHAN_TOUCH(AT91_SAMA5D2_TOUCH_X_CHAN_IDX, "x", IIO_MOD_X),
> + AT91_SAMA5D2_CHAN_TOUCH(AT91_SAMA5D2_TOUCH_Y_CHAN_IDX, "y", IIO_MOD_Y),
> + AT91_SAMA5D2_CHAN_PRESSURE(AT91_SAMA5D2_TOUCH_P_CHAN_IDX, "pressure"),
> };
>
> static int at91_adc_chan_xlate(struct iio_dev *indio_dev, int chan)
> @@ -354,6 +469,162 @@ at91_adc_chan_get(struct iio_dev *indio_dev, int chan)
> return indio_dev->channels + index;
> }
>
> +static inline int at91_adc_of_xlate(struct iio_dev *indio_dev,
> + const struct of_phandle_args *iiospec)
> +{
> + return at91_adc_chan_xlate(indio_dev, iiospec->args[0]);
> +}
> +
> +static int at91_adc_configure_touch(struct at91_adc_state *st, bool state)
> +{
> + u32 clk_khz = st->current_sample_rate / 1000;
> + int i = 0;
> + u16 pendbc;
> + u32 tsmr, acr;
> +
> + if (!state) {
> + /* disabling touch IRQs and setting mode to no touch enabled */
> + at91_adc_writel(st, AT91_SAMA5D2_IDR,
> + AT91_SAMA5D2_IER_PEN | AT91_SAMA5D2_IER_NOPEN);
> + at91_adc_writel(st, AT91_SAMA5D2_TSMR, 0);
> + return 0;
> + }
> + /*
> + * debounce time is in microseconds, we need it in milliseconds to
> + * multiply with kilohertz, so, divide by 1000, but after the multiply.
> + * round up to make sure pendbc is at least 1
> + */
> + pendbc = round_up(TOUCH_PEN_DETECT_DEBOUNCE_US * clk_khz / 1000, 1);
> +
> + /* get the required exponent */
> + while (pendbc >> i++)
> + ;
> +
> + pendbc = i;
> +
> + tsmr = AT91_SAMA5D2_TSMR_TSMODE_4WIRE_PRESS;
> +
> + tsmr |= AT91_SAMA5D2_TSMR_TSAV(2) & AT91_SAMA5D2_TSMR_TSAV_MASK;
> + tsmr |= AT91_SAMA5D2_TSMR_PENDBC(pendbc) &
> + AT91_SAMA5D2_TSMR_PENDBC_MASK;
> + tsmr |= AT91_SAMA5D2_TSMR_NOTSDMA;
> + tsmr |= AT91_SAMA5D2_TSMR_PENDET_ENA;
> + tsmr |= AT91_SAMA5D2_TSMR_TSFREQ(2) & AT91_SAMA5D2_TSMR_TSFREQ_MASK;
> +
> + at91_adc_writel(st, AT91_SAMA5D2_TSMR, tsmr);
> +
> + acr = at91_adc_readl(st, AT91_SAMA5D2_ACR);
> + acr &= ~AT91_SAMA5D2_ACR_PENDETSENS_MASK;
> + acr |= 0x02 & AT91_SAMA5D2_ACR_PENDETSENS_MASK;
> + at91_adc_writel(st, AT91_SAMA5D2_ACR, acr);
> +
> + /* Sample Period Time = (TRGPER + 1) / ADCClock */
> + st->touch_st.sample_period_val = round_up((TOUCH_SAMPLE_PERIOD_US *
> + clk_khz / 1000) - 1, 1);
> + /* enable pen detect IRQ */
> + at91_adc_writel(st, AT91_SAMA5D2_IER, AT91_SAMA5D2_IER_PEN);
> +
> + return 0;
> +}
> +
> +static u16 at91_adc_touch_x_pos(struct at91_adc_state *st)
> +{
> + u32 val;
> + u32 xscale, x, xpos;
> +
> + /* x position = (x / xscale) * max, max = 2^MAX_POS_BITS - 1 */
> + val = at91_adc_readl(st, AT91_SAMA5D2_XPOSR);
> + if (!val)
> + dev_dbg(&iio_priv_to_dev(st)->dev, "x_pos is 0\n");
> +
> + xpos = val & XYZ_MASK;
> + x = (xpos << MAX_POS_BITS) - xpos;
> + xscale = (val >> 16) & XYZ_MASK;
> + if (xscale == 0) {
> + dev_err(&iio_priv_to_dev(st)->dev, "xscale is 0\n");
> + return 0;
> + }
> + x /= xscale;
> + st->touch_st.x_pos = x;
> +
> + return x;
> +}
> +
> +static u16 at91_adc_touch_y_pos(struct at91_adc_state *st)
> +{
> + u32 val;
> + u32 yscale, y, ypos;
> +
> + /* y position = (y / yscale) * max, max = 2^MAX_POS_BITS - 1 */
> + val = at91_adc_readl(st, AT91_SAMA5D2_YPOSR);
> + if (!val)
> + dev_dbg(&iio_priv_to_dev(st)->dev, "y_pos is 0\n");
> +
> + ypos = val & XYZ_MASK;
> + y = (ypos << MAX_POS_BITS) - ypos;
> + yscale = (val >> 16) & XYZ_MASK;
> +
> + if (yscale == 0) {
> + dev_err(&iio_priv_to_dev(st)->dev, "yscale is 0\n");
> + return 0;
> + }
> +
> + y /= yscale;
> +
> + return y;
This is obviously very similar to the above and feels like you need
some wrappers around a single function?
Just the xpos store needs to be outside the shared function.
> +}
> +
> +static u16 at91_adc_touch_pressure(struct at91_adc_state *st)
> +{
> + u32 val;
> + u32 z1, z2;
> + u32 pres;
> + u32 rxp = 1;
> + u32 factor = 1000;
> +
> + /* calculate the pressure */
> + val = at91_adc_readl(st, AT91_SAMA5D2_PRESSR);
> + z1 = val & XYZ_MASK;
> + z2 = (val >> 16) & XYZ_MASK;
> +
> + if (z1 != 0)
> + pres = rxp * (st->touch_st.x_pos * factor / 1024) *
> + (z2 * factor / z1 - factor) /
> + factor;
> + else
> + pres = 0xFFFF; /* no pen contact */
Would a pressure value of 0 not make more sense?
> +
> + return pres;
> +}
> +
> +static int at91_adc_read_position(struct at91_adc_state *st, int chan, u16 *val)
> +{
> + *val = 0;
> + if (!st->touch_st.touching)
> + return -ENODATA;
> + if (chan == AT91_SAMA5D2_TOUCH_X_CHAN_IDX)
> + *val = at91_adc_touch_x_pos(st);
> + else if (chan == AT91_SAMA5D2_TOUCH_Y_CHAN_IDX)
> + *val = at91_adc_touch_y_pos(st);
> + else
> + return -ENODATA;
> +
> + return IIO_VAL_INT;
> +}
> +
> +static int at91_adc_read_pressure(struct at91_adc_state *st, int chan, u16 *val)
> +{
> + *val = 0;
> + if (!st->touch_st.touching)
> + return -ENODATA;
> + if (chan == AT91_SAMA5D2_TOUCH_P_CHAN_IDX)
> + *val = at91_adc_touch_pressure(st);
> + else
> + return -ENODATA;
> +
> + return IIO_VAL_INT;
> +}
> +
> static int at91_adc_configure_trigger(struct iio_trigger *trig, bool state)
> {
> struct iio_dev *indio = iio_trigger_get_drvdata(trig);
> @@ -373,7 +644,7 @@ static int at91_adc_configure_trigger(struct iio_trigger *trig, bool state)
> for_each_set_bit(bit, indio->active_scan_mask, indio->num_channels) {
> struct iio_chan_spec const *chan = at91_adc_chan_get(indio, bit);
>
> - if (!chan)
> + if (!chan || chan->type != IIO_VOLTAGE)
I think this would be more robust if we had it matching what it was rather
than what it wasn't. Otherwise we'll get a temperature sensor on this
part at somepoint and it'll break.
> continue;
> if (state) {
> at91_adc_writel(st, AT91_SAMA5D2_CHER,
> @@ -520,7 +791,17 @@ static int at91_adc_dma_start(struct iio_dev *indio_dev)
> static int at91_adc_buffer_postenable(struct iio_dev *indio_dev)
> {
> int ret;
> + struct at91_adc_state *st = iio_priv(indio_dev);
>
> + /* check if we are enabling triggered buffer or the touchscreen */
> + if (bitmap_subset(indio_dev->active_scan_mask,
> + &st->touch_st.channels_bitmask,
> + AT91_SAMA5D2_MAX_CHAN_IDX + 1)) {
> + /* touchscreen enabling */
> + at91_adc_configure_touch(st, true);
Given you have that returning a value (be it always 0 I think)
better to pass that on here as well.
> + return 0;
> + }
> + /* we continue with the triggered buffer */
> ret = at91_adc_dma_start(indio_dev);
> if (ret) {
> dev_err(&indio_dev->dev, "buffer postenable failed\n");
> @@ -536,6 +817,16 @@ static int at91_adc_buffer_predisable(struct iio_dev *indio_dev)
> int ret;
> u8 bit;
>
> + /* check if we are disabling triggered buffer or the touchscreen */
> + if (bitmap_subset(indio_dev->active_scan_mask,
> + &st->touch_st.channels_bitmask,
> + AT91_SAMA5D2_MAX_CHAN_IDX + 1)) {
> + /* touchscreen disable */
> + at91_adc_configure_touch(st, false);
> + return 0;
> + }
> +
> + /* continue with the triggered buffer */
> ret = iio_triggered_buffer_predisable(indio_dev);
> if (ret < 0)
> dev_err(&indio_dev->dev, "buffer predisable failed\n");
> @@ -556,7 +847,7 @@ static int at91_adc_buffer_predisable(struct iio_dev *indio_dev)
> struct iio_chan_spec const *chan =
> at91_adc_chan_get(indio_dev, bit);
>
> - if (!chan)
> + if (!chan && chan->type != IIO_VOLTAGE)
> continue;
> if (st->dma_st.dma_chan)
> at91_adc_readl(st, chan->address);
> @@ -622,7 +913,10 @@ static void at91_adc_trigger_handler_nodma(struct iio_dev *indio_dev,
>
> if (!chan)
> continue;
> - st->buffer[i] = at91_adc_readl(st, chan->address);
> + if (chan->type == IIO_VOLTAGE)
> + st->buffer[i] = at91_adc_readl(st, chan->address);
> + else
> + st->buffer[i] = 0;
Please explain this one with a comment.
> i++;
> }
> iio_push_to_buffers_with_timestamp(indio_dev, st->buffer,
> @@ -736,6 +1030,7 @@ static void at91_adc_setup_samp_freq(struct at91_adc_state *st, unsigned freq)
>
> dev_dbg(&indio_dev->dev, "freq: %u, startup: %u, prescal: %u\n",
> freq, startup, prescal);
> + st->current_sample_rate = freq;
> }
>
> static unsigned at91_adc_get_sample_freq(struct at91_adc_state *st)
> @@ -751,23 +1046,109 @@ static unsigned at91_adc_get_sample_freq(struct at91_adc_state *st)
If st->current_sample_rate is always valid, then
can we just use that for the get call?
> return f_adc;
> }
>
> +static void at91_adc_touch_data_handler(struct iio_dev *indio_dev)
> +{
> + struct at91_adc_state *st = iio_priv(indio_dev);
> + u8 bit;
> + u16 val;
> + int i = 0;
> +
> + for_each_set_bit(bit, indio_dev->active_scan_mask,
> + AT91_SAMA5D2_MAX_CHAN_IDX + 1) {
> + struct iio_chan_spec const *chan =
> + at91_adc_chan_get(indio_dev, bit);
> +
> + if (chan->type == IIO_POSITIONRELATIVE)
> + at91_adc_read_position(st, chan->channel, &val);
> + else if (chan->type == IIO_PRESSURE)
> + at91_adc_read_pressure(st, chan->channel, &val);
> + else
> + continue;
> + st->buffer[i] = val;
> + i++;
> + }
> + /* schedule work to push to buffers */
I would expand the comment to say why you don't just do it directly.
> + schedule_work(&st->touch_st.workq);
> +}
> +
> +static void at91_adc_pen_detect_interrupt(struct at91_adc_state *st)
> +{
> + at91_adc_writel(st, AT91_SAMA5D2_IDR, AT91_SAMA5D2_IER_PEN);
> + at91_adc_writel(st, AT91_SAMA5D2_IER, AT91_SAMA5D2_IER_NOPEN |
> + AT91_SAMA5D2_IER_XRDY | AT91_SAMA5D2_IER_YRDY |
> + AT91_SAMA5D2_IER_PRDY);
> + at91_adc_writel(st, AT91_SAMA5D2_TRGR,
> + AT91_SAMA5D2_TRGR_TRGMOD_PERIODIC |
> + AT91_SAMA5D2_TRGR_TRGPER(st->touch_st.sample_period_val));
> + st->touch_st.touching = true;
> +}
> +
> +static void at91_adc_no_pen_detect_interrupt(struct at91_adc_state *st)
> +{
> + struct iio_dev *indio_dev = iio_priv_to_dev(st);
> +
> + at91_adc_writel(st, AT91_SAMA5D2_TRGR,
> + AT91_SAMA5D2_TRGR_TRGMOD_NO_TRIGGER);
> + at91_adc_writel(st, AT91_SAMA5D2_IDR, AT91_SAMA5D2_IER_NOPEN |
> + AT91_SAMA5D2_IER_XRDY | AT91_SAMA5D2_IER_YRDY |
> + AT91_SAMA5D2_IER_PRDY);
> + st->touch_st.touching = false;
> +
> + at91_adc_touch_data_handler(indio_dev);
> +
> + at91_adc_writel(st, AT91_SAMA5D2_IER, AT91_SAMA5D2_IER_PEN);
> +}
> +
> +static void at91_adc_workq_handler(struct work_struct *workq)
> +{
> + struct at91_adc_touch *touch_st = container_of(workq,
> + struct at91_adc_touch, workq);
> + struct at91_adc_state *st = container_of(touch_st,
> + struct at91_adc_state, touch_st);
> + struct iio_dev *indio_dev = iio_priv_to_dev(st);
> +
> + iio_push_to_buffers(indio_dev, st->buffer);
> +}
> +
> static irqreturn_t at91_adc_interrupt(int irq, void *private)
> {
> struct iio_dev *indio = private;
> struct at91_adc_state *st = iio_priv(indio);
> u32 status = at91_adc_readl(st, AT91_SAMA5D2_ISR);
> u32 imr = at91_adc_readl(st, AT91_SAMA5D2_IMR);
> + u32 rdy_mask = AT91_SAMA5D2_IER_XRDY | AT91_SAMA5D2_IER_YRDY |
> + AT91_SAMA5D2_IER_PRDY;
>
> if (!(status & imr))
> return IRQ_NONE;
> -
> - if (iio_buffer_enabled(indio) && !st->dma_st.dma_chan) {
> + if (status & AT91_SAMA5D2_IER_PEN) {
> + /* pen detected IRQ */
> + at91_adc_pen_detect_interrupt(st);
> + } else if ((status & AT91_SAMA5D2_IER_NOPEN)) {
> + /* nopen detected IRQ */
> + at91_adc_no_pen_detect_interrupt(st);
> + } else if ((status & AT91_SAMA5D2_ISR_PENS) &&
> + ((status & rdy_mask) == rdy_mask)) {
> + /* periodic trigger IRQ - during pen sense */
> + at91_adc_touch_data_handler(indio);
> + } else if (status & AT91_SAMA5D2_ISR_PENS) {
> + /*
> + * touching, but the measurements are not ready yet.
> + * read and ignore.
> + */
> + status = at91_adc_readl(st, AT91_SAMA5D2_XPOSR);
> + status = at91_adc_readl(st, AT91_SAMA5D2_YPOSR);
> + status = at91_adc_readl(st, AT91_SAMA5D2_PRESSR);
> + } else if (iio_buffer_enabled(indio) && !st->dma_st.dma_chan) {
> + /* triggered buffer without DMA */
> disable_irq_nosync(irq);
> iio_trigger_poll(indio->trig);
> } else if (iio_buffer_enabled(indio) && st->dma_st.dma_chan) {
> + /* triggered buffer with DMA - should not happen */
> disable_irq_nosync(irq);
> WARN(true, "Unexpected irq occurred\n");
> } else if (!iio_buffer_enabled(indio)) {
> + /* software requested conversion */
> st->conversion_value = at91_adc_readl(st, st->chan->address);
> st->conversion_done = true;
> wake_up_interruptible(&st->wq_data_available);
> @@ -791,6 +1172,21 @@ static int at91_adc_read_raw(struct iio_dev *indio_dev,
> return ret;
> mutex_lock(&st->lock);
>
> + if (chan->type == IIO_POSITIONRELATIVE) {
> + ret = at91_adc_read_position(st,
> + chan->channel, (u16 *)val);
Odd line breaking, I'd expect chan->channel on the first line..
These exit paths are a bit ugly. Perhaps it is time to pull the
INFO_RAW block out as a utility function. Then the indenting will
be less allowing a simple single exit point with the unlocking all
in one place.
> + mutex_unlock(&st->lock);
> + iio_device_release_direct_mode(indio_dev);
> + return ret;
> + }
> + if (chan->type == IIO_PRESSURE) {
> + ret = at91_adc_read_pressure(st,
> + chan->channel, (u16 *)val);
> + mutex_unlock(&st->lock);
> + iio_device_release_direct_mode(indio_dev);
> + return ret;
> + }
> +
> st->chan = chan;
>
> if (chan->differential)
> @@ -974,9 +1370,29 @@ static int at91_adc_set_watermark(struct iio_dev *indio_dev, unsigned int val)
> return 0;
> }
>
> +static int at91_adc_update_scan_mode(struct iio_dev *indio_dev,
> + const unsigned long *scan_mask)
> +{
> + struct at91_adc_state *st = iio_priv(indio_dev);
> +
> + if (bitmap_subset(scan_mask, &st->touch_st.channels_bitmask,
> + AT91_SAMA5D2_MAX_CHAN_IDX + 1))
> + return 0;
> + /*
> + * if the new bitmap is a combination of touchscreen and regular
> + * channels, then we are not fine
> + */
> + if (bitmap_intersects(&st->touch_st.channels_bitmask, scan_mask,
> + AT91_SAMA5D2_MAX_CHAN_IDX + 1))
> + return -EBUSY;
> + return 0;
> +}
> +
> static const struct iio_info at91_adc_info = {
> .read_raw = &at91_adc_read_raw,
> .write_raw = &at91_adc_write_raw,
> + .update_scan_mode = &at91_adc_update_scan_mode,
> + .of_xlate = &at91_adc_of_xlate,
> .hwfifo_set_watermark = &at91_adc_set_watermark,
> };
>
> @@ -1044,13 +1460,20 @@ static int at91_adc_probe(struct platform_device *pdev)
>
> indio_dev->dev.parent = &pdev->dev;
> indio_dev->name = dev_name(&pdev->dev);
> - indio_dev->modes = INDIO_DIRECT_MODE;
> + indio_dev->modes = INDIO_DIRECT_MODE | INDIO_BUFFER_SOFTWARE;
> indio_dev->info = &at91_adc_info;
> indio_dev->channels = at91_adc_channels;
> indio_dev->num_channels = ARRAY_SIZE(at91_adc_channels);
>
> st = iio_priv(indio_dev);
>
> + bitmap_set(&st->touch_st.channels_bitmask,
> + AT91_SAMA5D2_TOUCH_X_CHAN_IDX, 1);
> + bitmap_set(&st->touch_st.channels_bitmask,
> + AT91_SAMA5D2_TOUCH_Y_CHAN_IDX, 1);
> + bitmap_set(&st->touch_st.channels_bitmask,
> + AT91_SAMA5D2_TOUCH_P_CHAN_IDX, 1);
> +
> ret = of_property_read_u32(pdev->dev.of_node,
> "atmel,min-sample-rate-hz",
> &st->soc_info.min_sample_rate);
> @@ -1100,6 +1523,7 @@ static int at91_adc_probe(struct platform_device *pdev)
>
> init_waitqueue_head(&st->wq_data_available);
> mutex_init(&st->lock);
> + INIT_WORK(&st->touch_st.workq, at91_adc_workq_handler);
>
> res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> if (!res)
> @@ -1272,8 +1696,18 @@ static __maybe_unused int at91_adc_resume(struct device *dev)
> at91_adc_hw_init(st);
>
> /* reconfiguring trigger hardware state */
> - if (iio_buffer_enabled(indio_dev))
> + if (!iio_buffer_enabled(indio_dev))
> + return 0;
> +
> + /* check if we are enabling triggered buffer or the touchscreen */
> + if (bitmap_subset(indio_dev->active_scan_mask,
> + &st->touch_st.channels_bitmask,
> + AT91_SAMA5D2_MAX_CHAN_IDX + 1)) {
> + /* touchscreen enabling */
> + at91_adc_configure_touch(st, true);
> + } else {
> at91_adc_configure_trigger(st->trig, true);
> + }
>
> return 0;
>
^ permalink raw reply
* Re: [PATCH v2 05/10] iio: adc: at91-sama5d2_adc: fix channel configuration for differential channels
From: Jonathan Cameron @ 2018-03-30 12:17 UTC (permalink / raw)
To: Eugen Hristev
Cc: ludovic.desroches, alexandre.belloni, linux-arm-kernel,
devicetree, linux-kernel, linux-iio, linux-input, nicolas.ferre,
dmitry.torokhov
In-Reply-To: <1522153963-1121-6-git-send-email-eugen.hristev@microchip.com>
On Tue, 27 Mar 2018 15:32:38 +0300
Eugen Hristev <eugen.hristev@microchip.com> wrote:
> When iterating through the channels, the index in the array is not the
> scan index. Added an xlate function to translate to the proper index.
> This will be used also for devicetree channel xlate
>
> Signed-off-by: Eugen Hristev <eugen.hristev@microchip.com>
So, this is a fix for an existing bug?
Please move this to the front of your set (to make it easier to backport).
Describe the result of the bug as well.
Fixes tag would be good.
Thanks,
Jonathan
> ---
> drivers/iio/adc/at91-sama5d2_adc.c | 41 ++++++++++++++++++++++++++++++++++----
> 1 file changed, 37 insertions(+), 4 deletions(-)
>
> diff --git a/drivers/iio/adc/at91-sama5d2_adc.c b/drivers/iio/adc/at91-sama5d2_adc.c
> index 4eff835..8729d65 100644
> --- a/drivers/iio/adc/at91-sama5d2_adc.c
> +++ b/drivers/iio/adc/at91-sama5d2_adc.c
> @@ -333,6 +333,27 @@ static const struct iio_chan_spec at91_adc_channels[] = {
> + AT91_SAMA5D2_DIFF_CHAN_CNT + 1),
> };
>
> +static int at91_adc_chan_xlate(struct iio_dev *indio_dev, int chan)
> +{
> + int i;
> +
> + for (i = 0; i < indio_dev->num_channels; i++) {
> + if (indio_dev->channels[i].scan_index == chan)
> + return i;
> + }
> + return -EINVAL;
> +}
> +
> +static inline struct iio_chan_spec const *
> +at91_adc_chan_get(struct iio_dev *indio_dev, int chan)
> +{
> + int index = at91_adc_chan_xlate(indio_dev, chan);
> +
> + if (index < 0)
> + return NULL;
> + return indio_dev->channels + index;
> +}
> +
> static int at91_adc_configure_trigger(struct iio_trigger *trig, bool state)
> {
> struct iio_dev *indio = iio_trigger_get_drvdata(trig);
> @@ -350,8 +371,10 @@ static int at91_adc_configure_trigger(struct iio_trigger *trig, bool state)
> at91_adc_writel(st, AT91_SAMA5D2_TRGR, status);
>
> for_each_set_bit(bit, indio->active_scan_mask, indio->num_channels) {
> - struct iio_chan_spec const *chan = indio->channels + bit;
> + struct iio_chan_spec const *chan = at91_adc_chan_get(indio, bit);
>
> + if (!chan)
> + continue;
> if (state) {
> at91_adc_writel(st, AT91_SAMA5D2_CHER,
> BIT(chan->channel));
> @@ -448,7 +471,11 @@ static int at91_adc_dma_start(struct iio_dev *indio_dev)
>
> for_each_set_bit(bit, indio_dev->active_scan_mask,
> indio_dev->num_channels) {
> - struct iio_chan_spec const *chan = indio_dev->channels + bit;
> + struct iio_chan_spec const *chan =
> + at91_adc_chan_get(indio_dev, bit);
> +
> + if (!chan)
> + continue;
>
> st->dma_st.rx_buf_sz += chan->scan_type.storagebits / 8;
> }
> @@ -526,8 +553,11 @@ static int at91_adc_buffer_predisable(struct iio_dev *indio_dev)
> */
> for_each_set_bit(bit, indio_dev->active_scan_mask,
> indio_dev->num_channels) {
> - struct iio_chan_spec const *chan = indio_dev->channels + bit;
> + struct iio_chan_spec const *chan =
> + at91_adc_chan_get(indio_dev, bit);
>
> + if (!chan)
> + continue;
> if (st->dma_st.dma_chan)
> at91_adc_readl(st, chan->address);
> }
> @@ -587,8 +617,11 @@ static void at91_adc_trigger_handler_nodma(struct iio_dev *indio_dev,
>
> for_each_set_bit(bit, indio_dev->active_scan_mask,
> indio_dev->num_channels) {
> - struct iio_chan_spec const *chan = indio_dev->channels + bit;
> + struct iio_chan_spec const *chan =
> + at91_adc_chan_get(indio_dev, bit);
>
> + if (!chan)
> + continue;
> st->buffer[i] = at91_adc_readl(st, chan->address);
> i++;
> }
^ permalink raw reply
* [PATCH] hid: intel-ish-hid: use put_device() instead of kfree()
From: Arvind Yadav @ 2018-03-30 11:26 UTC (permalink / raw)
To: srinivas.pandruvada, jikos, benjamin.tissoires; +Cc: linux-kernel, linux-input
Never directly free @dev after calling device_register(), even
if it returned an error. Always use put_device() to give up the
reference initialized.
Signed-off-by: Arvind Yadav <arvind.yadav.cs@gmail.com>
---
drivers/hid/intel-ish-hid/ishtp/bus.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/drivers/hid/intel-ish-hid/ishtp/bus.c b/drivers/hid/intel-ish-hid/ishtp/bus.c
index f272cdd..2623a56 100644
--- a/drivers/hid/intel-ish-hid/ishtp/bus.c
+++ b/drivers/hid/intel-ish-hid/ishtp/bus.c
@@ -418,7 +418,7 @@ static struct ishtp_cl_device *ishtp_bus_add_device(struct ishtp_device *dev,
list_del(&device->device_link);
spin_unlock_irqrestore(&dev->device_list_lock, flags);
dev_err(dev->devc, "Failed to register ISHTP client device\n");
- kfree(device);
+ put_device(&device->dev);
return NULL;
}
--
2.7.4
^ permalink raw reply related
* Re: [v3,4/4] watchdog: add Gateworks System Controller support
From: Guenter Roeck @ 2018-03-30 1:07 UTC (permalink / raw)
To: Tim Harvey
Cc: Lee Jones, Rob Herring, Mark Rutland, Mark Brown, Dmitry Torokhov,
Wim Van Sebroeck, linux-kernel, devicetree, linux-arm-kernel,
linux-hwmon, linux-input, linux-watchdog
In-Reply-To: <1522250043-8065-5-git-send-email-tharvey@gateworks.com>
On Wed, Mar 28, 2018 at 08:14:03AM -0700, Tim Harvey wrote:
> Signed-off-by: Tim Harvey <tharvey@gateworks.com>
> ---
> drivers/watchdog/Kconfig | 10 ++++
> drivers/watchdog/Makefile | 1 +
> drivers/watchdog/gsc_wdt.c | 146 +++++++++++++++++++++++++++++++++++++++++++++
> 3 files changed, 157 insertions(+)
> create mode 100644 drivers/watchdog/gsc_wdt.c
>
> diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig
> index ca200d1..c9d4b2e 100644
> --- a/drivers/watchdog/Kconfig
> +++ b/drivers/watchdog/Kconfig
> @@ -150,6 +150,16 @@ config GPIO_WATCHDOG_ARCH_INITCALL
> arch_initcall.
> If in doubt, say N.
>
> +config GSC_WATCHDOG
> + tristate "Gateworks System Controller (GSC) Watchdog support"
> + depends on MFD_GATEWORKS_GSC
> + select WATCHDOG_CORE
> + help
> + Say Y here to include support for the GSC Watchdog.
> +
> + This driver can also be built as a module. If so the module
> + will be called gsc_wdt.
> +
> config MENF21BMC_WATCHDOG
> tristate "MEN 14F021P00 BMC Watchdog"
> depends on MFD_MENF21BMC || COMPILE_TEST
> diff --git a/drivers/watchdog/Makefile b/drivers/watchdog/Makefile
> index 715a210..499327e 100644
> --- a/drivers/watchdog/Makefile
> +++ b/drivers/watchdog/Makefile
> @@ -215,6 +215,7 @@ obj-$(CONFIG_DA9055_WATCHDOG) += da9055_wdt.o
> obj-$(CONFIG_DA9062_WATCHDOG) += da9062_wdt.o
> obj-$(CONFIG_DA9063_WATCHDOG) += da9063_wdt.o
> obj-$(CONFIG_GPIO_WATCHDOG) += gpio_wdt.o
> +obj-$(CONFIG_GSC_WATCHDOG) += gsc_wdt.o
> obj-$(CONFIG_TANGOX_WATCHDOG) += tangox_wdt.o
> obj-$(CONFIG_WDAT_WDT) += wdat_wdt.o
> obj-$(CONFIG_WM831X_WATCHDOG) += wm831x_wdt.o
> diff --git a/drivers/watchdog/gsc_wdt.c b/drivers/watchdog/gsc_wdt.c
> new file mode 100644
> index 0000000..b43d083
> --- /dev/null
> +++ b/drivers/watchdog/gsc_wdt.c
> @@ -0,0 +1,146 @@
> +/* SPDX-License-Identifier: GPL-2.0
> + *
> + * Copyright (C) 2018 Gateworks Corporation
> + *
> + * This driver registers a Linux Watchdog for the GSC
> + */
> +#include <linux/mfd/gsc.h>
> +#include <linux/module.h>
> +#include <linux/platform_device.h>
> +#include <linux/regmap.h>
> +#include <linux/watchdog.h>
> +
> +#define WDT_DEFAULT_TIMEOUT 60
> +
> +struct gsc_wdt {
> + struct watchdog_device wdt_dev;
> + struct gsc_dev *gsc;
> +};
> +
> +static int gsc_wdt_start(struct watchdog_device *wdd)
> +{
> + struct gsc_wdt *wdt = watchdog_get_drvdata(wdd);
> + unsigned int reg = (1 << GSC_CTRL_1_WDT_ENABLE);
Please use BIT().
> + int ret;
> +
> + dev_dbg(wdd->parent, "%s timeout=%d\n", __func__, wdd->timeout);
I don't think those debug messages add any value.
> +
> + /* clear first as regmap_update_bits will not write if no change */
> + ret = regmap_update_bits(wdt->gsc->regmap, GSC_CTRL_1, reg, 0);
> + if (ret)
> + return ret;
> + return regmap_update_bits(wdt->gsc->regmap, GSC_CTRL_1, reg, reg);
> +}
> +
> +static int gsc_wdt_stop(struct watchdog_device *wdd)
> +{
> + struct gsc_wdt *wdt = watchdog_get_drvdata(wdd);
> + unsigned int reg = (1 << GSC_CTRL_1_WDT_ENABLE);
> +
BIT(). You might as well drop the variable and just use
BIT(GSC_CTRL_1_WDT_ENABLE) below.
> + dev_dbg(wdd->parent, "%s\n", __func__);
> +
> + return regmap_update_bits(wdt->gsc->regmap, GSC_CTRL_1, reg, 0);
> +}
> +
> +static int gsc_wdt_set_timeout(struct watchdog_device *wdd,
> + unsigned int timeout)
> +{
> + struct gsc_wdt *wdt = watchdog_get_drvdata(wdd);
> + unsigned int long_sel = 0;
> +
> + dev_dbg(wdd->parent, "%s: %d\n", __func__, timeout);
> +
> + switch (timeout) {
> + case 60:
> + long_sel = (1 << GSC_CTRL_1_WDT_TIME);
> + case 30:
> + regmap_update_bits(wdt->gsc->regmap, GSC_CTRL_1,
> + (1 << GSC_CTRL_1_WDT_TIME),
BIT()
> + (long_sel << GSC_CTRL_1_WDT_TIME));
> + wdd->timeout = timeout;
> + return 0;
> + }
Please use rounding and accept other values as well. We don't want to let
user space guessing valid timeouts.
> +
> + return -EINVAL;
> +}
> +
> +static const struct watchdog_info gsc_wdt_info = {
> + .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
Please confirm that WDIOF_MAGICCLOSE is not set on purpose.
> + .identity = "GSC Watchdog"
> +};
> +
> +static const struct watchdog_ops gsc_wdt_ops = {
> + .owner = THIS_MODULE,
> + .start = gsc_wdt_start,
> + .stop = gsc_wdt_stop,
> + .set_timeout = gsc_wdt_set_timeout,
> +};
> +
> +static int gsc_wdt_probe(struct platform_device *pdev)
> +{
> + struct gsc_dev *gsc = dev_get_drvdata(pdev->dev.parent);
> + struct device *dev = &pdev->dev;
> + struct gsc_wdt *wdt;
> + int ret;
> + unsigned int reg;
> +
> + wdt = devm_kzalloc(dev, sizeof(*wdt), GFP_KERNEL);
> + if (!wdt)
> + return -ENOMEM;
> +
> + /* ensure GSC fw supports WD functionality */
> + if (gsc->fwver < 44) {
What if gsc is NULL ?
> + dev_err(dev, "fw v44 or newer required for wdt function\n");
> + return -EINVAL;
> + }
> +
> + /* ensure WD bit enabled */
> + if (regmap_read(gsc->regmap, GSC_CTRL_1, ®))
> + return -EIO;
> + if (!(reg & (1 << GSC_CTRL_1_WDT_ENABLE))) {
BIT()
> + dev_err(dev, "not enabled - must be manually enabled\n");
This doesn't make sense. Bail out if the watchdog is disabled ? Why ?
> + return -EINVAL;
> + }
> +
> + platform_set_drvdata(pdev, wdt);
> +
> + wdt->gsc = gsc;
> + wdt->wdt_dev.info = &gsc_wdt_info;
> + wdt->wdt_dev.ops = &gsc_wdt_ops;
> + wdt->wdt_dev.status = 0;
Initializing a data structure which is known to be 0 is not needed
and discouraged.
> + wdt->wdt_dev.min_timeout = 30;
> + wdt->wdt_dev.max_timeout = 60;
> + wdt->wdt_dev.parent = dev;
> +
> + watchdog_set_nowayout(&wdt->wdt_dev, 1);
WATCHDOG_NOWAYOUT ?
> + watchdog_init_timeout(&wdt->wdt_dev, WDT_DEFAULT_TIMEOUT, dev);
This is quite pointless. If you don't want to support setting the timeout
through devicetree or through a module parameter, just set the timeout
directly above.
> +
> + watchdog_set_drvdata(&wdt->wdt_dev, wdt);
> + ret = devm_watchdog_register_device(dev, &wdt->wdt_dev);
> + if (ret)
> + return ret;
> +
> + dev_info(dev, "watchdog driver (timeout=%d sec)\n",
> + wdt->wdt_dev.timeout);
> +
> + return 0;
> +}
> +
> +static const struct of_device_id gsc_wdt_dt_ids[] = {
> + { .compatible = "gw,gsc-watchdog", },
> + {}
> +};
> +
> +static struct platform_driver gsc_wdt_driver = {
> + .probe = gsc_wdt_probe,
> + .driver = {
> + .name = "gsc-wdt",
> + .of_match_table = gsc_wdt_dt_ids,
> + },
> +};
> +
> +module_platform_driver(gsc_wdt_driver);
> +
> +MODULE_AUTHOR("Tim Harvey <tharvey@gateworks.com>");
> +MODULE_DESCRIPTION("Gateworks System Controller Watchdog driver");
> +MODULE_LICENSE("GPL v2");
^ permalink raw reply
* Re: [PATCH v6 3/6] dt-bindings: input: Add document bindings for mtk-pmic-keys
From: Dmitry Torokhov @ 2018-03-29 16:16 UTC (permalink / raw)
To: Chen Zhong
Cc: Rob Herring, Lee Jones, Alexandre Belloni, Mark Rutland,
Matthias Brugger, Eddie Huang, Alessandro Zummo, Linus Walleij,
Beomho Seo, Javier Martinez Canillas, Jaechul Lee,
Krzysztof Kozlowski, linux-input, devicetree, linux-kernel,
linux-arm-kernel, linux-mediatek, linux-rtc
In-Reply-To: <1508937364-30054-4-git-send-email-chen.zhong@mediatek.com>
On Wed, Oct 25, 2017 at 09:16:01PM +0800, Chen Zhong wrote:
> This patch adds the device tree binding documentation for the MediaTek
> pmic keys found on PMIC MT6397/MT6323.
>
> Acked-by: Rob Herring <robh@kernel.org>
> Signed-off-by: Chen Zhong <chen.zhong@mediatek.com>
Acked-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
> ---
> .../devicetree/bindings/input/mtk-pmic-keys.txt | 43 ++++++++++++++++++++
> 1 file changed, 43 insertions(+)
> create mode 100644 Documentation/devicetree/bindings/input/mtk-pmic-keys.txt
>
> diff --git a/Documentation/devicetree/bindings/input/mtk-pmic-keys.txt b/Documentation/devicetree/bindings/input/mtk-pmic-keys.txt
> new file mode 100644
> index 0000000..2888d07
> --- /dev/null
> +++ b/Documentation/devicetree/bindings/input/mtk-pmic-keys.txt
> @@ -0,0 +1,43 @@
> +MediaTek MT6397/MT6323 PMIC Keys Device Driver
> +
> +There are two key functions provided by MT6397/MT6323 PMIC, pwrkey
> +and homekey. The key functions are defined as the subnode of the function
> +node provided by MT6397/MT6323 PMIC that is being defined as one kind
> +of Muti-Function Device (MFD)
> +
> +For MT6397/MT6323 MFD bindings see:
> +Documentation/devicetree/bindings/mfd/mt6397.txt
> +
> +Required properties:
> +- compatible: "mediatek,mt6397-keys" or "mediatek,mt6323-keys"
> +- linux,keycodes: See Documentation/devicetree/bindings/input/keys.txt
> +
> +Optional Properties:
> +- wakeup-source: See Documentation/devicetree/bindings/power/wakeup-source.txt
> +- mediatek,long-press-mode: Long press key shutdown setting, 1 for
> + pwrkey only, 2 for pwrkey/homekey together, others for disabled.
> +- power-off-time-sec: See Documentation/devicetree/bindings/input/keys.txt
> +
> +Example:
> +
> + pmic: mt6397 {
> + compatible = "mediatek,mt6397";
> +
> + ...
> +
> + mt6397keys: mt6397keys {
> + compatible = "mediatek,mt6397-keys";
> + mediatek,long-press-mode = <1>;
> + power-off-time-sec = <0>;
> +
> + power {
> + linux,keycodes = <116>;
> + wakeup-source;
> + };
> +
> + home {
> + linux,keycodes = <114>;
> + };
> + };
> +
> + };
> --
> 1.7.9.5
>
--
Dmitry
^ permalink raw reply
* Re: [PATCH v6 2/6] dt-bindings: input: Add common keyboard document bindings
From: Dmitry Torokhov @ 2018-03-29 16:15 UTC (permalink / raw)
To: Chen Zhong
Cc: Rob Herring, Lee Jones, Alexandre Belloni, Mark Rutland,
Matthias Brugger, Eddie Huang, Alessandro Zummo, Linus Walleij,
Beomho Seo, Javier Martinez Canillas, Jaechul Lee,
Krzysztof Kozlowski, linux-input, devicetree, linux-kernel,
linux-arm-kernel, linux-mediatek, linux-rtc
In-Reply-To: <1508937364-30054-3-git-send-email-chen.zhong@mediatek.com>
On Wed, Oct 25, 2017 at 09:16:00PM +0800, Chen Zhong wrote:
> This patch adds the device tree binding documentation for common
> keyboard.
>
> Acked-by: Rob Herring <robh@kernel.org>
> Signed-off-by: Chen Zhong <chen.zhong@mediatek.com>
Acked-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
> ---
> Documentation/devicetree/bindings/input/keys.txt | 8 ++++++++
> 1 file changed, 8 insertions(+)
> create mode 100644 Documentation/devicetree/bindings/input/keys.txt
>
> diff --git a/Documentation/devicetree/bindings/input/keys.txt b/Documentation/devicetree/bindings/input/keys.txt
> new file mode 100644
> index 0000000..a0ea7eb
> --- /dev/null
> +++ b/Documentation/devicetree/bindings/input/keys.txt
> @@ -0,0 +1,8 @@
> +General Keys Properties:
> +
> +Optional properties for Keys:
> +- power-off-time-sec: Duration in seconds which the key should be kept
> + pressed for device to power off automatically. Device with key pressed
> + shutdown feature can specify this property.
> +- linux,keycodes: Specifies the numeric keycode values to be used for
> + reporting key presses.
> \ No newline at end of file
> --
> 1.7.9.5
>
--
Dmitry
^ permalink raw reply
* Re: [PATCH v6 0/6] Add MediaTek PMIC keys support
From: Dmitry Torokhov @ 2018-03-29 16:15 UTC (permalink / raw)
To: Lee Jones
Cc: Chen Zhong, Matthias Brugger, Sean Wang, Rob Herring,
Alexandre Belloni, Mark Rutland, a.zummo, devicetree,
linus.walleij, jcsing.lee, linux-kernel, krzk, javier,
linux-mediatek, linux-arm-kernel, linux-input, eddie.huang,
beomho.seo, linux-rtc
In-Reply-To: <20180329130402.6fp7nofyp6iesmbv@dell>
On Thu, Mar 29, 2018 at 02:04:02PM +0100, Lee Jones wrote:
> On Thu, 29 Mar 2018, Chen Zhong wrote:
>
> > On Wed, 2018-03-28 at 11:26 +0100, Lee Jones wrote:
> > > On Tue, 27 Mar 2018, Matthias Brugger wrote:
> > >
> > > >
> > > >
> > > > On 03/27/2018 10:05 AM, Lee Jones wrote:
> > > > > On Fri, 23 Mar 2018, Dmitry Torokhov wrote:
> > > > >> On Thu, Mar 22, 2018 at 10:17:53AM +0800, Sean Wang wrote:
> > > > >>> Hi, Dmitry and Lee
> > > > >>>
> > > > >>> The series seems not being got merged. Are they good enough to be ready
> > > > >>> into the your tree?
> > > > >>>
> > > > >>> Recently I've tested the series with focusing on pwrkey event generated
> > > > >>> through interrupt when push and release the key on bpi-r2 board and then
> > > > >>> finally it's working fine. but for homekey it cannot be found on the
> > > > >>> board and thus I cannot have more tests more about it.
> > > > >>>
> > > > >>> Tested-by: Sean Wang <sean.wang@mediatek.com>
> > > > >>
> > > > >> You have my Ack on the input patch; I expect it go through Lee's tree as
> > > > >> there are some dependencies on mfd core piece.
> > > > >
> > > > > Are you happy for me to merge the Input dt-bindings without your Ack?
> > > > >
> > > >
> > > > They got both Acked in v5, but the commit message was not updated:
> > > > https://patchwork.kernel.org/patch/9973721/
> > > > https://patchwork.kernel.org/patch/9973723/
> > >
> > > Thanks Matthias.
> > >
> > > Chen, can you collect all the Acks and repost as a RESEND please?
> > >
> >
> > Thanks Matthias, Lee, Dmitry and Sean for your comments.
> >
> > Hi Lee,
> >
> > I have collected the Acks by Rob and sent the v6:
> > https://patchwork.kernel.org/patch/10026705
> > https://patchwork.kernel.org/patch/10026707
> >
> > Are they enough to be merged?
>
> Oh, I see.
>
> I was asking about Dmitry's Ack.
Oh, sorry, I did not realize you wanted my Ack for bindings. I usually
leave it to Rob and simply ack the driver itself when I am happy with
the code.
I'll go and add my ack to the binding post if that will help merging
the series.
Thanks.
--
Dmitry
^ permalink raw reply
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox