// SPDX-License-Identifier: GPL-2.0-only
/*
 * ROHM BU21023/24 Dual touch support resistive touch screen driver
 * Copyright (C) 2012 ROHM CO.,LTD.
 */
#include <linux/delay.h>
#include <linux/firmware.h>
#include <linux/i2c.h>
#include <linux/input.h>
#include <linux/input/mt.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/slab.h>

#define BU21023_NAME                    "bu21023_ts"
#define BU21023_FIRMWARE_NAME           "bu21023.bin"

#define MAX_CONTACTS                    2

#define AXIS_ADJUST                     4
#define AXIS_OFFSET                     8

#define FIRMWARE_BLOCK_SIZE             32U
#define FIRMWARE_RETRY_MAX              4

#define SAMPLING_DELAY                  12      /* msec */

#define CALIBRATION_RETRY_MAX           6

#define ROHM_TS_ABS_X_MIN               40
#define ROHM_TS_ABS_X_MAX               990
#define ROHM_TS_ABS_Y_MIN               160
#define ROHM_TS_ABS_Y_MAX               920
#define ROHM_TS_DISPLACEMENT_MAX        0       /* zero for infinite */

/*
 * BU21023GUL/BU21023MUV/BU21024FV-M registers map
 */
#define VADOUT_YP_H             0x00
#define VADOUT_YP_L             0x01
#define VADOUT_XP_H             0x02
#define VADOUT_XP_L             0x03
#define VADOUT_YN_H             0x04
#define VADOUT_YN_L             0x05
#define VADOUT_XN_H             0x06
#define VADOUT_XN_L             0x07

#define PRM1_X_H                0x08
#define PRM1_X_L                0x09
#define PRM1_Y_H                0x0a
#define PRM1_Y_L                0x0b
#define PRM2_X_H                0x0c
#define PRM2_X_L                0x0d
#define PRM2_Y_H                0x0e
#define PRM2_Y_L                0x0f

#define MLT_PRM_MONI_X          0x10
#define MLT_PRM_MONI_Y          0x11

#define DEBUG_MONI_1            0x12
#define DEBUG_MONI_2            0x13

#define VADOUT_ZX_H             0x14
#define VADOUT_ZX_L             0x15
#define VADOUT_ZY_H             0x16
#define VADOUT_ZY_L             0x17

#define Z_PARAM_H               0x18
#define Z_PARAM_L               0x19

/*
 * Value for VADOUT_*_L
 */
#define VADOUT_L_MASK           0x01

/*
 * Value for PRM*_*_L
 */
#define PRM_L_MASK              0x01

#define POS_X1_H                0x20
#define POS_X1_L                0x21
#define POS_Y1_H                0x22
#define POS_Y1_L                0x23
#define POS_X2_H                0x24
#define POS_X2_L                0x25
#define POS_Y2_H                0x26
#define POS_Y2_L                0x27

/*
 * Value for POS_*_L
 */
#define POS_L_MASK              0x01

#define TOUCH                   0x28
#define TOUCH_DETECT            0x01

#define TOUCH_GESTURE           0x29
#define SINGLE_TOUCH            0x01
#define DUAL_TOUCH              0x03
#define TOUCH_MASK              0x03
#define CALIBRATION_REQUEST     0x04
#define CALIBRATION_STATUS      0x08
#define CALIBRATION_MASK        0x0c
#define GESTURE_SPREAD          0x10
#define GESTURE_PINCH           0x20
#define GESTURE_ROTATE_R        0x40
#define GESTURE_ROTATE_L        0x80

#define INT_STATUS              0x2a
#define INT_MASK                0x3d
#define INT_CLEAR               0x3e

/*
 * Values for INT_*
 */
#define COORD_UPDATE            0x01
#define CALIBRATION_DONE        0x02
#define SLEEP_IN                0x04
#define SLEEP_OUT               0x08
#define PROGRAM_LOAD_DONE       0x10
#define ERROR                   0x80
#define INT_ALL                 0x9f

#define ERR_STATUS              0x2b
#define ERR_MASK                0x3f

/*
 * Values for ERR_*
 */
#define ADC_TIMEOUT             0x01
#define CPU_TIMEOUT             0x02
#define CALIBRATION_ERR         0x04
#define PROGRAM_LOAD_ERR        0x10

#define COMMON_SETUP1                   0x30
#define PROGRAM_LOAD_HOST               0x02
#define PROGRAM_LOAD_EEPROM             0x03
#define CENSOR_4PORT                    0x04
#define CENSOR_8PORT                    0x00    /* Not supported by BU21023 */
#define CALIBRATION_TYPE_DEFAULT        0x08
#define CALIBRATION_TYPE_SPECIAL        0x00
#define INT_ACTIVE_HIGH                 0x10
#define INT_ACTIVE_LOW                  0x00
#define AUTO_CALIBRATION                0x40
#define MANUAL_CALIBRATION              0x00
#define COMMON_SETUP1_DEFAULT           0x4e

