1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Driver for Cypress CY8CTMA140 (TMA140) touchscreen 4 * (C) 2020 Linus Walleij <linus.walleij@linaro.org> 5 * (C) 2007 Cypress 6 * (C) 2007 Google, Inc. 7 * 8 * Inspired by the tma140_skomer.c driver in the Samsung GT-S7710 code 9 * drop. The GT-S7710 is codenamed "Skomer", the code also indicates 10 * that the same touchscreen was used in a product called "Lucas". 11 * 12 * The code drop for GT-S7710 also contains a firmware downloader and 13 * 15 (!) versions of the firmware drop from Cypress. But here we assume 14 * the firmware got downloaded to the touchscreen flash successfully and 15 * just use it to read the fingers. The shipped vendor driver does the 16 * same. 17 */ 18 19 #include <asm/unaligned.h> 20 #include <linux/module.h> 21 #include <linux/kernel.h> 22 #include <linux/input.h> 23 #include <linux/input/touchscreen.h> 24 #include <linux/input/mt.h> 25 #include <linux/slab.h> 26 #include <linux/interrupt.h> 27 #include <linux/io.h> 28 #include <linux/i2c.h> 29 #include <linux/regulator/consumer.h> 30 #include <linux/delay.h> 31 32 #define CY8CTMA140_NAME "cy8ctma140" 33 34 #define CY8CTMA140_MAX_FINGERS 4 35 36 #define CY8CTMA140_GET_FINGERS 0x00 37 #define CY8CTMA140_GET_FW_INFO 0x19 38 39 /* This message also fits some bytes for touchkeys, if used */ 40 #define CY8CTMA140_PACKET_SIZE 31 41 42 #define CY8CTMA140_INVALID_BUFFER_BIT 5 43 44 struct cy8ctma140 { 45 struct input_dev *input; 46 struct touchscreen_properties props; 47 struct device *dev; 48 struct i2c_client *client; 49 struct regulator_bulk_data regulators[2]; 50 u8 prev_fingers; 51 u8 prev_f1id; 52 u8 prev_f2id; 53 }; 54 55 static void cy8ctma140_report(struct cy8ctma140 *ts, u8 *data, int n_fingers) 56 { 57 static const u8 contact_offsets[] = { 0x03, 0x09, 0x10, 0x16 }; 58 u8 *buf; 59 u16 x, y; 60 u8 w; 61 u8 id; 62 int slot; 63 int i; 64 65 for (i = 0; i < n_fingers; i++) { 66 buf = &data[contact_offsets[i]]; 67 68 /* 69 * Odd contacts have contact ID in the lower nibble of 70 * the preceding byte, whereas even contacts have it in 71 * the upper nibble of the following byte. 72 */ 73 id = i % 2 ? buf[-1] & 0x0f : buf[5] >> 4; 74 slot = input_mt_get_slot_by_key(ts->input, id); 75 if (slot < 0) 76 continue; 77 78 x = get_unaligned_be16(buf); 79 y = get_unaligned_be16(buf + 2); 80 w = buf[4]; 81 82 dev_dbg(ts->dev, "finger %d: ID %02x (%d, %d) w: %d\n", 83 slot, id, x, y, w); 84 85 input_mt_slot(ts->input, slot); 86 input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, true); 87 touchscreen_report_pos(ts->input, &ts->props, x, y, true); 88 input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR, w); 89 } 90 91 input_mt_sync_frame(ts->input); 92 input_sync(ts->input); 93 } 94 95 static irqreturn_t cy8ctma140_irq_thread(int irq, void *d) 96 { 97 struct cy8ctma140 *ts = d; 98 u8 cmdbuf[] = { CY8CTMA140_GET_FINGERS }; 99 u8 buf[CY8CTMA140_PACKET_SIZE]; 100 struct i2c_msg msg[] = { 101 { 102 .addr = ts->client->addr, 103 .flags = 0, 104 .len = sizeof(cmdbuf), 105 .buf = cmdbuf, 106 }, { 107 .addr = ts->client->addr, 108 .flags = I2C_M_RD, 109 .len = sizeof(buf), 110 .buf = buf, 111 }, 112 }; 113 u8 n_fingers; 114 int ret; 115 116 ret = i2c_transfer(ts->client->adapter, msg, ARRAY_SIZE(msg)); 117 if (ret != ARRAY_SIZE(msg)) { 118 if (ret < 0) 119 dev_err(ts->dev, "error reading message: %d\n", ret); 120 else 121 dev_err(ts->dev, "wrong number of messages\n"); 122 goto out; 123 } 124 125 if (buf[1] & BIT(CY8CTMA140_INVALID_BUFFER_BIT)) { 126 dev_dbg(ts->dev, "invalid event\n"); 127 goto out; 128 } 129 130 n_fingers = buf[2] & 0x0f; 131 if (n_fingers > CY8CTMA140_MAX_FINGERS) { 132 dev_err(ts->dev, "unexpected number of fingers: %d\n", 133 n_fingers); 134 goto out; 135 } 136 137 cy8ctma140_report(ts, buf, n_fingers); 138 139 out: 140 return IRQ_HANDLED; 141 } 142 143 static int cy8ctma140_init(struct cy8ctma140 *ts) 144 { 145 u8 addr[1]; 146 u8 buf[5]; 147 int ret; 148 149 addr[0] = CY8CTMA140_GET_FW_INFO; 150 ret = i2c_master_send(ts->client, addr, 1); 151 if (ret < 0) { 152 dev_err(ts->dev, "error sending FW info message\n"); 153 return ret; 154 } 155 ret = i2c_master_recv(ts->client, buf, 5); 156 if (ret < 0) { 157 dev_err(ts->dev, "error receiving FW info message\n"); 158 return ret; 159 } 160 if (ret != 5) { 161 dev_err(ts->dev, "got only %d bytes\n", ret); 162 return -EIO; 163 } 164 165 dev_dbg(ts->dev, "vendor %c%c, HW ID %.2d, FW ver %.4d\n", 166 buf[0], buf[1], buf[3], buf[4]); 167 168 return 0; 169 } 170 171 static int cy8ctma140_power_up(struct cy8ctma140 *ts) 172 { 173 int error; 174 175 error = regulator_bulk_enable(ARRAY_SIZE(ts->regulators), 176 ts->regulators); 177 if (error) { 178 dev_err(ts->dev, "failed to enable regulators\n"); 179 return error; 180 } 181 182 msleep(250); 183 184 return 0; 185 } 186 187 static void cy8ctma140_power_down(struct cy8ctma140 *ts) 188 { 189 regulator_bulk_disable(ARRAY_SIZE(ts->regulators), 190 ts->regulators); 191 } 192 193 /* Called from the registered devm action */ 194 static void cy8ctma140_power_off_action(void *d) 195 { 196 struct cy8ctma140 *ts = d; 197 198 cy8ctma140_power_down(ts); 199 } 200 201 static int cy8ctma140_probe(struct i2c_client *client, 202 const struct i2c_device_id *id) 203 { 204 struct cy8ctma140 *ts; 205 struct input_dev *input; 206 struct device *dev = &client->dev; 207 int error; 208 209 ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL); 210 if (!ts) 211 return -ENOMEM; 212 213 input = devm_input_allocate_device(dev); 214 if (!input) 215 return -ENOMEM; 216 217 ts->dev = dev; 218 ts->client = client; 219 ts->input = input; 220 221 input_set_capability(input, EV_ABS, ABS_MT_POSITION_X); 222 input_set_capability(input, EV_ABS, ABS_MT_POSITION_Y); 223 /* One byte for width 0..255 so this is the limit */ 224 input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0); 225 /* 226 * This sets up event max/min capabilities and fuzz. 227 * Some DT properties are compulsory so we do not need 228 * to provide defaults for X/Y max or pressure max. 229 * 230 * We just initialize a very simple MT touchscreen here, 231 * some devices use the capability of this touchscreen to 232 * provide touchkeys, and in that case this needs to be 233 * extended to handle touchkey input. 234 * 235 * The firmware takes care of finger tracking and dropping 236 * invalid ranges. 237 */ 238 touchscreen_parse_properties(input, true, &ts->props); 239 input_abs_set_fuzz(input, ABS_MT_POSITION_X, 0); 240 input_abs_set_fuzz(input, ABS_MT_POSITION_Y, 0); 241 242 error = input_mt_init_slots(input, CY8CTMA140_MAX_FINGERS, 243 INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED); 244 if (error) 245 return error; 246 247 input->name = CY8CTMA140_NAME; 248 input->id.bustype = BUS_I2C; 249 input_set_drvdata(input, ts); 250 251 /* 252 * VCPIN is the analog voltage supply 253 * VDD is the digital voltage supply 254 * since the voltage range of VDD overlaps that of VCPIN, 255 * many designs to just supply both with a single voltage 256 * source of ~3.3 V. 257 */ 258 ts->regulators[0].supply = "vcpin"; 259 ts->regulators[1].supply = "vdd"; 260 error = devm_regulator_bulk_get(dev, ARRAY_SIZE(ts->regulators), 261 ts->regulators); 262 if (error) { 263 if (error != -EPROBE_DEFER) 264 dev_err(dev, "Failed to get regulators %d\n", 265 error); 266 return error; 267 } 268 269 error = cy8ctma140_power_up(ts); 270 if (error) 271 return error; 272 273 error = devm_add_action_or_reset(dev, cy8ctma140_power_off_action, ts); 274 if (error) { 275 dev_err(dev, "failed to install power off handler\n"); 276 return error; 277 } 278 279 error = devm_request_threaded_irq(dev, client->irq, 280 NULL, cy8ctma140_irq_thread, 281 IRQF_ONESHOT, CY8CTMA140_NAME, ts); 282 if (error) { 283 dev_err(dev, "irq %d busy? error %d\n", client->irq, error); 284 return error; 285 } 286 287 error = cy8ctma140_init(ts); 288 if (error) 289 return error; 290 291 error = input_register_device(input); 292 if (error) 293 return error; 294 295 i2c_set_clientdata(client, ts); 296 297 return 0; 298 } 299 300 static int __maybe_unused cy8ctma140_suspend(struct device *dev) 301 { 302 struct i2c_client *client = to_i2c_client(dev); 303 struct cy8ctma140 *ts = i2c_get_clientdata(client); 304 305 if (!device_may_wakeup(&client->dev)) 306 cy8ctma140_power_down(ts); 307 308 return 0; 309 } 310 311 static int __maybe_unused cy8ctma140_resume(struct device *dev) 312 { 313 struct i2c_client *client = to_i2c_client(dev); 314 struct cy8ctma140 *ts = i2c_get_clientdata(client); 315 int error; 316 317 if (!device_may_wakeup(&client->dev)) { 318 error = cy8ctma140_power_up(ts); 319 if (error) 320 return error; 321 } 322 323 return 0; 324 } 325 326 static SIMPLE_DEV_PM_OPS(cy8ctma140_pm, cy8ctma140_suspend, cy8ctma140_resume); 327 328 static const struct i2c_device_id cy8ctma140_idtable[] = { 329 { CY8CTMA140_NAME, 0 }, 330 { /* sentinel */ } 331 }; 332 MODULE_DEVICE_TABLE(i2c, cy8ctma140_idtable); 333 334 static const struct of_device_id cy8ctma140_of_match[] = { 335 { .compatible = "cypress,cy8ctma140", }, 336 { /* sentinel */ } 337 }; 338 MODULE_DEVICE_TABLE(of, cy8ctma140_of_match); 339 340 static struct i2c_driver cy8ctma140_driver = { 341 .driver = { 342 .name = CY8CTMA140_NAME, 343 .pm = &cy8ctma140_pm, 344 .of_match_table = cy8ctma140_of_match, 345 }, 346 .id_table = cy8ctma140_idtable, 347 .probe = cy8ctma140_probe, 348 }; 349 module_i2c_driver(cy8ctma140_driver); 350 351 MODULE_AUTHOR("Linus Walleij <linus.walleij@linaro.org>"); 352 MODULE_DESCRIPTION("CY8CTMA140 TouchScreen Driver"); 353 MODULE_LICENSE("GPL v2"); 354