drivers/input/keyboard/pinephone-keyboard.c - linux/kernel/git/torvalds/linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0-only
 //
 // Copyright (C) 2021-2022 Samuel Holland <samuel@sholland.org>

 #include <linux/crc8.h>
 #include <linux/delay.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/of.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_SYS_SMBUS_COMMAND		0x21
 #define PPKB_SYS_SMBUS_DATA		0x22
 #define PPKB_SYS_COMMAND		0x23
 #define PPKB_SYS_COMMAND_SMBUS_READ		0x91
 #define PPKB_SYS_COMMAND_SMBUS_WRITE		0xa1

 #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 i2c_adapter adapter;
 	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 int ppkb_adap_smbus_xfer(struct i2c_adapter *adap, u16 addr,
 				unsigned short flags, char read_write,
 				u8 command, int size,
 				union i2c_smbus_data *data)
 {
 	struct i2c_client *client = adap->algo_data;
 	u8 buf[3];
 	int ret;

 	buf[0] = command;
 	buf[1] = data->byte;
 	buf[2] = read_write == I2C_SMBUS_READ ? PPKB_SYS_COMMAND_SMBUS_READ
 					      : PPKB_SYS_COMMAND_SMBUS_WRITE;

 	ret = i2c_smbus_write_i2c_block_data(client, PPKB_SYS_SMBUS_COMMAND,
 					     sizeof(buf), buf);
 	if (ret)
 		return ret;

 	/* Read back the command status until it passes or fails. */
 	do {
 		usleep_range(300, 500);
 		ret = i2c_smbus_read_byte_data(client, PPKB_SYS_COMMAND);
 	} while (ret == buf[2]);
 	if (ret < 0)
 		return ret;
 	/* Commands return 0x00 on success and 0xff on failure. */
 	if (ret)
 		return -EIO;

 	if (read_write == I2C_SMBUS_READ) {
 		ret = i2c_smbus_read_byte_data(client, PPKB_SYS_SMBUS_DATA);
 		if (ret < 0)
 			return ret;

 		data->byte = ret;
 	}

 	return 0;
 }

 static u32 ppkg_adap_functionality(struct i2c_adapter *adap)
 {
 	return I2C_FUNC_SMBUS_BYTE_DATA;
 }

 static const struct i2c_algorithm ppkb_adap_algo = {
 	.smbus_xfer		= ppkb_adap_smbus_xfer,
 	.functionality		= ppkg_adap_functionality,
 };

 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];
 	struct device_node *i2c_bus;
 	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);

 	i2c_bus = of_get_child_by_name(dev->of_node, "i2c");
 	if (i2c_bus) {
 		ppkb->adapter.owner = THIS_MODULE;
 		ppkb->adapter.algo = &ppkb_adap_algo;
 		ppkb->adapter.algo_data = client;
 		ppkb->adapter.dev.parent = dev;
 		ppkb->adapter.dev.of_node = i2c_bus;
 		strscpy(ppkb->adapter.name, DRV_NAME, sizeof(ppkb->adapter.name));

 		error = devm_i2c_add_adapter(dev, &ppkb->adapter);
 		if (error) {
 			dev_err(dev, "Failed to add I2C adapter: %d\n", error);
 			return error;
 		}
 	}

 	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");
	// SPDX-License-Identifier: GPL-2.0-only
	//
	// Copyright (C) 2021-2022 Samuel Holland <samuel@sholland.org>

	#include <linux/crc8.h>
	#include <linux/delay.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/of.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_SYS_SMBUS_COMMAND 0x21
	#define PPKB_SYS_SMBUS_DATA 0x22
	#define PPKB_SYS_COMMAND 0x23
	#define PPKB_SYS_COMMAND_SMBUS_READ 0x91
	#define PPKB_SYS_COMMAND_SMBUS_WRITE 0xa1

	#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 i2c_adapter adapter;
	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 int ppkb_adap_smbus_xfer(struct i2c_adapter *adap, u16 addr,
	unsigned short flags, char read_write,
	u8 command, int size,
	union i2c_smbus_data *data)
	{
	struct i2c_client *client = adap->algo_data;
	u8 buf[3];
	int ret;

	buf[0] = command;
	buf[1] = data->byte;
	buf[2] = read_write == I2C_SMBUS_READ ? PPKB_SYS_COMMAND_SMBUS_READ
	: PPKB_SYS_COMMAND_SMBUS_WRITE;

	ret = i2c_smbus_write_i2c_block_data(client, PPKB_SYS_SMBUS_COMMAND,
	sizeof(buf), buf);
	if (ret)
	return ret;

	/* Read back the command status until it passes or fails. */
	do {
	usleep_range(300, 500);
	ret = i2c_smbus_read_byte_data(client, PPKB_SYS_COMMAND);
	} while (ret == buf[2]);
	if (ret < 0)
	return ret;
	/* Commands return 0x00 on success and 0xff on failure. */
	if (ret)
	return -EIO;

	if (read_write == I2C_SMBUS_READ) {
	ret = i2c_smbus_read_byte_data(client, PPKB_SYS_SMBUS_DATA);
	if (ret < 0)
	return ret;

	data->byte = ret;
	}

	return 0;
	}

	static u32 ppkg_adap_functionality(struct i2c_adapter *adap)
	{
	return I2C_FUNC_SMBUS_BYTE_DATA;
	}

	static const struct i2c_algorithm ppkb_adap_algo = {
	.smbus_xfer = ppkb_adap_smbus_xfer,
	.functionality = ppkg_adap_functionality,
	};

	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];
	struct device_node *i2c_bus;
	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);

	i2c_bus = of_get_child_by_name(dev->of_node, "i2c");
	if (i2c_bus) {
	ppkb->adapter.owner = THIS_MODULE;
	ppkb->adapter.algo = &ppkb_adap_algo;
	ppkb->adapter.algo_data = client;
	ppkb->adapter.dev.parent = dev;
	ppkb->adapter.dev.of_node = i2c_bus;
	strscpy(ppkb->adapter.name, DRV_NAME, sizeof(ppkb->adapter.name));

	error = devm_i2c_add_adapter(dev, &ppkb->adapter);
	if (error) {
	dev_err(dev, "Failed to add I2C adapter: %d\n", error);
	return error;
	}
	}

	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");