input/rmi4/rmi_f3a.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (c) 2012-2020 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_F3A_MAX_GPIO_COUNT      128
0013 #define RMI_F3A_MAX_REG_SIZE        DIV_ROUND_UP(RMI_F3A_MAX_GPIO_COUNT, 8)
0014
0015 /* Defs for Query 0 */
0016 #define RMI_F3A_GPIO_COUNT      0x7F
0017
0018 #define RMI_F3A_DATA_REGS_MAX_SIZE  RMI_F3A_MAX_REG_SIZE
0019
0020 #define TRACKSTICK_RANGE_START      3
0021 #define TRACKSTICK_RANGE_END        6
0022
0023 struct f3a_data {
0024     /* Query Data */
0025     u8 gpio_count;
0026
0027     u8 register_count;
0028
0029     u8 data_regs[RMI_F3A_DATA_REGS_MAX_SIZE];
0030     u16 *gpio_key_map;
0031
0032     struct input_dev *input;
0033
0034     struct rmi_function *f03;
0035     bool trackstick_buttons;
0036 };
0037
0038 static void rmi_f3a_report_button(struct rmi_function *fn,
0039                   struct f3a_data *f3a, unsigned int button)
0040 {
0041     u16 key_code = f3a->gpio_key_map[button];
0042     bool key_down = !(f3a->data_regs[0] & BIT(button));
0043
0044     if (f3a->trackstick_buttons &&
0045         button >= TRACKSTICK_RANGE_START &&
0046         button <= TRACKSTICK_RANGE_END) {
0047         rmi_f03_overwrite_button(f3a->f03, key_code, key_down);
0048     } else {
0049         rmi_dbg(RMI_DEBUG_FN, &fn->dev,
0050             "%s: call input report key (0x%04x) value (0x%02x)",
0051             __func__, key_code, key_down);
0052         input_report_key(f3a->input, key_code, key_down);
0053     }
0054 }
0055
0056 static irqreturn_t rmi_f3a_attention(int irq, void *ctx)
0057 {
0058     struct rmi_function *fn = ctx;
0059     struct f3a_data *f3a = dev_get_drvdata(&fn->dev);
0060     struct rmi_driver_data *drvdata = dev_get_drvdata(&fn->rmi_dev->dev);
0061     int error;
0062     int i;
0063
0064     if (drvdata->attn_data.data) {
0065         if (drvdata->attn_data.size < f3a->register_count) {
0066             dev_warn(&fn->dev,
0067                  "F3A interrupted, but data is missing\n");
0068             return IRQ_HANDLED;
0069         }
0070         memcpy(f3a->data_regs, drvdata->attn_data.data,
0071             f3a->register_count);
0072         drvdata->attn_data.data += f3a->register_count;
0073         drvdata->attn_data.size -= f3a->register_count;
0074     } else {
0075         error = rmi_read_block(fn->rmi_dev, fn->fd.data_base_addr,
0076                     f3a->data_regs, f3a->register_count);
0077         if (error) {
0078             dev_err(&fn->dev,
0079                 "%s: Failed to read F3a data registers: %d\n",
0080                 __func__, error);
0081             return IRQ_RETVAL(error);
0082         }
0083     }
0084
0085     for (i = 0; i < f3a->gpio_count; i++)
0086         if (f3a->gpio_key_map[i] != KEY_RESERVED)
0087             rmi_f3a_report_button(fn, f3a, i);
0088     if (f3a->trackstick_buttons)
0089         rmi_f03_commit_buttons(f3a->f03);
0090
0091     return IRQ_HANDLED;
0092 }
0093
0094 static int rmi_f3a_config(struct rmi_function *fn)
0095 {
0096     struct f3a_data *f3a = dev_get_drvdata(&fn->dev);
0097     struct rmi_driver *drv = fn->rmi_dev->driver;
0098     const struct rmi_device_platform_data *pdata =
0099             rmi_get_platform_data(fn->rmi_dev);
0100
0101     if (!f3a)
0102         return 0;
0103
0104     if (pdata->gpio_data.trackstick_buttons) {
0105         /* Try [re-]establish link to F03. */
0106         f3a->f03 = rmi_find_function(fn->rmi_dev, 0x03);
0107         f3a->trackstick_buttons = f3a->f03 != NULL;
0108     }
0109
0110     drv->set_irq_bits(fn->rmi_dev, fn->irq_mask);
0111
0112     return 0;
0113 }
0114
0115 static bool rmi_f3a_is_valid_button(int button, struct f3a_data *f3a,
0116                     u8 *query1_regs, u8 *ctrl1_regs)
0117 {
0118     /* gpio exist && direction input */
0119     return (query1_regs[0] & BIT(button)) && !(ctrl1_regs[0] & BIT(button));
0120 }
0121
0122 static int rmi_f3a_map_gpios(struct rmi_function *fn, struct f3a_data *f3a,
0123                 u8 *query1_regs, u8 *ctrl1_regs)
0124 {
0125     const struct rmi_device_platform_data *pdata =
0126             rmi_get_platform_data(fn->rmi_dev);
0127     struct input_dev *input = f3a->input;
0128     unsigned int button = BTN_LEFT;
0129     unsigned int trackstick_button = BTN_LEFT;
0130     bool button_mapped = false;
0131     int i;
0132     int button_count = min_t(u8, f3a->gpio_count, TRACKSTICK_RANGE_END);
0133
0134     f3a->gpio_key_map = devm_kcalloc(&fn->dev,
0135                         button_count,
0136                         sizeof(f3a->gpio_key_map[0]),
0137                         GFP_KERNEL);
0138     if (!f3a->gpio_key_map) {
0139         dev_err(&fn->dev, "Failed to allocate gpio map memory.\n");
0140         return -ENOMEM;
0141     }
0142
0143     for (i = 0; i < button_count; i++) {
0144         if (!rmi_f3a_is_valid_button(i, f3a, query1_regs, ctrl1_regs))
0145             continue;
0146
0147         if (pdata->gpio_data.trackstick_buttons &&
0148             i >= TRACKSTICK_RANGE_START &&
0149             i < TRACKSTICK_RANGE_END) {
0150             f3a->gpio_key_map[i] = trackstick_button++;
0151         } else if (!pdata->gpio_data.buttonpad || !button_mapped) {
0152             f3a->gpio_key_map[i] = button;
0153             input_set_capability(input, EV_KEY, button++);
0154             button_mapped = true;
0155         }
0156     }
0157     input->keycode = f3a->gpio_key_map;
0158     input->keycodesize = sizeof(f3a->gpio_key_map[0]);
0159     input->keycodemax = f3a->gpio_count;
0160
0161     if (pdata->gpio_data.buttonpad || (button - BTN_LEFT == 1))
0162         __set_bit(INPUT_PROP_BUTTONPAD, input->propbit);
0163
0164     return 0;
0165 }
0166
0167 static int rmi_f3a_initialize(struct rmi_function *fn, struct f3a_data *f3a)
0168 {
0169     u8 query1[RMI_F3A_MAX_REG_SIZE];
0170     u8 ctrl1[RMI_F3A_MAX_REG_SIZE];
0171     u8 buf;
0172     int error;
0173
0174     error = rmi_read(fn->rmi_dev, fn->fd.query_base_addr, &buf);
0175     if (error < 0) {
0176         dev_err(&fn->dev, "Failed to read general info register: %d\n",
0177             error);
0178         return -ENODEV;
0179     }
0180
0181     f3a->gpio_count = buf & RMI_F3A_GPIO_COUNT;
0182     f3a->register_count = DIV_ROUND_UP(f3a->gpio_count, 8);
0183
0184     /* Query1 -> gpio exist */
0185     error = rmi_read_block(fn->rmi_dev, fn->fd.query_base_addr + 1,
0186                 query1, f3a->register_count);
0187     if (error) {
0188         dev_err(&fn->dev, "Failed to read query1 register\n");
0189         return error;
0190     }
0191
0192     /* Ctrl1 -> gpio direction */
0193     error = rmi_read_block(fn->rmi_dev, fn->fd.control_base_addr + 1,
0194                 ctrl1, f3a->register_count);
0195     if (error) {
0196         dev_err(&fn->dev, "Failed to read control1 register\n");
0197         return error;
0198     }
0199
0200     error = rmi_f3a_map_gpios(fn, f3a, query1, ctrl1);
0201     if (error)
0202         return error;
0203
0204     return 0;
0205 }
0206
0207 static int rmi_f3a_probe(struct rmi_function *fn)
0208 {
0209     struct rmi_device *rmi_dev = fn->rmi_dev;
0210     struct rmi_driver_data *drv_data = dev_get_drvdata(&rmi_dev->dev);
0211     struct f3a_data *f3a;
0212     int error;
0213
0214     if (!drv_data->input) {
0215         dev_info(&fn->dev, "F3A: no input device found, ignoring\n");
0216         return -ENXIO;
0217     }
0218
0219     f3a = devm_kzalloc(&fn->dev, sizeof(*f3a), GFP_KERNEL);
0220     if (!f3a)
0221         return -ENOMEM;
0222
0223     f3a->input = drv_data->input;
0224
0225     error = rmi_f3a_initialize(fn, f3a);
0226     if (error)
0227         return error;
0228
0229     dev_set_drvdata(&fn->dev, f3a);
0230     return 0;
0231 }
0232
0233 struct rmi_function_handler rmi_f3a_handler = {
0234     .driver = {
0235         .name = "rmi4_f3a",
0236     },
0237     .func = 0x3a,
0238     .probe = rmi_f3a_probe,
0239     .config = rmi_f3a_config,
0240     .attention = rmi_f3a_attention,
0241 };