* [PATCH v2] input: Add ROHM BU21023/24 Dual touch support resistive touchscreens
@ 2014-08-04 11:51 Yoichi Yuasa
2014-09-12 7:23 ` Dmitry Torokhov
0 siblings, 1 reply; 3+ messages in thread
From: Yoichi Yuasa @ 2014-08-04 11:51 UTC (permalink / raw)
To: Dmitry Torokhov; +Cc: yuasa, linux-input
Signed-off-by: Yoichi Yuasa <yuasa@linux-mips.org>
---
drivers/input/touchscreen/Kconfig | 11 +
drivers/input/touchscreen/Makefile | 1 +
drivers/input/touchscreen/rohm_bu21023.c | 929 ++++++++++++++++++++++++++++++
drivers/input/touchscreen/rohm_bu21023.h | 258 +++++++++
4 files changed, 1199 insertions(+)
create mode 100644 drivers/input/touchscreen/rohm_bu21023.c
create mode 100644 drivers/input/touchscreen/rohm_bu21023.h
diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index 6bb9a7d..9ae5c88 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -950,4 +950,15 @@ config TOUCHSCREEN_ZFORCE
To compile this driver as a module, choose M here: the
module will be called zforce_ts.
+config TOUCHSCREEN_ROHM_BU21023
+ tristate "ROHM BU21023/24 Dual touch support resistive touchscreens"
+ depends on I2C
+ help
+ Say Y here if you have a touchscreen using ROHM BU21023/24.
+
+ If unsure, say N.
+
+ To compile this driver as a module, choose M here: the
+ module will be called bu21023_ts.
+
endif
diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
index 4be94fc..af766d0 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -52,6 +52,7 @@ obj-$(CONFIG_TOUCHSCREEN_USB_COMPOSITE) += usbtouchscreen.o
obj-$(CONFIG_TOUCHSCREEN_PCAP) += pcap_ts.o
obj-$(CONFIG_TOUCHSCREEN_PENMOUNT) += penmount.o
obj-$(CONFIG_TOUCHSCREEN_PIXCIR) += pixcir_i2c_ts.o
+obj-$(CONFIG_TOUCHSCREEN_ROHM_BU21023) += rohm_bu21023.o
obj-$(CONFIG_TOUCHSCREEN_S3C2410) += s3c2410_ts.o
obj-$(CONFIG_TOUCHSCREEN_ST1232) += st1232.o
obj-$(CONFIG_TOUCHSCREEN_STMPE) += stmpe-ts.o
diff --git a/drivers/input/touchscreen/rohm_bu21023.c b/drivers/input/touchscreen/rohm_bu21023.c
new file mode 100644
index 0000000..660b839
--- /dev/null
+++ b/drivers/input/touchscreen/rohm_bu21023.c
@@ -0,0 +1,929 @@
+/*
+ * ROHM BU21023/24 Dual touch support resistive touch screen driver
+ * Copyright (C) 2012 ROHM CO.,LTD.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+#include <linux/delay.h>
+#include <linux/firmware.h>
+#include <linux/hrtimer.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>
+
+#include "rohm_bu21023.h"
+
+struct rohm_ts_data {
+ struct i2c_client *client;
+ struct input_dev *input_dev;
+
+ bool initialized;
+
+ unsigned int untouch_count;
+ unsigned int single_touch_count;
+ unsigned int dual_touch_count;
+ unsigned int prev_touch_report;
+};
+
+/*
+ * rohm_i2c_burst_read - execute combined I2C message for ROHM BU21023/24
+ * @adap: Handle to I2C bus
+ * @msgs: combined messages to execute
+ * @num: Number of messages to be executed.
+ *
+ * Returns negative errno, else the number of messages executed.
+ *
+ * Note
+ * In BU21023/24 burst read, stop condition is needed after "address write".
+ * Therefore, transmission is performed in 2 steps.
+ */
+static inline int rohm_i2c_burst_read(struct i2c_adapter *adap,
+ struct i2c_msg *msgs, int num)
+{
+ int ret, i;
+
+ if (!adap->algo->master_xfer) {
+ dev_err(&adap->dev, "I2C level transfers not supported\n");
+ return -EOPNOTSUPP;
+ }
+
+ i2c_lock_adapter(adap);
+
+ for (i = 0; i < num; i++) {
+ ret = __i2c_transfer(adap, &msgs[i], 1);
+ if (ret < 0)
+ break;
+
+ ret = i;
+ }
+
+ i2c_unlock_adapter(adap);
+
+ return ret;
+}
+
+static int rohm_ts_manual_calibration(struct rohm_ts_data *ts)
+{
+ struct i2c_client *client = ts->client;
+ struct device *dev = &client->dev;
+ struct i2c_msg msg[2];
+ u8 buf[33];
+ u8 addr_buf; /* burst read start address */
+
+ 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 err = 0, ret;
+ int i;
+
+ addr_buf = PRM1_X_H;
+ msg[0].addr = client->addr;
+ msg[0].flags = 0;
+ msg[0].len = 1;
+ msg[0].buf = &addr_buf;
+
+ msg[1].addr = client->addr;
+ msg[1].flags = I2C_M_RD;
+ msg[1].len = sizeof(buf);
+ msg[1].buf = buf;
+
+#define READ_CALIB_BUF(reg) ((u16)buf[((reg) - PRM1_X_H)])
+
+ 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;
+
+ ret = i2c_smbus_write_byte_data(client, INT_MASK,
+ COORD_UPDATE | SLEEP_IN | SLEEP_OUT |
+ PROGRAM_LOAD_DONE);
+ if (ret) {
+ err = ret;
+ goto err_exit;
+ }
+
+ ret = i2c_smbus_write_byte_data(client, TEST1, DUALTOUCH_STABILIZE_ON);
+ if (ret) {
+ err = ret;
+ goto err_exit;
+ }
+
+ for (retry = 0; retry < CALIBRATION_RETRY_MAX; retry++) {
+ /* wait 2 sampling for update */
+ mdelay(2 * SAMPLING_DELAY);
+
+ ret = rohm_i2c_burst_read(client->adapter, msg, 2);
+ if (ret < 0) {
+ err = ret;
+ goto err_exit;
+ }
+
+ if (READ_CALIB_BUF(TOUCH) & TOUCH_DETECT)
+ continue;
+
+ if (first_time) {
+ /* generate calibration parameter */
+ calib_x =
+ (READ_CALIB_BUF(PRM1_X_H) << 2 |
+ READ_CALIB_BUF(PRM1_X_L)) - AXIS_OFFSET;
+ calib_y =
+ (READ_CALIB_BUF(PRM1_Y_H) << 2 |
+ READ_CALIB_BUF(PRM1_Y_L)) - AXIS_OFFSET;
+
+ ret = i2c_smbus_write_byte_data(client, TEST1,
+ DUALTOUCH_STABILIZE_ON |
+ DUALTOUCH_REG_ON);
+ if (ret) {
+ err = ret;
+ goto err_exit;
+ }
+
+ first_time = false;
+ } else {
+ /* generate adjustment parameter */
+ err_x = READ_CALIB_BUF(PRM1_X_H) << 2 |
+ READ_CALIB_BUF(PRM1_X_L);
+ err_y = READ_CALIB_BUF(PRM1_Y_H) << 2 |
+ READ_CALIB_BUF(PRM1_Y_L);
+
+ /* X axis ajust */
+ if (err_x <= 4)
+ calib_x -= AXIS_ADJUST;
+ else if (err_x >= 60)
+ calib_x += AXIS_ADJUST;
+
+ /* Y axis ajust */
+ 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;
+
+ ret = i2c_smbus_write_byte_data(client, CALIBRATION_REG1, reg1);
+ if (ret) {
+ err = ret;
+ goto err_exit;
+ }
+
+ ret = i2c_smbus_write_byte_data(client, CALIBRATION_REG2, reg2);
+ if (ret) {
+ err = ret;
+ goto err_exit;
+ }
+
+ ret = i2c_smbus_write_byte_data(client, CALIBRATION_REG3, reg3);
+ if (ret) {
+ err = ret;
+ goto err_exit;
+ }
+
+ /*
+ * force calibration sequcence
+ */
+ ret = i2c_smbus_write_byte_data(client, FORCE_CALIBRATION,
+ FORCE_CALIBRATION_OFF);
+ if (ret) {
+ err = ret;
+ goto err_exit;
+ }
+
+ ret = i2c_smbus_write_byte_data(client, FORCE_CALIBRATION,
+ FORCE_CALIBRATION_ON);
+ if (ret) {
+ err = ret;
+ goto err_exit;
+ }
+
+ /* clear all interrupts */
+ ret = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff);
+ if (ret) {
+ err = ret;
+ goto err_exit;
+ }
+
+ /*
+ * 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) {
+ err = val;
+ goto err_exit;
+ }
+ }
+
+ if (calibration_done) {
+ val = i2c_smbus_read_byte_data(client, INT_STATUS);
+ if (val == CALIBRATION_DONE) {
+ success = true;
+ break;
+ } else if (val < 0) {
+ err = val;
+ goto err_exit;
+ }
+ } else
+ dev_warn(dev, "Calibration timeout\n");
+ }
+
+ if (!success) {
+ ret = i2c_smbus_write_byte_data(client, CALIBRATION_REG1,
+ reg1_orig);
+ if (ret) {
+ err = ret;
+ goto err_exit;
+ }
+
+ ret = i2c_smbus_write_byte_data(client, CALIBRATION_REG2,
+ reg2_orig);
+ if (ret) {
+ err = ret;
+ goto err_exit;
+ }
+
+ ret = i2c_smbus_write_byte_data(client, CALIBRATION_REG3,
+ reg3_orig);
+ if (ret) {
+ err = ret;
+ goto err_exit;
+ }
+
+ /* calibration data enable */
+ ret = i2c_smbus_write_byte_data(client, TEST1,
+ DUALTOUCH_STABILIZE_ON |
+ DUALTOUCH_REG_ON);
+ if (ret) {
+ err = ret;
+ goto err_exit;
+ }
+
+ /* wait 10 sampling */
+ mdelay(10 * SAMPLING_DELAY);
+
+ err = -EBUSY;
+ }
+
+err_exit:
+ ret = i2c_smbus_write_byte_data(client, INT_MASK, INT_ALL);
+ if (!ret)
+ /* Clear all interrupts */
+ ret = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff);
+
+ if (!err && ret)
+ err = ret;
+
+ return err;
+}
+
+static unsigned long inactive_polling_interval[2] = { 1, 0 };
+static unsigned long active_polling_interval[2] = { 0, 10000000 };
+
+module_param_array(inactive_polling_interval, ulong, NULL, S_IRUGO | S_IWUSR);
+module_param_array(active_polling_interval, ulong, NULL, S_IRUGO | S_IWUSR);
+
+MODULE_PARM_DESC(inactive_polling_interval,
+ "Polling interval for un-touch detection");
+MODULE_PARM_DESC(active_polling_interval,
+ "Polling interval for touch detection");
+
+#define INACTIVE_POLLING_INTERVAL_KTIME \
+ ktime_set(inactive_polling_interval[0], inactive_polling_interval[1])
+#define ACTIVE_POLLING_INTERVAL_KTIME \
+ ktime_set(active_polling_interval[0], active_polling_interval[1])
+
+static unsigned int untouch_threshold[3] = { 0, 1, 5 };
+static unsigned int single_touch_threshold[3] = { 0, 0, 4 };
+static unsigned int dual_touch_threshold[3] = { 10, 8, 0 };
+
+module_param_array(untouch_threshold, uint, NULL, S_IRUGO | S_IWUSR);
+module_param_array(single_touch_threshold, uint, NULL, S_IRUGO | S_IWUSR);
+module_param_array(dual_touch_threshold, uint, NULL, S_IRUGO | S_IWUSR);
+
+MODULE_PARM_DESC(untouch_threshold, "Thresholds for un-touch detection");
+MODULE_PARM_DESC(single_touch_threshold,
+ "Thresholds for single touch detection");
+MODULE_PARM_DESC(dual_touch_threshold, "Thresholds for dual touch detection");
+
+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_dev;
+ struct device *dev = &client->dev;
+
+ struct i2c_msg msg[2];
+ u16 addr = client->addr;
+ u8 addr_buf;
+ u8 buf[10]; /* for 0x20-0x29 */
+
+ struct input_mt_pos pos[BU21023_MAX_SLOTS];
+ int slots[BU21023_MAX_SLOTS];
+ u8 touch_flags;
+ unsigned int threshold;
+ int touch_report = -1;
+ unsigned int prev_touch_report = ts->prev_touch_report;
+
+ s32 status;
+ int i, ret;
+
+ status = i2c_smbus_read_byte_data(client, INT_STATUS);
+ if (!status)
+ return IRQ_NONE;
+
+ if (status < 0)
+ return IRQ_HANDLED;
+
+ ret = i2c_smbus_write_byte_data(client, INT_MASK, INT_ALL);
+ if (ret)
+ return IRQ_HANDLED;
+
+ /* Clear all interrupts */
+ ret = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff);
+ if (ret)
+ return IRQ_HANDLED;
+
+ addr_buf = POS_X1_H;
+ msg[0].addr = addr;
+ msg[0].flags = 0;
+ msg[0].len = 1;
+ msg[0].buf = &addr_buf;
+
+ msg[1].addr = addr;
+ msg[1].flags = I2C_M_RD;
+ msg[1].len = sizeof(buf);
+ msg[1].buf = buf;
+
+#define READ_POS_BUF(reg) ((u16)buf[((reg) - POS_X1_H)])
+
+ ret = rohm_i2c_burst_read(client->adapter, msg, 2);
+ if (ret < 0)
+ return IRQ_HANDLED;
+
+ touch_flags = READ_POS_BUF(TOUCH_GESTURE) & TOUCH_MASK;
+ if (touch_flags) {
+ /* generate coordinates */
+ pos[0].x = (READ_POS_BUF(POS_X1_H) << 2) |
+ READ_POS_BUF(POS_X1_L);
+ pos[0].y = (READ_POS_BUF(POS_Y1_H) << 2) |
+ READ_POS_BUF(POS_Y1_L);
+ pos[1].x = (READ_POS_BUF(POS_X2_H) << 2) |
+ READ_POS_BUF(POS_X2_L);
+ pos[1].y = (READ_POS_BUF(POS_Y2_H) << 2) |
+ READ_POS_BUF(POS_Y2_L);
+
+ switch (touch_flags) {
+ case SINGLE_TOUCH:
+ ts->untouch_count = 0;
+ ts->single_touch_count++;
+ ts->dual_touch_count = 0;
+
+ threshold = single_touch_threshold[prev_touch_report];
+ if (ts->single_touch_count > threshold)
+ touch_report = 1;
+
+ if (touch_report == 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:
+ ts->untouch_count = 0;
+ ts->single_touch_count = 0;
+ ts->dual_touch_count++;
+
+ threshold = dual_touch_threshold[prev_touch_report];
+ if (ts->dual_touch_count > threshold)
+ touch_report = 2;
+ break;
+ default:
+ dev_err(dev,
+ "Three or more touches are not supported\n");
+ return IRQ_HANDLED;
+ break;
+ }
+ } else {
+ ts->untouch_count++;
+
+ threshold = untouch_threshold[prev_touch_report];
+ if (ts->untouch_count > threshold) {
+ ts->untouch_count = 0;
+ ts->single_touch_count = 0;
+ ts->dual_touch_count = 0;
+
+ touch_report = 0;
+ }
+ }
+
+ input_mt_assign_slots(input_dev, slots, pos, touch_report);
+
+ for (i = 0; i < touch_report; 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);
+
+ if (READ_POS_BUF(TOUCH_GESTURE) & CALIBRATION_REQUEST) {
+ if (rohm_ts_manual_calibration(ts) < 0)
+ dev_warn(dev, "Failed to manual calibration\n");
+ }
+
+
+ i2c_smbus_write_byte_data(client, INT_MASK,
+ CALIBRATION_DONE | SLEEP_OUT | SLEEP_IN |
+ PROGRAM_LOAD_DONE);
+
+ return IRQ_HANDLED;
+}
+
+static irqreturn_t rohm_ts_hard_irq(int irq, void *dev_id)
+{
+ return IRQ_WAKE_THREAD;
+}
+
+static int rohm_ts_load_firmware(struct i2c_client *client,
+ const char *firmware_name)
+{
+ struct device *dev = &client->dev;
+ const struct firmware *firmware = NULL;
+ s32 status;
+ int blocks, remainder, retry = 0, offset;
+ int err = 0, ret;
+ int i;
+
+ ret = request_firmware(&firmware, firmware_name, dev);
+ if (ret) {
+ dev_err(dev, "Unable to open firmware %s\n", firmware_name);
+ return ret;
+ }
+
+ blocks = firmware->size / FIRMWARE_BLOCK_SIZE;
+ remainder = firmware->size % FIRMWARE_BLOCK_SIZE;
+
+ ret = i2c_smbus_write_byte_data(client, INT_MASK,
+ COORD_UPDATE | CALIBRATION_DONE |
+ SLEEP_IN | SLEEP_OUT);
+ if (ret) {
+ err = ret;
+ goto err_int_mask_exit;
+ }
+
+ while (retry < FIRMWARE_RETRY_MAX) {
+ ret = i2c_smbus_write_byte_data(client, COMMON_SETUP1,
+ COMMON_SETUP1_DEFAULT);
+ if (ret) {
+ err = ret;
+ goto err_int_mask_exit;
+ }
+
+ ret = i2c_smbus_write_byte_data(client, EX_ADDR_H, 0);
+ if (ret) {
+ err = ret;
+ goto err_int_mask_exit;
+ }
+
+ ret = i2c_smbus_write_byte_data(client, EX_ADDR_L, 0);
+ if (ret) {
+ err = ret;
+ goto err_int_mask_exit;
+ }
+
+ offset = 0;
+
+ /* firmware load to the device */
+ for (i = 0; i < blocks; i++) {
+ ret = i2c_smbus_write_i2c_block_data(client, EX_WDAT,
+ FIRMWARE_BLOCK_SIZE, &firmware->data[offset]);
+ if (ret) {
+ err = ret;
+ goto err_int_mask_exit;
+ }
+
+ offset += FIRMWARE_BLOCK_SIZE;
+ }
+
+ if (remainder) {
+ ret = i2c_smbus_write_i2c_block_data(client, EX_WDAT,
+ remainder, &firmware->data[offset]);
+ if (ret) {
+ err = ret;
+ goto err_int_mask_exit;
+ }
+ }
+
+ /* check formware load result */
+ status = i2c_smbus_read_byte_data(client, INT_STATUS);
+ if (status < 0) {
+ err = status;
+ goto err_int_mask_exit;
+ }
+
+ /* clear all interrupts */
+ ret = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff);
+ if (ret) {
+ err = ret;
+ goto err_int_mask_exit;
+ }
+
+ if (status == PROGRAM_LOAD_DONE)
+ break;
+
+ /* settings for retry */
+ ret = i2c_smbus_write_byte_data(client, EX_WDAT, 0);
+ if (ret) {
+ err = ret;
+ goto err_int_mask_exit;
+ }
+
+ retry++;
+ dev_warn(dev, "Retry firmware load\n");
+ }
+
+err_int_mask_exit:
+ ret = i2c_smbus_write_byte_data(client, INT_MASK, INT_ALL);
+ if (ret)
+ err = ret;
+
+ release_firmware(firmware);
+
+ if (retry >= FIRMWARE_RETRY_MAX)
+ return -EBUSY;
+
+ return err;
+}
+
+static bool swap_xy;
+module_param(swap_xy, bool, S_IRUGO);
+MODULE_PARM_DESC(swap_xy, "Swap X-axis and Y-axis");
+
+static bool inv_x;
+module_param(inv_x, bool, S_IRUGO);
+MODULE_PARM_DESC(inv_x, "Invert X-axis");
+
+static bool inv_y;
+module_param(inv_y, bool, S_IRUGO);
+MODULE_PARM_DESC(inv_y, "Invert Y-axis");
+
+static int rohm_ts_device_init(struct rohm_ts_data *ts)
+{
+ struct i2c_client *client = ts->client;
+ struct device *dev = &client->dev;
+ u8 val;
+ int ret;
+
+ /*
+ * Wait 200usec for reset
+ */
+ udelay(200);
+
+ /* Release analog reset */
+ ret = i2c_smbus_write_byte_data(client, SYSTEM, ANALOG_POWER_ON);
+ if (ret)
+ return ret;
+
+ /* Waiting for the analog warm-up, max. 200usec */
+ udelay(200);
+
+ /* clear all interrupts */
+ ret = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff);
+ if (ret)
+ return ret;
+
+ val = MAF_1SAMPLE;
+ if (swap_xy)
+ val |= SWAP_XY;
+ if (inv_x)
+ val |= INV_X;
+ if (inv_y)
+ val |= INV_Y;
+
+ ret = i2c_smbus_write_byte_data(client, EX_WDAT, 0);
+ if (ret)
+ return ret;
+
+ ret = i2c_smbus_write_byte_data(client, COMMON_SETUP1, 0);
+ if (ret)
+ return ret;
+
+ ret = i2c_smbus_write_byte_data(client, COMMON_SETUP2, val);
+ if (ret)
+ return ret;
+
+ ret = i2c_smbus_write_byte_data(client, COMMON_SETUP3,
+ SEL_TBL_DEFAULT | EN_MULTI);
+ if (ret)
+ return ret;
+
+ ret = i2c_smbus_write_byte_data(client, THRESHOLD_GESTURE,
+ THRESHOLD_GESTURE_DEFAULT);
+ if (ret)
+ return ret;
+
+ ret = i2c_smbus_write_byte_data(client, INTERVAL_TIME,
+ INTERVAL_TIME_DEFAULT);
+ if (ret)
+ return ret;
+
+ ret = i2c_smbus_write_byte_data(client, CPU_FREQ, CPU_FREQ_10MHZ);
+ if (ret)
+ return ret;
+
+ ret = i2c_smbus_write_byte_data(client, PRM_SWOFF_TIME,
+ PRM_SWOFF_TIME_DEFAULT);
+ if (ret)
+ return ret;
+
+ ret = i2c_smbus_write_byte_data(client, ADC_CTRL, ADC_DIV_DEFAULT);
+ if (ret)
+ return ret;
+
+ ret = i2c_smbus_write_byte_data(client, ADC_WAIT, ADC_WAIT_DEFAULT);
+ if (ret)
+ return ret;
+
+ /*
+ * Panel setup, these values change with the panel.
+ */
+ ret = i2c_smbus_write_byte_data(client, STEP_X, STEP_X_DEFAULT);
+ if (ret)
+ return ret;
+
+ ret = i2c_smbus_write_byte_data(client, STEP_Y, STEP_Y_DEFAULT);
+ if (ret)
+ return ret;
+
+ ret = i2c_smbus_write_byte_data(client, OFFSET_X, OFFSET_X_DEFAULT);
+ if (ret)
+ return ret;
+
+ ret = i2c_smbus_write_byte_data(client, OFFSET_Y, OFFSET_Y_DEFAULT);
+ if (ret)
+ return ret;
+
+ ret = i2c_smbus_write_byte_data(client, THRESHOLD_TOUCH,
+ THRESHOLD_TOUCH_DEFAULT);
+ if (ret)
+ return ret;
+
+ ret = i2c_smbus_write_byte_data(client, EVR_XY, EVR_XY_DEFAULT);
+ if (ret)
+ return ret;
+
+ ret = i2c_smbus_write_byte_data(client, EVR_X, EVR_X_DEFAULT);
+ if (ret)
+ return ret;
+
+ ret = i2c_smbus_write_byte_data(client, EVR_Y, EVR_Y_DEFAULT);
+ if (ret)
+ return ret;
+
+ /* Fixed value settings */
+ ret = i2c_smbus_write_byte_data(client, CALIBRATION_ADJUST,
+ CALIBRATION_ADJUST_DEFAULT);
+ if (ret)
+ return ret;
+
+ ret = i2c_smbus_write_byte_data(client, SWCONT, SWCONT_DEFAULT);
+ if (ret)
+ return ret;
+
+ ret = i2c_smbus_write_byte_data(client, TEST1,
+ DUALTOUCH_STABILIZE_ON |
+ DUALTOUCH_REG_ON);
+ if (ret)
+ return ret;
+
+ ret = rohm_ts_load_firmware(client, BU21023_FIRMWARE_NAME);
+ if (ret) {
+ dev_err(dev, "Failed to firmware load\n");
+ return ret;
+ }
+
+ /*
+ * 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.
+ */
+ ret = i2c_smbus_write_byte_data(client, CALIBRATION_REG1,
+ CALIBRATION_REG1_DEFAULT);
+ if (ret)
+ return ret;
+
+ ret = i2c_smbus_write_byte_data(client, CALIBRATION_REG2,
+ CALIBRATION_REG2_DEFAULT);
+ if (ret)
+ return ret;
+
+ ret = i2c_smbus_write_byte_data(client, CALIBRATION_REG3,
+ CALIBRATION_REG3_DEFAULT);
+ if (ret)
+ return ret;
+
+ ret = i2c_smbus_write_byte_data(client, FORCE_CALIBRATION,
+ FORCE_CALIBRATION_OFF);
+ if (ret)
+ return ret;
+
+ ret = i2c_smbus_write_byte_data(client, FORCE_CALIBRATION,
+ FORCE_CALIBRATION_ON);
+ if (ret)
+ return ret;
+
+ /* Clear all interrupts */
+ ret = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff);
+ if (ret)
+ return ret;
+
+ ret = devm_request_threaded_irq(dev, client->irq, rohm_ts_hard_irq,
+ rohm_ts_soft_irq, IRQF_TRIGGER_FALLING,
+ client->name, ts);
+ if (ret) {
+ dev_err(dev, "Unable to request IRQ\n");
+ return ret;
+ }
+
+ /* Enable coordinates update interrupt */
+ ret = i2c_smbus_write_byte_data(client, INT_MASK,
+ CALIBRATION_DONE |
+ SLEEP_OUT | SLEEP_IN |
+ PROGRAM_LOAD_DONE);
+ if (ret)
+ return ret;
+
+ ret = i2c_smbus_write_byte_data(client, ERR_MASK,
+ PROGRAM_LOAD_ERR | CPU_TIMEOUT |
+ ADC_TIMEOUT);
+ if (ret)
+ return ret;
+
+ /* controller CPU power on */
+ ret = i2c_smbus_write_byte_data(client, SYSTEM,
+ CPU_POWER_ON | ANALOG_POWER_ON);
+
+ return ret;
+}
+
+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 ret;
+
+ if (!ts->initialized) {
+ ret = rohm_ts_device_init(ts);
+ if (ret) {
+ dev_err(&client->dev,
+ "Failed to device initialization\n");
+ return ret;
+ }
+
+ ts->initialized = true;
+ }
+
+ return 0;
+}
+
+static int rohm_bu21023_i2c_probe(struct i2c_client *client,
+ const struct i2c_device_id *id)
+{
+ struct rohm_ts_data *ts;
+ struct device *dev = &client->dev;
+ struct input_dev *input_dev;
+ int ret;
+
+ if (!client->irq) {
+ dev_err(dev, "IRQ is not assigned\n");
+ return -EBUSY;
+ }
+
+ ts = devm_kzalloc(dev, sizeof(struct rohm_ts_data), GFP_KERNEL);
+ if (!ts)
+ return -ENOMEM;
+
+ ts->client = client;
+ i2c_set_clientdata(client, ts);
+
+ input_dev = devm_input_allocate_device(dev);
+ if (!input_dev)
+ return -ENOMEM;
+
+ input_dev->name = BU21023_NAME;
+ input_dev->id.bustype = BUS_I2C;
+ input_dev->open = rohm_ts_open;
+
+ ts->input_dev = input_dev;
+ input_set_drvdata(input_dev, ts);
+
+ set_bit(EV_SYN, input_dev->evbit);
+ set_bit(EV_KEY, input_dev->evbit);
+ set_bit(EV_ABS, input_dev->evbit);
+
+ set_bit(BTN_TOUCH, input_dev->evbit);
+
+ input_set_abs_params(input_dev, ABS_MT_POSITION_X,
+ ROHM_TS_ABS_X_MIN, ROHM_TS_ABS_X_MAX, 0, 0);
+ input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
+ ROHM_TS_ABS_Y_MIN, ROHM_TS_ABS_Y_MAX, 0, 0);
+
+ input_set_abs_params(input_dev, ABS_X,
+ ROHM_TS_ABS_X_MIN, ROHM_TS_ABS_X_MAX, 0, 0);
+ input_set_abs_params(input_dev, ABS_Y,
+ ROHM_TS_ABS_Y_MIN, ROHM_TS_ABS_Y_MAX, 0, 0);
+
+ ret = input_register_device(input_dev);
+ if (ret)
+ dev_err(dev, "Unable to register input device\n");
+
+ return ret;
+}
+
+static int rohm_bu21023_i2c_remove(struct i2c_client *client)
+{
+ struct rohm_ts_data *ts = i2c_get_clientdata(client);
+ int ret;
+
+ input_unregister_device(ts->input_dev);
+
+ ret = i2c_smbus_write_byte_data(client, SYSTEM,
+ ANALOG_POWER_ON | CPU_POWER_OFF);
+ if (ret)
+ return ret;
+
+ ret = i2c_smbus_write_byte_data(client, SYSTEM,
+ ANALOG_POWER_OFF | CPU_POWER_OFF);
+
+ return ret;
+}
+
+static const struct i2c_device_id rohm_bu21023_i2c_id[] = {
+ {BU21023_NAME, 0},
+ {},
+};
+
+MODULE_DEVICE_TABLE(i2c, rohm_bu21023_i2c_id);
+
+static struct i2c_driver rohm_bu21023_i2c_driver = {
+ .driver = {
+ .name = BU21023_NAME,
+ },
+ .probe = rohm_bu21023_i2c_probe,
+ .remove = rohm_bu21023_i2c_remove,
+ .id_table = rohm_bu21023_i2c_id,
+};
+
+module_i2c_driver(rohm_bu21023_i2c_driver);
+
+MODULE_DESCRIPTION("ROHM BU21023/24 Touchscreen driver");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("ROHM Co., Ltd.");
diff --git a/drivers/input/touchscreen/rohm_bu21023.h b/drivers/input/touchscreen/rohm_bu21023.h
new file mode 100644
index 0000000..302581b
--- /dev/null
+++ b/drivers/input/touchscreen/rohm_bu21023.h
@@ -0,0 +1,258 @@
+/*
+ * ROHM BU21023/24 Dual touch support resistive touch screen driver
+ * Copyright (C) 2012 ROHM CO.,LTD.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+#ifndef _BU21023_TS_H
+#define _BU21023_TS_H
+
+#define BU21023_NAME "bu21023_ts"
+#define BU21023_FIRMWARE_NAME "bu21023.bin"
+
+#define BU21023_MAX_SLOTS 2
+
+#define AXIS_ADJUST 4
+#define AXIS_OFFSET 8
+
+#define FIRMWARE_BLOCK_SIZE 32
+#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
+
+/*
+ * 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
+
+#endif /* _BU21023_TS_H */
--
1.7.9.5
^ permalink raw reply related [flat|nested] 3+ messages in thread
* Re: [PATCH v2] input: Add ROHM BU21023/24 Dual touch support resistive touchscreens
2014-08-04 11:51 [PATCH v2] input: Add ROHM BU21023/24 Dual touch support resistive touchscreens Yoichi Yuasa
@ 2014-09-12 7:23 ` Dmitry Torokhov
2014-10-24 16:06 ` Yuasa Yoichi
0 siblings, 1 reply; 3+ messages in thread
From: Dmitry Torokhov @ 2014-09-12 7:23 UTC (permalink / raw)
To: Yoichi Yuasa; +Cc: linux-input
Hi Yoichi,
Just finishing a review I started a while back. I see that you posted v3
in the meantime, but I think majority of the comments are still
applicable.
On Mon, Aug 04, 2014 at 08:51:42PM +0900, Yoichi Yuasa wrote:
> Signed-off-by: Yoichi Yuasa <yuasa@linux-mips.org>
> ---
> drivers/input/touchscreen/Kconfig | 11 +
> drivers/input/touchscreen/Makefile | 1 +
> drivers/input/touchscreen/rohm_bu21023.c | 929 ++++++++++++++++++++++++++++++
> drivers/input/touchscreen/rohm_bu21023.h | 258 +++++++++
> 4 files changed, 1199 insertions(+)
> create mode 100644 drivers/input/touchscreen/rohm_bu21023.c
> create mode 100644 drivers/input/touchscreen/rohm_bu21023.h
>
> diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
> index 6bb9a7d..9ae5c88 100644
> --- a/drivers/input/touchscreen/Kconfig
> +++ b/drivers/input/touchscreen/Kconfig
> @@ -950,4 +950,15 @@ config TOUCHSCREEN_ZFORCE
> To compile this driver as a module, choose M here: the
> module will be called zforce_ts.
>
> +config TOUCHSCREEN_ROHM_BU21023
> + tristate "ROHM BU21023/24 Dual touch support resistive touchscreens"
> + depends on I2C
> + help
> + Say Y here if you have a touchscreen using ROHM BU21023/24.
> +
> + If unsure, say N.
> +
> + To compile this driver as a module, choose M here: the
> + module will be called bu21023_ts.
> +
> endif
> diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
> index 4be94fc..af766d0 100644
> --- a/drivers/input/touchscreen/Makefile
> +++ b/drivers/input/touchscreen/Makefile
> @@ -52,6 +52,7 @@ obj-$(CONFIG_TOUCHSCREEN_USB_COMPOSITE) += usbtouchscreen.o
> obj-$(CONFIG_TOUCHSCREEN_PCAP) += pcap_ts.o
> obj-$(CONFIG_TOUCHSCREEN_PENMOUNT) += penmount.o
> obj-$(CONFIG_TOUCHSCREEN_PIXCIR) += pixcir_i2c_ts.o
> +obj-$(CONFIG_TOUCHSCREEN_ROHM_BU21023) += rohm_bu21023.o
> obj-$(CONFIG_TOUCHSCREEN_S3C2410) += s3c2410_ts.o
> obj-$(CONFIG_TOUCHSCREEN_ST1232) += st1232.o
> obj-$(CONFIG_TOUCHSCREEN_STMPE) += stmpe-ts.o
> diff --git a/drivers/input/touchscreen/rohm_bu21023.c b/drivers/input/touchscreen/rohm_bu21023.c
> new file mode 100644
> index 0000000..660b839
> --- /dev/null
> +++ b/drivers/input/touchscreen/rohm_bu21023.c
> @@ -0,0 +1,929 @@
> +/*
> + * ROHM BU21023/24 Dual touch support resistive touch screen driver
> + * Copyright (C) 2012 ROHM CO.,LTD.
> + *
> + * This software is licensed under the terms of the GNU General Public
> + * License version 2, as published by the Free Software Foundation, and
> + * may be copied, distributed, and modified under those terms.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + * GNU General Public License for more details.
> + */
> +#include <linux/delay.h>
> +#include <linux/firmware.h>
> +#include <linux/hrtimer.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>
> +
> +#include "rohm_bu21023.h"
> +
> +struct rohm_ts_data {
> + struct i2c_client *client;
> + struct input_dev *input_dev;
> +
> + bool initialized;
> +
> + unsigned int untouch_count;
> + unsigned int single_touch_count;
> + unsigned int dual_touch_count;
> + unsigned int prev_touch_report;
> +};
> +
> +/*
> + * rohm_i2c_burst_read - execute combined I2C message for ROHM BU21023/24
> + * @adap: Handle to I2C bus
> + * @msgs: combined messages to execute
> + * @num: Number of messages to be executed.
> + *
> + * Returns negative errno, else the number of messages executed.
> + *
> + * Note
> + * In BU21023/24 burst read, stop condition is needed after "address write".
> + * Therefore, transmission is performed in 2 steps.
> + */
> +static inline int rohm_i2c_burst_read(struct i2c_adapter *adap,
> + struct i2c_msg *msgs, int num)
No need to declare functions in .c files inline, let compiler figure out what
worth inlining and what isn't.
> +{
> + int ret, i;
> +
> + if (!adap->algo->master_xfer) {
> + dev_err(&adap->dev, "I2C level transfers not supported\n");
> + return -EOPNOTSUPP;
> + }
This we better check in probe().
> +
> + i2c_lock_adapter(adap);
> +
> + for (i = 0; i < num; i++) {
> + ret = __i2c_transfer(adap, &msgs[i], 1);
> + if (ret < 0)
> + break;
> +
> + ret = i;
> + }
> +
> + i2c_unlock_adapter(adap);
> +
> + return ret;
> +}
Overall, I think this fucntion should just take the buffer and the size
to transfer and set up the 2 i2c message structure internally instead of
having callers supply them for you. So:
static int rohm_i2c_burst_read(struct i2c_client *client,
void *buf, size_t len)
{
...
}
You are also not handling partial transfers so make sure it return 0 on
success and threat partian trasfers as -EIO.
> +
> +static int rohm_ts_manual_calibration(struct rohm_ts_data *ts)
> +{
> + struct i2c_client *client = ts->client;
> + struct device *dev = &client->dev;
> + struct i2c_msg msg[2];
> + u8 buf[33];
> + u8 addr_buf; /* burst read start address */
> +
> + 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 err = 0, ret;
> + int i;
> +
> + addr_buf = PRM1_X_H;
> + msg[0].addr = client->addr;
> + msg[0].flags = 0;
> + msg[0].len = 1;
> + msg[0].buf = &addr_buf;
> +
> + msg[1].addr = client->addr;
> + msg[1].flags = I2C_M_RD;
> + msg[1].len = sizeof(buf);
> + msg[1].buf = buf;
> +
> +#define READ_CALIB_BUF(reg) ((u16)buf[((reg) - PRM1_X_H)])
> +
> + 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;
> +
> + ret = i2c_smbus_write_byte_data(client, INT_MASK,
> + COORD_UPDATE | SLEEP_IN | SLEEP_OUT |
> + PROGRAM_LOAD_DONE);
> + if (ret) {
> + err = ret;
> + goto err_exit;
> + }
> +
> + ret = i2c_smbus_write_byte_data(client, TEST1, DUALTOUCH_STABILIZE_ON);
> + if (ret) {
> + err = ret;
> + goto err_exit;
> + }
> +
> + for (retry = 0; retry < CALIBRATION_RETRY_MAX; retry++) {
> + /* wait 2 sampling for update */
> + mdelay(2 * SAMPLING_DELAY);
> +
> + ret = rohm_i2c_burst_read(client->adapter, msg, 2);
> + if (ret < 0) {
> + err = ret;
> + goto err_exit;
> + }
> +
> + if (READ_CALIB_BUF(TOUCH) & TOUCH_DETECT)
> + continue;
> +
> + if (first_time) {
> + /* generate calibration parameter */
> + calib_x =
> + (READ_CALIB_BUF(PRM1_X_H) << 2 |
> + READ_CALIB_BUF(PRM1_X_L)) - AXIS_OFFSET;
> + calib_y =
> + (READ_CALIB_BUF(PRM1_Y_H) << 2 |
> + READ_CALIB_BUF(PRM1_Y_L)) - AXIS_OFFSET;
> +
> + ret = i2c_smbus_write_byte_data(client, TEST1,
> + DUALTOUCH_STABILIZE_ON |
> + DUALTOUCH_REG_ON);
> + if (ret) {
> + err = ret;
> + goto err_exit;
> + }
> +
> + first_time = false;
> + } else {
> + /* generate adjustment parameter */
> + err_x = READ_CALIB_BUF(PRM1_X_H) << 2 |
> + READ_CALIB_BUF(PRM1_X_L);
> + err_y = READ_CALIB_BUF(PRM1_Y_H) << 2 |
> + READ_CALIB_BUF(PRM1_Y_L);
> +
> + /* X axis ajust */
> + if (err_x <= 4)
> + calib_x -= AXIS_ADJUST;
> + else if (err_x >= 60)
> + calib_x += AXIS_ADJUST;
> +
> + /* Y axis ajust */
> + 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;
> +
> + ret = i2c_smbus_write_byte_data(client, CALIBRATION_REG1, reg1);
> + if (ret) {
> + err = ret;
> + goto err_exit;
> + }
> +
> + ret = i2c_smbus_write_byte_data(client, CALIBRATION_REG2, reg2);
> + if (ret) {
> + err = ret;
> + goto err_exit;
> + }
> +
> + ret = i2c_smbus_write_byte_data(client, CALIBRATION_REG3, reg3);
> + if (ret) {
> + err = ret;
> + goto err_exit;
> + }
> +
> + /*
> + * force calibration sequcence
> + */
> + ret = i2c_smbus_write_byte_data(client, FORCE_CALIBRATION,
> + FORCE_CALIBRATION_OFF);
> + if (ret) {
> + err = ret;
> + goto err_exit;
> + }
> +
> + ret = i2c_smbus_write_byte_data(client, FORCE_CALIBRATION,
> + FORCE_CALIBRATION_ON);
> + if (ret) {
> + err = ret;
> + goto err_exit;
> + }
> +
> + /* clear all interrupts */
> + ret = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff);
> + if (ret) {
> + err = ret;
> + goto err_exit;
> + }
> +
> + /*
> + * 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) {
> + err = val;
> + goto err_exit;
> + }
> + }
> +
> + if (calibration_done) {
> + val = i2c_smbus_read_byte_data(client, INT_STATUS);
> + if (val == CALIBRATION_DONE) {
> + success = true;
> + break;
> + } else if (val < 0) {
> + err = val;
> + goto err_exit;
> + }
> + } else
> + dev_warn(dev, "Calibration timeout\n");
Curly braces around this branch too please.
> + }
> +
> + if (!success) {
> + ret = i2c_smbus_write_byte_data(client, CALIBRATION_REG1,
> + reg1_orig);
> + if (ret) {
> + err = ret;
> + goto err_exit;
> + }
> +
> + ret = i2c_smbus_write_byte_data(client, CALIBRATION_REG2,
> + reg2_orig);
> + if (ret) {
> + err = ret;
> + goto err_exit;
> + }
> +
> + ret = i2c_smbus_write_byte_data(client, CALIBRATION_REG3,
> + reg3_orig);
> + if (ret) {
> + err = ret;
> + goto err_exit;
> + }
> +
> + /* calibration data enable */
> + ret = i2c_smbus_write_byte_data(client, TEST1,
> + DUALTOUCH_STABILIZE_ON |
> + DUALTOUCH_REG_ON);
> + if (ret) {
> + err = ret;
> + goto err_exit;
> + }
> +
> + /* wait 10 sampling */
> + mdelay(10 * SAMPLING_DELAY);
> +
> + err = -EBUSY;
> + }
> +
> +err_exit:
> + ret = i2c_smbus_write_byte_data(client, INT_MASK, INT_ALL);
> + if (!ret)
> + /* Clear all interrupts */
> + ret = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff);
> +
> + if (!err && ret)
> + err = ret;
> +
> + return err;
> +}
> +
> +static unsigned long inactive_polling_interval[2] = { 1, 0 };
> +static unsigned long active_polling_interval[2] = { 0, 10000000 };
> +
> +module_param_array(inactive_polling_interval, ulong, NULL, S_IRUGO | S_IWUSR);
> +module_param_array(active_polling_interval, ulong, NULL, S_IRUGO | S_IWUSR);
> +
> +MODULE_PARM_DESC(inactive_polling_interval,
> + "Polling interval for un-touch detection");
> +MODULE_PARM_DESC(active_polling_interval,
> + "Polling interval for touch detection");
> +
> +#define INACTIVE_POLLING_INTERVAL_KTIME \
> + ktime_set(inactive_polling_interval[0], inactive_polling_interval[1])
> +#define ACTIVE_POLLING_INTERVAL_KTIME \
> + ktime_set(active_polling_interval[0], active_polling_interval[1])
I do not see it being used?
> +
> +static unsigned int untouch_threshold[3] = { 0, 1, 5 };
> +static unsigned int single_touch_threshold[3] = { 0, 0, 4 };
> +static unsigned int dual_touch_threshold[3] = { 10, 8, 0 };
> +
> +module_param_array(untouch_threshold, uint, NULL, S_IRUGO | S_IWUSR);
> +module_param_array(single_touch_threshold, uint, NULL, S_IRUGO | S_IWUSR);
> +module_param_array(dual_touch_threshold, uint, NULL, S_IRUGO | S_IWUSR);
> +
> +MODULE_PARM_DESC(untouch_threshold, "Thresholds for un-touch detection");
> +MODULE_PARM_DESC(single_touch_threshold,
> + "Thresholds for single touch detection");
> +MODULE_PARM_DESC(dual_touch_threshold, "Thresholds for dual touch detection");
> +
> +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_dev;
> + struct device *dev = &client->dev;
> +
> + struct i2c_msg msg[2];
> + u16 addr = client->addr;
> + u8 addr_buf;
> + u8 buf[10]; /* for 0x20-0x29 */
> +
> + struct input_mt_pos pos[BU21023_MAX_SLOTS];
> + int slots[BU21023_MAX_SLOTS];
> + u8 touch_flags;
> + unsigned int threshold;
> + int touch_report = -1;
> + unsigned int prev_touch_report = ts->prev_touch_report;
> +
> + s32 status;
> + int i, ret;
> +
> + status = i2c_smbus_read_byte_data(client, INT_STATUS);
> + if (!status)
> + return IRQ_NONE;
> +
> + if (status < 0)
> + return IRQ_HANDLED;
> +
> + ret = i2c_smbus_write_byte_data(client, INT_MASK, INT_ALL);
> + if (ret)
> + return IRQ_HANDLED;
> +
> + /* Clear all interrupts */
> + ret = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff);
> + if (ret)
> + return IRQ_HANDLED;
> +
> + addr_buf = POS_X1_H;
> + msg[0].addr = addr;
> + msg[0].flags = 0;
> + msg[0].len = 1;
> + msg[0].buf = &addr_buf;
> +
> + msg[1].addr = addr;
> + msg[1].flags = I2C_M_RD;
> + msg[1].len = sizeof(buf);
> + msg[1].buf = buf;
> +
> +#define READ_POS_BUF(reg) ((u16)buf[((reg) - POS_X1_H)])
> +
> + ret = rohm_i2c_burst_read(client->adapter, msg, 2);
> + if (ret < 0)
> + return IRQ_HANDLED;
> +
> + touch_flags = READ_POS_BUF(TOUCH_GESTURE) & TOUCH_MASK;
> + if (touch_flags) {
> + /* generate coordinates */
> + pos[0].x = (READ_POS_BUF(POS_X1_H) << 2) |
> + READ_POS_BUF(POS_X1_L);
> + pos[0].y = (READ_POS_BUF(POS_Y1_H) << 2) |
> + READ_POS_BUF(POS_Y1_L);
> + pos[1].x = (READ_POS_BUF(POS_X2_H) << 2) |
> + READ_POS_BUF(POS_X2_L);
> + pos[1].y = (READ_POS_BUF(POS_Y2_H) << 2) |
> + READ_POS_BUF(POS_Y2_L);
> +
> + switch (touch_flags) {
> + case SINGLE_TOUCH:
> + ts->untouch_count = 0;
> + ts->single_touch_count++;
> + ts->dual_touch_count = 0;
> +
> + threshold = single_touch_threshold[prev_touch_report];
> + if (ts->single_touch_count > threshold)
> + touch_report = 1;
> +
> + if (touch_report == 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:
> + ts->untouch_count = 0;
> + ts->single_touch_count = 0;
> + ts->dual_touch_count++;
> +
> + threshold = dual_touch_threshold[prev_touch_report];
> + if (ts->dual_touch_count > threshold)
> + touch_report = 2;
> + break;
> + default:
> + dev_err(dev,
> + "Three or more touches are not supported\n");
You do not want to pollute logs with this, please use dev_dbg().
> + return IRQ_HANDLED;
> + break;
> + }
> + } else {
> + ts->untouch_count++;
> +
> + threshold = untouch_threshold[prev_touch_report];
I do nto understand the therhold logic. You have an array but never
update prev_touch_report index so it is always 0... And why do you need
count at all?
> + if (ts->untouch_count > threshold) {
> + ts->untouch_count = 0;
> + ts->single_touch_count = 0;
> + ts->dual_touch_count = 0;
> +
> + touch_report = 0;
> + }
> + }
> +
> + input_mt_assign_slots(input_dev, slots, pos, touch_report);
> +
> + for (i = 0; i < touch_report; 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);
> +
> + if (READ_POS_BUF(TOUCH_GESTURE) & CALIBRATION_REQUEST) {
> + if (rohm_ts_manual_calibration(ts) < 0)
> + dev_warn(dev, "Failed to manual calibration\n");
> + }
> +
> +
> + i2c_smbus_write_byte_data(client, INT_MASK,
> + CALIBRATION_DONE | SLEEP_OUT | SLEEP_IN |
> + PROGRAM_LOAD_DONE);
> +
> + return IRQ_HANDLED;
> +}
> +
> +static irqreturn_t rohm_ts_hard_irq(int irq, void *dev_id)
> +{
> + return IRQ_WAKE_THREAD;
> +}
No need for this function, you can just pass NULL to request_threaded_irq().
> +
> +static int rohm_ts_load_firmware(struct i2c_client *client,
> + const char *firmware_name)
> +{
> + struct device *dev = &client->dev;
> + const struct firmware *firmware = NULL;
> + s32 status;
> + int blocks, remainder, retry = 0, offset;
> + int err = 0, ret;
> + int i;
> +
> + ret = request_firmware(&firmware, firmware_name, dev);
> + if (ret) {
> + dev_err(dev, "Unable to open firmware %s\n", firmware_name);
> + return ret;
> + }
> +
> + blocks = firmware->size / FIRMWARE_BLOCK_SIZE;
> + remainder = firmware->size % FIRMWARE_BLOCK_SIZE;
> +
> + ret = i2c_smbus_write_byte_data(client, INT_MASK,
> + COORD_UPDATE | CALIBRATION_DONE |
> + SLEEP_IN | SLEEP_OUT);
> + if (ret) {
> + err = ret;
> + goto err_int_mask_exit;
> + }
> +
> + while (retry < FIRMWARE_RETRY_MAX) {
> + ret = i2c_smbus_write_byte_data(client, COMMON_SETUP1,
> + COMMON_SETUP1_DEFAULT);
> + if (ret) {
> + err = ret;
> + goto err_int_mask_exit;
> + }
> +
> + ret = i2c_smbus_write_byte_data(client, EX_ADDR_H, 0);
> + if (ret) {
> + err = ret;
> + goto err_int_mask_exit;
> + }
> +
> + ret = i2c_smbus_write_byte_data(client, EX_ADDR_L, 0);
> + if (ret) {
> + err = ret;
> + goto err_int_mask_exit;
> + }
> +
> + offset = 0;
> +
> + /* firmware load to the device */
> + for (i = 0; i < blocks; i++) {
> + ret = i2c_smbus_write_i2c_block_data(client, EX_WDAT,
> + FIRMWARE_BLOCK_SIZE, &firmware->data[offset]);
> + if (ret) {
> + err = ret;
> + goto err_int_mask_exit;
> + }
> +
> + offset += FIRMWARE_BLOCK_SIZE;
> + }
> +
> + if (remainder) {
> + ret = i2c_smbus_write_i2c_block_data(client, EX_WDAT,
> + remainder, &firmware->data[offset]);
> + if (ret) {
> + err = ret;
> + goto err_int_mask_exit;
> + }
> + }
> +
> + /* check formware load result */
> + status = i2c_smbus_read_byte_data(client, INT_STATUS);
> + if (status < 0) {
> + err = status;
> + goto err_int_mask_exit;
> + }
> +
> + /* clear all interrupts */
> + ret = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff);
> + if (ret) {
> + err = ret;
> + goto err_int_mask_exit;
> + }
> +
> + if (status == PROGRAM_LOAD_DONE)
> + break;
> +
> + /* settings for retry */
> + ret = i2c_smbus_write_byte_data(client, EX_WDAT, 0);
> + if (ret) {
> + err = ret;
> + goto err_int_mask_exit;
> + }
> +
> + retry++;
> + dev_warn(dev, "Retry firmware load\n");
> + }
> +
> +err_int_mask_exit:
> + ret = i2c_smbus_write_byte_data(client, INT_MASK, INT_ALL);
> + if (ret)
> + err = ret;
> +
> + release_firmware(firmware);
> +
> + if (retry >= FIRMWARE_RETRY_MAX)
> + return -EBUSY;
> +
> + return err;
> +}
> +
> +static bool swap_xy;
> +module_param(swap_xy, bool, S_IRUGO);
> +MODULE_PARM_DESC(swap_xy, "Swap X-axis and Y-axis");
> +
> +static bool inv_x;
> +module_param(inv_x, bool, S_IRUGO);
> +MODULE_PARM_DESC(inv_x, "Invert X-axis");
> +
> +static bool inv_y;
> +module_param(inv_y, bool, S_IRUGO);
> +MODULE_PARM_DESC(inv_y, "Invert Y-axis");
This should be per-device parameters, not module parameters.
> +
> +static int rohm_ts_device_init(struct rohm_ts_data *ts)
> +{
> + struct i2c_client *client = ts->client;
> + struct device *dev = &client->dev;
> + u8 val;
> + int ret;
> +
> + /*
> + * Wait 200usec for reset
> + */
> + udelay(200);
> +
> + /* Release analog reset */
> + ret = i2c_smbus_write_byte_data(client, SYSTEM, ANALOG_POWER_ON);
> + if (ret)
> + return ret;
> +
> + /* Waiting for the analog warm-up, max. 200usec */
> + udelay(200);
> +
> + /* clear all interrupts */
> + ret = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff);
> + if (ret)
> + return ret;
> +
> + val = MAF_1SAMPLE;
> + if (swap_xy)
> + val |= SWAP_XY;
> + if (inv_x)
> + val |= INV_X;
> + if (inv_y)
> + val |= INV_Y;
> +
> + ret = i2c_smbus_write_byte_data(client, EX_WDAT, 0);
> + if (ret)
> + return ret;
> +
> + ret = i2c_smbus_write_byte_data(client, COMMON_SETUP1, 0);
> + if (ret)
> + return ret;
> +
> + ret = i2c_smbus_write_byte_data(client, COMMON_SETUP2, val);
> + if (ret)
> + return ret;
> +
> + ret = i2c_smbus_write_byte_data(client, COMMON_SETUP3,
> + SEL_TBL_DEFAULT | EN_MULTI);
> + if (ret)
> + return ret;
> +
> + ret = i2c_smbus_write_byte_data(client, THRESHOLD_GESTURE,
> + THRESHOLD_GESTURE_DEFAULT);
> + if (ret)
> + return ret;
> +
> + ret = i2c_smbus_write_byte_data(client, INTERVAL_TIME,
> + INTERVAL_TIME_DEFAULT);
> + if (ret)
> + return ret;
> +
> + ret = i2c_smbus_write_byte_data(client, CPU_FREQ, CPU_FREQ_10MHZ);
> + if (ret)
> + return ret;
> +
> + ret = i2c_smbus_write_byte_data(client, PRM_SWOFF_TIME,
> + PRM_SWOFF_TIME_DEFAULT);
> + if (ret)
> + return ret;
> +
> + ret = i2c_smbus_write_byte_data(client, ADC_CTRL, ADC_DIV_DEFAULT);
> + if (ret)
> + return ret;
> +
> + ret = i2c_smbus_write_byte_data(client, ADC_WAIT, ADC_WAIT_DEFAULT);
> + if (ret)
> + return ret;
> +
> + /*
> + * Panel setup, these values change with the panel.
> + */
> + ret = i2c_smbus_write_byte_data(client, STEP_X, STEP_X_DEFAULT);
> + if (ret)
> + return ret;
> +
> + ret = i2c_smbus_write_byte_data(client, STEP_Y, STEP_Y_DEFAULT);
> + if (ret)
> + return ret;
> +
> + ret = i2c_smbus_write_byte_data(client, OFFSET_X, OFFSET_X_DEFAULT);
> + if (ret)
> + return ret;
> +
> + ret = i2c_smbus_write_byte_data(client, OFFSET_Y, OFFSET_Y_DEFAULT);
> + if (ret)
> + return ret;
> +
> + ret = i2c_smbus_write_byte_data(client, THRESHOLD_TOUCH,
> + THRESHOLD_TOUCH_DEFAULT);
> + if (ret)
> + return ret;
> +
> + ret = i2c_smbus_write_byte_data(client, EVR_XY, EVR_XY_DEFAULT);
> + if (ret)
> + return ret;
> +
> + ret = i2c_smbus_write_byte_data(client, EVR_X, EVR_X_DEFAULT);
> + if (ret)
> + return ret;
> +
> + ret = i2c_smbus_write_byte_data(client, EVR_Y, EVR_Y_DEFAULT);
> + if (ret)
> + return ret;
> +
> + /* Fixed value settings */
> + ret = i2c_smbus_write_byte_data(client, CALIBRATION_ADJUST,
> + CALIBRATION_ADJUST_DEFAULT);
> + if (ret)
> + return ret;
> +
> + ret = i2c_smbus_write_byte_data(client, SWCONT, SWCONT_DEFAULT);
> + if (ret)
> + return ret;
> +
> + ret = i2c_smbus_write_byte_data(client, TEST1,
> + DUALTOUCH_STABILIZE_ON |
> + DUALTOUCH_REG_ON);
> + if (ret)
> + return ret;
> +
> + ret = rohm_ts_load_firmware(client, BU21023_FIRMWARE_NAME);
> + if (ret) {
> + dev_err(dev, "Failed to firmware load\n");
> + return ret;
> + }
> +
> + /*
> + * 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.
> + */
> + ret = i2c_smbus_write_byte_data(client, CALIBRATION_REG1,
> + CALIBRATION_REG1_DEFAULT);
> + if (ret)
> + return ret;
> +
> + ret = i2c_smbus_write_byte_data(client, CALIBRATION_REG2,
> + CALIBRATION_REG2_DEFAULT);
> + if (ret)
> + return ret;
> +
> + ret = i2c_smbus_write_byte_data(client, CALIBRATION_REG3,
> + CALIBRATION_REG3_DEFAULT);
> + if (ret)
> + return ret;
> +
> + ret = i2c_smbus_write_byte_data(client, FORCE_CALIBRATION,
> + FORCE_CALIBRATION_OFF);
> + if (ret)
> + return ret;
> +
> + ret = i2c_smbus_write_byte_data(client, FORCE_CALIBRATION,
> + FORCE_CALIBRATION_ON);
> + if (ret)
> + return ret;
> +
> + /* Clear all interrupts */
> + ret = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff);
> + if (ret)
> + return ret;
> +
> + ret = devm_request_threaded_irq(dev, client->irq, rohm_ts_hard_irq,
> + rohm_ts_soft_irq, IRQF_TRIGGER_FALLING,
> + client->name, ts);
> + if (ret) {
> + dev_err(dev, "Unable to request IRQ\n");
> + return ret;
> + }
> +
> + /* Enable coordinates update interrupt */
> + ret = i2c_smbus_write_byte_data(client, INT_MASK,
> + CALIBRATION_DONE |
> + SLEEP_OUT | SLEEP_IN |
> + PROGRAM_LOAD_DONE);
> + if (ret)
> + return ret;
> +
> + ret = i2c_smbus_write_byte_data(client, ERR_MASK,
> + PROGRAM_LOAD_ERR | CPU_TIMEOUT |
> + ADC_TIMEOUT);
> + if (ret)
> + return ret;
> +
> + /* controller CPU power on */
> + ret = i2c_smbus_write_byte_data(client, SYSTEM,
> + CPU_POWER_ON | ANALOG_POWER_ON);
> +
> + return ret;
> +}
> +
> +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 ret;
> +
> + if (!ts->initialized) {
> + ret = rohm_ts_device_init(ts);
> + if (ret) {
> + dev_err(&client->dev,
> + "Failed to device initialization\n");
> + return ret;
> + }
> +
> + ts->initialized = true;
> + }
> +
> + return 0;
> +}
> +
> +static int rohm_bu21023_i2c_probe(struct i2c_client *client,
> + const struct i2c_device_id *id)
> +{
> + struct rohm_ts_data *ts;
> + struct device *dev = &client->dev;
> + struct input_dev *input_dev;
> + int ret;
> +
> + if (!client->irq) {
> + dev_err(dev, "IRQ is not assigned\n");
> + return -EBUSY;
-EINVAL. There is no point in retrying.
> + }
> +
> + ts = devm_kzalloc(dev, sizeof(struct rohm_ts_data), GFP_KERNEL);
> + if (!ts)
> + return -ENOMEM;
> +
> + ts->client = client;
> + i2c_set_clientdata(client, ts);
> +
> + input_dev = devm_input_allocate_device(dev);
> + if (!input_dev)
> + return -ENOMEM;
> +
> + input_dev->name = BU21023_NAME;
> + input_dev->id.bustype = BUS_I2C;
> + input_dev->open = rohm_ts_open;
> +
> + ts->input_dev = input_dev;
> + input_set_drvdata(input_dev, ts);
> +
> + set_bit(EV_SYN, input_dev->evbit);
> + set_bit(EV_KEY, input_dev->evbit);
> + set_bit(EV_ABS, input_dev->evbit);
> +
> + set_bit(BTN_TOUCH, input_dev->evbit);
> +
> + input_set_abs_params(input_dev, ABS_MT_POSITION_X,
> + ROHM_TS_ABS_X_MIN, ROHM_TS_ABS_X_MAX, 0, 0);
> + input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
> + ROHM_TS_ABS_Y_MIN, ROHM_TS_ABS_Y_MAX, 0, 0);
> +
> + input_set_abs_params(input_dev, ABS_X,
> + ROHM_TS_ABS_X_MIN, ROHM_TS_ABS_X_MAX, 0, 0);
> + input_set_abs_params(input_dev, ABS_Y,
> + ROHM_TS_ABS_Y_MIN, ROHM_TS_ABS_Y_MAX, 0, 0);
> +
> + ret = input_register_device(input_dev);
> + if (ret)
> + dev_err(dev, "Unable to register input device\n");
> +
> + return ret;
> +}
> +
> +static int rohm_bu21023_i2c_remove(struct i2c_client *client)
> +{
> + struct rohm_ts_data *ts = i2c_get_clientdata(client);
> + int ret;
> +
> + input_unregister_device(ts->input_dev);
> +
> + ret = i2c_smbus_write_byte_data(client, SYSTEM,
> + ANALOG_POWER_ON | CPU_POWER_OFF);
> + if (ret)
> + return ret;
> +
> + ret = i2c_smbus_write_byte_data(client, SYSTEM,
> + ANALOG_POWER_OFF | CPU_POWER_OFF);
> +
> + return ret;
> +}
> +
> +static const struct i2c_device_id rohm_bu21023_i2c_id[] = {
> + {BU21023_NAME, 0},
> + {},
> +};
> +
> +MODULE_DEVICE_TABLE(i2c, rohm_bu21023_i2c_id);
> +
> +static struct i2c_driver rohm_bu21023_i2c_driver = {
> + .driver = {
> + .name = BU21023_NAME,
> + },
This is weird formatting.
> + .probe = rohm_bu21023_i2c_probe,
> + .remove = rohm_bu21023_i2c_remove,
> + .id_table = rohm_bu21023_i2c_id,
> +};
> +
> +module_i2c_driver(rohm_bu21023_i2c_driver);
> +
> +MODULE_DESCRIPTION("ROHM BU21023/24 Touchscreen driver");
> +MODULE_LICENSE("GPL");
> +MODULE_AUTHOR("ROHM Co., Ltd.");
> diff --git a/drivers/input/touchscreen/rohm_bu21023.h b/drivers/input/touchscreen/rohm_bu21023.h
> new file mode 100644
> index 0000000..302581b
> --- /dev/null
> +++ b/drivers/input/touchscreen/rohm_bu21023.h
> @@ -0,0 +1,258 @@
> +/*
> + * ROHM BU21023/24 Dual touch support resistive touch screen driver
> + * Copyright (C) 2012 ROHM CO.,LTD.
> + *
> + * This software is licensed under the terms of the GNU General Public
> + * License version 2, as published by the Free Software Foundation, and
> + * may be copied, distributed, and modified under those terms.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + * GNU General Public License for more details.
> + */
> +#ifndef _BU21023_TS_H
> +#define _BU21023_TS_H
> +
> +#define BU21023_NAME "bu21023_ts"
> +#define BU21023_FIRMWARE_NAME "bu21023.bin"
> +
> +#define BU21023_MAX_SLOTS 2
> +
> +#define AXIS_ADJUST 4
> +#define AXIS_OFFSET 8
> +
> +#define FIRMWARE_BLOCK_SIZE 32
> +#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
> +
> +/*
> + * 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
> +
> +#endif /* _BU21023_TS_H */
> --
> 1.7.9.5
>
Why does this have to be in a separate header if there are no users of
it?
Thanks.
--
Dmitry
^ permalink raw reply [flat|nested] 3+ messages in thread
* Re: [PATCH v2] input: Add ROHM BU21023/24 Dual touch support resistive touchscreens
2014-09-12 7:23 ` Dmitry Torokhov
@ 2014-10-24 16:06 ` Yuasa Yoichi
0 siblings, 0 replies; 3+ messages in thread
From: Yuasa Yoichi @ 2014-10-24 16:06 UTC (permalink / raw)
To: Dmitry Torokhov; +Cc: linux-input, Yoichi Yuasa
Hi Dmitry,
I'm sorry that I didn't find your e-mail earlier.
2014-09-12 16:23 GMT+09:00 Dmitry Torokhov <dmitry.torokhov@gmail.com>:
> Hi Yoichi,
>
> Just finishing a review I started a while back. I see that you posted v3
> in the meantime, but I think majority of the comments are still
> applicable.
Thank you for your comments.
I'll try to update them by v4.
Thanks,
Yoichi
^ permalink raw reply [flat|nested] 3+ messages in thread
end of thread, other threads:[~2014-10-24 16:06 UTC | newest]
Thread overview: 3+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2014-08-04 11:51 [PATCH v2] input: Add ROHM BU21023/24 Dual touch support resistive touchscreens Yoichi Yuasa
2014-09-12 7:23 ` Dmitry Torokhov
2014-10-24 16:06 ` Yuasa Yoichi
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.