input/rmi4/rmi_f30.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (c) 2012-2016 Synaptics Incorporated
0004  */
0005
0006 #include <linux/kernel.h>
0007 #include <linux/rmi.h>
0008 #include <linux/input.h>
0009 #include <linux/slab.h>
0010 #include "rmi_driver.h"
0011
0012 #define RMI_F30_QUERY_SIZE          2
0013
0014 /* Defs for Query 0 */
0015 #define RMI_F30_EXTENDED_PATTERNS       0x01
0016 #define RMI_F30_HAS_MAPPABLE_BUTTONS        BIT(1)
0017 #define RMI_F30_HAS_LED             BIT(2)
0018 #define RMI_F30_HAS_GPIO            BIT(3)
0019 #define RMI_F30_HAS_HAPTIC          BIT(4)
0020 #define RMI_F30_HAS_GPIO_DRV_CTL        BIT(5)
0021 #define RMI_F30_HAS_MECH_MOUSE_BTNS     BIT(6)
0022
0023 /* Defs for Query 1 */
0024 #define RMI_F30_GPIO_LED_COUNT          0x1F
0025
0026 /* Defs for Control Registers */
0027 #define RMI_F30_CTRL_1_GPIO_DEBOUNCE        0x01
0028 #define RMI_F30_CTRL_1_HALT         BIT(4)
0029 #define RMI_F30_CTRL_1_HALTED           BIT(5)
0030 #define RMI_F30_CTRL_10_NUM_MECH_MOUSE_BTNS 0x03
0031
0032 #define RMI_F30_CTRL_MAX_REGS       32
0033 #define RMI_F30_CTRL_MAX_BYTES      DIV_ROUND_UP(RMI_F30_CTRL_MAX_REGS, 8)
0034 #define RMI_F30_CTRL_MAX_REG_BLOCKS 11
0035
0036 #define RMI_F30_CTRL_REGS_MAX_SIZE (RMI_F30_CTRL_MAX_BYTES      \
0037                     + 1             \
0038                     + RMI_F30_CTRL_MAX_BYTES    \
0039                     + RMI_F30_CTRL_MAX_BYTES    \
0040                     + RMI_F30_CTRL_MAX_BYTES    \
0041                     + 6             \
0042                     + RMI_F30_CTRL_MAX_REGS     \
0043                     + RMI_F30_CTRL_MAX_REGS     \
0044                     + RMI_F30_CTRL_MAX_BYTES    \
0045                     + 1             \
0046                     + 1)
0047
0048 #define TRACKSTICK_RANGE_START      3
0049 #define TRACKSTICK_RANGE_END        6
0050
0051 struct rmi_f30_ctrl_data {
0052     int address;
0053     int length;
0054     u8 *regs;
0055 };
0056
0057 struct f30_data {
0058     /* Query Data */
0059     bool has_extended_pattern;
0060     bool has_mappable_buttons;
0061     bool has_led;
0062     bool has_gpio;
0063     bool has_haptic;
0064     bool has_gpio_driver_control;
0065     bool has_mech_mouse_btns;
0066     u8 gpioled_count;
0067
0068     u8 register_count;
0069
0070     /* Control Register Data */
0071     struct rmi_f30_ctrl_data ctrl[RMI_F30_CTRL_MAX_REG_BLOCKS];
0072     u8 ctrl_regs[RMI_F30_CTRL_REGS_MAX_SIZE];
0073     u32 ctrl_regs_size;
0074
0075     u8 data_regs[RMI_F30_CTRL_MAX_BYTES];
0076     u16 *gpioled_key_map;
0077
0078     struct input_dev *input;
0079
0080     struct rmi_function *f03;
0081     bool trackstick_buttons;
0082 };
0083
0084 static int rmi_f30_read_control_parameters(struct rmi_function *fn,
0085                         struct f30_data *f30)
0086 {
0087     int error;
0088
0089     error = rmi_read_block(fn->rmi_dev, fn->fd.control_base_addr,
0090                    f30->ctrl_regs, f30->ctrl_regs_size);
0091     if (error) {
0092         dev_err(&fn->dev,
0093             "%s: Could not read control registers at 0x%x: %d\n",
0094             __func__, fn->fd.control_base_addr, error);
0095         return error;
0096     }
0097
0098     return 0;
0099 }
0100
0101 static void rmi_f30_report_button(struct rmi_function *fn,
0102                   struct f30_data *f30, unsigned int button)
0103 {
0104     unsigned int reg_num = button >> 3;
0105     unsigned int bit_num = button & 0x07;
0106     u16 key_code = f30->gpioled_key_map[button];
0107     bool key_down = !(f30->data_regs[reg_num] & BIT(bit_num));
0108
0109     if (f30->trackstick_buttons &&
0110         button >= TRACKSTICK_RANGE_START &&
0111         button <= TRACKSTICK_RANGE_END) {
0112         rmi_f03_overwrite_button(f30->f03, key_code, key_down);
0113     } else {
0114         rmi_dbg(RMI_DEBUG_FN, &fn->dev,
0115             "%s: call input report key (0x%04x) value (0x%02x)",
0116             __func__, key_code, key_down);
0117
0118         input_report_key(f30->input, key_code, key_down);
0119     }
0120 }
0121
0122 static irqreturn_t rmi_f30_attention(int irq, void *ctx)
0123 {
0124     struct rmi_function *fn = ctx;
0125     struct f30_data *f30 = dev_get_drvdata(&fn->dev);
0126     struct rmi_driver_data *drvdata = dev_get_drvdata(&fn->rmi_dev->dev);
0127     int error;
0128     int i;
0129
0130     /* Read the gpi led data. */
0131     if (drvdata->attn_data.data) {
0132         if (drvdata->attn_data.size < f30->register_count) {
0133             dev_warn(&fn->dev,
0134                  "F30 interrupted, but data is missing\n");
0135             return IRQ_HANDLED;
0136         }
0137         memcpy(f30->data_regs, drvdata->attn_data.data,
0138             f30->register_count);
0139         drvdata->attn_data.data += f30->register_count;
0140         drvdata->attn_data.size -= f30->register_count;
0141     } else {
0142         error = rmi_read_block(fn->rmi_dev, fn->fd.data_base_addr,
0143                        f30->data_regs, f30->register_count);
0144         if (error) {
0145             dev_err(&fn->dev,
0146                 "%s: Failed to read F30 data registers: %d\n",
0147                 __func__, error);
0148             return IRQ_RETVAL(error);
0149         }
0150     }
0151
0152     if (f30->has_gpio) {
0153         for (i = 0; i < f30->gpioled_count; i++)
0154             if (f30->gpioled_key_map[i] != KEY_RESERVED)
0155                 rmi_f30_report_button(fn, f30, i);
0156         if (f30->trackstick_buttons)
0157             rmi_f03_commit_buttons(f30->f03);
0158     }
0159
0160     return IRQ_HANDLED;
0161 }
0162
0163 static int rmi_f30_config(struct rmi_function *fn)
0164 {
0165     struct f30_data *f30 = dev_get_drvdata(&fn->dev);
0166     struct rmi_driver *drv = fn->rmi_dev->driver;
0167     const struct rmi_device_platform_data *pdata =
0168                 rmi_get_platform_data(fn->rmi_dev);
0169     int error;
0170
0171     /* can happen if gpio_data.disable is set */
0172     if (!f30)
0173         return 0;
0174
0175     if (pdata->gpio_data.trackstick_buttons) {
0176         /* Try [re-]establish link to F03. */
0177         f30->f03 = rmi_find_function(fn->rmi_dev, 0x03);
0178         f30->trackstick_buttons = f30->f03 != NULL;
0179     }
0180
0181     if (pdata->gpio_data.disable) {
0182         drv->clear_irq_bits(fn->rmi_dev, fn->irq_mask);
0183     } else {
0184         /* Write Control Register values back to device */
0185         error = rmi_write_block(fn->rmi_dev, fn->fd.control_base_addr,
0186                     f30->ctrl_regs, f30->ctrl_regs_size);
0187         if (error) {
0188             dev_err(&fn->dev,
0189                 "%s: Could not write control registers at 0x%x: %d\n",
0190                 __func__, fn->fd.control_base_addr, error);
0191             return error;
0192         }
0193
0194         drv->set_irq_bits(fn->rmi_dev, fn->irq_mask);
0195     }
0196
0197     return 0;
0198 }
0199
0200 static void rmi_f30_set_ctrl_data(struct rmi_f30_ctrl_data *ctrl,
0201                   int *ctrl_addr, int len, u8 **reg)
0202 {
0203     ctrl->address = *ctrl_addr;
0204     ctrl->length = len;
0205     ctrl->regs = *reg;
0206     *ctrl_addr += len;
0207     *reg += len;
0208 }
0209
0210 static bool rmi_f30_is_valid_button(int button, struct rmi_f30_ctrl_data *ctrl)
0211 {
0212     int byte_position = button >> 3;
0213     int bit_position = button & 0x07;
0214
0215     /*
0216      * ctrl2 -> dir == 0 -> input mode
0217      * ctrl3 -> data == 1 -> actual button
0218      */
0219     return !(ctrl[2].regs[byte_position] & BIT(bit_position)) &&
0220         (ctrl[3].regs[byte_position] & BIT(bit_position));
0221 }
0222
0223 static int rmi_f30_map_gpios(struct rmi_function *fn,
0224                  struct f30_data *f30)
0225 {
0226     const struct rmi_device_platform_data *pdata =
0227                     rmi_get_platform_data(fn->rmi_dev);
0228     struct input_dev *input = f30->input;
0229     unsigned int button = BTN_LEFT;
0230     unsigned int trackstick_button = BTN_LEFT;
0231     bool button_mapped = false;
0232     int i;
0233     int button_count = min_t(u8, f30->gpioled_count, TRACKSTICK_RANGE_END);
0234
0235     f30->gpioled_key_map = devm_kcalloc(&fn->dev,
0236                         button_count,
0237                         sizeof(f30->gpioled_key_map[0]),
0238                         GFP_KERNEL);
0239     if (!f30->gpioled_key_map) {
0240         dev_err(&fn->dev, "Failed to allocate gpioled map memory.\n");
0241         return -ENOMEM;
0242     }
0243
0244     for (i = 0; i < button_count; i++) {
0245         if (!rmi_f30_is_valid_button(i, f30->ctrl))
0246             continue;
0247
0248         if (pdata->gpio_data.trackstick_buttons &&
0249             i >= TRACKSTICK_RANGE_START && i < TRACKSTICK_RANGE_END) {
0250             f30->gpioled_key_map[i] = trackstick_button++;
0251         } else if (!pdata->gpio_data.buttonpad || !button_mapped) {
0252             f30->gpioled_key_map[i] = button;
0253             input_set_capability(input, EV_KEY, button++);
0254             button_mapped = true;
0255         }
0256     }
0257
0258     input->keycode = f30->gpioled_key_map;
0259     input->keycodesize = sizeof(f30->gpioled_key_map[0]);
0260     input->keycodemax = f30->gpioled_count;
0261
0262     /*
0263      * Buttonpad could be also inferred from f30->has_mech_mouse_btns,
0264      * but I am not sure, so use only the pdata info and the number of
0265      * mapped buttons.
0266      */
0267     if (pdata->gpio_data.buttonpad || (button - BTN_LEFT == 1))
0268         __set_bit(INPUT_PROP_BUTTONPAD, input->propbit);
0269
0270     return 0;
0271 }
0272
0273 static int rmi_f30_initialize(struct rmi_function *fn, struct f30_data *f30)
0274 {
0275     u8 *ctrl_reg = f30->ctrl_regs;
0276     int control_address = fn->fd.control_base_addr;
0277     u8 buf[RMI_F30_QUERY_SIZE];
0278     int error;
0279
0280     error = rmi_read_block(fn->rmi_dev, fn->fd.query_base_addr,
0281                    buf, RMI_F30_QUERY_SIZE);
0282     if (error) {
0283         dev_err(&fn->dev, "Failed to read query register\n");
0284         return error;
0285     }
0286
0287     f30->has_extended_pattern = buf[0] & RMI_F30_EXTENDED_PATTERNS;
0288     f30->has_mappable_buttons = buf[0] & RMI_F30_HAS_MAPPABLE_BUTTONS;
0289     f30->has_led = buf[0] & RMI_F30_HAS_LED;
0290     f30->has_gpio = buf[0] & RMI_F30_HAS_GPIO;
0291     f30->has_haptic = buf[0] & RMI_F30_HAS_HAPTIC;
0292     f30->has_gpio_driver_control = buf[0] & RMI_F30_HAS_GPIO_DRV_CTL;
0293     f30->has_mech_mouse_btns = buf[0] & RMI_F30_HAS_MECH_MOUSE_BTNS;
0294     f30->gpioled_count = buf[1] & RMI_F30_GPIO_LED_COUNT;
0295
0296     f30->register_count = DIV_ROUND_UP(f30->gpioled_count, 8);
0297
0298     if (f30->has_gpio && f30->has_led)
0299         rmi_f30_set_ctrl_data(&f30->ctrl[0], &control_address,
0300                       f30->register_count, &ctrl_reg);
0301
0302     rmi_f30_set_ctrl_data(&f30->ctrl[1], &control_address,
0303                   sizeof(u8), &ctrl_reg);
0304
0305     if (f30->has_gpio) {
0306         rmi_f30_set_ctrl_data(&f30->ctrl[2], &control_address,
0307                       f30->register_count, &ctrl_reg);
0308
0309         rmi_f30_set_ctrl_data(&f30->ctrl[3], &control_address,
0310                       f30->register_count, &ctrl_reg);
0311     }
0312
0313     if (f30->has_led) {
0314         rmi_f30_set_ctrl_data(&f30->ctrl[4], &control_address,
0315                       f30->register_count, &ctrl_reg);
0316
0317         rmi_f30_set_ctrl_data(&f30->ctrl[5], &control_address,
0318                       f30->has_extended_pattern ? 6 : 2,
0319                       &ctrl_reg);
0320     }
0321
0322     if (f30->has_led || f30->has_gpio_driver_control) {
0323         /* control 6 uses a byte per gpio/led */
0324         rmi_f30_set_ctrl_data(&f30->ctrl[6], &control_address,
0325                       f30->gpioled_count, &ctrl_reg);
0326     }
0327
0328     if (f30->has_mappable_buttons) {
0329         /* control 7 uses a byte per gpio/led */
0330         rmi_f30_set_ctrl_data(&f30->ctrl[7], &control_address,
0331                       f30->gpioled_count, &ctrl_reg);
0332     }
0333
0334     if (f30->has_haptic) {
0335         rmi_f30_set_ctrl_data(&f30->ctrl[8], &control_address,
0336                       f30->register_count, &ctrl_reg);
0337
0338         rmi_f30_set_ctrl_data(&f30->ctrl[9], &control_address,
0339                       sizeof(u8), &ctrl_reg);
0340     }
0341
0342     if (f30->has_mech_mouse_btns)
0343         rmi_f30_set_ctrl_data(&f30->ctrl[10], &control_address,
0344                       sizeof(u8), &ctrl_reg);
0345
0346     f30->ctrl_regs_size = ctrl_reg -
0347                 f30->ctrl_regs ?: RMI_F30_CTRL_REGS_MAX_SIZE;
0348
0349     error = rmi_f30_read_control_parameters(fn, f30);
0350     if (error) {
0351         dev_err(&fn->dev,
0352             "Failed to initialize F30 control params: %d\n",
0353             error);
0354         return error;
0355     }
0356
0357     if (f30->has_gpio) {
0358         error = rmi_f30_map_gpios(fn, f30);
0359         if (error)
0360             return error;
0361     }
0362
0363     return 0;
0364 }
0365
0366 static int rmi_f30_probe(struct rmi_function *fn)
0367 {
0368     struct rmi_device *rmi_dev = fn->rmi_dev;
0369     const struct rmi_device_platform_data *pdata =
0370                     rmi_get_platform_data(rmi_dev);
0371     struct rmi_driver_data *drv_data = dev_get_drvdata(&rmi_dev->dev);
0372     struct f30_data *f30;
0373     int error;
0374
0375     if (pdata->gpio_data.disable)
0376         return 0;
0377
0378     if (!drv_data->input) {
0379         dev_info(&fn->dev, "F30: no input device found, ignoring\n");
0380         return -ENXIO;
0381     }
0382
0383     f30 = devm_kzalloc(&fn->dev, sizeof(*f30), GFP_KERNEL);
0384     if (!f30)
0385         return -ENOMEM;
0386
0387     f30->input = drv_data->input;
0388
0389     error = rmi_f30_initialize(fn, f30);
0390     if (error)
0391         return error;
0392
0393     dev_set_drvdata(&fn->dev, f30);
0394     return 0;
0395 }
0396
0397 struct rmi_function_handler rmi_f30_handler = {
0398     .driver = {
0399         .name = "rmi4_f30",
0400     },
0401     .func = 0x30,
0402     .probe = rmi_f30_probe,
0403     .config = rmi_f30_config,
0404     .attention = rmi_f30_attention,
0405 };