1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2012-2020 Synaptics Incorporated 4 */ 5 6 #include <linux/kernel.h> 7 #include <linux/rmi.h> 8 #include <linux/input.h> 9 #include <linux/slab.h> 10 #include "rmi_driver.h" 11 12 #define RMI_F3A_MAX_GPIO_COUNT 128 13 #define RMI_F3A_MAX_REG_SIZE DIV_ROUND_UP(RMI_F3A_MAX_GPIO_COUNT, 8) 14 15 /* Defs for Query 0 */ 16 #define RMI_F3A_GPIO_COUNT 0x7F 17 18 #define RMI_F3A_DATA_REGS_MAX_SIZE RMI_F3A_MAX_REG_SIZE 19 20 #define TRACKSTICK_RANGE_START 3 21 #define TRACKSTICK_RANGE_END 6 22 23 struct f3a_data { 24 /* Query Data */ 25 u8 gpio_count; 26 27 u8 register_count; 28 29 u8 data_regs[RMI_F3A_DATA_REGS_MAX_SIZE]; 30 u16 *gpio_key_map; 31 32 struct input_dev *input; 33 34 struct rmi_function *f03; 35 bool trackstick_buttons; 36 }; 37 38 static void rmi_f3a_report_button(struct rmi_function *fn, 39 struct f3a_data *f3a, unsigned int button) 40 { 41 u16 key_code = f3a->gpio_key_map[button]; 42 bool key_down = !(f3a->data_regs[0] & BIT(button)); 43 44 if (f3a->trackstick_buttons && 45 button >= TRACKSTICK_RANGE_START && 46 button <= TRACKSTICK_RANGE_END) { 47 rmi_f03_overwrite_button(f3a->f03, key_code, key_down); 48 } else { 49 rmi_dbg(RMI_DEBUG_FN, &fn->dev, 50 "%s: call input report key (0x%04x) value (0x%02x)", 51 __func__, key_code, key_down); 52 input_report_key(f3a->input, key_code, key_down); 53 } 54 } 55 56 static irqreturn_t rmi_f3a_attention(int irq, void *ctx) 57 { 58 struct rmi_function *fn = ctx; 59 struct f3a_data *f3a = dev_get_drvdata(&fn->dev); 60 struct rmi_driver_data *drvdata = dev_get_drvdata(&fn->rmi_dev->dev); 61 int error; 62 int i; 63 64 if (drvdata->attn_data.data) { 65 if (drvdata->attn_data.size < f3a->register_count) { 66 dev_warn(&fn->dev, 67 "F3A interrupted, but data is missing\n"); 68 return IRQ_HANDLED; 69 } 70 memcpy(f3a->data_regs, drvdata->attn_data.data, 71 f3a->register_count); 72 drvdata->attn_data.data += f3a->register_count; 73 drvdata->attn_data.size -= f3a->register_count; 74 } else { 75 error = rmi_read_block(fn->rmi_dev, fn->fd.data_base_addr, 76 f3a->data_regs, f3a->register_count); 77 if (error) { 78 dev_err(&fn->dev, 79 "%s: Failed to read F3a data registers: %d\n", 80 __func__, error); 81 return IRQ_RETVAL(error); 82 } 83 } 84 85 for (i = 0; i < f3a->gpio_count; i++) 86 if (f3a->gpio_key_map[i] != KEY_RESERVED) 87 rmi_f3a_report_button(fn, f3a, i); 88 if (f3a->trackstick_buttons) 89 rmi_f03_commit_buttons(f3a->f03); 90 91 return IRQ_HANDLED; 92 } 93 94 static int rmi_f3a_config(struct rmi_function *fn) 95 { 96 struct f3a_data *f3a = dev_get_drvdata(&fn->dev); 97 struct rmi_driver *drv = fn->rmi_dev->driver; 98 const struct rmi_device_platform_data *pdata = 99 rmi_get_platform_data(fn->rmi_dev); 100 101 if (!f3a) 102 return 0; 103 104 if (pdata->gpio_data.trackstick_buttons) { 105 /* Try [re-]establish link to F03. */ 106 f3a->f03 = rmi_find_function(fn->rmi_dev, 0x03); 107 f3a->trackstick_buttons = f3a->f03 != NULL; 108 } 109 110 drv->set_irq_bits(fn->rmi_dev, fn->irq_mask); 111 112 return 0; 113 } 114 115 static bool rmi_f3a_is_valid_button(int button, struct f3a_data *f3a, 116 u8 *query1_regs, u8 *ctrl1_regs) 117 { 118 /* gpio exist && direction input */ 119 return (query1_regs[0] & BIT(button)) && !(ctrl1_regs[0] & BIT(button)); 120 } 121 122 static int rmi_f3a_map_gpios(struct rmi_function *fn, struct f3a_data *f3a, 123 u8 *query1_regs, u8 *ctrl1_regs) 124 { 125 const struct rmi_device_platform_data *pdata = 126 rmi_get_platform_data(fn->rmi_dev); 127 struct input_dev *input = f3a->input; 128 unsigned int button = BTN_LEFT; 129 unsigned int trackstick_button = BTN_LEFT; 130 bool button_mapped = false; 131 int i; 132 int button_count = min_t(u8, f3a->gpio_count, TRACKSTICK_RANGE_END); 133 134 f3a->gpio_key_map = devm_kcalloc(&fn->dev, 135 button_count, 136 sizeof(f3a->gpio_key_map[0]), 137 GFP_KERNEL); 138 if (!f3a->gpio_key_map) { 139 dev_err(&fn->dev, "Failed to allocate gpio map memory.\n"); 140 return -ENOMEM; 141 } 142 143 for (i = 0; i < button_count; i++) { 144 if (!rmi_f3a_is_valid_button(i, f3a, query1_regs, ctrl1_regs)) 145 continue; 146 147 if (pdata->gpio_data.trackstick_buttons && 148 i >= TRACKSTICK_RANGE_START && 149 i < TRACKSTICK_RANGE_END) { 150 f3a->gpio_key_map[i] = trackstick_button++; 151 } else if (!pdata->gpio_data.buttonpad || !button_mapped) { 152 f3a->gpio_key_map[i] = button; 153 input_set_capability(input, EV_KEY, button++); 154 button_mapped = true; 155 } 156 } 157 input->keycode = f3a->gpio_key_map; 158 input->keycodesize = sizeof(f3a->gpio_key_map[0]); 159 input->keycodemax = f3a->gpio_count; 160 161 if (pdata->gpio_data.buttonpad || (button - BTN_LEFT == 1)) 162 __set_bit(INPUT_PROP_BUTTONPAD, input->propbit); 163 164 return 0; 165 } 166 167 static int rmi_f3a_initialize(struct rmi_function *fn, struct f3a_data *f3a) 168 { 169 u8 query1[RMI_F3A_MAX_REG_SIZE]; 170 u8 ctrl1[RMI_F3A_MAX_REG_SIZE]; 171 u8 buf; 172 int error; 173 174 error = rmi_read(fn->rmi_dev, fn->fd.query_base_addr, &buf); 175 if (error < 0) { 176 dev_err(&fn->dev, "Failed to read general info register: %d\n", 177 error); 178 return -ENODEV; 179 } 180 181 f3a->gpio_count = buf & RMI_F3A_GPIO_COUNT; 182 f3a->register_count = DIV_ROUND_UP(f3a->gpio_count, 8); 183 184 /* Query1 -> gpio exist */ 185 error = rmi_read_block(fn->rmi_dev, fn->fd.query_base_addr + 1, 186 query1, f3a->register_count); 187 if (error) { 188 dev_err(&fn->dev, "Failed to read query1 register\n"); 189 return error; 190 } 191 192 /* Ctrl1 -> gpio direction */ 193 error = rmi_read_block(fn->rmi_dev, fn->fd.control_base_addr + 1, 194 ctrl1, f3a->register_count); 195 if (error) { 196 dev_err(&fn->dev, "Failed to read control1 register\n"); 197 return error; 198 } 199 200 error = rmi_f3a_map_gpios(fn, f3a, query1, ctrl1); 201 if (error) 202 return error; 203 204 return 0; 205 } 206 207 static int rmi_f3a_probe(struct rmi_function *fn) 208 { 209 struct rmi_device *rmi_dev = fn->rmi_dev; 210 struct rmi_driver_data *drv_data = dev_get_drvdata(&rmi_dev->dev); 211 struct f3a_data *f3a; 212 int error; 213 214 if (!drv_data->input) { 215 dev_info(&fn->dev, "F3A: no input device found, ignoring\n"); 216 return -ENXIO; 217 } 218 219 f3a = devm_kzalloc(&fn->dev, sizeof(*f3a), GFP_KERNEL); 220 if (!f3a) 221 return -ENOMEM; 222 223 f3a->input = drv_data->input; 224 225 error = rmi_f3a_initialize(fn, f3a); 226 if (error) 227 return error; 228 229 dev_set_drvdata(&fn->dev, f3a); 230 return 0; 231 } 232 233 struct rmi_function_handler rmi_f3a_handler = { 234 .driver = { 235 .name = "rmi4_f3a", 236 }, 237 .func = 0x3a, 238 .probe = rmi_f3a_probe, 239 .config = rmi_f3a_config, 240 .attention = rmi_f3a_attention, 241 }; 242