lkml.org 
[lkml]   [2009]   [Jul]   [13]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    SubjectRe: HTC: touchscreen driver
    From
    On Mon, Jul 13, 2009 at 3:07 PM, Pavel Machek<pavel@ucw.cz> wrote:
    > On Mon 2009-07-13 22:57:49, Pavel Machek wrote:
    >> Hi!
    >>
    >> I'm looking at synaptic touchscreen driver... who should be listed as
    >> an author?
    >>
    >> Changes I have so far are...
    >>
    >> checkpatch only has minor complains -- lines over 80 characters -- but
    >> the code is _way_ too deeply nested with way too little functions.
    >
    > Here's better cleanup. But... some functions are still _way_ too big.
    >
    > Signed-off-by: Pavel Machek <pavel@ucw.cz>
    > diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
    > index 339083e..fa3404f 100644
    > --- a/drivers/input/touchscreen/Kconfig
    > +++ b/drivers/input/touchscreen/Kconfig
    > @@ -94,6 +94,9 @@ config TOUCHSCREEN_GUNZE
    >  config TOUCHSCREEN_ELAN_I2C_8232
    >        tristate "Elan 8232 I2C touchscreen"
    >        depends on I2C
    > +       help
    > +         This enables support for Elan over I2C based touchscreens.
    > +         Such touchscreen is used in HTC Dream.
    >

    Why is this here? This driver is not related to elan touchscreens.

    >  config TOUCHSCREEN_ELO
    >        tristate "Elo serial touchscreens"
    > @@ -215,6 +218,8 @@ config TOUCHSCREEN_SYNAPTICS_I2C_RMI
    >        depends on I2C
    >        help
    >          This enables support for Synaptics RMI over I2C based touchscreens.
    > +         Such touchscreen is used in HTC Dream.
    > +
    >
    >  config TOUCHSCREEN_TOUCHRIGHT
    >        tristate "Touchright serial touchscreen"
    > diff --git a/drivers/input/touchscreen/synaptics_i2c_rmi.c b/drivers/input/touchscreen/synaptics_i2c_rmi.c
    > index a45634b..f582582 100644
    > --- a/drivers/input/touchscreen/synaptics_i2c_rmi.c
    > +++ b/drivers/input/touchscreen/synaptics_i2c_rmi.c
    > @@ -1,4 +1,5 @@
    > -/* drivers/input/keyboard/synaptics_i2c_rmi.c
    > +/*
    > + * Support for synaptics touchscreen.
    >  *
    >  * Copyright (C) 2007 Google, Inc.
    >  *
    > @@ -15,7 +16,6 @@
    >
    >  #include <linux/module.h>
    >  #include <linux/delay.h>
    > -#include <linux/earlysuspend.h>
    >  #include <linux/hrtimer.h>
    >  #include <linux/i2c.h>
    >  #include <linux/input.h>
    > @@ -24,18 +24,16 @@
    >  #include <linux/platform_device.h>
    >  #include <linux/synaptics_i2c_rmi.h>
    >
    > -#define swap(x, y) do { typeof(x) z = x; x = y; y = z; } while (0)
    > -
    >  static struct workqueue_struct *synaptics_wq;
    >
    >  struct synaptics_ts_data {
    > -       uint16_t addr;
    > +       u16 addr;

    What is the point of this change?

    >        struct i2c_client *client;
    >        struct input_dev *input_dev;
    >        int use_irq;
    >        struct hrtimer timer;
    >        struct work_struct  work;
    > -       uint16_t max[2];
    > +       u16 max[2];
    >        int snap_state[2][2];
    >        int snap_down_on[2];
    >        int snap_down_off[2];
    > @@ -43,164 +41,142 @@ struct synaptics_ts_data {
    >        int snap_up_off[2];
    >        int snap_down[2];
    >        int snap_up[2];
    > -       uint32_t flags;
    > +       u32 flags;
    >        int (*power)(int on);
    > -       struct early_suspend early_suspend;
    >  };
    >
    > -#ifdef CONFIG_HAS_EARLYSUSPEND
    > -static void synaptics_ts_early_suspend(struct early_suspend *h);
    > -static void synaptics_ts_late_resume(struct early_suspend *h);
    > -#endif
    > -
    >  static int synaptics_init_panel(struct synaptics_ts_data *ts)
    >  {
    >        int ret;
    >
    > -       ret = i2c_smbus_write_byte_data(ts->client, 0xff, 0x10); /* page select = 0x10 */
    > +       /* page select = 0x10 */
    > +       ret = i2c_smbus_write_byte_data(ts->client, 0xff, 0x10);
    >        if (ret < 0) {
    > -               printk(KERN_ERR "i2c_smbus_write_byte_data failed for page select\n");
    > +               printk(KERN_ERR "smbus write failed for page select\n");
    >                goto err_page_select_failed;
    >        }
    > -       ret = i2c_smbus_write_byte_data(ts->client, 0x41, 0x04); /* Set "No Clip Z" */
    > +
    > +       /* Set "No Clip Z" */
    > +       ret = i2c_smbus_write_byte_data(ts->client, 0x41, 0x04);
    >        if (ret < 0)
    > -               printk(KERN_ERR "i2c_smbus_write_byte_data failed for No Clip Z\n");
    > +               printk(KERN_ERR "smbus write failed for No Clip Z\n");
    >
    >  err_page_select_failed:
    > -       ret = i2c_smbus_write_byte_data(ts->client, 0xff, 0x04); /* page select = 0x04 */
    > +       /* page select = 0x04 */
    > +       ret = i2c_smbus_write_byte_data(ts->client, 0xff, 0x04);
    >        if (ret < 0)
    > -               printk(KERN_ERR "i2c_smbus_write_byte_data failed for page select\n");
    > -       ret = i2c_smbus_write_byte_data(ts->client, 0xf0, 0x81); /* normal operation, 80 reports per second */
    > +               printk(KERN_ERR "smbus write failed for page select\n");
    > +       /* normal operation, 80 reports per second */
    > +       ret = i2c_smbus_write_byte_data(ts->client, 0xf0, 0x81);
    >        if (ret < 0)
    > -               printk(KERN_ERR "synaptics_ts_resume: i2c_smbus_write_byte_data failed\n");
    > +               printk(KERN_ERR "smbus write failed for 80/second\n");
    >        return ret;
    >  }
    >
    > +static void decode_report(struct synaptics_ts_data *ts, u8 *buf)
    > +{
    > +       int pos[2][2];
    > +       int f, a;
    > +       int base = 2;
    > +       int z = buf[1];
    > +       int w = buf[0] >> 4;
    > +       int finger = buf[0] & 7;
    > +       int finger2_pressed;
    > +
    > +       for (f = 0; f < 2; f++) {
    > +               u32 flip_flag = SYNAPTICS_FLIP_X;
    > +               for (a = 0; a < 2; a++) {
    > +                       int p = buf[base + 1];
    > +                       p |= (u16)(buf[base] & 0x1f) << 8;
    > +                       if (ts->flags & flip_flag)
    > +                               p = ts->max[a] - p;
    > +                       if (ts->flags & SYNAPTICS_SNAP_TO_INACTIVE_EDGE) {
    > +                               if (ts->snap_state[f][a]) {
    > +                                       if (p <= ts->snap_down_off[a])
    > +                                               p = ts->snap_down[a];
    > +                                       else if (p >= ts->snap_up_off[a])
    > +                                               p = ts->snap_up[a];
    > +                                       else
    > +                                               ts->snap_state[f][a] = 0;
    > +                               } else {
    > +                                       if (p <= ts->snap_down_on[a]) {
    > +                                               p = ts->snap_down[a];
    > +                                               ts->snap_state[f][a] = 1;
    > +                                       } else if (p >= ts->snap_up_on[a]) {
    > +                                               p = ts->snap_up[a];
    > +                                               ts->snap_state[f][a] = 1;
    > +                                       }
    > +                               }
    > +                       }
    > +                       pos[f][a] = p;
    > +                       base += 2;
    > +                       flip_flag <<= 1;
    > +               }
    > +               base += 2;
    > +               if (ts->flags & SYNAPTICS_SWAP_XY)
    > +                       swap(pos[f][0], pos[f][1]);
    > +       }
    > +       if (z) {
    > +               input_report_abs(ts->input_dev, ABS_X, pos[0][0]);
    > +               input_report_abs(ts->input_dev, ABS_Y, pos[0][1]);
    > +       }
    > +       input_report_abs(ts->input_dev, ABS_PRESSURE, z);
    > +       input_report_abs(ts->input_dev, ABS_TOOL_WIDTH, w);
    > +       input_report_key(ts->input_dev, BTN_TOUCH, finger);
    > +       finger2_pressed = finger > 1 && finger != 7;
    > +       input_report_key(ts->input_dev, BTN_2, finger2_pressed);
    > +       if (finger2_pressed) {
    > +               input_report_abs(ts->input_dev, ABS_HAT0X, pos[1][0]);
    > +               input_report_abs(ts->input_dev, ABS_HAT0Y, pos[1][1]);
    > +       }
    > +       input_sync(ts->input_dev);
    > +}
    > +
    >  static void synaptics_ts_work_func(struct work_struct *work)
    >  {
    >        int i;
    >        int ret;
    >        int bad_data = 0;
    >        struct i2c_msg msg[2];
    > -       uint8_t start_reg;
    > -       uint8_t buf[15];
    > -       struct synaptics_ts_data *ts = container_of(work, struct synaptics_ts_data, work);
    > +       u8 start_reg = 0;
    > +       u8 buf[15];
    > +       struct synaptics_ts_data *ts =
    > +               container_of(work, struct synaptics_ts_data, work);
    >
    >        msg[0].addr = ts->client->addr;
    >        msg[0].flags = 0;
    >        msg[0].len = 1;
    >        msg[0].buf = &start_reg;
    > -       start_reg = 0x00;
    >        msg[1].addr = ts->client->addr;
    >        msg[1].flags = I2C_M_RD;
    >        msg[1].len = sizeof(buf);
    >        msg[1].buf = buf;
    >
    > -       /* printk("synaptics_ts_work_func\n"); */
    >        for (i = 0; i < ((ts->use_irq && !bad_data) ? 1 : 10); i++) {
    >                ret = i2c_transfer(ts->client->adapter, msg, 2);
    >                if (ret < 0) {
    > -                       printk(KERN_ERR "synaptics_ts_work_func: i2c_transfer failed\n");
    > +                       printk(KERN_ERR "ts_work: i2c_transfer failed\n");

    This will make it harder to read the kernel logs since the driver is
    no longer specified.

    >                        bad_data = 1;
    > -               } else {
    > -                       /* printk("synaptics_ts_work_func: %x %x %x %x %x %x" */
    > -                       /*        " %x %x %x %x %x %x %x %x %x, ret %d\n", */
    > -                       /*        buf[0], buf[1], buf[2], buf[3], */
    > -                       /*        buf[4], buf[5], buf[6], buf[7], */
    > -                       /*        buf[8], buf[9], buf[10], buf[11], */
    > -                       /*        buf[12], buf[13], buf[14], ret); */
    > -                       if ((buf[14] & 0xc0) != 0x40) {
    > -                               printk(KERN_WARNING "synaptics_ts_work_func:"
    > -                                      " bad read %x %x %x %x %x %x %x %x %x"
    > -                                      " %x %x %x %x %x %x, ret %d\n",
    > -                                      buf[0], buf[1], buf[2], buf[3],
    > -                                      buf[4], buf[5], buf[6], buf[7],
    > -                                      buf[8], buf[9], buf[10], buf[11],
    > -                                      buf[12], buf[13], buf[14], ret);
    > -                               if (bad_data)
    > -                                       synaptics_init_panel(ts);
    > -                               bad_data = 1;
    > -                               continue;
    > -                       }
    > -                       bad_data = 0;
    > -                       if ((buf[14] & 1) == 0) {
    > -                               /* printk("read %d coordinates\n", i); */
    > -                               break;
    > -                       } else {
    > -                               int pos[2][2];
    > -                               int f, a;
    > -                               int base;
    > -                               /* int x = buf[3] | (uint16_t)(buf[2] & 0x1f) << 8; */
    > -                               /* int y = buf[5] | (uint16_t)(buf[4] & 0x1f) << 8; */
    > -                               int z = buf[1];
    > -                               int w = buf[0] >> 4;
    > -                               int finger = buf[0] & 7;
    > -
    > -                               /* int x2 = buf[3+6] | (uint16_t)(buf[2+6] & 0x1f) << 8; */
    > -                               /* int y2 = buf[5+6] | (uint16_t)(buf[4+6] & 0x1f) << 8; */
    > -                               /* int z2 = buf[1+6]; */
    > -                               /* int w2 = buf[0+6] >> 4; */
    > -                               /* int finger2 = buf[0+6] & 7; */
    > -
    > -                               /* int dx = (int8_t)buf[12]; */
    > -                               /* int dy = (int8_t)buf[13]; */
    > -                               int finger2_pressed;
    > -
    > -                               /* printk("x %4d, y %4d, z %3d, w %2d, F %d, 2nd: x %4d, y %4d, z %3d, w %2d, F %d, dx %4d, dy %4d\n", */
    > -                               /*      x, y, z, w, finger, */
    > -                               /*      x2, y2, z2, w2, finger2, */
    > -                               /*      dx, dy); */
    > -
    > -                               base = 2;
    > -                               for (f = 0; f < 2; f++) {
    > -                                       uint32_t flip_flag = SYNAPTICS_FLIP_X;
    > -                                       for (a = 0; a < 2; a++) {
    > -                                               int p = buf[base + 1];
    > -                                               p |= (uint16_t)(buf[base] & 0x1f) << 8;
    > -                                               if (ts->flags & flip_flag)
    > -                                                       p = ts->max[a] - p;
    > -                                               if (ts->flags & SYNAPTICS_SNAP_TO_INACTIVE_EDGE) {
    > -                                                       if (ts->snap_state[f][a]) {
    > -                                                               if (p <= ts->snap_down_off[a])
    > -                                                                       p = ts->snap_down[a];
    > -                                                               else if (p >= ts->snap_up_off[a])
    > -                                                                       p = ts->snap_up[a];
    > -                                                               else
    > -                                                                       ts->snap_state[f][a] = 0;
    > -                                                       } else {
    > -                                                               if (p <= ts->snap_down_on[a]) {
    > -                                                                       p = ts->snap_down[a];
    > -                                                                       ts->snap_state[f][a] = 1;
    > -                                                               } else if (p >= ts->snap_up_on[a]) {
    > -                                                                       p = ts->snap_up[a];
    > -                                                                       ts->snap_state[f][a] = 1;
    > -                                                               }
    > -                                                       }
    > -                                               }
    > -                                               pos[f][a] = p;
    > -                                               base += 2;
    > -                                               flip_flag <<= 1;
    > -                                       }
    > -                                       base += 2;
    > -                                       if (ts->flags & SYNAPTICS_SWAP_XY)
    > -                                               swap(pos[f][0], pos[f][1]);
    > -                               }
    > -                               if (z) {
    > -                                       input_report_abs(ts->input_dev, ABS_X, pos[0][0]);
    > -                                       input_report_abs(ts->input_dev, ABS_Y, pos[0][1]);
    > -                               }
    > -                               input_report_abs(ts->input_dev, ABS_PRESSURE, z);
    > -                               input_report_abs(ts->input_dev, ABS_TOOL_WIDTH, w);
    > -                               input_report_key(ts->input_dev, BTN_TOUCH, finger);
    > -                               finger2_pressed = finger > 1 && finger != 7;
    > -                               input_report_key(ts->input_dev, BTN_2, finger2_pressed);
    > -                               if (finger2_pressed) {
    > -                                       input_report_abs(ts->input_dev, ABS_HAT0X, pos[1][0]);
    > -                                       input_report_abs(ts->input_dev, ABS_HAT0Y, pos[1][1]);
    > -                               }
    > -                               input_sync(ts->input_dev);
    > -                       }
    > +                       continue;
    > +               }
    > +               if ((buf[14] & 0xc0) != 0x40) {
    > +                       printk(KERN_WARNING "synaptics_ts_work_func:"
    > +                              " bad read %x %x %x %x %x %x %x %x %x"
    > +                              " %x %x %x %x %x %x, ret %d\n",
    > +                              buf[0], buf[1], buf[2], buf[3],
    > +                              buf[4], buf[5], buf[6], buf[7],
    > +                              buf[8], buf[9], buf[10], buf[11],
    > +                              buf[12], buf[13], buf[14], ret);
    > +                       if (bad_data)
    > +                               synaptics_init_panel(ts);
    > +                       bad_data = 1;
    > +                       continue;
    >                }
    > +               bad_data = 0;
    > +               if ((buf[14] & 1) == 0)
    > +                       break;
    > +
    > +               decode_report(ts, buf);
    >        }
    >        if (ts->use_irq)
    >                enable_irq(ts->client->irq);
    > @@ -208,8 +184,8 @@ static void synaptics_ts_work_func(struct work_struct *work)
    >
    >  static enum hrtimer_restart synaptics_ts_timer_func(struct hrtimer *timer)
    >  {
    > -       struct synaptics_ts_data *ts = container_of(timer, struct synaptics_ts_data, timer);
    > -       /* printk("synaptics_ts_timer_func\n"); */
    > +       struct synaptics_ts_data *ts =
    > +               container_of(timer, struct synaptics_ts_data, timer);
    >
    >        queue_work(synaptics_wq, &ts->work);
    >
    > @@ -221,36 +197,145 @@ static irqreturn_t synaptics_ts_irq_handler(int irq, void *dev_id)
    >  {
    >        struct synaptics_ts_data *ts = dev_id;
    >
    > -       /* printk("synaptics_ts_irq_handler\n"); */
    >        disable_irq(ts->client->irq);
    >        queue_work(synaptics_wq, &ts->work);
    >        return IRQ_HANDLED;
    >  }
    >
    > +static int detect(struct synaptics_ts_data *ts, u32 *panel_version)
    > +{
    > +       int ret;
    > +       int retry = 10;
    > +
    > +       /* device command = reset */
    > +       ret = i2c_smbus_write_byte_data(ts->client, 0xf4, 0x01);
    > +       if (ret < 0) {
    > +               printk(KERN_ERR "i2c_smbus_write_byte_data failed\n");
    > +               /* fail? */
    > +       }
    > +
    > +       while (retry-- > 0) {
    > +               ret = i2c_smbus_read_byte_data(ts->client, 0xe4);
    > +               if (ret >= 0)
    > +                       break;
    > +               msleep(100);
    > +       }
    > +       if (ret < 0) {
    > +               printk(KERN_ERR "i2c_smbus_read_byte_data failed\n");
    > +               return ret;
    > +       }
    > +
    > +       printk(KERN_INFO "synaptics_ts_probe: Product Major Version %x\n", ret);
    > +       *panel_version = ret << 8;
    > +       ret = i2c_smbus_read_byte_data(ts->client, 0xe5);
    > +       if (ret < 0) {
    > +               printk(KERN_ERR "i2c_smbus_read_byte_data failed\n");
    > +               return ret;
    > +       }
    > +       printk(KERN_INFO "synaptics_ts_probe: Product Minor Version %x\n", ret);
    > +       *panel_version |= ret;
    > +
    > +       ret = i2c_smbus_read_byte_data(ts->client, 0xe3);
    > +       if (ret < 0) {
    > +               printk(KERN_ERR "i2c_smbus_read_byte_data failed\n");
    > +               return ret;
    > +       }
    > +       printk(KERN_INFO "synaptics_ts_probe: product property %x\n", ret);
    > +       return 0;
    > +}
    > +
    > +static void compute_areas(struct synaptics_ts_data *ts,
    > +                         struct synaptics_i2c_rmi_platform_data *pdata,
    > +                         u16 max_x, u16 max_y)
    > +{
    > +       u32 inactive_area_left;
    > +       u32 inactive_area_right;
    > +       u32 inactive_area_top;
    > +       u32 inactive_area_bottom;
    > +       u32 snap_left_on;
    > +       u32 snap_left_off;
    > +       u32 snap_right_on;
    > +       u32 snap_right_off;
    > +       u32 snap_top_on;
    > +       u32 snap_top_off;
    > +       u32 snap_bottom_on;
    > +       u32 snap_bottom_off;
    > +       u32 fuzz_x;
    > +       u32 fuzz_y;
    > +       int fuzz_p;
    > +       int fuzz_w;
    > +
    > +       inactive_area_left = pdata->inactive_left;
    > +       inactive_area_right = pdata->inactive_right;
    > +       inactive_area_top = pdata->inactive_top;
    > +       inactive_area_bottom = pdata->inactive_bottom;
    > +       snap_left_on = pdata->snap_left_on;
    > +       snap_left_off = pdata->snap_left_off;
    > +       snap_right_on = pdata->snap_right_on;
    > +       snap_right_off = pdata->snap_right_off;
    > +       snap_top_on = pdata->snap_top_on;
    > +       snap_top_off = pdata->snap_top_off;
    > +       snap_bottom_on = pdata->snap_bottom_on;
    > +       snap_bottom_off = pdata->snap_bottom_off;
    > +       fuzz_x = pdata->fuzz_x;
    > +       fuzz_y = pdata->fuzz_y;
    > +       fuzz_p = pdata->fuzz_p;
    > +       fuzz_w = pdata->fuzz_w;
    > +
    > +       inactive_area_left = inactive_area_left * max_x / 0x10000;
    > +       inactive_area_right = inactive_area_right * max_x / 0x10000;
    > +       inactive_area_top = inactive_area_top * max_y / 0x10000;
    > +       inactive_area_bottom = inactive_area_bottom * max_y / 0x10000;
    > +       snap_left_on = snap_left_on * max_x / 0x10000;
    > +       snap_left_off = snap_left_off * max_x / 0x10000;
    > +       snap_right_on = snap_right_on * max_x / 0x10000;
    > +       snap_right_off = snap_right_off * max_x / 0x10000;
    > +       snap_top_on = snap_top_on * max_y / 0x10000;
    > +       snap_top_off = snap_top_off * max_y / 0x10000;
    > +       snap_bottom_on = snap_bottom_on * max_y / 0x10000;
    > +       snap_bottom_off = snap_bottom_off * max_y / 0x10000;
    > +       fuzz_x = fuzz_x * max_x / 0x10000;
    > +       fuzz_y = fuzz_y * max_y / 0x10000;
    > +
    > +       ts->snap_down[!!(ts->flags & SYNAPTICS_SWAP_XY)] = -inactive_area_left;
    > +       ts->snap_up[!!(ts->flags & SYNAPTICS_SWAP_XY)] = max_x + inactive_area_right;
    > +       ts->snap_down[!(ts->flags & SYNAPTICS_SWAP_XY)] = -inactive_area_top;
    > +       ts->snap_up[!(ts->flags & SYNAPTICS_SWAP_XY)] = max_y + inactive_area_bottom;
    > +       ts->snap_down_on[!!(ts->flags & SYNAPTICS_SWAP_XY)] = snap_left_on;
    > +       ts->snap_down_off[!!(ts->flags & SYNAPTICS_SWAP_XY)] = snap_left_off;
    > +       ts->snap_up_on[!!(ts->flags & SYNAPTICS_SWAP_XY)] = max_x - snap_right_on;
    > +       ts->snap_up_off[!!(ts->flags & SYNAPTICS_SWAP_XY)] = max_x - snap_right_off;
    > +       ts->snap_down_on[!(ts->flags & SYNAPTICS_SWAP_XY)] = snap_top_on;
    > +       ts->snap_down_off[!(ts->flags & SYNAPTICS_SWAP_XY)] = snap_top_off;
    > +       ts->snap_up_on[!(ts->flags & SYNAPTICS_SWAP_XY)] = max_y - snap_bottom_on;
    > +       ts->snap_up_off[!(ts->flags & SYNAPTICS_SWAP_XY)] = max_y - snap_bottom_off;
    > +       printk(KERN_INFO "synaptics_ts_probe: max_x %d, max_y %d\n", max_x, max_y);
    > +       printk(KERN_INFO "synaptics_ts_probe: inactive_x %d %d, inactive_y %d %d\n",
    > +              inactive_area_left, inactive_area_right,
    > +              inactive_area_top, inactive_area_bottom);
    > +       printk(KERN_INFO "synaptics_ts_probe: snap_x %d-%d %d-%d, snap_y %d-%d %d-%d\n",
    > +              snap_left_on, snap_left_off, snap_right_on, snap_right_off,
    > +              snap_top_on, snap_top_off, snap_bottom_on, snap_bottom_off);
    > +
    > +       input_set_abs_params(ts->input_dev, ABS_X, -inactive_area_left, max_x + inactive_area_right, fuzz_x, 0);
    > +       input_set_abs_params(ts->input_dev, ABS_Y, -inactive_area_top, max_y + inactive_area_bottom, fuzz_y, 0);
    > +       input_set_abs_params(ts->input_dev, ABS_PRESSURE, 0, 255, fuzz_p, 0);
    > +       input_set_abs_params(ts->input_dev, ABS_TOOL_WIDTH, 0, 15, fuzz_w, 0);
    > +       input_set_abs_params(ts->input_dev, ABS_HAT0X, -inactive_area_left, max_x + inactive_area_right, fuzz_x, 0);
    > +       input_set_abs_params(ts->input_dev, ABS_HAT0Y, -inactive_area_top, max_y + inactive_area_bottom, fuzz_y, 0);
    > +}
    > +
    >  static int synaptics_ts_probe(
    >        struct i2c_client *client, const struct i2c_device_id *id)
    >  {
    >        struct synaptics_ts_data *ts;
    > -       uint8_t buf0[4];
    > -       uint8_t buf1[8];
    > +       u8 buf0[4];
    > +       u8 buf1[8];
    >        struct i2c_msg msg[2];
    >        int ret = 0;
    > -       uint16_t max_x, max_y;
    > -       int fuzz_x, fuzz_y, fuzz_p, fuzz_w;
    >        struct synaptics_i2c_rmi_platform_data *pdata;
    > -       int inactive_area_left;
    > -       int inactive_area_right;
    > -       int inactive_area_top;
    > -       int inactive_area_bottom;
    > -       int snap_left_on;
    > -       int snap_left_off;
    > -       int snap_right_on;
    > -       int snap_right_off;
    > -       int snap_top_on;
    > -       int snap_top_off;
    > -       int snap_bottom_on;
    > -       int snap_bottom_off;
    > -       uint32_t panel_version;
    > +       u32 panel_version = 0;
    > +       u16 max_x, max_y;
    >
    >        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
    >                printk(KERN_ERR "synaptics_ts_probe: need I2C_FUNC_I2C\n");
    > @@ -269,6 +354,9 @@ static int synaptics_ts_probe(
    >        pdata = client->dev.platform_data;
    >        if (pdata)
    >                ts->power = pdata->power;
    > +       else
    > +               pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
    > +

    Where do you free this?

    >        if (ts->power) {
    >                ret = ts->power(1);
    >                if (ret < 0) {
    > @@ -277,81 +365,16 @@ static int synaptics_ts_probe(
    >                }
    >        }
    >
    > -       ret = i2c_smbus_write_byte_data(ts->client, 0xf4, 0x01); /* device command = reset */
    > -       if (ret < 0) {
    > -               printk(KERN_ERR "i2c_smbus_write_byte_data failed\n");
    > -               /* fail? */
    > -       }
    > -       {
    > -               int retry = 10;
    > -               while (retry-- > 0) {
    > -                       ret = i2c_smbus_read_byte_data(ts->client, 0xe4);
    > -                       if (ret >= 0)
    > -                               break;
    > -                       msleep(100);
    > -               }
    > -       }
    > -       if (ret < 0) {
    > -               printk(KERN_ERR "i2c_smbus_read_byte_data failed\n");
    > -               goto err_detect_failed;
    > -       }
    > -       printk(KERN_INFO "synaptics_ts_probe: Product Major Version %x\n", ret);
    > -       panel_version = ret << 8;
    > -       ret = i2c_smbus_read_byte_data(ts->client, 0xe5);
    > -       if (ret < 0) {
    > -               printk(KERN_ERR "i2c_smbus_read_byte_data failed\n");
    > -               goto err_detect_failed;
    > -       }
    > -       printk(KERN_INFO "synaptics_ts_probe: Product Minor Version %x\n", ret);
    > -       panel_version |= ret;
    > -
    > -       ret = i2c_smbus_read_byte_data(ts->client, 0xe3);
    > -       if (ret < 0) {
    > -               printk(KERN_ERR "i2c_smbus_read_byte_data failed\n");
    > +       ret = detect(ts, &panel_version);
    > +       if (ret)
    >                goto err_detect_failed;
    > -       }
    > -       printk(KERN_INFO "synaptics_ts_probe: product property %x\n", ret);
    >
    > -       if (pdata) {
    > -               while (pdata->version > panel_version)
    > -                       pdata++;
    > -               ts->flags = pdata->flags;
    > -               inactive_area_left = pdata->inactive_left;
    > -               inactive_area_right = pdata->inactive_right;
    > -               inactive_area_top = pdata->inactive_top;
    > -               inactive_area_bottom = pdata->inactive_bottom;
    > -               snap_left_on = pdata->snap_left_on;
    > -               snap_left_off = pdata->snap_left_off;
    > -               snap_right_on = pdata->snap_right_on;
    > -               snap_right_off = pdata->snap_right_off;
    > -               snap_top_on = pdata->snap_top_on;
    > -               snap_top_off = pdata->snap_top_off;
    > -               snap_bottom_on = pdata->snap_bottom_on;
    > -               snap_bottom_off = pdata->snap_bottom_off;
    > -               fuzz_x = pdata->fuzz_x;
    > -               fuzz_y = pdata->fuzz_y;
    > -               fuzz_p = pdata->fuzz_p;
    > -               fuzz_w = pdata->fuzz_w;
    > -       } else {
    > -               inactive_area_left = 0;
    > -               inactive_area_right = 0;
    > -               inactive_area_top = 0;
    > -               inactive_area_bottom = 0;
    > -               snap_left_on = 0;
    > -               snap_left_off = 0;
    > -               snap_right_on = 0;
    > -               snap_right_off = 0;
    > -               snap_top_on = 0;
    > -               snap_top_off = 0;
    > -               snap_bottom_on = 0;
    > -               snap_bottom_off = 0;
    > -               fuzz_x = 0;
    > -               fuzz_y = 0;
    > -               fuzz_p = 0;
    > -               fuzz_w = 0;
    > -       }
    > +       while (pdata->version > panel_version)
    > +               pdata++;
    > +       ts->flags = pdata->flags;
    >
    >        ret = i2c_smbus_read_byte_data(ts->client, 0xf0);
    > +
    >        if (ret < 0) {
    >                printk(KERN_ERR "i2c_smbus_read_byte_data failed\n");
    >                goto err_detect_failed;
    > @@ -427,46 +450,10 @@ static int synaptics_ts_probe(
    >        set_bit(BTN_TOUCH, ts->input_dev->keybit);
    >        set_bit(BTN_2, ts->input_dev->keybit);
    >        set_bit(EV_ABS, ts->input_dev->evbit);
    > -       inactive_area_left = inactive_area_left * max_x / 0x10000;
    > -       inactive_area_right = inactive_area_right * max_x / 0x10000;
    > -       inactive_area_top = inactive_area_top * max_y / 0x10000;
    > -       inactive_area_bottom = inactive_area_bottom * max_y / 0x10000;
    > -       snap_left_on = snap_left_on * max_x / 0x10000;
    > -       snap_left_off = snap_left_off * max_x / 0x10000;
    > -       snap_right_on = snap_right_on * max_x / 0x10000;
    > -       snap_right_off = snap_right_off * max_x / 0x10000;
    > -       snap_top_on = snap_top_on * max_y / 0x10000;
    > -       snap_top_off = snap_top_off * max_y / 0x10000;
    > -       snap_bottom_on = snap_bottom_on * max_y / 0x10000;
    > -       snap_bottom_off = snap_bottom_off * max_y / 0x10000;
    > -       fuzz_x = fuzz_x * max_x / 0x10000;
    > -       fuzz_y = fuzz_y * max_y / 0x10000;
    > -       ts->snap_down[!!(ts->flags & SYNAPTICS_SWAP_XY)] = -inactive_area_left;
    > -       ts->snap_up[!!(ts->flags & SYNAPTICS_SWAP_XY)] = max_x + inactive_area_right;
    > -       ts->snap_down[!(ts->flags & SYNAPTICS_SWAP_XY)] = -inactive_area_top;
    > -       ts->snap_up[!(ts->flags & SYNAPTICS_SWAP_XY)] = max_y + inactive_area_bottom;
    > -       ts->snap_down_on[!!(ts->flags & SYNAPTICS_SWAP_XY)] = snap_left_on;
    > -       ts->snap_down_off[!!(ts->flags & SYNAPTICS_SWAP_XY)] = snap_left_off;
    > -       ts->snap_up_on[!!(ts->flags & SYNAPTICS_SWAP_XY)] = max_x - snap_right_on;
    > -       ts->snap_up_off[!!(ts->flags & SYNAPTICS_SWAP_XY)] = max_x - snap_right_off;
    > -       ts->snap_down_on[!(ts->flags & SYNAPTICS_SWAP_XY)] = snap_top_on;
    > -       ts->snap_down_off[!(ts->flags & SYNAPTICS_SWAP_XY)] = snap_top_off;
    > -       ts->snap_up_on[!(ts->flags & SYNAPTICS_SWAP_XY)] = max_y - snap_bottom_on;
    > -       ts->snap_up_off[!(ts->flags & SYNAPTICS_SWAP_XY)] = max_y - snap_bottom_off;
    > -       printk(KERN_INFO "synaptics_ts_probe: max_x %d, max_y %d\n", max_x, max_y);
    > -       printk(KERN_INFO "synaptics_ts_probe: inactive_x %d %d, inactive_y %d %d\n",
    > -              inactive_area_left, inactive_area_right,
    > -              inactive_area_top, inactive_area_bottom);
    > -       printk(KERN_INFO "synaptics_ts_probe: snap_x %d-%d %d-%d, snap_y %d-%d %d-%d\n",
    > -              snap_left_on, snap_left_off, snap_right_on, snap_right_off,
    > -              snap_top_on, snap_top_off, snap_bottom_on, snap_bottom_off);
    > -       input_set_abs_params(ts->input_dev, ABS_X, -inactive_area_left, max_x + inactive_area_right, fuzz_x, 0);
    > -       input_set_abs_params(ts->input_dev, ABS_Y, -inactive_area_top, max_y + inactive_area_bottom, fuzz_y, 0);
    > -       input_set_abs_params(ts->input_dev, ABS_PRESSURE, 0, 255, fuzz_p, 0);
    > -       input_set_abs_params(ts->input_dev, ABS_TOOL_WIDTH, 0, 15, fuzz_w, 0);
    > -       input_set_abs_params(ts->input_dev, ABS_HAT0X, -inactive_area_left, max_x + inactive_area_right, fuzz_x, 0);
    > -       input_set_abs_params(ts->input_dev, ABS_HAT0Y, -inactive_area_top, max_y + inactive_area_bottom, fuzz_y, 0);
    > -       /* ts->input_dev->name = ts->keypad_info->name; */
    > +
    > +       compute_areas(ts, pdata, max_x, max_y);
    > +
    > +
    >        ret = input_register_device(ts->input_dev);
    >        if (ret) {
    >                printk(KERN_ERR "synaptics_ts_probe: Unable to register %s input device\n", ts->input_dev->name);
    > @@ -489,33 +476,27 @@ static int synaptics_ts_probe(
    >                ts->timer.function = synaptics_ts_timer_func;
    >                hrtimer_start(&ts->timer, ktime_set(1, 0), HRTIMER_MODE_REL);
    >        }
    > -#ifdef CONFIG_HAS_EARLYSUSPEND
    > -       ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
    > -       ts->early_suspend.suspend = synaptics_ts_early_suspend;
    > -       ts->early_suspend.resume = synaptics_ts_late_resume;
    > -       register_early_suspend(&ts->early_suspend);
    > -#endif
    >
    >        printk(KERN_INFO "synaptics_ts_probe: Start touchscreen %s in %s mode\n", ts->input_dev->name, ts->use_irq ? "interrupt" : "polling");
    >
    >        return 0;
    >
    > -err_input_register_device_failed:
    > + err_input_register_device_failed:
    >        input_free_device(ts->input_dev);
    >
    > -err_input_dev_alloc_failed:
    > -err_detect_failed:
    > -err_power_failed:
    > + err_input_dev_alloc_failed:
    > + err_detect_failed:
    > + err_power_failed:
    >        kfree(ts);
    > -err_alloc_data_failed:
    > -err_check_functionality_failed:
    > + err_alloc_data_failed:
    > + err_check_functionality_failed:
    >        return ret;
    >  }
    >
    >  static int synaptics_ts_remove(struct i2c_client *client)
    >  {
    >        struct synaptics_ts_data *ts = i2c_get_clientdata(client);
    > -       unregister_early_suspend(&ts->early_suspend);
    > +
    >        if (ts->use_irq)
    >                free_irq(client->irq, ts);
    >        else
    > @@ -525,72 +506,6 @@ static int synaptics_ts_remove(struct i2c_client *client)
    >        return 0;
    >  }
    >
    > -static int synaptics_ts_suspend(struct i2c_client *client, pm_message_t mesg)
    > -{
    > -       int ret;
    > -       struct synaptics_ts_data *ts = i2c_get_clientdata(client);
    > -
    > -       if (ts->use_irq)
    > -               disable_irq(client->irq);
    > -       else
    > -               hrtimer_cancel(&ts->timer);
    > -       ret = cancel_work_sync(&ts->work);
    > -       if (ret && ts->use_irq) /* if work was pending disable-count is now 2 */
    > -               enable_irq(client->irq);
    > -       ret = i2c_smbus_write_byte_data(ts->client, 0xf1, 0); /* disable interrupt */
    > -       if (ret < 0)
    > -               printk(KERN_ERR "synaptics_ts_suspend: i2c_smbus_write_byte_data failed\n");
    > -
    > -       ret = i2c_smbus_write_byte_data(client, 0xf0, 0x86); /* deep sleep */
    > -       if (ret < 0)
    > -               printk(KERN_ERR "synaptics_ts_suspend: i2c_smbus_write_byte_data failed\n");
    > -       if (ts->power) {
    > -               ret = ts->power(0);
    > -               if (ret < 0)
    > -                       printk(KERN_ERR "synaptics_ts_resume power off failed\n");
    > -       }
    > -       return 0;
    > -}
    > -
    > -static int synaptics_ts_resume(struct i2c_client *client)
    > -{
    > -       int ret;
    > -       struct synaptics_ts_data *ts = i2c_get_clientdata(client);
    > -
    > -       if (ts->power) {
    > -               ret = ts->power(1);
    > -               if (ret < 0)
    > -                       printk(KERN_ERR "synaptics_ts_resume power on failed\n");
    > -       }
    > -
    > -       synaptics_init_panel(ts);
    > -
    > -       if (ts->use_irq)
    > -               enable_irq(client->irq);
    > -
    > -       if (!ts->use_irq)
    > -               hrtimer_start(&ts->timer, ktime_set(1, 0), HRTIMER_MODE_REL);
    > -       else
    > -               i2c_smbus_write_byte_data(ts->client, 0xf1, 0x01); /* enable abs int */
    > -
    > -       return 0;
    > -}

    Why did you remove suspend and resume?

    > -
    > -#ifdef CONFIG_HAS_EARLYSUSPEND
    > -static void synaptics_ts_early_suspend(struct early_suspend *h)
    > -{
    > -       struct synaptics_ts_data *ts;
    > -       ts = container_of(h, struct synaptics_ts_data, early_suspend);
    > -       synaptics_ts_suspend(ts->client, PMSG_SUSPEND);
    > -}
    > -
    > -static void synaptics_ts_late_resume(struct early_suspend *h)
    > -{
    > -       struct synaptics_ts_data *ts;
    > -       ts = container_of(h, struct synaptics_ts_data, early_suspend);
    > -       synaptics_ts_resume(ts->client);
    > -}
    > -#endif
    >
    >  static const struct i2c_device_id synaptics_ts_id[] = {
    >        { SYNAPTICS_I2C_RMI_NAME, 0 },
    > @@ -600,10 +515,6 @@ static const struct i2c_device_id synaptics_ts_id[] = {
    >  static struct i2c_driver synaptics_ts_driver = {
    >        .probe          = synaptics_ts_probe,
    >        .remove         = synaptics_ts_remove,
    > -#ifndef CONFIG_HAS_EARLYSUSPEND
    > -       .suspend        = synaptics_ts_suspend,
    > -       .resume         = synaptics_ts_resume,
    > -#endif

    Remove #ifndef only, not the content.


    >        .id_table       = synaptics_ts_id,
    >        .driver = {
    >                .name   = SYNAPTICS_I2C_RMI_NAME,
    > diff --git a/include/linux/synaptics_i2c_rmi.h b/include/linux/synaptics_i2c_rmi.h
    > index ca51b2f..73e1de7 100644
    > --- a/include/linux/synaptics_i2c_rmi.h
    > +++ b/include/linux/synaptics_i2c_rmi.h
    > @@ -1,5 +1,5 @@
    >  /*
    > - * include/linux/synaptics_i2c_rmi.h - platform data structure for f75375s sensor
    > + * synaptics_i2c_rmi.h - platform data structure for f75375s sensor
    >  *
    >  * Copyright (C) 2008 Google, Inc.
    >  *
    > @@ -27,25 +27,25 @@ enum {
    >  };
    >
    >  struct synaptics_i2c_rmi_platform_data {
    > -       uint32_t version;       /* Use this entry for panels with */
    > +       u32 version;    /* Use this entry for panels with */
    >                                /* (major << 8 | minor) version or above. */
    >                                /* If non-zero another array entry follows */
    >        int (*power)(int on);   /* Only valid in first array entry */
    > -       uint32_t flags;
    > -       uint32_t inactive_left; /* 0x10000 = screen width */
    > -       uint32_t inactive_right; /* 0x10000 = screen width */
    > -       uint32_t inactive_top; /* 0x10000 = screen height */
    > -       uint32_t inactive_bottom; /* 0x10000 = screen height */
    > -       uint32_t snap_left_on; /* 0x10000 = screen width */
    > -       uint32_t snap_left_off; /* 0x10000 = screen width */
    > -       uint32_t snap_right_on; /* 0x10000 = screen width */
    > -       uint32_t snap_right_off; /* 0x10000 = screen width */
    > -       uint32_t snap_top_on; /* 0x10000 = screen height */
    > -       uint32_t snap_top_off; /* 0x10000 = screen height */
    > -       uint32_t snap_bottom_on; /* 0x10000 = screen height */
    > -       uint32_t snap_bottom_off; /* 0x10000 = screen height */
    > -       uint32_t fuzz_x; /* 0x10000 = screen width */
    > -       uint32_t fuzz_y; /* 0x10000 = screen height */
    > +       u32 flags;
    > +       u32 inactive_left; /* 0x10000 = screen width */
    > +       u32 inactive_right; /* 0x10000 = screen width */
    > +       u32 inactive_top; /* 0x10000 = screen height */
    > +       u32 inactive_bottom; /* 0x10000 = screen height */
    > +       u32 snap_left_on; /* 0x10000 = screen width */
    > +       u32 snap_left_off; /* 0x10000 = screen width */
    > +       u32 snap_right_on; /* 0x10000 = screen width */
    > +       u32 snap_right_off; /* 0x10000 = screen width */
    > +       u32 snap_top_on; /* 0x10000 = screen height */
    > +       u32 snap_top_off; /* 0x10000 = screen height */
    > +       u32 snap_bottom_on; /* 0x10000 = screen height */
    > +       u32 snap_bottom_off; /* 0x10000 = screen height */
    > +       u32 fuzz_x; /* 0x10000 = screen width */
    > +       u32 fuzz_y; /* 0x10000 = screen height */

    I prefer the existing C99 types.

    >        int fuzz_p;
    >        int fuzz_w;
    >  };
    >
    > --
    > (english) http://www.livejournal.com/~pavelmachek
    > (cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
    > --
    > To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    > the body of a message to majordomo@vger.kernel.org
    > More majordomo info at  http://vger.kernel.org/majordomo-info.html
    > Please read the FAQ at  http://www.tux.org/lkml/
    >

    This driver only supports a subset of Synaptics' devices so a more
    generic driver will eventually be needed. The patch below adds support
    for a more recent but similar panel.

    --
    Arve Hjønnevåg

    ----

    commit 22d8c831554b8bec6e9fbac9d6bf972c775ee128
    Author: Arve Hjønnevåg <arve@android.com>
    Date: Wed Jul 8 21:32:06 2009 -0700

    Input: synaptics_i2c_rmi: Add support for panels with
    has-no-relative-data property.

    Signed-off-by: Arve Hjønnevåg <arve@android.com>

    diff --git a/drivers/input/touchscreen/synaptics_i2c_rmi.c
    b/drivers/input/touchscreen/synaptics_i2c_rmi.c
    index a45634b..88c8e4a 100644
    --- a/drivers/input/touchscreen/synaptics_i2c_rmi.c
    +++ b/drivers/input/touchscreen/synaptics_i2c_rmi.c
    @@ -33,6 +33,7 @@ struct synaptics_ts_data {
    struct i2c_client *client;
    struct input_dev *input_dev;
    int use_irq;
    + bool has_relative_report;
    struct hrtimer timer;
    struct work_struct work;
    uint16_t max[2];
    @@ -85,6 +86,7 @@ static void synaptics_ts_work_func(struct work_struct *work)
    uint8_t start_reg;
    uint8_t buf[15];
    struct synaptics_ts_data *ts = container_of(work, struct
    synaptics_ts_data, work);
    + int buf_len = ts->has_relative_report ? 15 : 13;

    msg[0].addr = ts->client->addr;
    msg[0].flags = 0;
    @@ -93,7 +95,7 @@ static void synaptics_ts_work_func(struct work_struct *work)
    start_reg = 0x00;
    msg[1].addr = ts->client->addr;
    msg[1].flags = I2C_M_RD;
    - msg[1].len = sizeof(buf);
    + msg[1].len = buf_len;
    msg[1].buf = buf;

    /* printk("synaptics_ts_work_func\n"); */
    @@ -109,7 +111,7 @@ static void synaptics_ts_work_func(struct work_struct *work)
    /* buf[4], buf[5], buf[6], buf[7], */
    /* buf[8], buf[9], buf[10], buf[11], */
    /* buf[12], buf[13], buf[14], ret); */
    - if ((buf[14] & 0xc0) != 0x40) {
    + if ((buf[buf_len - 1] & 0xc0) != 0x40) {
    printk(KERN_WARNING "synaptics_ts_work_func:"
    " bad read %x %x %x %x %x %x %x %x %x"
    " %x %x %x %x %x %x, ret %d\n",
    @@ -123,7 +125,7 @@ static void synaptics_ts_work_func(struct work_struct *work)
    continue;
    }
    bad_data = 0;
    - if ((buf[14] & 1) == 0) {
    + if ((buf[buf_len - 1] & 1) == 0) {
    /* printk("read %d coordinates\n", i); */
    break;
    } else {
    @@ -394,6 +396,13 @@ static int synaptics_ts_probe(
    printk(KERN_ERR "i2c_smbus_write_byte_data failed for
    page select\n");
    goto err_detect_failed;
    }
    + ret = i2c_smbus_read_word_data(ts->client, 0x02);
    + if (ret < 0) {
    + printk(KERN_ERR "i2c_smbus_read_word_data failed\n");
    + goto err_detect_failed;
    + }
    + ts->has_relative_report = !(ret & 0x100);
    + printk(KERN_INFO "synaptics_ts_probe: Sensor properties %x\n", ret);
    ret = i2c_smbus_read_word_data(ts->client, 0x04);
    if (ret < 0) {
    printk(KERN_ERR "i2c_smbus_read_word_data failed\n");
    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/
    \
     
     \ /
      Last update: 2009-07-14 03:33    [W:0.112 / U:2.096 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site