#define COMMON_SETUP2           0x31
#define MAF_NONE                0x00
#define MAF_1SAMPLE             0x01
#define MAF_3SAMPLES            0x02
#define MAF_5SAMPLES            0x03
#define INV_Y                   0x04
#define INV_X                   0x08
#define SWAP_XY                 0x10

#define COMMON_SETUP3           0x32
#define EN_SLEEP                0x01
#define EN_MULTI                0x02
#define EN_GESTURE              0x04
#define EN_INTVL                0x08
#define SEL_STEP                0x10
#define SEL_MULTI               0x20
#define SEL_TBL_DEFAULT         0x40

#define INTERVAL_TIME           0x33
#define INTERVAL_TIME_DEFAULT   0x10

#define STEP_X                  0x34
#define STEP_X_DEFAULT          0x41

#define STEP_Y                  0x35
#define STEP_Y_DEFAULT          0x8d

#define OFFSET_X                0x38
#define OFFSET_X_DEFAULT        0x0c

#define OFFSET_Y                0x39
#define OFFSET_Y_DEFAULT        0x0c

#define THRESHOLD_TOUCH         0x3a
#define THRESHOLD_TOUCH_DEFAULT 0xa0

#define THRESHOLD_GESTURE               0x3b
#define THRESHOLD_GESTURE_DEFAULT       0x17

#define SYSTEM                  0x40
#define ANALOG_POWER_ON         0x01
#define ANALOG_POWER_OFF        0x00
#define CPU_POWER_ON            0x02
#define CPU_POWER_OFF           0x00

#define FORCE_CALIBRATION       0x42
#define FORCE_CALIBRATION_ON    0x01
#define FORCE_CALIBRATION_OFF   0x00

#define CPU_FREQ                0x50    /* 10 / (reg + 1) MHz */
#define CPU_FREQ_10MHZ          0x00
#define CPU_FREQ_5MHZ           0x01
#define CPU_FREQ_1MHZ           0x09

#define EEPROM_ADDR             0x51

#define CALIBRATION_ADJUST              0x52
#define CALIBRATION_ADJUST_DEFAULT      0x00

#define THRESHOLD_SLEEP_IN      0x53

#define EVR_XY                  0x56
#define EVR_XY_DEFAULT          0x10

#define PRM_SWOFF_TIME          0x57
#define PRM_SWOFF_TIME_DEFAULT  0x04

#define PROGRAM_VERSION         0x5f

#define ADC_CTRL                0x60
#define ADC_DIV_MASK            0x1f    /* The minimum value is 4 */
#define ADC_DIV_DEFAULT         0x08

#define ADC_WAIT                0x61
#define ADC_WAIT_DEFAULT        0x0a

#define SWCONT                  0x62
#define SWCONT_DEFAULT          0x0f

#define EVR_X                   0x63
#define EVR_X_DEFAULT           0x86

#define EVR_Y                   0x64
#define EVR_Y_DEFAULT           0x64

#define TEST1                   0x65
#define DUALTOUCH_STABILIZE_ON  0x01
#define DUALTOUCH_STABILIZE_OFF 0x00
#define DUALTOUCH_REG_ON        0x20
#define DUALTOUCH_REG_OFF       0x00

#define CALIBRATION_REG1                0x68
#define CALIBRATION_REG1_DEFAULT        0xd9

#define CALIBRATION_REG2                0x69
#define CALIBRATION_REG2_DEFAULT        0x36

#define CALIBRATION_REG3                0x6a
#define CALIBRATION_REG3_DEFAULT        0x32

#define EX_ADDR_H               0x70
#define EX_ADDR_L               0x71
#define EX_WDAT                 0x72
#define EX_RDAT                 0x73
#define EX_CHK_SUM1             0x74
#define EX_CHK_SUM2             0x75
#define EX_CHK_SUM3             0x76

struct rohm_ts_data {
        struct i2c_client *client;
        struct input_dev *input;

        bool initialized;

        unsigned int contact_count[MAX_CONTACTS + 1];
        int finger_count;

        u8 setup2;
};

/*
 * rohm_i2c_burst_read - execute combined I2C message for ROHM BU21023/24
 * @client: Handle to ROHM BU21023/24
 * @start: Where to start read address from ROHM BU21023/24
 * @buf: Where to store read data from ROHM BU21023/24
 * @len: How many bytes to read
 *
 * Returns negative errno, else zero on success.
 *
 * Note
 * In BU21023/24 burst read, stop condition is needed after "address write".
 * Therefore, transmission is performed in 2 steps.
 */
