1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (C) IBM Corporation 2020 4 */ 5 6 #include <linux/i2c.h> 7 #include <linux/init.h> 8 #include <linux/input.h> 9 #include <linux/kernel.h> 10 #include <linux/limits.h> 11 #include <linux/module.h> 12 #include <linux/of.h> 13 #include <linux/spinlock.h> 14 15 #define DEVICE_NAME "ibm-panel" 16 #define PANEL_KEYCODES_COUNT 3 17 18 struct ibm_panel { 19 u8 idx; 20 u8 command[11]; 21 u32 keycodes[PANEL_KEYCODES_COUNT]; 22 spinlock_t lock; /* protects writes to idx and command */ 23 struct input_dev *input; 24 }; 25 26 static u8 ibm_panel_calculate_checksum(struct ibm_panel *panel) 27 { 28 u8 chksum; 29 u16 sum = 0; 30 unsigned int i; 31 32 for (i = 0; i < sizeof(panel->command) - 1; ++i) { 33 sum += panel->command[i]; 34 if (sum & 0xff00) { 35 sum &= 0xff; 36 sum++; 37 } 38 } 39 40 chksum = sum & 0xff; 41 chksum = ~chksum; 42 chksum++; 43 44 return chksum; 45 } 46 47 static void ibm_panel_process_command(struct ibm_panel *panel) 48 { 49 u8 button; 50 u8 chksum; 51 52 if (panel->command[0] != 0xff && panel->command[1] != 0xf0) { 53 dev_dbg(&panel->input->dev, "command invalid: %02x %02x\n", 54 panel->command[0], panel->command[1]); 55 return; 56 } 57 58 chksum = ibm_panel_calculate_checksum(panel); 59 if (chksum != panel->command[sizeof(panel->command) - 1]) { 60 dev_dbg(&panel->input->dev, 61 "command failed checksum: %u != %u\n", chksum, 62 panel->command[sizeof(panel->command) - 1]); 63 return; 64 } 65 66 button = panel->command[2] & 0xf; 67 if (button < PANEL_KEYCODES_COUNT) { 68 input_report_key(panel->input, panel->keycodes[button], 69 !(panel->command[2] & 0x80)); 70 input_sync(panel->input); 71 } else { 72 dev_dbg(&panel->input->dev, "unknown button %u\n", 73 button); 74 } 75 } 76 77 static int ibm_panel_i2c_slave_cb(struct i2c_client *client, 78 enum i2c_slave_event event, u8 *val) 79 { 80 unsigned long flags; 81 struct ibm_panel *panel = i2c_get_clientdata(client); 82 83 dev_dbg(&panel->input->dev, "event: %u data: %02x\n", event, *val); 84 85 spin_lock_irqsave(&panel->lock, flags); 86 87 switch (event) { 88 case I2C_SLAVE_STOP: 89 if (panel->idx == sizeof(panel->command)) 90 ibm_panel_process_command(panel); 91 else 92 dev_dbg(&panel->input->dev, 93 "command incorrect size %u\n", panel->idx); 94 fallthrough; 95 case I2C_SLAVE_WRITE_REQUESTED: 96 panel->idx = 0; 97 break; 98 case I2C_SLAVE_WRITE_RECEIVED: 99 if (panel->idx < sizeof(panel->command)) 100 panel->command[panel->idx++] = *val; 101 else 102 /* 103 * The command is too long and therefore invalid, so set the index 104 * to it's largest possible value. When a STOP is finally received, 105 * the command will be rejected upon processing. 106 */ 107 panel->idx = U8_MAX; 108 break; 109 case I2C_SLAVE_READ_REQUESTED: 110 case I2C_SLAVE_READ_PROCESSED: 111 *val = 0xff; 112 break; 113 default: 114 break; 115 } 116 117 spin_unlock_irqrestore(&panel->lock, flags); 118 119 return 0; 120 } 121 122 static int ibm_panel_probe(struct i2c_client *client, 123 const struct i2c_device_id *id) 124 { 125 struct ibm_panel *panel; 126 int i; 127 int error; 128 129 panel = devm_kzalloc(&client->dev, sizeof(*panel), GFP_KERNEL); 130 if (!panel) 131 return -ENOMEM; 132 133 spin_lock_init(&panel->lock); 134 135 panel->input = devm_input_allocate_device(&client->dev); 136 if (!panel->input) 137 return -ENOMEM; 138 139 panel->input->name = client->name; 140 panel->input->id.bustype = BUS_I2C; 141 142 error = device_property_read_u32_array(&client->dev, 143 "linux,keycodes", 144 panel->keycodes, 145 PANEL_KEYCODES_COUNT); 146 if (error) { 147 /* 148 * Use gamepad buttons as defaults for compatibility with 149 * existing applications. 150 */ 151 panel->keycodes[0] = BTN_NORTH; 152 panel->keycodes[1] = BTN_SOUTH; 153 panel->keycodes[2] = BTN_SELECT; 154 } 155 156 for (i = 0; i < PANEL_KEYCODES_COUNT; ++i) 157 input_set_capability(panel->input, EV_KEY, panel->keycodes[i]); 158 159 error = input_register_device(panel->input); 160 if (error) { 161 dev_err(&client->dev, 162 "Failed to register input device: %d\n", error); 163 return error; 164 } 165 166 i2c_set_clientdata(client, panel); 167 error = i2c_slave_register(client, ibm_panel_i2c_slave_cb); 168 if (error) { 169 dev_err(&client->dev, 170 "Failed to register as i2c slave: %d\n", error); 171 return error; 172 } 173 174 return 0; 175 } 176 177 static void ibm_panel_remove(struct i2c_client *client) 178 { 179 i2c_slave_unregister(client); 180 } 181 182 static const struct of_device_id ibm_panel_match[] = { 183 { .compatible = "ibm,op-panel" }, 184 { } 185 }; 186 MODULE_DEVICE_TABLE(of, ibm_panel_match); 187 188 static struct i2c_driver ibm_panel_driver = { 189 .driver = { 190 .name = DEVICE_NAME, 191 .of_match_table = ibm_panel_match, 192 }, 193 .probe = ibm_panel_probe, 194 .remove = ibm_panel_remove, 195 }; 196 module_i2c_driver(ibm_panel_driver); 197 198 MODULE_AUTHOR("Eddie James <eajames@linux.ibm.com>"); 199 MODULE_DESCRIPTION("IBM Operation Panel Driver"); 200 MODULE_LICENSE("GPL"); 201