* Re: [PATCH v6 0/7] mfd: AXP20x: Add support for AXP202 and AXP209
From: Carlo Caione @ 2014-05-21 7:24 UTC (permalink / raw)
To: Mark Brown
Cc: Carlo Caione, linux-arm-kernel,
linux-sunxi-/JYPxA39Uh5TLH3MbocFFw, Maxime Ripard, Hans De Goede,
Emilio Lopez, wens Tsai, sameo-VuQAYsv1563Yd54FQh9/CA,
Dmitry Torokhov, linux-input-u79uwXL29TY76Z2rM5mHXA,
linux-doc-u79uwXL29TY76Z2rM5mHXA, Liam Girdwood, Lee Jones,
Boris BREZILLON
In-Reply-To: <20140520222307.GK12304-GFdadSzt00ze9xe1eoZjHA@public.gmane.org>
On Wed, May 21, 2014 at 12:23 AM, Mark Brown <broonie-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org> wrote:
> On Mon, May 19, 2014 at 09:47:41PM +0200, Carlo Caione wrote:
>
>> This set of patches introduces the core driver and support for two different
>> subsystems:
>> - Regulators
>
>> .../ABI/testing/sysfs-driver-input-axp-pek | 11 +
>> Documentation/devicetree/bindings/mfd/axp20x.txt | 93 +++++++
>> .../devicetree/bindings/vendor-prefixes.txt | 1 +
>> arch/arm/configs/multi_v7_defconfig | 3 +
>> arch/arm/configs/sunxi_defconfig | 4 +
>> drivers/input/misc/Kconfig | 11 +
>> drivers/input/misc/Makefile | 1 +
>> drivers/input/misc/axp20x-pek.c | 281 +++++++++++++++++++++
>> drivers/mfd/Kconfig | 12 +
>> drivers/mfd/Makefile | 1 +
>> drivers/mfd/axp20x.c | 258 +++++++++++++++++++
>> include/linux/mfd/axp20x.h | 180 +++++++++++++
>> 12 files changed, 856 insertions(+)
>
> The regulator changes don't appear to be showing up in the diffstat or
> obviously in the series?
Right. Cut-and-paste error.
You have already applied the regulator patches so I didn't include
them here (in theory I posted this series to be picked up by Lee).
Thanks,
--
Carlo Caione
^ permalink raw reply
* [PATCH] Input: mcs_touchkey: fix incorrect input device name
From: Beomho Seo @ 2014-05-21 7:07 UTC (permalink / raw)
To: linux-input, dmitry.torokhov, Joonyoung Shim
Cc: Myungjoo Ham, Jaehoon Chung, Chanwoo Choi
This patch fix a typo error at input device name.
Signed-off-by: Beomho Seo <beomho.seo@samsung.com>
Cc: Joonyoung Shim <jy0922.shim@samsung.com>
---
drivers/input/keyboard/mcs_touchkey.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/drivers/input/keyboard/mcs_touchkey.c b/drivers/input/keyboard/mcs_touchkey.c
index 1da8e0b..375b05c 100644
--- a/drivers/input/keyboard/mcs_touchkey.c
+++ b/drivers/input/keyboard/mcs_touchkey.c
@@ -147,7 +147,7 @@ static int mcs_touchkey_probe(struct i2c_client *client,
}
dev_info(&client->dev, "Firmware version: %d\n", fw_ver);
- input_dev->name = "MELPAS MCS Touchkey";
+ input_dev->name = "MELFAS MCS Touchkey";
input_dev->id.bustype = BUS_I2C;
input_dev->dev.parent = &client->dev;
input_dev->evbit[0] = BIT_MASK(EV_KEY);
--
1.7.9.5
^ permalink raw reply related
* [PATCH 2/2] Input: mcs_touchkey: add device tree binding document
From: Beomho Seo @ 2014-05-21 5:51 UTC (permalink / raw)
To: linux-input, devicetree, dmitry.torokhov, Joonyoung Shim,
mark.rutland
Cc: Myungjoo Ham, Jaehoon Chung, Chanwoo Choi
This patch add simple device tree bindings to
MELFAS MCS5000/5080 controller.
Signed-off-by: Beomho Seo <beomho.seo@samsung.com>
---
.../devicetree/bindings/input/mcs-touchkey.txt | 25 ++++++++++++++++++++
1 file changed, 25 insertions(+)
create mode 100644 Documentation/devicetree/bindings/input/mcs-touchkey.txt
diff --git a/Documentation/devicetree/bindings/input/mcs-touchkey.txt b/Documentation/devicetree/bindings/input/mcs-touchkey.txt
new file mode 100644
index 0000000..8364799
--- /dev/null
+++ b/Documentation/devicetree/bindings/input/mcs-touchkey.txt
@@ -0,0 +1,25 @@
+* mcs_touchkey MELFAS MCS5000/5080 controller
+
+Required properties:
+- compatible: must be "mcs5000_touchkey" or "mcs5080_touchkey"
+- reg : I2C address of the chip
+- interrupts: interrupt to which the chip is connected
+- key_maxval: size of keycode table
+- code: key code for this device
+
+Example:
+
+ i2c_touch_key: i2c-gpio-0 {
+ /* ... */
+
+ touch_key@20 {
+ compatible = "mcs5080_touchkey";
+ reg = <0x20>;
+ interrupt-patrent = <gpj0>;
+ key_maxval = <2>;
+ linux, code = <0x0000009e
+ 0x000000a9>;
+ };
+
+ /* ... */
+ };
--
1.7.9.5
^ permalink raw reply related
* [PATCH 1/2] Input: mcs_touchkey: add device tree support
From: Beomho Seo @ 2014-05-21 5:51 UTC (permalink / raw)
To: linux-input, devicetree, dmitry.torokhov, Joonyoung Shim,
mark.rutland
Cc: Myungjoo Ham, Jaehoon Chung, Chanwoo Choi
Add device tree support for mcs touchkey driver.
Tested on exynos 4412 board.
Signed-off-by: Beomho Seo <beomho.seo@samsung.com>
Cc: Joonyoung Shim <jy0922.shim@samsung.com>
---
drivers/input/keyboard/mcs_touchkey.c | 73 +++++++++++++++++++++++++++++++--
1 file changed, 69 insertions(+), 4 deletions(-)
diff --git a/drivers/input/keyboard/mcs_touchkey.c b/drivers/input/keyboard/mcs_touchkey.c
index 1da8e0b..9bff47b 100644
--- a/drivers/input/keyboard/mcs_touchkey.c
+++ b/drivers/input/keyboard/mcs_touchkey.c
@@ -19,6 +19,7 @@
#include <linux/irq.h>
#include <linux/slab.h>
#include <linux/pm.h>
+#include <linux/of_gpio.h>
/* MCS5000 Touchkey */
#define MCS5000_TOUCHKEY_STATUS 0x04
@@ -96,6 +97,60 @@ static irqreturn_t mcs_touchkey_interrupt(int irq, void *dev_id)
return IRQ_HANDLED;
}
+#ifdef CONFIG_OF
+static struct mcs_platform_data *mcs_touchkey_parse_dt(struct device *dev)
+{
+ struct mcs_platform_data *pdata;
+ struct device_node *np = dev->of_node;
+ unsigned int keymap[2];
+ unsigned int len;
+ int i = 0;
+ const __be32 *prop;
+
+ pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
+ if (!pdata) {
+ dev_err(dev, "Failed to allocate platform data\n");
+ return ERR_PTR(-ENOMEM);
+ }
+
+ prop = of_get_property(np, "linux,code", &len);
+ if (!prop) {
+ dev_err(dev, "Failed to get code\n");
+ return ERR_PTR(-EINVAL);
+ }
+
+ if (len % sizeof(u32)) {
+ dev_err(dev, "Malformed keycode property\n");
+ return ERR_PTR(-EINVAL);
+ }
+
+ pdata->keymap_size = len / sizeof(u32);
+
+ if (of_property_read_u32(np, "key_maxval", &pdata->key_maxval)) {
+ dev_err(dev, "Failed to get key max value data\n");
+ return ERR_PTR(-EINVAL);
+ }
+
+ if (pdata->keymap_size > pdata->key_maxval) {
+ dev_err(dev, "Key map size overflow\n");
+ return ERR_PTR(-EINVAL);
+ }
+
+ for (i = 0; i < pdata->keymap_size; i++) {
+ u32 code = be32_to_cpup(prop + i);
+ keymap[i] = MCS_KEY_MAP(i, code);
+ }
+ pdata->keymap = keymap;
+ return pdata;
+}
+#else
+static inline struct mcs_platform_data *mcs_touchkey_parse_dt
+ (struct device *dev)
+{
+ return NULL;
+}
+#endif
+
static int mcs_touchkey_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
@@ -107,10 +162,14 @@ static int mcs_touchkey_probe(struct i2c_client *client,
int error;
int i;
- pdata = dev_get_platdata(&client->dev);
- if (!pdata) {
- dev_err(&client->dev, "no platform data defined\n");
- return -EINVAL;
+ if (&client->dev.of_node)
+ pdata = mcs_touchkey_parse_dt(&client->dev);
+ else
+ pdata = dev_get_platdata(&client->dev);
+
+ if (IS_ERR(pdata)) {
+ dev_err(&client->dev, "Failed to get platform data\n");
+ return PTR_ERR(pdata);
}
data = kzalloc(sizeof(struct mcs_touchkey_data) +
@@ -262,11 +321,17 @@ static const struct i2c_device_id mcs_touchkey_id[] = {
};
MODULE_DEVICE_TABLE(i2c, mcs_touchkey_id);
+static struct of_device_id mcs_touchkey_dt_match[] = {
+ { .compatible = "mcs5000_touchkey", },
+ { .compatible = "mcs5080_touchkey", },
+};
+
static struct i2c_driver mcs_touchkey_driver = {
.driver = {
.name = "mcs_touchkey",
.owner = THIS_MODULE,
.pm = &mcs_touchkey_pm_ops,
+ .of_match_table = of_match_ptr(mcs_touchkey_dt_match),
},
.probe = mcs_touchkey_probe,
.remove = mcs_touchkey_remove,
--
1.7.9.5
^ permalink raw reply related
* [PATCH 0/2] Input: mcs_touchkey: Adding device tree support for mcs touch key
From: Beomho Seo @ 2014-05-21 5:51 UTC (permalink / raw)
To: linux-input, devicetree, dmitry.torokhov, Joonyoung Shim,
mark.rutland
Cc: Myungjoo Ham, Jaehoon Chung, Chanwoo Choi
This patch adds the possibility to get the data from the device tree.
It is based on next branch. and tested on exynos4412 board.
Beomho Seo (2):
Input: mcs_touchkey: add device tree support
Input: mcs_touchkey: add device tree binding document
.../devicetree/bindings/input/mcs-touchkey.txt | 25 +++++++
drivers/input/keyboard/mcs_touchkey.c | 73 ++++++++++++++++++--
2 files changed, 94 insertions(+), 4 deletions(-)
create mode 100644 Documentation/devicetree/bindings/input/mcs-touchkey.txt
--
1.7.9.5
^ permalink raw reply
* Re: [PATCH v4 01/24] input: Add ff-memless-next module
From: Michal Malý @ 2014-05-21 2:13 UTC (permalink / raw)
To: Roland Bosa
Cc: simon, Dmitry Torokhov, linux-input, linux-kernel, jkosina,
elias.vds, anssi.hannula
In-Reply-To: <537BFEBF.8010601@logitech.com>
On Tuesday 20 of May 2014 18:17:51 Roland Bosa wrote:
>
> The file format of an IFR is probably easily deducible. There's a lot of
> textual clues to parameters and the values are also written out in
> string form.
>
> I don't have a FEdit file at hand, but I suppose it will be similar.
I believe that Elias successfully reverse engineered the effect file format
produced by FEdit. There is no support for this kind of prefabricated effects
in the Linux FF API.
> > I assume that most AAA games, would implement these through some middle
> > layer. I think that is probably via Steam using SDL2 haptic API, we have
> > been testing against SDL2's 'testhaptic'.
>
> I wasn't aware of this layer. I must read up on it. It sounds like a
> simple way to access force feedback - I guess a game developer should
> shed some light on this...
>
>
> > Do you see another path (which we should be supporting/testing)?
>
> Nope, not at this time.
>
> > There was some discussion about rate limiting the USB packets to the
> > wheel, and how to deal if app updates too quickly. Is there an upper limit
> > for the wheel itself, or is it just the USB 'pipe' which is the limiting
> > factor?
>
> On the Windows side we send 125 reports/sec. The entire simulation loop
> runs with a 8ms resolution. I assume this value was chosen for some
> hardware constraints back in the days, but it has proven to be a good
> compromise for simulated periodics and physics constraints.
Our current code uses 8 msecs delay as well.
> In any case, the USB traffic should be decoupled from the app. Any force
> updates should only change state in the ff-memless[-next] driver. Any
> change there should trickle down to a 'slot' representation of the
> device. If there's any change in the slots, the device is marked as
> 'dirty' and USB transfers are scheduled to send the latest state to the
> physical device.
>
> The scheduling should keep track of how many requests are in-flight and
> delay writing the next output, until the previous one has completed.
The approach I had in mind would keep track of the last effect that made it to
the device and the last effect that arrived from userspace. This would be
stored for each effect slot. An update would be scheduled at the desired update
rate. The updating routine would figure out the state change between last
update and "now", send the required data to the device and reschedule itself.
The routine could check if there are any USB transfers still running and
reschedule itself immediately.
> Question back to the community: are there APIs in the USB layer to check
> for presence of in-progress requests? Can one add a 'completion'
> callback to a request, that gets invoked on completion/cancellation?
For instance "usb_submit_urb()" can have a completion handler that is called
once the transfer is done. The current code uses "hid_hw_request()" which is
asynchronous and doesn't report anything back.
Proper decoupling of the userspace and driver is the only important thing that
is missing from the current code.
Michal
^ permalink raw reply
* Re: [PATCH v4 01/24] input: Add ff-memless-next module
From: Roland Bosa @ 2014-05-21 1:17 UTC (permalink / raw)
To: simon
Cc: Michal Malý, Dmitry Torokhov, linux-input, linux-kernel,
jkosina, elias.vds, anssi.hannula
In-Reply-To: <1c6140633925b0838b7627e071e80761.squirrel@mungewell.org>
On 05/20/2014 04:30 PM, simon@mungewell.org wrote:
> Sounds like these are the effect files produced by FEdit tool (from MS
> DirectX SDK), and/or played back by pressing buttons when configuring the
> Logitech driver on Windows ('wooden bridge', etc)...
Prior to the FEdit tool, there was Immersion Studio [1]. It created IFR
files, which were read using a DLL that Immersion provided. This DLL
produced arrays of DIEFFECTs, which had specific durations and start
offsets. By starting the entire array, you would get the desired effect.
Most of the original effects in the Logitech Control Panel were done
that way (by yours truly, as a matter of fact). To "sell" the effect, a
sound-effect was queued concurrently with the force effect.
(Trivia: part of the "Wooden bridge" sound effect was made by smashing a
cigarette lighter against real wooden clogs of a co-worker, then slowing
down the audio a bit.)
In 2003, all of these effects were 'hardcoded' in a series of arrays of
arrays of DI_EFFECTs. This allowed us to drop the Immersion loader DLL
and create them on the fly.
> Do you know if there is a mechanism for playing these under Linux?
I don't - I'm fairly new to the Linux platform itself.
> Under Windows do games just send a 'file' the DirectX driver, or do they
> parse them into individual effects to send?
With the IFR approach, you call a function in a library in userland with
the filename, and it returns an array of effects. With the FEdit tool,
you call a function on the IDirectInputDevice and calls a given callback
the the loaded effects.[2]
At the end of the day, you end up with a series of user-land effect
structures. It's up to the 'game' to download and start them on a given
device.
> If format is known/public it shouldn't be hard to write a userland client
> to play them back.
The file format of an IFR is probably easily deducible. There's a lot of
textual clues to parameters and the values are also written out in
string form.
I don't have a FEdit file at hand, but I suppose it will be similar.
> I assume that most AAA games, would implement these through some middle
> layer. I think that is probably via Steam using SDL2 haptic API, we have
> been testing against SDL2's 'testhaptic'.
I wasn't aware of this layer. I must read up on it. It sounds like a
simple way to access force feedback - I guess a game developer should
shed some light on this...
> Do you see another path (which we should be supporting/testing)?
Nope, not at this time.
> There was some discussion about rate limiting the USB packets to the
> wheel, and how to deal if app updates too quickly. Is there an upper limit
> for the wheel itself, or is it just the USB 'pipe' which is the limiting
> factor?
On the Windows side we send 125 reports/sec. The entire simulation loop
runs with a 8ms resolution. I assume this value was chosen for some
hardware constraints back in the days, but it has proven to be a good
compromise for simulated periodics and physics constraints.
In any case, the USB traffic should be decoupled from the app. Any force
updates should only change state in the ff-memless[-next] driver. Any
change there should trickle down to a 'slot' representation of the
device. If there's any change in the slots, the device is marked as
'dirty' and USB transfers are scheduled to send the latest state to the
physical device.
The scheduling should keep track of how many requests are in-flight and
delay writing the next output, until the previous one has completed.
Question back to the community: are there APIs in the USB layer to check
for presence of in-progress requests? Can one add a 'completion'
callback to a request, that gets invoked on completion/cancellation?
Thanks
roland
--
[1]
http://www.immersion.com/developers/index.php?option=com_content&view=article&id=423&Itemid=684
[2]
http://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.idirectinputdevice8.idirectinputdevice8.enumeffectsinfile(v=vs.85).aspx
^ permalink raw reply
* Re: [PATCH v4 01/24] input: Add ff-memless-next module
From: Michal Malý @ 2014-05-21 0:08 UTC (permalink / raw)
To: simon
Cc: Dmitry Torokhov, linux-input, linux-kernel, jkosina, elias.vds,
anssi.hannula
In-Reply-To: <7e57db42a261a54d38a3a7bb068c3ce2.squirrel@mungewell.org>
On Tuesday 20 of May 2014 19:45:44 simon@mungewell.org wrote:
> >> Regarding the question of emulated vs. real effects, can we extend the
> >> API
> >> so that applications can know which effects are really supported, and
> >> enable/disable emulation somehow?
> >
> > I suppose that a few extra flags (FF_PERIODIC_EMULATED etc.) defined in
> > "uapi/linux/input.h" should suffice.
>
> The only problem is that we probably want to maintain backward
> compatibility so that older apps still see 'PERIODIC' (even though it is
> emulated).
> --
> #define FF_RUMBLE 0x50
> #define FF_PERIODIC 0x51
> #define FF_CONSTANT 0x52
> #define FF_SPRING 0x53
> #define FF_FRICTION 0x54
> #define FF_DAMPER 0x55
> #define FF_INERTIA 0x56
> #define FF_RAMP 0x57
> --
>
> Do we therefore have to list extra items in our capabilities?
> --
> static const signed short lg4ff_wheel_effects[] = {
> FF_CONSTANT,
> FF_PERIODIC,
> FF_PERIODIC_NOT_EMULATED,
> FF_AUTOCENTER,
> -1
> };
> --
>
> Simon
Actually I was thinking something like this:
"input.h"
#define FF_DAMPER 0x55
#define FF_INERTIA 0x56
#define FF_RAMP 0x57
+# define FF_PERIODIC_EMULATED 0x58
+# define FF_RUMBLE_EMULATED 0x59
and
in the future "library-like" reimplementation of MLNX:
#define EMULATE_PERIODIC BIT(0)
#define EMULATE_RUMBLE BIT(1)
kfflib_init(..., EMULATE_PERIODIC | EMULATE_RUMBLE);
for full emulation.
Michal
^ permalink raw reply
* Re: [PATCH v4 01/24] input: Add ff-memless-next module
From: simon @ 2014-05-20 23:45 UTC (permalink / raw)
To: "Michal Malý"
Cc: simon, Dmitry Torokhov, linux-input, linux-kernel, jkosina,
elias.vds, anssi.hannula
In-Reply-To: <6970969.ej8OFzkVkO@sigyn>
>> Regarding the question of emulated vs. real effects, can we extend the
>> API
>> so that applications can know which effects are really supported, and
>> enable/disable emulation somehow?
>
> I suppose that a few extra flags (FF_PERIODIC_EMULATED etc.) defined in
> "uapi/linux/input.h" should suffice.
The only problem is that we probably want to maintain backward
compatibility so that older apps still see 'PERIODIC' (even though it is
emulated).
--
#define FF_RUMBLE 0x50
#define FF_PERIODIC 0x51
#define FF_CONSTANT 0x52
#define FF_SPRING 0x53
#define FF_FRICTION 0x54
#define FF_DAMPER 0x55
#define FF_INERTIA 0x56
#define FF_RAMP 0x57
--
Do we therefore have to list extra items in our capabilities?
--
static const signed short lg4ff_wheel_effects[] = {
FF_CONSTANT,
FF_PERIODIC,
FF_PERIODIC_NOT_EMULATED,
FF_AUTOCENTER,
-1
};
--
Simon
^ permalink raw reply
* Re: [PATCH v4 01/24] input: Add ff-memless-next module
From: simon @ 2014-05-20 23:30 UTC (permalink / raw)
To: Roland Bosa
Cc: simon, "Michal Malý", Dmitry Torokhov, linux-input,
linux-kernel, jkosina, elias.vds, anssi.hannula
In-Reply-To: <537BD184.9090608@logitech.com>
> IMO, there are two types of games. The "arcade" ones, which have a set
> of 'canned' force effects, which play whenever an event happens in game.
> And the "simulation" ones, which base the game on a physics engine. The
> latter can redirect some variables of their engine to the input layer
> and typically drive a constant force and maybe a spring/damper too.
>
> For the first type, you might want to keep a centering spring active all
> the time. Maybe you want to tweak the gain in the game settings. Maybe
> there's a gain for the centering and one for the special effects. The
> canned effects are mostly periodics with varying waveform, duration,
> amplitude and envelope. That's about it.
Sounds like these are the effect files produced by FEdit tool (from MS
DirectX SDK), and/or played back by pressing buttons when configuring the
Logitech driver on Windows ('wooden bridge', etc)...
Do you know if there is a mechanism for playing these under Linux?
Under Windows do games just send a 'file' the DirectX driver, or do they
parse them into individual effects to send?
If format is known/public it shouldn't be hard to write a userland client
to play them back. If this needs to be supported in the kernel that would
be more problematic.
> For the second type, you don't want a centering spring. You typically
> will drive a constant force effect with the engine, with some sprinkled
> damping and maybe a slight spring here and there.
>
> I would personally put more weight and effort to get the second type
> properly implemented. The players of those games demand more realism and
> they need the subtle force changes to drive better than the competition.
I would agree, these are probably more higher 'priority' but I think that
the work Elias and Michal have done already implements these fairly well.
I assume that most AAA games, would implement these through some middle
layer. I think that is probably via Steam using SDL2 haptic API, we have
been testing against SDL2's 'testhaptic'.
Do you see another path (which we should be supporting/testing)?
> That means having a FF driver that can deal with many force updates per
> second without choking and a consistent, reproducible force output at
> the device, maybe even similar across varying devices. This translates
> into a decoupled design for accepting force updates and sending USB
> updates, as well as a device-specific layer to "calibrate" and "unify"
> the force responses across different models.
There was some discussion about rate limiting the USB packets to the
wheel, and how to deal if app updates too quickly. Is there an upper limit
for the wheel itself, or is it just the USB 'pipe' which is the limiting
factor?
Simon
^ permalink raw reply
* Re: [PATCH v6 0/7] mfd: AXP20x: Add support for AXP202 and AXP209
From: Mark Brown @ 2014-05-20 22:23 UTC (permalink / raw)
To: Carlo Caione
Cc: linux-arm-kernel-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r,
linux-sunxi-/JYPxA39Uh5TLH3MbocFFw,
maxime.ripard-wi1+55ScJUtKEb57/3fJTNBPR1lH4CV8,
hdegoede-H+wXaHxf7aLQT0dZR+AlfA, emilio-0Z03zUJReD5OxF6Tv1QG9Q,
wens-jdAy2FN1RRM, sameo-VuQAYsv1563Yd54FQh9/CA,
dmitry.torokhov-Re5JQEeQqe8AvxtiuMwx3w,
linux-input-u79uwXL29TY76Z2rM5mHXA,
linux-doc-u79uwXL29TY76Z2rM5mHXA,
lgirdwood-Re5JQEeQqe8AvxtiuMwx3w,
lee.jones-QSEj5FYQhm4dnm+yROfE0A,
boris.brezillon-wi1+55ScJUtKEb57/3fJTNBPR1lH4CV8
In-Reply-To: <1400528868-5971-1-git-send-email-carlo-KA+7E9HrN00dnm+yROfE0A@public.gmane.org>
[-- Attachment #1: Type: text/plain, Size: 1109 bytes --]
On Mon, May 19, 2014 at 09:47:41PM +0200, Carlo Caione wrote:
> This set of patches introduces the core driver and support for two different
> subsystems:
> - Regulators
> .../ABI/testing/sysfs-driver-input-axp-pek | 11 +
> Documentation/devicetree/bindings/mfd/axp20x.txt | 93 +++++++
> .../devicetree/bindings/vendor-prefixes.txt | 1 +
> arch/arm/configs/multi_v7_defconfig | 3 +
> arch/arm/configs/sunxi_defconfig | 4 +
> drivers/input/misc/Kconfig | 11 +
> drivers/input/misc/Makefile | 1 +
> drivers/input/misc/axp20x-pek.c | 281 +++++++++++++++++++++
> drivers/mfd/Kconfig | 12 +
> drivers/mfd/Makefile | 1 +
> drivers/mfd/axp20x.c | 258 +++++++++++++++++++
> include/linux/mfd/axp20x.h | 180 +++++++++++++
> 12 files changed, 856 insertions(+)
The regulator changes don't appear to be showing up in the diffstat or
obviously in the series?
[-- Attachment #2: Digital signature --]
[-- Type: application/pgp-signature, Size: 836 bytes --]
^ permalink raw reply
* Re: [PATCH v4 01/24] input: Add ff-memless-next module
From: Roland Bosa @ 2014-05-20 22:04 UTC (permalink / raw)
To: simon
Cc: Michal Malý, Dmitry Torokhov, linux-input, linux-kernel,
jkosina, elias.vds, anssi.hannula
In-Reply-To: <8c45868c3cd4333d1098bdbc0fa83a2e.squirrel@mungewell.org>
On 05/20/2014 12:39 PM, simon@mungewell.org wrote:
> hopefully bring Linux into scope for force-feedback of AAA game quality.
^ That's my objective too.
> Mostly this has come from a small group of people reverse engineering the
> Logitech wheels, which leads to the 'tailor-made' situation. But we'd like
> the systems/interfaces to be device agnostic.
I'm sure we can consolidate the support into fewer files.
> As you how you can help...? As Michal said having a contact at Logitech to
> whom we can ask technical questions (off list) would probably be the
> greatest help. This would clear up any assumptions we have made, and help
> with decisions going forward.
Please don't hesitate to contact me. ;-)
> It may also be the case that Logitech is working with studios/game
> designers to improve controller performance. If any information can be
> feed 'forward' to improve the Linux driver, that would be useful too.
IMO, there are two types of games. The "arcade" ones, which have a set
of 'canned' force effects, which play whenever an event happens in game.
And the "simulation" ones, which base the game on a physics engine. The
latter can redirect some variables of their engine to the input layer
and typically drive a constant force and maybe a spring/damper too.
For the first type, you might want to keep a centering spring active all
the time. Maybe you want to tweak the gain in the game settings. Maybe
there's a gain for the centering and one for the special effects. The
canned effects are mostly periodics with varying waveform, duration,
amplitude and envelope. That's about it.
For the second type, you don't want a centering spring. You typically
will drive a constant force effect with the engine, with some sprinkled
damping and maybe a slight spring here and there.
I would personally put more weight and effort to get the second type
properly implemented. The players of those games demand more realism and
they need the subtle force changes to drive better than the competition.
That means having a FF driver that can deal with many force updates per
second without choking and a consistent, reproducible force output at
the device, maybe even similar across varying devices. This translates
into a decoupled design for accepting force updates and sending USB
updates, as well as a device-specific layer to "calibrate" and "unify"
the force responses across different models.
Does this make sense?
thanks
roland
^ permalink raw reply
* Re: [PATCH v4 01/24] input: Add ff-memless-next module
From: Roland Bosa @ 2014-05-20 21:38 UTC (permalink / raw)
To: Michal Malý
Cc: Dmitry Torokhov, linux-input, linux-kernel, jkosina, elias.vds,
anssi.hannula, simon
In-Reply-To: <10859911.6zyzadbfH9@sigyn>
On 05/20/2014 12:00 PM, Michal Malý wrote:
> Hi,
>
> "ff-memless-next" was designed with behavior of Logitech devices in mind,
> however it was always meant as a general replacement for the current "ff-
> memless". After some followup discussion it's unlikely that it will be
> mainlined in its current form. See the discussion here
> "http://www.spinics.net/lists/linux-input/msg31426.html" for more details.
>
> We would however really appreciate some information regarding Logitech devices
> specifically. Although we have reverse engineered most of things, I believe
> there are still areas we're not entirely clear about. I realize that you'd
> probably have to take it up with the legal deparment but if someone at
> Logitech could at least take a look at what we've found so far at fill in the
> blanks it'd be most helpful.
I'm your guy, then. Please send any questions my way and I'll dig out
the information you need - with the lawyer's blessings, if need be.
> Please note that we found numerous bugs and DirectInput specs violations in
> the Windows driver which might have impacted our understading of how the
> driver works. "ff-memless-next" and "lg4ff" tries to fix or work around these. A
> link to out-of-tree update to lg4ff which takes full advantage of "ff-memless-
> next" is also provided in this thread.
lg4ff is mostly wheels, from what I saw. We should be able to fold in
the G940 (Flight System) as well as other joysticks into the same
driver. The underlying model driving the forces of our devices is
essentially the same, there are just slight improvements made over the
years to accommodate higher resolutions and more powerful micro processors.
Each device has a unique number (say 2 or 4) of force 'slots' per axis,
which is running a force calculation in firmware. Typically, one of
these slots is allocated by the host driver for a constant force, that's
streamed to the device (and comprises all constant and periodic forces
sent by the 'game' - that's the combined type of your code, as far as I
can tell). The other slot may be used for position-based effects
(springs, centering spring) as well as velocity-based effects (dampers,
friction) - that's the un-combinable type. There's a healthy amount of
code in the Windows driver that you would call 'quirks' which deals with
deciding how to allocate multiple springs and dampers to a single slot.
Sometimes, even the springs and dampers are being streamed in via the
constants force, but that requires (as you pointed out earlier) a fast
update rate and some "smartness" (I'm getting in hot territory with the
lawyers now - let me stop).
One of the key features of the design is the decoupling of the USB
updates from the force feedback IOCTL's from the 'game'. I don't think
this is currently the case with today's drivers. I was able to send
force updates to a gamepad faster than the USB update rate, which led to
some lost packets which in turn left the device in a inconsistent state
- the motors were still rumbling although they should have stopped. If
the 'ff-memless-next' driver offers this decoupling, it is a step in the
right direction, IMO.
I will try to apply the patch mentioned in this thread and see where it
leads me...
Thanks
roland
--
To unsubscribe from this list: send the line "unsubscribe linux-input" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply
* Re: [PATCH v4 01/24] input: Add ff-memless-next module
From: Elias Vanderstuyft @ 2014-05-20 21:26 UTC (permalink / raw)
To: Dmitry Torokhov
Cc: Simon Wood, linux-input, linux-kernel, Jiri Kosina, Anssi Hannula,
Michal Malý
In-Reply-To: <6970969.ej8OFzkVkO@sigyn>
On Tue, May 20, 2014 at 10:58 PM, Michal Malý
<madcatxster@devoid-pointer.net> wrote:
> On Tuesday 20 of May 2014 16:16:12 simon@mungewell.org wrote:
>> Regarding the question of emulated vs. real effects, can we extend the API
>> so that applications can know which effects are really supported, and
>> enable/disable emulation somehow?
>
> I suppose that a few extra flags (FF_PERIODIC_EMULATED etc.) defined in
> "uapi/linux/input.h" should suffice.
@Dmitry:
Now that we're talking about API changes, I would like to propose some
additional things in the Linux FF API:
- Possibility to *get* FF state variables, such as the value of the
current GAIN, and the current AUTOCENTER:
At the moment, only *setting* is possible.
This poses a problem when implementing proper AUTOCENTER state
recovery (upon closing a Windows program) in Wine, because the initial
AUTOCENTER state was unknown.
The same applies for GAIN.
- Introduce multiple types of GAIN, apart from the current global
GAIN, e.g. GAIN_CONSTANT and GAIN_DAMPER:
This is mainly on request of some users, especially Logitech users: on
Windows Logitech additionally supports to set the global Damper and
Spring gain.
Maybe it would be nicer to create a global gain for every supported
Linux FF effect?
Thanks,
Elias
^ permalink raw reply
* Re: [PATCH 4/6] input: cyapa: enable/disable trackpad device based on LID state
From: Rafael J. Wysocki @ 2014-05-20 21:07 UTC (permalink / raw)
To: Dmitry Torokhov, Alan Stern
Cc: Dudley Du, Benson Leung, Daniel Kurtz, David Solda,
linux-input@vger.kernel.org, linux-kernel@vger.kernel.org
In-Reply-To: <20140520152551.GB9444@core.coreip.homeip.net>
On Tuesday, May 20, 2014 08:25:51 AM Dmitry Torokhov wrote:
> On Tue, May 20, 2014 at 02:40:12PM +0200, Rafael J. Wysocki wrote:
> > On Monday, May 19, 2014 08:43:02 PM Dmitry Torokhov wrote:
> > > Hi Dudley,
> > >
> > > On Wed, Apr 16, 2014 at 08:39:34AM +0000, Dudley Du wrote:
> > > > Rely on EV_SW and SW_LID bits to identify a LID device, and hook
> > > > up our filter to listen for SW_LID events to enable/disable touchpad when
> > > > LID is open/closed.
> > > > TEST=test on Chomebooks.
> > >
> > > This is a policy and it does not belong in the kernel. Please work with
> > > Rafael to establish generic interface to put devices into low power mode
> > > (like accelerating runtime PM idle timeout)
> >
> > I'm not really sure what you mean here, care to be more specific?
>
> I think we chatted about this before - we need a uniform interface for
> userspace to put devices into low power mode on demand.
I'm still not sure what you mean exactly.
If you mean an interface for user space to *force* transitions into low-power
states, we can't have it, because user space doesn't know when it is safe to
do that. The /sys/devices/.../power/control interface is the best we can
give to user space to this end.
Adding Alan Stern to the recipient list, because he was inovlved in discussions
about that.
But if you mean an interface for user space to poke at pm_runtime_idle() to
possibly trigger a runtime suspend, that we can add I think. Alan?
> As implementation detail I thought we could require runtime PM for that and
> simply pretend that the PM timeout expired early when userspace invokes
> that API.
That'd be overly complicated IMHO. Calling pm_runtime_idle() should suffice.
> >
> > > and use it when userspace detects that lid is closed.
> >
> > I guess we get an event then, don't we?
>
> Right, userspace gets EV_SW/SW_LID input event and needs to react. In
> this particular case the desire is to power down touchpad (since it is
> unaccessible). I am not sure why system suspend (which I expect happen
> in reaction to lid closing) is not enough, but that's question for
> Dudley.
OK
Rafael
^ permalink raw reply
* Re: [PATCH v4 01/24] input: Add ff-memless-next module
From: Michal Malý @ 2014-05-20 20:58 UTC (permalink / raw)
To: simon
Cc: Dmitry Torokhov, linux-input, linux-kernel, jkosina, elias.vds,
anssi.hannula
In-Reply-To: <865ad8dbc7ae0d13c045bd2a85cff2e2.squirrel@mungewell.org>
On Tuesday 20 of May 2014 16:16:12 simon@mungewell.org wrote:
> > To bring this to a conclusion we could go from, would this be an
> > acceptable
> > solution?
> >
> > - Have the HW-specific driver talk directly to ff-core and reimplement
> > upload(),
> > play(), etc.
> > - Rewrite "ff-memless-next" so that it is not a self-contained module but
> > a
> > library of functions.
> >
> > - Have the driver either:
> > - Upload an effect to a device directly if the device can fully manage
> >
> > the
> > effect by itself.
> >
> > - Use provided timing functions to know when an effect should start,
> >
> > stop,
> > restart etc...
> >
> > - Use provided timing AND processing functions to combine effects that
> >
> > can be
> > combined into one, calculate periodic waveforms etc?
> >
> > I have no problem with throwing my current approach away but before I
> > start working on a new one I'd like to know which way to go...
>
> Hi all,
> If the driver itself (hid-logitech, via hid-lg4ff for example) is more
> involved in the creation/timing/management of the effects, does this mean
> that we end up with code duplicated in lots of places?
Hopefully not. I tried to work out some scheme how this would work in my head
today and the code duplication among other drivers should be minimal.
Basically an equivalent of "play_effects()" - implemented in the HW-specific
driver - would by called as needed. Such a function would then use provided
helper functions to process combinable effects and check if any uncombinable
effects changed state. A proper rate limiting will fit into this scheme nicely
as well.
The biggest advantage of this design is that the HW-specific driver will be
able to either handle an effect all by itself or use the provided "helper"
infrastructure.
In retrospect I've got agree with Dmitry that the current handling of
(semi)memless devices is not very flexible and therefore potentially
problematic. It'll require some extra work but we don't have to invent
anything entirely new here, we can just rearrange what we've already done in
MLNX and package it into a library.
> Also, does this mean that the 'old' ff-memless system would remain in
> kernel? If not, who will reworking each driver?
I suppose that the maintainers would want us to move all FF drivers to this
architecture. If we get it right, it shouldn't require a terrible amount of
work to port the other drivers.
> Regarding the question of emulated vs. real effects, can we extend the API
> so that applications can know which effects are really supported, and
> enable/disable emulation somehow?
I suppose that a few extra flags (FF_PERIODIC_EMULATED etc.) defined in
"uapi/linux/input.h" should suffice.
Michal
^ permalink raw reply
* Re: [PATCH v4 01/24] input: Add ff-memless-next module
From: simon @ 2014-05-20 20:16 UTC (permalink / raw)
To: "Michal Malý"
Cc: Dmitry Torokhov, linux-input, linux-kernel, jkosina, elias.vds,
anssi.hannula, simon
In-Reply-To: <2965006.XKYHWj9YzJ@sigyn>
> To bring this to a conclusion we could go from, would this be an
> acceptable
> solution?
>
> - Have the HW-specific driver talk directly to ff-core and reimplement
> upload(),
> play(), etc.
> - Rewrite "ff-memless-next" so that it is not a self-contained module but
> a
> library of functions.
> - Have the driver either:
> - Upload an effect to a device directly if the device can fully manage
> the
> effect by itself.
> - Use provided timing functions to know when an effect should start,
> stop,
> restart etc...
> - Use provided timing AND processing functions to combine effects that
> can be
> combined into one, calculate periodic waveforms etc?
>
> I have no problem with throwing my current approach away but before I
> start working on a new one I'd like to know which way to go...
Hi all,
If the driver itself (hid-logitech, via hid-lg4ff for example) is more
involved in the creation/timing/management of the effects, does this mean
that we end up with code duplicated in lots of places?
Also, does this mean that the 'old' ff-memless system would remain in
kernel? If not, who will reworking each driver?
Regarding the question of emulated vs. real effects, can we extend the API
so that applications can know which effects are really supported, and
enable/disable emulation somehow?
Apologies for asking some many questions, without answering anything...
Simon
^ permalink raw reply
* Re: [PATCH v2] input: xpad: Prevent corruption of urb request.
From: Sarah Bessmer @ 2014-05-20 20:09 UTC (permalink / raw)
To: dmitry.torokhov; +Cc: linux-input
In-Reply-To: <20140516021157.45c281f9@willow>
Is the patch acceptable, or do I need to make any major changes? If additional justification is required,
I can post kernel log files with the patch not applied, and a test program to cause a kernel panic.
On Fri, 16 May 2014 02:11:57 -0700
Sarah Bessmer <aotos@fastmail.fm> wrote:
> The xpad_send_led_command() and xpad_play_effect() functions submit urb requests, but do not
> wait for the previous urb request to complete before using the same resources to
> submit a new request. This can lead to unpredictable undesirable effects, including
> memory corruption and dereferencing of NULL pointers(and needless to say, kernel
> panics).
>
> Fix the issue by introducing a busy flag set on submission of the urb request, and
> cleared on urb request completion. If this flag is set while in xpad_send_led_command()
> or xpad_play_effect(), the led/rumble packet data is buffered, and will be sent from
> the urb request completion routine when the current urb request finishes.
>
>
> Patch tested with rumble against a Logitech F510 and an X-Box v1 pad.
>
>
> Signed-off-by: Sarah Bessmer <aotos@fastmail.fm>
> ---
> v2:
> -fixed introduced race in xpad_irq_out()
>
> --- linux-3.14.4/drivers/input/joystick/xpad.c.orig 2014-05-15 13:13:39.000000000 -0700
> +++ linux-3.14.4/drivers/input/joystick/xpad.c 2014-05-16 02:00:56.000000000 -0700
> @@ -78,6 +78,7 @@
> #include <linux/stat.h>
> #include <linux/module.h>
> #include <linux/usb/input.h>
> +#include <linux/spinlock.h>
>
> #define DRIVER_AUTHOR "Marko Friedemann <mfr@bmx-chemnitz.de>"
> #define DRIVER_DESC "X-Box pad driver"
> @@ -282,7 +283,15 @@ struct usb_xpad {
> struct urb *irq_out; /* urb for interrupt out report */
> unsigned char *odata; /* output data */
> dma_addr_t odata_dma;
> - struct mutex odata_mutex;
> + int odata_busy;
> +
> + spinlock_t pend_lock;
> +
> + unsigned pend_rum;
> + unsigned char rum_data[XPAD_PKT_LEN];
> +
> + unsigned pend_led;
> + unsigned char led_data[XPAD_PKT_LEN];
> #endif
>
> #if defined(CONFIG_JOYSTICK_XPAD_LEDS)
> @@ -541,12 +550,37 @@ static void xpad_irq_out(struct urb *urb
> struct usb_xpad *xpad = urb->context;
> struct device *dev = &xpad->intf->dev;
> int retval, status;
> + unsigned long flags;
>
> status = urb->status;
>
> switch (status) {
> case 0:
> /* success */
> + spin_lock_irqsave(&xpad->pend_lock, flags);
> + xpad->irq_out->transfer_buffer_length = 0;
> +
> + if (xpad->pend_rum != 0) {
> + memcpy(xpad->odata, xpad->rum_data, xpad->pend_rum);
> + xpad->irq_out->transfer_buffer_length = xpad->pend_rum;
> + xpad->pend_rum = 0;
> + } else if (xpad->pend_led != 0) {
> + memcpy(xpad->odata, xpad->led_data, xpad->pend_led);
> + xpad->irq_out->transfer_buffer_length = xpad->pend_led;
> + xpad->pend_led = 0;
> + }
> +
> + if (xpad->irq_out->transfer_buffer_length != 0) {
> + spin_unlock_irqrestore(&xpad->pend_lock, flags);
> + if (usb_submit_urb(xpad->irq_out, GFP_ATOMIC) != 0) {
> + spin_lock_irqsave(&xpad->pend_lock, flags);
> + xpad->odata_busy = 0;
> + spin_unlock_irqrestore(&xpad->pend_lock, flags);
> + }
> + } else {
> + xpad->odata_busy = 0;
> + spin_unlock_irqrestore(&xpad->pend_lock, flags);
> + }
> return;
>
> case -ECONNRESET:
> @@ -555,19 +589,27 @@ static void xpad_irq_out(struct urb *urb
> /* this urb is terminated, clean up */
> dev_dbg(dev, "%s - urb shutting down with status: %d\n",
> __func__, status);
> +
> + spin_lock_irqsave(&xpad->pend_lock, flags);
> + xpad->odata_busy = 0;
> + spin_unlock_irqrestore(&xpad->pend_lock, flags);
> return;
>
> default:
> dev_dbg(dev, "%s - nonzero urb status received: %d\n",
> __func__, status);
> - goto exit;
> - }
>
> -exit:
> - retval = usb_submit_urb(urb, GFP_ATOMIC);
> - if (retval)
> - dev_err(dev, "%s - usb_submit_urb failed with result %d\n",
> - __func__, retval);
> + retval = usb_submit_urb(urb, GFP_ATOMIC);
> + if (retval) {
> + dev_err(dev, "%s - usb_submit_urb failed with result %d\n",
> + __func__, retval);
> + spin_lock_irqsave(&xpad->pend_lock, flags);
> + xpad->odata_busy = 0;
> + spin_unlock_irqrestore(&xpad->pend_lock, flags);
> + }
> +
> + return;
> + }
> }
>
> static int xpad_init_output(struct usb_interface *intf, struct usb_xpad *xpad)
> @@ -585,7 +627,12 @@ static int xpad_init_output(struct usb_i
> goto fail1;
> }
>
> - mutex_init(&xpad->odata_mutex);
> + xpad->odata_busy = 0;
> +
> + spin_lock_init(&xpad->pend_lock);
> +
> + xpad->pend_rum = 0;
> + xpad->pend_led = 0;
>
> xpad->irq_out = usb_alloc_urb(0, GFP_KERNEL);
> if (!xpad->irq_out) {
> @@ -628,61 +675,91 @@ static void xpad_stop_output(struct usb_
> #endif
>
> #ifdef CONFIG_JOYSTICK_XPAD_FF
> +static int xpad_make_rum_data(struct usb_xpad *xpad, __u16 strong, __u16 weak)
> +{
> + switch (xpad->xtype) {
> +
> + case XTYPE_XBOX:
> + xpad->rum_data[0] = 0x00;
> + xpad->rum_data[1] = 0x06;
> + xpad->rum_data[2] = 0x00;
> + xpad->rum_data[3] = strong / 256; /* left actuator */
> + xpad->rum_data[4] = 0x00;
> + xpad->rum_data[5] = weak / 256; /* right actuator */
> + xpad->pend_rum = 6;
> + return 0;
> +
> +
> + case XTYPE_XBOX360:
> + xpad->rum_data[0] = 0x00;
> + xpad->rum_data[1] = 0x08;
> + xpad->rum_data[2] = 0x00;
> + xpad->rum_data[3] = strong / 256; /* left actuator? */
> + xpad->rum_data[4] = weak / 256; /* right actuator? */
> + xpad->rum_data[5] = 0x00;
> + xpad->rum_data[6] = 0x00;
> + xpad->rum_data[7] = 0x00;
> + xpad->pend_rum = 8;
> + return 0;
> +
> + case XTYPE_XBOX360W:
> + xpad->rum_data[0] = 0x00;
> + xpad->rum_data[1] = 0x01;
> + xpad->rum_data[2] = 0x0F;
> + xpad->rum_data[3] = 0xC0;
> + xpad->rum_data[4] = 0x00;
> + xpad->rum_data[5] = strong / 256;
> + xpad->rum_data[6] = weak / 256;
> + xpad->rum_data[7] = 0x00;
> + xpad->rum_data[8] = 0x00;
> + xpad->rum_data[9] = 0x00;
> + xpad->rum_data[10] = 0x00;
> + xpad->rum_data[11] = 0x00;
> + xpad->pend_rum = 12;
> + return 0;
> +
> + }
> + return -1;
> +}
> +
> static int xpad_play_effect(struct input_dev *dev, void *data, struct ff_effect *effect)
> {
> struct usb_xpad *xpad = input_get_drvdata(dev);
>
> if (effect->type == FF_RUMBLE) {
> - __u16 strong = effect->u.rumble.strong_magnitude;
> - __u16 weak = effect->u.rumble.weak_magnitude;
> -
> - switch (xpad->xtype) {
> + unsigned long flags;
> + int mrdrv;
>
> - case XTYPE_XBOX:
> - xpad->odata[0] = 0x00;
> - xpad->odata[1] = 0x06;
> - xpad->odata[2] = 0x00;
> - xpad->odata[3] = strong / 256; /* left actuator */
> - xpad->odata[4] = 0x00;
> - xpad->odata[5] = weak / 256; /* right actuator */
> - xpad->irq_out->transfer_buffer_length = 6;
> -
> - return usb_submit_urb(xpad->irq_out, GFP_ATOMIC);
> -
> - case XTYPE_XBOX360:
> - xpad->odata[0] = 0x00;
> - xpad->odata[1] = 0x08;
> - xpad->odata[2] = 0x00;
> - xpad->odata[3] = strong / 256; /* left actuator? */
> - xpad->odata[4] = weak / 256; /* right actuator? */
> - xpad->odata[5] = 0x00;
> - xpad->odata[6] = 0x00;
> - xpad->odata[7] = 0x00;
> - xpad->irq_out->transfer_buffer_length = 8;
> -
> - return usb_submit_urb(xpad->irq_out, GFP_ATOMIC);
> -
> - case XTYPE_XBOX360W:
> - xpad->odata[0] = 0x00;
> - xpad->odata[1] = 0x01;
> - xpad->odata[2] = 0x0F;
> - xpad->odata[3] = 0xC0;
> - xpad->odata[4] = 0x00;
> - xpad->odata[5] = strong / 256;
> - xpad->odata[6] = weak / 256;
> - xpad->odata[7] = 0x00;
> - xpad->odata[8] = 0x00;
> - xpad->odata[9] = 0x00;
> - xpad->odata[10] = 0x00;
> - xpad->odata[11] = 0x00;
> - xpad->irq_out->transfer_buffer_length = 12;
> -
> - return usb_submit_urb(xpad->irq_out, GFP_ATOMIC);
> + spin_lock_irqsave(&xpad->pend_lock, flags);
> + mrdrv = xpad_make_rum_data(xpad, effect->u.rumble.strong_magnitude,
> + effect->u.rumble.weak_magnitude);
> +
> + if (mrdrv == 0 && !xpad->odata_busy) {
> + memcpy(xpad->odata, xpad->rum_data, xpad->pend_rum);
> + xpad->irq_out->transfer_buffer_length = xpad->pend_rum;
> + xpad->pend_rum = 0;
> + xpad->odata_busy = 1;
> + spin_unlock_irqrestore(&xpad->pend_lock, flags);
> +
> + if (usb_submit_urb(xpad->irq_out, GFP_ATOMIC) != 0) {
> + spin_lock_irqsave(&xpad->pend_lock, flags);
> + xpad->odata_busy = 0;
> + spin_unlock_irqrestore(&xpad->pend_lock, flags);
> + }
> + } else {
> + spin_unlock_irqrestore(&xpad->pend_lock, flags);
> +
> + if (mrdrv == 0) {
> + dev_dbg(&xpad->dev->dev,
> + "%s - rumble while urb busy\n", __func__);
> + }
> + }
>
> - default:
> + if (mrdrv != 0) {
> dev_dbg(&xpad->dev->dev,
> "%s - rumble command sent to unsupported xpad type: %d\n",
> __func__, xpad->xtype);
> +
> return -1;
> }
> }
> @@ -716,13 +793,30 @@ struct xpad_led {
> static void xpad_send_led_command(struct usb_xpad *xpad, int command)
> {
> if (command >= 0 && command < 14) {
> - mutex_lock(&xpad->odata_mutex);
> - xpad->odata[0] = 0x01;
> - xpad->odata[1] = 0x03;
> - xpad->odata[2] = command;
> - xpad->irq_out->transfer_buffer_length = 3;
> - usb_submit_urb(xpad->irq_out, GFP_KERNEL);
> - mutex_unlock(&xpad->odata_mutex);
> + unsigned long flags;
> +
> + spin_lock_irqsave(&xpad->pend_lock, flags);
> + xpad->led_data[0] = 0x01;
> + xpad->led_data[1] = 0x03;
> + xpad->led_data[2] = command;
> + xpad->pend_led = 3;
> +
> + if (!xpad->odata_busy) {
> + memcpy(xpad->odata, xpad->led_data, xpad->pend_led);
> + xpad->irq_out->transfer_buffer_length = xpad->pend_led;
> + xpad->pend_led = 0;
> + xpad->odata_busy = 1;
> + spin_unlock_irqrestore(&xpad->pend_lock, flags);
> +
> + if (usb_submit_urb(xpad->irq_out, GFP_KERNEL) != 0) {
> + spin_lock_irqsave(&xpad->pend_lock, flags);
> + xpad->odata_busy = 0;
> + spin_unlock_irqrestore(&xpad->pend_lock, flags);
> + }
> + } else {
> + spin_unlock_irqrestore(&xpad->pend_lock, flags);
> + dev_dbg(&xpad->dev->dev, "%s - led while urb busy\n", __func__);
> + }
> }
> }
^ permalink raw reply
* Re: [PATCH v4 01/24] input: Add ff-memless-next module
From: simon @ 2014-05-20 19:39 UTC (permalink / raw)
To: Roland Bosa
Cc: "Michal Malý", Dmitry Torokhov, linux-input,
linux-kernel, jkosina, elias.vds, anssi.hannula, simon
In-Reply-To: <537B9FAE.9070602@logitech.com>
> Allow me to introduce myself. I'm Roland Bosa and I work for Logitech,
> more specifically the gaming group. I have been tasked to look into
> gaming device support for Linux and I just started following this list
> and studying the kernel code related to the Logitech Force Feedback
> devices. The 'ff-memless-next' module sounds tailor-made for our
> devices. Please let me know how I can help with its development.
Hello Roland,
Let me echo Michal's welcome.
As you will see from the 'ff-memless-next' driver we are looking to extend
force-feedback support to cover more than just ConstantForce support, and
hopefully bring Linux into scope for force-feedback of AAA game quality.
Mostly this has come from a small group of people reverse engineering the
Logitech wheels, which leads to the 'tailor-made' situation. But we'd like
the systems/interfaces to be device agnostic.
As you how you can help...? As Michal said having a contact at Logitech to
whom we can ask technical questions (off list) would probably be the
greatest help. This would clear up any assumptions we have made, and help
with decisions going forward.
It may also be the case that Logitech is working with studios/game
designers to improve controller performance. If any information can be
feed 'forward' to improve the Linux driver, that would be useful too.
Many thanks,
Simon Wood.
^ permalink raw reply
* Re: [PATCH v3] HID: quirk for Saitek RAT7 and MMO7 mices' mode button
From: Jiri Kosina @ 2014-05-20 19:30 UTC (permalink / raw)
To: Harald Brinkmann; +Cc: Benjamin Tissoires, linux-input, linux-kernel
In-Reply-To: <537B9EB0.60603@braincalibration.de>
On Tue, 20 May 2014, Harald Brinkmann wrote:
> Some saitek mice implement a tristate button (for switching button
> mappings in the original driver) by keeping one of three (non-physical)
> buttons constantly pressed.
> This breaks X and probably other userspace software.
> This patch implements a quirk for the R.A.T.7 and M.M.O.7, tracking
> the mode and generating presses of a single button if it changes.
> Also the missing release event is generated instantly.
>
> Signed-off-by: Harald Brinkmann <hbrinkmann@braincalibration.de>
Applied, thanks.
--
Jiri Kosina
SUSE Labs
^ permalink raw reply
* Re: [PATCH v4 01/24] input: Add ff-memless-next module
From: Michal Malý @ 2014-05-20 19:00 UTC (permalink / raw)
To: Roland Bosa
Cc: Dmitry Torokhov, linux-input, linux-kernel, jkosina, elias.vds,
anssi.hannula, simon
In-Reply-To: <537B9FAE.9070602@logitech.com>
On Tuesday 20 of May 2014 11:32:14 Roland Bosa wrote:
> On 05/20/2014 02:27 AM, Michal Malý wrote:
> > On Wednesday 14 of May 2014 11:05:58 Dmitry Torokhov wrote:
> >> On Wed, May 14, 2014 at 10:35:25AM +0200, Michal Malý wrote:
> >>> Hi Dmitry,
> >>>
> >>> thank you for reviewing this.
> >>>
> >>> On Tuesday 13 of May 2014 23:38:06 Dmitry Torokhov wrote:
> >>>> On Sat, Apr 26, 2014 at 05:02:00PM +0200, Michal Malý wrote:
> >>>>> +
> >>>>> +/** DEFINITION OF TERMS
> >>>>> + *
> >>>>> + * Combined effect - An effect whose force is a superposition of
> >>>>> forces
> >>>>> + * generated by all effects that can be added
> >>>>> together.
> >>>>> + * Only one combined effect can be playing at a
> >>>>> time.
> >>>>> + * Effects that can be added together to create a
> >>>>> combined + * effect are FF_CONSTANT, FF_PERIODIC and
> >>>>> FF_RAMP. + * Uncombinable effect - An effect that cannot be combined
> >>>>> with
> >>>>> another effect. + * All conditional effects -
> >>>>> FF_DAMPER, FF_FRICTION, + * FF_INERTIA and
> >>>>> FF_SPRING are uncombinable. + * Number of
> >>>>> uncombinable effects playing simultaneously + *
> >>>>> depends on the capabilities of the hardware. + * Rumble effect - An
> >>>>> effect generated by device's rumble motors instead of + *
> >>>>> force feedback actuators.
> >>>>> + *
> >>>>> + *
> >>>>> + * HANDLING OF UNCOMBINABLE EFFECTS
> >>>>> + *
> >>>>> + * Uncombinable effects cannot be combined together into just one
> >>>>> effect,
> >>>>> at + * least not in a clear and obvious manner. Therefore these
> >>>>> effects
> >>>>> have to + * be handled individually by ff-memless-next. Handling of
> >>>>> these
> >>>>> effects is + * left entirely to the hardware-specific driver,
> >>>>> ff-memless-next merely + * passes these effects to the
> >>>>> hardware-specific
> >>>>> driver at appropriate time. + * ff-memless-next provides the UPLOAD
> >>>>> command to notify the hardware-specific + * driver that the userspace
> >>>>> is
> >>>>> about to request playback of an uncombinable + * effect. The
> >>>>> hardware-specific driver shall take all steps needed to make + * the
> >>>>> device ready to play the effect when it receives the UPLOAD command. +
> >>>>> *
> >>>>> The actual playback shall commence when START_UNCOMB command is
> >>>>> received.
> >>>>> + * Opposite to the UPLOAD command is the ERASE command which tells +
> >>>>> *
> >>>>> the hardware-specific driver that the playback has finished and that +
> >>>>> *
> >>>>> the effect will not be restarted. STOP_UNCOMB command tells
> >>>>> + * the hardware-specific driver that the playback shall stop but the
> >>>>> device + * shall still be ready to resume the playback immediately.
> >>>>> + *
> >>>>> + * In case it is not possible to make the device ready to play an
> >>>>> uncombinable + * effect (all hardware effect slots are occupied), the
> >>>>> hardware-specific + * driver may return an error when it receives an
> >>>>> UPLOAD command. If the
> >>>>
> >>>> This part concerns me. It seems to me that devices supporting
> >>>> "uncombinable" effects are in fact not memoryless devices and we should
> >>>> not be introducing this term here. If the goal is to work around
> >>>> limited
> >>>> number of effect slots in the devices by combining certain effects then
> >>>> it needs to be done at ff-core level as it will be potentially useful
> >>>> for all devices.
> >>>
> >>> Force generated by a conditional effect (referred to as "uncombinable"
> >>> within ff-memless-next to make the distinction clear) depends on a
> >>> position of the device. For instance the more a device is deflected from
> >>> a neutral position the greater force FF_SPRING generates. A truly
> >>> memoryless device would have to report its position to the driver, have
> >>> it calculate the appropriate force and send it back to the device. IMHO
> >>> such a loop would require a very high USB polling rate to play
> >>> conditional effects with acceptable quality.
> >>>
> >>> We know for a fact that at least many (all?) Logitech devices that
> >>> support
> >>> conditional effects use this "semi-memoryless" approach where
> >>> FF_CONSTANT
> >>> and FF_PERIODIC are handled in the memoryless fashion and conditional
> >>> effects are uploaded to the device (in a somewhat simplified form). The
> >>> amount of effects that can be uploaded to a device is limited which is
> >>> why ff-memless-next uses two steps (UPLOAD/ERASE and START/STOP) to
> >>> handle these effects.
> >>>
> >>> Conditional effects - even if they are of the same type - cannot be
> >>> effectively combined into one because superposition doesn't seem to work
> >>> here so they have to be processed one by one.
> >>>
> >>> If we ever come across a really memoryless device it should not be
> >>> particularly difficult to add another callback to ff-memless-next which
> >>> would emulate conditional effects with constant force.
> >>
> >> Thank you for the explanation. This further solidifies for me the idea
> >> that handling of such effects that are in fact uploaded to and managed
> >> by the device should not be handled by the memoryless core but rather by
> >> the driver itself. I.e. such drivers should implement their own play(),
> >> upload(), erase(), etc, and decide whether to use a hardware slot for
> >> the effect or handle effect in memoryless fashion (if possible). We can
> >> open ff-memless to allow such drivers to use parts of memoryless
> >> handling.
> >>
> >> Thanks.
> >
> > To bring this to a conclusion we could go from, would this be an
> > acceptable
> > solution?
> >
> > - Have the HW-specific driver talk directly to ff-core and reimplement
> > upload(), play(), etc.
> > - Rewrite "ff-memless-next" so that it is not a self-contained module but
> > a
> > library of functions.
> >
> > - Have the driver either:
> > - Upload an effect to a device directly if the device can fully manage
> > the
> >
> > effect by itself.
> >
> > - Use provided timing functions to know when an effect should start,
> > stop,
> >
> > restart etc...
> >
> > - Use provided timing AND processing functions to combine effects that
> > can be>
> > combined into one, calculate periodic waveforms etc?
> >
> > I have no problem with throwing my current approach away but before I
> > start
> > working on a new one I'd like to know which way to go...
> >
> > Thanks,
> > Michal
>
> Hi everyone
>
> Allow me to introduce myself. I'm Roland Bosa and I work for Logitech,
> more specifically the gaming group. I have been tasked to look into
> gaming device support for Linux and I just started following this list
> and studying the kernel code related to the Logitech Force Feedback
> devices. The 'ff-memless-next' module sounds tailor-made for our
> devices. Please let me know how I can help with its development.
Hi,
"ff-memless-next" was designed with behavior of Logitech devices in mind,
however it was always meant as a general replacement for the current "ff-
memless". After some followup discussion it's unlikely that it will be
mainlined in its current form. See the discussion here
"http://www.spinics.net/lists/linux-input/msg31426.html" for more details.
We would however really appreciate some information regarding Logitech devices
specifically. Although we have reverse engineered most of things, I believe
there are still areas we're not entirely clear about. I realize that you'd
probably have to take it up with the legal deparment but if someone at
Logitech could at least take a look at what we've found so far at fill in the
blanks it'd be most helpful.
Please note that we found numerous bugs and DirectInput specs violations in
the Windows driver which might have impacted our understading of how the
driver works. "ff-memless-next" and "lg4ff" tries to fix or work around these. A
link to out-of-tree update to lg4ff which takes full advantage of "ff-memless-
next" is also provided in this thread.
Thanks for any help you can get us,
Michal
--
To unsubscribe from this list: send the line "unsubscribe linux-input" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply
* [PATCH v3] HID: quirk for Saitek RAT7 and MMO7 mices' mode button
From: Harald Brinkmann @ 2014-05-20 18:28 UTC (permalink / raw)
To: Jiri Kosina; +Cc: Benjamin Tissoires, linux-input, linux-kernel
Hi all,
- added RAT7 abd MMO7 VID/PIDs to hid_have_special_driver[]
Some saitek mice implement a tristate button (for switching button
mappings in the original driver) by keeping one of three (non-physical)
buttons constantly pressed.
This breaks X and probably other userspace software.
This patch implements a quirk for the R.A.T.7 and M.M.O.7, tracking
the mode and generating presses of a single button if it changes.
Also the missing release event is generated instantly.
Signed-off-by: Harald Brinkmann <hbrinkmann@braincalibration.de>
---
drivers/hid/Kconfig | 5 -
drivers/hid/hid-core.c | 4
drivers/hid/hid-ids.h | 2
drivers/hid/hid-saitek.c | 154 +++++++++++++++++++++++++++++++++++--
4 files changed, 157 insertions(+), 8 deletions(-)
diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
index 7af9d0b..00e0138 100644
--- a/drivers/hid/Kconfig
+++ b/drivers/hid/Kconfig
@@ -608,7 +608,10 @@ config HID_SAITEK
Support for Saitek devices that are not fully compliant with the
HID standard.
- Currently only supports the PS1000 controller.
+ Supported devices:
+ - PS1000 Dual Analog Pad
+ - R.A.T.7 Gaming Mouse
+ - M.M.O.7 Gaming Mouse
config HID_SAMSUNG
tristate "Samsung InfraRed remote control or keyboards"
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index da52279..d078f85 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -1868,7 +1868,11 @@ static const struct hid_device_id hid_have_special_driver[] = {
{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_RYOS_MK_PRO) },
{ HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_SAVU) },
#endif
+#if IS_ENABLED(CONFIG_HID_SAITEK)
{ HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_PS1000) },
+ { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_RAT7) },
+ { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_MMO7) },
+#endif
{ HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE) },
{ HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE) },
{ HID_USB_DEVICE(USB_VENDOR_ID_SKYCABLE, USB_DEVICE_ID_SKYCABLE_WIRELESS_PRESENTER) },
diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
index 34bb220..adb0187 100644
--- a/drivers/hid/hid-ids.h
+++ b/drivers/hid/hid-ids.h
@@ -764,6 +764,8 @@
#define USB_VENDOR_ID_SAITEK 0x06a3
#define USB_DEVICE_ID_SAITEK_RUMBLEPAD 0xff17
#define USB_DEVICE_ID_SAITEK_PS1000 0x0621
+#define USB_DEVICE_ID_SAITEK_RAT7 0x0cd7
+#define USB_DEVICE_ID_SAITEK_MMO7 0x0cd0
#define USB_VENDOR_ID_SAMSUNG 0x0419
#define USB_DEVICE_ID_SAMSUNG_IR_REMOTE 0x0001
diff --git a/drivers/hid/hid-saitek.c b/drivers/hid/hid-saitek.c
index 37961c7..69cca14 100644
--- a/drivers/hid/hid-saitek.c
+++ b/drivers/hid/hid-saitek.c
@@ -1,10 +1,17 @@
/*
- * HID driver for Saitek devices, currently only the PS1000 (USB gamepad).
+ * HID driver for Saitek devices.
+ *
+ * PS1000 (USB gamepad):
* Fixes the HID report descriptor by removing a non-existent axis and
* clearing the constant bit on the input reports for buttons and d-pad.
* (This module is based on "hid-ortek".)
- *
* Copyright (c) 2012 Andreas Hübner
+ *
+ * R.A.T.7, M.M.O.7 (USB gaming mice):
+ * Fixes the mode button which cycles through three constantly pressed
+ * buttons. All three press events are mapped to one button and the
+ * missing release event is generated immediately.
+ *
*/
/*
@@ -21,12 +28,57 @@
#include "hid-ids.h"
+#define SAITEK_FIX_PS1000 0x0001
+#define SAITEK_RELEASE_MODE_RAT7 0x0002
+#define SAITEK_RELEASE_MODE_MMO7 0x0004
+
+struct saitek_sc {
+ unsigned long quirks;
+ int mode;
+};
+
+static int saitek_probe(struct hid_device *hdev,
+ const struct hid_device_id *id)
+{
+ unsigned long quirks = id->driver_data;
+ struct saitek_sc *ssc;
+ int ret;
+
+ ssc = devm_kzalloc(&hdev->dev, sizeof(*ssc), GFP_KERNEL);
+ if (ssc == NULL) {
+ hid_err(hdev, "can't alloc saitek descriptor\n");
+ return -ENOMEM;
+ }
+
+ ssc->quirks = quirks;
+ ssc->mode = -1;
+
+ hid_set_drvdata(hdev, ssc);
+
+ ret = hid_parse(hdev);
+ if (ret) {
+ hid_err(hdev, "parse failed\n");
+ return ret;
+ }
+
+ ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
+ if (ret) {
+ hid_err(hdev, "hw start failed\n");
+ return ret;
+ }
+
+ return 0;
+}
+
static __u8 *saitek_report_fixup(struct hid_device *hdev, __u8 *rdesc,
unsigned int *rsize)
{
- if (*rsize == 137 && rdesc[20] == 0x09 && rdesc[21] == 0x33
- && rdesc[94] == 0x81 && rdesc[95] == 0x03
- && rdesc[110] == 0x81 && rdesc[111] == 0x03) {
+ struct saitek_sc *ssc = hid_get_drvdata(hdev);
+
+ if ((ssc->quirks & SAITEK_FIX_PS1000) && *rsize == 137 &&
+ rdesc[20] == 0x09 && rdesc[21] == 0x33 &&
+ rdesc[94] == 0x81 && rdesc[95] == 0x03 &&
+ rdesc[110] == 0x81 && rdesc[111] == 0x03) {
hid_info(hdev, "Fixing up Saitek PS1000 report descriptor\n");
@@ -42,8 +94,93 @@ static __u8 *saitek_report_fixup(struct hid_device *hdev, __u8 *rdesc,
return rdesc;
}
+static int saitek_raw_event(struct hid_device *hdev,
+ struct hid_report *report, u8 *raw_data, int size)
+{
+ struct saitek_sc *ssc = hid_get_drvdata(hdev);
+
+ if (ssc->quirks & SAITEK_RELEASE_MODE_RAT7 && size == 7) {
+ /* R.A.T.7 uses bits 13, 14, 15 for the mode */
+ int mode = -1;
+ if (raw_data[1] & 0x01)
+ mode = 0;
+ else if (raw_data[1] & 0x02)
+ mode = 1;
+ else if (raw_data[1] & 0x04)
+ mode = 2;
+
+ /* clear mode bits */
+ raw_data[1] &= ~0x07;
+
+ if (mode != ssc->mode) {
+ hid_dbg(hdev, "entered mode %d\n", mode);
+ if (ssc->mode != -1) {
+ /* use bit 13 as the mode button */
+ raw_data[1] |= 0x04;
+ }
+ ssc->mode = mode;
+ }
+ } else if (ssc->quirks & SAITEK_RELEASE_MODE_MMO7 && size == 8) {
+
+ /* M.M.O.7 uses bits 8, 22, 23 for the mode */
+ int mode = -1;
+ if (raw_data[1] & 0x80)
+ mode = 0;
+ else if (raw_data[2] & 0x01)
+ mode = 1;
+ else if (raw_data[2] & 0x02)
+ mode = 2;
+
+ /* clear mode bits */
+ raw_data[1] &= ~0x80;
+ raw_data[2] &= ~0x03;
+
+ if (mode != ssc->mode) {
+ hid_dbg(hdev, "entered mode %d\n", mode);
+ if (ssc->mode != -1) {
+ /* use bit 8 as the mode button, bits 22
+ * and 23 do not represent buttons
+ * according to the HID report descriptor
+ */
+ raw_data[1] |= 0x80;
+ }
+ ssc->mode = mode;
+ }
+ }
+
+ return 0;
+}
+
+static int saitek_event(struct hid_device *hdev, struct hid_field *field,
+ struct hid_usage *usage, __s32 value)
+{
+ struct saitek_sc *ssc = hid_get_drvdata(hdev);
+ struct input_dev *input = field->hidinput->input;
+
+ if (usage->type == EV_KEY && value &&
+ (((ssc->quirks & SAITEK_RELEASE_MODE_RAT7) &&
+ usage->code - BTN_MOUSE == 10) ||
+ ((ssc->quirks & SAITEK_RELEASE_MODE_MMO7) &&
+ usage->code - BTN_MOUSE == 15))) {
+
+ input_report_key(input, usage->code, 1);
+
+ /* report missing release event */
+ input_report_key(input, usage->code, 0);
+
+ return 1;
+ }
+
+ return 0;
+}
+
static const struct hid_device_id saitek_devices[] = {
- { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_PS1000)},
+ { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_PS1000),
+ .driver_data = SAITEK_FIX_PS1000 },
+ { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_RAT7),
+ .driver_data = SAITEK_RELEASE_MODE_RAT7 },
+ { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_MMO7),
+ .driver_data = SAITEK_RELEASE_MODE_MMO7 },
{ }
};
@@ -52,7 +189,10 @@ MODULE_DEVICE_TABLE(hid, saitek_devices);
static struct hid_driver saitek_driver = {
.name = "saitek",
.id_table = saitek_devices,
- .report_fixup = saitek_report_fixup
+ .probe = saitek_probe,
+ .report_fixup = saitek_report_fixup,
+ .raw_event = saitek_raw_event,
+ .event = saitek_event,
};
module_hid_driver(saitek_driver);
--
To unsubscribe from this list: send the line "unsubscribe linux-input" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply related
* Re: [PATCH v4 01/24] input: Add ff-memless-next module
From: Roland Bosa @ 2014-05-20 18:32 UTC (permalink / raw)
To: Michal Malý, Dmitry Torokhov
Cc: linux-input, linux-kernel, jkosina, elias.vds, anssi.hannula,
simon
In-Reply-To: <2965006.XKYHWj9YzJ@sigyn>
On 05/20/2014 02:27 AM, Michal Malý wrote:
> On Wednesday 14 of May 2014 11:05:58 Dmitry Torokhov wrote:
>> On Wed, May 14, 2014 at 10:35:25AM +0200, Michal Malý wrote:
>>> Hi Dmitry,
>>>
>>> thank you for reviewing this.
>>>
>>> On Tuesday 13 of May 2014 23:38:06 Dmitry Torokhov wrote:
>>>> On Sat, Apr 26, 2014 at 05:02:00PM +0200, Michal Malý wrote:
>>>>> +
>>>>> +/** DEFINITION OF TERMS
>>>>> + *
>>>>> + * Combined effect - An effect whose force is a superposition of
>>>>> forces
>>>>> + * generated by all effects that can be added
>>>>> together.
>>>>> + * Only one combined effect can be playing at a
>>>>> time.
>>>>> + * Effects that can be added together to create a
>>>>> combined + * effect are FF_CONSTANT, FF_PERIODIC and
>>>>> FF_RAMP. + * Uncombinable effect - An effect that cannot be combined
>>>>> with
>>>>> another effect. + * All conditional effects -
>>>>> FF_DAMPER, FF_FRICTION, + * FF_INERTIA and
>>>>> FF_SPRING are uncombinable. + * Number of
>>>>> uncombinable effects playing simultaneously + *
>>>>> depends on the capabilities of the hardware. + * Rumble effect - An
>>>>> effect generated by device's rumble motors instead of + *
>>>>> force feedback actuators.
>>>>> + *
>>>>> + *
>>>>> + * HANDLING OF UNCOMBINABLE EFFECTS
>>>>> + *
>>>>> + * Uncombinable effects cannot be combined together into just one
>>>>> effect,
>>>>> at + * least not in a clear and obvious manner. Therefore these
>>>>> effects
>>>>> have to + * be handled individually by ff-memless-next. Handling of
>>>>> these
>>>>> effects is + * left entirely to the hardware-specific driver,
>>>>> ff-memless-next merely + * passes these effects to the
>>>>> hardware-specific
>>>>> driver at appropriate time. + * ff-memless-next provides the UPLOAD
>>>>> command to notify the hardware-specific + * driver that the userspace
>>>>> is
>>>>> about to request playback of an uncombinable + * effect. The
>>>>> hardware-specific driver shall take all steps needed to make + * the
>>>>> device ready to play the effect when it receives the UPLOAD command. +
>>>>> *
>>>>> The actual playback shall commence when START_UNCOMB command is
>>>>> received.
>>>>> + * Opposite to the UPLOAD command is the ERASE command which tells +
>>>>> *
>>>>> the hardware-specific driver that the playback has finished and that +
>>>>> *
>>>>> the effect will not be restarted. STOP_UNCOMB command tells
>>>>> + * the hardware-specific driver that the playback shall stop but the
>>>>> device + * shall still be ready to resume the playback immediately.
>>>>> + *
>>>>> + * In case it is not possible to make the device ready to play an
>>>>> uncombinable + * effect (all hardware effect slots are occupied), the
>>>>> hardware-specific + * driver may return an error when it receives an
>>>>> UPLOAD command. If the
>>>>
>>>> This part concerns me. It seems to me that devices supporting
>>>> "uncombinable" effects are in fact not memoryless devices and we should
>>>> not be introducing this term here. If the goal is to work around limited
>>>> number of effect slots in the devices by combining certain effects then
>>>> it needs to be done at ff-core level as it will be potentially useful
>>>> for all devices.
>>>
>>> Force generated by a conditional effect (referred to as "uncombinable"
>>> within ff-memless-next to make the distinction clear) depends on a
>>> position of the device. For instance the more a device is deflected from
>>> a neutral position the greater force FF_SPRING generates. A truly
>>> memoryless device would have to report its position to the driver, have
>>> it calculate the appropriate force and send it back to the device. IMHO
>>> such a loop would require a very high USB polling rate to play
>>> conditional effects with acceptable quality.
>>>
>>> We know for a fact that at least many (all?) Logitech devices that support
>>> conditional effects use this "semi-memoryless" approach where FF_CONSTANT
>>> and FF_PERIODIC are handled in the memoryless fashion and conditional
>>> effects are uploaded to the device (in a somewhat simplified form). The
>>> amount of effects that can be uploaded to a device is limited which is
>>> why ff-memless-next uses two steps (UPLOAD/ERASE and START/STOP) to
>>> handle these effects.
>>>
>>> Conditional effects - even if they are of the same type - cannot be
>>> effectively combined into one because superposition doesn't seem to work
>>> here so they have to be processed one by one.
>>>
>>> If we ever come across a really memoryless device it should not be
>>> particularly difficult to add another callback to ff-memless-next which
>>> would emulate conditional effects with constant force.
>>
>> Thank you for the explanation. This further solidifies for me the idea
>> that handling of such effects that are in fact uploaded to and managed
>> by the device should not be handled by the memoryless core but rather by
>> the driver itself. I.e. such drivers should implement their own play(),
>> upload(), erase(), etc, and decide whether to use a hardware slot for
>> the effect or handle effect in memoryless fashion (if possible). We can
>> open ff-memless to allow such drivers to use parts of memoryless
>> handling.
>>
>> Thanks.
>
> To bring this to a conclusion we could go from, would this be an acceptable
> solution?
>
> - Have the HW-specific driver talk directly to ff-core and reimplement upload(),
> play(), etc.
> - Rewrite "ff-memless-next" so that it is not a self-contained module but a
> library of functions.
> - Have the driver either:
> - Upload an effect to a device directly if the device can fully manage the
> effect by itself.
> - Use provided timing functions to know when an effect should start, stop,
> restart etc...
> - Use provided timing AND processing functions to combine effects that can be
> combined into one, calculate periodic waveforms etc?
>
> I have no problem with throwing my current approach away but before I start
> working on a new one I'd like to know which way to go...
>
> Thanks,
> Michal
Hi everyone
Allow me to introduce myself. I'm Roland Bosa and I work for Logitech,
more specifically the gaming group. I have been tasked to look into
gaming device support for Linux and I just started following this list
and studying the kernel code related to the Logitech Force Feedback
devices. The 'ff-memless-next' module sounds tailor-made for our
devices. Please let me know how I can help with its development.
Thanks
Roland
--
To unsubscribe from this list: send the line "unsubscribe linux-input" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply
* Re: [PATCH 0/4] Input: atmel_mxt_ts - make it work on Tegra
From: Nick Dyer @ 2014-05-20 16:19 UTC (permalink / raw)
To: Stephen Warren
Cc: Dmitry Torokhov, Benson Leung, Yufeng Shen, Daniel Kurtz,
linux-input@vger.kernel.org, Stephen Warren, Bowens, Alan
In-Reply-To: <53763F95.6000609@wwwdotorg.org>
Stephen Warren wrote:
> On 05/16/2014 10:21 AM, Nick Dyer wrote:
>> Thanks for this. Would you be happy for me to pick these changes up and
>> include them along with the other work I am sending to Dmitry? I am just
>> beginning to do various updates to the whole series, one of the things I
>> need to sort out is the device tree support.
>
> That would be fine. I assume you'd only take the 2 Atmel driver patches.
> I'll send the Tegra patches separately once the driver is merged.
Great! Dmitry has merged some of the patches I sent now, so I'm just
working on updating to take account of that and adding the device tree
changes, and taking account of a couple of other review comments.
> One thing I wasn't really sure about: With your latest patches, it seems
> like the bootloader address is auto-calculated from the application
> address. As such, do I still need separate struct i2c_device for the
> application and bootloader I2C addresses? If not, we should remove the
> atmel,mxt-tp-bootloader from those patches. If so, I need to add the
> second DT node back into the Tegra DT. Either way, it might be
> preferable if we only had 1 node in DT, and the driver automatically
> handled the two separate I2C addresses.
Currently you shouldn't need the extra node for the bootloader, it should
figure it out itself. I think in the future, the driver should register the
bootloader address with i2c_new_dummy() to prevent it being bound to a
different driver.
>> I will need to add device tree parameters for the touchscreen as well as
>> the touchpad, of course.
>>
>> By the way, the driver should work without any firmware file and just use
>> the firmware and configuration from NVRAM - request_firmware() returns a
>> failure and it continues through mxt_initialize().
>
> Hmmm. I couldn't get that to work after applying the patches you posted.
> However, it did with what's already in linux-next plus the patches I sent.
I will test this on my setup and see if I can figure out what is causing
the problem.
>> In a later patch in my long series, I make the MXT_CFG_NAME configurable
>> from platform data (because you may have multiple devices needing different
>> configs), and leaving it null means the call to request_firmware() is skipped.
>
> It'd be preferable to automatically derive the firmware name from the
> device type (touchscreen/touchpad) or some other parameter that can be
> calculated at run-time, or queried from HW (e.g. version # from
> bootloader?). I'm not sure that putting firmware filenames in DT is a
> good idea, but perhaps that would work. Deriving firmware filename from
> the DT compatible value would work best.
Yes, I was planning to allow the firmware filename to be specified in DT. I
think that coming up with a scheme to automatically derive it would fall
down in various corner cases (as an example, you might have two devices
which have the same family/variant IDs but require different firmwares), so
it gives maximum flexibility to not dictate the naming policy.
> If different HW needs different
> firmware, it should probably have a different compatible value in DT.
There are literally hundreds of different combinations of hardware/firmware
supported by this driver. Trying to generate a comprehensive list would be
a never-ending task to support. I don't think this is a good idea.
^ permalink raw reply
* Sentelic probe routine issue
From: Aristeu Rozanski @ 2014-05-20 16:08 UTC (permalink / raw)
To: Dmitry Torokhov; +Cc: linux-input, Tai-hwa Liang
[-- Attachment #1: Type: text/plain, Size: 2109 bytes --]
Hello,
we hit a strange bug which has some matching reports elsewhere[1][2]. A
Dell box using a rebranded logitech mouse (M-S69) fails to enable the
mouse with:
psmouse serio1: Failed to enable mouse on isa0060/serio1
The very same mouse in a different machine works fine and a different
ps/2 mouse which uses a protocol better than IMPS in the Dell box also
works.
The behavior is the same: if after booting you unplug the mouse and plug
it again it'll work.
After some digging I found out that Sentelic's probe routine is the
culprit (which was moved down already on 4a18b3ab6ed537b055). As soon
the first byte is sent in fsp_reg_read():
if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
goto out;
Here, that ps2_sendbyte() will return 0 but even forcing to stop there,
won't get it working again. Right after it returns in psmouse-bare.c:
/*
* Reset to defaults in case the device got confused by extended
* protocol probes. Note that we follow up with full reset because
* some mice put themselves to sleep when they see PSMOUSE_RESET_DIS.
*/
ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS);
psmouse_reset(psmouse);
which doesn't seem to help at all. Due to the fact that the same mouse
works in a different machine and a different protocol mouse (which will
stop the probe earlier, never getting to Sentelic's) works in this
machine, my conclusion is that the i8042 in this machine can't handle
that byte.
So I'm out of ideas. We can't move Sentelic's probe even further down
because it'd break in the case of a very old mouse only capable of bare
protocol and I don't have Sentelic's documentation to try to find a
different way to probe without breaking this machine.
Attached are the debug output of an unchanged kernel and a kernel with
Sentelic's probe disabled. "i8042: unplug/plug mouse" was added to
signal when I stopped moving the mouse and unplugged and plugged again.
Any thoughts?
[1] http://debian.2.n7.nabble.com/Bug-418114-intellimouse-linux-image-2-6-686-td2443859.html
[2] http://ubuntuforums.org/archive/index.php/t-1091535.html
--
Aristeu
[-- Attachment #2: stock.log --]
[-- Type: text/plain, Size: 29706 bytes --]
[ 0.000000] Command line: BOOT_IMAGE=/vmlinuz-3.15.0-rc5+ root=/dev/mapper/rhel-root ro rd.lvm.lv=fedora/swap rd.lvm.lv=rhel/swap rd.lvm.lv=rhel/root vconsole.keymap=us crashkernel=auto vconsole.font=latarcyrheb-sun16 rd.lvm.lv=rhel/swap rhgb quiet LANG=en_US.UTF-8 i8042.debug=1
[ 0.000000] Kernel command line: BOOT_IMAGE=/vmlinuz-3.15.0-rc5+ root=/dev/mapper/rhel-root ro rd.lvm.lv=fedora/swap rd.lvm.lv=rhel/swap rd.lvm.lv=rhel/root vconsole.keymap=us crashkernel=auto vconsole.font=latarcyrheb-sun16 rd.lvm.lv=rhel/swap rhgb quiet LANG=en_US.UTF-8 i8042.debug=1
[ 4.537412] i8042: PNP: PS/2 Controller [PNP0f03:PS2M] at 0x60,0x64 irq 12
[ 4.537414] i8042: PNP: PS/2 controller doesn't have KBD irq; using default 1
[ 4.537425] i8042: [0] d1 -> i8042 (command)
[ 4.537481] i8042: [0] df -> i8042 (parameter)
[ 4.537537] i8042: [0] ff -> i8042 (command)
[ 4.537570] i8042: [1] 20 -> i8042 (command)
[ 4.537680] i8042: [1] 65 <- i8042 (return)
[ 4.537733] i8042: [1] 20 -> i8042 (command)
[ 4.537791] i8042: [1] 65 <- i8042 (return)
[ 4.537793] i8042: Warning: Keylock active
[ 4.537796] i8042: [1] 60 -> i8042 (command)
[ 4.537852] i8042: [1] 74 -> i8042 (parameter)
[ 4.537912] i8042: [1] d3 -> i8042 (command)
[ 4.538020] i8042: [1] 5a -> i8042 (parameter)
[ 4.538080] i8042: [1] 5a <- i8042 (return)
[ 4.538083] i8042: [1] a7 -> i8042 (command)
[ 4.538137] i8042: [1] 20 -> i8042 (command)
[ 4.538195] i8042: [1] 74 <- i8042 (return)
[ 4.538198] i8042: [1] a8 -> i8042 (command)
[ 4.538304] i8042: [1] 20 -> i8042 (command)
[ 4.538362] i8042: [1] 54 <- i8042 (return)
[ 4.538375] i8042: [1] 60 -> i8042 (command)
[ 4.538431] i8042: [1] 56 -> i8042 (parameter)
[ 4.538539] i8042: [1] d3 -> i8042 (command)
[ 4.538595] i8042: [1] a5 -> i8042 (parameter)
[ 4.538667] i8042: [2] a5 <- i8042 (aux_test_irq, aux)
[ 4.538676] i8042: [2] 60 -> i8042 (command)
[ 4.538785] i8042: [2] 74 -> i8042 (parameter)
[ 4.538851] i8042: [2] d3 -> i8042 (command)
[ 4.538907] i8042: [2] f0 -> i8042 (parameter)
[ 4.538967] i8042: [2] f0 <- i8042 (return)
[ 4.538970] i8042: [2] d3 -> i8042 (command)
[ 4.539026] i8042: [2] 56 -> i8042 (parameter)
[ 4.539137] i8042: [2] 56 <- i8042 (return)
[ 4.539140] i8042: [2] d3 -> i8042 (command)
[ 4.539196] i8042: [2] a4 -> i8042 (parameter)
[ 4.539255] i8042: [2] a4 <- i8042 (return)
[ 4.539270] i8042: [2] 60 -> i8042 (command)
[ 4.539326] i8042: [2] 56 -> i8042 (parameter)
[ 4.539338] i8042: [2] Interrupt 1, without any data
[ 4.539394] i8042: [2] 60 -> i8042 (command)
[ 4.539450] i8042: [2] 47 -> i8042 (parameter)
[ 4.539454] serio: i8042 KBD port at 0x60,0x64 irq 1
[ 4.539459] serio: i8042 AUX port at 0x60,0x64 irq 12
[ 4.539890] i8042: [3] d4 -> i8042 (command)
[ 4.539947] i8042: [3] f2 -> i8042 (parameter)
[ 4.542300] i8042: [5] fa <- i8042 (interrupt, 1, 12)
[ 4.543471] i8042: [6] 03 <- i8042 (interrupt, 1, 12)
[ 4.543487] i8042: [6] d4 -> i8042 (command)
[ 4.543543] i8042: [7] f6 -> i8042 (parameter)
[ 4.545925] i8042: [9] fa <- i8042 (interrupt, 1, 12)
[ 4.545942] i8042: [9] d4 -> i8042 (command)
[ 4.545999] i8042: [9] f3 -> i8042 (parameter)
[ 4.546067] i8042: [9] fa <- i8042 (interrupt, 1, 12)
[ 4.546072] i8042: [9] d4 -> i8042 (command)
[ 4.546180] i8042: [9] 0a -> i8042 (parameter)
[ 4.550683] i8042: [14] fa <- i8042 (interrupt, 1, 12)
[ 4.550700] i8042: [14] d4 -> i8042 (command)
[ 4.550756] i8042: [14] e8 -> i8042 (parameter)
[ 4.550819] i8042: [14] fa <- i8042 (interrupt, 1, 12)
[ 4.550825] i8042: [14] d4 -> i8042 (command)
[ 4.550933] i8042: [14] 00 -> i8042 (parameter)
[ 4.555349] i8042: [18] fa <- i8042 (interrupt, 1, 12)
[ 4.555365] i8042: [18] d4 -> i8042 (command)
[ 4.555422] i8042: [18] f3 -> i8042 (parameter)
[ 4.555501] i8042: [19] fa <- i8042 (interrupt, 1, 12)
[ 4.555508] i8042: [19] d4 -> i8042 (command)
[ 4.555616] i8042: [19] 14 -> i8042 (parameter)
[ 4.560036] i8042: [23] fa <- i8042 (interrupt, 1, 12)
[ 4.560052] i8042: [23] d4 -> i8042 (command)
[ 4.560316] i8042: [23] f3 -> i8042 (parameter)
[ 4.560440] i8042: [23] fa <- i8042 (interrupt, 1, 12)
[ 4.560445] i8042: [23] d4 -> i8042 (command)
[ 4.560553] i8042: [24] 3c -> i8042 (parameter)
[ 4.565103] i8042: [28] fa <- i8042 (interrupt, 1, 12)
[ 4.565119] i8042: [28] d4 -> i8042 (command)
[ 4.565176] i8042: [28] f3 -> i8042 (parameter)
[ 4.565244] i8042: [28] fa <- i8042 (interrupt, 1, 12)
[ 4.565250] i8042: [28] d4 -> i8042 (command)
[ 4.565358] i8042: [28] 28 -> i8042 (parameter)
[ 4.569825] i8042: [33] fa <- i8042 (interrupt, 1, 12)
[ 4.569833] i8042: [33] d4 -> i8042 (command)
[ 4.569941] i8042: [33] f3 -> i8042 (parameter)
[ 4.569999] i8042: [33] fa <- i8042 (interrupt, 1, 12)
[ 4.570004] i8042: [33] d4 -> i8042 (command)
[ 4.570112] i8042: [33] 14 -> i8042 (parameter)
[ 4.574584] i8042: [38] fa <- i8042 (interrupt, 1, 12)
[ 4.574596] i8042: [38] d4 -> i8042 (command)
[ 4.574703] i8042: [38] f3 -> i8042 (parameter)
[ 4.574764] i8042: [38] fa <- i8042 (interrupt, 1, 12)
[ 4.574769] i8042: [38] d4 -> i8042 (command)
[ 4.574876] i8042: [38] 14 -> i8042 (parameter)
[ 4.579421] i8042: [42] fa <- i8042 (interrupt, 1, 12)
[ 4.579434] i8042: [42] d4 -> i8042 (command)
[ 4.579697] i8042: [43] f3 -> i8042 (parameter)
[ 4.579800] i8042: [43] fa <- i8042 (interrupt, 1, 12)
[ 4.579811] i8042: [43] d4 -> i8042 (command)
[ 4.579920] i8042: [43] 3c -> i8042 (parameter)
[ 4.584419] i8042: [47] fa <- i8042 (interrupt, 1, 12)
[ 4.584449] i8042: [47] d4 -> i8042 (command)
[ 4.584562] i8042: [48] f3 -> i8042 (parameter)
[ 4.584654] i8042: [48] fa <- i8042 (interrupt, 1, 12)
[ 4.584673] i8042: [48] d4 -> i8042 (command)
[ 4.584732] i8042: [48] 28 -> i8042 (parameter)
[ 4.589186] i8042: [52] fa <- i8042 (interrupt, 1, 12)
[ 4.589210] i8042: [52] d4 -> i8042 (command)
[ 4.589268] i8042: [52] f3 -> i8042 (parameter)
[ 4.589353] i8042: [52] fa <- i8042 (interrupt, 1, 12)
[ 4.589360] i8042: [52] d4 -> i8042 (command)
[ 4.589469] i8042: [52] 14 -> i8042 (parameter)
[ 4.594031] i8042: [57] fa <- i8042 (interrupt, 1, 12)
[ 4.594056] i8042: [57] d4 -> i8042 (command)
[ 4.594114] i8042: [57] f3 -> i8042 (parameter)
[ 4.594204] i8042: [57] fa <- i8042 (interrupt, 1, 12)
[ 4.594214] i8042: [57] d4 -> i8042 (command)
[ 4.594324] i8042: [57] 14 -> i8042 (parameter)
[ 4.598859] i8042: [62] fa <- i8042 (interrupt, 1, 12)
[ 4.598885] i8042: [62] d4 -> i8042 (command)
[ 4.599101] i8042: [62] f2 -> i8042 (parameter)
[ 4.601408] i8042: [64] fa <- i8042 (interrupt, 1, 12)
[ 4.602552] i8042: [66] 03 <- i8042 (interrupt, 1, 12)
[ 4.602578] i8042: [66] d4 -> i8042 (command)
[ 4.602688] i8042: [66] e8 -> i8042 (parameter)
[ 4.602735] i8042: [66] fa <- i8042 (interrupt, 1, 12)
[ 4.602742] i8042: [66] d4 -> i8042 (command)
[ 4.602851] i8042: [66] 00 -> i8042 (parameter)
[ 4.607281] i8042: [70] fa <- i8042 (interrupt, 1, 12)
[ 4.607305] i8042: [70] d4 -> i8042 (command)
[ 4.607363] i8042: [70] e8 -> i8042 (parameter)
[ 4.607431] i8042: [70] fa <- i8042 (interrupt, 1, 12)
[ 4.607438] i8042: [70] d4 -> i8042 (command)
[ 4.607547] i8042: [71] 00 -> i8042 (parameter)
[ 4.611929] i8042: [75] fa <- i8042 (interrupt, 1, 12)
[ 4.611952] i8042: [75] d4 -> i8042 (command)
[ 4.612062] i8042: [75] e8 -> i8042 (parameter)
[ 4.612135] i8042: [75] fa <- i8042 (interrupt, 1, 12)
[ 4.612142] i8042: [75] d4 -> i8042 (command)
[ 4.612251] i8042: [75] 00 -> i8042 (parameter)
[ 4.616772] i8042: [80] fa <- i8042 (interrupt, 1, 12)
[ 4.616806] i8042: [80] d4 -> i8042 (command)
[ 4.616866] i8042: [80] e8 -> i8042 (parameter)
[ 4.617073] i8042: [80] fa <- i8042 (interrupt, 1, 12)
[ 4.617085] i8042: [80] d4 -> i8042 (command)
[ 4.617144] i8042: [80] 00 -> i8042 (parameter)
[ 4.621704] i8042: [85] fa <- i8042 (interrupt, 1, 12)
[ 4.621734] i8042: [85] d4 -> i8042 (command)
[ 4.621793] i8042: [85] e9 -> i8042 (parameter)
[ 4.624097] i8042: [87] fa <- i8042 (interrupt, 1, 12)
[ 4.627411] i8042: [90] 00 <- i8042 (interrupt, 1, 12)
[ 4.627465] i8042: [90] 00 <- i8042 (interrupt, 1, 12)
[ 4.627523] i8042: [91] 14 <- i8042 (interrupt, 1, 12)
[ 4.627541] i8042: [91] d4 -> i8042 (command)
[ 4.627599] i8042: [91] e8 -> i8042 (parameter)
[ 4.627688] i8042: [91] fa <- i8042 (interrupt, 1, 12)
[ 4.627701] i8042: [91] d4 -> i8042 (command)
[ 4.627760] i8042: [91] 00 -> i8042 (parameter)
[ 4.632205] i8042: [95] fa <- i8042 (interrupt, 1, 12)
[ 4.632239] i8042: [95] d4 -> i8042 (command)
[ 4.632455] i8042: [95] e8 -> i8042 (parameter)
[ 4.632632] i8042: [96] fa <- i8042 (interrupt, 1, 12)
[ 4.632654] i8042: [96] d4 -> i8042 (command)
[ 4.632713] i8042: [96] 00 -> i8042 (parameter)
[ 4.637298] i8042: [100] fa <- i8042 (interrupt, 1, 12)
[ 4.637325] i8042: [100] d4 -> i8042 (command)
[ 4.637384] i8042: [100] e8 -> i8042 (parameter)
[ 4.637448] i8042: [100] fa <- i8042 (interrupt, 1, 12)
[ 4.637455] i8042: [100] d4 -> i8042 (command)
[ 4.637565] i8042: [101] 00 -> i8042 (parameter)
[ 4.641960] i8042: [105] fa <- i8042 (interrupt, 1, 12)
[ 4.641993] i8042: [105] d4 -> i8042 (command)
[ 4.642053] i8042: [105] e8 -> i8042 (parameter)
[ 4.642129] i8042: [105] fa <- i8042 (interrupt, 1, 12)
[ 4.642142] i8042: [105] d4 -> i8042 (command)
[ 4.642201] i8042: [105] 00 -> i8042 (parameter)
[ 4.646627] i8042: [110] fa <- i8042 (interrupt, 1, 12)
[ 4.646661] i8042: [110] d4 -> i8042 (command)
[ 4.646720] i8042: [110] e9 -> i8042 (parameter)
[ 4.649043] i8042: [112] fa <- i8042 (interrupt, 1, 12)
[ 4.652355] i8042: [115] 00 <- i8042 (interrupt, 1, 12)
[ 4.652410] i8042: [115] 00 <- i8042 (interrupt, 1, 12)
[ 4.652471] i8042: [116] 14 <- i8042 (interrupt, 1, 12)
[ 4.848411] i8042: [312] d4 -> i8042 (command)
[ 4.848472] i8042: [312] f6 -> i8042 (parameter)
[ 4.850834] i8042: [314] fa <- i8042 (interrupt, 1, 12)
[ 4.850853] i8042: [314] d4 -> i8042 (command)
[ 4.850962] i8042: [314] e8 -> i8042 (parameter)
[ 4.851002] i8042: [314] fa <- i8042 (interrupt, 1, 12)
[ 4.851010] i8042: [314] d4 -> i8042 (command)
[ 4.851119] i8042: [314] 00 -> i8042 (parameter)
[ 4.855503] i8042: [319] fa <- i8042 (interrupt, 1, 12)
[ 4.855516] i8042: [319] d4 -> i8042 (command)
[ 4.855627] i8042: [319] e6 -> i8042 (parameter)
[ 4.857927] i8042: [321] fa <- i8042 (interrupt, 1, 12)
[ 4.857941] i8042: [321] d4 -> i8042 (command)
[ 4.858155] i8042: [321] e6 -> i8042 (parameter)
[ 4.860499] i8042: [324] fa <- i8042 (interrupt, 1, 12)
[ 4.860513] i8042: [324] d4 -> i8042 (command)
[ 4.860622] i8042: [324] e6 -> i8042 (parameter)
[ 4.862916] i8042: [326] fa <- i8042 (interrupt, 1, 12)
[ 4.862929] i8042: [326] d4 -> i8042 (command)
[ 4.863040] i8042: [326] e9 -> i8042 (parameter)
[ 4.865334] i8042: [328] fa <- i8042 (interrupt, 1, 12)
[ 4.868637] i8042: [332] 1a <- i8042 (interrupt, 1, 12)
[ 4.868697] i8042: [332] 03 <- i8042 (interrupt, 1, 12)
[ 4.868755] i8042: [332] 3c <- i8042 (interrupt, 1, 12)
[ 4.868847] i8042: [332] d4 -> i8042 (command)
[ 4.868905] i8042: [332] f6 -> i8042 (parameter)
[ 4.871259] i8042: [334] fa <- i8042 (interrupt, 1, 12)
[ 4.871280] i8042: [334] d4 -> i8042 (command)
[ 4.871389] i8042: [335] f5 -> i8042 (parameter)
[ 4.873677] i8042: [337] fa <- i8042 (interrupt, 1, 12)
[ 4.873688] i8042: [337] d4 -> i8042 (command)
[ 4.873797] i8042: [337] e6 -> i8042 (parameter)
[ 4.876089] i8042: [339] fa <- i8042 (interrupt, 1, 12)
[ 4.876344] i8042: [339] d4 -> i8042 (command)
[ 4.876403] i8042: [340] e6 -> i8042 (parameter)
[ 4.878749] i8042: [342] fa <- i8042 (interrupt, 1, 12)
[ 4.878768] i8042: [342] d4 -> i8042 (command)
[ 4.878878] i8042: [342] e6 -> i8042 (parameter)
[ 4.881159] i8042: [344] fa <- i8042 (interrupt, 1, 12)
[ 4.881177] i8042: [344] d4 -> i8042 (command)
[ 4.881286] i8042: [344] e9 -> i8042 (parameter)
[ 4.883578] i8042: [347] fa <- i8042 (interrupt, 1, 12)
[ 4.886888] i8042: [350] 1a <- i8042 (interrupt, 1, 12)
[ 4.886948] i8042: [350] 03 <- i8042 (interrupt, 1, 12)
[ 4.887006] i8042: [350] 3c <- i8042 (interrupt, 1, 12)
[ 4.887023] i8042: [350] d4 -> i8042 (command)
[ 4.887081] i8042: [350] e8 -> i8042 (parameter)
[ 4.887171] i8042: [350] fa <- i8042 (interrupt, 1, 12)
[ 4.887178] i8042: [350] d4 -> i8042 (command)
[ 4.887287] i8042: [350] 03 -> i8042 (parameter)
[ 4.891684] i8042: [355] fa <- i8042 (interrupt, 1, 12)
[ 4.891699] i8042: [355] d4 -> i8042 (command)
[ 4.891810] i8042: [355] e6 -> i8042 (parameter)
[ 4.894108] i8042: [357] fa <- i8042 (interrupt, 1, 12)
[ 4.894123] i8042: [357] d4 -> i8042 (command)
[ 4.894233] i8042: [357] e6 -> i8042 (parameter)
[ 4.896516] i8042: [360] fa <- i8042 (interrupt, 1, 12)
[ 4.896530] i8042: [360] d4 -> i8042 (command)
[ 4.896641] i8042: [360] e6 -> i8042 (parameter)
[ 4.901288] i8042: [364] fa <- i8042 (interrupt, 1, 12)
[ 4.901321] i8042: [364] d4 -> i8042 (command)
[ 4.901432] i8042: [365] e9 -> i8042 (parameter)
[ 4.913603] i8042: [377] fa <- i8042 (interrupt, 1, 12)
[ 4.916905] i8042: [380] 1a <- i8042 (interrupt, 1, 12)
[ 4.926948] i8042: [390] 03 <- i8042 (interrupt, 1, 12)
[ 4.927838] i8042: [391] 3c <- i8042 (interrupt, 1, 12)
[ 4.927867] i8042: [391] d4 -> i8042 (command)
[ 4.928757] i8042: [392] e8 -> i8042 (parameter)
[ 4.929611] i8042: [393] fa <- i8042 (interrupt, 1, 12)
[ 4.929630] i8042: [393] d4 -> i8042 (command)
[ 4.930521] i8042: [394] 00 -> i8042 (parameter)
[ 4.935820] i8042: [399] fa <- i8042 (interrupt, 1, 12)
[ 4.935844] i8042: [399] d4 -> i8042 (command)
[ 4.936062] i8042: [399] e6 -> i8042 (parameter)
[ 4.938416] i8042: [402] fa <- i8042 (interrupt, 1, 12)
[ 4.938445] i8042: [402] d4 -> i8042 (command)
[ 4.938658] i8042: [402] e6 -> i8042 (parameter)
[ 4.940961] i8042: [404] fa <- i8042 (interrupt, 1, 12)
[ 4.940995] i8042: [404] d4 -> i8042 (command)
[ 4.941055] i8042: [404] e6 -> i8042 (parameter)
[ 4.943376] i8042: [407] fa <- i8042 (interrupt, 1, 12)
[ 4.943401] i8042: [407] d4 -> i8042 (command)
[ 4.943511] i8042: [407] e9 -> i8042 (parameter)
[ 4.945793] i8042: [409] fa <- i8042 (interrupt, 1, 12)
[ 4.949106] i8042: [412] 1a <- i8042 (interrupt, 1, 12)
[ 4.949167] i8042: [412] 03 <- i8042 (interrupt, 1, 12)
[ 4.949232] i8042: [412] 3c <- i8042 (interrupt, 1, 12)
[ 4.949246] i8042: [412] d4 -> i8042 (command)
[ 4.949356] i8042: [413] e6 -> i8042 (parameter)
[ 4.951637] i8042: [415] fa <- i8042 (interrupt, 1, 12)
[ 4.951661] i8042: [415] d4 -> i8042 (command)
[ 4.951772] i8042: [415] e8 -> i8042 (parameter)
[ 4.951819] i8042: [415] fa <- i8042 (interrupt, 1, 12)
[ 4.951831] i8042: [415] d4 -> i8042 (command)
[ 4.951889] i8042: [415] 00 -> i8042 (parameter)
[ 4.956324] i8042: [419] fa <- i8042 (interrupt, 1, 12)
[ 4.956348] i8042: [419] d4 -> i8042 (command)
[ 4.956458] i8042: [420] e8 -> i8042 (parameter)
[ 4.956531] i8042: [420] fa <- i8042 (interrupt, 1, 12)
[ 4.956544] i8042: [420] d4 -> i8042 (command)
[ 4.956601] i8042: [420] 03 -> i8042 (parameter)
[ 4.961156] i8042: [424] fa <- i8042 (interrupt, 1, 12)
[ 4.961181] i8042: [424] d4 -> i8042 (command)
[ 4.961290] i8042: [424] e8 -> i8042 (parameter)
[ 4.961329] i8042: [424] fa <- i8042 (interrupt, 1, 12)
[ 4.961336] i8042: [424] d4 -> i8042 (command)
[ 4.961447] i8042: [425] 02 -> i8042 (parameter)
[ 4.965833] i8042: [429] fa <- i8042 (interrupt, 1, 12)
[ 4.965860] i8042: [429] d4 -> i8042 (command)
[ 4.965970] i8042: [429] e8 -> i8042 (parameter)
[ 4.966041] i8042: [429] fa <- i8042 (interrupt, 1, 12)
[ 4.966049] i8042: [429] d4 -> i8042 (command)
[ 4.966158] i8042: [429] 01 -> i8042 (parameter)
[ 4.970663] i8042: [434] fa <- i8042 (interrupt, 1, 12)
[ 4.970681] i8042: [434] d4 -> i8042 (command)
[ 4.970790] i8042: [434] eb -> i8042 (parameter)
[ 4.973085] i8042: [436] fa <- i8042 (interrupt, 1, 12)
[ 4.976385] i8042: [440] 08 <- i8042 (interrupt, 1, 12)
[ 4.976444] i8042: [440] 00 <- i8042 (interrupt, 1, 12)
[ 4.976503] i8042: [440] 00 <- i8042 (interrupt, 1, 12)
[ 4.976514] i8042: [440] d4 -> i8042 (command)
[ 4.976624] i8042: [440] e6 -> i8042 (parameter)
[ 4.978931] i8042: [442] fa <- i8042 (interrupt, 1, 12)
[ 4.978945] i8042: [442] d4 -> i8042 (command)
[ 4.979160] i8042: [442] e8 -> i8042 (parameter)
[ 4.979241] i8042: [442] fa <- i8042 (interrupt, 1, 12)
[ 4.979248] i8042: [442] d4 -> i8042 (command)
[ 4.979357] i8042: [443] 03 -> i8042 (parameter)
[ 4.983846] i8042: [447] fa <- i8042 (interrupt, 1, 12)
[ 4.983858] i8042: [447] d4 -> i8042 (command)
[ 4.983969] i8042: [447] e8 -> i8042 (parameter)
[ 4.984019] i8042: [447] fa <- i8042 (interrupt, 1, 12)
[ 4.984025] i8042: [447] d4 -> i8042 (command)
[ 4.984135] i8042: [447] 01 -> i8042 (parameter)
[ 4.988603] i8042: [452] fa <- i8042 (interrupt, 1, 12)
[ 4.988617] i8042: [452] d4 -> i8042 (command)
[ 4.988728] i8042: [452] e8 -> i8042 (parameter)
[ 4.988777] i8042: [452] fa <- i8042 (interrupt, 1, 12)
[ 4.988783] i8042: [452] d4 -> i8042 (command)
[ 4.988892] i8042: [452] 02 -> i8042 (parameter)
[ 4.993288] i8042: [456] fa <- i8042 (interrupt, 1, 12)
[ 4.993304] i8042: [456] d4 -> i8042 (command)
[ 4.993414] i8042: [457] e8 -> i8042 (parameter)
[ 4.993461] i8042: [457] fa <- i8042 (interrupt, 1, 12)
[ 4.993473] i8042: [457] d4 -> i8042 (command)
[ 4.993531] i8042: [457] 03 -> i8042 (parameter)
[ 4.998046] i8042: [461] fa <- i8042 (interrupt, 1, 12)
[ 4.998060] i8042: [461] d4 -> i8042 (command)
[ 4.998169] i8042: [461] eb -> i8042 (parameter)
[ 5.000457] i8042: [464] fa <- i8042 (interrupt, 1, 12)
[ 5.003768] i8042: [467] 08 <- i8042 (interrupt, 1, 12)
[ 5.003828] i8042: [467] 00 <- i8042 (interrupt, 1, 12)
[ 5.003889] i8042: [467] 00 <- i8042 (interrupt, 1, 12)
[ 5.003903] i8042: [467] d4 -> i8042 (command)
[ 5.004012] i8042: [467] e1 -> i8042 (parameter)
[ 5.006316] i8042: [469] fe <- i8042 (interrupt, 1, 12)
[ 5.006337] i8042: [470] d4 -> i8042 (command)
[ 5.006446] i8042: [470] f5 -> i8042 (parameter)
[ 5.008807] i8042: [472] fa <- i8042 (interrupt, 1, 12)
[ 5.008820] i8042: [472] d4 -> i8042 (command)
[ 5.009034] i8042: [472] f3 -> i8042 (parameter)
[ 5.009120] i8042: [472] fa <- i8042 (interrupt, 1, 12)
[ 5.009126] i8042: [472] d4 -> i8042 (command)
[ 5.009235] i8042: [472] 66 -> i8042 (parameter)
[ 5.038330] i8042: [502] d4 -> i8042 (command)
[ 5.089257] i8042: [552] 88 -> i8042 (parameter)
[ 5.089365] i8042: [553] fe <- i8042 (interrupt, 1, 12)
[ 5.089384] i8042: [553] d4 -> i8042 (command)
[ 5.089441] i8042: [553] f3 -> i8042 (parameter)
[ 5.089535] i8042: [553] fa <- i8042 (interrupt, 1, 12)
[ 5.089542] i8042: [553] d4 -> i8042 (command)
[ 5.089651] i8042: [553] 66 -> i8042 (parameter)
[ 5.119319] i8042: [583] d4 -> i8042 (command)
[ 5.119378] i8042: [583] 00 -> i8042 (parameter)
[ 5.119459] i8042: [583] fe <- i8042 (interrupt, 1, 12)
[ 5.119466] i8042: [583] d4 -> i8042 (command)
[ 5.119523] i8042: [583] e9 -> i8042 (parameter)
[ 5.319231] i8042: [783] d4 -> i8042 (command)
[ 5.319291] i8042: [783] f4 -> i8042 (parameter)
[ 5.519170] i8042: [983] d4 -> i8042 (command)
[ 5.519228] i8042: [983] f6 -> i8042 (parameter)
[ 5.719091] i8042: [1183] d4 -> i8042 (command)
[ 5.719152] i8042: [1183] ff -> i8042 (parameter)
[ 6.718753] i8042: [2183] d4 -> i8042 (command)
[ 6.718814] i8042: [2183] f3 -> i8042 (parameter)
[ 6.718864] i8042: [2183] fa <- i8042 (interrupt, 1, 12)
[ 6.718873] i8042: [2183] d4 -> i8042 (command)
[ 6.718930] i8042: [2183] c8 -> i8042 (parameter)
[ 6.918692] i8042: [2383] d4 -> i8042 (command)
[ 6.918752] i8042: [2383] f3 -> i8042 (parameter)
[ 6.918813] i8042: [2383] fa <- i8042 (interrupt, 1, 12)
[ 6.918822] i8042: [2383] d4 -> i8042 (command)
[ 6.918931] i8042: [2383] 64 -> i8042 (parameter)
[ 7.118621] i8042: [2583] d4 -> i8042 (command)
[ 7.118682] i8042: [2583] f3 -> i8042 (parameter)
[ 7.118741] i8042: [2583] fa <- i8042 (interrupt, 1, 12)
[ 7.118749] i8042: [2583] d4 -> i8042 (command)
[ 7.119014] i8042: [2583] 50 -> i8042 (parameter)
[ 7.318551] i8042: [2783] d4 -> i8042 (command)
[ 7.318611] i8042: [2783] f2 -> i8042 (parameter)
[ 7.518462] i8042: [2983] d4 -> i8042 (command)
[ 7.518522] i8042: [2983] f3 -> i8042 (parameter)
[ 7.518601] i8042: [2983] fa <- i8042 (interrupt, 1, 12)
[ 7.518609] i8042: [2983] d4 -> i8042 (command)
[ 7.518718] i8042: [2983] c8 -> i8042 (parameter)
[ 7.718405] i8042: [3183] d4 -> i8042 (command)
[ 7.718483] i8042: [3183] f3 -> i8042 (parameter)
[ 7.718532] i8042: [3183] fa <- i8042 (interrupt, 1, 12)
[ 7.718540] i8042: [3183] d4 -> i8042 (command)
[ 7.718649] i8042: [3183] c8 -> i8042 (parameter)
[ 7.918336] i8042: [3383] d4 -> i8042 (command)
[ 7.918396] i8042: [3383] f3 -> i8042 (parameter)
[ 7.918483] i8042: [3383] fa <- i8042 (interrupt, 1, 12)
[ 7.918491] i8042: [3383] d4 -> i8042 (command)
[ 7.918600] i8042: [3383] 50 -> i8042 (parameter)
[ 8.118260] i8042: [3583] d4 -> i8042 (command)
[ 8.121121] i8042: [3585] f2 -> i8042 (parameter)
[ 8.320191] i8042: [3785] d4 -> i8042 (command)
[ 8.320251] i8042: [3785] f3 -> i8042 (parameter)
[ 8.320322] i8042: [3785] fa <- i8042 (interrupt, 1, 12)
[ 8.320331] i8042: [3785] d4 -> i8042 (command)
[ 8.320440] i8042: [3785] c8 -> i8042 (parameter)
[ 8.520099] i8042: [3985] d4 -> i8042 (command)
[ 8.520159] i8042: [3985] f3 -> i8042 (parameter)
[ 8.520208] i8042: [3985] fa <- i8042 (interrupt, 1, 12)
[ 8.520216] i8042: [3985] d4 -> i8042 (command)
[ 8.520326] i8042: [3985] 64 -> i8042 (parameter)
[ 8.720043] i8042: [4185] d4 -> i8042 (command)
[ 8.720103] i8042: [4185] f3 -> i8042 (parameter)
[ 8.720175] i8042: [4185] fa <- i8042 (interrupt, 1, 12)
[ 8.720183] i8042: [4185] d4 -> i8042 (command)
[ 8.720293] i8042: [4185] 50 -> i8042 (parameter)
[ 8.919961] i8042: [4385] d4 -> i8042 (command)
[ 8.920021] i8042: [4385] f2 -> i8042 (parameter)
[ 9.119906] i8042: [4585] d4 -> i8042 (command)
[ 9.119966] i8042: [4585] f3 -> i8042 (parameter)
[ 9.120018] i8042: [4585] fa <- i8042 (interrupt, 1, 12)
[ 9.120026] i8042: [4585] d4 -> i8042 (command)
[ 9.120135] i8042: [4585] 64 -> i8042 (parameter)
[ 9.319825] i8042: [4785] d4 -> i8042 (command)
[ 9.319885] i8042: [4785] e8 -> i8042 (parameter)
[ 9.319932] i8042: [4785] fa <- i8042 (interrupt, 1, 12)
[ 9.319940] i8042: [4785] d4 -> i8042 (command)
[ 9.320049] i8042: [4785] 03 -> i8042 (parameter)
[ 9.519753] i8042: [4985] d4 -> i8042 (command)
[ 9.519813] i8042: [4985] e6 -> i8042 (parameter)
[ 9.719741] input: PS/2 Logitech Wheel Mouse as /devices/platform/i8042/serio1/input/input2
[ 9.719879] i8042: [5185] d4 -> i8042 (command)
[ 9.719937] i8042: [5185] f4 -> i8042 (parameter)
[ 9.919605] i8042: [5385] f2 -> i8042 (kbd-data)
[ 9.919662] i8042: [5385] fa <- i8042 (interrupt, 0, 1)
[ 9.919729] i8042: [5385] ab <- i8042 (interrupt, 0, 1)
[ 9.919797] i8042: [5385] 41 <- i8042 (interrupt, 0, 1)
[ 9.919804] i8042: [5385] f5 -> i8042 (kbd-data)
[ 9.919904] i8042: [5385] fa <- i8042 (interrupt, 0, 1)
[ 9.919911] i8042: [5385] ed -> i8042 (kbd-data)
[ 9.920002] i8042: [5385] fa <- i8042 (interrupt, 0, 1)
[ 9.920008] i8042: [5385] 00 -> i8042 (kbd-data)
[ 9.920090] i8042: [5385] fa <- i8042 (interrupt, 0, 1)
[ 9.920096] i8042: [5385] f3 -> i8042 (kbd-data)
[ 9.920187] i8042: [5385] fa <- i8042 (interrupt, 0, 1)
[ 9.920193] i8042: [5385] 00 -> i8042 (kbd-data)
[ 9.920275] i8042: [5385] fa <- i8042 (interrupt, 0, 1)
[ 9.920297] i8042: [5385] f4 -> i8042 (kbd-data)
[ 9.920382] i8042: [5385] fa <- i8042 (interrupt, 0, 1)
[ 9.920467] input: AT Translated Set 2 keyboard as /devices/platform/i8042/serio0/input/input4
[ 9.920496] i8042: [5385] ed -> i8042 (kbd-data)
[ 9.920548] i8042: [5385] fa <- i8042 (interrupt, 0, 1)
[ 9.920565] i8042: [5386] 02 -> i8042 (kbd-data)
[ 9.920633] i8042: [5386] fa <- i8042 (interrupt, 0, 1)
[ 69.046947] i8042: unplug/plug mouse
[ 83.058924] i8042: [78550] 08 <- i8042 (interrupt, 1, 12)
[ 83.060059] i8042: [78551] 01 <- i8042 (interrupt, 1, 12)
[ 83.061148] i8042: [78552] 00 <- i8042 (interrupt, 1, 12)
[ 83.068677] i8042: [78560] 08 <- i8042 (interrupt, 1, 12)
[ 83.069762] i8042: [78561] 01 <- i8042 (interrupt, 1, 12)
[ 83.070889] i8042: [78562] 02 <- i8042 (interrupt, 1, 12)
[ 83.078429] i8042: [78570] 08 <- i8042 (interrupt, 1, 12)
[ 83.079556] i8042: [78571] 00 <- i8042 (interrupt, 1, 12)
[ 83.080644] i8042: [78572] 02 <- i8042 (interrupt, 1, 12)
[ 83.088178] i8042: [78579] 18 <- i8042 (interrupt, 1, 12)
[ 83.089263] i8042: [78580] ff <- i8042 (interrupt, 1, 12)
[ 83.090373] i8042: [78582] 01 <- i8042 (interrupt, 1, 12)
[ 83.097938] i8042: [78589] 18 <- i8042 (interrupt, 1, 12)
[ 83.099023] i8042: [78590] fc <- i8042 (interrupt, 1, 12)
[ 83.100109] i8042: [78591] 03 <- i8042 (interrupt, 1, 12)
[ 83.107684] i8042: [78599] 18 <- i8042 (interrupt, 1, 12)
[ 83.108770] i8042: [78600] f7 <- i8042 (interrupt, 1, 12)
[ 83.109856] i8042: [78601] 04 <- i8042 (interrupt, 1, 12)
[ 83.117423] i8042: [78609] 18 <- i8042 (interrupt, 1, 12)
[ 83.118508] i8042: [78610] f3 <- i8042 (interrupt, 1, 12)
[ 83.119643] i8042: [78611] 09 <- i8042 (interrupt, 1, 12)
[ 83.144059] i8042: [78635] 18 <- i8042 (interrupt, 1, 12)
[ 83.144987] i8042: [78636] f6 <- i8042 (interrupt, 1, 12)
[ 83.146789] i8042: [78638] 0c <- i8042 (interrupt, 1, 12)
[ 83.156050] i8042: [78647] 18 <- i8042 (interrupt, 1, 12)
[ 83.157136] i8042: [78648] 71 <- i8042 (interrupt, 1, 12)
[ 83.158223] i8042: [78649] 1e <- i8042 (interrupt, 1, 12)
[ 83.165798] i8042: [78657] 18 <- i8042 (interrupt, 1, 12)
[ 83.166884] i8042: [78658] c2 <- i8042 (interrupt, 1, 12)
[ 83.167970] i8042: [78659] 0b <- i8042 (interrupt, 1, 12)
[ 83.175558] i8042: [78667] 18 <- i8042 (interrupt, 1, 12)
[ 83.176640] i8042: [78668] bd <- i8042 (interrupt, 1, 12)
[ 83.177726] i8042: [78669] 0e <- i8042 (interrupt, 1, 12)
[ 83.185305] i8042: [78677] 18 <- i8042 (interrupt, 1, 12)
[ 83.186391] i8042: [78678] ba <- i8042 (interrupt, 1, 12)
[ 83.187476] i8042: [78679] 10 <- i8042 (interrupt, 1, 12)
[ 83.195055] i8042: [78686] 18 <- i8042 (interrupt, 1, 12)
[ 83.196142] i8042: [78687] b8 <- i8042 (interrupt, 1, 12)
[ 83.197228] i8042: [78688] 11 <- i8042 (interrupt, 1, 12)
[ 83.204795] i8042: [78696] 18 <- i8042 (interrupt, 1, 12)
[ 83.205882] i8042: [78697] b4 <- i8042 (interrupt, 1, 12)
[ 83.206976] i8042: [78698] 11 <- i8042 (interrupt, 1, 12)
[ 83.214546] i8042: [78706] 18 <- i8042 (interrupt, 1, 12)
[ 83.215628] i8042: [78707] b6 <- i8042 (interrupt, 1, 12)
[ 83.216697] i8042: [78708] 12 <- i8042 (interrupt, 1, 12)
[ 83.224302] i8042: [78716] 18 <- i8042 (interrupt, 1, 12)
[ 83.225388] i8042: [78717] bc <- i8042 (interrupt, 1, 12)
[ 83.226476] i8042: [78718] 10 <- i8042 (interrupt, 1, 12)
[ 83.234051] i8042: [78725] 18 <- i8042 (interrupt, 1, 12)
[ 83.235139] i8042: [78726] c2 <- i8042 (interrupt, 1, 12)
[ 83.236224] i8042: [78728] 0e <- i8042 (interrupt, 1, 12)
[ 83.243799] i8042: [78735] 18 <- i8042 (interrupt, 1, 12)
[ 83.244885] i8042: [78736] ca <- i8042 (interrupt, 1, 12)
[ 83.245972] i8042: [78737] 0c <- i8042 (interrupt, 1, 12)
[ 83.253541] i8042: [78745] 18 <- i8042 (interrupt, 1, 12)
[ 83.254623] i8042: [78746] d7 <- i8042 (interrupt, 1, 12)
[ 83.255698] i8042: [78747] 0a <- i8042 (interrupt, 1, 12)
[ 83.263268] i8042: [78755] 18 <- i8042 (interrupt, 1, 12)
[ 83.264354] i8042: [78756] e4 <- i8042 (interrupt, 1, 12)
[ 83.265492] i8042: [78757] 07 <- i8042 (interrupt, 1, 12)
[ 83.273022] i8042: [78764] 18 <- i8042 (interrupt, 1, 12)
[ 83.274107] i8042: [78765] f2 <- i8042 (interrupt, 1, 12)
[ 83.275194] i8042: [78766] 04 <- i8042 (interrupt, 1, 12)
[ 83.282770] i8042: [78774] 18 <- i8042 (interrupt, 1, 12)
[ 83.283856] i8042: [78775] fc <- i8042 (interrupt, 1, 12)
[ 83.284942] i8042: [78776] 01 <- i8042 (interrupt, 1, 12)
[ 83.312012] i8042: [78803] 28 <- i8042 (interrupt, 1, 12)
[ 83.313098] i8042: [78804] 00 <- i8042 (interrupt, 1, 12)
[ 83.314192] i8042: [78806] fe <- i8042 (interrupt, 1, 12)
[ 83.321763] i8042: [78813] 28 <- i8042 (interrupt, 1, 12)
[ 83.322849] i8042: [78814] 01 <- i8042 (interrupt, 1, 12)
[ 83.323936] i8042: [78815] fe <- i8042 (interrupt, 1, 12)
[ 83.331511] i8042: [78823] 28 <- i8042 (interrupt, 1, 12)
[ 83.332598] i8042: [78824] 00 <- i8042 (interrupt, 1, 12)
[ 83.333682] i8042: [78825] fe <- i8042 (interrupt, 1, 12)
[ 83.341260] i8042: [78833] 28 <- i8042 (interrupt, 1, 12)
[ 83.342345] i8042: [78834] 01 <- i8042 (interrupt, 1, 12)
[ 83.343431] i8042: [78835] ff <- i8042 (interrupt, 1, 12)
[ 83.351009] i8042: [78842] 08 <- i8042 (interrupt, 1, 12)
[ 83.352094] i8042: [78843] 01 <- i8042 (interrupt, 1, 12)
[ 83.353221] i8042: [78845] 00 <- i8042 (interrupt, 1, 12)
[-- Attachment #3: sentelic-disabled.log --]
[-- Type: text/plain, Size: 41843 bytes --]
[ 0.000000] Command line: BOOT_IMAGE=/vmlinuz-3.15.0-rc5+ root=/dev/mapper/rhel-root ro rd.lvm.lv=fedora/swap rd.lvm.lv=rhel/swap rd.lvm.lv=rhel/root vconsole.keymap=us crashkernel=auto vconsole.font=latarcyrheb-sun16 rd.lvm.lv=rhel/swap rhgb quiet LANG=en_US.UTF-8 i8042.debug=1
[ 0.000000] Kernel command line: BOOT_IMAGE=/vmlinuz-3.15.0-rc5+ root=/dev/mapper/rhel-root ro rd.lvm.lv=fedora/swap rd.lvm.lv=rhel/swap rd.lvm.lv=rhel/root vconsole.keymap=us crashkernel=auto vconsole.font=latarcyrheb-sun16 rd.lvm.lv=rhel/swap rhgb quiet LANG=en_US.UTF-8 i8042.debug=1
[ 4.534970] i8042: PNP: PS/2 Controller [PNP0f03:PS2M] at 0x60,0x64 irq 12
[ 4.534972] i8042: PNP: PS/2 controller doesn't have KBD irq; using default 1
[ 4.534983] i8042: [0] d1 -> i8042 (command)
[ 4.535040] i8042: [0] df -> i8042 (parameter)
[ 4.535096] i8042: [0] ff -> i8042 (command)
[ 4.535122] i8042: [0] 20 -> i8042 (command)
[ 4.535231] i8042: [0] 65 <- i8042 (return)
[ 4.535284] i8042: [0] 20 -> i8042 (command)
[ 4.535342] i8042: [0] 65 <- i8042 (return)
[ 4.535345] i8042: Warning: Keylock active
[ 4.535348] i8042: [0] 60 -> i8042 (command)
[ 4.535404] i8042: [0] 74 -> i8042 (parameter)
[ 4.535464] i8042: [0] d3 -> i8042 (command)
[ 4.535571] i8042: [0] 5a -> i8042 (parameter)
[ 4.535631] i8042: [0] 5a <- i8042 (return)
[ 4.535634] i8042: [0] a7 -> i8042 (command)
[ 4.535688] i8042: [0] 20 -> i8042 (command)
[ 4.535798] i8042: [0] 74 <- i8042 (return)
[ 4.535801] i8042: [0] a8 -> i8042 (command)
[ 4.535855] i8042: [1] 20 -> i8042 (command)
[ 4.535913] i8042: [1] 54 <- i8042 (return)
[ 4.535927] i8042: [1] 60 -> i8042 (command)
[ 4.535983] i8042: [1] 56 -> i8042 (parameter)
[ 4.536040] i8042: [1] d3 -> i8042 (command)
[ 4.536148] i8042: [1] a5 -> i8042 (parameter)
[ 4.536199] i8042: [1] a5 <- i8042 (aux_test_irq, aux)
[ 4.536208] i8042: [1] 60 -> i8042 (command)
[ 4.536265] i8042: [1] 74 -> i8042 (parameter)
[ 4.536331] i8042: [1] d3 -> i8042 (command)
[ 4.536439] i8042: [1] f0 -> i8042 (parameter)
[ 4.536499] i8042: [1] f0 <- i8042 (return)
[ 4.536502] i8042: [1] d3 -> i8042 (command)
[ 4.536558] i8042: [1] 56 -> i8042 (parameter)
[ 4.536618] i8042: [1] 56 <- i8042 (return)
[ 4.536620] i8042: [1] d3 -> i8042 (command)
[ 4.536728] i8042: [1] a4 -> i8042 (parameter)
[ 4.536788] i8042: [1] a4 <- i8042 (return)
[ 4.536802] i8042: [1] 60 -> i8042 (command)
[ 4.536858] i8042: [2] 56 -> i8042 (parameter)
[ 4.536878] i8042: [2] Interrupt 1, without any data
[ 4.536935] i8042: [2] 60 -> i8042 (command)
[ 4.537043] i8042: [2] 47 -> i8042 (parameter)
[ 4.537046] serio: i8042 KBD port at 0x60,0x64 irq 1
[ 4.537051] serio: i8042 AUX port at 0x60,0x64 irq 12
[ 4.537482] i8042: [2] d4 -> i8042 (command)
[ 4.537539] i8042: [2] f2 -> i8042 (parameter)
[ 4.539893] i8042: [5] fa <- i8042 (interrupt, 1, 12)
[ 4.541018] i8042: [6] 03 <- i8042 (interrupt, 1, 12)
[ 4.541033] i8042: [6] d4 -> i8042 (command)
[ 4.541090] i8042: [6] f6 -> i8042 (parameter)
[ 4.543443] i8042: [8] fa <- i8042 (interrupt, 1, 12)
[ 4.543460] i8042: [8] d4 -> i8042 (command)
[ 4.543621] i8042: [8] f3 -> i8042 (parameter)
[ 4.543702] i8042: [8] fa <- i8042 (interrupt, 1, 12)
[ 4.543708] i8042: [8] d4 -> i8042 (command)
[ 4.543764] i8042: [8] 0a -> i8042 (parameter)
[ 4.548355] i8042: [13] fa <- i8042 (interrupt, 1, 12)
[ 4.548376] i8042: [13] d4 -> i8042 (command)
[ 4.548537] i8042: [13] e8 -> i8042 (parameter)
[ 4.548628] i8042: [13] fa <- i8042 (interrupt, 1, 12)
[ 4.548633] i8042: [13] d4 -> i8042 (command)
[ 4.548741] i8042: [13] 00 -> i8042 (parameter)
[ 4.553160] i8042: [18] fa <- i8042 (interrupt, 1, 12)
[ 4.553174] i8042: [18] d4 -> i8042 (command)
[ 4.553283] i8042: [18] f3 -> i8042 (parameter)
[ 4.553335] i8042: [18] fa <- i8042 (interrupt, 1, 12)
[ 4.553340] i8042: [18] d4 -> i8042 (command)
[ 4.553448] i8042: [18] 14 -> i8042 (parameter)
[ 4.557862] i8042: [23] fa <- i8042 (interrupt, 1, 12)
[ 4.557878] i8042: [23] d4 -> i8042 (command)
[ 4.557934] i8042: [23] f3 -> i8042 (parameter)
[ 4.558001] i8042: [23] fa <- i8042 (interrupt, 1, 12)
[ 4.558007] i8042: [23] d4 -> i8042 (command)
[ 4.558115] i8042: [23] 3c -> i8042 (parameter)
[ 4.562503] i8042: [27] fa <- i8042 (interrupt, 1, 12)
[ 4.562515] i8042: [27] d4 -> i8042 (command)
[ 4.562623] i8042: [27] f3 -> i8042 (parameter)
[ 4.562677] i8042: [27] fa <- i8042 (interrupt, 1, 12)
[ 4.562682] i8042: [27] d4 -> i8042 (command)
[ 4.562790] i8042: [27] 28 -> i8042 (parameter)
[ 4.567182] i8042: [32] fa <- i8042 (interrupt, 1, 12)
[ 4.572087] i8042: [37] d4 -> i8042 (command)
[ 4.572144] i8042: [37] f3 -> i8042 (parameter)
[ 4.572212] i8042: [37] fa <- i8042 (interrupt, 1, 12)
[ 4.572221] i8042: [37] d4 -> i8042 (command)
[ 4.572278] i8042: [37] 14 -> i8042 (parameter)
[ 4.576691] i8042: [41] fa <- i8042 (interrupt, 1, 12)
[ 4.576700] i8042: [41] d4 -> i8042 (command)
[ 4.576809] i8042: [41] f3 -> i8042 (parameter)
[ 4.576875] i8042: [42] fa <- i8042 (interrupt, 1, 12)
[ 4.576880] i8042: [42] d4 -> i8042 (command)
[ 4.576937] i8042: [42] 14 -> i8042 (parameter)
[ 4.581376] i8042: [46] fa <- i8042 (interrupt, 1, 12)
[ 4.581383] i8042: [46] d4 -> i8042 (command)
[ 4.581492] i8042: [46] f3 -> i8042 (parameter)
[ 4.581553] i8042: [46] fa <- i8042 (interrupt, 1, 12)
[ 4.581558] i8042: [46] d4 -> i8042 (command)
[ 4.581667] i8042: [46] 3c -> i8042 (parameter)
[ 4.586136] i8042: [51] fa <- i8042 (interrupt, 1, 12)
[ 4.586152] i8042: [51] d4 -> i8042 (command)
[ 4.586262] i8042: [51] f3 -> i8042 (parameter)
[ 4.586314] i8042: [51] fa <- i8042 (interrupt, 1, 12)
[ 4.586321] i8042: [51] d4 -> i8042 (command)
[ 4.586430] i8042: [51] 28 -> i8042 (parameter)
[ 4.590832] i8042: [55] fa <- i8042 (interrupt, 1, 12)
[ 4.590876] i8042: [56] d4 -> i8042 (command)
[ 4.591040] i8042: [56] f3 -> i8042 (parameter)
[ 4.591111] i8042: [56] fa <- i8042 (interrupt, 1, 12)
[ 4.591119] i8042: [56] d4 -> i8042 (command)
[ 4.591228] i8042: [56] 14 -> i8042 (parameter)
[ 4.595668] i8042: [60] fa <- i8042 (interrupt, 1, 12)
[ 4.595693] i8042: [60] d4 -> i8042 (command)
[ 4.595751] i8042: [60] f3 -> i8042 (parameter)
[ 4.595822] i8042: [60] fa <- i8042 (interrupt, 1, 12)
[ 4.595837] i8042: [61] d4 -> i8042 (command)
[ 4.595894] i8042: [61] 14 -> i8042 (parameter)
[ 4.600434] i8042: [65] fa <- i8042 (interrupt, 1, 12)
[ 4.600461] i8042: [65] d4 -> i8042 (command)
[ 4.600519] i8042: [65] f2 -> i8042 (parameter)
[ 4.602853] i8042: [68] fa <- i8042 (interrupt, 1, 12)
[ 4.603972] i8042: [69] 03 <- i8042 (interrupt, 1, 12)
[ 4.604000] i8042: [69] d4 -> i8042 (command)
[ 4.604110] i8042: [69] e8 -> i8042 (parameter)
[ 4.604189] i8042: [69] fa <- i8042 (interrupt, 1, 12)
[ 4.604196] i8042: [69] d4 -> i8042 (command)
[ 4.604305] i8042: [69] 00 -> i8042 (parameter)
[ 4.608860] i8042: [74] fa <- i8042 (interrupt, 1, 12)
[ 4.608904] i8042: [74] d4 -> i8042 (command)
[ 4.609072] i8042: [74] e8 -> i8042 (parameter)
[ 4.609139] i8042: [74] fa <- i8042 (interrupt, 1, 12)
[ 4.609146] i8042: [74] d4 -> i8042 (command)
[ 4.609255] i8042: [74] 00 -> i8042 (parameter)
[ 4.613766] i8042: [78] fa <- i8042 (interrupt, 1, 12)
[ 4.613794] i8042: [78] d4 -> i8042 (command)
[ 4.613852] i8042: [79] e8 -> i8042 (parameter)
[ 4.613917] i8042: [79] fa <- i8042 (interrupt, 1, 12)
[ 4.613924] i8042: [79] d4 -> i8042 (command)
[ 4.614033] i8042: [79] 00 -> i8042 (parameter)
[ 4.618451] i8042: [83] fa <- i8042 (interrupt, 1, 12)
[ 4.618479] i8042: [83] d4 -> i8042 (command)
[ 4.618641] i8042: [83] e8 -> i8042 (parameter)
[ 4.618721] i8042: [83] fa <- i8042 (interrupt, 1, 12)
[ 4.618728] i8042: [83] d4 -> i8042 (command)
[ 4.618838] i8042: [84] 00 -> i8042 (parameter)
[ 4.623357] i8042: [88] fa <- i8042 (interrupt, 1, 12)
[ 4.623385] i8042: [88] d4 -> i8042 (command)
[ 4.623444] i8042: [88] e9 -> i8042 (parameter)
[ 4.625778] i8042: [90] fa <- i8042 (interrupt, 1, 12)
[ 4.629080] i8042: [94] 00 <- i8042 (interrupt, 1, 12)
[ 4.629126] i8042: [94] 00 <- i8042 (interrupt, 1, 12)
[ 4.629187] i8042: [94] 14 <- i8042 (interrupt, 1, 12)
[ 4.629196] i8042: [94] d4 -> i8042 (command)
[ 4.629305] i8042: [94] e8 -> i8042 (parameter)
[ 4.629366] i8042: [94] fa <- i8042 (interrupt, 1, 12)
[ 4.629373] i8042: [94] d4 -> i8042 (command)
[ 4.629482] i8042: [94] 00 -> i8042 (parameter)
[ 4.634040] i8042: [99] fa <- i8042 (interrupt, 1, 12)
[ 4.634069] i8042: [99] d4 -> i8042 (command)
[ 4.634127] i8042: [99] e8 -> i8042 (parameter)
[ 4.634205] i8042: [99] fa <- i8042 (interrupt, 1, 12)
[ 4.634212] i8042: [99] d4 -> i8042 (command)
[ 4.634321] i8042: [99] 00 -> i8042 (parameter)
[ 4.638881] i8042: [104] fa <- i8042 (interrupt, 1, 12)
[ 4.638909] i8042: [104] d4 -> i8042 (command)
[ 4.639227] i8042: [104] e8 -> i8042 (parameter)
[ 4.639300] i8042: [104] fa <- i8042 (interrupt, 1, 12)
[ 4.639307] i8042: [104] d4 -> i8042 (command)
[ 4.639417] i8042: [104] 00 -> i8042 (parameter)
[ 4.643865] i8042: [109] fa <- i8042 (interrupt, 1, 12)
[ 4.643893] i8042: [109] d4 -> i8042 (command)
[ 4.643952] i8042: [109] e8 -> i8042 (parameter)
[ 4.644030] i8042: [109] fa <- i8042 (interrupt, 1, 12)
[ 4.644037] i8042: [109] d4 -> i8042 (command)
[ 4.644146] i8042: [109] 00 -> i8042 (parameter)
[ 4.648704] i8042: [113] fa <- i8042 (interrupt, 1, 12)
[ 4.648732] i8042: [113] d4 -> i8042 (command)
[ 4.648894] i8042: [114] e9 -> i8042 (parameter)
[ 4.651272] i8042: [116] fa <- i8042 (interrupt, 1, 12)
[ 4.654575] i8042: [119] 00 <- i8042 (interrupt, 1, 12)
[ 4.654615] i8042: [119] 00 <- i8042 (interrupt, 1, 12)
[ 4.654681] i8042: [119] 14 <- i8042 (interrupt, 1, 12)
[ 4.850762] i8042: [316] d4 -> i8042 (command)
[ 4.850822] i8042: [316] f6 -> i8042 (parameter)
[ 4.853174] i8042: [318] fa <- i8042 (interrupt, 1, 12)
[ 4.853192] i8042: [318] d4 -> i8042 (command)
[ 4.853302] i8042: [318] e8 -> i8042 (parameter)
[ 4.855690] i8042: [320] fa <- i8042 (interrupt, 1, 12)
[ 4.855702] i8042: [320] d4 -> i8042 (command)
[ 4.855811] i8042: [321] 00 -> i8042 (parameter)
[ 4.869959] i8042: [335] fa <- i8042 (interrupt, 1, 12)
[ 4.869987] i8042: [335] d4 -> i8042 (command)
[ 4.879793] i8042: [345] e6 -> i8042 (parameter)
[ 4.882914] i8042: [348] fa <- i8042 (interrupt, 1, 12)
[ 4.882942] i8042: [348] d4 -> i8042 (command)
[ 4.883000] i8042: [348] e6 -> i8042 (parameter)
[ 4.886188] i8042: [351] fa <- i8042 (interrupt, 1, 12)
[ 4.886216] i8042: [351] d4 -> i8042 (command)
[ 4.887052] i8042: [352] e6 -> i8042 (parameter)
[ 4.890242] i8042: [355] fa <- i8042 (interrupt, 1, 12)
[ 4.890270] i8042: [355] d4 -> i8042 (command)
[ 4.891106] i8042: [356] e9 -> i8042 (parameter)
[ 4.893431] i8042: [358] fa <- i8042 (interrupt, 1, 12)
[ 4.896860] i8042: [362] 1a <- i8042 (interrupt, 1, 12)
[ 4.896913] i8042: [362] 03 <- i8042 (interrupt, 1, 12)
[ 4.896978] i8042: [362] 3c <- i8042 (interrupt, 1, 12)
[ 4.896988] i8042: [362] d4 -> i8042 (command)
[ 4.897097] i8042: [362] f6 -> i8042 (parameter)
[ 4.899419] i8042: [364] fa <- i8042 (interrupt, 1, 12)
[ 4.899443] i8042: [364] d4 -> i8042 (command)
[ 4.899553] i8042: [364] f5 -> i8042 (parameter)
[ 4.901850] i8042: [367] fa <- i8042 (interrupt, 1, 12)
[ 4.901879] i8042: [367] d4 -> i8042 (command)
[ 4.901937] i8042: [367] e6 -> i8042 (parameter)
[ 4.904267] i8042: [369] fa <- i8042 (interrupt, 1, 12)
[ 4.904295] i8042: [369] d4 -> i8042 (command)
[ 4.904353] i8042: [369] e6 -> i8042 (parameter)
[ 4.906686] i8042: [371] fa <- i8042 (interrupt, 1, 12)
[ 4.906715] i8042: [371] d4 -> i8042 (command)
[ 4.906774] i8042: [372] e6 -> i8042 (parameter)
[ 4.909083] i8042: [374] fa <- i8042 (interrupt, 1, 12)
[ 4.909112] i8042: [374] d4 -> i8042 (command)
[ 4.909327] i8042: [374] e9 -> i8042 (parameter)
[ 4.911682] i8042: [376] fa <- i8042 (interrupt, 1, 12)
[ 4.914988] i8042: [380] 1a <- i8042 (interrupt, 1, 12)
[ 4.915036] i8042: [380] 03 <- i8042 (interrupt, 1, 12)
[ 4.915079] i8042: [380] 3c <- i8042 (interrupt, 1, 12)
[ 4.915088] i8042: [380] d4 -> i8042 (command)
[ 4.915198] i8042: [380] e8 -> i8042 (parameter)
[ 4.915243] i8042: [380] fa <- i8042 (interrupt, 1, 12)
[ 4.915249] i8042: [380] d4 -> i8042 (command)
[ 4.915358] i8042: [380] 03 -> i8042 (parameter)
[ 4.919760] i8042: [385] fa <- i8042 (interrupt, 1, 12)
[ 4.919773] i8042: [385] d4 -> i8042 (command)
[ 4.919883] i8042: [385] e6 -> i8042 (parameter)
[ 4.922200] i8042: [387] fa <- i8042 (interrupt, 1, 12)
[ 4.922230] i8042: [387] d4 -> i8042 (command)
[ 4.922392] i8042: [387] e6 -> i8042 (parameter)
[ 4.924779] i8042: [390] fa <- i8042 (interrupt, 1, 12)
[ 4.924808] i8042: [390] d4 -> i8042 (command)
[ 4.924866] i8042: [390] e6 -> i8042 (parameter)
[ 4.927167] i8042: [392] fa <- i8042 (interrupt, 1, 12)
[ 4.927185] i8042: [392] d4 -> i8042 (command)
[ 4.927295] i8042: [392] e9 -> i8042 (parameter)
[ 4.929599] i8042: [394] fa <- i8042 (interrupt, 1, 12)
[ 4.932898] i8042: [398] 1a <- i8042 (interrupt, 1, 12)
[ 4.933044] i8042: [398] 03 <- i8042 (interrupt, 1, 12)
[ 4.933137] i8042: [398] 3c <- i8042 (interrupt, 1, 12)
[ 4.933146] i8042: [398] d4 -> i8042 (command)
[ 4.933255] i8042: [398] e8 -> i8042 (parameter)
[ 4.933302] i8042: [398] fa <- i8042 (interrupt, 1, 12)
[ 4.933309] i8042: [398] d4 -> i8042 (command)
[ 4.933418] i8042: [398] 00 -> i8042 (parameter)
[ 4.937934] i8042: [403] fa <- i8042 (interrupt, 1, 12)
[ 4.937952] i8042: [403] d4 -> i8042 (command)
[ 4.938061] i8042: [403] e6 -> i8042 (parameter)
[ 4.940355] i8042: [405] fa <- i8042 (interrupt, 1, 12)
[ 4.941719] i8042: [407] d4 -> i8042 (command)
[ 4.941778] i8042: [407] e6 -> i8042 (parameter)
[ 4.944102] i8042: [409] fa <- i8042 (interrupt, 1, 12)
[ 4.944146] i8042: [409] d4 -> i8042 (command)
[ 4.944204] i8042: [409] e6 -> i8042 (parameter)
[ 4.946507] i8042: [411] fa <- i8042 (interrupt, 1, 12)
[ 4.951208] i8042: [416] d4 -> i8042 (command)
[ 4.951266] i8042: [416] e9 -> i8042 (parameter)
[ 4.953610] i8042: [418] fa <- i8042 (interrupt, 1, 12)
[ 4.957041] i8042: [422] 1a <- i8042 (interrupt, 1, 12)
[ 4.957099] i8042: [422] 03 <- i8042 (interrupt, 1, 12)
[ 4.957157] i8042: [422] 3c <- i8042 (interrupt, 1, 12)
[ 4.957202] i8042: [422] d4 -> i8042 (command)
[ 4.957260] i8042: [422] e6 -> i8042 (parameter)
[ 4.959612] i8042: [424] fa <- i8042 (interrupt, 1, 12)
[ 4.959630] i8042: [424] d4 -> i8042 (command)
[ 4.959740] i8042: [425] e8 -> i8042 (parameter)
[ 4.959780] i8042: [425] fa <- i8042 (interrupt, 1, 12)
[ 4.959791] i8042: [425] d4 -> i8042 (command)
[ 4.959849] i8042: [425] 00 -> i8042 (parameter)
[ 4.964367] i8042: [429] fa <- i8042 (interrupt, 1, 12)
[ 4.964384] i8042: [429] d4 -> i8042 (command)
[ 4.964494] i8042: [429] e8 -> i8042 (parameter)
[ 4.964549] i8042: [429] fa <- i8042 (interrupt, 1, 12)
[ 4.964557] i8042: [429] d4 -> i8042 (command)
[ 4.964666] i8042: [429] 03 -> i8042 (parameter)
[ 4.969045] i8042: [434] fa <- i8042 (interrupt, 1, 12)
[ 4.969057] i8042: [434] d4 -> i8042 (command)
[ 4.969271] i8042: [434] e8 -> i8042 (parameter)
[ 4.969347] i8042: [434] fa <- i8042 (interrupt, 1, 12)
[ 4.969355] i8042: [434] d4 -> i8042 (command)
[ 4.969465] i8042: [434] 02 -> i8042 (parameter)
[ 4.973873] i8042: [439] fa <- i8042 (interrupt, 1, 12)
[ 4.973888] i8042: [439] d4 -> i8042 (command)
[ 4.973998] i8042: [439] e8 -> i8042 (parameter)
[ 4.974047] i8042: [439] fa <- i8042 (interrupt, 1, 12)
[ 4.974053] i8042: [439] d4 -> i8042 (command)
[ 4.974162] i8042: [439] 01 -> i8042 (parameter)
[ 4.978559] i8042: [443] fa <- i8042 (interrupt, 1, 12)
[ 4.978575] i8042: [443] d4 -> i8042 (command)
[ 4.978684] i8042: [443] eb -> i8042 (parameter)
[ 4.980975] i8042: [446] fa <- i8042 (interrupt, 1, 12)
[ 4.984279] i8042: [449] 08 <- i8042 (interrupt, 1, 12)
[ 4.984339] i8042: [449] 00 <- i8042 (interrupt, 1, 12)
[ 4.984407] i8042: [449] 00 <- i8042 (interrupt, 1, 12)
[ 4.984422] i8042: [449] d4 -> i8042 (command)
[ 4.984479] i8042: [449] e6 -> i8042 (parameter)
[ 4.986815] i8042: [452] fa <- i8042 (interrupt, 1, 12)
[ 4.986829] i8042: [452] d4 -> i8042 (command)
[ 4.986939] i8042: [452] e8 -> i8042 (parameter)
[ 4.986988] i8042: [452] fa <- i8042 (interrupt, 1, 12)
[ 4.986994] i8042: [452] d4 -> i8042 (command)
[ 4.987103] i8042: [452] 03 -> i8042 (parameter)
[ 4.991497] i8042: [456] fa <- i8042 (interrupt, 1, 12)
[ 4.991510] i8042: [456] d4 -> i8042 (command)
[ 4.991620] i8042: [456] e8 -> i8042 (parameter)
[ 4.991670] i8042: [456] fa <- i8042 (interrupt, 1, 12)
[ 4.991676] i8042: [456] d4 -> i8042 (command)
[ 4.991785] i8042: [457] 01 -> i8042 (parameter)
[ 4.996175] i8042: [461] fa <- i8042 (interrupt, 1, 12)
[ 4.996188] i8042: [461] d4 -> i8042 (command)
[ 4.996403] i8042: [461] e8 -> i8042 (parameter)
[ 4.996486] i8042: [461] fa <- i8042 (interrupt, 1, 12)
[ 4.996493] i8042: [461] d4 -> i8042 (command)
[ 4.996602] i8042: [461] 02 -> i8042 (parameter)
[ 5.001097] i8042: [466] fa <- i8042 (interrupt, 1, 12)
[ 5.001110] i8042: [466] d4 -> i8042 (command)
[ 5.001220] i8042: [466] e8 -> i8042 (parameter)
[ 5.001280] i8042: [466] fa <- i8042 (interrupt, 1, 12)
[ 5.001287] i8042: [466] d4 -> i8042 (command)
[ 5.001396] i8042: [466] 03 -> i8042 (parameter)
[ 5.005855] i8042: [471] fa <- i8042 (interrupt, 1, 12)
[ 5.005871] i8042: [471] d4 -> i8042 (command)
[ 5.005982] i8042: [471] eb -> i8042 (parameter)
[ 5.008276] i8042: [473] fa <- i8042 (interrupt, 1, 12)
[ 5.011579] i8042: [476] 08 <- i8042 (interrupt, 1, 12)
[ 5.011639] i8042: [476] 00 <- i8042 (interrupt, 1, 12)
[ 5.011705] i8042: [477] 00 <- i8042 (interrupt, 1, 12)
[ 5.011719] i8042: [477] d4 -> i8042 (command)
[ 5.011828] i8042: [477] e1 -> i8042 (parameter)
[ 5.014123] i8042: [479] fe <- i8042 (interrupt, 1, 12)
[ 5.014138] i8042: [479] d4 -> i8042 (command)
[ 5.014248] i8042: [479] f6 -> i8042 (parameter)
[ 5.016532] i8042: [481] fa <- i8042 (interrupt, 1, 12)
[ 5.016545] i8042: [481] d4 -> i8042 (command)
[ 5.016656] i8042: [481] ff -> i8042 (parameter)
[ 5.018957] i8042: [484] fa <- i8042 (interrupt, 1, 12)
[ 5.411767] i8042: [877] aa <- i8042 (interrupt, 1, 12)
[ 5.411911] i8042: [877] 00 <- i8042 (interrupt, 1, 12)
[ 5.411927] i8042: [877] d4 -> i8042 (command)
[ 5.412193] i8042: [877] f3 -> i8042 (parameter)
[ 5.412567] i8042: [878] fa <- i8042 (interrupt, 1, 12)
[ 5.412712] i8042: [878] d4 -> i8042 (command)
[ 5.412771] i8042: [878] c8 -> i8042 (parameter)
[ 5.417209] i8042: [882] fa <- i8042 (interrupt, 1, 12)
[ 5.417238] i8042: [882] d4 -> i8042 (command)
[ 5.417296] i8042: [882] f3 -> i8042 (parameter)
[ 5.417383] i8042: [882] fa <- i8042 (interrupt, 1, 12)
[ 5.417390] i8042: [882] d4 -> i8042 (command)
[ 5.417499] i8042: [882] 64 -> i8042 (parameter)
[ 5.422050] i8042: [887] fa <- i8042 (interrupt, 1, 12)
[ 5.422080] i8042: [887] d4 -> i8042 (command)
[ 5.422242] i8042: [887] f3 -> i8042 (parameter)
[ 5.422351] i8042: [887] fa <- i8042 (interrupt, 1, 12)
[ 5.422358] i8042: [887] d4 -> i8042 (command)
[ 5.422467] i8042: [887] 50 -> i8042 (parameter)
[ 5.426961] i8042: [892] fa <- i8042 (interrupt, 1, 12)
[ 5.426991] i8042: [892] d4 -> i8042 (command)
[ 5.427049] i8042: [892] f2 -> i8042 (parameter)
[ 5.429456] i8042: [894] fa <- i8042 (interrupt, 1, 12)
[ 5.430702] i8042: [896] 03 <- i8042 (interrupt, 1, 12)
[ 5.430730] i8042: [896] d4 -> i8042 (command)
[ 5.430840] i8042: [896] f3 -> i8042 (parameter)
[ 5.430881] i8042: [896] fa <- i8042 (interrupt, 1, 12)
[ 5.430888] i8042: [896] d4 -> i8042 (command)
[ 5.430998] i8042: [896] c8 -> i8042 (parameter)
[ 5.435538] i8042: [901] fa <- i8042 (interrupt, 1, 12)
[ 5.435567] i8042: [901] d4 -> i8042 (command)
[ 5.435625] i8042: [901] f3 -> i8042 (parameter)
[ 5.435692] i8042: [901] fa <- i8042 (interrupt, 1, 12)
[ 5.435699] i8042: [901] d4 -> i8042 (command)
[ 5.435808] i8042: [901] c8 -> i8042 (parameter)
[ 5.440293] i8042: [905] fa <- i8042 (interrupt, 1, 12)
[ 5.440322] i8042: [905] d4 -> i8042 (command)
[ 5.440380] i8042: [905] f3 -> i8042 (parameter)
[ 5.440448] i8042: [905] fa <- i8042 (interrupt, 1, 12)
[ 5.440455] i8042: [905] d4 -> i8042 (command)
[ 5.440564] i8042: [906] 50 -> i8042 (parameter)
[ 5.444968] i8042: [910] fa <- i8042 (interrupt, 1, 12)
[ 5.444996] i8042: [910] d4 -> i8042 (command)
[ 5.445054] i8042: [910] f2 -> i8042 (parameter)
[ 5.447393] i8042: [912] fa <- i8042 (interrupt, 1, 12)
[ 5.448487] i8042: [913] 03 <- i8042 (interrupt, 1, 12)
[ 5.448508] i8042: [913] d4 -> i8042 (command)
[ 5.448566] i8042: [914] f3 -> i8042 (parameter)
[ 5.448652] i8042: [914] fa <- i8042 (interrupt, 1, 12)
[ 5.448673] i8042: [914] d4 -> i8042 (command)
[ 5.448730] i8042: [914] c8 -> i8042 (parameter)
[ 5.453294] i8042: [918] fa <- i8042 (interrupt, 1, 12)
[ 5.453314] i8042: [918] d4 -> i8042 (command)
[ 5.453528] i8042: [919] f3 -> i8042 (parameter)
[ 5.453597] i8042: [919] fa <- i8042 (interrupt, 1, 12)
[ 5.453609] i8042: [919] d4 -> i8042 (command)
[ 5.453668] i8042: [919] 64 -> i8042 (parameter)
[ 5.458206] i8042: [923] fa <- i8042 (interrupt, 1, 12)
[ 5.458217] i8042: [923] d4 -> i8042 (command)
[ 5.458326] i8042: [923] f3 -> i8042 (parameter)
[ 5.458383] i8042: [923] fa <- i8042 (interrupt, 1, 12)
[ 5.458389] i8042: [923] d4 -> i8042 (command)
[ 5.458499] i8042: [923] 50 -> i8042 (parameter)
[ 5.462881] i8042: [928] fa <- i8042 (interrupt, 1, 12)
[ 5.462901] i8042: [928] d4 -> i8042 (command)
[ 5.463010] i8042: [928] f2 -> i8042 (parameter)
[ 5.465298] i8042: [930] fa <- i8042 (interrupt, 1, 12)
[ 5.466566] i8042: [932] 03 <- i8042 (interrupt, 1, 12)
[ 5.466586] i8042: [932] d4 -> i8042 (command)
[ 5.466643] i8042: [932] f3 -> i8042 (parameter)
[ 5.466709] i8042: [932] fa <- i8042 (interrupt, 1, 12)
[ 5.466716] i8042: [932] d4 -> i8042 (command)
[ 5.466825] i8042: [932] 64 -> i8042 (parameter)
[ 5.471314] i8042: [936] fa <- i8042 (interrupt, 1, 12)
[ 5.471330] i8042: [936] d4 -> i8042 (command)
[ 5.471439] i8042: [936] e8 -> i8042 (parameter)
[ 5.471486] i8042: [936] fa <- i8042 (interrupt, 1, 12)
[ 5.471492] i8042: [936] d4 -> i8042 (command)
[ 5.471602] i8042: [937] 03 -> i8042 (parameter)
[ 5.476072] i8042: [941] fa <- i8042 (interrupt, 1, 12)
[ 5.476083] i8042: [941] d4 -> i8042 (command)
[ 5.476192] i8042: [941] e6 -> i8042 (parameter)
[ 5.478496] i8042: [943] fa <- i8042 (interrupt, 1, 12)
[ 5.478588] input: ImPS/2 Logitech Wheel Mouse as /devices/platform/i8042/serio1/input/input2
[ 5.478746] i8042: [944] d4 -> i8042 (command)
[ 5.478804] i8042: [944] f4 -> i8042 (parameter)
[ 5.481152] i8042: [946] fa <- i8042 (interrupt, 1, 12)
[ 5.481187] i8042: [946] f2 -> i8042 (kbd-data)
[ 5.481266] i8042: [946] fa <- i8042 (interrupt, 0, 1)
[ 5.481333] i8042: [946] ab <- i8042 (interrupt, 0, 1)
[ 5.481402] i8042: [946] 41 <- i8042 (interrupt, 0, 1)
[ 5.481409] i8042: [946] f5 -> i8042 (kbd-data)
[ 5.481509] i8042: [947] fa <- i8042 (interrupt, 0, 1)
[ 5.481525] i8042: [947] ed -> i8042 (kbd-data)
[ 5.481607] i8042: [947] fa <- i8042 (interrupt, 0, 1)
[ 5.481613] i8042: [947] 00 -> i8042 (kbd-data)
[ 5.481695] i8042: [947] fa <- i8042 (interrupt, 0, 1)
[ 5.481702] i8042: [947] f3 -> i8042 (kbd-data)
[ 5.481801] i8042: [947] fa <- i8042 (interrupt, 0, 1)
[ 5.481807] i8042: [947] 00 -> i8042 (kbd-data)
[ 5.481889] i8042: [947] fa <- i8042 (interrupt, 0, 1)
[ 5.481918] i8042: [947] f4 -> i8042 (kbd-data)
[ 5.481996] i8042: [947] fa <- i8042 (interrupt, 0, 1)
[ 5.482069] input: AT Translated Set 2 keyboard as /devices/platform/i8042/serio0/input/input3
[ 5.482095] i8042: [947] ed -> i8042 (kbd-data)
[ 5.482152] i8042: [947] fa <- i8042 (interrupt, 0, 1)
[ 5.482176] i8042: [947] 02 -> i8042 (kbd-data)
[ 5.482239] i8042: [947] fa <- i8042 (interrupt, 0, 1)
[ 73.720606] i8042: [69210] 08 <- i8042 (interrupt, 1, 12)
[ 73.721701] i8042: [69211] 01 <- i8042 (interrupt, 1, 12)
[ 73.722790] i8042: [69212] 00 <- i8042 (interrupt, 1, 12)
[ 73.723877] i8042: [69213] 00 <- i8042 (interrupt, 1, 12)
[ 73.730359] i8042: [69220] 08 <- i8042 (interrupt, 1, 12)
[ 73.731446] i8042: [69221] 03 <- i8042 (interrupt, 1, 12)
[ 73.732535] i8042: [69222] 02 <- i8042 (interrupt, 1, 12)
[ 73.733622] i8042: [69223] 00 <- i8042 (interrupt, 1, 12)
[ 73.740111] i8042: [69230] 08 <- i8042 (interrupt, 1, 12)
[ 73.741198] i8042: [69231] 0a <- i8042 (interrupt, 1, 12)
[ 73.742285] i8042: [69232] 04 <- i8042 (interrupt, 1, 12)
[ 73.743371] i8042: [69233] 00 <- i8042 (interrupt, 1, 12)
[ 73.749859] i8042: [69239] 08 <- i8042 (interrupt, 1, 12)
[ 73.750945] i8042: [69240] 0f <- i8042 (interrupt, 1, 12)
[ 73.752032] i8042: [69242] 03 <- i8042 (interrupt, 1, 12)
[ 73.753250] i8042: [69243] 00 <- i8042 (interrupt, 1, 12)
[ 73.759617] i8042: [69249] 08 <- i8042 (interrupt, 1, 12)
[ 73.760705] i8042: [69250] 16 <- i8042 (interrupt, 1, 12)
[ 73.761794] i8042: [69251] 01 <- i8042 (interrupt, 1, 12)
[ 73.762881] i8042: [69252] 00 <- i8042 (interrupt, 1, 12)
[ 73.769364] i8042: [69259] 08 <- i8042 (interrupt, 1, 12)
[ 73.770458] i8042: [69260] 1a <- i8042 (interrupt, 1, 12)
[ 73.771544] i8042: [69261] 00 <- i8042 (interrupt, 1, 12)
[ 73.772630] i8042: [69262] 00 <- i8042 (interrupt, 1, 12)
[ 73.779109] i8042: [69269] 28 <- i8042 (interrupt, 1, 12)
[ 73.780196] i8042: [69270] 1e <- i8042 (interrupt, 1, 12)
[ 73.781281] i8042: [69271] ff <- i8042 (interrupt, 1, 12)
[ 73.782376] i8042: [69272] 00 <- i8042 (interrupt, 1, 12)
[ 73.788854] i8042: [69278] 28 <- i8042 (interrupt, 1, 12)
[ 73.789938] i8042: [69279] 1f <- i8042 (interrupt, 1, 12)
[ 73.791026] i8042: [69281] fe <- i8042 (interrupt, 1, 12)
[ 73.792112] i8042: [69282] 00 <- i8042 (interrupt, 1, 12)
[ 73.798599] i8042: [69288] 28 <- i8042 (interrupt, 1, 12)
[ 73.799683] i8042: [69289] 22 <- i8042 (interrupt, 1, 12)
[ 73.800769] i8042: [69290] fc <- i8042 (interrupt, 1, 12)
[ 73.801855] i8042: [69291] 00 <- i8042 (interrupt, 1, 12)
[ 73.808344] i8042: [69298] 28 <- i8042 (interrupt, 1, 12)
[ 73.809429] i8042: [69299] 22 <- i8042 (interrupt, 1, 12)
[ 73.810516] i8042: [69300] fa <- i8042 (interrupt, 1, 12)
[ 73.811601] i8042: [69301] 00 <- i8042 (interrupt, 1, 12)
[ 73.818088] i8042: [69308] 28 <- i8042 (interrupt, 1, 12)
[ 73.819174] i8042: [69309] 23 <- i8042 (interrupt, 1, 12)
[ 73.820244] i8042: [69310] fa <- i8042 (interrupt, 1, 12)
[ 73.821351] i8042: [69311] 00 <- i8042 (interrupt, 1, 12)
[ 73.827831] i8042: [69317] 28 <- i8042 (interrupt, 1, 12)
[ 73.828918] i8042: [69318] 22 <- i8042 (interrupt, 1, 12)
[ 73.830015] i8042: [69320] f9 <- i8042 (interrupt, 1, 12)
[ 73.831100] i8042: [69321] 00 <- i8042 (interrupt, 1, 12)
[ 73.837617] i8042: [69327] 28 <- i8042 (interrupt, 1, 12)
[ 73.838671] i8042: [69328] 20 <- i8042 (interrupt, 1, 12)
[ 73.839755] i8042: [69329] f7 <- i8042 (interrupt, 1, 12)
[ 73.840840] i8042: [69330] 00 <- i8042 (interrupt, 1, 12)
[ 73.847329] i8042: [69337] 28 <- i8042 (interrupt, 1, 12)
[ 73.848416] i8042: [69338] 19 <- i8042 (interrupt, 1, 12)
[ 73.849502] i8042: [69339] f7 <- i8042 (interrupt, 1, 12)
[ 73.850587] i8042: [69340] 00 <- i8042 (interrupt, 1, 12)
[ 73.857083] i8042: [69347] 28 <- i8042 (interrupt, 1, 12)
[ 73.858164] i8042: [69348] 11 <- i8042 (interrupt, 1, 12)
[ 73.859251] i8042: [69349] f8 <- i8042 (interrupt, 1, 12)
[ 73.860336] i8042: [69350] 00 <- i8042 (interrupt, 1, 12)
[ 73.866825] i8042: [69356] 28 <- i8042 (interrupt, 1, 12)
[ 73.867909] i8042: [69357] 08 <- i8042 (interrupt, 1, 12)
[ 73.868997] i8042: [69359] fc <- i8042 (interrupt, 1, 12)
[ 73.870083] i8042: [69360] 00 <- i8042 (interrupt, 1, 12)
[ 73.876573] i8042: [69366] 28 <- i8042 (interrupt, 1, 12)
[ 73.877668] i8042: [69367] 01 <- i8042 (interrupt, 1, 12)
[ 73.878754] i8042: [69368] ff <- i8042 (interrupt, 1, 12)
[ 73.879839] i8042: [69369] 00 <- i8042 (interrupt, 1, 12)
[ 73.915575] i8042: [69405] 18 <- i8042 (interrupt, 1, 12)
[ 73.916661] i8042: [69406] ff <- i8042 (interrupt, 1, 12)
[ 73.917748] i8042: [69407] 00 <- i8042 (interrupt, 1, 12)
[ 73.918833] i8042: [69408] 00 <- i8042 (interrupt, 1, 12)
[ 73.925327] i8042: [69415] 18 <- i8042 (interrupt, 1, 12)
[ 73.926414] i8042: [69416] fc <- i8042 (interrupt, 1, 12)
[ 73.927500] i8042: [69417] 02 <- i8042 (interrupt, 1, 12)
[ 73.928586] i8042: [69418] 00 <- i8042 (interrupt, 1, 12)
[ 73.935070] i8042: [69425] 18 <- i8042 (interrupt, 1, 12)
[ 73.936185] i8042: [69426] f9 <- i8042 (interrupt, 1, 12)
[ 73.937251] i8042: [69427] 03 <- i8042 (interrupt, 1, 12)
[ 73.938338] i8042: [69428] 00 <- i8042 (interrupt, 1, 12)
[ 73.944779] i8042: [69434] 18 <- i8042 (interrupt, 1, 12)
[ 73.945908] i8042: [69436] f5 <- i8042 (interrupt, 1, 12)
[ 73.946995] i8042: [69437] 05 <- i8042 (interrupt, 1, 12)
[ 73.948081] i8042: [69438] 00 <- i8042 (interrupt, 1, 12)
[ 73.954529] i8042: [69444] 18 <- i8042 (interrupt, 1, 12)
[ 73.955659] i8042: [69445] ef <- i8042 (interrupt, 1, 12)
[ 73.956747] i8042: [69446] 07 <- i8042 (interrupt, 1, 12)
[ 73.957832] i8042: [69447] 00 <- i8042 (interrupt, 1, 12)
[ 73.964281] i8042: [69454] 18 <- i8042 (interrupt, 1, 12)
[ 73.965409] i8042: [69455] e8 <- i8042 (interrupt, 1, 12)
[ 73.966495] i8042: [69456] 0a <- i8042 (interrupt, 1, 12)
[ 73.967581] i8042: [69457] 00 <- i8042 (interrupt, 1, 12)
[ 73.974029] i8042: [69464] 18 <- i8042 (interrupt, 1, 12)
[ 73.975156] i8042: [69465] e7 <- i8042 (interrupt, 1, 12)
[ 73.976243] i8042: [69466] 0b <- i8042 (interrupt, 1, 12)
[ 73.977329] i8042: [69467] 00 <- i8042 (interrupt, 1, 12)
[ 73.983808] i8042: [69473] 18 <- i8042 (interrupt, 1, 12)
[ 73.984903] i8042: [69475] e3 <- i8042 (interrupt, 1, 12)
[ 73.985989] i8042: [69476] 0d <- i8042 (interrupt, 1, 12)
[ 73.987075] i8042: [69477] 00 <- i8042 (interrupt, 1, 12)
[ 73.993555] i8042: [69483] 18 <- i8042 (interrupt, 1, 12)
[ 73.994642] i8042: [69484] e0 <- i8042 (interrupt, 1, 12)
[ 73.995727] i8042: [69485] 12 <- i8042 (interrupt, 1, 12)
[ 73.996913] i8042: [69487] 00 <- i8042 (interrupt, 1, 12)
[ 74.003309] i8042: [69493] 18 <- i8042 (interrupt, 1, 12)
[ 74.004399] i8042: [69494] df <- i8042 (interrupt, 1, 12)
[ 74.005483] i8042: [69495] 13 <- i8042 (interrupt, 1, 12)
[ 74.006572] i8042: [69496] 00 <- i8042 (interrupt, 1, 12)
[ 74.013058] i8042: [69503] 18 <- i8042 (interrupt, 1, 12)
[ 74.014144] i8042: [69504] e0 <- i8042 (interrupt, 1, 12)
[ 74.015230] i8042: [69505] 14 <- i8042 (interrupt, 1, 12)
[ 74.016315] i8042: [69506] 00 <- i8042 (interrupt, 1, 12)
[ 74.022807] i8042: [69512] 18 <- i8042 (interrupt, 1, 12)
[ 74.023894] i8042: [69514] e3 <- i8042 (interrupt, 1, 12)
[ 74.024981] i8042: [69515] 11 <- i8042 (interrupt, 1, 12)
[ 74.026067] i8042: [69516] 00 <- i8042 (interrupt, 1, 12)
[ 74.032554] i8042: [69522] 18 <- i8042 (interrupt, 1, 12)
[ 74.033640] i8042: [69523] e8 <- i8042 (interrupt, 1, 12)
[ 74.034746] i8042: [69524] 0e <- i8042 (interrupt, 1, 12)
[ 74.035815] i8042: [69525] 00 <- i8042 (interrupt, 1, 12)
[ 74.042295] i8042: [69532] 18 <- i8042 (interrupt, 1, 12)
[ 74.043382] i8042: [69533] f0 <- i8042 (interrupt, 1, 12)
[ 74.044477] i8042: [69534] 0c <- i8042 (interrupt, 1, 12)
[ 74.045563] i8042: [69535] 00 <- i8042 (interrupt, 1, 12)
[ 74.052042] i8042: [69542] 18 <- i8042 (interrupt, 1, 12)
[ 74.053128] i8042: [69543] f6 <- i8042 (interrupt, 1, 12)
[ 74.054215] i8042: [69544] 08 <- i8042 (interrupt, 1, 12)
[ 74.055299] i8042: [69545] 00 <- i8042 (interrupt, 1, 12)
[ 74.061794] i8042: [69551] 18 <- i8042 (interrupt, 1, 12)
[ 74.062879] i8042: [69553] fb <- i8042 (interrupt, 1, 12)
[ 74.064094] i8042: [69554] 05 <- i8042 (interrupt, 1, 12)
[ 74.065222] i8042: [69555] 00 <- i8042 (interrupt, 1, 12)
[ 74.071502] i8042: [69561] 18 <- i8042 (interrupt, 1, 12)
[ 74.072631] i8042: [69562] ff <- i8042 (interrupt, 1, 12)
[ 74.073716] i8042: [69563] 01 <- i8042 (interrupt, 1, 12)
[ 74.074800] i8042: [69564] 00 <- i8042 (interrupt, 1, 12)
[ 74.091033] i8042: [69581] 08 <- i8042 (interrupt, 1, 12)
[ 74.092127] i8042: [69582] 02 <- i8042 (interrupt, 1, 12)
[ 74.093214] i8042: [69583] 00 <- i8042 (interrupt, 1, 12)
[ 74.094300] i8042: [69584] 00 <- i8042 (interrupt, 1, 12)
[ 74.100780] i8042: [69590] 28 <- i8042 (interrupt, 1, 12)
[ 74.101867] i8042: [69592] 01 <- i8042 (interrupt, 1, 12)
[ 74.102952] i8042: [69593] ff <- i8042 (interrupt, 1, 12)
[ 74.104048] i8042: [69594] 00 <- i8042 (interrupt, 1, 12)
[ 74.110526] i8042: [69600] 08 <- i8042 (interrupt, 1, 12)
[ 74.111613] i8042: [69601] 01 <- i8042 (interrupt, 1, 12)
[ 74.112698] i8042: [69602] 00 <- i8042 (interrupt, 1, 12)
[ 74.113783] i8042: [69603] 00 <- i8042 (interrupt, 1, 12)
[ 74.120274] i8042: [69610] 28 <- i8042 (interrupt, 1, 12)
[ 74.121361] i8042: [69611] 00 <- i8042 (interrupt, 1, 12)
[ 74.122450] i8042: [69612] ff <- i8042 (interrupt, 1, 12)
[ 74.123537] i8042: [69613] 00 <- i8042 (interrupt, 1, 12)
[ 74.130030] i8042: [69620] 08 <- i8042 (interrupt, 1, 12)
[ 74.131116] i8042: [69621] 01 <- i8042 (interrupt, 1, 12)
[ 74.132203] i8042: [69622] 00 <- i8042 (interrupt, 1, 12)
[ 74.134763] i8042: [69624] 00 <- i8042 (interrupt, 1, 12)
[ 82.093040] i8042: unplug/plug mouse
[ 89.224205] i8042: [84719] 08 <- i8042 (interrupt, 1, 12)
[ 89.225096] i8042: [84720] 01 <- i8042 (interrupt, 1, 12)
[ 89.226897] i8042: [84722] 00 <- i8042 (interrupt, 1, 12)
[ 89.236117] i8042: [84731] 28 <- i8042 (interrupt, 1, 12)
[ 89.237244] i8042: [84732] 09 <- i8042 (interrupt, 1, 12)
[ 89.238330] i8042: [84733] fb <- i8042 (interrupt, 1, 12)
[ 89.245869] i8042: [84741] 28 <- i8042 (interrupt, 1, 12)
[ 89.246997] i8042: [84742] 10 <- i8042 (interrupt, 1, 12)
[ 89.248083] i8042: [84743] f7 <- i8042 (interrupt, 1, 12)
[ 89.255660] i8042: [84751] 28 <- i8042 (interrupt, 1, 12)
[ 89.256745] i8042: [84752] 18 <- i8042 (interrupt, 1, 12)
[ 89.257833] i8042: [84753] f1 <- i8042 (interrupt, 1, 12)
[ 89.265408] i8042: [84761] 28 <- i8042 (interrupt, 1, 12)
[ 89.266495] i8042: [84762] 1e <- i8042 (interrupt, 1, 12)
[ 89.267585] i8042: [84763] e8 <- i8042 (interrupt, 1, 12)
[ 89.275152] i8042: [84770] 28 <- i8042 (interrupt, 1, 12)
[ 89.276247] i8042: [84771] 21 <- i8042 (interrupt, 1, 12)
[ 89.277332] i8042: [84772] e1 <- i8042 (interrupt, 1, 12)
[ 89.284865] i8042: [84780] 28 <- i8042 (interrupt, 1, 12)
[ 89.285950] i8042: [84781] 1d <- i8042 (interrupt, 1, 12)
[ 89.287078] i8042: [84782] de <- i8042 (interrupt, 1, 12)
[ 89.294613] i8042: [84790] 28 <- i8042 (interrupt, 1, 12)
[ 89.295741] i8042: [84791] 13 <- i8042 (interrupt, 1, 12)
[ 89.296827] i8042: [84792] de <- i8042 (interrupt, 1, 12)
[ 89.304362] i8042: [84799] 28 <- i8042 (interrupt, 1, 12)
[ 89.305490] i8042: [84801] 0f <- i8042 (interrupt, 1, 12)
[ 89.306576] i8042: [84802] dd <- i8042 (interrupt, 1, 12)
[ 89.314115] i8042: [84809] 28 <- i8042 (interrupt, 1, 12)
[ 89.315242] i8042: [84810] 0c <- i8042 (interrupt, 1, 12)
[ 89.316327] i8042: [84811] db <- i8042 (interrupt, 1, 12)
[ 89.323905] i8042: [84819] 28 <- i8042 (interrupt, 1, 12)
[ 89.324992] i8042: [84820] 08 <- i8042 (interrupt, 1, 12)
[ 89.326078] i8042: [84821] db <- i8042 (interrupt, 1, 12)
[ 89.333646] i8042: [84829] 28 <- i8042 (interrupt, 1, 12)
[ 89.334732] i8042: [84830] 05 <- i8042 (interrupt, 1, 12)
[ 89.335828] i8042: [84831] db <- i8042 (interrupt, 1, 12)
[ 89.343361] i8042: [84838] 28 <- i8042 (interrupt, 1, 12)
[ 89.344490] i8042: [84840] 02 <- i8042 (interrupt, 1, 12)
[ 89.345577] i8042: [84841] dc <- i8042 (interrupt, 1, 12)
[ 89.353111] i8042: [84848] 28 <- i8042 (interrupt, 1, 12)
[ 89.354197] i8042: [84849] 00 <- i8042 (interrupt, 1, 12)
[ 89.355324] i8042: [84850] df <- i8042 (interrupt, 1, 12)
[ 89.362861] i8042: [84858] 38 <- i8042 (interrupt, 1, 12)
[ 89.363947] i8042: [84859] ff <- i8042 (interrupt, 1, 12)
[ 89.365075] i8042: [84860] e2 <- i8042 (interrupt, 1, 12)
[ 89.372622] i8042: [84868] 38 <- i8042 (interrupt, 1, 12)
[ 89.373708] i8042: [84869] fd <- i8042 (interrupt, 1, 12)
[ 89.374793] i8042: [84870] e7 <- i8042 (interrupt, 1, 12)
[ 89.382361] i8042: [84877] 38 <- i8042 (interrupt, 1, 12)
[ 89.383447] i8042: [84879] fa <- i8042 (interrupt, 1, 12)
[ 89.384544] i8042: [84880] eb <- i8042 (interrupt, 1, 12)
[ 89.392109] i8042: [84887] 38 <- i8042 (interrupt, 1, 12)
[ 89.393195] i8042: [84888] f8 <- i8042 (interrupt, 1, 12)
[ 89.394279] i8042: [84889] f2 <- i8042 (interrupt, 1, 12)
[ 89.401861] i8042: [84897] 38 <- i8042 (interrupt, 1, 12)
[ 89.402947] i8042: [84898] f7 <- i8042 (interrupt, 1, 12)
[ 89.404033] i8042: [84899] f6 <- i8042 (interrupt, 1, 12)
[ 89.411610] i8042: [84907] 38 <- i8042 (interrupt, 1, 12)
[ 89.412711] i8042: [84908] f8 <- i8042 (interrupt, 1, 12)
[ 89.413798] i8042: [84909] fa <- i8042 (interrupt, 1, 12)
[ 89.421377] i8042: [84917] 38 <- i8042 (interrupt, 1, 12)
[ 89.422458] i8042: [84918] f8 <- i8042 (interrupt, 1, 12)
[ 89.423545] i8042: [84919] fd <- i8042 (interrupt, 1, 12)
[ 89.431114] i8042: [84926] 38 <- i8042 (interrupt, 1, 12)
[ 89.432208] i8042: [84927] f6 <- i8042 (interrupt, 1, 12)
[ 89.433292] i8042: [84928] ff <- i8042 (interrupt, 1, 12)
[ 89.440865] i8042: [84936] 18 <- i8042 (interrupt, 1, 12)
[ 89.441952] i8042: [84937] f1 <- i8042 (interrupt, 1, 12)
[ 89.443046] i8042: [84938] 00 <- i8042 (interrupt, 1, 12)
[ 89.450613] i8042: [84946] 18 <- i8042 (interrupt, 1, 12)
[ 89.451699] i8042: [84947] ea <- i8042 (interrupt, 1, 12)
[ 89.452785] i8042: [84948] 05 <- i8042 (interrupt, 1, 12)
[ 89.460366] i8042: [84956] 18 <- i8042 (interrupt, 1, 12)
[ 89.461452] i8042: [84957] e5 <- i8042 (interrupt, 1, 12)
[ 89.462539] i8042: [84958] 0a <- i8042 (interrupt, 1, 12)
[ 89.470119] i8042: [84965] 18 <- i8042 (interrupt, 1, 12)
[ 89.471205] i8042: [84966] df <- i8042 (interrupt, 1, 12)
[ 89.472290] i8042: [84967] 10 <- i8042 (interrupt, 1, 12)
[ 89.479868] i8042: [84975] 18 <- i8042 (interrupt, 1, 12)
[ 89.480955] i8042: [84976] e0 <- i8042 (interrupt, 1, 12)
[ 89.482040] i8042: [84977] 14 <- i8042 (interrupt, 1, 12)
[ 89.489608] i8042: [84985] 18 <- i8042 (interrupt, 1, 12)
[ 89.490694] i8042: [84986] e4 <- i8042 (interrupt, 1, 12)
[ 89.491789] i8042: [84987] 16 <- i8042 (interrupt, 1, 12)
[ 89.499368] i8042: [84995] 18 <- i8042 (interrupt, 1, 12)
[ 89.500454] i8042: [84996] ec <- i8042 (interrupt, 1, 12)
[ 89.501541] i8042: [84997] 18 <- i8042 (interrupt, 1, 12)
[ 89.509116] i8042: [85004] 18 <- i8042 (interrupt, 1, 12)
[ 89.510201] i8042: [85005] f4 <- i8042 (interrupt, 1, 12)
[ 89.511288] i8042: [85006] 16 <- i8042 (interrupt, 1, 12)
[ 89.518831] i8042: [85014] 18 <- i8042 (interrupt, 1, 12)
[ 89.519918] i8042: [85015] fb <- i8042 (interrupt, 1, 12)
[ 89.521045] i8042: [85016] 17 <- i8042 (interrupt, 1, 12)
[ 89.528580] i8042: [85024] 08 <- i8042 (interrupt, 1, 12)
[ 89.529668] i8042: [85025] 00 <- i8042 (interrupt, 1, 12)
[ 89.530795] i8042: [85026] 14 <- i8042 (interrupt, 1, 12)
[ 89.538371] i8042: [85034] 08 <- i8042 (interrupt, 1, 12)
[ 89.539458] i8042: [85035] 04 <- i8042 (interrupt, 1, 12)
[ 89.540544] i8042: [85036] 12 <- i8042 (interrupt, 1, 12)
[ 89.548087] i8042: [85043] 08 <- i8042 (interrupt, 1, 12)
[ 89.549175] i8042: [85044] 07 <- i8042 (interrupt, 1, 12)
[ 89.550258] i8042: [85045] 0f <- i8042 (interrupt, 1, 12)
[ 89.557836] i8042: [85053] 08 <- i8042 (interrupt, 1, 12)
[ 89.558922] i8042: [85054] 0a <- i8042 (interrupt, 1, 12)
[ 89.560010] i8042: [85055] 0b <- i8042 (interrupt, 1, 12)
[ 89.567590] i8042: [85063] 08 <- i8042 (interrupt, 1, 12)
[ 89.568677] i8042: [85064] 0a <- i8042 (interrupt, 1, 12)
[ 89.569778] i8042: [85065] 06 <- i8042 (interrupt, 1, 12)
[ 89.577318] i8042: [85073] 08 <- i8042 (interrupt, 1, 12)
[ 89.578446] i8042: [85074] 09 <- i8042 (interrupt, 1, 12)
[ 89.579532] i8042: [85075] 03 <- i8042 (interrupt, 1, 12)
[ 89.587108] i8042: [85082] 08 <- i8042 (interrupt, 1, 12)
[ 89.588193] i8042: [85083] 05 <- i8042 (interrupt, 1, 12)
[ 89.589279] i8042: [85084] 02 <- i8042 (interrupt, 1, 12)
[ 89.596849] i8042: [85092] 08 <- i8042 (interrupt, 1, 12)
[ 89.597944] i8042: [85093] 03 <- i8042 (interrupt, 1, 12)
[ 89.599032] i8042: [85094] 02 <- i8042 (interrupt, 1, 12)
[ 89.606599] i8042: [85102] 08 <- i8042 (interrupt, 1, 12)
[ 89.607686] i8042: [85103] 01 <- i8042 (interrupt, 1, 12)
[ 89.608773] i8042: [85104] 01 <- i8042 (interrupt, 1, 12)
[ 89.616398] i8042: [85112] 08 <- i8042 (interrupt, 1, 12)
[ 89.617438] i8042: [85113] 01 <- i8042 (interrupt, 1, 12)
[ 89.618525] i8042: [85114] 01 <- i8042 (interrupt, 1, 12)
^ 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