static int rohm_i2c_burst_read(struct i2c_client *client, u8 start, void *buf,
                               size_t len)
{
        struct i2c_adapter *adap = client->adapter;
        struct i2c_msg msg[2];
        int i, ret = 0;

        msg[0].addr = client->addr;
        msg[0].flags = 0;
        msg[0].len = 1;
        msg[0].buf = &start;

        msg[1].addr = client->addr;
        msg[1].flags = I2C_M_RD;
        msg[1].len = len;
        msg[1].buf = buf;

        i2c_lock_bus(adap, I2C_LOCK_SEGMENT);

        for (i = 0; i < 2; i++) {
                if (__i2c_transfer(adap, &msg[i], 1) < 0) {
                        ret = -EIO;
                        break;
                }
        }

        i2c_unlock_bus(adap, I2C_LOCK_SEGMENT);

        return ret;
}

static int rohm_ts_manual_calibration(struct rohm_ts_data *ts)
{
        struct i2c_client *client = ts->client;
        struct device *dev = &client->dev;
        u8 buf[33];     /* for PRM1_X_H(0x08)-TOUCH(0x28) */

        int retry;
        bool success = false;
        bool first_time = true;
        bool calibration_done;

        u8 reg1, reg2, reg3;
        s32 reg1_orig, reg2_orig, reg3_orig;
        s32 val;

        int calib_x = 0, calib_y = 0;
        int reg_x, reg_y;
        int err_x, err_y;

        int error, error2;
        int i;

        reg1_orig = i2c_smbus_read_byte_data(client, CALIBRATION_REG1);
        if (reg1_orig < 0)
                return reg1_orig;

        reg2_orig = i2c_smbus_read_byte_data(client, CALIBRATION_REG2);
        if (reg2_orig < 0)
                return reg2_orig;

        reg3_orig = i2c_smbus_read_byte_data(client, CALIBRATION_REG3);
        if (reg3_orig < 0)
                return reg3_orig;

        error = i2c_smbus_write_byte_data(client, INT_MASK,
                                          COORD_UPDATE | SLEEP_IN | SLEEP_OUT |
                                          PROGRAM_LOAD_DONE);
        if (error)
                goto out;

        error = i2c_smbus_write_byte_data(client, TEST1,
                                          DUALTOUCH_STABILIZE_ON);
        if (error)
                goto out;

        for (retry = 0; retry < CALIBRATION_RETRY_MAX; retry++) {
                /* wait 2 sampling for update */
                mdelay(2 * SAMPLING_DELAY);

#define READ_CALIB_BUF(reg)     buf[((reg) - PRM1_X_H)]

                error = rohm_i2c_burst_read(client, PRM1_X_H, buf, sizeof(buf));
                if (error)
                        goto out;

                if (READ_CALIB_BUF(TOUCH) & TOUCH_DETECT)
                        continue;

                if (first_time) {
                        /* generate calibration parameter */
                        calib_x = ((int)READ_CALIB_BUF(PRM1_X_H) << 2 |
                                READ_CALIB_BUF(PRM1_X_L)) - AXIS_OFFSET;
                        calib_y = ((int)READ_CALIB_BUF(PRM1_Y_H) << 2 |
                                READ_CALIB_BUF(PRM1_Y_L)) - AXIS_OFFSET;

                        error = i2c_smbus_write_byte_data(client, TEST1,
                                DUALTOUCH_STABILIZE_ON | DUALTOUCH_REG_ON);
                        if (error)
                                goto out;

                        first_time = false;
                } else {
                        /* generate adjustment parameter */
                        err_x = (int)READ_CALIB_BUF(PRM1_X_H) << 2 |
                                READ_CALIB_BUF(PRM1_X_L);
                        err_y = (int)READ_CALIB_BUF(PRM1_Y_H) << 2 |
                                READ_CALIB_BUF(PRM1_Y_L);

                        /* X axis adjust */
                        if (err_x <= 4)
                                calib_x -= AXIS_ADJUST;
                        else if (err_x >= 60)
                                calib_x += AXIS_ADJUST;

                        /* Y axis adjust */
                        if (err_y <= 4)
                                calib_y -= AXIS_ADJUST;
                        else if (err_y >= 60)
                                calib_y += AXIS_ADJUST;
                }

                /* generate calibration setting value */
                reg_x = calib_x + ((calib_x & 0x200) << 1);
                reg_y = calib_y + ((calib_y & 0x200) << 1);

                /* convert for register format */
                reg1 = reg_x >> 3;
                reg2 = (reg_y & 0x7) << 4 | (reg_x & 0x7);
                reg3 = reg_y >> 3;

                error = i2c_smbus_write_byte_data(client,
                                                  CALIBRATION_REG1, reg1);
                if (error)
                        goto out;

                error = i2c_smbus_write_byte_data(client,
                                                  CALIBRATION_REG2, reg2);
                if (error)
                        goto out;

                error = i2c_smbus_write_byte_data(client,
                                                  CALIBRATION_REG3, reg3);
                if (error)
                        goto out;

                /*
                 * force calibration sequcence
                 */
                error = i2c_smbus_write_byte_data(client, FORCE_CALIBRATION,
                                                  FORCE_CALIBRATION_OFF);
                if (error)
                        goto out;

                error = i2c_smbus_write_byte_data(client, FORCE_CALIBRATION,
                                                  FORCE_CALIBRATION_ON);
                if (error)
                        goto out;

                /* clear all interrupts */
                error = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff);
                if (error)
                        goto out;

                /*
                 * Wait for the status change of calibration, max 10 sampling
                 */
                calibration_done = false;

                for (i = 0; i < 10; i++) {
                        mdelay(SAMPLING_DELAY);

                        val = i2c_smbus_read_byte_data(client, TOUCH_GESTURE);
                        if (!(val & CALIBRATION_MASK)) {
                                calibration_done = true;
                                break;
                        } else if (val < 0) {
                                error = val;
                                goto out;
                        }
                }

                if (calibration_done) {
                        val = i2c_smbus_read_byte_data(client, INT_STATUS);
                        if (val == CALIBRATION_DONE) {
                                success = true;
                                break;
                        } else if (val < 0) {
                                error = val;
                                goto out;
                        }
                } else {
                        dev_warn(dev, "calibration timeout\n");
                }
        }

        if (!success) {
                error = i2c_smbus_write_byte_data(client, CALIBRATION_REG1,
                                                  reg1_orig);
                if (error)
                        goto out;

                error = i2c_smbus_write_byte_data(client, CALIBRATION_REG2,
                                                  reg2_orig);
                if (error)
                        goto out;

                error = i2c_smbus_write_byte_data(client, CALIBRATION_REG3,
                                                  reg3_orig);
                if (error)
                        goto out;

                /* calibration data enable */
                error = i2c_smbus_write_byte_data(client, TEST1,
                                                  DUALTOUCH_STABILIZE_ON |
                                                  DUALTOUCH_REG_ON);
                if (error)
                        goto out;

                /* wait 10 sampling */
                mdelay(10 * SAMPLING_DELAY);

                error = -EBUSY;
        }

