Hi Trilok, > -----Original Message----- > From: Trilok Soni [mailto:tsoni@xxxxxxxxxxxxxx] > 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@xxxxxxxxxxxxxxx; linux-kernel@xxxxxxxxxxxxxxx; > linux-i2c@xxxxxxxxxxxxxxx; khali@xxxxxxxxxxxx; linux-arm- > msm@xxxxxxxxxxxxxxx > 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@xxxxxxxxxxxxxxxxxxxxxxxxx> > > E-mail id looks wrong. Do you mean fwk@xxxxxxxxxxx? > > > > > 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@xxxxxxxxxxx> > > --- > > 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. --------------------------------------------------------------- -- To unsubscribe from this list: send the line "unsubscribe linux-input" in the body of a message to majordomo@xxxxxxxxxxxxxxx More majordomo info at http://vger.kernel.org/majordomo-info.html
