1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2015-2016 Red Hat 4 * Copyright (C) 2015 Lyude Paul <thatslyude@gmail.com> 5 */ 6 7 #include <linux/kernel.h> 8 #include <linux/slab.h> 9 #include <linux/serio.h> 10 #include <linux/notifier.h> 11 #include "rmi_driver.h" 12 13 #define RMI_F03_RX_DATA_OFB 0x01 14 #define RMI_F03_OB_SIZE 2 15 16 #define RMI_F03_OB_OFFSET 2 17 #define RMI_F03_OB_DATA_OFFSET 1 18 #define RMI_F03_OB_FLAG_TIMEOUT BIT(6) 19 #define RMI_F03_OB_FLAG_PARITY BIT(7) 20 21 #define RMI_F03_DEVICE_COUNT 0x07 22 #define RMI_F03_BYTES_PER_DEVICE 0x07 23 #define RMI_F03_BYTES_PER_DEVICE_SHIFT 4 24 #define RMI_F03_QUEUE_LENGTH 0x0F 25 26 #define PSMOUSE_OOB_EXTRA_BTNS 0x01 27 28 struct f03_data { 29 struct rmi_function *fn; 30 31 struct serio *serio; 32 bool serio_registered; 33 34 unsigned int overwrite_buttons; 35 36 u8 device_count; 37 u8 rx_queue_length; 38 }; 39 40 int rmi_f03_overwrite_button(struct rmi_function *fn, unsigned int button, 41 int value) 42 { 43 struct f03_data *f03 = dev_get_drvdata(&fn->dev); 44 unsigned int bit; 45 46 if (button < BTN_LEFT || button > BTN_MIDDLE) 47 return -EINVAL; 48 49 bit = BIT(button - BTN_LEFT); 50 51 if (value) 52 f03->overwrite_buttons |= bit; 53 else 54 f03->overwrite_buttons &= ~bit; 55 56 return 0; 57 } 58 59 void rmi_f03_commit_buttons(struct rmi_function *fn) 60 { 61 struct f03_data *f03 = dev_get_drvdata(&fn->dev); 62 struct serio *serio = f03->serio; 63 64 serio_pause_rx(serio); 65 if (serio->drv) { 66 serio->drv->interrupt(serio, PSMOUSE_OOB_EXTRA_BTNS, 67 SERIO_OOB_DATA); 68 serio->drv->interrupt(serio, f03->overwrite_buttons, 69 SERIO_OOB_DATA); 70 } 71 serio_continue_rx(serio); 72 } 73 74 static int rmi_f03_pt_write(struct serio *id, unsigned char val) 75 { 76 struct f03_data *f03 = id->port_data; 77 int error; 78 79 rmi_dbg(RMI_DEBUG_FN, &f03->fn->dev, 80 "%s: Wrote %.2hhx to PS/2 passthrough address", 81 __func__, val); 82 83 error = rmi_write(f03->fn->rmi_dev, f03->fn->fd.data_base_addr, val); 84 if (error) { 85 dev_err(&f03->fn->dev, 86 "%s: Failed to write to F03 TX register (%d).\n", 87 __func__, error); 88 return error; 89 } 90 91 return 0; 92 } 93 94 static int rmi_f03_initialize(struct f03_data *f03) 95 { 96 struct rmi_function *fn = f03->fn; 97 struct device *dev = &fn->dev; 98 int error; 99 u8 bytes_per_device; 100 u8 query1; 101 u8 query2[RMI_F03_DEVICE_COUNT * RMI_F03_BYTES_PER_DEVICE]; 102 size_t query2_len; 103 104 error = rmi_read(fn->rmi_dev, fn->fd.query_base_addr, &query1); 105 if (error) { 106 dev_err(dev, "Failed to read query register (%d).\n", error); 107 return error; 108 } 109 110 f03->device_count = query1 & RMI_F03_DEVICE_COUNT; 111 bytes_per_device = (query1 >> RMI_F03_BYTES_PER_DEVICE_SHIFT) & 112 RMI_F03_BYTES_PER_DEVICE; 113 114 query2_len = f03->device_count * bytes_per_device; 115 116 /* 117 * The first generation of image sensors don't have a second part to 118 * their f03 query, as such we have to set some of these values manually 119 */ 120 if (query2_len < 1) { 121 f03->device_count = 1; 122 f03->rx_queue_length = 7; 123 } else { 124 error = rmi_read_block(fn->rmi_dev, fn->fd.query_base_addr + 1, 125 query2, query2_len); 126 if (error) { 127 dev_err(dev, 128 "Failed to read second set of query registers (%d).\n", 129 error); 130 return error; 131 } 132 133 f03->rx_queue_length = query2[0] & RMI_F03_QUEUE_LENGTH; 134 } 135 136 return 0; 137 } 138 139 static int rmi_f03_pt_open(struct serio *serio) 140 { 141 struct f03_data *f03 = serio->port_data; 142 struct rmi_function *fn = f03->fn; 143 const u8 ob_len = f03->rx_queue_length * RMI_F03_OB_SIZE; 144 const u16 data_addr = fn->fd.data_base_addr + RMI_F03_OB_OFFSET; 145 u8 obs[RMI_F03_QUEUE_LENGTH * RMI_F03_OB_SIZE]; 146 int error; 147 148 /* 149 * Consume any pending data. Some devices like to spam with 150 * 0xaa 0x00 announcements which may confuse us as we try to 151 * probe the device. 152 */ 153 error = rmi_read_block(fn->rmi_dev, data_addr, &obs, ob_len); 154 if (!error) 155 rmi_dbg(RMI_DEBUG_FN, &fn->dev, 156 "%s: Consumed %*ph (%d) from PS2 guest\n", 157 __func__, ob_len, obs, ob_len); 158 159 return fn->rmi_dev->driver->set_irq_bits(fn->rmi_dev, fn->irq_mask); 160 } 161 162 static void rmi_f03_pt_close(struct serio *serio) 163 { 164 struct f03_data *f03 = serio->port_data; 165 struct rmi_function *fn = f03->fn; 166 167 fn->rmi_dev->driver->clear_irq_bits(fn->rmi_dev, fn->irq_mask); 168 } 169 170 static int rmi_f03_register_pt(struct f03_data *f03) 171 { 172 struct serio *serio; 173 174 serio = kzalloc(sizeof(struct serio), GFP_KERNEL); 175 if (!serio) 176 return -ENOMEM; 177 178 serio->id.type = SERIO_PS_PSTHRU; 179 serio->write = rmi_f03_pt_write; 180 serio->open = rmi_f03_pt_open; 181 serio->close = rmi_f03_pt_close; 182 serio->port_data = f03; 183 184 strlcpy(serio->name, "RMI4 PS/2 pass-through", sizeof(serio->name)); 185 snprintf(serio->phys, sizeof(serio->phys), "%s/serio0", 186 dev_name(&f03->fn->dev)); 187 serio->dev.parent = &f03->fn->dev; 188 189 f03->serio = serio; 190 191 printk(KERN_INFO "serio: %s port at %s\n", 192 serio->name, dev_name(&f03->fn->dev)); 193 serio_register_port(serio); 194 195 return 0; 196 } 197 198 static int rmi_f03_probe(struct rmi_function *fn) 199 { 200 struct device *dev = &fn->dev; 201 struct f03_data *f03; 202 int error; 203 204 f03 = devm_kzalloc(dev, sizeof(struct f03_data), GFP_KERNEL); 205 if (!f03) 206 return -ENOMEM; 207 208 f03->fn = fn; 209 210 error = rmi_f03_initialize(f03); 211 if (error < 0) 212 return error; 213 214 if (f03->device_count != 1) 215 dev_warn(dev, "found %d devices on PS/2 passthrough", 216 f03->device_count); 217 218 dev_set_drvdata(dev, f03); 219 return 0; 220 } 221 222 static int rmi_f03_config(struct rmi_function *fn) 223 { 224 struct f03_data *f03 = dev_get_drvdata(&fn->dev); 225 int error; 226 227 if (!f03->serio_registered) { 228 error = rmi_f03_register_pt(f03); 229 if (error) 230 return error; 231 232 f03->serio_registered = true; 233 } else { 234 /* 235 * We must be re-configuring the sensor, just enable 236 * interrupts for this function. 237 */ 238 fn->rmi_dev->driver->set_irq_bits(fn->rmi_dev, fn->irq_mask); 239 } 240 241 return 0; 242 } 243 244 static irqreturn_t rmi_f03_attention(int irq, void *ctx) 245 { 246 struct rmi_function *fn = ctx; 247 struct rmi_device *rmi_dev = fn->rmi_dev; 248 struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev); 249 struct f03_data *f03 = dev_get_drvdata(&fn->dev); 250 const u16 data_addr = fn->fd.data_base_addr + RMI_F03_OB_OFFSET; 251 const u8 ob_len = f03->rx_queue_length * RMI_F03_OB_SIZE; 252 u8 obs[RMI_F03_QUEUE_LENGTH * RMI_F03_OB_SIZE]; 253 u8 ob_status; 254 u8 ob_data; 255 unsigned int serio_flags; 256 int i; 257 int error; 258 259 if (drvdata->attn_data.data) { 260 /* First grab the data passed by the transport device */ 261 if (drvdata->attn_data.size < ob_len) { 262 dev_warn(&fn->dev, "F03 interrupted, but data is missing!\n"); 263 return IRQ_HANDLED; 264 } 265 266 memcpy(obs, drvdata->attn_data.data, ob_len); 267 268 drvdata->attn_data.data += ob_len; 269 drvdata->attn_data.size -= ob_len; 270 } else { 271 /* Grab all of the data registers, and check them for data */ 272 error = rmi_read_block(fn->rmi_dev, data_addr, &obs, ob_len); 273 if (error) { 274 dev_err(&fn->dev, 275 "%s: Failed to read F03 output buffers: %d\n", 276 __func__, error); 277 serio_interrupt(f03->serio, 0, SERIO_TIMEOUT); 278 return IRQ_RETVAL(error); 279 } 280 } 281 282 for (i = 0; i < ob_len; i += RMI_F03_OB_SIZE) { 283 ob_status = obs[i]; 284 ob_data = obs[i + RMI_F03_OB_DATA_OFFSET]; 285 serio_flags = 0; 286 287 if (!(ob_status & RMI_F03_RX_DATA_OFB)) 288 continue; 289 290 if (ob_status & RMI_F03_OB_FLAG_TIMEOUT) 291 serio_flags |= SERIO_TIMEOUT; 292 if (ob_status & RMI_F03_OB_FLAG_PARITY) 293 serio_flags |= SERIO_PARITY; 294 295 rmi_dbg(RMI_DEBUG_FN, &fn->dev, 296 "%s: Received %.2hhx from PS2 guest T: %c P: %c\n", 297 __func__, ob_data, 298 serio_flags & SERIO_TIMEOUT ? 'Y' : 'N', 299 serio_flags & SERIO_PARITY ? 'Y' : 'N'); 300 301 serio_interrupt(f03->serio, ob_data, serio_flags); 302 } 303 304 return IRQ_HANDLED; 305 } 306 307 static void rmi_f03_remove(struct rmi_function *fn) 308 { 309 struct f03_data *f03 = dev_get_drvdata(&fn->dev); 310 311 if (f03->serio_registered) 312 serio_unregister_port(f03->serio); 313 } 314 315 struct rmi_function_handler rmi_f03_handler = { 316 .driver = { 317 .name = "rmi4_f03", 318 }, 319 .func = 0x03, 320 .probe = rmi_f03_probe, 321 .config = rmi_f03_config, 322 .attention = rmi_f03_attention, 323 .remove = rmi_f03_remove, 324 }; 325 326 MODULE_AUTHOR("Lyude Paul <thatslyude@gmail.com>"); 327 MODULE_DESCRIPTION("RMI F03 module"); 328 MODULE_LICENSE("GPL"); 329