out:
        error2 = i2c_smbus_write_byte_data(client, INT_MASK, INT_ALL);
        if (!error2)
                /* Clear all interrupts */
                error2 = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff);

        return error ? error : error2;
}

static const unsigned int untouch_threshold[3] = { 0, 1, 5 };
static const unsigned int single_touch_threshold[3] = { 0, 0, 4 };
static const unsigned int dual_touch_threshold[3] = { 10, 8, 0 };

static irqreturn_t rohm_ts_soft_irq(int irq, void *dev_id)
{
        struct rohm_ts_data *ts = dev_id;
        struct i2c_client *client = ts->client;
        struct input_dev *input_dev = ts->input;
        struct device *dev = &client->dev;

        u8 buf[10];     /* for POS_X1_H(0x20)-TOUCH_GESTURE(0x29) */

        struct input_mt_pos pos[MAX_CONTACTS];
        int slots[MAX_CONTACTS];
        u8 touch_flags;
        unsigned int threshold;
        int finger_count = -1;
        int prev_finger_count = ts->finger_count;
        int count;
        int error;
        int i;

        error = i2c_smbus_write_byte_data(client, INT_MASK, INT_ALL);
        if (error)
                return IRQ_HANDLED;

        /* Clear all interrupts */
        error = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff);
        if (error)
                return IRQ_HANDLED;

