lkml.org 
[lkml]   [2010]   [Aug]   [4]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    SubjectRE: [PATCH] i2c: cyttsp i2c touchscreen driver init submit
    Date
    From
    Hi Trilok,

    > -----Original Message-----
    > From: Trilok Soni [mailto:tsoni@codeaurora.org]
    > Sent: Tuesday, July 13, 2010 12:32 AM
    > To: Kevin McNeely
    > Cc: Dmitry Torokhov; David Brown; Fred; Samuel Ortiz; Eric Miao; Mark
    > Brown; Simtec Linux Team; Arnaud Patard; Antonio Ospite; Henrik
    > Rydberg; linux-input@vger.kernel.org; linux-kernel@vger.kernel.org;
    > linux-i2c@vger.kernel.org; khali@linux-fr.org; linux-arm-
    > msm@vger.kernel.org
    > Subject: Re: [PATCH] i2c: cyttsp i2c touchscreen driver init submit
    >
    > Hi Kevin,
    >
    > Thanks for posting this driver.
    >
    > Adding Jean Delvar for i2c bits.
    >
    > On 7/13/2010 2:26 AM, Kevin McNeely wrote:
    > > From: Fred <fwk@ubuntu.linuxcertified.com>
    >
    > E-mail id looks wrong. Do you mean fwk@cypress.com?
    >
    > >
    > > This is a new touchscreen driver for the Cypress Semiconductor
    > > cyttsp family of devices. This driver is for the i2c version
    > > of cyttsp parts.
    >
    > Please explain in commit text which exact version of the chips this
    > driver is supporting.
    > It is hard to make out that from this text.
    > >
    > > Signed-off-by: Kevin McNeely <kev@cypress.com>
    > > ---
    > > drivers/input/touchscreen/Kconfig | 13 +
    > > drivers/input/touchscreen/Makefile | 1 +
    > > drivers/input/touchscreen/cyttsp-i2c.c | 2016
    > ++++++++++++++++++++++++++++++++
    > > include/linux/cyttsp.h | 649 ++++++++++
    >
    > Please move this file to include/linux/input directory.
    >
    >
    > >
    > > diff --git a/drivers/input/touchscreen/Kconfig
    > b/drivers/input/touchscreen/Kconfig
    > > index 3b9d5e2..a7a69a0 100644
    > > --- a/drivers/input/touchscreen/Kconfig
    > > +++ b/drivers/input/touchscreen/Kconfig
    > > @@ -603,4 +603,17 @@ config TOUCHSCREEN_TPS6507X
    > > To compile this driver as a module, choose M here: the
    > > module will be called tps6507x_ts.
    > >
    > > +config TOUCHSCREEN_CYTTSP_I2C
    > > + default n
    >
    > Do we need to provide this if it is no by default?
    >

    The new refactored code has new core file added to build dependencies.

    > > + tristate "Cypress TTSP i2c touchscreen"
    > > + depends on I2C
    > > + help
    > > + Say Y here if you have a Cypress TTSP touchscreen
    > > + connected to your system's i2c bus.
    >
    > What is TTSP?
    >

    TTSP=TrueTouch Standard Product. Headers will be updated to show this.

    > > +
    > > + If unsure, say N.
    > > +
    > > + To compile this driver as a module, choose M here: the
    > > + module will be called cyttsp_i2c.
    > > +
    > > endif
    >
    >
    > > diff --git a/drivers/input/touchscreen/cyttsp-i2c.c
    > b/drivers/input/touchscreen/cyttsp-i2c.c
    > > new file mode 100644
    > > index 0000000..8397aa1
    > > --- /dev/null
    > > +++ b/drivers/input/touchscreen/cyttsp-i2c.c
    > > @@ -0,0 +1,2016 @@
    > > +/* Source for:
    > > + * Cypress TrueTouch(TM) Standard Product I2C touchscreen driver.
    > > + * drivers/input/touchscreen/cyttsp-i2c.c
    >
    > No file paths please. Already commented on it by Christoph.
    >

    Paths and filenames will be removed from headers.

    > > + *
    > > + * Copyright (C) 2009, 2010 Cypress Semiconductor, Inc.
    > > + *
    > > + * This program is free software; you can redistribute it and/or
    > > + * modify it under the terms of the GNU General Public License
    > > + * version 2, and only version 2, as published by the
    > > + * Free Software Foundation.
    > > + *
    > > + * 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.
    > > + *
    > > + * You should have received a copy of the GNU General Public
    License
    > along
    > > + * with this program; if not, write to the Free Software
    Foundation,
    > Inc.,
    > > + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
    > > + *
    > > + * Cypress reserves the right to make changes without further
    notice
    > > + * to the materials described herein. Cypress does not assume any
    > > + * liability arising out of the application described herein.
    > > + *
    > > + * Contact Cypress Semiconductor at www.cypress.com
    >
    > I would like Dmitry to comment on it. Dmitry?
    >

    The paragraph will be removed from headers.

    > > + *
    > > + */
    > > +
    > > +#include <linux/delay.h>
    > > +#include <linux/init.h>
    > > +#include <linux/module.h>
    > > +#include <linux/i2c.h>
    > > +#include <linux/input.h>
    > > +#include <linux/slab.h>
    > > +#include <linux/gpio.h>
    > > +#include <linux/irq.h>
    > > +#include <linux/interrupt.h>
    > > +#include <linux/timer.h>
    > > +#include <linux/workqueue.h>
    > > +#include <linux/byteorder/generic.h>
    > > +#include <linux/bitops.h>
    > > +#ifdef CONFIG_HAS_EARLYSUSPEND
    > > +#include <linux/earlysuspend.h>
    > > +#endif /* CONFIG_HAS_EARLYSUSPEND */
    >
    > We don't have early suspend support yet into the mainline kernel.
    > Please remove this code from the driver.
    >

    Early suspend will be removed from the driver.

    > > +
    > > +#define CY_DECLARE_GLOBALS
    >
    > Could you please explain what it does?
    >

    This has been removed. No globals will be used.

    > > +
    > > +#include <linux/cyttsp.h>
    > > +
    > > +uint32_t cyttsp_tsdebug1 = 0xff;
    > > +module_param_named(tsdebug1, cyttsp_tsdebug1, uint, 0664);
    > > +
    > > +/* CY TTSP I2C Driver private data */
    > > +struct cyttsp {
    > > + struct i2c_client *client;
    > > + struct input_dev *input;
    > > + struct work_struct work;
    > > + struct timer_list timer;
    > > + struct mutex mutex;
    > > + char phys[32];
    > > + struct cyttsp_platform_data *platform_data;
    > > + u8 num_prv_st_tch;
    > > + u16 act_trk[CY_NUM_TRK_ID];
    > > + u16 prv_st_tch[CY_NUM_ST_TCH_ID];
    > > + u16 prv_mt_tch[CY_NUM_MT_TCH_ID];
    > > + u16 prv_mt_pos[CY_NUM_TRK_ID][2];
    > > + atomic_t irq_enabled;
    > > +#ifdef CONFIG_HAS_EARLYSUSPEND
    > > + struct early_suspend early_suspend;
    > > +#endif /* CONFIG_HAS_EARLYSUSPEND */
    > > +};
    > > +static u8 irq_cnt; /* comparison counter with register
    valuw
    > */
    >
    > s/valuw/value
    >
    > > +static u32 irq_cnt_total; /* total interrupts */
    > > +static u32 irq_err_cnt; /* count number of touch
    interrupts
    > with err */
    > > +#define CY_IRQ_CNT_MASK 0x000000FF /* mapped for sizeof
    count in
    > reg */
    > > +#define CY_IRQ_CNT_REG 0x00 /* tt_undef[0]=reg 0x1B
    -
    > Gen3 only */
    > > +
    > > +#ifdef CONFIG_HAS_EARLYSUSPEND
    > > +static void cyttsp_early_suspend(struct early_suspend *handler);
    > > +static void cyttsp_late_resume(struct early_suspend *handler);
    > > +#endif /* CONFIG_HAS_EARLYSUSPEND */
    > > +
    > > +static struct workqueue_struct *cyttsp_ts_wq;
    >
    > Why there are so many global variables lying around?
    >

    Globals have been removed.

    > > +
    > > +
    > > +/*
    >
    ***********************************************************************
    > *****
    > > + * Prototypes for static functions
    > > + *
    >
    ***********************************************************************
    > *** */
    > > +static void cyttsp_xy_worker(struct work_struct *work);
    > > +static irqreturn_t cyttsp_irq(int irq, void *handle);
    > > +static int cyttsp_inlist(u16 prev_track[],
    > > + u8 cur_trk_id, u8 *prev_loc, u8 num_touches);
    > > +static int cyttsp_next_avail_inlist(u16 cur_trk[],
    > > + u8 *new_loc, u8 num_touches);
    > > +static int cyttsp_putbl(struct cyttsp *ts, int show,
    > > + int show_status, int show_version, int
    show_cid);
    > > +static int __devinit cyttsp_probe(struct i2c_client *client,
    > > + const struct i2c_device_id *id);
    > > +static int __devexit cyttsp_remove(struct i2c_client *client);
    > > +static int cyttsp_resume(struct i2c_client *client);
    > > +static int cyttsp_suspend(struct i2c_client *client, pm_message_t
    > message);
    >
    > Please re-order the functions in the driver such a way so that you
    > don't need have these prototypes here.
    >

    Functions have been reordered to eliminate prototypes.

    > > +
    > > +/* Static variables */
    > > +static struct cyttsp_gen3_xydata_t g_xy_data;
    > > +static struct cyttsp_bootloader_data_t g_bl_data;
    > > +static struct cyttsp_sysinfo_data_t g_sysinfo_data;
    >
    > again globals?
    >
    > > +static const struct i2c_device_id cyttsp_id[] = {
    > > + { CY_I2C_NAME, 0 }, { }
    >
    > Why dont you put ,{} at the next line.
    >
    > > +};
    >
    > You should not put driver name above, but it should be something like
    > real chip name.
    >
    > Say cy8ctXXX.

    The parts are called TTSP parts.
    The driver supports all TTSP parts.
    Sample part numbers will be added to the headers.

    >
    > > +static u8 bl_cmd[] = {
    > > + CY_BL_FILE0, CY_BL_CMD, CY_BL_EXIT,
    > > + CY_BL_KEY0, CY_BL_KEY1, CY_BL_KEY2,
    > > + CY_BL_KEY3, CY_BL_KEY4, CY_BL_KEY5,
    > > + CY_BL_KEY6, CY_BL_KEY7};
    >
    > and what these keys does?
    >

    The key must be sent to the device on bootup to move the device to
    operational mode.

    > > +
    > > +MODULE_DEVICE_TABLE(i2c, cyttsp_id);
    >
    > Why it is not with cyttsp_id above?
    >

    This has been moved in the new code.

    > > +
    > > +static struct i2c_driver cyttsp_driver = {
    > > + .driver = {
    > > + .name = CY_I2C_NAME,
    > > + .owner = THIS_MODULE,
    > > + },
    > > + .probe = cyttsp_probe,
    > > + .remove = __devexit_p(cyttsp_remove),
    > > + .suspend = cyttsp_suspend,
    > > + .resume = cyttsp_resume,
    > > + .id_table = cyttsp_id,
    > > +};
    > > +
    > > +MODULE_LICENSE("GPL");
    > > +MODULE_DESCRIPTION("Cypress TrueTouch(R) Standard touchscreen
    > driver");
    > > +MODULE_AUTHOR("Cypress");
    >
    > MODULE_ALIAS?
    >

    This has been added to new code.

    > > +
    > > +static ssize_t cyttsp_irq_status(struct device *dev,
    > > + struct device_attribute *attr, char
    *buf)
    > > +{
    > > + struct i2c_client *client = container_of(dev, struct i2c_client,
    > dev);
    > > + struct cyttsp *ts = i2c_get_clientdata(client);
    > > + return sprintf(buf, "%u\n", atomic_read(&ts->irq_enabled));
    > > +}
    > > +
    > > +static ssize_t cyttsp_irq_enable(struct device *dev,
    > > + struct device_attribute *attr,
    > > + const char *buf, size_t size)
    > > +{
    > > + struct i2c_client *client = container_of(dev, struct i2c_client,
    > dev);
    > > + struct cyttsp *ts = i2c_get_clientdata(client);
    > > + int err = 0;
    > > + unsigned long value;
    > > +
    > > + if (size > 2)
    > > + return -EINVAL;
    > > +
    > > + err = strict_strtoul(buf, 10, &value);
    > > + if (err != 0)
    > > + return err;
    > > +
    > > + switch (value) {
    > > + case 0:
    > > + if (atomic_cmpxchg(&ts->irq_enabled, 1, 0)) {
    > > + pr_info("touch irq disabled!\n");
    > > + disable_irq_nosync(ts->client->irq);
    > > + }
    > > + err = size;
    > > + break;
    > > + case 1:
    > > + if (!atomic_cmpxchg(&ts->irq_enabled, 0, 1)) {
    > > + pr_info("touch irq enabled!\n");
    > > + enable_irq(ts->client->irq);
    > > + }
    > > + err = size;
    > > + break;
    > > + default:
    > > + pr_info("cyttsp_irq_enable failed -> irq_enabled =
    %d\n",
    > > + atomic_read(&ts->irq_enabled));
    > > + err = -EINVAL;
    > > + break;
    > > + }
    > > +
    > > + return err;
    > > +}
    > > +
    > > +static DEVICE_ATTR(irq_enable, 0777, cyttsp_irq_status,
    > cyttsp_irq_enable);
    >
    >
    > Please explain why you are providing this sysfs entries?
    >

    The sysfs entried were to support dynamic debug enables.
    These have been removed.
    The new code has replaced the custom debug.

    > > +
    > > +/* The cyttsp_xy_worker function reads the XY coordinates and sends
    > them to
    > > + * the input layer. It is scheduled from the interrupt (or timer).
    > > + */
    > > +void cyttsp_xy_worker(struct work_struct *work)
    > > +{
    > > + struct cyttsp *ts = container_of(work, struct cyttsp, work);
    > > + u8 id, tilt, rev_x, rev_y;
    > > + u8 i, loc;
    > > + u8 prv_tch; /* number of previous touches */
    > > + u8 cur_tch; /* number of current touches */
    > > + u16 tmp_trk[CY_NUM_MT_TCH_ID];
    > > + u16 snd_trk[CY_NUM_MT_TCH_ID];
    > > + u16 cur_trk[CY_NUM_TRK_ID];
    > > + u16 cur_st_tch[CY_NUM_ST_TCH_ID];
    > > + u16 cur_mt_tch[CY_NUM_MT_TCH_ID];
    > > + /* if NOT CY_USE_TRACKING_ID then
    > > + * only uses CY_NUM_MT_TCH_ID positions */
    > > + u16 cur_mt_pos[CY_NUM_TRK_ID][2];
    > > + /* if NOT CY_USE_TRACKING_ID then
    > > + * only uses CY_NUM_MT_TCH_ID positions */
    > > + u8 cur_mt_z[CY_NUM_TRK_ID];
    > > + u8 curr_tool_width;
    > > + u16 st_x1, st_y1;
    > > + u8 st_z1;
    > > + u16 st_x2, st_y2;
    > > + u8 st_z2;
    > > + s32 retval;
    > > +
    > > + cyttsp_xdebug("TTSP worker start 1:\n");
    > > +
    > > + /* get event data from CYTTSP device */
    > > + i = CY_NUM_RETRY;
    > > + do {
    > > + retval = i2c_smbus_read_i2c_block_data(ts->client,
    > > + CY_REG_BASE,
    > > + sizeof(struct cyttsp_gen3_xydata_t), (u8
    > *)&g_xy_data);
    > > + } while ((retval < CY_OK) && --i);
    > > +
    > > + if (retval < CY_OK) {
    > > + /* return immediately on
    > > + * failure to read device on the i2c bus */
    > > + goto exit_xy_worker;
    > > + }
    > > +
    > > + cyttsp_xdebug("TTSP worker start 2:\n");
    > > +
    > > + /* compare own irq counter with the device irq counter */
    > > + if (ts->client->irq) {
    > > + u8 host_reg;
    > > + u8 cur_cnt;
    > > + if (ts->platform_data->use_hndshk) {
    > > +
    > > + host_reg = g_xy_data.hst_mode & CY_HNDSHK_BIT ?
    > > + g_xy_data.hst_mode & ~CY_HNDSHK_BIT :
    > > + g_xy_data.hst_mode | CY_HNDSHK_BIT;
    > > + retval =
    i2c_smbus_write_i2c_block_data(ts->client,
    > > + CY_REG_BASE, sizeof(host_reg),
    &host_reg);
    > > + }
    > > + cur_cnt = g_xy_data.tt_undef[CY_IRQ_CNT_REG];
    > > + irq_cnt_total++;
    > > + irq_cnt++;
    > > + if (irq_cnt != cur_cnt) {
    > > + irq_err_cnt++;
    > > + cyttsp_debug("i_c_ER: dv=%d fw=%d hm=%02X t=%lu
    > te=%lu\n", \
    > > + irq_cnt, \
    > > + cur_cnt, g_xy_data.hst_mode, \
    > > + (unsigned long)irq_cnt_total, \
    > > + (unsigned long)irq_err_cnt);
    > > + } else {
    > > + cyttsp_debug("i_c_ok: dv=%d fw=%d hm=%02X t=%lu
    > te=%lu\n", \
    > > + irq_cnt, \
    > > + cur_cnt, g_xy_data.hst_mode, \
    > > + (unsigned long)irq_cnt_total, \
    > > + (unsigned long)irq_err_cnt);
    > > + }
    > > + irq_cnt = cur_cnt;
    > > + }
    > > +
    > > + /* Get the current num touches and return if there are no
    touches
    > */
    > > + if ((GET_BOOTLOADERMODE(g_xy_data.tt_mode) == 1) ||
    > > + (GET_HSTMODE(g_xy_data.hst_mode) != CY_OK)) {
    > > + u8 host_reg, tries;
    > > + /* the TTSP device has suffered spurious reset or mode
    > switch */
    > > + cyttsp_debug( \
    > > + "Spurious err opmode (tt_mode=%02X
    hst_mode=%02X)\n",
    > \
    > > + g_xy_data.tt_mode, g_xy_data.hst_mode);
    > > + cyttsp_debug("Reset TTSP Device; Terminating active
    > tracks\n");
    > > + /* terminate all active tracks */
    > > + cur_tch = CY_NTCH;
    > > + /* reset TTSP part and take it back out of Bootloader
    mode
    > */
    > > + host_reg = CY_SOFT_RESET_MODE;
    > > + retval = i2c_smbus_write_i2c_block_data(ts->client,
    > > + CY_REG_BASE,
    > > + sizeof(host_reg), &host_reg);
    > > + tries = 0;
    > > + do {
    > > + mdelay(1000);
    > > +
    > > + /* set arg2 to non-0 to activate */
    > > + retval = cyttsp_putbl(ts, 1, false, false,
    false);
    > > + } while (!(retval < CY_OK) &&
    > > + !GET_BOOTLOADERMODE(g_bl_data.bl_status) &&
    > > + !(g_bl_data.bl_file ==
    > > + CY_OP_MODE + CY_LOW_PWR_MODE) &&
    > > + tries++ < 10);
    > > + /* switch back to operational mode */
    > > + if (GET_BOOTLOADERMODE(g_bl_data.bl_status)) {
    > > + retval =
    i2c_smbus_write_i2c_block_data(ts->client,
    > > + CY_REG_BASE,
    > > + sizeof(bl_cmd), bl_cmd);
    > > + tries = 0;
    > > + do {
    > > + mdelay(1000);
    > > + cyttsp_putbl(ts, 1, false, false,
    false);
    > > + } while (GET_BOOTLOADERMODE(g_bl_data.bl_status)
    &&
    > > + tries++ < 10);
    > > + }
    > > + if (!(retval < CY_OK)) {
    > > + host_reg = CY_OP_MODE
    > > + /* + CY_LOW_PWR_MODE */;
    > > + retval =
    i2c_smbus_write_i2c_block_data(ts->client,
    > > + CY_REG_BASE,
    > > + sizeof(host_reg), &host_reg);
    > > + /* wait for TTSP Device to complete switch to Op
    mode
    > */
    > > + mdelay(1000);
    > > + }
    > > + goto exit_xy_worker;
    > > + } else {
    > > + cur_tch = GET_NUM_TOUCHES(g_xy_data.tt_stat);
    > > + if (IS_LARGE_AREA(g_xy_data.tt_stat)) {
    > > + /* terminate all active tracks */
    > > + cur_tch = CY_NTCH;
    > > + cyttsp_debug("Large obj detect (tt_stat=0x%02X).
    > Terminate act trks\n", \
    > > + g_xy_data.tt_stat);
    > > + } else if (cur_tch > CY_NUM_MT_TCH_ID) {
    > > + /* if the number of fingers on the touch surface
    > > + * is more than the maximum then
    > > + * there will be no new track information
    > > + * even for the original touches.
    > > + * Therefore, terminate all active tracks.
    > > + */
    > > + cur_tch = CY_NTCH;
    > > + cyttsp_debug("Num touch err (tt_stat=0x%02X).
    > Terminate act trks\n", \
    > > + g_xy_data.tt_stat);
    > > + }
    > > + }
    > > +
    > > + /* set tool size */
    > > + curr_tool_width = CY_SMALL_TOOL_WIDTH;
    > > +
    > > + /* translate Gen2 interface data into comparable Gen3 data */
    > > + if (ts->platform_data->gen == CY_GEN2) {
    > > + struct cyttsp_gen2_xydata_t *pxy_gen2_data;
    > > + pxy_gen2_data = (struct cyttsp_gen2_xydata_t
    > *)(&g_xy_data);
    > > +
    > > + /* use test data? */
    > > + cyttsp_testdat(&g_xy_data, &tt_gen2_testray, \
    > > + sizeof(struct cyttsp_gen3_xydata_t));
    > > +
    > > + if (pxy_gen2_data->evnt_idx == CY_GEN2_NOTOUCH) {
    > > + cur_tch = 0;
    > > + } else if (cur_tch == CY_GEN2_GHOST) {
    > > + cur_tch = 0;
    > > + } else if (cur_tch == CY_GEN2_2TOUCH) {
    > > + /* stuff artificial track ID1 and ID2 */
    > > + g_xy_data.touch12_id = 0x12;
    > > + g_xy_data.z1 = CY_MAXZ;
    > > + g_xy_data.z2 = CY_MAXZ;
    > > + cur_tch--; /* 2 touches */
    > > + } else if (cur_tch == CY_GEN2_1TOUCH) {
    > > + /* stuff artificial track ID1 and ID2 */
    > > + g_xy_data.touch12_id = 0x12;
    > > + g_xy_data.z1 = CY_MAXZ;
    > > + g_xy_data.z2 = CY_NTCH;
    > > + if (pxy_gen2_data->evnt_idx == CY_GEN2_TOUCH2) {
    > > + /* push touch 2 data into touch1
    > > + * (first finger up; second finger down)
    */
    > > + /* stuff artificial track ID1 for touch2
    info
    > */
    > > + g_xy_data.touch12_id = 0x20;
    > > + /* stuff touch 1 with touch 2 coordinate
    data
    > */
    > > + g_xy_data.x1 = g_xy_data.x2;
    > > + g_xy_data.y1 = g_xy_data.y2;
    > > + }
    > > + } else {
    > > + cur_tch = 0;
    > > + }
    > > + } else {
    > > + /* use test data? */
    > > + cyttsp_testdat(&g_xy_data, &tt_gen3_testray, \
    > > + sizeof(struct cyttsp_gen3_xydata_t));
    > > + }
    > > +
    > > +
    > > +
    > > + /* clear current active track ID array and count previous
    touches
    > */
    > > + for (id = 0, prv_tch = CY_NTCH;
    > > + id < CY_NUM_TRK_ID; id++) {
    > > + cur_trk[id] = CY_NTCH;
    > > + prv_tch += ts->act_trk[id];
    > > + }
    > > +
    > > + /* send no events if no previous touches and no new touches */
    > > + if ((prv_tch == CY_NTCH) &&
    > > + ((cur_tch == CY_NTCH) ||
    > > + (cur_tch > CY_NUM_MT_TCH_ID))) {
    > > + goto exit_xy_worker;
    > > + }
    > > +
    > > + cyttsp_debug("prev=%d curr=%d\n", prv_tch, cur_tch);
    > > +
    > > + for (id = 0; id < CY_NUM_ST_TCH_ID; id++) {
    > > + /* clear current single touches array */
    > > + cur_st_tch[id] = CY_IGNR_TCH;
    > > + }
    > > +
    > > + /* clear single touch positions */
    > > + st_x1 = CY_NTCH;
    > > + st_y1 = CY_NTCH;
    > > + st_z1 = CY_NTCH;
    > > + st_x2 = CY_NTCH;
    > > + st_y2 = CY_NTCH;
    > > + st_z2 = CY_NTCH;
    > > +
    > > + for (id = 0; id < CY_NUM_MT_TCH_ID; id++) {
    > > + /* clear current multi-touches array and
    > > + * multi-touch positions/z */
    > > + cur_mt_tch[id] = CY_IGNR_TCH;
    > > + }
    > > +
    > > + if (ts->platform_data->use_trk_id) {
    > > + for (id = 0; id < CY_NUM_MT_TCH_ID; id++) {
    > > + cur_mt_pos[id][CY_XPOS] = 0;
    > > + cur_mt_pos[id][CY_YPOS] = 0;
    > > + cur_mt_z[id] = 0;
    > > + }
    > > + } else {
    > > + for (id = 0; id < CY_NUM_TRK_ID; id++) {
    > > + cur_mt_pos[id][CY_XPOS] = 0;
    > > + cur_mt_pos[id][CY_YPOS] = 0;
    > > + cur_mt_z[id] = 0;
    > > + }
    > > + }
    > > +
    > > + /* Determine if display is tilted */
    > > + if (FLIP_DATA(ts->platform_data->flags))
    > > + tilt = true;
    > > + else
    > > + tilt = false;
    > > +
    > > + /* Check for switch in origin */
    > > + if (REVERSE_X(ts->platform_data->flags))
    > > + rev_x = true;
    > > + else
    > > + rev_x = false;
    > > +
    > > + if (REVERSE_Y(ts->platform_data->flags))
    > > + rev_y = true;
    > > + else
    > > + rev_y = false;
    > > +
    > > + if (cur_tch) {
    > > + struct cyttsp_gen2_xydata_t *pxy_gen2_data;
    > > + struct cyttsp_gen3_xydata_t *pxy_gen3_data;
    > > + switch (ts->platform_data->gen) {
    > > + case CY_GEN2: {
    > > + pxy_gen2_data =
    > > + (struct cyttsp_gen2_xydata_t
    *)(&g_xy_data);
    > > + cyttsp_xdebug("TTSP Gen2 report:\n");
    > > + cyttsp_xdebug("%02X %02X %02X\n", \
    > > + pxy_gen2_data->hst_mode, \
    > > + pxy_gen2_data->tt_mode, \
    > > + pxy_gen2_data->tt_stat);
    > > + cyttsp_xdebug("%04X %04X %02X %02X\n", \
    > > + pxy_gen2_data->x1, \
    > > + pxy_gen2_data->y1, \
    > > + pxy_gen2_data->z1, \
    > > + pxy_gen2_data->evnt_idx);
    > > + cyttsp_xdebug("%04X %04X %02X\n", \
    > > + pxy_gen2_data->x2, \
    > > + pxy_gen2_data->y2, \
    > > + pxy_gen2_data->tt_undef1);
    > > + cyttsp_xdebug("%02X %02X %02X\n", \
    > > + pxy_gen2_data->gest_cnt, \
    > > + pxy_gen2_data->gest_id, \
    > > + pxy_gen2_data->gest_set);
    > > + break;
    > > + }
    > > + case CY_GEN3:
    > > + default: {
    > > + pxy_gen3_data =
    > > + (struct cyttsp_gen3_xydata_t
    *)(&g_xy_data);
    > > + cyttsp_xdebug("TTSP Gen3 report:\n");
    > > + cyttsp_xdebug("%02X %02X %02X\n", \
    > > + pxy_gen3_data->hst_mode,
    > > + pxy_gen3_data->tt_mode,
    > > + pxy_gen3_data->tt_stat);
    > > + cyttsp_xdebug("%04X %04X %02X %02X", \
    > > + pxy_gen3_data->x1,
    > > + pxy_gen3_data->y1,
    > > + pxy_gen3_data->z1, \
    > > + pxy_gen3_data->touch12_id);
    > > + cyttsp_xdebug("%04X %04X %02X\n", \
    > > + pxy_gen3_data->x2, \
    > > + pxy_gen3_data->y2, \
    > > + pxy_gen3_data->z2);
    > > + cyttsp_xdebug("%02X %02X %02X\n", \
    > > + pxy_gen3_data->gest_cnt, \
    > > + pxy_gen3_data->gest_id, \
    > > + pxy_gen3_data->gest_set);
    > > + cyttsp_xdebug("%04X %04X %02X %02X\n", \
    > > + pxy_gen3_data->x3, \
    > > + pxy_gen3_data->y3, \
    > > + pxy_gen3_data->z3, \
    > > + pxy_gen3_data->touch34_id);
    > > + cyttsp_xdebug("%04X %04X %02X\n", \
    > > + pxy_gen3_data->x4, \
    > > + pxy_gen3_data->y4, \
    > > + pxy_gen3_data->z4);
    > > + break;
    > > + }
    > > + }
    > > + }
    > > +
    > > + /* process the touches */
    > > + switch (cur_tch) {
    > > + case 4: {
    > > + g_xy_data.x4 = be16_to_cpu(g_xy_data.x4);
    > > + g_xy_data.y4 = be16_to_cpu(g_xy_data.y4);
    > > + if (tilt)
    > > + FLIP_XY(g_xy_data.x4, g_xy_data.y4);
    > > +
    > > + if (rev_x) {
    > > + g_xy_data.x4 =
    > > + INVERT_X(g_xy_data.x4,
    ts->platform_data-
    > >maxx);
    > > + }
    > > + if (rev_y) {
    > > + g_xy_data.y4 =
    > > + INVERT_X(g_xy_data.y4,
    ts->platform_data-
    > >maxy);
    > > + }
    > > + id = GET_TOUCH4_ID(g_xy_data.touch34_id);
    > > + if (ts->platform_data->use_trk_id) {
    > > + cur_mt_pos[CY_MT_TCH4_IDX][CY_XPOS] =
    > > + g_xy_data.x4;
    > > + cur_mt_pos[CY_MT_TCH4_IDX][CY_YPOS] =
    > > + g_xy_data.y4;
    > > + cur_mt_z[CY_MT_TCH4_IDX] = g_xy_data.z4;
    > > + } else {
    > > + cur_mt_pos[id][CY_XPOS] = g_xy_data.x4;
    > > + cur_mt_pos[id][CY_YPOS] = g_xy_data.y4;
    > > + cur_mt_z[id] = g_xy_data.z4;
    > > + }
    > > + cur_mt_tch[CY_MT_TCH4_IDX] = id;
    > > + cur_trk[id] = CY_TCH;
    > > + if (ts->prv_st_tch[CY_ST_FNGR1_IDX] <
    > > + CY_NUM_TRK_ID) {
    > > + if (ts->prv_st_tch[CY_ST_FNGR1_IDX] == id) {
    > > + st_x1 = g_xy_data.x4;
    > > + st_y1 = g_xy_data.y4;
    > > + st_z1 = g_xy_data.z4;
    > > + cur_st_tch[CY_ST_FNGR1_IDX] = id;
    > > + } else if (ts->prv_st_tch[CY_ST_FNGR2_IDX] ==
    id) {
    > > + st_x2 = g_xy_data.x4;
    > > + st_y2 = g_xy_data.y4;
    > > + st_z2 = g_xy_data.z4;
    > > + cur_st_tch[CY_ST_FNGR2_IDX] = id;
    > > + }
    > > + }
    > > + cyttsp_xdebug("4th XYZ:% 3d,% 3d,% 3d ID:% 2d\n\n", \
    > > + g_xy_data.x4, g_xy_data.y4, g_xy_data.z4, \
    > > + (g_xy_data.touch34_id & 0x0F));
    > > + /* do not break */
    > > + }
    > > + case 3: {
    > > + g_xy_data.x3 = be16_to_cpu(g_xy_data.x3);
    > > + g_xy_data.y3 = be16_to_cpu(g_xy_data.y3);
    > > + if (tilt)
    > > + FLIP_XY(g_xy_data.x3, g_xy_data.y3);
    > > +
    > > + if (rev_x) {
    > > + g_xy_data.x3 =
    > > + INVERT_X(g_xy_data.x3,
    ts->platform_data-
    > >maxx);
    > > + }
    > > + if (rev_y) {
    > > + g_xy_data.y3 =
    > > + INVERT_X(g_xy_data.y3,
    ts->platform_data-
    > >maxy);
    > > + }
    > > + id = GET_TOUCH3_ID(g_xy_data.touch34_id);
    > > + if (ts->platform_data->use_trk_id) {
    > > + cur_mt_pos[CY_MT_TCH3_IDX][CY_XPOS] =
    > > + g_xy_data.x3;
    > > + cur_mt_pos[CY_MT_TCH3_IDX][CY_YPOS] =
    > > + g_xy_data.y3;
    > > + cur_mt_z[CY_MT_TCH3_IDX] = g_xy_data.z3;
    > > + } else {
    > > + cur_mt_pos[id][CY_XPOS] = g_xy_data.x3;
    > > + cur_mt_pos[id][CY_YPOS] = g_xy_data.y3;
    > > + cur_mt_z[id] = g_xy_data.z3;
    > > + }
    > > + cur_mt_tch[CY_MT_TCH3_IDX] = id;
    > > + cur_trk[id] = CY_TCH;
    > > + if (ts->prv_st_tch[CY_ST_FNGR1_IDX] <
    > > + CY_NUM_TRK_ID) {
    > > + if (ts->prv_st_tch[CY_ST_FNGR1_IDX] == id) {
    > > + st_x1 = g_xy_data.x3;
    > > + st_y1 = g_xy_data.y3;
    > > + st_z1 = g_xy_data.z3;
    > > + cur_st_tch[CY_ST_FNGR1_IDX] = id;
    > > + } else if (ts->prv_st_tch[CY_ST_FNGR2_IDX] ==
    id) {
    > > + st_x2 = g_xy_data.x3;
    > > + st_y2 = g_xy_data.y3;
    > > + st_z2 = g_xy_data.z3;
    > > + cur_st_tch[CY_ST_FNGR2_IDX] = id;
    > > + }
    > > + }
    > > + cyttsp_xdebug("3rd XYZ:% 3d,% 3d,% 3d ID:% 2d\n", \
    > > + g_xy_data.x3, g_xy_data.y3, g_xy_data.z3, \
    > > + ((g_xy_data.touch34_id >> 4) & 0x0F));
    > > + /* do not break */
    > > + }
    > > + case 2: {
    > > + g_xy_data.x2 = be16_to_cpu(g_xy_data.x2);
    > > + g_xy_data.y2 = be16_to_cpu(g_xy_data.y2);
    > > + if (tilt)
    > > + FLIP_XY(g_xy_data.x2, g_xy_data.y2);
    > > +
    > > + if (rev_x) {
    > > + g_xy_data.x2 =
    > > + INVERT_X(g_xy_data.x2,
    ts->platform_data-
    > >maxx);
    > > + }
    > > + if (rev_y) {
    > > + g_xy_data.y2 =
    > > + INVERT_X(g_xy_data.y2,
    ts->platform_data-
    > >maxy);
    > > + }
    > > + id = GET_TOUCH2_ID(g_xy_data.touch12_id);
    > > + if (ts->platform_data->use_trk_id) {
    > > + cur_mt_pos[CY_MT_TCH2_IDX][CY_XPOS] =
    > > + g_xy_data.x2;
    > > + cur_mt_pos[CY_MT_TCH2_IDX][CY_YPOS] =
    > > + g_xy_data.y2;
    > > + cur_mt_z[CY_MT_TCH2_IDX] = g_xy_data.z2;
    > > + } else {
    > > + cur_mt_pos[id][CY_XPOS] = g_xy_data.x2;
    > > + cur_mt_pos[id][CY_YPOS] = g_xy_data.y2;
    > > + cur_mt_z[id] = g_xy_data.z2;
    > > + }
    > > + cur_mt_tch[CY_MT_TCH2_IDX] = id;
    > > + cur_trk[id] = CY_TCH;
    > > + if (ts->prv_st_tch[CY_ST_FNGR1_IDX] <
    > > + CY_NUM_TRK_ID) {
    > > + if (ts->prv_st_tch[CY_ST_FNGR1_IDX] == id) {
    > > + st_x1 = g_xy_data.x2;
    > > + st_y1 = g_xy_data.y2;
    > > + st_z1 = g_xy_data.z2;
    > > + cur_st_tch[CY_ST_FNGR1_IDX] = id;
    > > + } else if (ts->prv_st_tch[CY_ST_FNGR2_IDX] ==
    id) {
    > > + st_x2 = g_xy_data.x2;
    > > + st_y2 = g_xy_data.y2;
    > > + st_z2 = g_xy_data.z2;
    > > + cur_st_tch[CY_ST_FNGR2_IDX] = id;
    > > + }
    > > + }
    > > + cyttsp_xdebug("2nd XYZ:% 3d,% 3d,% 3d ID:% 2d\n", \
    > > + g_xy_data.x2, g_xy_data.y2, g_xy_data.z2, \
    > > + (g_xy_data.touch12_id & 0x0F));
    > > + /* do not break */
    > > + }
    > > + case 1: {
    > > + g_xy_data.x1 = be16_to_cpu(g_xy_data.x1);
    > > + g_xy_data.y1 = be16_to_cpu(g_xy_data.y1);
    > > + if (tilt)
    > > + FLIP_XY(g_xy_data.x1, g_xy_data.y1);
    > > +
    > > + if (rev_x) {
    > > + g_xy_data.x1 =
    > > + INVERT_X(g_xy_data.x1,
    ts->platform_data-
    > >maxx);
    > > + }
    > > + if (rev_y) {
    > > + g_xy_data.y1 =
    > > + INVERT_X(g_xy_data.y1,
    ts->platform_data-
    > >maxy);
    > > + }
    > > + id = GET_TOUCH1_ID(g_xy_data.touch12_id);
    > > + if (ts->platform_data->use_trk_id) {
    > > + cur_mt_pos[CY_MT_TCH1_IDX][CY_XPOS] =
    > > + g_xy_data.x1;
    > > + cur_mt_pos[CY_MT_TCH1_IDX][CY_YPOS] =
    > > + g_xy_data.y1;
    > > + cur_mt_z[CY_MT_TCH1_IDX] = g_xy_data.z1;
    > > + } else {
    > > + cur_mt_pos[id][CY_XPOS] = g_xy_data.x1;
    > > + cur_mt_pos[id][CY_YPOS] = g_xy_data.y1;
    > > + cur_mt_z[id] = g_xy_data.z1;
    > > + }
    > > + cur_mt_tch[CY_MT_TCH1_IDX] = id;
    > > + cur_trk[id] = CY_TCH;
    > > + if (ts->prv_st_tch[CY_ST_FNGR1_IDX] <
    > > + CY_NUM_TRK_ID) {
    > > + if (ts->prv_st_tch[CY_ST_FNGR1_IDX] == id) {
    > > + st_x1 = g_xy_data.x1;
    > > + st_y1 = g_xy_data.y1;
    > > + st_z1 = g_xy_data.z1;
    > > + cur_st_tch[CY_ST_FNGR1_IDX] = id;
    > > + } else if (ts->prv_st_tch[CY_ST_FNGR2_IDX] ==
    id) {
    > > + st_x2 = g_xy_data.x1;
    > > + st_y2 = g_xy_data.y1;
    > > + st_z2 = g_xy_data.z1;
    > > + cur_st_tch[CY_ST_FNGR2_IDX] = id;
    > > + }
    > > + }
    > > + cyttsp_xdebug("1st XYZ:% 3d,% 3d,% 3d ID:% 2d\n", \
    > > + g_xy_data.x1, g_xy_data.y1, g_xy_data.z1, \
    > > + ((g_xy_data.touch12_id >> 4) & 0x0F));
    > > + break;
    > > + }
    > > + case 0:
    > > + default:{
    > > + break;
    > > + }
    > > + }
    > > +
    > > + /* handle Single Touch signals */
    > > + if (ts->platform_data->use_st) {
    > > + cyttsp_xdebug("ST STEP 0 - ST1 ID=%d ST2 ID=%d\n", \
    > > + cur_st_tch[CY_ST_FNGR1_IDX], \
    > > + cur_st_tch[CY_ST_FNGR2_IDX]);
    > > + if (cur_st_tch[CY_ST_FNGR1_IDX] > CY_NUM_TRK_ID) {
    > > + /* reassign finger 1 and 2 positions to new
    tracks */
    > > + if (cur_tch > 0) {
    > > + /* reassign st finger1 */
    > > + if (ts->platform_data->use_trk_id) {
    > > + id = CY_MT_TCH1_IDX;
    > > + cur_st_tch[CY_ST_FNGR1_IDX] =
    > cur_mt_tch[id];
    > > + } else {
    > > + id =
    GET_TOUCH1_ID(g_xy_data.touch12_id);
    > > + cur_st_tch[CY_ST_FNGR1_IDX] =
    id;
    > > + }
    > > + st_x1 = cur_mt_pos[id][CY_XPOS];
    > > + st_y1 = cur_mt_pos[id][CY_YPOS];
    > > + st_z1 = cur_mt_z[id];
    > > + cyttsp_xdebug("ST STEP 1 - ST1
    ID=%3d\n", \
    > > + cur_st_tch[CY_ST_FNGR1_IDX]);
    > > + if ((cur_tch > 1) &&
    > > + (cur_st_tch[CY_ST_FNGR2_IDX] >
    > > + CY_NUM_TRK_ID)) {
    > > + /* reassign st finger2 */
    > > + if (cur_tch > 1) {
    > > + if
    (ts->platform_data->use_trk_id)
    > {
    > > + id =
    CY_MT_TCH2_IDX;
    > > +
    cur_st_tch[CY_ST_FNGR2_IDX] =
    > cur_mt_tch[id];
    > > + } else {
    > > + id =
    > GET_TOUCH2_ID(g_xy_data.touch12_id);
    > > +
    cur_st_tch[CY_ST_FNGR2_IDX] =
    > id;
    > > + }
    > > + st_x2 =
    cur_mt_pos[id][CY_XPOS];
    > > + st_y2 =
    cur_mt_pos[id][CY_YPOS];
    > > + st_z2 = cur_mt_z[id];
    > > + cyttsp_xdebug("ST STEP 2
    - ST2
    > ID=%3d\n", \
    > > +
    cur_st_tch[CY_ST_FNGR2_IDX]);
    > > + }
    > > + }
    > > + }
    > > + } else if (cur_st_tch[CY_ST_FNGR2_IDX] > CY_NUM_TRK_ID)
    {
    > > + if (cur_tch > 1) {
    > > + /* reassign st finger2 */
    > > + if (ts->platform_data->use_trk_id) {
    > > + /* reassign st finger2 */
    > > + id = CY_MT_TCH2_IDX;
    > > + cur_st_tch[CY_ST_FNGR2_IDX] =
    > > + cur_mt_tch[id];
    > > + } else {
    > > + /* reassign st finger2 */
    > > + id =
    GET_TOUCH2_ID(g_xy_data.touch12_id);
    > > + cur_st_tch[CY_ST_FNGR2_IDX] =
    id;
    > > + }
    > > + st_x2 = cur_mt_pos[id][CY_XPOS];
    > > + st_y2 = cur_mt_pos[id][CY_YPOS];
    > > + st_z2 = cur_mt_z[id];
    > > + cyttsp_xdebug("ST STEP 3 - ST2
    ID=%3d\n", \
    > > + cur_st_tch[CY_ST_FNGR2_IDX]);
    > > + }
    > > + }
    > > + /* if the 1st touch is missing and there is a 2nd touch,
    > > + * then set the 1st touch to 2nd touch and terminate 2nd
    > touch
    > > + */
    > > + if ((cur_st_tch[CY_ST_FNGR1_IDX] > CY_NUM_TRK_ID) &&
    > > + (cur_st_tch[CY_ST_FNGR2_IDX] < CY_NUM_TRK_ID)) {
    > > + st_x1 = st_x2;
    > > + st_y1 = st_y2;
    > > + st_z1 = st_z2;
    > > + cur_st_tch[CY_ST_FNGR1_IDX] =
    > > + cur_st_tch[CY_ST_FNGR2_IDX];
    > > + cur_st_tch[CY_ST_FNGR2_IDX] =
    > > + CY_IGNR_TCH;
    > > + }
    > > + /* if the 2nd touch ends up equal to the 1st touch,
    > > + * then just report a single touch */
    > > + if (cur_st_tch[CY_ST_FNGR1_IDX] ==
    > > + cur_st_tch[CY_ST_FNGR2_IDX]) {
    > > + cur_st_tch[CY_ST_FNGR2_IDX] =
    > > + CY_IGNR_TCH;
    > > + }
    > > + /* set Single Touch current event signals */
    > > + if (cur_st_tch[CY_ST_FNGR1_IDX] < CY_NUM_TRK_ID) {
    > > + input_report_abs(ts->input,
    > > + ABS_X, st_x1);
    > > + input_report_abs(ts->input,
    > > + ABS_Y, st_y1);
    > > + input_report_abs(ts->input,
    > > + ABS_PRESSURE, st_z1);
    > > + input_report_key(ts->input,
    > > + BTN_TOUCH,
    > > + CY_TCH);
    > > + input_report_abs(ts->input,
    > > + ABS_TOOL_WIDTH,
    > > + curr_tool_width);
    > > + cyttsp_debug("ST->F1:%3d X:%3d Y:%3d Z:%3d\n", \
    > > + cur_st_tch[CY_ST_FNGR1_IDX], \
    > > + st_x1, st_y1, st_z1);
    > > + if (cur_st_tch[CY_ST_FNGR2_IDX] < CY_NUM_TRK_ID)
    {
    > > + input_report_key(ts->input, BTN_2,
    CY_TCH);
    > > + input_report_abs(ts->input, ABS_HAT0X,
    st_x2);
    > > + input_report_abs(ts->input, ABS_HAT0Y,
    st_y2);
    > > + cyttsp_debug("ST->F2:%3d X:%3d Y:%3d
    Z:%3d\n",
    > \
    > > + cur_st_tch[CY_ST_FNGR2_IDX],
    > > + st_x2, st_y2, st_z2);
    > > + } else {
    > > + input_report_key(ts->input,
    > > + BTN_2,
    > > + CY_NTCH);
    > > + }
    > > + } else {
    > > + input_report_abs(ts->input, ABS_PRESSURE,
    CY_NTCH);
    > > + input_report_key(ts->input, BTN_TOUCH, CY_NTCH);
    > > + input_report_key(ts->input, BTN_2, CY_NTCH);
    > > + }
    > > + /* update platform data for the current single touch
    info
    > */
    > > + ts->prv_st_tch[CY_ST_FNGR1_IDX] =
    > cur_st_tch[CY_ST_FNGR1_IDX];
    > > + ts->prv_st_tch[CY_ST_FNGR2_IDX] =
    > cur_st_tch[CY_ST_FNGR2_IDX];
    > > +
    > > + }
    > > +
    > > + /* handle Multi-touch signals */
    > > + if (ts->platform_data->use_mt) {
    > > + if (ts->platform_data->use_trk_id) {
    > > + /* terminate any previous touch where the track
    > > + * is missing from the current event */
    > > + for (id = 0; id < CY_NUM_TRK_ID; id++) {
    > > + if ((ts->act_trk[id] != CY_NTCH) &&
    > > + (cur_trk[id] == CY_NTCH)) {
    > > + input_report_abs(ts->input,
    > > + ABS_MT_TRACKING_ID,
    > > + id);
    > > + input_report_abs(ts->input,
    > > + ABS_MT_TOUCH_MAJOR,
    > > + CY_NTCH);
    > > + input_report_abs(ts->input,
    > > + ABS_MT_WIDTH_MAJOR,
    > > + curr_tool_width);
    > > + input_report_abs(ts->input,
    > > + ABS_MT_POSITION_X,
    > > +
    ts->prv_mt_pos[id][CY_XPOS]);
    > > + input_report_abs(ts->input,
    > > + ABS_MT_POSITION_Y,
    > > +
    ts->prv_mt_pos[id][CY_YPOS]);
    > > + CY_MT_SYNC(ts->input);
    > > + ts->act_trk[id] = CY_NTCH;
    > > + ts->prv_mt_pos[id][CY_XPOS] = 0;
    > > + ts->prv_mt_pos[id][CY_YPOS] = 0;
    > > + }
    > > + }
    > > + /* set Multi-Touch current event signals */
    > > + for (id = 0; id < CY_NUM_MT_TCH_ID; id++) {
    > > + if (cur_mt_tch[id] < CY_NUM_TRK_ID) {
    > > + input_report_abs(ts->input,
    > > + ABS_MT_TRACKING_ID,
    > > + cur_mt_tch[id]);
    > > + input_report_abs(ts->input,
    > > + ABS_MT_TOUCH_MAJOR,
    > > + cur_mt_z[id]);
    > > + input_report_abs(ts->input,
    > > + ABS_MT_WIDTH_MAJOR,
    > > + curr_tool_width);
    > > + input_report_abs(ts->input,
    > > + ABS_MT_POSITION_X,
    > > +
    cur_mt_pos[id][CY_XPOS]);
    > > + input_report_abs(ts->input,
    > > + ABS_MT_POSITION_Y,
    > > +
    cur_mt_pos[id][CY_YPOS]);
    > > + CY_MT_SYNC(ts->input);
    > > + ts->act_trk[id] = CY_TCH;
    > > + ts->prv_mt_pos[id][CY_XPOS] =
    > > + cur_mt_pos[id][CY_XPOS];
    > > + ts->prv_mt_pos[id][CY_YPOS] =
    > > + cur_mt_pos[id][CY_YPOS];
    > > + }
    > > + }
    > > + } else {
    > > + /* set temporary track array elements to voids
    */
    > > + for (id = 0; id < CY_NUM_MT_TCH_ID; id++) {
    > > + tmp_trk[id] = CY_IGNR_TCH;
    > > + snd_trk[id] = CY_IGNR_TCH;
    > > + }
    > > +
    > > + /* get what is currently active */
    > > + for (i = 0, id = 0;
    > > + id < CY_NUM_TRK_ID && i <
    CY_NUM_MT_TCH_ID;
    > > + id++) {
    > > + if (cur_trk[id] == CY_TCH) {
    > > + /* only incr counter if track
    found */
    > > + tmp_trk[i] = id;
    > > + i++;
    > > + }
    > > + }
    > > + cyttsp_xdebug("T1: t0=%d, t1=%d, t2=%d,
    t3=%d\n", \
    > > + tmp_trk[0], tmp_trk[1], tmp_trk[2], \
    > > + tmp_trk[3]);
    > > + cyttsp_xdebug("T1: p0=%d, p1=%d, p2=%d,
    p3=%d\n", \
    > > + ts->prv_mt_tch[0], ts->prv_mt_tch[1], \
    > > + ts->prv_mt_tch[2], ts->prv_mt_tch[3]);
    > > +
    > > + /* pack in still active previous touches */
    > > + for (id = 0, prv_tch = 0;
    > > + id < CY_NUM_MT_TCH_ID; id++) {
    > > + if (tmp_trk[id] < CY_NUM_TRK_ID) {
    > > + if
    (cyttsp_inlist(ts->prv_mt_tch,
    > > + tmp_trk[id], &loc,
    > > + CY_NUM_MT_TCH_ID)) {
    > > + loc &= CY_NUM_MT_TCH_ID
    - 1;
    > > + snd_trk[loc] =
    tmp_trk[id];
    > > + prv_tch++;
    > > + cyttsp_xdebug("inlist
    s[%d]=%d
    > t[%d]=%d l=%d p=%d\n", \
    > > + loc,
    snd_trk[loc], \
    > > + id, tmp_trk[id],
    \
    > > + loc, prv_tch);
    > > + } else {
    > > + cyttsp_xdebug("not
    inlist s[%d]=%d
    > t[%d]=%d l=%d \n", \
    > > + id, snd_trk[id],
    \
    > > + id, tmp_trk[id],
    \
    > > + loc);
    > > + }
    > > + }
    > > + }
    > > + cyttsp_xdebug("S1: s0=%d, s1=%d, s2=%d, s3=%d
    > p=%d\n", \
    > > + snd_trk[0], snd_trk[1], snd_trk[2], \
    > > + snd_trk[3], prv_tch);
    > > +
    > > + /* pack in new touches */
    > > + for (id = 0; id < CY_NUM_MT_TCH_ID; id++) {
    > > + if (tmp_trk[id] < CY_NUM_TRK_ID) {
    > > + if (!cyttsp_inlist(snd_trk,
    tmp_trk[id],
    > &loc, CY_NUM_MT_TCH_ID)) {
    > > + cyttsp_xdebug("not
    inlist t[%d]=%d
    > l=%d\n", \
    > > + id, tmp_trk[id],
    loc);
    > > + if
    > (cyttsp_next_avail_inlist(snd_trk, &loc, CY_NUM_MT_TCH_ID)) {
    > > + loc &=
    CY_NUM_MT_TCH_ID - 1;
    > > + snd_trk[loc] =
    tmp_trk[id];
    > > +
    cyttsp_xdebug("put inlist
    > s[%d]=%d t[%d]=%d\n",
    > > + loc,
    snd_trk[loc], id,
    > tmp_trk[id]);
    > > + }
    > > + } else {
    > > + cyttsp_xdebug("is in
    list s[%d]=%d
    > t[%d]=%d loc=%d\n", \
    > > + id, snd_trk[id],
    id,
    > tmp_trk[id], loc);
    > > + }
    > > + }
    > > + }
    > > + cyttsp_xdebug("S2: s0=%d, s1=%d, s2=%d,
    s3=%d\n", \
    > > + snd_trk[0], snd_trk[1],
    > > + snd_trk[2], snd_trk[3]);
    > > +
    > > + /* sync motion event signals for each current
    touch
    > */
    > > + for (id = 0; id < CY_NUM_MT_TCH_ID; id++) {
    > > + /* z will either be 0 (NOTOUCH) or
    > > + * some pressure (TOUCH) */
    > > + cyttsp_xdebug("MT0 prev[%d]=%d
    temp[%d]=%d
    > send[%d]=%d\n", \
    > > + id, ts->prv_mt_tch[id], \
    > > + id, tmp_trk[id], \
    > > + id, snd_trk[id]);
    > > + if (snd_trk[id] < CY_NUM_TRK_ID) {
    > > + input_report_abs(ts->input,
    > > + ABS_MT_TOUCH_MAJOR,
    > > + cur_mt_z[snd_trk[id]]);
    > > + input_report_abs(ts->input,
    > > + ABS_MT_WIDTH_MAJOR,
    > > + curr_tool_width);
    > > + input_report_abs(ts->input,
    > > + ABS_MT_POSITION_X,
    > > +
    cur_mt_pos[snd_trk[id]][CY_XPOS]);
    > > + input_report_abs(ts->input,
    > > + ABS_MT_POSITION_Y,
    > > +
    cur_mt_pos[snd_trk[id]][CY_YPOS]);
    > > + CY_MT_SYNC(ts->input);
    > > + cyttsp_debug("MT1->TID:%2d X:%3d
    Y:%3d
    > Z:%3d touch-sent\n", \
    > > + snd_trk[id], \
    > > +
    cur_mt_pos[snd_trk[id]][CY_XPOS], \
    > > +
    cur_mt_pos[snd_trk[id]][CY_YPOS], \
    > > + cur_mt_z[snd_trk[id]]);
    > > + } else if (ts->prv_mt_tch[id] <
    CY_NUM_TRK_ID)
    > {
    > > + /* void out this touch */
    > > + input_report_abs(ts->input,
    > > + ABS_MT_TOUCH_MAJOR,
    > > + CY_NTCH);
    > > + input_report_abs(ts->input,
    > > + ABS_MT_WIDTH_MAJOR,
    > > + curr_tool_width);
    > > + input_report_abs(ts->input,
    > > + ABS_MT_POSITION_X,
    > > + ts->prv_mt_pos[ts-
    > >prv_mt_tch[id]][CY_XPOS]);
    > > + input_report_abs(ts->input,
    > > + ABS_MT_POSITION_Y,
    > > + ts->prv_mt_pos[ts-
    > >prv_mt_tch[id]][CY_YPOS]);
    > > + CY_MT_SYNC(ts->input);
    > > + cyttsp_debug("MT2->TID:%2d X:%3d
    Y:%3d
    > Z:%3d lift off-sent\n", \
    > > + ts->prv_mt_tch[id], \
    > > + ts->prv_mt_pos[ts-
    > >prv_mt_tch[id]][CY_XPOS], \
    > > + ts->prv_mt_pos[ts-
    > >prv_mt_tch[id]][CY_YPOS], \
    > > + CY_NTCH);
    > > + } else {
    > > + /* do not stuff any signals for
    this
    > > + * previously and currently
    > > + * void touches */
    > > + cyttsp_xdebug("MT3->send[%d]=%d
    - No
    > touch - NOT sent\n", \
    > > + id,
    snd_trk[id]);
    > > + }
    > > + }
    > > +
    > > + /* save current posted tracks to
    > > + * previous track memory */
    > > + for (id = 0; id < CY_NUM_MT_TCH_ID; id++) {
    > > + ts->prv_mt_tch[id] = snd_trk[id];
    > > + ts->prv_mt_pos[snd_trk[id]][CY_XPOS] =
    > > +
    cur_mt_pos[snd_trk[id]][CY_XPOS];
    > > + ts->prv_mt_pos[snd_trk[id]][CY_YPOS] =
    > > +
    cur_mt_pos[snd_trk[id]][CY_YPOS];
    > > + cyttsp_xdebug("MT4->TID:%2d X:%3d Y:%3d
    Z:%3d
    > save for previous\n", \
    > > + snd_trk[id], \
    > > +
    ts->prv_mt_pos[snd_trk[id]][CY_XPOS], \
    > > +
    ts->prv_mt_pos[snd_trk[id]][CY_YPOS], \
    > > + CY_NTCH);
    > > + }
    > > + for (id = 0; id < CY_NUM_TRK_ID; id++)
    > > + ts->act_trk[id] = CY_NTCH;
    > > + for (id = 0; id < CY_NUM_MT_TCH_ID; id++) {
    > > + if (snd_trk[id] < CY_NUM_TRK_ID)
    > > + ts->act_trk[snd_trk[id]] =
    CY_TCH;
    > > + }
    > > + }
    > > + }
    > > +
    > > + /* handle gestures */
    > > + if (ts->platform_data->use_gestures) {
    > > + if (g_xy_data.gest_id) {
    > > + input_report_key(ts->input,
    > > + BTN_3, CY_TCH);
    > > + input_report_abs(ts->input,
    > > + ABS_HAT1X, g_xy_data.gest_id);
    > > + input_report_abs(ts->input,
    > > + ABS_HAT2Y, g_xy_data.gest_cnt);
    > > + }
    > > + }
    > > +
    > > + /* signal the view motion event */
    > > + input_sync(ts->input);
    > > +
    > > + for (id = 0; id < CY_NUM_TRK_ID; id++) {
    > > + /* update platform data for the current MT information
    */
    > > + ts->act_trk[id] = cur_trk[id];
    > > + }
    > > +
    > > +exit_xy_worker:
    > > + if (cyttsp_disable_touch) {
    > > + /* Turn off the touch interrupts */
    > > + cyttsp_debug("Not enabling touch\n");
    > > + } else {
    > > + if (ts->client->irq == 0) {
    > > + /* restart event timer */
    > > + mod_timer(&ts->timer, jiffies +
    TOUCHSCREEN_TIMEOUT);
    > > + } else {
    > > + /* re-enable the interrupt after processing */
    > > + enable_irq(ts->client->irq);
    > > + }
    > > + }
    > > + return;
    > > +}
    > > +
    > > +static int cyttsp_inlist(u16 prev_track[], u8 cur_trk_id,
    > > + u8 *prev_loc, u8 num_touches)
    > > +{
    >
    > return could be "bool" instead of "int" right?
    >

    Yes. In new code.

    > > + u8 id = 0;
    > > +
    > > + *prev_loc = CY_IGNR_TCH;
    > > +
    > > + cyttsp_xdebug("IN p[%d]=%d c=%d n=%d loc=%d\n", \
    > > + id, prev_track[id], cur_trk_id, \
    > > + num_touches, *prev_loc);
    >
    > Indentation problem.
    >

    New code should be clean.

    > > + for (id = 0, *prev_loc = CY_IGNR_TCH;
    > > + (id < num_touches); id++) {
    > > + cyttsp_xdebug("p[%d]=%d c=%d n=%d loc=%d\n", \
    > > + id, prev_track[id], cur_trk_id, \
    > > + num_touches, *prev_loc);
    > > + if (prev_track[id] == cur_trk_id) {
    > > + *prev_loc = id;
    > > + break;
    > > + }
    > > + }
    > > + cyttsp_xdebug("OUT p[%d]=%d c=%d n=%d loc=%d\n", \
    > > + id, prev_track[id], cur_trk_id, num_touches, *prev_loc);
    > > +
    > > + return ((*prev_loc < CY_NUM_TRK_ID) ? true : false);
    > > +}
    > > +
    > > +static int cyttsp_next_avail_inlist(u16 cur_trk[],
    > > + u8 *new_loc, u8 num_touches)
    > > +{
    >
    > return could be "bool" instead of "int" right?
    >

    Yes. In new code.

    > > + u8 id;
    > > +
    > > + for (id = 0, *new_loc = CY_IGNR_TCH;
    > > + (id < num_touches); id++) {
    > > + if (cur_trk[id] > CY_NUM_TRK_ID) {
    > > + *new_loc = id;
    > > + break;
    > > + }
    > > + }
    > > +
    > > + return ((*new_loc < CY_NUM_TRK_ID) ? true : false);
    > > +}
    > > +
    > > +/* Timer function used as dummy interrupt driver */
    > > +static void cyttsp_timer(unsigned long handle)
    > > +{
    > > + struct cyttsp *ts = (struct cyttsp *) handle;
    > > +
    > > + cyttsp_xdebug("TTSP Device timer event\n");
    > > +
    > > + /* schedule motion signal handling */
    > > + queue_work(cyttsp_ts_wq, &ts->work);
    > > +
    > > + return;
    > > +}
    > > +
    > > +
    > > +
    > > +/*
    >
    ***********************************************************************
    > *
    > > + * ISR function. This function is general, initialized in drivers
    > init
    > > + * function
    > > + *
    >
    ***********************************************************************
    > * */
    > > +static irqreturn_t cyttsp_irq(int irq, void *handle)
    > > +{
    > > + struct cyttsp *ts = (struct cyttsp *) handle;
    > > +
    > > + cyttsp_xdebug("%s: Got IRQ\n", CY_I2C_NAME);
    > > +
    > > + /* disable further interrupts until this interrupt is processed
    > */
    > > + disable_irq_nosync(ts->client->irq);
    >
    > As indicated below please use request_threaded_irq(..).
    >
    >

    New code uses request_threaded_irq().

    > > +
    > > + /* schedule motion signal handling */
    > > + queue_work(cyttsp_ts_wq, &ts->work);
    > > + return IRQ_HANDLED;
    > > +}
    > > +
    > > +/*
    >
    ***********************************************************************
    > *
    > > + * Probe initialization functions
    > > + *
    >
    ***********************************************************************
    > * */
    > > +static int cyttsp_putbl(struct cyttsp *ts, int show,
    > > + int show_status, int show_version, int show_cid)
    > > +{
    > > + int retval = CY_OK;
    > > +
    > > + int num_bytes = (show_status * 3) + (show_version * 6) +
    > (show_cid * 3);
    > > +
    > > + if (show_cid)
    > > + num_bytes = sizeof(struct cyttsp_bootloader_data_t);
    > > + else if (show_version)
    > > + num_bytes = sizeof(struct cyttsp_bootloader_data_t) - 3;
    > > + else
    > > + num_bytes = sizeof(struct cyttsp_bootloader_data_t) - 9;
    > > +
    > > + if (show) {
    > > + retval = i2c_smbus_read_i2c_block_data(ts->client,
    > > + CY_REG_BASE, num_bytes, (u8 *)&g_bl_data);
    > > + if (show_status) {
    > > + cyttsp_debug("BL%d: f=%02X s=%02X err=%02X
    > bl=%02X%02X bld=%02X%02X\n", \
    > > + show, \
    > > + g_bl_data.bl_file, \
    > > + g_bl_data.bl_status, \
    > > + g_bl_data.bl_error, \
    > > + g_bl_data.blver_hi, g_bl_data.blver_lo,
    \
    > > + g_bl_data.bld_blver_hi,
    > g_bl_data.bld_blver_lo);
    > > + }
    > > + if (show_version) {
    > > + cyttsp_debug("BL%d: ttspver=0x%02X%02X
    > appid=0x%02X%02X appver=0x%02X%02X\n", \
    > > + show, \
    > > + g_bl_data.ttspver_hi,
    g_bl_data.ttspver_lo, \
    > > + g_bl_data.appid_hi, g_bl_data.appid_lo,
    \
    > > + g_bl_data.appver_hi,
    g_bl_data.appver_lo);
    > > + }
    > > + if (show_cid) {
    > > + cyttsp_debug("BL%d: cid=0x%02X%02X%02X\n", \
    > > + show, \
    > > + g_bl_data.cid_0, \
    > > + g_bl_data.cid_1, \
    > > + g_bl_data.cid_2);
    > > + }
    > > + mdelay(CY_DLY_DFLT);
    > > + }
    > > +
    > > + return retval;
    > > +}
    > > +
    > > +#ifdef CY_INCLUDE_LOAD_FILE
    >
    > Could you please explain what is the use of this #define?
    >
    > Are we loading any firmware? Please explain why we can't use
    > request_firware(...).
    >

    New code replaces included code with file based loader support.

    > > +#define CY_MAX_I2C_LEN 256
    > > +#define CY_MAX_TRY 10
    > > +#define CY_BL_PAGE_SIZE 16
    > > +#define CY_BL_NUM_PAGES 5
    > > +static int cyttsp_i2c_wr_blk_data(struct i2c_client *client, u8
    > command,
    > > + u8 length, const u8 *values)
    > > +{
    > > + int retval = CY_OK;
    > > +
    > > + u8 dataray[CY_MAX_I2C_LEN];
    > > + u8 try;
    > > + dataray[0] = command;
    > > + if (length)
    > > + memcpy(&dataray[1], values, length);
    > > +
    > > + try = CY_MAX_TRY;
    > > + do {
    > > + retval = i2c_master_send(client, dataray, length+1);
    > > + mdelay(CY_DLY_DFLT*2);
    > > + } while ((retval != length+1) && try--);
    > > +
    > > + return retval;
    > > +}
    > > +
    > > +static int cyttsp_i2c_wr_blk_chunks(struct cyttsp *ts, u8 command,
    > > + u8 length, const u8 *values)
    > > +{
    > > + int retval = CY_OK;
    > > + int block = 1;
    > > +
    > > + u8 dataray[CY_MAX_I2C_LEN];
    > > +
    > > + /* first page already includes the bl page offset */
    > > + retval = i2c_smbus_write_i2c_block_data(ts->client, CY_REG_BASE,
    > > + CY_BL_PAGE_SIZE+1, values);
    > > + mdelay(10);
    > > + values += CY_BL_PAGE_SIZE+1;
    > > + length -= CY_BL_PAGE_SIZE+1;
    > > +
    > > + /* rem blocks require bl page offset stuffing */
    > > + while (length &&
    > > + (block < CY_BL_NUM_PAGES) &&
    > > + !(retval < CY_OK)) {
    > > + dataray[0] = CY_BL_PAGE_SIZE*block;
    > > + memcpy(&dataray[1], values,
    > > + length >= CY_BL_PAGE_SIZE ?
    > > + CY_BL_PAGE_SIZE : length);
    > > + retval = i2c_smbus_write_i2c_block_data(ts->client,
    > > + CY_REG_BASE,
    > > + length >= CY_BL_PAGE_SIZE ?
    > > + CY_BL_PAGE_SIZE + 1 : length+1, dataray);
    > > + mdelay(10);
    > > + values += CY_BL_PAGE_SIZE;
    > > + length = length >= CY_BL_PAGE_SIZE ?
    > > + length - CY_BL_PAGE_SIZE : 0;
    > > + block++;
    > > + }
    > > +
    > > + return retval;
    > > +}
    > > +
    > > +static int cyttsp_bootload_app(struct cyttsp *ts)
    > > +{
    > > + int retval = CY_OK;
    > > + int i, tries;
    > > + u8 host_reg;
    > > +
    > > + cyttsp_debug("load new firmware \n");
    > > + /* reset TTSP Device back to bootloader mode */
    > > + host_reg = CY_SOFT_RESET_MODE;
    > > + retval = i2c_smbus_write_i2c_block_data(ts->client, CY_REG_BASE,
    > > + sizeof(host_reg), &host_reg);
    > > + /* wait for TTSP Device to complete reset back to bootloader */
    > > + mdelay(1000);
    > > + cyttsp_putbl(ts, 3, true, true, true);
    > > + cyttsp_debug("load file - tver=0x%02X%02X a_id=0x%02X%02X
    > aver=0x%02X%02X\n", \
    > > + cyttsp_fw_tts_verh, cyttsp_fw_tts_verl, \
    > > + cyttsp_fw_app_idh, cyttsp_fw_app_idl, \
    > > + cyttsp_fw_app_verh, cyttsp_fw_app_verl);
    > > +
    > > + /* download new TTSP Application to the Bootloader */
    > > + if (!(retval < CY_OK)) {
    > > + i = 0;
    > > + /* send bootload initiation command */
    > > + if (cyttsp_fw[i].Command == CY_BL_INIT_LOAD) {
    > > + g_bl_data.bl_file = 0;
    > > + g_bl_data.bl_status = 0;
    > > + g_bl_data.bl_error = 0;
    > > + retval =
    i2c_smbus_write_i2c_block_data(ts->client,
    > > + CY_REG_BASE,
    > > + cyttsp_fw[i].Length,
    cyttsp_fw[i].Block);
    > > + /* delay to allow bl to get ready for block
    writes */
    > > + i++;
    > > + tries = 0;
    > > + cyttsp_debug("wait init f=%02X, s=%02X, e=%02X
    > t=%d\n", \
    > > + g_bl_data.bl_file, g_bl_data.bl_status,
    \
    > > + g_bl_data.bl_error, tries);
    > > + do {
    > > + mdelay(1000);
    > > + cyttsp_putbl(ts, 4, true, false, false);
    > > + } while (g_bl_data.bl_status != 0x10 &&
    > > + g_bl_data.bl_status != 0x11 &&
    > > + tries++ < 10);
    > > + /* send bootload firmware load blocks */
    > > + if (!(retval < CY_OK)) {
    > > + while (cyttsp_fw[i].Command ==
    CY_BL_WRITE_BLK)
    > {
    > > + retval =
    cyttsp_i2c_wr_blk_chunks(ts,
    > > + CY_REG_BASE,
    > > + cyttsp_fw[i].Length,
    > > + cyttsp_fw[i].Block);
    > > + /* bl requires dly after blocks
    */
    > > + mdelay(100);
    > > + cyttsp_debug("BL DNLD Rec=% 3d
    Len=% 3d
    > Addr=%04X\n", \
    > > + cyttsp_fw[i].Record, \
    > > + cyttsp_fw[i].Length, \
    > > + cyttsp_fw[i].Address);
    > > + i++;
    > > + if (retval < CY_OK) {
    > > + cyttsp_debug("BL fail
    Rec=%3d
    > retval=%d\n", \
    > > +
    cyttsp_fw[i-1].Record, \
    > > + retval);
    > > + break;
    > > + } else {
    > > + /* reset TTSP I2C
    counter */
    > > + retval =
    cyttsp_i2c_wr_blk_data(ts-
    > >client,
    > > + CY_REG_BASE,
    > > + 0, NULL);
    > > + mdelay(10);
    > > + cyttsp_putbl(ts, 5,
    > > + true, false,
    false);
    > > + }
    > > + }
    > > + if (!(retval < CY_OK)) {
    > > + while (i < cyttsp_fw_records) {
    > > + retval =
    > i2c_smbus_write_i2c_block_data(ts->client, CY_REG_BASE,
    > > +
    cyttsp_fw[i].Length,
    > > +
    cyttsp_fw[i].Block);
    > > + i++;
    > > + tries = 0;
    > > + cyttsp_debug("wait init
    f=%02X,
    > s=%02X, e=%02X t=%d\n", \
    > > +
    g_bl_data.bl_file, \
    > > +
    g_bl_data.bl_status, \
    > > +
    g_bl_data.bl_error, \
    > > + tries);
    > > + do {
    > > + mdelay(1000);
    > > + cyttsp_putbl(ts,
    6, true,
    > false, false);
    > > + } while
    (g_bl_data.bl_status !=
    > 0x10 &&
    > > +
    g_bl_data.bl_status != 0x11
    > &&
    > > + tries++ < 10);
    > > + cyttsp_putbl(ts, 7,
    true, false,
    > > + false);
    > > + if (retval < CY_OK)
    > > + break;
    > > + }
    > > + }
    > > + }
    > > + }
    > > + }
    > > +
    > > + /* reset TTSP Device back to bootloader mode */
    > > + host_reg = CY_SOFT_RESET_MODE;
    > > + retval = i2c_smbus_write_i2c_block_data(ts->client, CY_REG_BASE,
    > > + sizeof(host_reg), &host_reg);
    > > + /* wait for TTSP Device to complete reset back to bootloader */
    > > + mdelay(1000);
    > > +
    > > + /* set arg2 to non-0 to activate */
    > > + retval = cyttsp_putbl(ts, 8, true, true, true);
    > > +
    > > + return retval;
    > > +}
    > > +#else
    > > +static int cyttsp_bootload_app(struct cyttsp *ts)
    > > +{
    > > + cyttsp_debug("no-load new firmware \n");
    > > + return CY_OK;
    > > +}
    > > +#endif /* CY_INCLUDE_LOAD_FILE */
    > > +
    > > +
    > > +static int cyttsp_power_on(struct cyttsp *ts)
    > > +{
    > > + int retval = CY_OK;
    > > + u8 host_reg;
    > > + int tries;
    > > +
    > > + cyttsp_debug("Power up \n");
    > > +
    > > + /* check if the TTSP device has a bootloader installed */
    > > + host_reg = CY_SOFT_RESET_MODE;
    > > + retval = i2c_smbus_write_i2c_block_data(ts->client, CY_REG_BASE,
    > > + sizeof(host_reg), &host_reg);
    > > + tries = 0;
    > > + do {
    > > + mdelay(1000);
    > > +
    > > + /* set arg2 to non-0 to activate */
    > > + retval = cyttsp_putbl(ts, 1, true, true, true);
    > > + cyttsp_info("BL%d: f=%02X s=%02X err=%02X bl=%02X%02X
    > bld=%02X%02X R=%d\n", \
    > > + 101, \
    > > + g_bl_data.bl_file, g_bl_data.bl_status, \
    > > + g_bl_data.bl_error, \
    > > + g_bl_data.blver_hi, g_bl_data.blver_lo, \
    > > + g_bl_data.bld_blver_hi, g_bl_data.bld_blver_lo,
    > > + retval);
    > > + cyttsp_info("BL%d: tver=%02X%02X a_id=%02X%02X
    > aver=%02X%02X\n", \
    > > + 102, \
    > > + g_bl_data.ttspver_hi, g_bl_data.ttspver_lo, \
    > > + g_bl_data.appid_hi, g_bl_data.appid_lo, \
    > > + g_bl_data.appver_hi, g_bl_data.appver_lo);
    > > + cyttsp_info("BL%d: c_id=%02X%02X%02X\n", \
    > > + 103, \
    > > + g_bl_data.cid_0, g_bl_data.cid_1,
    g_bl_data.cid_2);
    > > + } while (!(retval < CY_OK) &&
    > > + !GET_BOOTLOADERMODE(g_bl_data.bl_status) &&
    > > + !(g_bl_data.bl_file == CY_OP_MODE + CY_LOW_PWR_MODE) &&
    > > + tries++ < 10);
    > > +
    > > + /* is bootloader missing? */
    > > + if (!(retval < CY_OK)) {
    > > + cyttsp_xdebug("Ret=%d Check if bootloader is
    > missing...\n", \
    > > + retval);
    > > + if (!GET_BOOTLOADERMODE(g_bl_data.bl_status)) {
    > > + /* skip all bl and sys info and go to op mode */
    > > + if (!(retval < CY_OK)) {
    > > + cyttsp_xdebug("Bl is missing
    (ret=%d)\n", \
    > > + retval);
    > > + host_reg = CY_OP_MODE/* +
    CY_LOW_PWR_MODE*/;
    > > + retval =
    i2c_smbus_write_i2c_block_data(ts-
    > >client, CY_REG_BASE,
    > > + sizeof(host_reg), &host_reg);
    > > + /* wait for TTSP Device to complete
    switch to
    > > + * Operational mode */
    > > + mdelay(1000);
    > > + goto bypass;
    > > + }
    > > + }
    > > + }
    > > +
    > > +
    > > + /* take TTSP out of bootloader mode; go to TrueTouch operational
    > mode */
    > > + if (!(retval < CY_OK)) {
    > > + cyttsp_xdebug1("exit bootloader; go operational\n");
    > > + retval = i2c_smbus_write_i2c_block_data(ts->client,
    > > + CY_REG_BASE, sizeof(bl_cmd), bl_cmd);
    > > + tries = 0;
    > > + do {
    > > + mdelay(1000);
    > > + cyttsp_putbl(ts, 4, true, false, false);
    > > + cyttsp_info("BL%d: f=%02X s=%02X err=%02X
    bl=%02X%02X
    > bld=%02X%02X\n", \
    > > + 104, \
    > > + g_bl_data.bl_file, g_bl_data.bl_status,
    \
    > > + g_bl_data.bl_error, \
    > > + g_bl_data.blver_hi, g_bl_data.blver_lo,
    \
    > > + g_bl_data.bld_blver_hi,
    > g_bl_data.bld_blver_lo);
    > > + } while (GET_BOOTLOADERMODE(g_bl_data.bl_status) &&
    > > + tries++ < 10);
    > > + }
    > > +
    > > +
    > > +
    > > + if (!(retval < CY_OK) &&
    > > + cyttsp_app_load()) {
    > > + mdelay(1000);
    > > + if (CY_DIFF(g_bl_data.ttspver_hi, cyttsp_tts_verh()) ||
    > > + CY_DIFF(g_bl_data.ttspver_lo, cyttsp_tts_verl())
    ||
    > > + CY_DIFF(g_bl_data.appid_hi, cyttsp_app_idh())
    ||
    > > + CY_DIFF(g_bl_data.appid_lo, cyttsp_app_idl())
    ||
    > > + CY_DIFF(g_bl_data.appver_hi, cyttsp_app_verh())
    ||
    > > + CY_DIFF(g_bl_data.appver_lo, cyttsp_app_verl())
    ||
    > > + CY_DIFF(g_bl_data.cid_0, cyttsp_cid_0()) ||
    > > + CY_DIFF(g_bl_data.cid_1, cyttsp_cid_1()) ||
    > > + CY_DIFF(g_bl_data.cid_2, cyttsp_cid_2()) ||
    > > + cyttsp_force_fw_load()) {
    > > + cyttsp_debug("blttsp=0x%02X%02X
    flttsp=0x%02X%02X
    > force=%d\n", \
    > > + g_bl_data.ttspver_hi,
    g_bl_data.ttspver_lo, \
    > > + cyttsp_tts_verh(), cyttsp_tts_verl(), \
    > > + cyttsp_force_fw_load());
    > > + cyttsp_debug("blappid=0x%02X%02X
    > flappid=0x%02X%02X\n", \
    > > + g_bl_data.appid_hi, g_bl_data.appid_lo,
    \
    > > + cyttsp_app_idh(), cyttsp_app_idl());
    > > + cyttsp_debug("blappver=0x%02X%02X
    > flappver=0x%02X%02X\n", \
    > > + g_bl_data.appver_hi,
    g_bl_data.appver_lo, \
    > > + cyttsp_app_verh(), cyttsp_app_verl());
    > > + cyttsp_debug("blcid=0x%02X%02X%02X
    > flcid=0x%02X%02X%02X\n", \
    > > + g_bl_data.cid_0, \
    > > + g_bl_data.cid_1, \
    > > + g_bl_data.cid_2, \
    > > + cyttsp_cid_0(), \
    > > + cyttsp_cid_1(), \
    > > + cyttsp_cid_2());
    > > + /* enter bootloader to load new app into TTSP
    Device
    > */
    > > + retval = cyttsp_bootload_app(ts);
    > > + /* take TTSP device out of bootloader mode;
    > > + * switch back to TrueTouch operational mode */
    > > + if (!(retval < CY_OK)) {
    > > + retval =
    i2c_smbus_write_i2c_block_data(ts-
    > >client,
    > > + CY_REG_BASE,
    > > + sizeof(bl_cmd), bl_cmd);
    > > + /* wait for TTSP Device to complete
    > > + * switch to Operational mode */
    > > + mdelay(1000);
    > > + }
    > > + }
    > > + }
    > > +
    > > +bypass:
    > > + /* switch to System Information mode to read versions
    > > + * and set interval registers */
    > > + if (!(retval < CY_OK)) {
    > > + cyttsp_debug("switch to sysinfo mode \n");
    > > + host_reg = CY_SYSINFO_MODE;
    > > + retval = i2c_smbus_write_i2c_block_data(ts->client,
    > > + CY_REG_BASE, sizeof(host_reg), &host_reg);
    > > + /* wait for TTSP Device to complete switch to SysInfo
    mode
    > */
    > > + mdelay(1000);
    > > + if (!(retval < CY_OK)) {
    > > + retval =
    i2c_smbus_read_i2c_block_data(ts->client,
    > > + CY_REG_BASE,
    > > + sizeof(struct cyttsp_sysinfo_data_t),
    > > + (u8 *)&g_sysinfo_data);
    > > + cyttsp_debug("SI2: hst_mode=0x%02X
    mfg_cmd=0x%02X
    > mfg_stat=0x%02X\n", \
    > > + g_sysinfo_data.hst_mode, \
    > > + g_sysinfo_data.mfg_cmd, \
    > > + g_sysinfo_data.mfg_stat);
    > > + cyttsp_debug("SI2: bl_ver=0x%02X%02X\n", \
    > > + g_sysinfo_data.bl_verh, \
    > > + g_sysinfo_data.bl_verl);
    > > + cyttsp_debug("SI2: sysinfo act_int=0x%02X
    > tch_tmout=0x%02X lp_int=0x%02X\n", \
    > > + g_sysinfo_data.act_intrvl, \
    > > + g_sysinfo_data.tch_tmout, \
    > > + g_sysinfo_data.lp_intrvl);
    > > + cyttsp_info("SI%d: tver=%02X%02X a_id=%02X%02X
    > aver=%02X%02X\n", \
    > > + 102, \
    > > + g_sysinfo_data.tts_verh, \
    > > + g_sysinfo_data.tts_verl, \
    > > + g_sysinfo_data.app_idh, \
    > > + g_sysinfo_data.app_idl, \
    > > + g_sysinfo_data.app_verh, \
    > > + g_sysinfo_data.app_verl);
    > > + cyttsp_info("SI%d: c_id=%02X%02X%02X\n", \
    > > + 103, \
    > > + g_sysinfo_data.cid[0], \
    > > + g_sysinfo_data.cid[1], \
    > > + g_sysinfo_data.cid[2]);
    > > + if (!(retval < CY_OK) &&
    > > + (CY_DIFF(ts->platform_data->act_intrvl,
    > > + CY_ACT_INTRVL_DFLT) ||
    > > + CY_DIFF(ts->platform_data->tch_tmout,
    > > + CY_TCH_TMOUT_DFLT) ||
    > > + CY_DIFF(ts->platform_data->lp_intrvl,
    > > + CY_LP_INTRVL_DFLT))) {
    > > + if (!(retval < CY_OK)) {
    > > + u8
    intrvl_ray[sizeof(ts->platform_data-
    > >act_intrvl) +
    > > +
    sizeof(ts->platform_data-
    > >tch_tmout) +
    > > +
    sizeof(ts->platform_data-
    > >lp_intrvl)];
    > > + u8 i = 0;
    > > +
    > > + intrvl_ray[i++] =
    > > +
    ts->platform_data->act_intrvl;
    > > + intrvl_ray[i++] =
    > > +
    ts->platform_data->tch_tmout;
    > > + intrvl_ray[i++] =
    > > +
    ts->platform_data->lp_intrvl;
    > > +
    > > + cyttsp_debug("SI2: platinfo
    > act_intrvl=0x%02X tch_tmout=0x%02X lp_intrvl=0x%02X\n", \
    > > +
    ts->platform_data->act_intrvl, \
    > > +
    ts->platform_data->tch_tmout, \
    > > +
    ts->platform_data->lp_intrvl);
    > > + /* set intrvl registers */
    > > + retval =
    i2c_smbus_write_i2c_block_data(
    > > + ts->client,
    > > + CY_REG_ACT_INTRVL,
    > > + sizeof(intrvl_ray),
    intrvl_ray);
    > > + mdelay(CY_DLY_SYSINFO);
    > > + }
    > > + }
    > > + }
    > > + /* switch back to Operational mode */
    > > + cyttsp_debug("switch back to operational mode \n");
    > > + if (!(retval < CY_OK)) {
    > > + host_reg = CY_OP_MODE/* + CY_LOW_PWR_MODE*/;
    > > + retval =
    i2c_smbus_write_i2c_block_data(ts->client,
    > > + CY_REG_BASE,
    > > + sizeof(host_reg), &host_reg);
    > > + /* wait for TTSP Device to complete
    > > + * switch to Operational mode */
    > > + mdelay(1000);
    > > + }
    > > + }
    > > + /* init gesture setup;
    > > + * this is required even if not using gestures
    > > + * in order to set the active distance */
    > > + if (!(retval < CY_OK)) {
    > > + u8 gesture_setup;
    > > + cyttsp_debug("init gesture setup \n");
    > > + gesture_setup = ts->platform_data->gest_set;
    > > + retval = i2c_smbus_write_i2c_block_data(ts->client,
    > > + CY_REG_GEST_SET,
    > > + sizeof(gesture_setup), &gesture_setup);
    > > + mdelay(CY_DLY_DFLT);
    > > + }
    > > +
    > > + if (!(retval < CY_OK))
    > > + ts->platform_data->power_state = CY_ACTIVE_STATE;
    > > + else
    > > + ts->platform_data->power_state = CY_IDLE_STATE;
    > > +
    > > + cyttsp_debug("Retval=%d Power state is %s\n", \
    > > + retval, \
    > > + ts->platform_data->power_state == CY_ACTIVE_STATE ? \
    > > + "ACTIVE" : "IDLE");
    >
    > Whole function looks scary and hard to understand. Is it possible to
    > break it into the smaller
    > functionality so that it becomes easy to understand.
    >

    New refactored code breaks this into modules for clarity and reuse.

    > > +
    > > + return retval;
    > > +}
    > > +
    > > +/* cyttsp_initialize: Driver Initialization. This function takes
    > > + * care of the following tasks:
    > > + * 1. Create and register an input device with input layer
    > > + * 2. Take CYTTSP device out of bootloader mode; go operational
    > > + * 3. Start any timers/Work queues. */
    > > +static int cyttsp_initialize(struct i2c_client *client, struct
    > cyttsp *ts)
    > > +{
    > > + struct input_dev *input_device;
    > > + int error = 0;
    > > + int retval = CY_OK;
    > > + u8 id;
    > > +
    > > + /* Create the input device and register it. */
    > > + input_device = input_allocate_device();
    > > + if (!input_device) {
    > > + error = -ENOMEM;
    > > + cyttsp_xdebug1("err input allocate device\n");
    > > + goto error_free_device;
    > > + }
    > > +
    > > + if (!client) {
    > > + error = ~ENODEV;
    > > + cyttsp_xdebug1("err client is Null\n");
    > > + goto error_free_device;
    > > + }
    >
    > Why you are checking !client here?
    >

    Fixed in new code.

    > > +
    > > + if (!ts) {
    > > + error = ~ENODEV;
    >
    > ~? It should be -ENODEV, right?
    >

    Correct. Fixed in new code.

    > > + cyttsp_xdebug1("err context is Null\n");
    > > + goto error_free_device;
    > > + }
    > > +
    > > + ts->input = input_device;
    > > + input_device->name = CY_I2C_NAME;
    > > + input_device->phys = ts->phys;
    > > + input_device->dev.parent = &client->dev;
    > > +
    > > + /* init the touch structures */
    > > + ts->num_prv_st_tch = CY_NTCH;
    > > + for (id = 0; id < CY_NUM_TRK_ID; id++) {
    > > + ts->act_trk[id] = CY_NTCH;
    > > + ts->prv_mt_pos[id][CY_XPOS] = 0;
    > > + ts->prv_mt_pos[id][CY_YPOS] = 0;
    > > + }
    > > +
    > > + for (id = 0; id < CY_NUM_MT_TCH_ID; id++)
    > > + ts->prv_mt_tch[id] = CY_IGNR_TCH;
    > > +
    > > + for (id = 0; id < CY_NUM_ST_TCH_ID; id++)
    > > + ts->prv_st_tch[id] = CY_IGNR_TCH;
    > > +
    > > + set_bit(EV_SYN, input_device->evbit);
    > > + set_bit(EV_KEY, input_device->evbit);
    > > + set_bit(EV_ABS, input_device->evbit);
    > > + set_bit(BTN_TOUCH, input_device->keybit);
    > > + set_bit(BTN_2, input_device->keybit);
    >
    > You need not use atomic versions. Please use __set_bit.
    >

    Converted to use __set_bit() calls.

    > > + if (ts->platform_data->use_gestures)
    > > + set_bit(BTN_3, input_device->keybit);
    > > +
    > > + input_set_abs_params(input_device,
    > > + ABS_X, 0, ts->platform_data->maxx, 0, 0);
    > > + input_set_abs_params(input_device,
    > > + ABS_Y, 0, ts->platform_data->maxy, 0, 0);
    > > + input_set_abs_params(input_device,
    > > + ABS_TOOL_WIDTH, 0, CY_LARGE_TOOL_WIDTH, 0 , 0);
    > > + input_set_abs_params(input_device,
    > > + ABS_PRESSURE, 0, CY_MAXZ, 0, 0);
    > > + input_set_abs_params(input_device,
    > > + ABS_HAT0X, 0, ts->platform_data->maxx, 0, 0);
    > > + input_set_abs_params(input_device,
    > > + ABS_HAT0Y, 0, ts->platform_data->maxy, 0, 0);
    >
    > Why you are using HATxx? MT should be able to satisfy all the
    > requirements.
    >

    Code includes Single_Touch handling to support developers with older
    platform trees. Single-touch is a board configuration selection item.

    > > + if (ts->platform_data->use_gestures) {
    > > + input_set_abs_params(input_device,
    > > + ABS_HAT1X, 0, CY_MAXZ, 0, 0);
    > > + input_set_abs_params(input_device,
    > > + ABS_HAT1Y, 0, CY_MAXZ, 0, 0);
    > > + }
    > > + if (ts->platform_data->use_mt) {
    > > + input_set_abs_params(input_device,
    > > + ABS_MT_POSITION_X, 0, ts->platform_data->maxx,
    0, 0);
    > > + input_set_abs_params(input_device,
    > > + ABS_MT_POSITION_Y, 0, ts->platform_data->maxy,
    0, 0);
    > > + input_set_abs_params(input_device,
    > > + ABS_MT_TOUCH_MAJOR, 0, CY_MAXZ, 0, 0);
    > > + input_set_abs_params(input_device,
    > > + ABS_MT_WIDTH_MAJOR, 0, CY_LARGE_TOOL_WIDTH, 0,
    0);
    > > + if (ts->platform_data->use_trk_id) {
    > > + input_set_abs_params(input_device,
    > > + ABS_MT_TRACKING_ID, 0, CY_NUM_TRK_ID, 0,
    0);
    > > + }
    > > + }
    > > +
    > > + /* set dummy key to make driver work with virtual keys */
    > > + input_set_capability(input_device, EV_KEY, KEY_PROG1);
    >
    > What is virtual keys and how they are supported?
    >

    By enabling programmable keys, the developer can define regions of the
    touch surface that can be translated to button presses. The regions can
    be defined in the board configuration file.

    > > +
    > > + cyttsp_info("%s: Register input device\n", CY_I2C_NAME);
    > > + error = input_register_device(input_device);
    > > + if (error) {
    > > + cyttsp_alert("%s: Failed to register input device\n", \
    > > + CY_I2C_NAME);
    > > + retval = error;
    > > + goto error_free_device;
    > > + }
    > > +
    > > + /* Prepare our worker structure prior to setting up the
    timer/ISR
    > */
    > > + INIT_WORK(&ts->work, cyttsp_xy_worker);
    > > +
    > > + /* Power on the chip and make sure that I/Os are set as
    specified
    > > + * in the platform */
    > > + if (ts->platform_data->init)
    > > + retval = ts->platform_data->init(client);
    > > +
    > > + if (!(retval < CY_OK))
    > > + retval = cyttsp_power_on(ts);
    > > +
    > > + if (retval < 0)
    > > + goto error_free_device;
    >
    > Wrong.
    >
    > if (!rc) {
    > rc = power_on(ts);
    > if (!rc) {
    > rc = -Exxx;
    > goto error_path;
    > }
    > }
    >

    The new code has been reworked.

    > > +
    > > + /* Timer or Interrupt setup */
    > > + if (ts->client->irq == 0) {
    > > + cyttsp_info("Setting up timer\n");
    > > + setup_timer(&ts->timer, cyttsp_timer, (unsigned long)
    ts);
    > > + mod_timer(&ts->timer, jiffies + TOUCHSCREEN_TIMEOUT);
    >
    > Please support only one mode in the driver. Most of the time polling
    > mode is used
    > only during early development phase when the IRQs doesn't work, but we
    > don't want to carry
    > this code here.
    >
    > Please remove polling mode code.
    >

    We require supporting developers that have polling models.

    > > + } else {
    > > + cyttsp_info("Setting up interrupt\n");
    > > + /* request_irq() will also call enable_irq() */
    > > + error = request_irq(client->irq, cyttsp_irq,
    > > + IRQF_TRIGGER_FALLING,
    > > + client->dev.driver->name, ts);
    >
    > Please use request_threaded_irq(...) with IRQF_ONESHOT flag.
    >

    Done in new code.

    > > + if (error) {
    > > + cyttsp_alert("error: could not request irq\n");
    > > + retval = error;
    > > + goto error_free_irq;
    > > + }
    > > + }
    > > +
    > > + irq_cnt = 0;
    > > + irq_cnt_total = 0;
    > > + irq_err_cnt = 0;
    > > +
    > > + atomic_set(&ts->irq_enabled, 1);
    > > + retval = device_create_file(&ts->client->dev,
    > &dev_attr_irq_enable);
    > > + if (retval < CY_OK) {
    > > + cyttsp_alert("File device creation failed: %d\n",
    retval);
    > > + retval = -ENODEV;
    > > + goto error_free_irq;
    > > + }
    > > +
    > > + cyttsp_info("%s: Successful registration\n", CY_I2C_NAME);
    > > + goto success;
    > > +
    > > +error_free_irq:
    > > + cyttsp_alert("Error: Failed to register IRQ handler\n");
    > > + free_irq(client->irq, ts);
    > > +
    > > +error_free_device:
    > > + if (input_device)
    > > + input_free_device(input_device);
    > > +
    > > +success:
    > > + return retval;
    > > +}
    > > +
    > > +/* I2C driver probe function */
    > > +static int __devinit cyttsp_probe(struct i2c_client *client,
    > > + const struct i2c_device_id *id)
    > > +{
    > > + struct cyttsp *ts;
    > > + int error;
    > > + int retval = CY_OK;
    >
    > Please don't define your own error return codes. Use appropriate one
    > from the kernel like say -EINVAL etc.,
    >

    Error code defines eliminated.

    > > +
    > > + cyttsp_info("Start Probe 1.2\n");
    >
    > Please remove such debug statements. They are of no use.
    >

    Custom debug statements removed. New code uses printk() calls.

    > I don't see call to i2c_check_functionality(...)
    >

    Added in new code.

    > > +
    > > + /* allocate and clear memory */
    > > + ts = kzalloc(sizeof(struct cyttsp), GFP_KERNEL);
    > > + if (ts == NULL) {
    > > + cyttsp_xdebug1("err kzalloc for cyttsp\n");
    >
    > Please use dev_dbg or pr_debug provided by kernel only. This comment
    > applies to whole driver.
    > We don't need driver specific macros please.
    >

    New code uses printk() calls.

    > > + retval = -ENOMEM;
    > > + }
    > > +
    > > + if (!(retval < CY_OK)) {
    > > + /* register driver_data */
    > > + ts->client = client;
    > > + ts->platform_data = client->dev.platform_data;
    > > + i2c_set_clientdata(client, ts);
    > > +
    > > + error = cyttsp_initialize(client, ts);
    > > + if (error) {
    > > + cyttsp_xdebug1("err cyttsp_initialize\n");
    > > + if (ts != NULL) {
    > > + /* deallocate memory */
    > > + kfree(ts);
    > > + }
    > > +/*
    > > + i2c_del_driver(&cyttsp_driver);
    > > +*/
    >
    > Do you need this commented out code?
    >

    New code has no commented out code.

    > > + retval = -ENODEV;
    > > + } else
    > > + cyttsp_openlog();
    > > + }
    > > +
    > > +#ifdef CONFIG_HAS_EARLYSUSPEND
    > > + if (!(retval < CY_OK)) {
    > > + ts->early_suspend.level =
    EARLY_SUSPEND_LEVEL_BLANK_SCREEN
    > + 1;
    > > + ts->early_suspend.suspend = cyttsp_early_suspend;
    > > + ts->early_suspend.resume = cyttsp_late_resume;
    > > + register_early_suspend(&ts->early_suspend);
    > > + }
    > > +#endif /* CONFIG_HAS_EARLYSUSPEND */
    >
    > As mentioned above I want all the early suspend code to be removed.
    > Explore RunTime PM framework of the kernel.
    >

    Done.

    > > +
    > > + cyttsp_info("Start Probe %s\n", \
    > > + (retval < CY_OK) ? "FAIL" : "PASS");
    > > +
    > > + return retval;
    > > +}
    > > +
    > > +/* Function to manage power-on resume */
    > > +static int cyttsp_resume(struct i2c_client *client)
    > > +{
    > > + struct cyttsp *ts;
    > > + int retval = CY_OK;
    > > +
    > > + cyttsp_debug("Wake Up\n");
    > > + ts = (struct cyttsp *) i2c_get_clientdata(client);
    >
    > No need of casting.
    >

    Fixed.

    > > +
    > > + /* re-enable the interrupt prior to wake device */
    > > + if (ts->client->irq)
    > > + enable_irq(ts->client->irq);
    > > +
    > > + if (ts->platform_data->use_sleep &&
    > > + (ts->platform_data->power_state != CY_ACTIVE_STATE)) {
    > > + if (ts->platform_data->resume)
    > > + retval = ts->platform_data->resume(client);
    > > + if (!(retval < CY_OK)) {
    > > + retval =
    i2c_smbus_read_i2c_block_data(ts->client,
    > > + CY_REG_BASE,
    > > + sizeof(struct cyttsp_bootloader_data_t),
    > > + (u8 *)&g_bl_data);
    > > + if (!(retval < CY_OK) &&
    > > + GET_BOOTLOADERMODE(g_bl_data.bl_status))
    {
    > > + u8 tries;
    > > + retval = i2c_smbus_write_i2c_block_data(
    > > + ts->client,
    > > + CY_REG_BASE,
    > > + sizeof(bl_cmd), bl_cmd);
    > > + /* switch back to operational mode */
    > > + tries = 0;
    > > + mdelay(10);
    > > + while
    (GET_BOOTLOADERMODE(g_bl_data.bl_status)
    > > + && tries++ < 10) {
    > > + mdelay(100);
    >
    > Do you really need to use mdelay(...) in the resume path? Is there any
    > way you could use msleep(..)
    > or say no delay at all.
    >

    Replaced all mdelay with msleep in new code.

    > > + cyttsp_putbl(ts, 16,
    > > + false, false, false);
    > > + }
    > > + }
    > > + }
    > > + }
    > > +
    > > + if (!(retval < CY_OK) &&
    > > + (GET_HSTMODE(g_bl_data.bl_file) == CY_OK)) {
    > > + ts->platform_data->power_state = CY_ACTIVE_STATE;
    > > +
    > > + /* re-enable the timer after resuming */
    > > + if (ts->client->irq == 0)
    > > + mod_timer(&ts->timer, jiffies +
    TOUCHSCREEN_TIMEOUT);
    > > + } else
    > > + retval = -ENODEV;
    > > +
    > > + cyttsp_debug("Wake Up %s\n", \
    > > + (retval < CY_OK) ? "FAIL" : "PASS");
    > > +
    > > + return retval;
    > > +}
    > > +
    > > +
    > > +/* Function to manage low power suspend */
    > > +static int cyttsp_suspend(struct i2c_client *client, pm_message_t
    > message)
    >
    > Please put #ifdef CONFIG_PM around suspend/resume functions.
    >

    Done.

    > > +{
    > > + struct cyttsp *ts;
    > > + u8 sleep_mode = CY_OK;
    > > + int retval = CY_OK;
    > > +
    > > + cyttsp_debug("Enter Sleep\n");
    > > + ts = (struct cyttsp *) i2c_get_clientdata(client);
    >
    > Casting from void * is not required. Please remove.
    >

    Done.

    > > +
    > > + /* disable worker */
    > > + if (ts->client->irq == 0)
    > > + del_timer(&ts->timer);
    > > + else
    > > + disable_irq_nosync(ts->client->irq);
    > > + retval = cancel_work_sync(&ts->work);
    > > +
    > > + if (retval)
    > > + enable_irq(ts->client->irq);
    > > +
    > > + if (!(retval < CY_OK)) {
    > > + if (ts->platform_data->use_sleep &&
    > > + (ts->platform_data->power_state ==
    CY_ACTIVE_STATE))
    > {
    > > + if (ts->platform_data->use_sleep &
    > CY_USE_DEEP_SLEEP_SEL)
    > > + sleep_mode = CY_DEEP_SLEEP_MODE;
    > > + else
    > > + sleep_mode = CY_LOW_PWR_MODE;
    > > +
    > > + retval =
    i2c_smbus_write_i2c_block_data(ts->client,
    > > + CY_REG_BASE,
    > > + sizeof(sleep_mode), &sleep_mode);
    > > + }
    > > + }
    > > +
    > > + if (!(retval < CY_OK)) {
    > > + if (sleep_mode == CY_DEEP_SLEEP_MODE)
    > > + ts->platform_data->power_state = CY_SLEEP_STATE;
    > > + else if (sleep_mode == CY_LOW_PWR_MODE)
    > > + ts->platform_data->power_state =
    CY_LOW_PWR_STATE;
    > > + }
    > > +
    > > + cyttsp_debug("Sleep Power state is %s\n", \
    > > + (ts->platform_data->power_state == CY_ACTIVE_STATE) ? \
    > > + "ACTIVE" : \
    > > + ((ts->platform_data->power_state == CY_SLEEP_STATE) ? \
    > > + "SLEEP" : "LOW POWER"));
    > > +
    > > + return retval;
    > > +}
    > > +
    > > +/* registered in driver struct */
    > > +static int __devexit cyttsp_remove(struct i2c_client *client)
    > > +{
    > > + struct cyttsp *ts;
    > > + int err;
    > > +
    > > + cyttsp_alert("Unregister\n");
    > > +
    > > + /* clientdata registered on probe */
    > > + ts = i2c_get_clientdata(client);
    > > + device_remove_file(&ts->client->dev, &dev_attr_irq_enable);
    > > +
    > > + /* Start cleaning up by removing any delayed work and the timer
    > */
    > > + if (cancel_delayed_work((struct delayed_work *)&ts->work) <
    > CY_OK)
    > > + cyttsp_alert("error: could not remove work from
    > workqueue\n");
    > > +
    > > + /* free up timer or irq */
    > > + if (ts->client->irq == 0) {
    > > + err = del_timer(&ts->timer);
    > > + if (err < CY_OK)
    > > + cyttsp_alert("error: failed to delete timer\n");
    > > + } else
    > > + free_irq(client->irq, ts);
    > > +
    > > +#ifdef CONFIG_HAS_EARLYSUSPEND
    > > + unregister_early_suspend(&ts->early_suspend);
    > > +#endif /* CONFIG_HAS_EARLYSUSPEND */
    > > +
    > > + /* housekeeping */
    > > + if (ts != NULL)
    > > + kfree(ts);
    > > +
    > > + cyttsp_alert("Leaving\n");
    >
    > I don't removal of input_dev structures.
    >

    New code has removal code.

    > > +
    > > + return 0;
    > > +}
    > > +
    > > +#ifdef CONFIG_HAS_EARLYSUSPEND
    > > +static void cyttsp_early_suspend(struct early_suspend *handler)
    > > +{
    > > + struct cyttsp *ts;
    > > +
    > > + ts = container_of(handler, struct cyttsp, early_suspend);
    > > + cyttsp_suspend(ts->client, PMSG_SUSPEND);
    > > +}
    > > +
    > > +static void cyttsp_late_resume(struct early_suspend *handler)
    > > +{
    > > + struct cyttsp *ts;
    > > +
    > > + ts = container_of(handler, struct cyttsp, early_suspend);
    > > + cyttsp_resume(ts->client);
    > > +}
    > > +#endif /* CONFIG_HAS_EARLYSUSPEND */
    > > +
    > > +static int cyttsp_init(void)
    > > +{
    >
    > __init
    >

    Module_init() used in new code.

    > > + int ret;
    > > +
    > > + cyttsp_info("Cypress TrueTouch(R) Standard Product\n");
    > > + cyttsp_info("I2C Touchscreen Driver (Built %s @ %s)\n", \
    > > + __DATE__, __TIME__);
    > > +
    > > + cyttsp_ts_wq = create_singlethread_workqueue("cyttsp_ts_wq");
    > > + if (cyttsp_ts_wq == NULL) {
    > > + cyttsp_debug("No memory for cyttsp_ts_wq\n");
    > > + return -ENOMEM;
    > > + }
    > > +
    > > + ret = i2c_add_driver(&cyttsp_driver);
    > > +
    > > + return ret;
    > > +}
    > > +
    > > +static void cyttsp_exit(void)
    > > +{
    >
    > __exit
    >

    Module_exit() used in new code.

    > > + if (cyttsp_ts_wq)
    > > + destroy_workqueue(cyttsp_ts_wq);
    > > + return i2c_del_driver(&cyttsp_driver);
    > > +}
    > > +
    > > +module_init(cyttsp_init);
    > > +module_exit(cyttsp_exit);
    > > +
    > > diff --git a/include/linux/cyttsp.h b/include/linux/cyttsp.h
    > > new file mode 100644
    > > index 0000000..2ab1a5c
    > > --- /dev/null
    > > +++ b/include/linux/cyttsp.h
    > > @@ -0,0 +1,649 @@
    > > +/* Header file for:
    > > + * Cypress TrueTouch(TM) Standard Product touchscreen drivers.
    > > + * include/linux/cyttsp.h

    > No file paths please.
    >

    Removed in new code.

    > > + *
    > > + * Copyright (C) 2009, 2010 Cypress Semiconductor, Inc.
    > > + *
    > > + * This program is free software; you can redistribute it and/or
    > > + * modify it under the terms of the GNU General Public License
    > > + * version 2, and only version 2, as published by the
    > > + * Free Software Foundation.
    > > + *
    > > + * 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.
    > > + *
    > > + * You should have received a copy of the GNU General Public
    License
    > along
    > > + * with this program; if not, write to the Free Software
    Foundation,
    > Inc.,
    > > + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
    > > + *
    > > + * Cypress reserves the right to make changes without further
    notice
    > > + * to the materials described herein. Cypress does not assume any
    > > + * liability arising out of the application described herein.
    > > + *
    > > + * Contact Cypress Semiconductor at www.cypress.com
    > > + *
    > > + */
    > > +
    > > +
    > > +#ifndef __CYTTSP_H__
    > > +#define __CYTTSP_H__
    > > +
    > > +#include <linux/input.h>
    > > +#include <linux/timer.h>
    > > +#include <linux/workqueue.h>
    > > +#include <linux/kernel.h>
    > > +#include <linux/delay.h>
    > > +
    > > +#define CYPRESS_TTSP_NAME "cyttsp"
    > > +#define CY_I2C_NAME "cyttsp-i2c"
    > > +#define CY_SPI_NAME "cyttsp-spi"
    >
    > I don't think that driver could be easily converted to fit with "spi",
    > as I see i2c calls all over.
    >

    New refactored code has extracted common code into a core file and added
    special I2C only and SPI only files.

    > > +
    > > +#ifdef CY_DECLARE_GLOBALS
    > > + uint32_t cyttsp_tsdebug;
    > > + module_param_named(tsdebug, cyttsp_tsdebug, uint, 0664);
    > > + uint32_t cyttsp_tsxdebug;
    > > + module_param_named(tsxdebug, cyttsp_tsxdebug, uint, 0664);
    > > +
    > > + uint32_t cyttsp_disable_touch;
    > > + module_param_named(disable_touch, cyttsp_disable_touch, uint,
    > 0664);
    > > +#else
    > > + extern uint32_t cyttsp_tsdebug;
    > > + extern uint32_t cyttsp_tsxdebug;
    > > + extern uint32_t cyttsp_disable_touch;
    > > +#endif
    > > +
    > > +
    > > +
    > >
    >
    +/*********************************************************************
    > *********
    > > + * Global Control, Used to control the behavior of the driver
    > > + */
    > > +
    > > +/* defines for Gen2 (Txx2xx); Gen3 (Txx3xx)
    > > + * use these defines to set cyttsp_platform_data.gen in board
    config
    > file
    > > + */
    > > +#define CY_GEN2 2
    > > +#define CY_GEN3 3
    > > +
    > > +/* define for using I2C driver
    > > + */
    > > +#define CY_USE_I2C_DRIVER
    > > +
    > > +/* defines for using SPI driver */
    > > +/*
    > > +#define CY_USE_SPI_DRIVER
    > > + */
    > > +#define CY_SPI_DFLT_SPEED_HZ 1000000
    > > +#define CY_SPI_MAX_SPEED_HZ 4000000
    > > +#define CY_SPI_SPEED_HZ CY_SPI_DFLT_SPEED_HZ
    > > +#define CY_SPI_BITS_PER_WORD 8
    > > +#define CY_SPI_DAV 139 /* set correct gpio id
    */
    > > +#define CY_SPI_BUFSIZE 512

    >
    > No need of these #defines unless we see driver for SPI.
    >

    New code has SPI defines only in SPI file.

    > > +
    > > +
    > > +/* define for inclusion of TTSP App Update Load File
    > > + * use this define if update to the TTSP Device is desired
    > > + */
    > > +/*
    > > +#define CY_INCLUDE_LOAD_FILE
    > > +*/
    > > +
    > > +/* define if force new load file for bootloader load */
    > > +/*
    > > +#define CY_FORCE_FW_UPDATE
    > > +*/
    > > +
    > > +/* undef for production use */
    > > +/*
    > > + */
    > > +#define CY_USE_DEBUG
    >
    > As indicated please use kernel dev_dbg/dev_xxx and pr_debug/pr_xxx
    > friends.
    >

    New code only uses printk() calls.

    > > +
    > > +/* undef for irq use; use this define in the board configuration
    > file */
    > > +/*
    > > +#define CY_USE_TIMER
    > > + */
    >
    > As indicated above polling mode should be removed.
    >

    Retained to support developers using polling platform models.

    > > +
    > > +/* undef to allow use of extra debug capability */
    > > +/*
    > > +#define CY_ALLOW_EXTRA_DEBUG
    > > +*/
    > > +
    > > +/* undef to remove additional debug prints */
    > > +/*
    > > +#define CY_USE_EXTRA_DEBUG
    > > +*/
    > > +
    > > +/* undef to remove additional debug prints */
    > > +/*
    > > +#define CY_USE_EXTRA_DEBUG1
    > > + */
    > > +
    > > +/* undef to use operational touch timer jiffies; else use test
    > jiffies */
    > > +/*
    > > +#define CY_USE_TIMER_DEBUG
    > > + */
    > > +
    > > +/* define to use canned test data */
    > > +/*
    > > +#define CY_USE_TEST_DATA
    > > + */
    > > +
    > > +/* define to activate power management */
    > > +/*
    > > +#define CY_USE_LOW_POWER
    > > + */
    >
    > Please see if you can use RunTime PM apis for LPM.
    >

    Suspend/resume code simplified in new code.

    > > +
    > > +/* define if wake on i2c addr is activated */
    > > +/*
    > > +#define CY_USE_DEEP_SLEEP
    > > + */
    > > +
    > > +/* define if gesture signaling is used
    > > + * and which gesture groups to use
    > > + */
    > > +/*
    > > +#define CY_USE_GEST
    > > +#define CY_USE_GEST_GRP1
    > > +#define CY_USE_GEST_GRP2
    > > +#define CY_USE_GEST_GRP3
    > > +#define CY_USE_GEST_GRP4
    > > + */
    > > +/* Active distance in pixels for a gesture to be reported
    > > + * if set to 0, then all gesture movements are reported
    > > + */
    > > +#define CY_ACT_DIST_DFLT 8
    > > +#define CY_ACT_DIST CY_ACT_DIST_DFLT
    > > +
    > > +/* define if MT signals are desired */
    > > +/*
    > > +*/
    > > +#define CY_USE_MT_SIGNALS
    > > +
    > > +/* define if MT tracking id signals are used */
    > > +/*
    > > +#define CY_USE_MT_TRACK_ID
    > > + */
    > > +
    > > +/* define if ST signals are required */
    > > +/*
    > > +#define CY_USE_ST_SIGNALS
    > > +*/
    > > +
    > > +/* define to send handshake to device */
    > > +/*
    > > +#define CY_USE_HNDSHK
    > > +*/
    > > +
    > > +/* define if log all raw motion signals to a sysfs file */
    > > +/*
    > > +#define CY_LOG_TO_FILE
    > > +*/
    > > +
    > > +
    > > +/* End of the Global Control section
    > > +
    >
    ***********************************************************************
    > *******
    > > + */
    > > +#define CY_DIFF(m, n) ((m) != (n))
    > > +
    > > +#ifdef CY_LOG_TO_FILE
    > > + #define cyttsp_openlog() /* use sysfs */
    > > +#else
    > > + #define cyttsp_openlog()
    > > +#endif /* CY_LOG_TO_FILE */
    > > +
    > > +/* see kernel.h for pr_xxx def'ns */
    > > +#define cyttsp_info(f, a...) pr_info("%s:" f,
    __func__ ,
    > ## a)
    > > +#define cyttsp_error(f, a...) pr_err("%s:" f,
    __func__ ,
    > ## a)
    > > +#define cyttsp_alert(f, a...) pr_alert("%s:" f,
    __func__ ,
    > ## a)
    > > +
    > > +#ifdef CY_USE_DEBUG
    > > + #define cyttsp_debug(f, a...) pr_alert("%s:" f, __func__ , ##
    a)
    > > +#else
    > > + #define cyttsp_debug(f, a...) {if (cyttsp_tsdebug) \
    > > + pr_alert("%s:" f, __func__ , ##
    a); }
    > > +#endif /* CY_USE_DEBUG */
    > > +
    > > +#ifdef CY_ALLOW_EXTRA_DEBUG
    > > +#ifdef CY_USE_EXTRA_DEBUG
    > > + #define cyttsp_xdebug(f, a...) pr_alert("%s:" f, __func__ ,
    > ## a)
    > > +#else
    > > + #define cyttsp_xdebug(f, a...) {if (cyttsp_tsxdebug) \
    > > + pr_alert("%s:" f, __func__ , ##
    a); }
    > > +#endif /* CY_USE_EXTRA_DEBUG */
    > > +
    > > +#ifdef CY_USE_EXTRA_DEBUG1
    > > + #define cyttsp_xdebug1(f, a...) pr_alert("%s:" f, __func__ ,
    > ## a)
    > > +#else
    > > + #define cyttsp_xdebug1(f, a...)
    > > +#endif /* CY_USE_EXTRA_DEBUG1 */
    > > +#else
    > > + #define cyttsp_xdebug(f, a...)
    > > + #define cyttsp_xdebug1(f, a...)
    > > +#endif /* CY_ALLOW_EXTRA_DEBUG */

    > Please remove customized debugs.
    >

    Done in new code.

    > > +
    > > +#ifdef CY_USE_TIMER_DEBUG
    > > + #define TOUCHSCREEN_TIMEOUT (msecs_to_jiffies(1000))
    > > +#else
    > > + #define TOUCHSCREEN_TIMEOUT (msecs_to_jiffies(28))
    > > +#endif
    > > +
    >
    >
    >
    > > +/* reduce extra signals in MT only build
    > > + * be careful not to lose backward compatibility for pre-MT apps
    > > + */
    > > +#ifdef CY_USE_ST_SIGNALS
    > > + #define CY_USE_ST 1
    > > +#else
    > > + #define CY_USE_ST 0
    > > +#endif /* CY_USE_ST_SIGNALS */
    > > +
    > > +/* rely on kernel input.h to define Multi-Touch capability */
    > > +/* if input.h defines the Multi-Touch signals, then use MT */
    > > +#if defined(ABS_MT_TOUCH_MAJOR) && defined(CY_USE_MT_SIGNALS)
    > > + #define CY_USE_MT 1
    > > + #define CY_MT_SYNC(input) input_mt_sync(input)
    > > +#else
    >
    > I don't think we need such hacks, as latest kernel supports MT.
    >

    Hacks removed from driver code.

    > > + #define CY_USE_MT 0
    > > + #define CY_MT_SYNC(input)
    > > + /* the following includes are provided to ensure a compile;
    > > + * the code that compiles with these defines will not be
    executed
    > if
    > > + * the CY_USE_MT is properly used in the platform structure init
    > > + */
    > > + #ifndef ABS_MT_TOUCH_MAJOR
    > > + #define ABS_MT_TOUCH_MAJOR 0x30 /* touching ellipse */
    > > + #define ABS_MT_TOUCH_MINOR 0x31 /* (omit if circular) */
    > > + #define ABS_MT_WIDTH_MAJOR 0x32 /* approaching ellipse
    */
    > > + #define ABS_MT_WIDTH_MINOR 0x33 /* (omit if circular) */
    > > + #define ABS_MT_ORIENTATION 0x34 /* Ellipse orientation
    */
    > > + #define ABS_MT_POSITION_X 0x35 /* Center X ellipse
    position
    > */
    > > + #define ABS_MT_POSITION_Y 0x36 /* Center Y ellipse
    position
    > */
    > > + #define ABS_MT_TOOL_TYPE 0x37 /* Type of touching
    device */
    > > + #define ABS_MT_BLOB_ID 0x38 /* Group set of pkts as
    blob
    > */
    > > + #endif /* ABS_MT_TOUCH_MAJOR */
    > > +#endif /* ABS_MT_TOUCH_MAJOR and CY_USE_MT_SIGNALS */
    > > +#if defined(ABS_MT_TRACKING_ID) && defined(CY_USE_MT_TRACK_ID)
    > > + #define CY_USE_TRACKING_ID 1
    > > +#else
    > > + #define CY_USE_TRACKING_ID 0
    > > +/* define only if not defined already by system;
    > > + * value based on linux kernel 2.6.30.10
    > > + */
    > > +#ifndef ABS_MT_TRACKING_ID
    > > + #define ABS_MT_TRACKING_ID (ABS_MT_BLOB_ID+1)
    > > +#endif
    > > +#endif /* ABS_MT_TRACKING_ID */
    > > +
    > > +#ifdef CY_USE_DEEP_SLEEP
    > > + #define CY_USE_DEEP_SLEEP_SEL 0x80
    > > +#else
    > > + #define CY_USE_DEEP_SLEEP_SEL 0x00
    > > +#endif
    > > +#ifdef CY_USE_LOW_POWER
    > > + #define CY_USE_SLEEP (CY_USE_DEEP_SLEEP_SEL | 0x01)
    > > +#else
    > > + #define CY_USE_SLEEP 0x00
    > > +#endif /* CY_USE_LOW_POWER */
    > > +
    > > +#ifdef CY_USE_TEST_DATA
    > > + #define cyttsp_testdat(ray1, ray2, sizeofray) \
    > > + { \
    > > + int i; \
    > > + u8 *up1 = (u8 *)ray1; \
    > > + u8 *up2 = (u8 *)ray2; \
    > > + for (i = 0; i < sizeofray; i++) { \
    > > + up1[i] = up2[i]; \
    > > + } \
    > > + }
    > > +#else
    > > + #define cyttsp_testdat(xy, test_xy, sizeofray)
    > > +#endif /* CY_USE_TEST_DATA */
    > > +
    > > +/* helper macros */
    > > +#define GET_NUM_TOUCHES(x) ((x) & 0x0F)
    > > +#define GET_TOUCH1_ID(x) (((x) & 0xF0) >> 4)
    > > +#define GET_TOUCH2_ID(x) ((x) & 0x0F)
    > > +#define GET_TOUCH3_ID(x) (((x) & 0xF0) >> 4)
    > > +#define GET_TOUCH4_ID(x) ((x) & 0x0F)
    > > +#define IS_LARGE_AREA(x) (((x) & 0x10) >> 4)
    > > +#define FLIP_DATA_FLAG 0x01
    > > +#define REVERSE_X_FLAG 0x02
    > > +#define REVERSE_Y_FLAG 0x04
    > > +#define FLIP_DATA(flags) ((flags) & FLIP_DATA_FLAG)
    > > +#define REVERSE_X(flags) ((flags) & REVERSE_X_FLAG)
    > > +#define REVERSE_Y(flags) ((flags) & REVERSE_Y_FLAG)
    > > +#define FLIP_XY(x, y) { \
    > > + u16 tmp; \
    > > + tmp = (x); \
    > > + (x) = (y); \
    > > + (y) = tmp; \
    > > + }
    > > +#define INVERT_X(x, xmax) ((xmax) - (x))
    > > +#define INVERT_Y(y, ymax) ((ymax) - (y))
    > > +#define SET_HSTMODE(reg, mode) ((reg) & (mode))
    > > +#define GET_HSTMODE(reg) ((reg & 0x70) >> 4)
    > > +#define GET_BOOTLOADERMODE(reg) ((reg & 0x10) >> 4)
    > > +
    > > +/* constant definitions */
    > > +/* maximum number of concurrent ST track IDs */
    > > +#define CY_NUM_ST_TCH_ID 2
    > > +
    > > +/* maximum number of concurrent MT track IDs */
    > > +#define CY_NUM_MT_TCH_ID 4
    > > +
    > > +/* maximum number of track IDs */
    > > +#define CY_NUM_TRK_ID 16
    > > +
    > > +#define CY_NTCH 0 /* no touch
    (lift off)
    > */
    > > +#define CY_TCH 1 /* active touch
    (touchdown)
    > */
    > > +#define CY_ST_FNGR1_IDX 0
    > > +#define CY_ST_FNGR2_IDX 1
    > > +#define CY_MT_TCH1_IDX 0
    > > +#define CY_MT_TCH2_IDX 1
    > > +#define CY_MT_TCH3_IDX 2
    > > +#define CY_MT_TCH4_IDX 3
    > > +#define CY_XPOS 0
    > > +#define CY_YPOS 1
    > > +#define CY_IGNR_TCH (-1)
    > > +#define CY_SMALL_TOOL_WIDTH 10
    > > +#define CY_LARGE_TOOL_WIDTH 255
    > > +#define CY_REG_BASE 0x00
    > > +#define CY_REG_GEST_SET 0x1E
    > > +#define CY_REG_ACT_INTRVL 0x1D
    > > +#define CY_REG_TCH_TMOUT (CY_REG_ACT_INTRVL+1)
    > > +#define CY_REG_LP_INTRVL (CY_REG_TCH_TMOUT+1)
    > > +#define CY_SOFT_RESET ((1 << 0))
    > > +#define CY_DEEP_SLEEP ((1 << 1))
    > > +#define CY_LOW_POWER ((1 << 2))
    > > +#define CY_MAXZ 255
    > > +#define CY_OK 0
    > > +#define CY_INIT 1
    > > +#define CY_DLY_DFLT 10 /* ms */
    > > +#define CY_DLY_SYSINFO 20 /* ms */
    > > +#define CY_DLY_BL 300
    > > +#define CY_DLY_DNLOAD 100 /* ms */
    > > +#define CY_NUM_RETRY 4 /* max num touch
    data read */
    > > +
    > > +/* handshake bit in the hst_mode reg */
    > > +#define CY_HNDSHK_BIT 0x80
    > > +#ifdef CY_USE_HNDSHK
    > > + #define CY_SEND_HNDSHK 1
    > > +#else
    > > + #define CY_SEND_HNDSHK 0
    > > +#endif
    > > +
    > > +/* Bootloader File 0 offset */
    > > +#define CY_BL_FILE0 0x00
    > > +
    > > +/* Bootloader command directive */
    > > +#define CY_BL_CMD 0xFF
    > > +
    > > +/* Bootloader Initiate Bootload */
    > > +#define CY_BL_INIT_LOAD 0x38
    > > +
    > > +/* Bootloader Write a Block */
    > > +#define CY_BL_WRITE_BLK 0x39
    > > +
    > > +/* Bootloader Terminate Bootload */
    > > +#define CY_BL_TERMINATE 0x3B
    > > +
    > > +/* Bootloader Exit and Verify Checksum command */
    > > +#define CY_BL_EXIT 0xA5
    > > +
    > > +/* Bootloader default keys */
    > > +#define CY_BL_KEY0 0x00
    > > +#define CY_BL_KEY1 0x01
    > > +#define CY_BL_KEY2 0x02
    > > +#define CY_BL_KEY3 0x03
    > > +#define CY_BL_KEY4 0x04
    > > +#define CY_BL_KEY5 0x05
    > > +#define CY_BL_KEY6 0x06
    > > +#define CY_BL_KEY7 0x07
    > > +
    > > +/* Active Power state scanning/processing refresh interval */
    > > +#define CY_ACT_INTRVL_DFLT 0x00
    > > +
    > > +/* touch timeout for the Active power */
    > > +#define CY_TCH_TMOUT_DFLT 0xFF
    > > +
    > > +/* Low Power state scanning/processing refresh interval */
    > > +#define CY_LP_INTRVL_DFLT 0x0A
    > > +
    > > +#define CY_IDLE_STATE 0
    > > +#define CY_ACTIVE_STATE 1
    > > +#define CY_LOW_PWR_STATE 2
    > > +#define CY_SLEEP_STATE 3
    > > +
    > > +/* device mode bits */
    > > +#define CY_OP_MODE 0x00
    > > +#define CY_SYSINFO_MODE 0x10
    > > +
    > > +/* power mode select bits */
    > > +#define CY_SOFT_RESET_MODE 0x01 /* return to Bootloader
    mode
    > */
    > > +#define CY_DEEP_SLEEP_MODE 0x02
    > > +#define CY_LOW_PWR_MODE 0x04
    > > +
    > > +#define CY_NUM_KEY 8
    > > +
    > > +#ifdef CY_USE_GEST
    > > + #define CY_USE_GESTURES 1
    > > +#else
    > > + #define CY_USE_GESTURES 0
    > > +#endif /* CY_USE_GESTURE_SIGNALS */
    > > +
    > > +#ifdef CY_USE_GEST_GRP1
    > > + #define CY_GEST_GRP1 0x10
    > > +#else
    > > + #define CY_GEST_GRP1 0x00
    > > +#endif /* CY_USE_GEST_GRP1 */
    > > +#ifdef CY_USE_GEST_GRP2
    > > + #define CY_GEST_GRP2 0x20
    > > +#else
    > > + #define CY_GEST_GRP2 0x00
    > > +#endif /* CY_USE_GEST_GRP2 */
    > > +#ifdef CY_USE_GEST_GRP3
    > > + #define CY_GEST_GRP3 0x40
    > > +#else
    > > + #define CY_GEST_GRP3 0x00
    > > +#endif /* CY_USE_GEST_GRP3 */
    > > +#ifdef CY_USE_GEST_GRP4
    > > + #define CY_GEST_GRP4 0x80
    > > +#else
    > > + #define CY_GEST_GRP4 0x00
    > > +#endif /* CY_USE_GEST_GRP4 */
    > > +
    > > +
    > > +struct cyttsp_platform_data {
    > > + u32 maxx;
    > > + u32 maxy;
    > > + u32 flags;
    > > + u8 gen;
    > > + u8 use_st;
    > > + u8 use_mt;
    > > + u8 use_hndshk;
    > > + u8 use_trk_id;
    > > + u8 use_sleep;
    > > + u8 use_gestures;
    > > + u8 gest_set;
    > > + u8 act_intrvl;
    > > + u8 tch_tmout;
    > > + u8 lp_intrvl;
    > > + u8 power_state;
    > > +#ifdef CY_USE_I2C_DRIVER
    > > + s32 (*init)(struct i2c_client *client);
    > > + s32 (*resume)(struct i2c_client *client);
    > > +#endif
    > > +#ifdef CY_USE_SPI_DRIVER
    > > + s32 (*init)(struct spi_device *spi);
    > > + s32 (*resume)(struct spi_device *spi);
    > > +#endif
    > > +};
    > > +
    > > +/* TrueTouch Standard Product Gen3 (Txx3xx) interface definition */
    > > +struct cyttsp_gen3_xydata_t {
    > > + u8 hst_mode;
    > > + u8 tt_mode;
    > > + u8 tt_stat;
    > > + u16 x1 __attribute__ ((packed));
    > > + u16 y1 __attribute__ ((packed));
    > > + u8 z1;
    > > + u8 touch12_id;
    > > + u16 x2 __attribute__ ((packed));
    > > + u16 y2 __attribute__ ((packed));
    > > + u8 z2;
    > > + u8 gest_cnt;
    > > + u8 gest_id;
    > > + u16 x3 __attribute__ ((packed));
    > > + u16 y3 __attribute__ ((packed));
    > > + u8 z3;
    > > + u8 touch34_id;
    > > + u16 x4 __attribute__ ((packed));
    > > + u16 y4 __attribute__ ((packed));
    > > + u8 z4;
    > > + u8 tt_undef[3];
    > > + u8 gest_set;
    > > + u8 tt_reserved;
    > > +};
    >
    > Do you really need this to be exported in the header file? If possible
    > move it to the .c file.
    >

    This has been done in the new refactored code.

    > > +
    > > +/* TrueTouch Standard Product Gen2 (Txx2xx) interface definition */
    > > +#define CY_GEN2_NOTOUCH 0x03 /* Both touches removed
    */
    > > +#define CY_GEN2_GHOST 0x02 /* ghost */
    > > +#define CY_GEN2_2TOUCH 0x03 /* 2 touch; no ghost */
    > > +#define CY_GEN2_1TOUCH 0x01 /* 1 touch only */
    > > +#define CY_GEN2_TOUCH2 0x01 /* 1st touch removed;
    > > + * 2nd touch remains */
    > > +struct cyttsp_gen2_xydata_t {
    > > + u8 hst_mode;
    > > + u8 tt_mode;
    > > + u8 tt_stat;
    > > + u16 x1 __attribute__ ((packed));
    > > + u16 y1 __attribute__ ((packed));
    > > + u8 z1;
    > > + u8 evnt_idx;
    > > + u16 x2 __attribute__ ((packed));
    > > + u16 y2 __attribute__ ((packed));
    > > + u8 tt_undef1;
    > > + u8 gest_cnt;
    > > + u8 gest_id;
    > > + u8 tt_undef[14];
    > > + u8 gest_set;
    > > + u8 tt_reserved;
    > > +};
    > > +
    > > +/* TTSP System Information interface definition */
    > > +struct cyttsp_sysinfo_data_t {
    > > + u8 hst_mode;
    > > + u8 mfg_cmd;
    > > + u8 mfg_stat;
    > > + u8 cid[3];
    > > + u8 tt_undef1;
    > > + u8 uid[8];
    > > + u8 bl_verh;
    > > + u8 bl_verl;
    > > + u8 tts_verh;
    > > + u8 tts_verl;
    > > + u8 app_idh;
    > > + u8 app_idl;
    > > + u8 app_verh;
    > > + u8 app_verl;
    > > + u8 tt_undef[6];
    > > + u8 act_intrvl;
    > > + u8 tch_tmout;
    > > + u8 lp_intrvl;
    > > +};
    >
    > Ditto.
    >
    > > +
    > > +/* TTSP Bootloader Register Map interface definition */
    > > +#define CY_BL_CHKSUM_OK 0x01
    > > +struct cyttsp_bootloader_data_t {
    > > + u8 bl_file;
    > > + u8 bl_status;
    > > + u8 bl_error;
    > > + u8 blver_hi;
    > > + u8 blver_lo;
    > > + u8 bld_blver_hi;
    > > + u8 bld_blver_lo;
    > > + u8 ttspver_hi;
    > > + u8 ttspver_lo;
    > > + u8 appid_hi;
    > > + u8 appid_lo;
    > > + u8 appver_hi;
    > > + u8 appver_lo;
    > > + u8 cid_0;
    > > + u8 cid_1;
    > > + u8 cid_2;
    > > +};
    > > +
    > > +#define cyttsp_wake_data_t cyttsp_gen3_xydata_t
    > > +#ifdef CY_DECLARE_GLOBALS
    > > + #ifdef CY_INCLUDE_LOAD_FILE
    > > + /* this file declares:
    > > + * firmware download block array (cyttsp_fw[]),
    > > + * the number of command block records
    (cyttsp_fw_records),
    > > + * and the version variables
    > > + */
    > > + #include "cyttsp_fw.h" /* imports cyttsp_fw[]
    array
    > */
    > > + #define cyttsp_app_load() 1
    > > + #ifdef CY_FORCE_FW_UPDATE
    > > + #define cyttsp_force_fw_load() 1
    > > + #else
    > > + #define cyttsp_force_fw_load() 0
    > > + #endif
    > > +
    > > + #else
    > > + /* the following declarations are to allow
    > > + * some debugging capability
    > > + */
    > > + unsigned char cyttsp_fw_tts_verh = 0x00;
    > > + unsigned char cyttsp_fw_tts_verl = 0x01;
    > > + unsigned char cyttsp_fw_app_idh = 0x02;
    > > + unsigned char cyttsp_fw_app_idl = 0x03;
    > > + unsigned char cyttsp_fw_app_verh = 0x04;
    > > + unsigned char cyttsp_fw_app_verl = 0x05;
    > > + unsigned char cyttsp_fw_cid_0 = 0x06;
    > > + unsigned char cyttsp_fw_cid_1 = 0x07;
    > > + unsigned char cyttsp_fw_cid_2 = 0x08;
    > > + #define cyttsp_app_load() 0
    > > + #define cyttsp_force_fw_load() 0
    > > + #endif
    > > + #define cyttsp_tts_verh() cyttsp_fw_tts_verh
    > > + #define cyttsp_tts_verl() cyttsp_fw_tts_verl
    > > + #define cyttsp_app_idh() cyttsp_fw_app_idh
    > > + #define cyttsp_app_idl() cyttsp_fw_app_idl
    > > + #define cyttsp_app_verh() cyttsp_fw_app_verh
    > > + #define cyttsp_app_verl() cyttsp_fw_app_verl
    > > + #define cyttsp_cid_0() cyttsp_fw_cid_0
    > > + #define cyttsp_cid_1() cyttsp_fw_cid_1
    > > + #define cyttsp_cid_2() cyttsp_fw_cid_2
    > > + #ifdef CY_USE_TEST_DATA
    > > + static struct cyttsp_gen2_xydata_t tt_gen2_testray[] = {
    > > + {0x00}, {0x00}, {0x04},
    > > + {0x4000}, {0x8000}, {0x80},
    > > + {0x03},
    > > + {0x2000}, {0x1000}, {0x00},
    > > + {0x00},
    > > + {0x00},
    > > + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    > > + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
    > > + {0x00},
    > > + {0x00}
    > > + };
    > > +
    > > + static struct cyttsp_gen3_xydata_t tt_gen3_testray[] = {
    > > + {0x00}, {0x00}, {0x04},
    > > + {0x4000}, {0x8000}, {0x80},
    > > + {0x12},
    > > + {0x2000}, {0x1000}, {0xA0},
    > > + {0x00}, {0x00},
    > > + {0x8000}, {0x4000}, {0xB0},
    > > + {0x34},
    > > + {0x4000}, {0x1000}, {0xC0},
    > > + {0x00, 0x00, 0x00},
    > > + {0x00},
    > > + {0x00}
    > > + };
    > > + #endif /* CY_USE_TEST_DATA */
    > > +
    > > +#else
    > > + extern u8 g_appload_ray[];
    > > +#endif
    > > +
    > > +#endif /* __CYTTSP_H__ */
    >
    > ---Trilok Soni
    >
    >
    > --
    > Sent by a consultant of the Qualcomm Innovation Center, Inc.
    > The Qualcomm Innovation Center, Inc. is a member of the Code Aurora
    > Forum.

    Thank you Trilok for your review.



    ---------------------------------------------------------------
    This message and any attachments may contain Cypress (or its
    subsidiaries) confidential information. If it has been received
    in error, please advise the sender and immediately delete this
    message.
    ---------------------------------------------------------------


    \
     
     \ /
      Last update: 2010-08-04 19:33    [W:0.288 / U:91.996 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site