Re: [PATCH v3] HID: i2c-hid: add polling mode based on connected GPIO chip's pin status
flat view
From: Barnabás Pőcze <hidden>
Date: 2020-10-22 14:23:19
Also in:
lkml, stable
Hi, I think this looks a lot better than the first version, the issues around suspend/resume are sorted out as far as I can see. However, I still have a couple comments, mainly minor ones.
[...] +/* polling mode */ +#define I2C_HID_POLLING_DISABLED 0 +#define I2C_HID_POLLING_GPIO_PIN 1 +#define I2C_HID_POLLING_INTERVAL_ACTIVE_US 4000 +#define I2C_HID_POLLING_INTERVAL_IDLE_MS 10 + +static u8 polling_mode; +module_param(polling_mode, byte, 0444); +MODULE_PARM_DESC(polling_mode, "How to poll - 0 disabled; 1 based on GPIO pin's status"); +
Minor thing, but maybe the default value should be documented in the parameter description?
quoted hunk ↗ jump to hunk
+static unsigned int polling_interval_active_us = I2C_HID_POLLING_INTERVAL_ACTIVE_US; +module_param(polling_interval_active_us, uint, 0644); +MODULE_PARM_DESC(polling_interval_active_us, + "Poll every {polling_interval_active_us} us when the touchpad is active. Default to 4000 us"); + +static unsigned int polling_interval_idle_ms = I2C_HID_POLLING_INTERVAL_IDLE_MS;
Since these two parameters are mostly read, I think the `__read_mostly` attribute (linux/cache.h) is justified here.
quoted hunk ↗ jump to hunk
+module_param(polling_interval_idle_ms, uint, 0644); +MODULE_PARM_DESC(polling_interval_idle_ms, + "Poll every {polling_interval_idle_ms} ms when the touchpad is idle. Default to 10 ms");
This is minor stylistic thing; as far as I see, the prevalent pattern is to put the default value at the end, in parenthesis: E.g. "some parameter description (default=X)" or "... (default: X)" or something similar Maybe __stringify() (linux/stringify.h) could be used here and for the previous module parameter? E.g. "... (default=" __stringify(I2C_HID_POLLING_INTERVAL_IDLE_MS) ")"
[...]
+static int get_gpio_pin_state(struct irq_desc *irq_desc)
+{
+ struct gpio_chip *gc = irq_data_get_irq_chip_data(&irq_desc->irq_data);
+
+ return gc->get(gc, irq_desc->irq_data.hwirq);
+}
+
+static bool interrupt_line_active(struct i2c_client *client)
+{
+ unsigned long trigger_type = irq_get_trigger_type(client->irq);Can the trigger type change? Because if not, then I think it'd be better to store the value somewhere and not query it every time.
+ struct irq_desc *irq_desc = irq_to_desc(client->irq);
Same here.
+ ssize_t status = get_gpio_pin_state(irq_desc);
`get_gpio_pin_state()` returns an `int`, so I am not sure why `ssize_t` is used here.
quoted hunk ↗ jump to hunk
+ + if (status < 0) { + dev_warn(&client->dev, + "Failed to get GPIO Interrupt line status for %s", + client->name);
I think it's possible that the kernel message buffer is flooded with these messages, which is not optimal in my opinion.
quoted hunk ↗ jump to hunk
+ return false; + } + /* + * According to Windows Precsiontion Touchpad's specs + * https://docs.microsoft.com/en-us/windows-hardware/design/component-guidelines/windows-precision-touchpad-device-bus-connectivity, + * GPIO Interrupt Assertion Leve could be either ActiveLow or + * ActiveHigh. + */ + if (trigger_type & IRQF_TRIGGER_LOW) + return !status; + + return status; +} + +static int i2c_hid_polling_thread(void *i2c_hid) +{ + struct i2c_hid *ihid = i2c_hid; + struct i2c_client *client = ihid->client; + unsigned int polling_interval_idle; + + while (1) { + if (kthread_should_stop()) + break;
I think this should be `while (!kthread_should_stop())`.
quoted hunk ↗ jump to hunk
+ + while (interrupt_line_active(client) && + !test_bit(I2C_HID_READ_PENDING, &ihid->flags) && + !kthread_should_stop()) { + i2c_hid_get_input(ihid); + usleep_range(polling_interval_active_us, + polling_interval_active_us + 100); + } + /* + * re-calculate polling_interval_idle + * so the module parameters polling_interval_idle_ms can be + * changed dynamically through sysfs as polling_interval_active_us + */ + polling_interval_idle = polling_interval_idle_ms * 1000; + usleep_range(polling_interval_idle, + polling_interval_idle + 1000);
I don't quite understand why you use an extra variable here. I'm assuming you want to "save" a multiplication? I believe the compiler will optimize it to a single read, and single multiplication regardless whether you use a "temporary" variable or not.
quoted hunk ↗ jump to hunk
+ } + + do_exit(0);
Looking at other examples, I don't think `do_exit()` is necessary.
quoted hunk ↗ jump to hunk
+ return 0; +} + +static int i2c_hid_init_polling(struct i2c_hid *ihid) +{ + struct i2c_client *client = ihid->client; + + if (!irq_get_trigger_type(client->irq)) { + dev_warn(&client->dev, + "Failed to get GPIO Interrupt Assertion Level, could not enable polling mode for %s", + client->name); + return -EINVAL; + } + + ihid->polling_thread = kthread_create(i2c_hid_polling_thread, ihid, + "I2C HID polling thread"); + + if (!IS_ERR(ihid->polling_thread)) { + pr_info("I2C HID polling thread created"); + wake_up_process(ihid->polling_thread); + return 0; + } + + return PTR_ERR(ihid->polling_thread);
I would personally rewrite this parts as
if (IS_ERR(...)) {
dev_err(...);
return PTR_ERR(...);
}
....
return 0;
+} [...]
Regards, Barnabás Pőcze