#define READ_POS_BUF(reg)       buf[((reg) - POS_X1_H)]

        error = rohm_i2c_burst_read(client, POS_X1_H, buf, sizeof(buf));
        if (error)
                return IRQ_HANDLED;

        touch_flags = READ_POS_BUF(TOUCH_GESTURE) & TOUCH_MASK;
        if (touch_flags) {
                /* generate coordinates */
                pos[0].x = ((s16)READ_POS_BUF(POS_X1_H) << 2) |
                           READ_POS_BUF(POS_X1_L);
                pos[0].y = ((s16)READ_POS_BUF(POS_Y1_H) << 2) |
                           READ_POS_BUF(POS_Y1_L);
                pos[1].x = ((s16)READ_POS_BUF(POS_X2_H) << 2) |
                           READ_POS_BUF(POS_X2_L);
                pos[1].y = ((s16)READ_POS_BUF(POS_Y2_H) << 2) |
                           READ_POS_BUF(POS_Y2_L);
        }

        switch (touch_flags) {
        case 0:
                threshold = untouch_threshold[prev_finger_count];
                if (++ts->contact_count[0] >= threshold)
                        finger_count = 0;
                break;

        case SINGLE_TOUCH:
                threshold = single_touch_threshold[prev_finger_count];
                if (++ts->contact_count[1] >= threshold)
                        finger_count = 1;

                if (finger_count == 1) {
                        if (pos[1].x != 0 && pos[1].y != 0) {
                                pos[0].x = pos[1].x;
                                pos[0].y = pos[1].y;
                                pos[1].x = 0;
                                pos[1].y = 0;
                        }
                }
                break;

        case DUAL_TOUCH:
                threshold = dual_touch_threshold[prev_finger_count];
                if (++ts->contact_count[2] >= threshold)
                        finger_count = 2;
                break;

        default:
                dev_dbg(dev,
                        "Three or more touches are not supported\n");
                return IRQ_HANDLED;
        }

        if (finger_count >= 0) {
                if (prev_finger_count != finger_count) {
                        count = ts->contact_count[finger_count];
                        memset(ts->contact_count, 0, sizeof(ts->contact_count));
                        ts->contact_count[finger_count] = count;
                }

                input_mt_assign_slots(input_dev, slots, pos,
                                      finger_count, ROHM_TS_DISPLACEMENT_MAX);

                for (i = 0; i < finger_count; i++) {
                        input_mt_slot(input_dev, slots[i]);
                        input_mt_report_slot_state(input_dev,
                                                   MT_TOOL_FINGER, true);
                        input_report_abs(input_dev,
                                         ABS_MT_POSITION_X, pos[i].x);
                        input_report_abs(input_dev,
                                         ABS_MT_POSITION_Y, pos[i].y);
                }

                input_mt_sync_frame(input_dev);
                input_mt_report_pointer_emulation(input_dev, true);
                input_sync(input_dev);

                ts->finger_count = finger_count;
        }

        if (READ_POS_BUF(TOUCH_GESTURE) & CALIBRATION_REQUEST) {
                error = rohm_ts_manual_calibration(ts);
                if (error)
                        dev_warn(dev, "manual calibration failed: %d\n",
                                 error);
        }

        i2c_smbus_write_byte_data(client, INT_MASK,
                                  CALIBRATION_DONE | SLEEP_OUT | SLEEP_IN |
                                  PROGRAM_LOAD_DONE);

        return IRQ_HANDLED;
}

static int rohm_ts_load_firmware(struct i2c_client *client,
                                 const char *firmware_name)
{
        struct device *dev = &client->dev;
        s32 status;
        unsigned int offset, len, xfer_len;
        unsigned int retry = 0;
        int error, error2;

        const struct firmware *fw __free(firmware) = NULL;
        error = request_firmware(&fw, firmware_name, dev);
        if (error) {
                dev_err(dev, "unable to retrieve firmware %s: %d\n",
                        firmware_name, error);
                return error;
        }

        error = i2c_smbus_write_byte_data(client, INT_MASK,
                                          COORD_UPDATE | CALIBRATION_DONE |
                                          SLEEP_IN | SLEEP_OUT);
        if (error)
                goto out;

        do {
                if (retry) {
                        dev_warn(dev, "retrying firmware load\n");

                        /* settings for retry */
                        error = i2c_smbus_write_byte_data(client, EX_WDAT, 0);
                        if (error)
                                goto out;
                }

                error = i2c_smbus_write_byte_data(client, EX_ADDR_H, 0);
                if (error)
                        goto out;

                error = i2c_smbus_write_byte_data(client, EX_ADDR_L, 0);
                if (error)
                        goto out;

                error = i2c_smbus_write_byte_data(client, COMMON_SETUP1,
                                                  COMMON_SETUP1_DEFAULT);
                if (error)
                        goto out;

                /* firmware load to the device */
                offset = 0;
                len = fw->size;

                while (len) {
                        xfer_len = min(FIRMWARE_BLOCK_SIZE, len);

                        error = i2c_smbus_write_i2c_block_data(client, EX_WDAT,
                                                xfer_len, &fw->data[offset]);
                        if (error)
                                goto out;

                        len -= xfer_len;
                        offset += xfer_len;
                }

                /* check firmware load result */
                status = i2c_smbus_read_byte_data(client, INT_STATUS);
                if (status < 0) {
                        error = status;
                        goto out;
                }

                /* clear all interrupts */
                error = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff);
                if (error)
                        goto out;

                if (status == PROGRAM_LOAD_DONE)
                        break;

                error = -EIO;
        } while (++retry <= FIRMWARE_RETRY_MAX);

