Commit 17406967 authored by Samuel Holland's avatar Samuel Holland Committed by Dmitry Torokhov

Input: pinephone-keyboard - add PinePhone keyboard driver

The official Pine64 PinePhone keyboard case contains a matrix keypad and
a MCU which runs a libre firmware. Add support for its I2C interface.
Signed-off-by: default avatarSamuel Holland <samuel@sholland.org>
Link: https://lore.kernel.org/r/20220618165747.55709-3-samuel@sholland.orgSigned-off-by: default avatarDmitry Torokhov <dmitry.torokhov@gmail.com>
parent 75024261
......@@ -16186,6 +16186,12 @@ F: Documentation/devicetree/bindings/pinctrl/sunplus,*
F: drivers/pinctrl/sunplus/
F: include/dt-bindings/pinctrl/sppctl*.h
PINE64 PINEPHONE KEYBOARD DRIVER
M: Samuel Holland <samuel@sholland.org>
S: Supported
F: Documentation/devicetree/bindings/input/pine64,pinephone-keyboard.yaml
F: drivers/input/keyboard/pinephone-keyboard.c
PKTCDVD DRIVER
M: linux-block@vger.kernel.org
S: Orphan
......
......@@ -527,6 +527,19 @@ config KEYBOARD_OPENCORES
To compile this driver as a module, choose M here; the
module will be called opencores-kbd.
config KEYBOARD_PINEPHONE
tristate "Pine64 PinePhone Keyboard"
depends on I2C && REGULATOR
select CRC8
select INPUT_MATRIXKMAP
help
Say Y here to enable support for the keyboard in the Pine64 PinePhone
keyboard case. This driver supports the FLOSS firmware available at
https://megous.com/git/pinephone-keyboard/
To compile this driver as a module, choose M here; the
module will be called pinephone-keyboard.
config KEYBOARD_PXA27x
tristate "PXA27x/PXA3xx keypad support"
depends on PXA27x || PXA3xx || ARCH_MMP
......
......@@ -52,6 +52,7 @@ obj-$(CONFIG_KEYBOARD_NSPIRE) += nspire-keypad.o
obj-$(CONFIG_KEYBOARD_OMAP) += omap-keypad.o
obj-$(CONFIG_KEYBOARD_OMAP4) += omap4-keypad.o
obj-$(CONFIG_KEYBOARD_OPENCORES) += opencores-kbd.o
obj-$(CONFIG_KEYBOARD_PINEPHONE) += pinephone-keyboard.o
obj-$(CONFIG_KEYBOARD_PMIC8XXX) += pmic8xxx-keypad.o
obj-$(CONFIG_KEYBOARD_PXA27x) += pxa27x_keypad.o
obj-$(CONFIG_KEYBOARD_PXA930_ROTARY) += pxa930_rotary.o
......
// SPDX-License-Identifier: GPL-2.0-only
//
// Copyright (C) 2021-2022 Samuel Holland <samuel@sholland.org>
#include <linux/crc8.h>
#include <linux/err.h>
#include <linux/i2c.h>
#include <linux/input.h>
#include <linux/input/matrix_keypad.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/mod_devicetable.h>
#include <linux/regulator/consumer.h>
#include <linux/types.h>
#define DRV_NAME "pinephone-keyboard"
#define PPKB_CRC8_POLYNOMIAL 0x07
#define PPKB_DEVICE_ID_HI 0x00
#define PPKB_DEVICE_ID_HI_VALUE 'K'
#define PPKB_DEVICE_ID_LO 0x01
#define PPKB_DEVICE_ID_LO_VALUE 'B'
#define PPKB_FW_REVISION 0x02
#define PPKB_FW_FEATURES 0x03
#define PPKB_MATRIX_SIZE 0x06
#define PPKB_SCAN_CRC 0x07
#define PPKB_SCAN_DATA 0x08
#define PPKB_SYS_CONFIG 0x20
#define PPKB_SYS_CONFIG_DISABLE_SCAN BIT(0)
#define PPKB_ROWS 6
#define PPKB_COLS 12
/* Size of the scan buffer, including the CRC byte at the beginning. */
#define PPKB_BUF_LEN (1 + PPKB_COLS)
static const uint32_t ppkb_keymap[] = {
KEY(0, 0, KEY_ESC),
KEY(0, 1, KEY_1),
KEY(0, 2, KEY_2),
KEY(0, 3, KEY_3),
KEY(0, 4, KEY_4),
KEY(0, 5, KEY_5),
KEY(0, 6, KEY_6),
KEY(0, 7, KEY_7),
KEY(0, 8, KEY_8),
KEY(0, 9, KEY_9),
KEY(0, 10, KEY_0),
KEY(0, 11, KEY_BACKSPACE),
KEY(1, 0, KEY_TAB),
KEY(1, 1, KEY_Q),
KEY(1, 2, KEY_W),
KEY(1, 3, KEY_E),
KEY(1, 4, KEY_R),
KEY(1, 5, KEY_T),
KEY(1, 6, KEY_Y),
KEY(1, 7, KEY_U),
KEY(1, 8, KEY_I),
KEY(1, 9, KEY_O),
KEY(1, 10, KEY_P),
KEY(1, 11, KEY_ENTER),
KEY(2, 0, KEY_LEFTMETA),
KEY(2, 1, KEY_A),
KEY(2, 2, KEY_S),
KEY(2, 3, KEY_D),
KEY(2, 4, KEY_F),
KEY(2, 5, KEY_G),
KEY(2, 6, KEY_H),
KEY(2, 7, KEY_J),
KEY(2, 8, KEY_K),
KEY(2, 9, KEY_L),
KEY(2, 10, KEY_SEMICOLON),
KEY(3, 0, KEY_LEFTSHIFT),
KEY(3, 1, KEY_Z),
KEY(3, 2, KEY_X),
KEY(3, 3, KEY_C),
KEY(3, 4, KEY_V),
KEY(3, 5, KEY_B),
KEY(3, 6, KEY_N),
KEY(3, 7, KEY_M),
KEY(3, 8, KEY_COMMA),
KEY(3, 9, KEY_DOT),
KEY(3, 10, KEY_SLASH),
KEY(4, 1, KEY_LEFTCTRL),
KEY(4, 4, KEY_SPACE),
KEY(4, 6, KEY_APOSTROPHE),
KEY(4, 8, KEY_RIGHTBRACE),
KEY(4, 9, KEY_LEFTBRACE),
KEY(5, 2, KEY_FN),
KEY(5, 3, KEY_LEFTALT),
KEY(5, 5, KEY_RIGHTALT),
/* FN layer */
KEY(PPKB_ROWS + 0, 0, KEY_FN_ESC),
KEY(PPKB_ROWS + 0, 1, KEY_F1),
KEY(PPKB_ROWS + 0, 2, KEY_F2),
KEY(PPKB_ROWS + 0, 3, KEY_F3),
KEY(PPKB_ROWS + 0, 4, KEY_F4),
KEY(PPKB_ROWS + 0, 5, KEY_F5),
KEY(PPKB_ROWS + 0, 6, KEY_F6),
KEY(PPKB_ROWS + 0, 7, KEY_F7),
KEY(PPKB_ROWS + 0, 8, KEY_F8),
KEY(PPKB_ROWS + 0, 9, KEY_F9),
KEY(PPKB_ROWS + 0, 10, KEY_F10),
KEY(PPKB_ROWS + 0, 11, KEY_DELETE),
KEY(PPKB_ROWS + 1, 10, KEY_PAGEUP),
KEY(PPKB_ROWS + 2, 0, KEY_SYSRQ),
KEY(PPKB_ROWS + 2, 9, KEY_PAGEDOWN),
KEY(PPKB_ROWS + 2, 10, KEY_INSERT),
KEY(PPKB_ROWS + 3, 0, KEY_LEFTSHIFT),
KEY(PPKB_ROWS + 3, 8, KEY_HOME),
KEY(PPKB_ROWS + 3, 9, KEY_UP),
KEY(PPKB_ROWS + 3, 10, KEY_END),
KEY(PPKB_ROWS + 4, 1, KEY_LEFTCTRL),
KEY(PPKB_ROWS + 4, 6, KEY_LEFT),
KEY(PPKB_ROWS + 4, 8, KEY_RIGHT),
KEY(PPKB_ROWS + 4, 9, KEY_DOWN),
KEY(PPKB_ROWS + 5, 3, KEY_LEFTALT),
KEY(PPKB_ROWS + 5, 5, KEY_RIGHTALT),
};
static const struct matrix_keymap_data ppkb_keymap_data = {
.keymap = ppkb_keymap,
.keymap_size = ARRAY_SIZE(ppkb_keymap),
};
struct pinephone_keyboard {
struct input_dev *input;
u8 buf[2][PPKB_BUF_LEN];
u8 crc_table[CRC8_TABLE_SIZE];
u8 fn_state[PPKB_COLS];
bool buf_swap;
bool fn_pressed;
};
static void ppkb_update(struct i2c_client *client)
{
struct pinephone_keyboard *ppkb = i2c_get_clientdata(client);
unsigned short *keymap = ppkb->input->keycode;
int row_shift = get_count_order(PPKB_COLS);
u8 *old_buf = ppkb->buf[!ppkb->buf_swap];
u8 *new_buf = ppkb->buf[ppkb->buf_swap];
int col, crc, ret, row;
struct device *dev = &client->dev;
ret = i2c_smbus_read_i2c_block_data(client, PPKB_SCAN_CRC,
PPKB_BUF_LEN, new_buf);
if (ret != PPKB_BUF_LEN) {
dev_err(dev, "Failed to read scan data: %d\n", ret);
return;
}
crc = crc8(ppkb->crc_table, &new_buf[1], PPKB_COLS, CRC8_INIT_VALUE);
if (crc != new_buf[0]) {
dev_err(dev, "Bad scan data (%02x != %02x)\n", crc, new_buf[0]);
return;
}
ppkb->buf_swap = !ppkb->buf_swap;
for (col = 0; col < PPKB_COLS; ++col) {
u8 old = old_buf[1 + col];
u8 new = new_buf[1 + col];
u8 changed = old ^ new;
if (!changed)
continue;
for (row = 0; row < PPKB_ROWS; ++row) {
u8 mask = BIT(row);
u8 value = new & mask;
unsigned short code;
bool fn_state;
if (!(changed & mask))
continue;
/*
* Save off the FN key state when the key was pressed,
* and use that to determine the code during a release.
*/
fn_state = value ? ppkb->fn_pressed : ppkb->fn_state[col] & mask;
if (fn_state)
ppkb->fn_state[col] ^= mask;
/* The FN layer is a second set of rows. */
code = MATRIX_SCAN_CODE(fn_state ? PPKB_ROWS + row : row,
col, row_shift);
input_event(ppkb->input, EV_MSC, MSC_SCAN, code);
input_report_key(ppkb->input, keymap[code], value);
if (keymap[code] == KEY_FN)
ppkb->fn_pressed = value;
}
}
input_sync(ppkb->input);
}
static irqreturn_t ppkb_irq_thread(int irq, void *data)
{
struct i2c_client *client = data;
ppkb_update(client);
return IRQ_HANDLED;
}
static int ppkb_set_scan(struct i2c_client *client, bool enable)
{
struct device *dev = &client->dev;
int ret, val;
ret = i2c_smbus_read_byte_data(client, PPKB_SYS_CONFIG);
if (ret < 0) {
dev_err(dev, "Failed to read config: %d\n", ret);
return ret;
}
if (enable)
val = ret & ~PPKB_SYS_CONFIG_DISABLE_SCAN;
else
val = ret | PPKB_SYS_CONFIG_DISABLE_SCAN;
ret = i2c_smbus_write_byte_data(client, PPKB_SYS_CONFIG, val);
if (ret) {
dev_err(dev, "Failed to write config: %d\n", ret);
return ret;
}
return 0;
}
static int ppkb_open(struct input_dev *input)
{
struct i2c_client *client = input_get_drvdata(input);
int error;
error = ppkb_set_scan(client, true);
if (error)
return error;
return 0;
}
static void ppkb_close(struct input_dev *input)
{
struct i2c_client *client = input_get_drvdata(input);
ppkb_set_scan(client, false);
}
static void ppkb_regulator_disable(void *regulator)
{
regulator_disable(regulator);
}
static int ppkb_probe(struct i2c_client *client)
{
struct device *dev = &client->dev;
unsigned int phys_rows, phys_cols;
struct pinephone_keyboard *ppkb;
struct regulator *vbat_supply;
u8 info[PPKB_MATRIX_SIZE + 1];
int ret;
int error;
vbat_supply = devm_regulator_get(dev, "vbat");
error = PTR_ERR_OR_ZERO(vbat_supply);
if (error) {
dev_err(dev, "Failed to get VBAT supply: %d\n", error);
return error;
}
error = regulator_enable(vbat_supply);
if (error) {
dev_err(dev, "Failed to enable VBAT: %d\n", error);
return error;
}
error = devm_add_action_or_reset(dev, ppkb_regulator_disable,
vbat_supply);
if (error)
return error;
ret = i2c_smbus_read_i2c_block_data(client, 0, sizeof(info), info);
if (ret != sizeof(info)) {
error = ret < 0 ? ret : -EIO;
dev_err(dev, "Failed to read device ID: %d\n", error);
return error;
}
if (info[PPKB_DEVICE_ID_HI] != PPKB_DEVICE_ID_HI_VALUE ||
info[PPKB_DEVICE_ID_LO] != PPKB_DEVICE_ID_LO_VALUE) {
dev_warn(dev, "Unexpected device ID: %#02x %#02x\n",
info[PPKB_DEVICE_ID_HI], info[PPKB_DEVICE_ID_LO]);
return -ENODEV;
}
dev_info(dev, "Found firmware version %d.%d features %#x\n",
info[PPKB_FW_REVISION] >> 4,
info[PPKB_FW_REVISION] & 0xf,
info[PPKB_FW_FEATURES]);
phys_rows = info[PPKB_MATRIX_SIZE] & 0xf;
phys_cols = info[PPKB_MATRIX_SIZE] >> 4;
if (phys_rows != PPKB_ROWS || phys_cols != PPKB_COLS) {
dev_err(dev, "Unexpected keyboard size %ux%u\n",
phys_rows, phys_cols);
return -EINVAL;
}
/* Disable scan by default to save power. */
error = ppkb_set_scan(client, false);
if (error)
return error;
ppkb = devm_kzalloc(dev, sizeof(*ppkb), GFP_KERNEL);
if (!ppkb)
return -ENOMEM;
i2c_set_clientdata(client, ppkb);
crc8_populate_msb(ppkb->crc_table, PPKB_CRC8_POLYNOMIAL);
ppkb->input = devm_input_allocate_device(dev);
if (!ppkb->input)
return -ENOMEM;
input_set_drvdata(ppkb->input, client);
ppkb->input->name = "PinePhone Keyboard";
ppkb->input->phys = DRV_NAME "/input0";
ppkb->input->id.bustype = BUS_I2C;
ppkb->input->open = ppkb_open;
ppkb->input->close = ppkb_close;
input_set_capability(ppkb->input, EV_MSC, MSC_SCAN);
__set_bit(EV_REP, ppkb->input->evbit);
error = matrix_keypad_build_keymap(&ppkb_keymap_data, NULL,
2 * PPKB_ROWS, PPKB_COLS, NULL,
ppkb->input);
if (error) {
dev_err(dev, "Failed to build keymap: %d\n", error);
return error;
}
error = input_register_device(ppkb->input);
if (error) {
dev_err(dev, "Failed to register input: %d\n", error);
return error;
}
error = devm_request_threaded_irq(dev, client->irq,
NULL, ppkb_irq_thread,
IRQF_ONESHOT, client->name, client);
if (error) {
dev_err(dev, "Failed to request IRQ: %d\n", error);
return error;
}
return 0;
}
static const struct of_device_id ppkb_of_match[] = {
{ .compatible = "pine64,pinephone-keyboard" },
{ }
};
MODULE_DEVICE_TABLE(of, ppkb_of_match);
static struct i2c_driver ppkb_driver = {
.probe_new = ppkb_probe,
.driver = {
.name = DRV_NAME,
.of_match_table = ppkb_of_match,
},
};
module_i2c_driver(ppkb_driver);
MODULE_AUTHOR("Samuel Holland <samuel@sholland.org>");
MODULE_DESCRIPTION("Pine64 PinePhone keyboard driver");
MODULE_LICENSE("GPL");
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment