From patchwork Thu Jul 31 10:54:34 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yoichi Yuasa X-Patchwork-Id: 4655181 Return-Path: X-Original-To: patchwork-linux-input@patchwork.kernel.org Delivered-To: patchwork-parsemail@patchwork1.web.kernel.org Received: from mail.kernel.org (mail.kernel.org [198.145.19.201]) by patchwork1.web.kernel.org (Postfix) with ESMTP id B49339F32F for ; Thu, 31 Jul 2014 11:26:44 +0000 (UTC) Received: from mail.kernel.org (localhost [127.0.0.1]) by mail.kernel.org (Postfix) with ESMTP id 92B612015E for ; Thu, 31 Jul 2014 11:26:42 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 12E6F2017A for ; Thu, 31 Jul 2014 11:26:40 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751222AbaGaL0j (ORCPT ); Thu, 31 Jul 2014 07:26:39 -0400 Received: from mo-sg-fb1501.iij4u.or.jp ([210.130.239.8]:37607 "EHLO mo-sg-fb.iij4u.or.jp" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750859AbaGaL0h (ORCPT ); Thu, 31 Jul 2014 07:26:37 -0400 X-Greylist: delayed 1825 seconds by postgrey-1.27 at vger.kernel.org; Thu, 31 Jul 2014 07:26:37 EDT Received: by mo-sg-fb.iij4u.or.jp (4u-mo-sg-fb1501) id s6VAuLk1000426; Thu, 31 Jul 2014 19:56:21 +0900 Received: by mo-sg.iij4u.or.jp (4u-mo-sg1501) id s6VAu0mh024106; Thu, 31 Jul 2014 19:56:00 +0900 Received: from delta (sannin29190.nirai.ne.jp [203.160.29.190]) by mbox.iij4u.or.jp (4u-mbox1500) id s6VAti6N021825 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=NOT); Thu, 31 Jul 2014 19:55:54 +0900 Date: Thu, 31 Jul 2014 19:54:34 +0900 From: Yoichi Yuasa To: Dmitry Torokhov Cc: yuasa@linux-mips.org, linux-input@vger.kernel.org Subject: [PATCH] input: Add ROHM BU21023/24 Dual touch support resistive touchscreens Message-Id: <20140731195434.d141b39f3920686485c64191@linux-mips.org> X-Mailer: Sylpheed 3.2.0beta5 (GTK+ 2.24.10; x86_64-pc-linux-gnu) Mime-Version: 1.0 Sender: linux-input-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-input@vger.kernel.org X-Spam-Status: No, score=-7.6 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_HI, RP_MATCHES_RCVD, UNPARSEABLE_RELAY autolearn=ham version=3.3.1 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on mail.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP Signed-off-by: Yoichi Yuasa --- drivers/input/touchscreen/Kconfig | 11 + drivers/input/touchscreen/Makefile | 1 + drivers/input/touchscreen/rohm_bu21023.c | 791 ++++++++++++++++++++++++++++++ drivers/input/touchscreen/rohm_bu21023.h | 255 ++++++++++ 4 files changed, 1058 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..317d59b --- /dev/null +++ b/drivers/input/touchscreen/rohm_bu21023.c @@ -0,0 +1,791 @@ +/* + * 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 +#include +#include +#include +#include +#include +#include +#include + +#include "rohm_bu21023.h" + +struct rohm_ts_point { + unsigned int x; + unsigned int y; +}; + +struct rohm_ts_data { + struct i2c_client *client; + struct input_dev *input_dev; + + int use_irq; + struct hrtimer hrtimer; + struct workqueue_struct *workqueue; + struct work_struct work; + + 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_dbg(&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; + u8 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 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); + reg2_orig = i2c_smbus_read_byte_data(client, CALIBRATION_REG2); + reg3_orig = i2c_smbus_read_byte_data(client, CALIBRATION_REG3); + + if (ts->use_irq) + disable_irq(client->irq); + + i2c_smbus_write_byte_data(client, INT_MASK, + COORD_UPDATE | SLEEP_IN | SLEEP_OUT | + PROGRAM_LOAD_DONE); + + i2c_smbus_write_byte_data(client, TEST1, DUALTOUCH_STABILIZE_ON); + + 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) { + dev_err(dev, "I2C transfer error\n"); + return ret; + } + + 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; + + i2c_smbus_write_byte_data(client, TEST1, + DUALTOUCH_STABILIZE_ON | + DUALTOUCH_REG_ON); + + 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; + + i2c_smbus_write_byte_data(client, CALIBRATION_REG1, reg1); + i2c_smbus_write_byte_data(client, CALIBRATION_REG2, reg2); + i2c_smbus_write_byte_data(client, CALIBRATION_REG3, reg3); + + /* + * force calibration sequcence + */ + i2c_smbus_write_byte_data(client, FORCE_CALIBRATION, + FORCE_CALIBRATION_OFF); + + i2c_smbus_write_byte_data(client, FORCE_CALIBRATION, + FORCE_CALIBRATION_ON); + + /* clear all interrupts */ + i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff); + + /* + * 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; + } + } + + if (calibration_done) { + val = i2c_smbus_read_byte_data(client, INT_STATUS); + if (val == CALIBRATION_DONE) { + success = true; + break; + } + } else + dev_warn(dev, "Calibration timeout\n"); + } + + if (!success) { + i2c_smbus_write_byte_data(client, CALIBRATION_REG1, reg1_orig); + i2c_smbus_write_byte_data(client, CALIBRATION_REG2, reg2_orig); + i2c_smbus_write_byte_data(client, CALIBRATION_REG3, reg3_orig); + + /* calibration data enable */ + i2c_smbus_write_byte_data(client, TEST1, + DUALTOUCH_STABILIZE_ON | + DUALTOUCH_REG_ON); + + /* wait 10 sampling */ + mdelay(10 * SAMPLING_DELAY); + + dev_warn(dev, "Failed to manual calibration\n"); + ret = -EBUSY; + } else { + dev_dbg(dev, "Manual calibration done\n"); + ret = 0; + } + + i2c_smbus_write_byte_data(client, INT_MASK, + COORD_UPDATE | CALIBRATION_DONE | + SLEEP_IN | SLEEP_OUT | + PROGRAM_LOAD_DONE | ERROR); + + /* Clear all interrupts */ + i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff); + + if (ts->use_irq) + enable_irq(client->irq); + + return ret; +} + +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 void rohm_ts_work_func(struct work_struct *work) +{ + struct rohm_ts_data *ts = container_of(work, struct rohm_ts_data, work); + 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 rohm_ts_point tp1, tp2; + u8 touch_flags; + unsigned int threshold; + int touch_report = -1; + unsigned int prev_touch_report = ts->prev_touch_report; + bool next_sensing_immediately = false; + + int ret; + + i2c_smbus_write_byte_data(client, INT_MASK, + COORD_UPDATE | CALIBRATION_DONE | + SLEEP_OUT | SLEEP_IN | PROGRAM_LOAD_DONE | + ERROR); + + /* Clear all interrupts */ + i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff); + + 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) { + dev_err(dev, "I2C transfer error\n"); + return; + } + + touch_flags = READ_POS_BUF(TOUCH_GESTURE) & TOUCH_MASK; + if (touch_flags) { + next_sensing_immediately = true; + + /* generate coordinates */ + tp1.x = (READ_POS_BUF(POS_X1_H) << 2) | READ_POS_BUF(POS_X1_L); + tp1.y = (READ_POS_BUF(POS_Y1_H) << 2) | READ_POS_BUF(POS_Y1_L); + tp2.x = (READ_POS_BUF(POS_X2_H) << 2) | READ_POS_BUF(POS_X2_L); + tp2.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 (tp2.x != 0 && tp2.y != 0) { + tp1.x = tp2.x; + tp1.y = tp2.y; + tp2.x = 0; + tp2.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"); + 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; + } else if (prev_touch_report > 0) { + next_sensing_immediately = true; + } + } + + switch (touch_report) { + case 0: + input_mt_sync(input_dev); + + input_sync(input_dev); + ts->prev_touch_report = touch_report; + break; + case 1: + input_report_abs(input_dev, ABS_MT_POSITION_X, tp1.x); + input_report_abs(input_dev, ABS_MT_POSITION_Y, tp1.y); + input_mt_sync(input_dev); + + input_sync(input_dev); + ts->prev_touch_report = touch_report; + break; + case 2: + input_report_abs(input_dev, ABS_MT_POSITION_X, tp1.x); + input_report_abs(input_dev, ABS_MT_POSITION_Y, tp1.y); + input_mt_sync(input_dev); + input_report_abs(input_dev, ABS_MT_POSITION_X, tp2.x); + input_report_abs(input_dev, ABS_MT_POSITION_Y, tp2.y); + input_mt_sync(input_dev); + + input_sync(input_dev); + ts->prev_touch_report = touch_report; + break; + default: + break; + } + + /* set next sensing time */ + if (next_sensing_immediately) { + hrtimer_start(&ts->hrtimer, + ACTIVE_POLLING_INTERVAL_KTIME, HRTIMER_MODE_REL); + } else { + if (READ_POS_BUF(TOUCH_GESTURE) & CALIBRATION_REQUEST) + rohm_ts_manual_calibration(ts); + + if (ts->use_irq) { + i2c_smbus_write_byte_data(client, INT_MASK, + CALIBRATION_DONE | + SLEEP_OUT | SLEEP_IN | + PROGRAM_LOAD_DONE); + } else { + hrtimer_start(&ts->hrtimer, + INACTIVE_POLLING_INTERVAL_KTIME, + HRTIMER_MODE_REL); + } + } +} + +static enum hrtimer_restart rohm_ts_timer_func(struct hrtimer *hrtimer) +{ + struct rohm_ts_data *ts = + container_of(hrtimer, struct rohm_ts_data, hrtimer); + + queue_work(ts->workqueue, &ts->work); + + return HRTIMER_NORESTART; +} + +static irqreturn_t rohm_ts_irq_handler(int irq, void *dev_id) +{ + struct rohm_ts_data *ts = dev_id; + + queue_work(ts->workqueue, &ts->work); + + return IRQ_HANDLED; +} + +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, offset; + int 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; + + i2c_smbus_write_byte_data(client, INT_MASK, + COORD_UPDATE | CALIBRATION_DONE | + SLEEP_IN | SLEEP_OUT); + + for (retry = 0; retry < FIRMWARE_RETRY_MAX; retry++) { + i2c_smbus_write_byte_data(client, COMMON_SETUP1, + COMMON_SETUP1_DEFAULT); + i2c_smbus_write_byte_data(client, EX_ADDR_H, 0); + i2c_smbus_write_byte_data(client, EX_ADDR_L, 0); + + offset = 0; + + /* firmware load to the device */ + for (i = 0; i < blocks; i++) { + i2c_smbus_write_i2c_block_data(client, EX_WDAT, + FIRMWARE_BLOCK_SIZE, + &firmware->data[offset]); + offset += FIRMWARE_BLOCK_SIZE; + } + + if (remainder) + i2c_smbus_write_i2c_block_data(client, EX_WDAT, + remainder, + &firmware->data[offset]); + + /* check formware load result */ + status = i2c_smbus_read_byte_data(client, INT_STATUS); + + /* clear all interrupts */ + i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff); + + if (status == PROGRAM_LOAD_DONE) + break; + + dev_warn(dev, "Retry firmware load\n"); + + /* settings for retry */ + i2c_smbus_write_byte_data(client, EX_WDAT, 0); + } + + i2c_smbus_write_byte_data(client, INT_MASK, + COORD_UPDATE | CALIBRATION_DONE | + SLEEP_IN | SLEEP_OUT | + PROGRAM_LOAD_DONE | ERROR); + + release_firmware(firmware); + + if (retry >= FIRMWARE_RETRY_MAX) + return -EBUSY; + + return 0; +} + +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 i2c_client *client) +{ + 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 < 0) + return ret; + + /* Waiting for the analog warm-up, max. 200usec */ + udelay(200); + + /* clear all interrupts */ + i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff); + + val = MAF_1SAMPLE; + if (swap_xy) + val |= SWAP_XY; + if (inv_x) + val |= INV_X; + if (inv_y) + val |= INV_Y; + + i2c_smbus_write_byte_data(client, EX_WDAT, 0); + i2c_smbus_write_byte_data(client, COMMON_SETUP1, 0); + i2c_smbus_write_byte_data(client, COMMON_SETUP2, val); + i2c_smbus_write_byte_data(client, COMMON_SETUP3, + SEL_TBL_DEFAULT | EN_GESTURE | EN_MULTI); + i2c_smbus_write_byte_data(client, THRESHOLD_GESTURE, + THRESHOLD_GESTURE_DEFAULT); + + i2c_smbus_write_byte_data(client, INTERVAL_TIME, INTERVAL_TIME_DEFAULT); + i2c_smbus_write_byte_data(client, CPU_FREQ, CPU_FREQ_10MHZ); + i2c_smbus_write_byte_data(client, PRM_SWOFF_TIME, + PRM_SWOFF_TIME_DEFAULT); + i2c_smbus_write_byte_data(client, ADC_CTRL, ADC_DIV_DEFAULT); + i2c_smbus_write_byte_data(client, ADC_WAIT, ADC_WAIT_DEFAULT); + + /* + * Panel setup, these values change with the panel. + */ + i2c_smbus_write_byte_data(client, STEP_X, STEP_X_DEFAULT); + i2c_smbus_write_byte_data(client, STEP_Y, STEP_Y_DEFAULT); + i2c_smbus_write_byte_data(client, OFFSET_X, OFFSET_X_DEFAULT); + i2c_smbus_write_byte_data(client, OFFSET_Y, OFFSET_Y_DEFAULT); + i2c_smbus_write_byte_data(client, THRESHOLD_TOUCH, + THRESHOLD_TOUCH_DEFAULT); + i2c_smbus_write_byte_data(client, EVR_XY, EVR_XY_DEFAULT); + i2c_smbus_write_byte_data(client, EVR_X, EVR_X_DEFAULT); + i2c_smbus_write_byte_data(client, EVR_Y, EVR_Y_DEFAULT); + + /* Fixed value settings */ + i2c_smbus_write_byte_data(client, CALIBRATION_ADJUST, + CALIBRATION_ADJUST_DEFAULT); + i2c_smbus_write_byte_data(client, SWCONT, SWCONT_DEFAULT); + i2c_smbus_write_byte_data(client, TEST1, + DUALTOUCH_STABILIZE_ON | DUALTOUCH_REG_ON); + + ret = rohm_ts_load_firmware(client, BU21023_FIRMWARE_NAME); + if (ret) { + dev_err(&client->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. + */ + i2c_smbus_write_byte_data(client, CALIBRATION_REG1, + CALIBRATION_REG1_DEFAULT); + i2c_smbus_write_byte_data(client, CALIBRATION_REG2, + CALIBRATION_REG2_DEFAULT); + i2c_smbus_write_byte_data(client, CALIBRATION_REG3, + CALIBRATION_REG3_DEFAULT); + + i2c_smbus_write_byte_data(client, FORCE_CALIBRATION, + FORCE_CALIBRATION_OFF); + i2c_smbus_write_byte_data(client, FORCE_CALIBRATION, + FORCE_CALIBRATION_ON); + + /* Clear all interrupts */ + i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff); + + /* Enable coordinates update interrupt */ + i2c_smbus_write_byte_data(client, INT_MASK, + CALIBRATION_DONE | SLEEP_OUT | SLEEP_IN | + PROGRAM_LOAD_DONE); + + i2c_smbus_write_byte_data(client, ERR_MASK, + PROGRAM_LOAD_ERR | CPU_TIMEOUT | ADC_TIMEOUT); + + /* controller CPU power on */ + i2c_smbus_write_byte_data(client, SYSTEM, + CPU_POWER_ON | ANALOG_POWER_ON); + + 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; + + ts = kzalloc(sizeof(struct rohm_ts_data), GFP_KERNEL); + if (!ts) + return -ENOMEM; + + INIT_WORK(&ts->work, rohm_ts_work_func); + + ts->client = client; + i2c_set_clientdata(client, ts); + + ret = rohm_ts_device_init(client); + if (ret) { + dev_err(dev, "Failed to device initialization\n"); + goto err_ts_free_exit; + } + + input_dev = input_allocate_device(); + if (!input_dev) { + ret = -ENOMEM; + dev_err(dev, "Failed to allocate input device\n"); + goto err_ts_free_exit; + } + + input_dev->name = BU21023_NAME; + input_dev->id.bustype = BUS_I2C; + input_dev->dev.parent = &client->dev; + + ts->input_dev = input_dev; + + set_bit(EV_SYN, input_dev->evbit); + set_bit(EV_KEY, input_dev->evbit); + set_bit(EV_ABS, 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); + + ret = input_register_device(input_dev); + if (ret) { + dev_err(dev, "Unable to register input device\n"); + goto err_input_free_device_exit; + } + + ts->workqueue = create_singlethread_workqueue("rohm_ts_wq"); + if (!ts->workqueue) { + dev_err(dev, "Cannot create workqueue\n"); + ret = -ENOMEM; + goto err_input_unregister_device_exit; + } + + if (client->irq) { + ret = request_irq(client->irq, rohm_ts_irq_handler, + IRQF_TRIGGER_FALLING, client->name, ts); + + /* If the request IRQ failed, use polling mode */ + if (!ret) + ts->use_irq = 1; + } + + hrtimer_init(&ts->hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); + ts->hrtimer.function = rohm_ts_timer_func; + if (!ts->use_irq) + hrtimer_start(&ts->hrtimer, INACTIVE_POLLING_INTERVAL_KTIME, + HRTIMER_MODE_REL); + + dev_info(dev, "%s mode\n", ts->use_irq ? "interrupt" : "polling"); + + return 0; + +err_input_unregister_device_exit: + input_unregister_device(input_dev); + +err_input_free_device_exit: + input_free_device(input_dev); + +err_ts_free_exit: + kfree(ts); + + return ret; +} + +static int rohm_bu21023_i2c_remove(struct i2c_client *client) +{ + struct rohm_ts_data *ts = i2c_get_clientdata(client); + + if (ts->use_irq) + free_irq(client->irq, ts); + else + hrtimer_cancel(&ts->hrtimer); + + if (ts->workqueue) + destroy_workqueue(ts->workqueue); + + input_unregister_device(ts->input_dev); + + i2c_smbus_write_byte_data(client, SYSTEM, + ANALOG_POWER_ON | CPU_POWER_OFF); + + i2c_smbus_write_byte_data(client, SYSTEM, + ANALOG_POWER_OFF | CPU_POWER_OFF); + + kfree(ts); + + return 0; +} + +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"); diff --git a/drivers/input/touchscreen/rohm_bu21023.h b/drivers/input/touchscreen/rohm_bu21023.h new file mode 100644 index 0000000..2db32848 --- /dev/null +++ b/drivers/input/touchscreen/rohm_bu21023.h @@ -0,0 +1,255 @@ +/* + * 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 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 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 */