out:
        error2 = i2c_smbus_write_byte_data(client, INT_MASK, INT_ALL);

        return error ? error : error2;
}

static int rohm_ts_update_setting(struct rohm_ts_data *ts,
                                  unsigned int setting_bit, bool on)
{
        int error;

        scoped_cond_guard(mutex_intr, return -EINTR, &ts->input->mutex) {
                if (on)
                        ts->setup2 |= setting_bit;
                else
                        ts->setup2 &= ~setting_bit;

                if (ts->initialized) {
                        error = i2c_smbus_write_byte_data(ts->client,
                                                          COMMON_SETUP2,
                                                          ts->setup2);
                        if (error)
                                return error;
                }
        }

        return 0;
}

static ssize_t swap_xy_show(struct device *dev, struct device_attribute *attr,
                            char *buf)
{
        struct i2c_client *client = to_i2c_client(dev);
        struct rohm_ts_data *ts = i2c_get_clientdata(client);

        return sysfs_emit(buf, "%d\n", !!(ts->setup2 & SWAP_XY));
}

static ssize_t swap_xy_store(struct device *dev, struct device_attribute *attr,
                             const char *buf, size_t count)
{
        struct i2c_client *client = to_i2c_client(dev);
        struct rohm_ts_data *ts = i2c_get_clientdata(client);
        unsigned int val;
        int error;

        error = kstrtouint(buf, 0, &val);
        if (error)
                return error;

        error = rohm_ts_update_setting(ts, SWAP_XY, val);
        return error ?: count;
}

static ssize_t inv_x_show(struct device *dev, struct device_attribute *attr,
                          char *buf)
{
        struct i2c_client *client = to_i2c_client(dev);
        struct rohm_ts_data *ts = i2c_get_clientdata(client);

        return sysfs_emit(buf, "%d\n", !!(ts->setup2 & INV_X));
}

static ssize_t inv_x_store(struct device *dev, struct device_attribute *attr,
                           const char *buf, size_t count)
{
        struct i2c_client *client = to_i2c_client(dev);
        struct rohm_ts_data *ts = i2c_get_clientdata(client);
        unsigned int val;
        int error;

        error = kstrtouint(buf, 0, &val);
        if (error)
                return error;

        error = rohm_ts_update_setting(ts, INV_X, val);
        return error ?: count;
}

static ssize_t inv_y_show(struct device *dev, struct device_attribute *attr,
                          char *buf)
{
        struct i2c_client *client = to_i2c_client(dev);
        struct rohm_ts_data *ts = i2c_get_clientdata(client);

        return sysfs_emit(buf, "%d\n", !!(ts->setup2 & INV_Y));
}

static ssize_t inv_y_store(struct device *dev, struct device_attribute *attr,
                           const char *buf, size_t count)
{
        struct i2c_client *client = to_i2c_client(dev);
        struct rohm_ts_data *ts = i2c_get_clientdata(client);
        unsigned int val;
        int error;

        error = kstrtouint(buf, 0, &val);
        if (error)
                return error;

        error = rohm_ts_update_setting(ts, INV_Y, val);
        return error ?: count;
}

static DEVICE_ATTR_RW(swap_xy);
static DEVICE_ATTR_RW(inv_x);
static DEVICE_ATTR_RW(inv_y);

static struct attribute *rohm_ts_attrs[] = {
        &dev_attr_swap_xy.attr,
        &dev_attr_inv_x.attr,
        &dev_attr_inv_y.attr,
        NULL,
};
ATTRIBUTE_GROUPS(rohm_ts);

