Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2012-2016 Synaptics Incorporated |
| 3 | * |
| 4 | * This program is free software; you can redistribute it and/or modify it |
| 5 | * under the terms of the GNU General Public License version 2 as published by |
| 6 | * the Free Software Foundation. |
| 7 | */ |
| 8 | |
| 9 | #include <linux/kernel.h> |
| 10 | #include <linux/rmi.h> |
| 11 | #include <linux/input.h> |
| 12 | #include <linux/slab.h> |
| 13 | #include "rmi_driver.h" |
| 14 | |
| 15 | #define RMI_F30_QUERY_SIZE 2 |
| 16 | |
| 17 | /* Defs for Query 0 */ |
| 18 | #define RMI_F30_EXTENDED_PATTERNS 0x01 |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 19 | #define RMI_F30_HAS_MAPPABLE_BUTTONS BIT(1) |
| 20 | #define RMI_F30_HAS_LED BIT(2) |
| 21 | #define RMI_F30_HAS_GPIO BIT(3) |
| 22 | #define RMI_F30_HAS_HAPTIC BIT(4) |
| 23 | #define RMI_F30_HAS_GPIO_DRV_CTL BIT(5) |
| 24 | #define RMI_F30_HAS_MECH_MOUSE_BTNS BIT(6) |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 25 | |
| 26 | /* Defs for Query 1 */ |
| 27 | #define RMI_F30_GPIO_LED_COUNT 0x1F |
| 28 | |
| 29 | /* Defs for Control Registers */ |
| 30 | #define RMI_F30_CTRL_1_GPIO_DEBOUNCE 0x01 |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 31 | #define RMI_F30_CTRL_1_HALT BIT(4) |
| 32 | #define RMI_F30_CTRL_1_HALTED BIT(5) |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 33 | #define RMI_F30_CTRL_10_NUM_MECH_MOUSE_BTNS 0x03 |
| 34 | |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 35 | #define RMI_F30_CTRL_MAX_REGS 32 |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 36 | #define RMI_F30_CTRL_MAX_BYTES DIV_ROUND_UP(RMI_F30_CTRL_MAX_REGS, 8) |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 37 | #define RMI_F30_CTRL_MAX_REG_BLOCKS 11 |
| 38 | |
| 39 | #define RMI_F30_CTRL_REGS_MAX_SIZE (RMI_F30_CTRL_MAX_BYTES \ |
| 40 | + 1 \ |
| 41 | + RMI_F30_CTRL_MAX_BYTES \ |
| 42 | + RMI_F30_CTRL_MAX_BYTES \ |
| 43 | + RMI_F30_CTRL_MAX_BYTES \ |
| 44 | + 6 \ |
| 45 | + RMI_F30_CTRL_MAX_REGS \ |
| 46 | + RMI_F30_CTRL_MAX_REGS \ |
| 47 | + RMI_F30_CTRL_MAX_BYTES \ |
| 48 | + 1 \ |
| 49 | + 1) |
| 50 | |
Benjamin Tissoires | 81dec80 | 2017-02-08 00:26:45 -0800 | [diff] [blame] | 51 | #define TRACKSTICK_RANGE_START 3 |
| 52 | #define TRACKSTICK_RANGE_END 6 |
| 53 | |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 54 | struct rmi_f30_ctrl_data { |
| 55 | int address; |
| 56 | int length; |
| 57 | u8 *regs; |
| 58 | }; |
| 59 | |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 60 | struct f30_data { |
| 61 | /* Query Data */ |
| 62 | bool has_extended_pattern; |
| 63 | bool has_mappable_buttons; |
| 64 | bool has_led; |
| 65 | bool has_gpio; |
| 66 | bool has_haptic; |
| 67 | bool has_gpio_driver_control; |
| 68 | bool has_mech_mouse_btns; |
| 69 | u8 gpioled_count; |
| 70 | |
| 71 | u8 register_count; |
| 72 | |
| 73 | /* Control Register Data */ |
| 74 | struct rmi_f30_ctrl_data ctrl[RMI_F30_CTRL_MAX_REG_BLOCKS]; |
| 75 | u8 ctrl_regs[RMI_F30_CTRL_REGS_MAX_SIZE]; |
| 76 | u32 ctrl_regs_size; |
| 77 | |
| 78 | u8 data_regs[RMI_F30_CTRL_MAX_BYTES]; |
| 79 | u16 *gpioled_key_map; |
| 80 | |
| 81 | struct input_dev *input; |
Benjamin Tissoires | 81dec80 | 2017-02-08 00:26:45 -0800 | [diff] [blame] | 82 | |
| 83 | struct rmi_function *f03; |
| 84 | bool trackstick_buttons; |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 85 | }; |
| 86 | |
| 87 | static int rmi_f30_read_control_parameters(struct rmi_function *fn, |
| 88 | struct f30_data *f30) |
| 89 | { |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 90 | int error; |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 91 | |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 92 | error = rmi_read_block(fn->rmi_dev, fn->fd.control_base_addr, |
| 93 | f30->ctrl_regs, f30->ctrl_regs_size); |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 94 | if (error) { |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 95 | dev_err(&fn->dev, |
| 96 | "%s: Could not read control registers at 0x%x: %d\n", |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 97 | __func__, fn->fd.control_base_addr, error); |
| 98 | return error; |
| 99 | } |
| 100 | |
| 101 | return 0; |
| 102 | } |
| 103 | |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 104 | static void rmi_f30_report_button(struct rmi_function *fn, |
| 105 | struct f30_data *f30, unsigned int button) |
| 106 | { |
| 107 | unsigned int reg_num = button >> 3; |
| 108 | unsigned int bit_num = button & 0x07; |
Benjamin Tissoires | 81dec80 | 2017-02-08 00:26:45 -0800 | [diff] [blame] | 109 | u16 key_code = f30->gpioled_key_map[button]; |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 110 | bool key_down = !(f30->data_regs[reg_num] & BIT(bit_num)); |
| 111 | |
Benjamin Tissoires | 81dec80 | 2017-02-08 00:26:45 -0800 | [diff] [blame] | 112 | if (f30->trackstick_buttons && |
| 113 | button >= TRACKSTICK_RANGE_START && |
| 114 | button <= TRACKSTICK_RANGE_END) { |
| 115 | rmi_f03_overwrite_button(f30->f03, key_code, key_down); |
| 116 | } else { |
| 117 | rmi_dbg(RMI_DEBUG_FN, &fn->dev, |
| 118 | "%s: call input report key (0x%04x) value (0x%02x)", |
| 119 | __func__, key_code, key_down); |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 120 | |
Benjamin Tissoires | 81dec80 | 2017-02-08 00:26:45 -0800 | [diff] [blame] | 121 | input_report_key(f30->input, key_code, key_down); |
| 122 | } |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 123 | } |
| 124 | |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 125 | static int rmi_f30_attention(struct rmi_function *fn, unsigned long *irq_bits) |
| 126 | { |
| 127 | struct f30_data *f30 = dev_get_drvdata(&fn->dev); |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 128 | struct rmi_driver_data *drvdata = dev_get_drvdata(&fn->rmi_dev->dev); |
| 129 | int error; |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 130 | int i; |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 131 | |
| 132 | /* Read the gpi led data. */ |
Benjamin Tissoires | ae9979c | 2016-12-02 17:49:10 -0800 | [diff] [blame] | 133 | if (drvdata->attn_data.data) { |
| 134 | if (drvdata->attn_data.size < f30->register_count) { |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 135 | dev_warn(&fn->dev, |
| 136 | "F30 interrupted, but data is missing\n"); |
Andrew Duggan | 6d0dbea | 2016-11-08 16:46:20 -0800 | [diff] [blame] | 137 | return 0; |
| 138 | } |
Benjamin Tissoires | ae9979c | 2016-12-02 17:49:10 -0800 | [diff] [blame] | 139 | memcpy(f30->data_regs, drvdata->attn_data.data, |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 140 | f30->register_count); |
Benjamin Tissoires | ae9979c | 2016-12-02 17:49:10 -0800 | [diff] [blame] | 141 | drvdata->attn_data.data += f30->register_count; |
| 142 | drvdata->attn_data.size -= f30->register_count; |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 143 | } else { |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 144 | error = rmi_read_block(fn->rmi_dev, fn->fd.data_base_addr, |
| 145 | f30->data_regs, f30->register_count); |
| 146 | if (error) { |
| 147 | dev_err(&fn->dev, |
| 148 | "%s: Failed to read F30 data registers: %d\n", |
| 149 | __func__, error); |
| 150 | return error; |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 151 | } |
| 152 | } |
| 153 | |
Benjamin Tissoires | 81dec80 | 2017-02-08 00:26:45 -0800 | [diff] [blame] | 154 | if (f30->has_gpio) { |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 155 | for (i = 0; i < f30->gpioled_count; i++) |
| 156 | if (f30->gpioled_key_map[i] != KEY_RESERVED) |
| 157 | rmi_f30_report_button(fn, f30, i); |
Benjamin Tissoires | 81dec80 | 2017-02-08 00:26:45 -0800 | [diff] [blame] | 158 | if (f30->trackstick_buttons) |
| 159 | rmi_f03_commit_buttons(f30->f03); |
| 160 | } |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 161 | |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 162 | return 0; |
| 163 | } |
| 164 | |
| 165 | static int rmi_f30_config(struct rmi_function *fn) |
| 166 | { |
| 167 | struct f30_data *f30 = dev_get_drvdata(&fn->dev); |
| 168 | struct rmi_driver *drv = fn->rmi_dev->driver; |
| 169 | const struct rmi_device_platform_data *pdata = |
| 170 | rmi_get_platform_data(fn->rmi_dev); |
| 171 | int error; |
| 172 | |
Benjamin Tissoires | 81dec80 | 2017-02-08 00:26:45 -0800 | [diff] [blame] | 173 | if (pdata->f30_data.trackstick_buttons) { |
| 174 | /* Try [re-]establish link to F03. */ |
| 175 | f30->f03 = rmi_find_function(fn->rmi_dev, 0x03); |
| 176 | f30->trackstick_buttons = f30->f03 != NULL; |
| 177 | } |
| 178 | |
Benjamin Tissoires | 0a135b8 | 2016-11-30 17:01:50 -0800 | [diff] [blame] | 179 | if (pdata->f30_data.disable) { |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 180 | drv->clear_irq_bits(fn->rmi_dev, fn->irq_mask); |
| 181 | } else { |
| 182 | /* Write Control Register values back to device */ |
| 183 | error = rmi_write_block(fn->rmi_dev, fn->fd.control_base_addr, |
| 184 | f30->ctrl_regs, f30->ctrl_regs_size); |
| 185 | if (error) { |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 186 | dev_err(&fn->dev, |
| 187 | "%s: Could not write control registers at 0x%x: %d\n", |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 188 | __func__, fn->fd.control_base_addr, error); |
| 189 | return error; |
| 190 | } |
| 191 | |
| 192 | drv->set_irq_bits(fn->rmi_dev, fn->irq_mask); |
| 193 | } |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 194 | |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 195 | return 0; |
| 196 | } |
| 197 | |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 198 | static void rmi_f30_set_ctrl_data(struct rmi_f30_ctrl_data *ctrl, |
| 199 | int *ctrl_addr, int len, u8 **reg) |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 200 | { |
| 201 | ctrl->address = *ctrl_addr; |
| 202 | ctrl->length = len; |
| 203 | ctrl->regs = *reg; |
| 204 | *ctrl_addr += len; |
| 205 | *reg += len; |
| 206 | } |
| 207 | |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 208 | static bool rmi_f30_is_valid_button(int button, struct rmi_f30_ctrl_data *ctrl) |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 209 | { |
| 210 | int byte_position = button >> 3; |
| 211 | int bit_position = button & 0x07; |
| 212 | |
| 213 | /* |
| 214 | * ctrl2 -> dir == 0 -> input mode |
| 215 | * ctrl3 -> data == 1 -> actual button |
| 216 | */ |
| 217 | return !(ctrl[2].regs[byte_position] & BIT(bit_position)) && |
| 218 | (ctrl[3].regs[byte_position] & BIT(bit_position)); |
| 219 | } |
| 220 | |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 221 | static int rmi_f30_map_gpios(struct rmi_function *fn, |
| 222 | struct f30_data *f30) |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 223 | { |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 224 | const struct rmi_device_platform_data *pdata = |
| 225 | rmi_get_platform_data(fn->rmi_dev); |
| 226 | struct input_dev *input = f30->input; |
| 227 | unsigned int button = BTN_LEFT; |
Benjamin Tissoires | 81dec80 | 2017-02-08 00:26:45 -0800 | [diff] [blame] | 228 | unsigned int trackstick_button = BTN_LEFT; |
| 229 | bool button_mapped = false; |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 230 | int i; |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 231 | |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 232 | f30->gpioled_key_map = devm_kcalloc(&fn->dev, |
| 233 | f30->gpioled_count, |
| 234 | sizeof(f30->gpioled_key_map[0]), |
| 235 | GFP_KERNEL); |
| 236 | if (!f30->gpioled_key_map) { |
| 237 | dev_err(&fn->dev, "Failed to allocate gpioled map memory.\n"); |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 238 | return -ENOMEM; |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 239 | } |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 240 | |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 241 | for (i = 0; i < f30->gpioled_count; i++) { |
Benjamin Tissoires | 81dec80 | 2017-02-08 00:26:45 -0800 | [diff] [blame] | 242 | if (!rmi_f30_is_valid_button(i, f30->ctrl)) |
| 243 | continue; |
| 244 | |
| 245 | if (pdata->f30_data.trackstick_buttons && |
| 246 | i >= TRACKSTICK_RANGE_START && i < TRACKSTICK_RANGE_END) { |
| 247 | f30->gpioled_key_map[i] = trackstick_button++; |
| 248 | } else if (!pdata->f30_data.buttonpad || !button_mapped) { |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 249 | f30->gpioled_key_map[i] = button; |
| 250 | input_set_capability(input, EV_KEY, button++); |
Benjamin Tissoires | 81dec80 | 2017-02-08 00:26:45 -0800 | [diff] [blame] | 251 | button_mapped = true; |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 252 | } |
| 253 | } |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 254 | |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 255 | input->keycode = f30->gpioled_key_map; |
| 256 | input->keycodesize = sizeof(f30->gpioled_key_map[0]); |
| 257 | input->keycodemax = f30->gpioled_count; |
| 258 | |
Benjamin Tissoires | 81dec80 | 2017-02-08 00:26:45 -0800 | [diff] [blame] | 259 | /* |
| 260 | * Buttonpad could be also inferred from f30->has_mech_mouse_btns, |
| 261 | * but I am not sure, so use only the pdata info. |
| 262 | */ |
| 263 | if (pdata->f30_data.buttonpad) |
| 264 | __set_bit(INPUT_PROP_BUTTONPAD, input->propbit); |
| 265 | |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 266 | return 0; |
| 267 | } |
| 268 | |
| 269 | static int rmi_f30_initialize(struct rmi_function *fn, struct f30_data *f30) |
| 270 | { |
| 271 | u8 *ctrl_reg = f30->ctrl_regs; |
| 272 | int control_address = fn->fd.control_base_addr; |
| 273 | u8 buf[RMI_F30_QUERY_SIZE]; |
| 274 | int error; |
| 275 | |
| 276 | error = rmi_read_block(fn->rmi_dev, fn->fd.query_base_addr, |
| 277 | buf, RMI_F30_QUERY_SIZE); |
| 278 | if (error) { |
| 279 | dev_err(&fn->dev, "Failed to read query register\n"); |
| 280 | return error; |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 281 | } |
| 282 | |
| 283 | f30->has_extended_pattern = buf[0] & RMI_F30_EXTENDED_PATTERNS; |
| 284 | f30->has_mappable_buttons = buf[0] & RMI_F30_HAS_MAPPABLE_BUTTONS; |
| 285 | f30->has_led = buf[0] & RMI_F30_HAS_LED; |
| 286 | f30->has_gpio = buf[0] & RMI_F30_HAS_GPIO; |
| 287 | f30->has_haptic = buf[0] & RMI_F30_HAS_HAPTIC; |
| 288 | f30->has_gpio_driver_control = buf[0] & RMI_F30_HAS_GPIO_DRV_CTL; |
| 289 | f30->has_mech_mouse_btns = buf[0] & RMI_F30_HAS_MECH_MOUSE_BTNS; |
| 290 | f30->gpioled_count = buf[1] & RMI_F30_GPIO_LED_COUNT; |
| 291 | |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 292 | f30->register_count = DIV_ROUND_UP(f30->gpioled_count, 8); |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 293 | |
| 294 | if (f30->has_gpio && f30->has_led) |
| 295 | rmi_f30_set_ctrl_data(&f30->ctrl[0], &control_address, |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 296 | f30->register_count, &ctrl_reg); |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 297 | |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 298 | rmi_f30_set_ctrl_data(&f30->ctrl[1], &control_address, |
| 299 | sizeof(u8), &ctrl_reg); |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 300 | |
| 301 | if (f30->has_gpio) { |
| 302 | rmi_f30_set_ctrl_data(&f30->ctrl[2], &control_address, |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 303 | f30->register_count, &ctrl_reg); |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 304 | |
| 305 | rmi_f30_set_ctrl_data(&f30->ctrl[3], &control_address, |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 306 | f30->register_count, &ctrl_reg); |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 307 | } |
| 308 | |
| 309 | if (f30->has_led) { |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 310 | rmi_f30_set_ctrl_data(&f30->ctrl[4], &control_address, |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 311 | f30->register_count, &ctrl_reg); |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 312 | |
| 313 | rmi_f30_set_ctrl_data(&f30->ctrl[5], &control_address, |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 314 | f30->has_extended_pattern ? 6 : 2, |
| 315 | &ctrl_reg); |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 316 | } |
| 317 | |
| 318 | if (f30->has_led || f30->has_gpio_driver_control) { |
| 319 | /* control 6 uses a byte per gpio/led */ |
| 320 | rmi_f30_set_ctrl_data(&f30->ctrl[6], &control_address, |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 321 | f30->gpioled_count, &ctrl_reg); |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 322 | } |
| 323 | |
| 324 | if (f30->has_mappable_buttons) { |
| 325 | /* control 7 uses a byte per gpio/led */ |
| 326 | rmi_f30_set_ctrl_data(&f30->ctrl[7], &control_address, |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 327 | f30->gpioled_count, &ctrl_reg); |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 328 | } |
| 329 | |
| 330 | if (f30->has_haptic) { |
| 331 | rmi_f30_set_ctrl_data(&f30->ctrl[8], &control_address, |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 332 | f30->register_count, &ctrl_reg); |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 333 | |
| 334 | rmi_f30_set_ctrl_data(&f30->ctrl[9], &control_address, |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 335 | sizeof(u8), &ctrl_reg); |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 336 | } |
| 337 | |
| 338 | if (f30->has_mech_mouse_btns) |
| 339 | rmi_f30_set_ctrl_data(&f30->ctrl[10], &control_address, |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 340 | sizeof(u8), &ctrl_reg); |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 341 | |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 342 | f30->ctrl_regs_size = ctrl_reg - |
| 343 | f30->ctrl_regs ?: RMI_F30_CTRL_REGS_MAX_SIZE; |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 344 | |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 345 | error = rmi_f30_read_control_parameters(fn, f30); |
| 346 | if (error) { |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 347 | dev_err(&fn->dev, |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 348 | "Failed to initialize F30 control params: %d\n", |
| 349 | error); |
| 350 | return error; |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 351 | } |
| 352 | |
Benjamin Tissoires | 0a135b8 | 2016-11-30 17:01:50 -0800 | [diff] [blame] | 353 | if (f30->has_gpio) { |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 354 | error = rmi_f30_map_gpios(fn, f30); |
| 355 | if (error) |
| 356 | return error; |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 357 | } |
| 358 | |
| 359 | return 0; |
| 360 | } |
| 361 | |
| 362 | static int rmi_f30_probe(struct rmi_function *fn) |
| 363 | { |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 364 | struct rmi_device *rmi_dev = fn->rmi_dev; |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 365 | const struct rmi_device_platform_data *pdata = |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 366 | rmi_get_platform_data(rmi_dev); |
| 367 | struct rmi_driver_data *drv_data = dev_get_drvdata(&rmi_dev->dev); |
| 368 | struct f30_data *f30; |
| 369 | int error; |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 370 | |
Benjamin Tissoires | 0a135b8 | 2016-11-30 17:01:50 -0800 | [diff] [blame] | 371 | if (pdata->f30_data.disable) |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 372 | return 0; |
| 373 | |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 374 | if (!drv_data->input) { |
| 375 | dev_info(&fn->dev, "F30: no input device found, ignoring\n"); |
| 376 | return -ENXIO; |
| 377 | } |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 378 | |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 379 | f30 = devm_kzalloc(&fn->dev, sizeof(*f30), GFP_KERNEL); |
| 380 | if (!f30) |
| 381 | return -ENOMEM; |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 382 | |
Dmitry Torokhov | bf3e850 | 2017-02-08 12:02:07 -0800 | [diff] [blame] | 383 | f30->input = drv_data->input; |
| 384 | |
| 385 | error = rmi_f30_initialize(fn, f30); |
| 386 | if (error) |
| 387 | return error; |
| 388 | |
| 389 | dev_set_drvdata(&fn->dev, f30); |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 390 | return 0; |
Andrew Duggan | 562b42d | 2016-03-10 15:56:58 -0800 | [diff] [blame] | 391 | } |
| 392 | |
| 393 | struct rmi_function_handler rmi_f30_handler = { |
| 394 | .driver = { |
| 395 | .name = "rmi4_f30", |
| 396 | }, |
| 397 | .func = 0x30, |
| 398 | .probe = rmi_f30_probe, |
| 399 | .config = rmi_f30_config, |
| 400 | .attention = rmi_f30_attention, |
| 401 | }; |