static int rohm_ts_device_init(struct i2c_client *client, u8 setup2)
{
        struct device *dev = &client->dev;
        int error;

        guard(disable_irq)(&client->irq);

        /*
         * Wait 200usec for reset
         */
        udelay(200);

        /* Release analog reset */
        error = i2c_smbus_write_byte_data(client, SYSTEM,
                                          ANALOG_POWER_ON | CPU_POWER_OFF);
        if (error)
                return error;

        /* Waiting for the analog warm-up, max. 200usec */
        udelay(200);

        /* clear all interrupts */
        error = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff);
        if (error)
                return error;

        error = i2c_smbus_write_byte_data(client, EX_WDAT, 0);
        if (error)
                return error;

        error = i2c_smbus_write_byte_data(client, COMMON_SETUP1, 0);
        if (error)
                return error;

        error = i2c_smbus_write_byte_data(client, COMMON_SETUP2, setup2);
        if (error)
                return error;

        error = i2c_smbus_write_byte_data(client, COMMON_SETUP3,
                                          SEL_TBL_DEFAULT | EN_MULTI);
        if (error)
                return error;

        error = i2c_smbus_write_byte_data(client, THRESHOLD_GESTURE,
                                          THRESHOLD_GESTURE_DEFAULT);
        if (error)
                return error;

        error = i2c_smbus_write_byte_data(client, INTERVAL_TIME,
                                          INTERVAL_TIME_DEFAULT);
        if (error)
                return error;

        error = i2c_smbus_write_byte_data(client, CPU_FREQ, CPU_FREQ_10MHZ);
        if (error)
                return error;

        error = i2c_smbus_write_byte_data(client, PRM_SWOFF_TIME,
                                          PRM_SWOFF_TIME_DEFAULT);
        if (error)
                return error;

        error = i2c_smbus_write_byte_data(client, ADC_CTRL, ADC_DIV_DEFAULT);
        if (error)
                return error;

        error = i2c_smbus_write_byte_data(client, ADC_WAIT, ADC_WAIT_DEFAULT);
        if (error)
                return error;

        /*
         * Panel setup, these values change with the panel.
         */
        error = i2c_smbus_write_byte_data(client, STEP_X, STEP_X_DEFAULT);
        if (error)
                return error;

        error = i2c_smbus_write_byte_data(client, STEP_Y, STEP_Y_DEFAULT);
        if (error)
                return error;

        error = i2c_smbus_write_byte_data(client, OFFSET_X, OFFSET_X_DEFAULT);
        if (error)
                return error;

        error = i2c_smbus_write_byte_data(client, OFFSET_Y, OFFSET_Y_DEFAULT);
        if (error)
                return error;

        error = i2c_smbus_write_byte_data(client, THRESHOLD_TOUCH,
                                          THRESHOLD_TOUCH_DEFAULT);
        if (error)
                return error;

        error = i2c_smbus_write_byte_data(client, EVR_XY, EVR_XY_DEFAULT);
        if (error)
                return error;

        error = i2c_smbus_write_byte_data(client, EVR_X, EVR_X_DEFAULT);
        if (error)
                return error;

        error = i2c_smbus_write_byte_data(client, EVR_Y, EVR_Y_DEFAULT);
        if (error)
                return error;

        /* Fixed value settings */
        error = i2c_smbus_write_byte_data(client, CALIBRATION_ADJUST,
                                          CALIBRATION_ADJUST_DEFAULT);
        if (error)
                return error;

        error = i2c_smbus_write_byte_data(client, SWCONT, SWCONT_DEFAULT);
        if (error)
                return error;

        error = i2c_smbus_write_byte_data(client, TEST1,
                                          DUALTOUCH_STABILIZE_ON |
                                          DUALTOUCH_REG_ON);
        if (error)
                return error;

        error = rohm_ts_load_firmware(client, BU21023_FIRMWARE_NAME);
        if (error) {
                dev_err(dev, "failed to load firmware: %d\n", error);
                return error;
        }

        /*
         * Manual calibration results are not changed in same environment.
         * If the force calibration is performed,
         * the controller will not require calibration request interrupt
         * when the typical values are set to the calibration registers.
         */
        error = i2c_smbus_write_byte_data(client, CALIBRATION_REG1,
                                          CALIBRATION_REG1_DEFAULT);
        if (error)
                return error;

        error = i2c_smbus_write_byte_data(client, CALIBRATION_REG2,
                                          CALIBRATION_REG2_DEFAULT);
        if (error)
                return error;

        error = i2c_smbus_write_byte_data(client, CALIBRATION_REG3,
                                          CALIBRATION_REG3_DEFAULT);
        if (error)
                return error;

        error = i2c_smbus_write_byte_data(client, FORCE_CALIBRATION,
                                          FORCE_CALIBRATION_OFF);
        if (error)
                return error;

        error = i2c_smbus_write_byte_data(client, FORCE_CALIBRATION,
                                          FORCE_CALIBRATION_ON);
        if (error)
                return error;

        /* Clear all interrupts */
        error = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff);
        if (error)
                return error;

        /* Enable coordinates update interrupt */
        error = i2c_smbus_write_byte_data(client, INT_MASK,
                                          CALIBRATION_DONE | SLEEP_OUT |
                                          SLEEP_IN | PROGRAM_LOAD_DONE);
        if (error)
                return error;

        error = i2c_smbus_write_byte_data(client, ERR_MASK,
                                          PROGRAM_LOAD_ERR | CPU_TIMEOUT |
                                          ADC_TIMEOUT);
        if (error)
                return error;

        /* controller CPU power on */
        error = i2c_smbus_write_byte_data(client, SYSTEM,
                                          ANALOG_POWER_ON | CPU_POWER_ON);
        if (error)
                return error;

        return 0;
}

static int rohm_ts_power_off(struct i2c_client *client)
{
        int error;

        error = i2c_smbus_write_byte_data(client, SYSTEM,
                                          ANALOG_POWER_ON | CPU_POWER_OFF);
        if (error) {
                dev_err(&client->dev,
                        "failed to power off device CPU: %d\n", error);
                return error;
        }

        error = i2c_smbus_write_byte_data(client, SYSTEM,
                                          ANALOG_POWER_OFF | CPU_POWER_OFF);
        if (error)
                dev_err(&client->dev,
                        "failed to power off the device: %d\n", error);

        return error;
}

static int rohm_ts_open(struct input_dev *input_dev)
{
        struct rohm_ts_data *ts = input_get_drvdata(input_dev);
        struct i2c_client *client = ts->client;
        int error;

        if (!ts->initialized) {
                error = rohm_ts_device_init(client, ts->setup2);
                if (error) {
                        dev_err(&client->dev,
                                "device initialization failed: %d\n", error);
                        return error;
                }

                ts->initialized = true;
        }

        return 0;
}

static void rohm_ts_close(struct input_dev *input_dev)
{
        struct rohm_ts_data *ts = input_get_drvdata(input_dev);

        rohm_ts_power_off(ts->client);

        ts->initialized = false;
}

static int rohm_bu21023_i2c_probe(struct i2c_client *client)
{
        struct device *dev = &client->dev;
        struct rohm_ts_data *ts;
        struct input_dev *input;
        int error;

        if (!client->irq) {
                dev_err(dev, "IRQ is not assigned\n");
                return -EINVAL;
        }

        if (!client->adapter->algo->master_xfer) {
                dev_err(dev, "I2C level transfers not supported\n");
                return -EOPNOTSUPP;
        }

        /* Turn off CPU just in case */
        error = rohm_ts_power_off(client);
        if (error)
                return error;

        ts = devm_kzalloc(dev, sizeof(struct rohm_ts_data), GFP_KERNEL);
        if (!ts)
                return -ENOMEM;

        ts->client = client;
        ts->setup2 = MAF_1SAMPLE;
        i2c_set_clientdata(client, ts);

        input = devm_input_allocate_device(dev);
        if (!input)
                return -ENOMEM;

        input->name = BU21023_NAME;
        input->id.bustype = BUS_I2C;
        input->open = rohm_ts_open;
        input->close = rohm_ts_close;

        ts->input = input;
        input_set_drvdata(input, ts);

        input_set_abs_params(input, ABS_MT_POSITION_X,
                             ROHM_TS_ABS_X_MIN, ROHM_TS_ABS_X_MAX, 0, 0);
        input_set_abs_params(input, ABS_MT_POSITION_Y,
                             ROHM_TS_ABS_Y_MIN, ROHM_TS_ABS_Y_MAX, 0, 0);

        error = input_mt_init_slots(input, MAX_CONTACTS,
                                    INPUT_MT_DIRECT | INPUT_MT_TRACK |
                                    INPUT_MT_DROP_UNUSED);
        if (error) {
                dev_err(dev, "failed to multi touch slots initialization\n");
                return error;
        }

        error = devm_request_threaded_irq(dev, client->irq,
                                          NULL, rohm_ts_soft_irq,
                                          IRQF_ONESHOT, client->name, ts);
        if (error) {
                dev_err(dev, "failed to request IRQ: %d\n", error);
                return error;
        }

        error = input_register_device(input);
        if (error) {
                dev_err(dev, "failed to register input device: %d\n", error);
                return error;
        }

        return error;
}

static const struct i2c_device_id rohm_bu21023_i2c_id[] = {
        { BU21023_NAME },
        { /* sentinel */ }
};
MODULE_DEVICE_TABLE(i2c, rohm_bu21023_i2c_id);

static struct i2c_driver rohm_bu21023_i2c_driver = {
        .driver = {
                .name = BU21023_NAME,
                .dev_groups = rohm_ts_groups,
        },
        .probe = rohm_bu21023_i2c_probe,
        .id_table = rohm_bu21023_i2c_id,
};
module_i2c_driver(rohm_bu21023_i2c_driver);

MODULE_DESCRIPTION("ROHM BU21023/24 Touchscreen driver");
MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("ROHM Co., Ltd.");