Eric Lee / smarc-ti-linux-kernel | Embedian Git Server

Commit 56c381f93d57b88a3e667a2f55137947315c17e2

Authored by Linus Torvalds 2014-11-15 06:31:54 +0800

Exists in ti-lsk-linux-4.1.y and in 10 other branches

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input

Pull input subsystem updates from Dmitry Torokhov:
 "Mostly small fixups to PS/2 tochpad drivers (ALPS, Elantech,
  Synaptics) to better deal with specific hardware"

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input:
  Input: elantech - update the documentation
  Input: elantech - provide a sysfs knob for crc_enabled
  Input: elantech - report the middle button of the touchpad
  Input: alps - ignore bad data on Dell Latitudes E6440 and E7440
  Input: alps - allow up to 2 invalid packets without resetting device
  Input: alps - ignore potential bare packets when device is out of sync
  Input: elantech - fix crc_enabled for Fujitsu H730
  Input: elantech - use elantech_report_trackpoint for hardware v4 too
  Input: twl4030-pwrbutton - ensure a wakeup event is recorded.
  Input: synaptics - add min/max quirk for Lenovo T440s

Showing 5 changed files Inline Diff

Documentation/input/elantech.txt
drivers/input/misc/twl4030-pwrbutton.c
drivers/input/mouse/alps.c
drivers/input/mouse/elantech.c
drivers/input/mouse/synaptics.c

Documentation/input/elantech.txt

Diff comments View file @ 56c381f

 Elantech Touchpad Driver
 ========================
 	Copyright (C) 2007-2008 Arjan Opmeer <arjan@opmeer.net>
 	Extra information for hardware version 1 found and
 	provided by Steve Havelka
 	Version 2 (EeePC) hardware support based on patches
 	received from Woody at Xandros and forwarded to me
 	by user StewieGriffin at the eeeuser.com forum
 Contents
 ~~~~~~~~
  1. Introduction
  2. Extra knobs
  3. Differentiating hardware versions
  4. Hardware version 1
     4.1 Registers
     4.2 Native relative mode 4 byte packet format
     4.3 Native absolute mode 4 byte packet format
  5. Hardware version 2
     5.1 Registers
     5.2 Native absolute mode 6 byte packet format
         5.2.1 Parity checking and packet re-synchronization
         5.2.2 One/Three finger touch
         5.2.3 Two finger touch
  6. Hardware version 3
     6.1 Registers
     6.2 Native absolute mode 6 byte packet format
         6.2.1 One/Three finger touch
         6.2.2 Two finger touch
  7. Hardware version 4
     7.1 Registers
     7.2 Native absolute mode 6 byte packet format
         7.2.1 Status packet
         7.2.2 Head packet
         7.2.3 Motion packet
+ 8. Trackpoint (for Hardware version 3 and 4)
+    8.1 Registers
+    8.2 Native relative mode 6 byte packet format
+        8.2.1 Status Packet
 1. Introduction
    ~~~~~~~~~~~~
-Currently the Linux Elantech touchpad driver is aware of two different
+Currently the Linux Elantech touchpad driver is aware of four different
-hardware versions unimaginatively called version 1 and version 2. Version 1
+hardware versions unimaginatively called version 1,version 2, version 3
-is found in "older" laptops and uses 4 bytes per packet. Version 2 seems to
+and version 4. Version 1 is found in "older" laptops and uses 4 bytes per
-be introduced with the EeePC and uses 6 bytes per packet, and provides
+packet. Version 2 seems to be introduced with the EeePC and uses 6 bytes
-additional features such as position of two fingers, and width of the touch.
+per packet, and provides additional features such as position of two fingers,
+and width of the touch.  Hardware version 3 uses 6 bytes per packet (and
+for 2 fingers the concatenation of two 6 bytes packets) and allows tracking
+of up to 3 fingers. Hardware version 4 uses 6 bytes per packet, and can
+combine a status packet with multiple head or motion packets. Hardware version
+4 allows tracking up to 5 fingers.
+Some Hardware version 3 and version 4 also have a trackpoint which uses a
+separate packet format. It is also 6 bytes per packet.
 The driver tries to support both hardware versions and should be compatible
 with the Xorg Synaptics touchpad driver and its graphical configuration
 utilities.
+Note that a mouse button is also associated with either the touchpad or the
+trackpoint when a trackpoint is available.  Disabling the Touchpad in xorg
+(TouchPadOff=0) will also disable the buttons associated with the touchpad.
 Additionally the operation of the touchpad can be altered by adjusting the
 contents of some of its internal registers. These registers are represented
 by the driver as sysfs entries under /sys/bus/serio/drivers/psmouse/serio?
 that can be read from and written to.
 Currently only the registers for hardware version 1 are somewhat understood.
 Hardware version 2 seems to use some of the same registers but it is not
 known whether the bits in the registers represent the same thing or might
 have changed their meaning.
 On top of that, some register settings have effect only when the touchpad is
 in relative mode and not in absolute mode. As the Linux Elantech touchpad
 driver always puts the hardware into absolute mode not all information
 mentioned below can be used immediately. But because there is no freely
 available Elantech documentation the information is provided here anyway for
 completeness sake.
 /////////////////////////////////////////////////////////////////////////////
 2. Extra knobs
    ~~~~~~~~~~~
-Currently the Linux Elantech touchpad driver provides two extra knobs under
+Currently the Linux Elantech touchpad driver provides three extra knobs under
 /sys/bus/serio/drivers/psmouse/serio? for the user.
 * debug
    Turn different levels of debugging ON or OFF.
    By echoing "0" to this file all debugging will be turned OFF.
    Currently a value of "1" will turn on some basic debugging and a value of
    "2" will turn on packet debugging. For hardware version 1 the default is
    OFF. For version 2 the default is "1".
    Turning packet debugging on will make the driver dump every packet
    received to the syslog before processing it. Be warned that this can
    generate quite a lot of data!
 * paritycheck
    Turns parity checking ON or OFF.
    By echoing "0" to this file parity checking will be turned OFF. Any
    non-zero value will turn it ON. For hardware version 1 the default is ON.
    For version 2 the default it is OFF.
    Hardware version 1 provides basic data integrity verification by
    calculating a parity bit for the last 3 bytes of each packet. The driver
    can check these bits and reject any packet that appears corrupted. Using
    this knob you can bypass that check.
    Hardware version 2 does not provide the same parity bits. Only some basic
    data consistency checking can be done. For now checking is disabled by
    default. Currently even turning it on will do nothing.
+* crc_enabled
+   Sets crc_enabled to 0/1. The name "crc_enabled" is the official name of
+   this integrity check, even though it is not an actual cyclic redundancy
+   check.
+   Depending on the state of crc_enabled, certain basic data integrity
+   verification is done by the driver on hardware version 3 and 4. The
+   driver will reject any packet that appears corrupted. Using this knob,
+   The state of crc_enabled can be altered with this knob.
+   Reading the crc_enabled value will show the active value. Echoing
+   "0" or "1" to this file will set the state to "0" or "1".
 /////////////////////////////////////////////////////////////////////////////
 3. Differentiating hardware versions
    =================================
 To detect the hardware version, read the version number as param[0].param[1].param[2]
  4 bytes version: (after the arrow is the name given in the Dell-provided driver)
  02.00.22 => EF013
  02.06.00 => EF019
 In the wild, there appear to be more versions, such as 00.01.64, 01.00.21,
 02.00.00, 02.00.04, 02.00.06.
  6 bytes:
  02.00.30 => EF113
  02.08.00 => EF023
  02.08.XX => EF123
  02.0B.00 => EF215
  04.01.XX => Scroll_EF051
  04.02.XX => EF051
 In the wild, there appear to be more versions, such as 04.03.01, 04.04.11. There
 appears to be almost no difference, except for EF113, which does not report
 pressure/width and has different data consistency checks.
 Probably all the versions with param[0] <= 01 can be considered as
 4 bytes/firmware 1. The versions < 02.08.00, with the exception of 02.00.30, as
 4 bytes/firmware 2. Everything >= 02.08.00 can be considered as 6 bytes.
 /////////////////////////////////////////////////////////////////////////////
 4. Hardware version 1
    ==================
 4.1 Registers
     ~~~~~~~~~
 By echoing a hexadecimal value to a register it contents can be altered.
 For example:
    echo -n 0x16 > reg_10
 * reg_10
    bit   7   6   5   4   3   2   1   0
          B   C   T   D   L   A   S   E
          E: 1 = enable smart edges unconditionally
          S: 1 = enable smart edges only when dragging
          A: 1 = absolute mode (needs 4 byte packets, see reg_11)
          L: 1 = enable drag lock (see reg_22)
          D: 1 = disable dynamic resolution
          T: 1 = disable tapping
          C: 1 = enable corner tap
          B: 1 = swap left and right button
 * reg_11
    bit   7   6   5   4   3   2   1   0
          1   0   0   H   V   1   F   P
          P: 1 = enable parity checking for relative mode
          F: 1 = enable native 4 byte packet mode
          V: 1 = enable vertical scroll area
          H: 1 = enable horizontal scroll area
 * reg_20
          single finger width?
 * reg_21
          scroll area width (small: 0x40 ... wide: 0xff)
 * reg_22
          drag lock time out (short: 0x14 ... long: 0xfe;
                              0xff = tap again to release)
 * reg_23
          tap make timeout?
 * reg_24
          tap release timeout?
 * reg_25
          smart edge cursor speed (0x02 = slow, 0x03 = medium, 0x04 = fast)
 * reg_26
          smart edge activation area width?
 4.2 Native relative mode 4 byte packet format
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 byte 0:
    bit   7   6   5   4   3   2   1   0
          c   c  p2  p1   1   M   R   L
          L, R, M = 1 when Left, Right, Middle mouse button pressed
             some models have M as byte 3 odd parity bit
          when parity checking is enabled (reg_11, P = 1):
             p1..p2 = byte 1 and 2 odd parity bit
          c = 1 when corner tap detected
 byte 1:
    bit   7   6   5   4   3   2   1   0
         dx7 dx6 dx5 dx4 dx3 dx2 dx1 dx0
          dx7..dx0 = x movement;   positive = right, negative = left
          byte 1 = 0xf0 when corner tap detected
 byte 2:
    bit   7   6   5   4   3   2   1   0
         dy7 dy6 dy5 dy4 dy3 dy2 dy1 dy0
          dy7..dy0 = y movement;   positive = up,    negative = down
 byte 3:
    parity checking enabled (reg_11, P = 1):
       bit   7   6   5   4   3   2   1   0
             w   h  n1  n0  ds3 ds2 ds1 ds0
             normally:
                ds3..ds0 = scroll wheel amount and direction
                           positive = down or left
                           negative = up or right
             when corner tap detected:
                ds0 = 1 when top right corner tapped
                ds1 = 1 when bottom right corner tapped
                ds2 = 1 when bottom left corner tapped
                ds3 = 1 when top left corner tapped
             n1..n0 = number of fingers on touchpad
                only models with firmware 2.x report this, models with
                firmware 1.x seem to map one, two and three finger taps
                directly to L, M and R mouse buttons
             h = 1 when horizontal scroll action
             w = 1 when wide finger touch?
    otherwise (reg_11, P = 0):
       bit   7   6   5   4   3   2   1   0
            ds7 ds6 ds5 ds4 ds3 ds2 ds1 ds0
             ds7..ds0 = vertical scroll amount and direction
                        negative = up
                        positive = down
 4.3 Native absolute mode 4 byte packet format
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 EF013 and EF019 have a special behaviour (due to a bug in the firmware?), and
 when 1 finger is touching, the first 2 position reports must be discarded.
 This counting is reset whenever a different number of fingers is reported.
 byte 0:
    firmware version 1.x:
       bit   7   6   5   4   3   2   1   0
             D   U  p1  p2   1  p3   R   L
             L, R = 1 when Left, Right mouse button pressed
             p1..p3 = byte 1..3 odd parity bit
             D, U = 1 when rocker switch pressed Up, Down
    firmware version 2.x:
       bit   7   6   5   4   3   2   1   0
            n1  n0  p2  p1   1  p3   R   L
             L, R = 1 when Left, Right mouse button pressed
             p1..p3 = byte 1..3 odd parity bit
             n1..n0 = number of fingers on touchpad
 byte 1:
    firmware version 1.x:
       bit   7   6   5   4   3   2   1   0
             f   0  th  tw  x9  x8  y9  y8
             tw = 1 when two finger touch
             th = 1 when three finger touch
             f  = 1 when finger touch
    firmware version 2.x:
       bit   7   6   5   4   3   2   1   0
             .   .   .   .  x9  x8  y9  y8
 byte 2:
    bit   7   6   5   4   3   2   1   0
         x7  x6  x5  x4  x3  x2  x1  x0
          x9..x0 = absolute x value (horizontal)
 byte 3:
    bit   7   6   5   4   3   2   1   0
         y7  y6  y5  y4  y3  y2  y1  y0
          y9..y0 = absolute y value (vertical)
 /////////////////////////////////////////////////////////////////////////////
 5. Hardware version 2
    ==================
 5.1 Registers
     ~~~~~~~~~
 By echoing a hexadecimal value to a register it contents can be altered.
 For example:
    echo -n 0x56 > reg_10
 * reg_10
    bit   7   6   5   4   3   2   1   0
          0   1   0   1   0   1   D   0
          D: 1 = enable drag and drop
 * reg_11
    bit   7   6   5   4   3   2   1   0
          1   0   0   0   S   0   1   0
          S: 1 = enable vertical scroll
 * reg_21
          unknown (0x00)
 * reg_22
          drag and drop release time out (short: 0x70 ... long 0x7e;
                                    0x7f = never i.e. tap again to release)
 5.2 Native absolute mode 6 byte packet format
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 5.2.1 Parity checking and packet re-synchronization
 There is no parity checking, however some consistency checks can be performed.
 For instance for EF113:
         SA1= packet[0];
         A1 = packet[1];
         B1 = packet[2];
         SB1= packet[3];
         C1 = packet[4];
         D1 = packet[5];
         if( (((SA1 & 0x3C) != 0x3C) && ((SA1 & 0xC0) != 0x80)) || // check Byte 1
             (((SA1 & 0x0C) != 0x0C) && ((SA1 & 0xC0) == 0x80)) || // check Byte 1 (one finger pressed)
             (((SA1 & 0xC0) != 0x80) && (( A1 & 0xF0) != 0x00)) || // check Byte 2
             (((SB1 & 0x3E) != 0x38) && ((SA1 & 0xC0) != 0x80)) || // check Byte 4
             (((SB1 & 0x0E) != 0x08) && ((SA1 & 0xC0) == 0x80)) || // check Byte 4 (one finger pressed)
             (((SA1 & 0xC0) != 0x80) && (( C1 & 0xF0) != 0x00))  ) // check Byte 5
 		// error detected
 For all the other ones, there are just a few constant bits:
         if( ((packet[0] & 0x0C) != 0x04) ||
             ((packet[3] & 0x0f) != 0x02) )
 		// error detected
 In case an error is detected, all the packets are shifted by one (and packet[0] is discarded).
 5.2.2 One/Three finger touch
       ~~~~~~~~~~~~~~~~
 byte 0:
    bit   7   6   5   4   3   2   1   0
 	 n1  n0  w3  w2   .   .   R   L
          L, R = 1 when Left, Right mouse button pressed
          n1..n0 = number of fingers on touchpad
 byte 1:
    bit   7   6   5   4   3   2   1   0
 	 p7  p6  p5  p4 x11 x10 x9  x8
 byte 2:
    bit   7   6   5   4   3   2   1   0
 	 x7  x6  x5  x4  x3  x2  x1  x0
          x11..x0 = absolute x value (horizontal)
 byte 3:
    bit   7   6   5   4   3   2   1   0
 	 n4  vf  w1  w0   .   .   .  b2
 	 n4 = set if more than 3 fingers (only in 3 fingers mode)
 	 vf = a kind of flag ? (only on EF123, 0 when finger is over one
 	      of the buttons, 1 otherwise)
 	 w3..w0 = width of the finger touch (not EF113)
 	 b2 (on EF113 only, 0 otherwise), b2.R.L indicates one button pressed:
 		0 = none
 		1 = Left
 		2 = Right
 		3 = Middle (Left and Right)
 		4 = Forward
 		5 = Back
 		6 = Another one
 		7 = Another one
 byte 4:
    bit   7   6   5   4   3   2   1   0
         p3  p1  p2  p0  y11 y10 y9  y8
 	 p7..p0 = pressure (not EF113)
 byte 5:
    bit   7   6   5   4   3   2   1   0
         y7  y6  y5  y4  y3  y2  y1  y0
          y11..y0 = absolute y value (vertical)
 5.2.3 Two finger touch
       ~~~~~~~~~~~~~~~~
 Note that the two pairs of coordinates are not exactly the coordinates of the
 two fingers, but only the pair of the lower-left and upper-right coordinates.
 So the actual fingers might be situated on the other diagonal of the square
 defined by these two points.
 byte 0:
    bit   7   6   5   4   3   2   1   0
         n1  n0  ay8 ax8  .   .   R   L
          L, R = 1 when Left, Right mouse button pressed
          n1..n0 = number of fingers on touchpad
 byte 1:
    bit   7   6   5   4   3   2   1   0
         ax7 ax6 ax5 ax4 ax3 ax2 ax1 ax0
 	 ax8..ax0 = lower-left finger absolute x value
 byte 2:
    bit   7   6   5   4   3   2   1   0
         ay7 ay6 ay5 ay4 ay3 ay2 ay1 ay0
 	 ay8..ay0 = lower-left finger absolute y value
 byte 3:
    bit   7   6   5   4   3   2   1   0
          .   .  by8 bx8  .   .   .   .
 byte 4:
    bit   7   6   5   4   3   2   1   0
         bx7 bx6 bx5 bx4 bx3 bx2 bx1 bx0
          bx8..bx0 = upper-right finger absolute x value
 byte 5:
    bit   7   6   5   4   3   2   1   0
         by7 by8 by5 by4 by3 by2 by1 by0
          by8..by0 = upper-right finger absolute y value
 /////////////////////////////////////////////////////////////////////////////
 6. Hardware version 3
    ==================
 6.1 Registers
     ~~~~~~~~~
 * reg_10
    bit   7   6   5   4   3   2   1   0
          0   0   0   0   R   F   T   A
          A: 1 = enable absolute tracking
          T: 1 = enable two finger mode auto correct
          F: 1 = disable ABS Position Filter
          R: 1 = enable real hardware resolution
 6.2 Native absolute mode 6 byte packet format
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 1 and 3 finger touch shares the same 6-byte packet format, except that
 3 finger touch only reports the position of the center of all three fingers.
 Firmware would send 12 bytes of data for 2 finger touch.
 Note on debounce:
 In case the box has unstable power supply or other electricity issues, or
 when number of finger changes, F/W would send "debounce packet" to inform
 driver that the hardware is in debounce status.
 The debouce packet has the following signature:
     byte 0: 0xc4
     byte 1: 0xff
     byte 2: 0xff
     byte 3: 0x02
     byte 4: 0xff
     byte 5: 0xff
 When we encounter this kind of packet, we just ignore it.
 6.2.1 One/Three finger touch
       ~~~~~~~~~~~~~~~~~~~~~~
 byte 0:
    bit   7   6   5   4   3   2   1   0
         n1  n0  w3  w2   0   1   R   L
         L, R = 1 when Left, Right mouse button pressed
         n1..n0 = number of fingers on touchpad
 byte 1:
    bit   7   6   5   4   3   2   1   0
         p7  p6  p5  p4 x11 x10  x9  x8
 byte 2:
    bit   7   6   5   4   3   2   1   0
         x7  x6  x5  x4  x3  x2  x1  x0
         x11..x0 = absolute x value (horizontal)
 byte 3:
    bit   7   6   5   4   3   2   1   0
          0   0  w1  w0   0   0   1   0
          w3..w0 = width of the finger touch
 byte 4:
    bit   7   6   5   4   3   2   1   0
         p3  p1  p2  p0  y11 y10 y9  y8
         p7..p0 = pressure
 byte 5:
    bit   7   6   5   4   3   2   1   0
         y7  y6  y5  y4  y3  y2  y1  y0
         y11..y0 = absolute y value (vertical)
 6.2.2 Two finger touch
       ~~~~~~~~~~~~~~~~
 The packet format is exactly the same for two finger touch, except the hardware
 sends two 6 byte packets. The first packet contains data for the first finger,
 the second packet has data for the second finger. So for two finger touch a
 total of 12 bytes are sent.
 /////////////////////////////////////////////////////////////////////////////
 7. Hardware version 4
    ==================
 7.1 Registers
     ~~~~~~~~~
 * reg_07
    bit   7   6   5   4   3   2   1   0
          0   0   0   0   0   0   0   A
          A: 1 = enable absolute tracking
 7.2 Native absolute mode 6 byte packet format
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 v4 hardware is a true multitouch touchpad, capable of tracking up to 5 fingers.
 Unfortunately, due to PS/2's limited bandwidth, its packet format is rather
 complex.
 Whenever the numbers or identities of the fingers changes, the hardware sends a
 status packet to indicate how many and which fingers is on touchpad, followed by
 head packets or motion packets. A head packet contains data of finger id, finger
 position (absolute x, y values), width, and pressure. A motion packet contains
 two fingers' position delta.
 For example, when status packet tells there are 2 fingers on touchpad, then we
 can expect two following head packets. If the finger status doesn't change,
 the following packets would be motion packets, only sending delta of finger
 position, until we receive a status packet.
 One exception is one finger touch. when a status packet tells us there is only
 one finger, the hardware would just send head packets afterwards.
 7.2.1 Status packet
       ~~~~~~~~~~~~~
 byte 0:
    bit   7   6   5   4   3   2   1   0
          .   .   .   .   0   1   R   L
          L, R = 1 when Left, Right mouse button pressed
 byte 1:
    bit   7   6   5   4   3   2   1   0
          .   .   . ft4 ft3 ft2 ft1 ft0
          ft4 ft3 ft2 ft1 ft0 ftn = 1 when finger n is on touchpad
 byte 2: not used
 byte 3:
    bit   7   6   5   4   3   2   1   0
          .   .   .   1   0   0   0   0
          constant bits
 byte 4:
    bit   7   6   5   4   3   2   1   0
          p   .   .   .   .   .   .   .
          p = 1 for palm
 byte 5: not used
 7.2.2 Head packet
       ~~~~~~~~~~~
 byte 0:
    bit   7   6   5   4   3   2   1   0
         w3  w2  w1  w0   0   1   R   L
         L, R = 1 when Left, Right mouse button pressed
         w3..w0 = finger width (spans how many trace lines)
 byte 1:
    bit   7   6   5   4   3   2   1   0
         p7  p6  p5  p4 x11 x10  x9  x8
 byte 2:
    bit   7   6   5   4   3   2   1   0
         x7  x6  x5  x4  x3  x2  x1  x0
         x11..x0 = absolute x value (horizontal)
 byte 3:
    bit   7   6   5   4   3   2   1   0
        id2 id1 id0   1   0   0   0   1
        id2..id0 = finger id
 byte 4:
    bit   7   6   5   4   3   2   1   0
         p3  p1  p2  p0  y11 y10 y9  y8
         p7..p0 = pressure
 byte 5:
    bit   7   6   5   4   3   2   1   0
         y7  y6  y5  y4  y3  y2  y1  y0
         y11..y0 = absolute y value (vertical)
 7.2.3 Motion packet
       ~~~~~~~~~~~~~
 byte 0:
    bit   7   6   5   4   3   2   1   0
        id2 id1 id0   w   0   1   R   L
        L, R = 1 when Left, Right mouse button pressed
        id2..id0 = finger id
        w = 1 when delta overflows (> 127 or < -128), in this case
        firmware sends us (delta x / 5) and (delta y  / 5)
 byte 1:
    bit   7   6   5   4   3   2   1   0
         x7  x6  x5  x4  x3  x2  x1  x0
         x7..x0 = delta x (two's complement)
 byte 2:
    bit   7   6   5   4   3   2   1   0
         y7  y6  y5  y4  y3  y2  y1  y0
         y7..y0 = delta y (two's complement)
 byte 3:
    bit   7   6   5   4   3   2   1   0
        id2 id1 id0   1   0   0   1   0
        id2..id0 = finger id
 byte 4:
    bit   7   6   5   4   3   2   1   0
         x7  x6  x5  x4  x3  x2  x1  x0
         x7..x0 = delta x (two's complement)
 byte 5:
    bit   7   6   5   4   3   2   1   0
         y7  y6  y5  y4  y3  y2  y1  y0
         y7..y0 = delta y (two's complement)
         byte 0 ~ 2 for one finger
         byte 3 ~ 5 for another
+8. Trackpoint (for Hardware version 3 and 4)
+   =========================================
+8.1 Registers
+    ~~~~~~~~~
+No special registers have been identified.
+8.2 Native relative mode 6 byte packet format
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+8.2.1 Status Packet
+      ~~~~~~~~~~~~~
+byte 0:
+   bit   7   6   5   4   3   2   1   0
+         0   0  sx  sy   0   M   R   L
+byte 1:
+   bit   7   6   5   4   3   2   1   0
+       ~sx   0   0   0   0   0   0   0
+byte 2:
+   bit   7   6   5   4   3   2   1   0
+       ~sy   0   0   0   0   0   0   0
+byte 3:
+   bit   7   6   5   4   3   2   1   0
+         0   0 ~sy ~sx   0   1   1   0
+byte 4:
+   bit   7   6   5   4   3   2   1   0
+        x7  x6  x5  x4  x3  x2  x1  x0
+byte 5:
+   bit   7   6   5   4   3   2   1   0
+        y7  y6  y5  y4  y3  y2  y1  y0
+         x and y are written in two's complement spread
+             over 9 bits with sx/sy the relative top bit and
+             x7..x0 and y7..y0 the lower bits.
+	 ~sx is the inverse of sx, ~sy is the inverse of sy.
+         The sign of y is opposite to what the input driver
+             expects for a relative movement

drivers/input/misc/twl4030-pwrbutton.c

Diff comments View file @ 56c381f

 /**
  * twl4030-pwrbutton.c - TWL4030 Power Button Input Driver
  *
  * Copyright (C) 2008-2009 Nokia Corporation
  *
  * Written by Peter De Schrijver <peter.de-schrijver@nokia.com>
  * Several fixes by Felipe Balbi <felipe.balbi@nokia.com>
  *
  * This file is subject to the terms and conditions of the GNU General
  * Public License. See the file "COPYING" in the main directory of this
  * archive for more details.
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/input.h>
 #include <linux/interrupt.h>
 #include <linux/platform_device.h>
 #include <linux/i2c/twl.h>
 #define PWR_PWRON_IRQ (1 << 0)
 #define STS_HW_CONDITIONS 0xf
 static irqreturn_t powerbutton_irq(int irq, void *_pwr)
 {
 	struct input_dev *pwr = _pwr;
 	int err;
 	u8 value;
 	err = twl_i2c_read_u8(TWL_MODULE_PM_MASTER, &value, STS_HW_CONDITIONS);
 	if (!err)  {
 		pm_wakeup_event(pwr->dev.parent, 0);
 		input_report_key(pwr, KEY_POWER, value & PWR_PWRON_IRQ);
 		input_sync(pwr);
 	} else {
 		dev_err(pwr->dev.parent, "twl4030: i2c error %d while reading"
 			" TWL4030 PM_MASTER STS_HW_CONDITIONS register\n", err);
 	}
 	return IRQ_HANDLED;
 }
 static int twl4030_pwrbutton_probe(struct platform_device *pdev)
 {
 	struct input_dev *pwr;
 	int irq = platform_get_irq(pdev, 0);
 	int err;
 	pwr = devm_input_allocate_device(&pdev->dev);
 	if (!pwr) {
 		dev_err(&pdev->dev, "Can't allocate power button\n");
 		return -ENOMEM;
 	}
 	pwr->evbit[0] = BIT_MASK(EV_KEY);
 	pwr->keybit[BIT_WORD(KEY_POWER)] = BIT_MASK(KEY_POWER);
 	pwr->name = "twl4030_pwrbutton";
 	pwr->phys = "twl4030_pwrbutton/input0";
 	pwr->dev.parent = &pdev->dev;
 	err = devm_request_threaded_irq(&pwr->dev, irq, NULL, powerbutton_irq,
 			IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
 			"twl4030_pwrbutton", pwr);
 	if (err < 0) {
 		dev_err(&pdev->dev, "Can't get IRQ for pwrbutton: %d\n", err);
 		return err;
 	}
 	err = input_register_device(pwr);
 	if (err) {
 		dev_err(&pdev->dev, "Can't register power button: %d\n", err);
 		return err;
 	}
 	platform_set_drvdata(pdev, pwr);
+	device_init_wakeup(&pdev->dev, true);
 	return 0;
 }
 #ifdef CONFIG_OF
 static const struct of_device_id twl4030_pwrbutton_dt_match_table[] = {
        { .compatible = "ti,twl4030-pwrbutton" },
        {},
 };
 MODULE_DEVICE_TABLE(of, twl4030_pwrbutton_dt_match_table);
 #endif
 static struct platform_driver twl4030_pwrbutton_driver = {
 	.probe		= twl4030_pwrbutton_probe,
 	.driver		= {
 		.name	= "twl4030_pwrbutton",
 		.owner	= THIS_MODULE,
 		.of_match_table = of_match_ptr(twl4030_pwrbutton_dt_match_table),
 	},
 };
 module_platform_driver(twl4030_pwrbutton_driver);
 MODULE_ALIAS("platform:twl4030_pwrbutton");
 MODULE_DESCRIPTION("Triton2 Power Button");
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Peter De Schrijver <peter.de-schrijver@nokia.com>");
 MODULE_AUTHOR("Felipe Balbi <felipe.balbi@nokia.com>");

drivers/input/mouse/alps.c

Diff comments View file @ 56c381f

 /*
  * ALPS touchpad PS/2 mouse driver
  *
  * Copyright (c) 2003 Neil Brown <neilb@cse.unsw.edu.au>
  * Copyright (c) 2003-2005 Peter Osterlund <petero2@telia.com>
  * Copyright (c) 2004 Dmitry Torokhov <dtor@mail.ru>
  * Copyright (c) 2005 Vojtech Pavlik <vojtech@suse.cz>
  * Copyright (c) 2009 Sebastian Kapfer <sebastian_kapfer@gmx.net>
  *
  * ALPS detection, tap switching and status querying info is taken from
  * tpconfig utility (by C. Scott Ananian and Bruce Kall).
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 as published by
  * the Free Software Foundation.
  */
 #include <linux/slab.h>
 #include <linux/input.h>
 #include <linux/input/mt.h>
 #include <linux/serio.h>
 #include <linux/libps2.h>
 #include "psmouse.h"
 #include "alps.h"
 /*
  * Definitions for ALPS version 3 and 4 command mode protocol
  */
 #define ALPS_CMD_NIBBLE_10	0x01f2
 #define ALPS_REG_BASE_RUSHMORE	0xc2c0
 #define ALPS_REG_BASE_PINNACLE	0x0000
 static const struct alps_nibble_commands alps_v3_nibble_commands[] = {
 	{ PSMOUSE_CMD_SETPOLL,		0x00 }, /* 0 */
 	{ PSMOUSE_CMD_RESET_DIS,	0x00 }, /* 1 */
 	{ PSMOUSE_CMD_SETSCALE21,	0x00 }, /* 2 */
 	{ PSMOUSE_CMD_SETRATE,		0x0a }, /* 3 */
 	{ PSMOUSE_CMD_SETRATE,		0x14 }, /* 4 */
 	{ PSMOUSE_CMD_SETRATE,		0x28 }, /* 5 */
 	{ PSMOUSE_CMD_SETRATE,		0x3c }, /* 6 */
 	{ PSMOUSE_CMD_SETRATE,		0x50 }, /* 7 */
 	{ PSMOUSE_CMD_SETRATE,		0x64 }, /* 8 */
 	{ PSMOUSE_CMD_SETRATE,		0xc8 }, /* 9 */
 	{ ALPS_CMD_NIBBLE_10,		0x00 }, /* a */
 	{ PSMOUSE_CMD_SETRES,		0x00 }, /* b */
 	{ PSMOUSE_CMD_SETRES,		0x01 }, /* c */
 	{ PSMOUSE_CMD_SETRES,		0x02 }, /* d */
 	{ PSMOUSE_CMD_SETRES,		0x03 }, /* e */
 	{ PSMOUSE_CMD_SETSCALE11,	0x00 }, /* f */
 };
 static const struct alps_nibble_commands alps_v4_nibble_commands[] = {
 	{ PSMOUSE_CMD_ENABLE,		0x00 }, /* 0 */
 	{ PSMOUSE_CMD_RESET_DIS,	0x00 }, /* 1 */
 	{ PSMOUSE_CMD_SETSCALE21,	0x00 }, /* 2 */
 	{ PSMOUSE_CMD_SETRATE,		0x0a }, /* 3 */
 	{ PSMOUSE_CMD_SETRATE,		0x14 }, /* 4 */
 	{ PSMOUSE_CMD_SETRATE,		0x28 }, /* 5 */
 	{ PSMOUSE_CMD_SETRATE,		0x3c }, /* 6 */
 	{ PSMOUSE_CMD_SETRATE,		0x50 }, /* 7 */
 	{ PSMOUSE_CMD_SETRATE,		0x64 }, /* 8 */
 	{ PSMOUSE_CMD_SETRATE,		0xc8 }, /* 9 */
 	{ ALPS_CMD_NIBBLE_10,		0x00 }, /* a */
 	{ PSMOUSE_CMD_SETRES,		0x00 }, /* b */
 	{ PSMOUSE_CMD_SETRES,		0x01 }, /* c */
 	{ PSMOUSE_CMD_SETRES,		0x02 }, /* d */
 	{ PSMOUSE_CMD_SETRES,		0x03 }, /* e */
 	{ PSMOUSE_CMD_SETSCALE11,	0x00 }, /* f */
 };
 static const struct alps_nibble_commands alps_v6_nibble_commands[] = {
 	{ PSMOUSE_CMD_ENABLE,		0x00 }, /* 0 */
 	{ PSMOUSE_CMD_SETRATE,		0x0a }, /* 1 */
 	{ PSMOUSE_CMD_SETRATE,		0x14 }, /* 2 */
 	{ PSMOUSE_CMD_SETRATE,		0x28 }, /* 3 */
 	{ PSMOUSE_CMD_SETRATE,		0x3c }, /* 4 */
 	{ PSMOUSE_CMD_SETRATE,		0x50 }, /* 5 */
 	{ PSMOUSE_CMD_SETRATE,		0x64 }, /* 6 */
 	{ PSMOUSE_CMD_SETRATE,		0xc8 }, /* 7 */
 	{ PSMOUSE_CMD_GETID,		0x00 }, /* 8 */
 	{ PSMOUSE_CMD_GETINFO,		0x00 }, /* 9 */
 	{ PSMOUSE_CMD_SETRES,		0x00 }, /* a */
 	{ PSMOUSE_CMD_SETRES,		0x01 }, /* b */
 	{ PSMOUSE_CMD_SETRES,		0x02 }, /* c */
 	{ PSMOUSE_CMD_SETRES,		0x03 }, /* d */
 	{ PSMOUSE_CMD_SETSCALE21,	0x00 }, /* e */
 	{ PSMOUSE_CMD_SETSCALE11,	0x00 }, /* f */
 };
 #define ALPS_DUALPOINT		0x02	/* touchpad has trackstick */
 #define ALPS_PASS		0x04	/* device has a pass-through port */
 #define ALPS_WHEEL		0x08	/* hardware wheel present */
 #define ALPS_FW_BK_1		0x10	/* front & back buttons present */
 #define ALPS_FW_BK_2		0x20	/* front & back buttons present */
 #define ALPS_FOUR_BUTTONS	0x40	/* 4 direction button present */
 #define ALPS_PS2_INTERLEAVED	0x80	/* 3-byte PS/2 packet interleaved with
 					   6-byte ALPS packet */
 #define ALPS_IS_RUSHMORE	0x100	/* device is a rushmore */
 #define ALPS_BUTTONPAD		0x200	/* device is a clickpad */
 static const struct alps_model_info alps_model_data[] = {
 	{ { 0x32, 0x02, 0x14 },	0x00, ALPS_PROTO_V2, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT },	/* Toshiba Salellite Pro M10 */
 	{ { 0x33, 0x02, 0x0a },	0x00, ALPS_PROTO_V1, 0x88, 0xf8, 0 },				/* UMAX-530T */
 	{ { 0x53, 0x02, 0x0a },	0x00, ALPS_PROTO_V2, 0xf8, 0xf8, 0 },
 	{ { 0x53, 0x02, 0x14 },	0x00, ALPS_PROTO_V2, 0xf8, 0xf8, 0 },
 	{ { 0x60, 0x03, 0xc8 }, 0x00, ALPS_PROTO_V2, 0xf8, 0xf8, 0 },				/* HP ze1115 */
 	{ { 0x63, 0x02, 0x0a },	0x00, ALPS_PROTO_V2, 0xf8, 0xf8, 0 },
 	{ { 0x63, 0x02, 0x14 },	0x00, ALPS_PROTO_V2, 0xf8, 0xf8, 0 },
 	{ { 0x63, 0x02, 0x28 },	0x00, ALPS_PROTO_V2, 0xf8, 0xf8, ALPS_FW_BK_2 },		/* Fujitsu Siemens S6010 */
 	{ { 0x63, 0x02, 0x3c },	0x00, ALPS_PROTO_V2, 0x8f, 0x8f, ALPS_WHEEL },			/* Toshiba Satellite S2400-103 */
 	{ { 0x63, 0x02, 0x50 },	0x00, ALPS_PROTO_V2, 0xef, 0xef, ALPS_FW_BK_1 },		/* NEC Versa L320 */
 	{ { 0x63, 0x02, 0x64 },	0x00, ALPS_PROTO_V2, 0xf8, 0xf8, 0 },
 	{ { 0x63, 0x03, 0xc8 }, 0x00, ALPS_PROTO_V2, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT },	/* Dell Latitude D800 */
 	{ { 0x73, 0x00, 0x0a },	0x00, ALPS_PROTO_V2, 0xf8, 0xf8, ALPS_DUALPOINT },		/* ThinkPad R61 8918-5QG */
 	{ { 0x73, 0x02, 0x0a },	0x00, ALPS_PROTO_V2, 0xf8, 0xf8, 0 },
 	{ { 0x73, 0x02, 0x14 },	0x00, ALPS_PROTO_V2, 0xf8, 0xf8, ALPS_FW_BK_2 },		/* Ahtec Laptop */
 	{ { 0x20, 0x02, 0x0e },	0x00, ALPS_PROTO_V2, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT },	/* XXX */
 	{ { 0x22, 0x02, 0x0a },	0x00, ALPS_PROTO_V2, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT },
 	{ { 0x22, 0x02, 0x14 }, 0x00, ALPS_PROTO_V2, 0xff, 0xff, ALPS_PASS | ALPS_DUALPOINT },	/* Dell Latitude D600 */
 	/* Dell Latitude E5500, E6400, E6500, Precision M4400 */
 	{ { 0x62, 0x02, 0x14 }, 0x00, ALPS_PROTO_V2, 0xcf, 0xcf,
 		ALPS_PASS | ALPS_DUALPOINT | ALPS_PS2_INTERLEAVED },
 	{ { 0x73, 0x00, 0x14 }, 0x00, ALPS_PROTO_V6, 0xff, 0xff, ALPS_DUALPOINT },		/* Dell XT2 */
 	{ { 0x73, 0x02, 0x50 }, 0x00, ALPS_PROTO_V2, 0xcf, 0xcf, ALPS_FOUR_BUTTONS },		/* Dell Vostro 1400 */
 	{ { 0x52, 0x01, 0x14 }, 0x00, ALPS_PROTO_V2, 0xff, 0xff,
 		ALPS_PASS | ALPS_DUALPOINT | ALPS_PS2_INTERLEAVED },				/* Toshiba Tecra A11-11L */
 	{ { 0x73, 0x02, 0x64 },	0x8a, ALPS_PROTO_V4, 0x8f, 0x8f, 0 },
 };
 static void alps_set_abs_params_st(struct alps_data *priv,
 				   struct input_dev *dev1);
 static void alps_set_abs_params_mt(struct alps_data *priv,
 				   struct input_dev *dev1);
 /*
  * XXX - this entry is suspicious. First byte has zero lower nibble,
  * which is what a normal mouse would report. Also, the value 0x0e
  * isn't valid per PS/2 spec.
  */
 /* Packet formats are described in Documentation/input/alps.txt */
 static bool alps_is_valid_first_byte(struct alps_data *priv,
 				     unsigned char data)
 {
 	return (data & priv->mask0) == priv->byte0;
 }
 static void alps_report_buttons(struct psmouse *psmouse,
 				struct input_dev *dev1, struct input_dev *dev2,
 				int left, int right, int middle)
 {
 	struct input_dev *dev;
 	/*
 	 * If shared button has already been reported on the
 	 * other device (dev2) then this event should be also
 	 * sent through that device.
 	 */
 	dev = test_bit(BTN_LEFT, dev2->key) ? dev2 : dev1;
 	input_report_key(dev, BTN_LEFT, left);
 	dev = test_bit(BTN_RIGHT, dev2->key) ? dev2 : dev1;
 	input_report_key(dev, BTN_RIGHT, right);
 	dev = test_bit(BTN_MIDDLE, dev2->key) ? dev2 : dev1;
 	input_report_key(dev, BTN_MIDDLE, middle);
 	/*
 	 * Sync the _other_ device now, we'll do the first
 	 * device later once we report the rest of the events.
 	 */
 	input_sync(dev2);
 }
 static void alps_process_packet_v1_v2(struct psmouse *psmouse)
 {
 	struct alps_data *priv = psmouse->private;
 	unsigned char *packet = psmouse->packet;
 	struct input_dev *dev = psmouse->dev;
 	struct input_dev *dev2 = priv->dev2;
 	int x, y, z, ges, fin, left, right, middle;
 	int back = 0, forward = 0;
 	if (priv->proto_version == ALPS_PROTO_V1) {
 		left = packet[2] & 0x10;
 		right = packet[2] & 0x08;
 		middle = 0;
 		x = packet[1] | ((packet[0] & 0x07) << 7);
 		y = packet[4] | ((packet[3] & 0x07) << 7);
 		z = packet[5];
 	} else {
 		left = packet[3] & 1;
 		right = packet[3] & 2;
 		middle = packet[3] & 4;
 		x = packet[1] | ((packet[2] & 0x78) << (7 - 3));
 		y = packet[4] | ((packet[3] & 0x70) << (7 - 4));
 		z = packet[5];
 	}
 	if (priv->flags & ALPS_FW_BK_1) {
 		back = packet[0] & 0x10;
 		forward = packet[2] & 4;
 	}
 	if (priv->flags & ALPS_FW_BK_2) {
 		back = packet[3] & 4;
 		forward = packet[2] & 4;
 		if ((middle = forward && back))
 			forward = back = 0;
 	}
 	ges = packet[2] & 1;
 	fin = packet[2] & 2;
 	if ((priv->flags & ALPS_DUALPOINT) && z == 127) {
 		input_report_rel(dev2, REL_X,  (x > 383 ? (x - 768) : x));
 		input_report_rel(dev2, REL_Y, -(y > 255 ? (y - 512) : y));
 		alps_report_buttons(psmouse, dev2, dev, left, right, middle);
 		input_sync(dev2);
 		return;
 	}
 	alps_report_buttons(psmouse, dev, dev2, left, right, middle);
 	/* Convert hardware tap to a reasonable Z value */
 	if (ges && !fin)
 		z = 40;
 	/*
 	 * A "tap and drag" operation is reported by the hardware as a transition
 	 * from (!fin && ges) to (fin && ges). This should be translated to the
 	 * sequence Z>0, Z==0, Z>0, so the Z==0 event has to be generated manually.
 	 */
 	if (ges && fin && !priv->prev_fin) {
 		input_report_abs(dev, ABS_X, x);
 		input_report_abs(dev, ABS_Y, y);
 		input_report_abs(dev, ABS_PRESSURE, 0);
 		input_report_key(dev, BTN_TOOL_FINGER, 0);
 		input_sync(dev);
 	}
 	priv->prev_fin = fin;
 	if (z > 30)
 		input_report_key(dev, BTN_TOUCH, 1);
 	if (z < 25)
 		input_report_key(dev, BTN_TOUCH, 0);
 	if (z > 0) {
 		input_report_abs(dev, ABS_X, x);
 		input_report_abs(dev, ABS_Y, y);
 	}
 	input_report_abs(dev, ABS_PRESSURE, z);
 	input_report_key(dev, BTN_TOOL_FINGER, z > 0);
 	if (priv->flags & ALPS_WHEEL)
 		input_report_rel(dev, REL_WHEEL, ((packet[2] << 1) & 0x08) - ((packet[0] >> 4) & 0x07));
 	if (priv->flags & (ALPS_FW_BK_1 | ALPS_FW_BK_2)) {
 		input_report_key(dev, BTN_FORWARD, forward);
 		input_report_key(dev, BTN_BACK, back);
 	}
 	if (priv->flags & ALPS_FOUR_BUTTONS) {
 		input_report_key(dev, BTN_0, packet[2] & 4);
 		input_report_key(dev, BTN_1, packet[0] & 0x10);
 		input_report_key(dev, BTN_2, packet[3] & 4);
 		input_report_key(dev, BTN_3, packet[0] & 0x20);
 	}
 	input_sync(dev);
 }
 /*
  * Process bitmap data for V5 protocols. Return value is null.
  *
  * The bitmaps don't have enough data to track fingers, so this function
  * only generates points representing a bounding box of at most two contacts.
  * These two points are returned in fields->mt.
  */
 static void alps_process_bitmap_dolphin(struct alps_data *priv,
 					struct alps_fields *fields)
 {
 	int box_middle_x, box_middle_y;
 	unsigned int x_map, y_map;
 	unsigned char start_bit, end_bit;
 	unsigned char x_msb, x_lsb, y_msb, y_lsb;
 	x_map = fields->x_map;
 	y_map = fields->y_map;
 	if (!x_map || !y_map)
 		return;
 	/* Get Most-significant and Least-significant bit */
 	x_msb = fls(x_map);
 	x_lsb = ffs(x_map);
 	y_msb = fls(y_map);
 	y_lsb = ffs(y_map);
 	/* Most-significant bit should never exceed max sensor line number */
 	if (x_msb > priv->x_bits || y_msb > priv->y_bits)
 		return;
 	if (fields->fingers > 1) {
 		start_bit = priv->x_bits - x_msb;
 		end_bit = priv->x_bits - x_lsb;
 		box_middle_x = (priv->x_max * (start_bit + end_bit)) /
 				(2 * (priv->x_bits - 1));
 		start_bit = y_lsb - 1;
 		end_bit = y_msb - 1;
 		box_middle_y = (priv->y_max * (start_bit + end_bit)) /
 				(2 * (priv->y_bits - 1));
 		fields->mt[0] = fields->st;
 		fields->mt[1].x = 2 * box_middle_x - fields->mt[0].x;
 		fields->mt[1].y = 2 * box_middle_y - fields->mt[0].y;
 	}
 }
 static void alps_get_bitmap_points(unsigned int map,
 				   struct alps_bitmap_point *low,
 				   struct alps_bitmap_point *high,
 				   int *fingers)
 {
 	struct alps_bitmap_point *point;
 	int i, bit, prev_bit = 0;
 	point = low;
 	for (i = 0; map != 0; i++, map >>= 1) {
 		bit = map & 1;
 		if (bit) {
 			if (!prev_bit) {
 				point->start_bit = i;
 				point->num_bits = 0;
 				(*fingers)++;
 			}
 			point->num_bits++;
 		} else {
 			if (prev_bit)
 				point = high;
 		}
 		prev_bit = bit;
 	}
 }
 /*
  * Process bitmap data from v3 and v4 protocols. Returns the number of
  * fingers detected. A return value of 0 means at least one of the
  * bitmaps was empty.
  *
  * The bitmaps don't have enough data to track fingers, so this function
  * only generates points representing a bounding box of all contacts.
  * These points are returned in fields->mt when the return value
  * is greater than 0.
  */
 static int alps_process_bitmap(struct alps_data *priv,
 			       struct alps_fields *fields)
 {
 	int i, fingers_x = 0, fingers_y = 0, fingers;
 	struct alps_bitmap_point x_low = {0,}, x_high = {0,};
 	struct alps_bitmap_point y_low = {0,}, y_high = {0,};
 	if (!fields->x_map || !fields->y_map)
 		return 0;
 	alps_get_bitmap_points(fields->x_map, &x_low, &x_high, &fingers_x);
 	alps_get_bitmap_points(fields->y_map, &y_low, &y_high, &fingers_y);
 	/*
 	 * Fingers can overlap, so we use the maximum count of fingers
 	 * on either axis as the finger count.
 	 */
 	fingers = max(fingers_x, fingers_y);
 	/*
 	 * If an axis reports only a single contact, we have overlapping or
 	 * adjacent fingers. Divide the single contact between the two points.
 	 */
 	if (fingers_x == 1) {
 		i = (x_low.num_bits - 1) / 2;
 		x_low.num_bits = x_low.num_bits - i;
 		x_high.start_bit = x_low.start_bit + i;
 		x_high.num_bits = max(i, 1);
 	}
 	if (fingers_y == 1) {
 		i = (y_low.num_bits - 1) / 2;
 		y_low.num_bits = y_low.num_bits - i;
 		y_high.start_bit = y_low.start_bit + i;
 		y_high.num_bits = max(i, 1);
 	}
 	fields->mt[0].x =
 		(priv->x_max * (2 * x_low.start_bit + x_low.num_bits - 1)) /
 		(2 * (priv->x_bits - 1));
 	fields->mt[0].y =
 		(priv->y_max * (2 * y_low.start_bit + y_low.num_bits - 1)) /
 		(2 * (priv->y_bits - 1));
 	fields->mt[1].x =
 		(priv->x_max * (2 * x_high.start_bit + x_high.num_bits - 1)) /
 		(2 * (priv->x_bits - 1));
 	fields->mt[1].y =
 		(priv->y_max * (2 * y_high.start_bit + y_high.num_bits - 1)) /
 		(2 * (priv->y_bits - 1));
 	/* y-bitmap order is reversed, except on rushmore */
 	if (!(priv->flags & ALPS_IS_RUSHMORE)) {
 		fields->mt[0].y = priv->y_max - fields->mt[0].y;
 		fields->mt[1].y = priv->y_max - fields->mt[1].y;
 	}
 	return fingers;
 }
 static void alps_set_slot(struct input_dev *dev, int slot, int x, int y)
 {
 	input_mt_slot(dev, slot);
 	input_mt_report_slot_state(dev, MT_TOOL_FINGER, true);
 	input_report_abs(dev, ABS_MT_POSITION_X, x);
 	input_report_abs(dev, ABS_MT_POSITION_Y, y);
 }
 static void alps_report_mt_data(struct psmouse *psmouse, int n)
 {
 	struct alps_data *priv = psmouse->private;
 	struct input_dev *dev = psmouse->dev;
 	struct alps_fields *f = &priv->f;
 	int i, slot[MAX_TOUCHES];
 	input_mt_assign_slots(dev, slot, f->mt, n);
 	for (i = 0; i < n; i++)
 		alps_set_slot(dev, slot[i], f->mt[i].x, f->mt[i].y);
 	input_mt_sync_frame(dev);
 }
 static void alps_report_semi_mt_data(struct psmouse *psmouse, int fingers)
 {
 	struct alps_data *priv = psmouse->private;
 	struct input_dev *dev = psmouse->dev;
 	struct alps_fields *f = &priv->f;
 	/* Use st data when we don't have mt data */
 	if (fingers < 2) {
 		f->mt[0].x = f->st.x;
 		f->mt[0].y = f->st.y;
 		fingers = f->pressure > 0 ? 1 : 0;
 	}
 	alps_report_mt_data(psmouse, (fingers <= 2) ? fingers : 2);
 	input_mt_report_finger_count(dev, fingers);
 	input_report_key(dev, BTN_LEFT, f->left);
 	input_report_key(dev, BTN_RIGHT, f->right);
 	input_report_key(dev, BTN_MIDDLE, f->middle);
 	input_report_abs(dev, ABS_PRESSURE, f->pressure);
 	input_sync(dev);
 }
 static void alps_process_trackstick_packet_v3(struct psmouse *psmouse)
 {
 	struct alps_data *priv = psmouse->private;
 	unsigned char *packet = psmouse->packet;
 	struct input_dev *dev = priv->dev2;
 	int x, y, z, left, right, middle;
 	/* Sanity check packet */
 	if (!(packet[0] & 0x40)) {
 		psmouse_dbg(psmouse, "Bad trackstick packet, discarding\n");
 		return;
 	}
 	/*
 	 * There's a special packet that seems to indicate the end
 	 * of a stream of trackstick data. Filter these out.
 	 */
 	if (packet[1] == 0x7f && packet[2] == 0x7f && packet[4] == 0x7f)
 		return;
 	x = (s8)(((packet[0] & 0x20) << 2) | (packet[1] & 0x7f));
 	y = (s8)(((packet[0] & 0x10) << 3) | (packet[2] & 0x7f));
 	z = (packet[4] & 0x7c) >> 2;
 	/*
 	 * The x and y values tend to be quite large, and when used
 	 * alone the trackstick is difficult to use. Scale them down
 	 * to compensate.
 	 */
 	x /= 8;
 	y /= 8;
 	input_report_rel(dev, REL_X, x);
 	input_report_rel(dev, REL_Y, -y);
 	/*
 	 * Most ALPS models report the trackstick buttons in the touchpad
 	 * packets, but a few report them here. No reliable way has been
 	 * found to differentiate between the models upfront, so we enable
 	 * the quirk in response to seeing a button press in the trackstick
 	 * packet.
 	 */
 	left = packet[3] & 0x01;
 	right = packet[3] & 0x02;
 	middle = packet[3] & 0x04;
 	if (!(priv->quirks & ALPS_QUIRK_TRACKSTICK_BUTTONS) &&
 	    (left || right || middle))
 		priv->quirks |= ALPS_QUIRK_TRACKSTICK_BUTTONS;
 	if (priv->quirks & ALPS_QUIRK_TRACKSTICK_BUTTONS) {
 		input_report_key(dev, BTN_LEFT, left);
 		input_report_key(dev, BTN_RIGHT, right);
 		input_report_key(dev, BTN_MIDDLE, middle);
 	}
 	input_sync(dev);
 	return;
 }
 static void alps_decode_buttons_v3(struct alps_fields *f, unsigned char *p)
 {
 	f->left = !!(p[3] & 0x01);
 	f->right = !!(p[3] & 0x02);
 	f->middle = !!(p[3] & 0x04);
 	f->ts_left = !!(p[3] & 0x10);
 	f->ts_right = !!(p[3] & 0x20);
 	f->ts_middle = !!(p[3] & 0x40);
 }
 static int alps_decode_pinnacle(struct alps_fields *f, unsigned char *p,
 				 struct psmouse *psmouse)
 {
 	f->first_mp = !!(p[4] & 0x40);
 	f->is_mp = !!(p[0] & 0x40);
 	f->fingers = (p[5] & 0x3) + 1;
 	f->x_map = ((p[4] & 0x7e) << 8) |
 		   ((p[1] & 0x7f) << 2) |
 		   ((p[0] & 0x30) >> 4);
 	f->y_map = ((p[3] & 0x70) << 4) |
 		   ((p[2] & 0x7f) << 1) |
 		   (p[4] & 0x01);
 	f->st.x = ((p[1] & 0x7f) << 4) | ((p[4] & 0x30) >> 2) |
 	       ((p[0] & 0x30) >> 4);
 	f->st.y = ((p[2] & 0x7f) << 4) | (p[4] & 0x0f);
 	f->pressure = p[5] & 0x7f;
 	alps_decode_buttons_v3(f, p);
 	return 0;
 }
 static int alps_decode_rushmore(struct alps_fields *f, unsigned char *p,
 				 struct psmouse *psmouse)
 {
 	alps_decode_pinnacle(f, p, psmouse);
 	/* Rushmore's packet decode has a bit difference with Pinnacle's */
 	f->is_mp = !!(p[5] & 0x40);
 	f->fingers = max((p[5] & 0x3), ((p[5] >> 2) & 0x3)) + 1;
 	f->x_map |= (p[5] & 0x10) << 11;
 	f->y_map |= (p[5] & 0x20) << 6;
 	return 0;
 }
 static int alps_decode_dolphin(struct alps_fields *f, unsigned char *p,
 				struct psmouse *psmouse)
 {
 	u64 palm_data = 0;
 	struct alps_data *priv = psmouse->private;
 	f->first_mp = !!(p[0] & 0x02);
 	f->is_mp = !!(p[0] & 0x20);
 	if (!f->is_mp) {
 		f->st.x = ((p[1] & 0x7f) | ((p[4] & 0x0f) << 7));
 		f->st.y = ((p[2] & 0x7f) | ((p[4] & 0xf0) << 3));
 		f->pressure = (p[0] & 4) ? 0 : p[5] & 0x7f;
 		alps_decode_buttons_v3(f, p);
 	} else {
 		f->fingers = ((p[0] & 0x6) >> 1 |
 		     (p[0] & 0x10) >> 2);
 		palm_data = (p[1] & 0x7f) |
 			    ((p[2] & 0x7f) << 7) |
 			    ((p[4] & 0x7f) << 14) |
 			    ((p[5] & 0x7f) << 21) |
 			    ((p[3] & 0x07) << 28) |
 			    (((u64)p[3] & 0x70) << 27) |
 			    (((u64)p[0] & 0x01) << 34);
 		/* Y-profile is stored in P(0) to p(n-1), n = y_bits; */
 		f->y_map = palm_data & (BIT(priv->y_bits) - 1);
 		/* X-profile is stored in p(n) to p(n+m-1), m = x_bits; */
 		f->x_map = (palm_data >> priv->y_bits) &
 			   (BIT(priv->x_bits) - 1);
 	}
 	return 0;
 }
 static void alps_process_touchpad_packet_v3_v5(struct psmouse *psmouse)
 {
 	struct alps_data *priv = psmouse->private;
 	unsigned char *packet = psmouse->packet;
 	struct input_dev *dev2 = priv->dev2;
 	struct alps_fields *f = &priv->f;
 	int fingers = 0;
 	memset(f, 0, sizeof(*f));
 	priv->decode_fields(f, packet, psmouse);
 	/*
 	 * There's no single feature of touchpad position and bitmap packets
 	 * that can be used to distinguish between them. We rely on the fact
 	 * that a bitmap packet should always follow a position packet with
 	 * bit 6 of packet[4] set.
 	 */
 	if (priv->multi_packet) {
 		/*
 		 * Sometimes a position packet will indicate a multi-packet
 		 * sequence, but then what follows is another position
 		 * packet. Check for this, and when it happens process the
 		 * position packet as usual.
 		 */
 		if (f->is_mp) {
 			fingers = f->fingers;
 			if (priv->proto_version == ALPS_PROTO_V3) {
 				if (alps_process_bitmap(priv, f) == 0)
 					fingers = 0; /* Use st data */
 				/* Now process position packet */
 				priv->decode_fields(f, priv->multi_data,
 						    psmouse);
 			} else {
 				/*
 				 * Because Dolphin uses position packet's
 				 * coordinate data as Pt1 and uses it to
 				 * calculate Pt2, so we need to do position
 				 * packet decode first.
 				 */
 				priv->decode_fields(f, priv->multi_data,
 						    psmouse);
 				/*
 				 * Since Dolphin's finger number is reliable,
 				 * there is no need to compare with bmap_fn.
 				 */
 				alps_process_bitmap_dolphin(priv, f);
 			}
 		} else {
 			priv->multi_packet = 0;
 		}
 	}
 	/*
 	 * Bit 6 of byte 0 is not usually set in position packets. The only
 	 * times it seems to be set is in situations where the data is
 	 * suspect anyway, e.g. a palm resting flat on the touchpad. Given
 	 * this combined with the fact that this bit is useful for filtering
 	 * out misidentified bitmap packets, we reject anything with this
 	 * bit set.
 	 */
 	if (f->is_mp)
 		return;
 	if (!priv->multi_packet && f->first_mp) {
 		priv->multi_packet = 1;
 		memcpy(priv->multi_data, packet, sizeof(priv->multi_data));
 		return;
 	}
 	priv->multi_packet = 0;
 	/*
 	 * Sometimes the hardware sends a single packet with z = 0
 	 * in the middle of a stream. Real releases generate packets
 	 * with x, y, and z all zero, so these seem to be flukes.
 	 * Ignore them.
 	 */
 	if (f->st.x && f->st.y && !f->pressure)
 		return;
 	alps_report_semi_mt_data(psmouse, fingers);
 	if (!(priv->quirks & ALPS_QUIRK_TRACKSTICK_BUTTONS)) {
 		input_report_key(dev2, BTN_LEFT, f->ts_left);
 		input_report_key(dev2, BTN_RIGHT, f->ts_right);
 		input_report_key(dev2, BTN_MIDDLE, f->ts_middle);
 		input_sync(dev2);
 	}
 }
 static void alps_process_packet_v3(struct psmouse *psmouse)
 {
 	unsigned char *packet = psmouse->packet;
 	/*
 	 * v3 protocol packets come in three types, two representing
 	 * touchpad data and one representing trackstick data.
 	 * Trackstick packets seem to be distinguished by always
 	 * having 0x3f in the last byte. This value has never been
 	 * observed in the last byte of either of the other types
 	 * of packets.
 	 */
 	if (packet[5] == 0x3f) {
 		alps_process_trackstick_packet_v3(psmouse);
 		return;
 	}
 	alps_process_touchpad_packet_v3_v5(psmouse);
 }
 static void alps_process_packet_v6(struct psmouse *psmouse)
 {
 	struct alps_data *priv = psmouse->private;
 	unsigned char *packet = psmouse->packet;
 	struct input_dev *dev = psmouse->dev;
 	struct input_dev *dev2 = priv->dev2;
 	int x, y, z, left, right, middle;
 	/*
 	 * We can use Byte5 to distinguish if the packet is from Touchpad
 	 * or Trackpoint.
 	 * Touchpad:	0 - 0x7E
 	 * Trackpoint:	0x7F
 	 */
 	if (packet[5] == 0x7F) {
 		/* It should be a DualPoint when received Trackpoint packet */
 		if (!(priv->flags & ALPS_DUALPOINT))
 			return;
 		/* Trackpoint packet */
 		x = packet[1] | ((packet[3] & 0x20) << 2);
 		y = packet[2] | ((packet[3] & 0x40) << 1);
 		z = packet[4];
 		left = packet[3] & 0x01;
 		right = packet[3] & 0x02;
 		middle = packet[3] & 0x04;
 		/* To prevent the cursor jump when finger lifted */
 		if (x == 0x7F && y == 0x7F && z == 0x7F)
 			x = y = z = 0;
 		/* Divide 4 since trackpoint's speed is too fast */
 		input_report_rel(dev2, REL_X, (char)x / 4);
 		input_report_rel(dev2, REL_Y, -((char)y / 4));
 		input_report_key(dev2, BTN_LEFT, left);
 		input_report_key(dev2, BTN_RIGHT, right);
 		input_report_key(dev2, BTN_MIDDLE, middle);
 		input_sync(dev2);
 		return;
 	}
 	/* Touchpad packet */
 	x = packet[1] | ((packet[3] & 0x78) << 4);
 	y = packet[2] | ((packet[4] & 0x78) << 4);
 	z = packet[5];
 	left = packet[3] & 0x01;
 	right = packet[3] & 0x02;
 	if (z > 30)
 		input_report_key(dev, BTN_TOUCH, 1);
 	if (z < 25)
 		input_report_key(dev, BTN_TOUCH, 0);
 	if (z > 0) {
 		input_report_abs(dev, ABS_X, x);
 		input_report_abs(dev, ABS_Y, y);
 	}
 	input_report_abs(dev, ABS_PRESSURE, z);
 	input_report_key(dev, BTN_TOOL_FINGER, z > 0);
 	/* v6 touchpad does not have middle button */
 	input_report_key(dev, BTN_LEFT, left);
 	input_report_key(dev, BTN_RIGHT, right);
 	input_sync(dev);
 }
 static void alps_process_packet_v4(struct psmouse *psmouse)
 {
 	struct alps_data *priv = psmouse->private;
 	unsigned char *packet = psmouse->packet;
 	struct alps_fields *f = &priv->f;
 	int offset;
 	/*
 	 * v4 has a 6-byte encoding for bitmap data, but this data is
 	 * broken up between 3 normal packets. Use priv->multi_packet to
 	 * track our position in the bitmap packet.
 	 */
 	if (packet[6] & 0x40) {
 		/* sync, reset position */
 		priv->multi_packet = 0;
 	}
 	if (WARN_ON_ONCE(priv->multi_packet > 2))
 		return;
 	offset = 2 * priv->multi_packet;
 	priv->multi_data[offset] = packet[6];
 	priv->multi_data[offset + 1] = packet[7];
 	if (++priv->multi_packet > 2) {
 		priv->multi_packet = 0;
 		f->x_map = ((priv->multi_data[2] & 0x1f) << 10) |
 			   ((priv->multi_data[3] & 0x60) << 3) |
 			   ((priv->multi_data[0] & 0x3f) << 2) |
 			   ((priv->multi_data[1] & 0x60) >> 5);
 		f->y_map = ((priv->multi_data[5] & 0x01) << 10) |
 			   ((priv->multi_data[3] & 0x1f) << 5) |
 			    (priv->multi_data[1] & 0x1f);
 		f->fingers = alps_process_bitmap(priv, f);
 	}
 	f->left = !!(packet[4] & 0x01);
 	f->right = !!(packet[4] & 0x02);
 	f->st.x = ((packet[1] & 0x7f) << 4) | ((packet[3] & 0x30) >> 2) |
 		  ((packet[0] & 0x30) >> 4);
 	f->st.y = ((packet[2] & 0x7f) << 4) | (packet[3] & 0x0f);
 	f->pressure = packet[5] & 0x7f;
 	alps_report_semi_mt_data(psmouse, f->fingers);
 }
 static bool alps_is_valid_package_v7(struct psmouse *psmouse)
 {
 	switch (psmouse->pktcnt) {
 	case 3:
 		return (psmouse->packet[2] & 0x40) == 0x40;
 	case 4:
 		return (psmouse->packet[3] & 0x48) == 0x48;
 	case 6:
 		return (psmouse->packet[5] & 0x40) == 0x00;
 	}
 	return true;
 }
 static unsigned char alps_get_packet_id_v7(char *byte)
 {
 	unsigned char packet_id;
 	if (byte[4] & 0x40)
 		packet_id = V7_PACKET_ID_TWO;
 	else if (byte[4] & 0x01)
 		packet_id = V7_PACKET_ID_MULTI;
 	else if ((byte[0] & 0x10) && !(byte[4] & 0x43))
 		packet_id = V7_PACKET_ID_NEW;
 	else if (byte[1] == 0x00 && byte[4] == 0x00)
 		packet_id = V7_PACKET_ID_IDLE;
 	else
 		packet_id = V7_PACKET_ID_UNKNOWN;
 	return packet_id;
 }
 static void alps_get_finger_coordinate_v7(struct input_mt_pos *mt,
 					  unsigned char *pkt,
 					  unsigned char pkt_id)
 {
 	mt[0].x = ((pkt[2] & 0x80) << 4);
 	mt[0].x |= ((pkt[2] & 0x3F) << 5);
 	mt[0].x |= ((pkt[3] & 0x30) >> 1);
 	mt[0].x |= (pkt[3] & 0x07);
 	mt[0].y = (pkt[1] << 3) | (pkt[0] & 0x07);
 	mt[1].x = ((pkt[3] & 0x80) << 4);
 	mt[1].x |= ((pkt[4] & 0x80) << 3);
 	mt[1].x |= ((pkt[4] & 0x3F) << 4);
 	mt[1].y = ((pkt[5] & 0x80) << 3);
 	mt[1].y |= ((pkt[5] & 0x3F) << 4);
 	switch (pkt_id) {
 	case V7_PACKET_ID_TWO:
 		mt[1].x &= ~0x000F;
 		mt[1].y |= 0x000F;
 		break;
 	case V7_PACKET_ID_MULTI:
 		mt[1].x &= ~0x003F;
 		mt[1].y &= ~0x0020;
 		mt[1].y |= ((pkt[4] & 0x02) << 4);
 		mt[1].y |= 0x001F;
 		break;
 	case V7_PACKET_ID_NEW:
 		mt[1].x &= ~0x003F;
 		mt[1].x |= (pkt[0] & 0x20);
 		mt[1].y |= 0x000F;
 		break;
 	}
 	mt[0].y = 0x7FF - mt[0].y;
 	mt[1].y = 0x7FF - mt[1].y;
 }
 static int alps_get_mt_count(struct input_mt_pos *mt)
 {
 	int i;
 	for (i = 0; i < MAX_TOUCHES && mt[i].x != 0 && mt[i].y != 0; i++)
 		/* empty */;
 	return i;
 }
 static int alps_decode_packet_v7(struct alps_fields *f,
 				  unsigned char *p,
 				  struct psmouse *psmouse)
 {
 	unsigned char pkt_id;
 	pkt_id = alps_get_packet_id_v7(p);
 	if (pkt_id == V7_PACKET_ID_IDLE)
 		return 0;
 	if (pkt_id == V7_PACKET_ID_UNKNOWN)
 		return -1;
 	alps_get_finger_coordinate_v7(f->mt, p, pkt_id);
 	if (pkt_id == V7_PACKET_ID_TWO || pkt_id == V7_PACKET_ID_MULTI) {
 		f->left = (p[0] & 0x80) >> 7;
 		f->right = (p[0] & 0x20) >> 5;
 		f->middle = (p[0] & 0x10) >> 4;
 	}
 	if (pkt_id == V7_PACKET_ID_TWO)
 		f->fingers = alps_get_mt_count(f->mt);
 	else if (pkt_id == V7_PACKET_ID_MULTI)
 		f->fingers = 3 + (p[5] & 0x03);
 	return 0;
 }
 static void alps_process_trackstick_packet_v7(struct psmouse *psmouse)
 {
 	struct alps_data *priv = psmouse->private;
 	unsigned char *packet = psmouse->packet;
 	struct input_dev *dev2 = priv->dev2;
 	int x, y, z, left, right, middle;
 	/*
 	 *        b7 b6 b5 b4 b3 b2 b1 b0
 	 * Byte0   0  1  0  0  1  0  0  0
 	 * Byte1   1  1  *  *  1  M  R  L
 	 * Byte2  X7  1 X5 X4 X3 X2 X1 X0
 	 * Byte3  Z6  1 Y6 X6  1 Y2 Y1 Y0
 	 * Byte4  Y7  0 Y5 Y4 Y3  1  1  0
 	 * Byte5 T&P  0 Z5 Z4 Z3 Z2 Z1 Z0
 	 * M / R / L: Middle / Right / Left button
 	 */
 	x = ((packet[2] & 0xbf)) | ((packet[3] & 0x10) << 2);
 	y = (packet[3] & 0x07) | (packet[4] & 0xb8) |
 	    ((packet[3] & 0x20) << 1);
 	z = (packet[5] & 0x3f) | ((packet[3] & 0x80) >> 1);
 	left = (packet[1] & 0x01);
 	right = (packet[1] & 0x02) >> 1;
 	middle = (packet[1] & 0x04) >> 2;
 	/* Divide 2 since trackpoint's speed is too fast */
 	input_report_rel(dev2, REL_X, (char)x / 2);
 	input_report_rel(dev2, REL_Y, -((char)y / 2));
 	input_report_key(dev2, BTN_LEFT, left);
 	input_report_key(dev2, BTN_RIGHT, right);
 	input_report_key(dev2, BTN_MIDDLE, middle);
 	input_sync(dev2);
 }
 static void alps_process_touchpad_packet_v7(struct psmouse *psmouse)
 {
 	struct alps_data *priv = psmouse->private;
 	struct input_dev *dev = psmouse->dev;
 	struct alps_fields *f = &priv->f;
 	memset(f, 0, sizeof(*f));
 	if (priv->decode_fields(f, psmouse->packet, psmouse))
 		return;
 	alps_report_mt_data(psmouse, alps_get_mt_count(f->mt));
 	input_mt_report_finger_count(dev, f->fingers);
 	input_report_key(dev, BTN_LEFT, f->left);
 	input_report_key(dev, BTN_RIGHT, f->right);
 	input_report_key(dev, BTN_MIDDLE, f->middle);
 	input_sync(dev);
 }
 static void alps_process_packet_v7(struct psmouse *psmouse)
 {
 	unsigned char *packet = psmouse->packet;
 	if (packet[0] == 0x48 && (packet[4] & 0x47) == 0x06)
 		alps_process_trackstick_packet_v7(psmouse);
 	else
 		alps_process_touchpad_packet_v7(psmouse);
 }
 static void alps_report_bare_ps2_packet(struct psmouse *psmouse,
 					unsigned char packet[],
 					bool report_buttons)
 {
 	struct alps_data *priv = psmouse->private;
 	struct input_dev *dev2 = priv->dev2;
 	if (report_buttons)
 		alps_report_buttons(psmouse, dev2, psmouse->dev,
 				packet[0] & 1, packet[0] & 2, packet[0] & 4);
 	input_report_rel(dev2, REL_X,
 		packet[1] ? packet[1] - ((packet[0] << 4) & 0x100) : 0);
 	input_report_rel(dev2, REL_Y,
 		packet[2] ? ((packet[0] << 3) & 0x100) - packet[2] : 0);
 	input_sync(dev2);
 }
 static psmouse_ret_t alps_handle_interleaved_ps2(struct psmouse *psmouse)
 {
 	struct alps_data *priv = psmouse->private;
 	if (psmouse->pktcnt < 6)
 		return PSMOUSE_GOOD_DATA;
 	if (psmouse->pktcnt == 6) {
 		/*
 		 * Start a timer to flush the packet if it ends up last
 		 * 6-byte packet in the stream. Timer needs to fire
 		 * psmouse core times out itself. 20 ms should be enough
 		 * to decide if we are getting more data or not.
 		 */
 		mod_timer(&priv->timer, jiffies + msecs_to_jiffies(20));
 		return PSMOUSE_GOOD_DATA;
 	}
 	del_timer(&priv->timer);
 	if (psmouse->packet[6] & 0x80) {
 		/*
 		 * Highest bit is set - that means we either had
 		 * complete ALPS packet and this is start of the
 		 * next packet or we got garbage.
 		 */
 		if (((psmouse->packet[3] |
 		      psmouse->packet[4] |
 		      psmouse->packet[5]) & 0x80) ||
 		    (!alps_is_valid_first_byte(priv, psmouse->packet[6]))) {
 			psmouse_dbg(psmouse,
 				    "refusing packet %4ph (suspected interleaved ps/2)\n",
 				    psmouse->packet + 3);
 			return PSMOUSE_BAD_DATA;
 		}
 		priv->process_packet(psmouse);
 		/* Continue with the next packet */
 		psmouse->packet[0] = psmouse->packet[6];
 		psmouse->pktcnt = 1;
 	} else {
 		/*
 		 * High bit is 0 - that means that we indeed got a PS/2
 		 * packet in the middle of ALPS packet.
 		 *
 		 * There is also possibility that we got 6-byte ALPS
 		 * packet followed  by 3-byte packet from trackpoint. We
 		 * can not distinguish between these 2 scenarios but
 		 * because the latter is unlikely to happen in course of
 		 * normal operation (user would need to press all
 		 * buttons on the pad and start moving trackpoint
 		 * without touching the pad surface) we assume former.
 		 * Even if we are wrong the wost thing that would happen
 		 * the cursor would jump but we should not get protocol
 		 * de-synchronization.
 		 */
 		alps_report_bare_ps2_packet(psmouse, &psmouse->packet[3],
 					    false);
 		/*
 		 * Continue with the standard ALPS protocol handling,
 		 * but make sure we won't process it as an interleaved
 		 * packet again, which may happen if all buttons are
 		 * pressed. To avoid this let's reset the 4th bit which
 		 * is normally 1.
 		 */
 		psmouse->packet[3] = psmouse->packet[6] & 0xf7;
 		psmouse->pktcnt = 4;
 	}
 	return PSMOUSE_GOOD_DATA;
 }
 static void alps_flush_packet(unsigned long data)
 {
 	struct psmouse *psmouse = (struct psmouse *)data;
 	struct alps_data *priv = psmouse->private;
 	serio_pause_rx(psmouse->ps2dev.serio);
 	if (psmouse->pktcnt == psmouse->pktsize) {
 		/*
 		 * We did not any more data in reasonable amount of time.
 		 * Validate the last 3 bytes and process as a standard
 		 * ALPS packet.
 		 */
 		if ((psmouse->packet[3] |
 		     psmouse->packet[4] |
 		     psmouse->packet[5]) & 0x80) {
 			psmouse_dbg(psmouse,
 				    "refusing packet %3ph (suspected interleaved ps/2)\n",
 				    psmouse->packet + 3);
 		} else {
 			priv->process_packet(psmouse);
 		}
 		psmouse->pktcnt = 0;
 	}
 	serio_continue_rx(psmouse->ps2dev.serio);
 }
 static psmouse_ret_t alps_process_byte(struct psmouse *psmouse)
 {
 	struct alps_data *priv = psmouse->private;
-	if ((psmouse->packet[0] & 0xc8) == 0x08) { /* PS/2 packet */
+	/*
+	 * Check if we are dealing with a bare PS/2 packet, presumably from
+	 * a device connected to the external PS/2 port. Because bare PS/2
+	 * protocol does not have enough constant bits to self-synchronize
+	 * properly we only do this if the device is fully synchronized.
+	 */
+	if (!psmouse->out_of_sync_cnt && (psmouse->packet[0] & 0xc8) == 0x08) {
 		if (psmouse->pktcnt == 3) {
 			alps_report_bare_ps2_packet(psmouse, psmouse->packet,
 						    true);
 			return PSMOUSE_FULL_PACKET;
 		}
 		return PSMOUSE_GOOD_DATA;
 	}
 	/* Check for PS/2 packet stuffed in the middle of ALPS packet. */
 	if ((priv->flags & ALPS_PS2_INTERLEAVED) &&
 	    psmouse->pktcnt >= 4 && (psmouse->packet[3] & 0x0f) == 0x0f) {
 		return alps_handle_interleaved_ps2(psmouse);
 	}
 	if (!alps_is_valid_first_byte(priv, psmouse->packet[0])) {
 		psmouse_dbg(psmouse,
 			    "refusing packet[0] = %x (mask0 = %x, byte0 = %x)\n",
 			    psmouse->packet[0], priv->mask0, priv->byte0);
 		return PSMOUSE_BAD_DATA;
 	}
 	/* Bytes 2 - pktsize should have 0 in the highest bit */
-	if ((priv->proto_version < ALPS_PROTO_V5) &&
+	if (priv->proto_version < ALPS_PROTO_V5 &&
 	    psmouse->pktcnt >= 2 && psmouse->pktcnt <= psmouse->pktsize &&
 	    (psmouse->packet[psmouse->pktcnt - 1] & 0x80)) {
 		psmouse_dbg(psmouse, "refusing packet[%i] = %x\n",
 			    psmouse->pktcnt - 1,
 			    psmouse->packet[psmouse->pktcnt - 1]);
+		if (priv->proto_version == ALPS_PROTO_V3 &&
+		    psmouse->pktcnt == psmouse->pktsize) {
+			/*
+			 * Some Dell boxes, such as Latitude E6440 or E7440
+			 * with closed lid, quite often smash last byte of
+			 * otherwise valid packet with 0xff. Given that the
+			 * next packet is very likely to be valid let's
+			 * report PSMOUSE_FULL_PACKET but not process data,
+			 * rather than reporting PSMOUSE_BAD_DATA and
+			 * filling the logs.
+			 */
+			return PSMOUSE_FULL_PACKET;
+		}
 		return PSMOUSE_BAD_DATA;
 	}
 	if (priv->proto_version == ALPS_PROTO_V7 &&
 	    !alps_is_valid_package_v7(psmouse)) {
 		psmouse_dbg(psmouse, "refusing packet[%i] = %x\n",
 			    psmouse->pktcnt - 1,
 			    psmouse->packet[psmouse->pktcnt - 1]);
 		return PSMOUSE_BAD_DATA;
 	}
 	if (psmouse->pktcnt == psmouse->pktsize) {
 		priv->process_packet(psmouse);
 		return PSMOUSE_FULL_PACKET;
 	}
 	return PSMOUSE_GOOD_DATA;
 }
 static int alps_command_mode_send_nibble(struct psmouse *psmouse, int nibble)
 {
 	struct ps2dev *ps2dev = &psmouse->ps2dev;
 	struct alps_data *priv = psmouse->private;
 	int command;
 	unsigned char *param;
 	unsigned char dummy[4];
 	BUG_ON(nibble > 0xf);
 	command = priv->nibble_commands[nibble].command;
 	param = (command & 0x0f00) ?
 		dummy : (unsigned char *)&priv->nibble_commands[nibble].data;
 	if (ps2_command(ps2dev, param, command))
 		return -1;
 	return 0;
 }
 static int alps_command_mode_set_addr(struct psmouse *psmouse, int addr)
 {
 	struct ps2dev *ps2dev = &psmouse->ps2dev;
 	struct alps_data *priv = psmouse->private;
 	int i, nibble;
 	if (ps2_command(ps2dev, NULL, priv->addr_command))
 		return -1;
 	for (i = 12; i >= 0; i -= 4) {
 		nibble = (addr >> i) & 0xf;
 		if (alps_command_mode_send_nibble(psmouse, nibble))
 			return -1;
 	}
 	return 0;
 }
 static int __alps_command_mode_read_reg(struct psmouse *psmouse, int addr)
 {
 	struct ps2dev *ps2dev = &psmouse->ps2dev;
 	unsigned char param[4];
 	if (ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO))
 		return -1;
 	/*
 	 * The address being read is returned in the first two bytes
 	 * of the result. Check that this address matches the expected
 	 * address.
 	 */
 	if (addr != ((param[0] << 8) | param[1]))
 		return -1;
 	return param[2];
 }
 static int alps_command_mode_read_reg(struct psmouse *psmouse, int addr)
 {
 	if (alps_command_mode_set_addr(psmouse, addr))
 		return -1;
 	return __alps_command_mode_read_reg(psmouse, addr);
 }
 static int __alps_command_mode_write_reg(struct psmouse *psmouse, u8 value)
 {
 	if (alps_command_mode_send_nibble(psmouse, (value >> 4) & 0xf))
 		return -1;
 	if (alps_command_mode_send_nibble(psmouse, value & 0xf))
 		return -1;
 	return 0;
 }
 static int alps_command_mode_write_reg(struct psmouse *psmouse, int addr,
 				       u8 value)
 {
 	if (alps_command_mode_set_addr(psmouse, addr))
 		return -1;
 	return __alps_command_mode_write_reg(psmouse, value);
 }
 static int alps_rpt_cmd(struct psmouse *psmouse, int init_command,
 			int repeated_command, unsigned char *param)
 {
 	struct ps2dev *ps2dev = &psmouse->ps2dev;
 	param[0] = 0;
 	if (init_command && ps2_command(ps2dev, param, init_command))
 		return -EIO;
 	if (ps2_command(ps2dev,  NULL, repeated_command) ||
 	    ps2_command(ps2dev,  NULL, repeated_command) ||
 	    ps2_command(ps2dev,  NULL, repeated_command))
 		return -EIO;
 	param[0] = param[1] = param[2] = 0xff;
 	if (ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO))
 		return -EIO;
 	psmouse_dbg(psmouse, "%2.2X report: %3ph\n",
 		    repeated_command, param);
 	return 0;
 }
 static bool alps_check_valid_firmware_id(unsigned char id[])
 {
 	if (id[0] == 0x73)
 		return true;
 	if (id[0] == 0x88 &&
 	    (id[1] == 0x07 ||
 	     id[1] == 0x08 ||
 	     (id[1] & 0xf0) == 0xb0 ||
 	     (id[1] & 0xf0) == 0xc0)) {
 		return true;
 	}
 	return false;
 }
 static int alps_enter_command_mode(struct psmouse *psmouse)
 {
 	unsigned char param[4];
 	if (alps_rpt_cmd(psmouse, 0, PSMOUSE_CMD_RESET_WRAP, param)) {
 		psmouse_err(psmouse, "failed to enter command mode\n");
 		return -1;
 	}
 	if (!alps_check_valid_firmware_id(param)) {
 		psmouse_dbg(psmouse,
 			    "unknown response while entering command mode\n");
 		return -1;
 	}
 	return 0;
 }
 static inline int alps_exit_command_mode(struct psmouse *psmouse)
 {
 	struct ps2dev *ps2dev = &psmouse->ps2dev;
 	if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSTREAM))
 		return -1;
 	return 0;
 }
 /*
  * For DualPoint devices select the device that should respond to
  * subsequent commands. It looks like glidepad is behind stickpointer,
  * I'd thought it would be other way around...
  */
 static int alps_passthrough_mode_v2(struct psmouse *psmouse, bool enable)
 {
 	struct ps2dev *ps2dev = &psmouse->ps2dev;
 	int cmd = enable ? PSMOUSE_CMD_SETSCALE21 : PSMOUSE_CMD_SETSCALE11;
 	if (ps2_command(ps2dev, NULL, cmd) ||
 	    ps2_command(ps2dev, NULL, cmd) ||
 	    ps2_command(ps2dev, NULL, cmd) ||
 	    ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE))
 		return -1;
 	/* we may get 3 more bytes, just ignore them */
 	ps2_drain(ps2dev, 3, 100);
 	return 0;
 }
 static int alps_absolute_mode_v1_v2(struct psmouse *psmouse)
 {
 	struct ps2dev *ps2dev = &psmouse->ps2dev;
 	/* Try ALPS magic knock - 4 disable before enable */
 	if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
 	    ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
 	    ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
 	    ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
 	    ps2_command(ps2dev, NULL, PSMOUSE_CMD_ENABLE))
 		return -1;
 	/*
 	 * Switch mouse to poll (remote) mode so motion data will not
 	 * get in our way
 	 */
 	return ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETPOLL);
 }
 static int alps_monitor_mode_send_word(struct psmouse *psmouse, u16 word)
 {
 	int i, nibble;
 	/*
 	 * b0-b11 are valid bits, send sequence is inverse.
 	 * e.g. when word = 0x0123, nibble send sequence is 3, 2, 1
 	 */
 	for (i = 0; i <= 8; i += 4) {
 		nibble = (word >> i) & 0xf;
 		if (alps_command_mode_send_nibble(psmouse, nibble))
 			return -1;
 	}
 	return 0;
 }
 static int alps_monitor_mode_write_reg(struct psmouse *psmouse,
 				       u16 addr, u16 value)
 {
 	struct ps2dev *ps2dev = &psmouse->ps2dev;
 	/* 0x0A0 is the command to write the word */
 	if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_ENABLE) ||
 	    alps_monitor_mode_send_word(psmouse, 0x0A0) ||
 	    alps_monitor_mode_send_word(psmouse, addr) ||
 	    alps_monitor_mode_send_word(psmouse, value) ||
 	    ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE))
 		return -1;
 	return 0;
 }
 static int alps_monitor_mode(struct psmouse *psmouse, bool enable)
 {
 	struct ps2dev *ps2dev = &psmouse->ps2dev;
 	if (enable) {
 		/* EC E9 F5 F5 E7 E6 E7 E9 to enter monitor mode */
 		if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_RESET_WRAP) ||
 		    ps2_command(ps2dev, NULL, PSMOUSE_CMD_GETINFO) ||
 		    ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
 		    ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
 		    ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE21) ||
 		    ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) ||
 		    ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE21) ||
 		    ps2_command(ps2dev, NULL, PSMOUSE_CMD_GETINFO))
 			return -1;
 	} else {
 		/* EC to exit monitor mode */
 		if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_RESET_WRAP))
 			return -1;
 	}
 	return 0;
 }
 static int alps_absolute_mode_v6(struct psmouse *psmouse)
 {
 	u16 reg_val = 0x181;
 	int ret = -1;
 	/* enter monitor mode, to write the register */
 	if (alps_monitor_mode(psmouse, true))
 		return -1;
 	ret = alps_monitor_mode_write_reg(psmouse, 0x000, reg_val);
 	if (alps_monitor_mode(psmouse, false))
 		ret = -1;
 	return ret;
 }
 static int alps_get_status(struct psmouse *psmouse, char *param)
 {
 	/* Get status: 0xF5 0xF5 0xF5 0xE9 */
 	if (alps_rpt_cmd(psmouse, 0, PSMOUSE_CMD_DISABLE, param))
 		return -1;
 	return 0;
 }
 /*
  * Turn touchpad tapping on or off. The sequences are:
  * 0xE9 0xF5 0xF5 0xF3 0x0A to enable,
  * 0xE9 0xF5 0xF5 0xE8 0x00 to disable.
  * My guess that 0xE9 (GetInfo) is here as a sync point.
  * For models that also have stickpointer (DualPoints) its tapping
  * is controlled separately (0xE6 0xE6 0xE6 0xF3 0x14|0x0A) but
  * we don't fiddle with it.
  */
 static int alps_tap_mode(struct psmouse *psmouse, int enable)
 {
 	struct ps2dev *ps2dev = &psmouse->ps2dev;
 	int cmd = enable ? PSMOUSE_CMD_SETRATE : PSMOUSE_CMD_SETRES;
 	unsigned char tap_arg = enable ? 0x0A : 0x00;
 	unsigned char param[4];
 	if (ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO) ||
 	    ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
 	    ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
 	    ps2_command(ps2dev, &tap_arg, cmd))
 		return -1;
 	if (alps_get_status(psmouse, param))
 		return -1;
 	return 0;
 }
 /*
  * alps_poll() - poll the touchpad for current motion packet.
  * Used in resync.
  */
 static int alps_poll(struct psmouse *psmouse)
 {
 	struct alps_data *priv = psmouse->private;
 	unsigned char buf[sizeof(psmouse->packet)];
 	bool poll_failed;
 	if (priv->flags & ALPS_PASS)
 		alps_passthrough_mode_v2(psmouse, true);
 	poll_failed = ps2_command(&psmouse->ps2dev, buf,
 				  PSMOUSE_CMD_POLL | (psmouse->pktsize << 8)) < 0;
 	if (priv->flags & ALPS_PASS)
 		alps_passthrough_mode_v2(psmouse, false);
 	if (poll_failed || (buf[0] & priv->mask0) != priv->byte0)
 		return -1;
 	if ((psmouse->badbyte & 0xc8) == 0x08) {
 /*
  * Poll the track stick ...
  */
 		if (ps2_command(&psmouse->ps2dev, buf, PSMOUSE_CMD_POLL | (3 << 8)))
 			return -1;
 	}
 	memcpy(psmouse->packet, buf, sizeof(buf));
 	return 0;
 }
 static int alps_hw_init_v1_v2(struct psmouse *psmouse)
 {
 	struct alps_data *priv = psmouse->private;
 	if ((priv->flags & ALPS_PASS) &&
 	    alps_passthrough_mode_v2(psmouse, true)) {
 		return -1;
 	}
 	if (alps_tap_mode(psmouse, true)) {
 		psmouse_warn(psmouse, "Failed to enable hardware tapping\n");
 		return -1;
 	}
 	if (alps_absolute_mode_v1_v2(psmouse)) {
 		psmouse_err(psmouse, "Failed to enable absolute mode\n");
 		return -1;
 	}
 	if ((priv->flags & ALPS_PASS) &&
 	    alps_passthrough_mode_v2(psmouse, false)) {
 		return -1;
 	}
 	/* ALPS needs stream mode, otherwise it won't report any data */
 	if (ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSTREAM)) {
 		psmouse_err(psmouse, "Failed to enable stream mode\n");
 		return -1;
 	}
 	return 0;
 }
 static int alps_hw_init_v6(struct psmouse *psmouse)
 {
 	unsigned char param[2] = {0xC8, 0x14};
 	/* Enter passthrough mode to let trackpoint enter 6byte raw mode */
 	if (alps_passthrough_mode_v2(psmouse, true))
 		return -1;
 	if (ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) ||
 	    ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) ||
 	    ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) ||
 	    ps2_command(&psmouse->ps2dev, &param[0], PSMOUSE_CMD_SETRATE) ||
 	    ps2_command(&psmouse->ps2dev, &param[1], PSMOUSE_CMD_SETRATE))
 		return -1;
 	if (alps_passthrough_mode_v2(psmouse, false))
 		return -1;
 	if (alps_absolute_mode_v6(psmouse)) {
 		psmouse_err(psmouse, "Failed to enable absolute mode\n");
 		return -1;
 	}
 	return 0;
 }
 /*
  * Enable or disable passthrough mode to the trackstick.
  */
 static int alps_passthrough_mode_v3(struct psmouse *psmouse,
 				    int reg_base, bool enable)
 {
 	int reg_val, ret = -1;
 	if (alps_enter_command_mode(psmouse))
 		return -1;
 	reg_val = alps_command_mode_read_reg(psmouse, reg_base + 0x0008);
 	if (reg_val == -1)
 		goto error;
 	if (enable)
 		reg_val |= 0x01;
 	else
 		reg_val &= ~0x01;
 	ret = __alps_command_mode_write_reg(psmouse, reg_val);
 error:
 	if (alps_exit_command_mode(psmouse))
 		ret = -1;
 	return ret;
 }
 /* Must be in command mode when calling this function */
 static int alps_absolute_mode_v3(struct psmouse *psmouse)
 {
 	int reg_val;
 	reg_val = alps_command_mode_read_reg(psmouse, 0x0004);
 	if (reg_val == -1)
 		return -1;
 	reg_val |= 0x06;
 	if (__alps_command_mode_write_reg(psmouse, reg_val))
 		return -1;
 	return 0;
 }
 static int alps_probe_trackstick_v3(struct psmouse *psmouse, int reg_base)
 {
 	int ret = -EIO, reg_val;
 	if (alps_enter_command_mode(psmouse))
 		goto error;
 	reg_val = alps_command_mode_read_reg(psmouse, reg_base + 0x08);
 	if (reg_val == -1)
 		goto error;
 	/* bit 7: trackstick is present */
 	ret = reg_val & 0x80 ? 0 : -ENODEV;
 error:
 	alps_exit_command_mode(psmouse);
 	return ret;
 }
 static int alps_setup_trackstick_v3(struct psmouse *psmouse, int reg_base)
 {
 	struct ps2dev *ps2dev = &psmouse->ps2dev;
 	int ret = 0;
 	unsigned char param[4];
 	if (alps_passthrough_mode_v3(psmouse, reg_base, true))
 		return -EIO;
 	/*
 	 * E7 report for the trackstick
 	 *
 	 * There have been reports of failures to seem to trace back
 	 * to the above trackstick check failing. When these occur
 	 * this E7 report fails, so when that happens we continue
 	 * with the assumption that there isn't a trackstick after
 	 * all.
 	 */
 	if (alps_rpt_cmd(psmouse, 0, PSMOUSE_CMD_SETSCALE21, param)) {
 		psmouse_warn(psmouse, "trackstick E7 report failed\n");
 		ret = -ENODEV;
 	} else {
 		psmouse_dbg(psmouse, "trackstick E7 report: %3ph\n", param);
 		/*
 		 * Not sure what this does, but it is absolutely
 		 * essential. Without it, the touchpad does not
 		 * work at all and the trackstick just emits normal
 		 * PS/2 packets.
 		 */
 		if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) ||
 		    ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) ||
 		    ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) ||
 		    alps_command_mode_send_nibble(psmouse, 0x9) ||
 		    alps_command_mode_send_nibble(psmouse, 0x4)) {
 			psmouse_err(psmouse,
 				    "Error sending magic E6 sequence\n");
 			ret = -EIO;
 			goto error;
 		}
 		/*
 		 * This ensures the trackstick packets are in the format
 		 * supported by this driver. If bit 1 isn't set the packet
 		 * format is different.
 		 */
 		if (alps_enter_command_mode(psmouse) ||
 		    alps_command_mode_write_reg(psmouse,
 						reg_base + 0x08, 0x82) ||
 		    alps_exit_command_mode(psmouse))
 			ret = -EIO;
 	}
 error:
 	if (alps_passthrough_mode_v3(psmouse, reg_base, false))
 		ret = -EIO;
 	return ret;
 }
 static int alps_hw_init_v3(struct psmouse *psmouse)
 {
 	struct ps2dev *ps2dev = &psmouse->ps2dev;
 	int reg_val;
 	unsigned char param[4];
 	reg_val = alps_probe_trackstick_v3(psmouse, ALPS_REG_BASE_PINNACLE);
 	if (reg_val == -EIO)
 		goto error;
 	if (reg_val == 0 &&
 	    alps_setup_trackstick_v3(psmouse, ALPS_REG_BASE_PINNACLE) == -EIO)
 		goto error;
 	if (alps_enter_command_mode(psmouse) ||
 	    alps_absolute_mode_v3(psmouse)) {
 		psmouse_err(psmouse, "Failed to enter absolute mode\n");
 		goto error;
 	}
 	reg_val = alps_command_mode_read_reg(psmouse, 0x0006);
 	if (reg_val == -1)
 		goto error;
 	if (__alps_command_mode_write_reg(psmouse, reg_val | 0x01))
 		goto error;
 	reg_val = alps_command_mode_read_reg(psmouse, 0x0007);
 	if (reg_val == -1)
 		goto error;
 	if (__alps_command_mode_write_reg(psmouse, reg_val | 0x01))
 		goto error;
 	if (alps_command_mode_read_reg(psmouse, 0x0144) == -1)
 		goto error;
 	if (__alps_command_mode_write_reg(psmouse, 0x04))
 		goto error;
 	if (alps_command_mode_read_reg(psmouse, 0x0159) == -1)
 		goto error;
 	if (__alps_command_mode_write_reg(psmouse, 0x03))
 		goto error;
 	if (alps_command_mode_read_reg(psmouse, 0x0163) == -1)
 		goto error;
 	if (alps_command_mode_write_reg(psmouse, 0x0163, 0x03))
 		goto error;
 	if (alps_command_mode_read_reg(psmouse, 0x0162) == -1)
 		goto error;
 	if (alps_command_mode_write_reg(psmouse, 0x0162, 0x04))
 		goto error;
 	alps_exit_command_mode(psmouse);
 	/* Set rate and enable data reporting */
 	param[0] = 0x64;
 	if (ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE) ||
 	    ps2_command(ps2dev, NULL, PSMOUSE_CMD_ENABLE)) {
 		psmouse_err(psmouse, "Failed to enable data reporting\n");
 		return -1;
 	}
 	return 0;
 error:
 	/*
 	 * Leaving the touchpad in command mode will essentially render
 	 * it unusable until the machine reboots, so exit it here just
 	 * to be safe
 	 */
 	alps_exit_command_mode(psmouse);
 	return -1;
 }
 static int alps_get_v3_v7_resolution(struct psmouse *psmouse, int reg_pitch)
 {
 	int reg, x_pitch, y_pitch, x_electrode, y_electrode, x_phys, y_phys;
 	struct alps_data *priv = psmouse->private;
 	reg = alps_command_mode_read_reg(psmouse, reg_pitch);
 	if (reg < 0)
 		return reg;
 	x_pitch = (char)(reg << 4) >> 4; /* sign extend lower 4 bits */
 	x_pitch = 50 + 2 * x_pitch; /* In 0.1 mm units */
 	y_pitch = (char)reg >> 4; /* sign extend upper 4 bits */
 	y_pitch = 36 + 2 * y_pitch; /* In 0.1 mm units */
 	reg = alps_command_mode_read_reg(psmouse, reg_pitch + 1);
 	if (reg < 0)
 		return reg;
 	x_electrode = (char)(reg << 4) >> 4; /* sign extend lower 4 bits */
 	x_electrode = 17 + x_electrode;
 	y_electrode = (char)reg >> 4; /* sign extend upper 4 bits */
 	y_electrode = 13 + y_electrode;
 	x_phys = x_pitch * (x_electrode - 1); /* In 0.1 mm units */
 	y_phys = y_pitch * (y_electrode - 1); /* In 0.1 mm units */
 	priv->x_res = priv->x_max * 10 / x_phys; /* units / mm */
 	priv->y_res = priv->y_max * 10 / y_phys; /* units / mm */
 	psmouse_dbg(psmouse,
 		    "pitch %dx%d num-electrodes %dx%d physical size %dx%d mm res %dx%d\n",
 		    x_pitch, y_pitch, x_electrode, y_electrode,
 		    x_phys / 10, y_phys / 10, priv->x_res, priv->y_res);
 	return 0;
 }
 static int alps_hw_init_rushmore_v3(struct psmouse *psmouse)
 {
 	struct alps_data *priv = psmouse->private;
 	struct ps2dev *ps2dev = &psmouse->ps2dev;
 	int reg_val, ret = -1;
 	if (priv->flags & ALPS_DUALPOINT) {
 		reg_val = alps_setup_trackstick_v3(psmouse,
 						   ALPS_REG_BASE_RUSHMORE);
 		if (reg_val == -EIO)
 			goto error;
 		if (reg_val == -ENODEV)
 			priv->flags &= ~ALPS_DUALPOINT;
 	}
 	if (alps_enter_command_mode(psmouse) ||
 	    alps_command_mode_read_reg(psmouse, 0xc2d9) == -1 ||
 	    alps_command_mode_write_reg(psmouse, 0xc2cb, 0x00))
 		goto error;
 	if (alps_get_v3_v7_resolution(psmouse, 0xc2da))
 		goto error;
 	reg_val = alps_command_mode_read_reg(psmouse, 0xc2c6);
 	if (reg_val == -1)
 		goto error;
 	if (__alps_command_mode_write_reg(psmouse, reg_val & 0xfd))
 		goto error;
 	if (alps_command_mode_write_reg(psmouse, 0xc2c9, 0x64))
 		goto error;
 	/* enter absolute mode */
 	reg_val = alps_command_mode_read_reg(psmouse, 0xc2c4);
 	if (reg_val == -1)
 		goto error;
 	if (__alps_command_mode_write_reg(psmouse, reg_val | 0x02))
 		goto error;
 	alps_exit_command_mode(psmouse);
 	return ps2_command(ps2dev, NULL, PSMOUSE_CMD_ENABLE);
 error:
 	alps_exit_command_mode(psmouse);
 	return ret;
 }
 /* Must be in command mode when calling this function */
 static int alps_absolute_mode_v4(struct psmouse *psmouse)
 {
 	int reg_val;
 	reg_val = alps_command_mode_read_reg(psmouse, 0x0004);
 	if (reg_val == -1)
 		return -1;
 	reg_val |= 0x02;
 	if (__alps_command_mode_write_reg(psmouse, reg_val))
 		return -1;
 	return 0;
 }
 static int alps_hw_init_v4(struct psmouse *psmouse)
 {
 	struct ps2dev *ps2dev = &psmouse->ps2dev;
 	unsigned char param[4];
 	if (alps_enter_command_mode(psmouse))
 		goto error;
 	if (alps_absolute_mode_v4(psmouse)) {
 		psmouse_err(psmouse, "Failed to enter absolute mode\n");
 		goto error;
 	}
 	if (alps_command_mode_write_reg(psmouse, 0x0007, 0x8c))
 		goto error;
 	if (alps_command_mode_write_reg(psmouse, 0x0149, 0x03))
 		goto error;
 	if (alps_command_mode_write_reg(psmouse, 0x0160, 0x03))
 		goto error;
 	if (alps_command_mode_write_reg(psmouse, 0x017f, 0x15))
 		goto error;
 	if (alps_command_mode_write_reg(psmouse, 0x0151, 0x01))
 		goto error;
 	if (alps_command_mode_write_reg(psmouse, 0x0168, 0x03))
 		goto error;
 	if (alps_command_mode_write_reg(psmouse, 0x014a, 0x03))
 		goto error;
 	if (alps_command_mode_write_reg(psmouse, 0x0161, 0x03))
 		goto error;
 	alps_exit_command_mode(psmouse);
 	/*
 	 * This sequence changes the output from a 9-byte to an
 	 * 8-byte format. All the same data seems to be present,
 	 * just in a more compact format.
 	 */
 	param[0] = 0xc8;
 	param[1] = 0x64;
 	param[2] = 0x50;
 	if (ps2_command(ps2dev, &param[0], PSMOUSE_CMD_SETRATE) ||
 	    ps2_command(ps2dev, &param[1], PSMOUSE_CMD_SETRATE) ||
 	    ps2_command(ps2dev, &param[2], PSMOUSE_CMD_SETRATE) ||
 	    ps2_command(ps2dev, param, PSMOUSE_CMD_GETID))
 		return -1;
 	/* Set rate and enable data reporting */
 	param[0] = 0x64;
 	if (ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE) ||
 	    ps2_command(ps2dev, NULL, PSMOUSE_CMD_ENABLE)) {
 		psmouse_err(psmouse, "Failed to enable data reporting\n");
 		return -1;
 	}
 	return 0;
 error:
 	/*
 	 * Leaving the touchpad in command mode will essentially render
 	 * it unusable until the machine reboots, so exit it here just
 	 * to be safe
 	 */
 	alps_exit_command_mode(psmouse);
 	return -1;
 }
 static int alps_dolphin_get_device_area(struct psmouse *psmouse,
 					struct alps_data *priv)
 {
 	struct ps2dev *ps2dev = &psmouse->ps2dev;
 	unsigned char param[4] = {0};
 	int num_x_electrode, num_y_electrode;
 	if (alps_enter_command_mode(psmouse))
 		return -1;
 	param[0] = 0x0a;
 	if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_RESET_WRAP) ||
 	    ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETPOLL) ||
 	    ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETPOLL) ||
 	    ps2_command(ps2dev, &param[0], PSMOUSE_CMD_SETRATE) ||
 	    ps2_command(ps2dev, &param[0], PSMOUSE_CMD_SETRATE))
 		return -1;
 	if (ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO))
 		return -1;
 	/*
 	 * Dolphin's sensor line number is not fixed. It can be calculated
 	 * by adding the device's register value with DOLPHIN_PROFILE_X/YOFFSET.
 	 * Further more, we can get device's x_max and y_max by multiplying
 	 * sensor line number with DOLPHIN_COUNT_PER_ELECTRODE.
 	 *
 	 * e.g. When we get register's sensor_x = 11 & sensor_y = 8,
 	 *	real sensor line number X = 11 + 8 = 19, and
 	 *	real sensor line number Y = 8 + 1 = 9.
 	 *	So, x_max = (19 - 1) * 64 = 1152, and
 	 *	    y_max = (9 - 1) * 64 = 512.
 	 */
 	num_x_electrode = DOLPHIN_PROFILE_XOFFSET + (param[2] & 0x0F);
 	num_y_electrode = DOLPHIN_PROFILE_YOFFSET + ((param[2] >> 4) & 0x0F);
 	priv->x_bits = num_x_electrode;
 	priv->y_bits = num_y_electrode;
 	priv->x_max = (num_x_electrode - 1) * DOLPHIN_COUNT_PER_ELECTRODE;
 	priv->y_max = (num_y_electrode - 1) * DOLPHIN_COUNT_PER_ELECTRODE;
 	if (alps_exit_command_mode(psmouse))
 		return -1;
 	return 0;
 }
 static int alps_hw_init_dolphin_v1(struct psmouse *psmouse)
 {
 	struct ps2dev *ps2dev = &psmouse->ps2dev;
 	unsigned char param[2];
 	/* This is dolphin "v1" as empirically defined by florin9doi */
 	param[0] = 0x64;
 	param[1] = 0x28;
 	if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSTREAM) ||
 	    ps2_command(ps2dev, &param[0], PSMOUSE_CMD_SETRATE) ||
 	    ps2_command(ps2dev, &param[1], PSMOUSE_CMD_SETRATE))
 		return -1;
 	return 0;
 }
 static int alps_hw_init_v7(struct psmouse *psmouse)
 {
 	struct ps2dev *ps2dev = &psmouse->ps2dev;
 	int reg_val, ret = -1;
 	if (alps_enter_command_mode(psmouse) ||
 	    alps_command_mode_read_reg(psmouse, 0xc2d9) == -1)
 		goto error;
 	if (alps_get_v3_v7_resolution(psmouse, 0xc397))
 		goto error;
 	if (alps_command_mode_write_reg(psmouse, 0xc2c9, 0x64))
 		goto error;
 	reg_val = alps_command_mode_read_reg(psmouse, 0xc2c4);
 	if (reg_val == -1)
 		goto error;
 	if (__alps_command_mode_write_reg(psmouse, reg_val | 0x02))
 		goto error;
 	alps_exit_command_mode(psmouse);
 	return ps2_command(ps2dev, NULL, PSMOUSE_CMD_ENABLE);
 error:
 	alps_exit_command_mode(psmouse);
 	return ret;
 }
 static void alps_set_defaults(struct alps_data *priv)
 {
 	priv->byte0 = 0x8f;
 	priv->mask0 = 0x8f;
 	priv->flags = ALPS_DUALPOINT;
 	priv->x_max = 2000;
 	priv->y_max = 1400;
 	priv->x_bits = 15;
 	priv->y_bits = 11;
 	switch (priv->proto_version) {
 	case ALPS_PROTO_V1:
 	case ALPS_PROTO_V2:
 		priv->hw_init = alps_hw_init_v1_v2;
 		priv->process_packet = alps_process_packet_v1_v2;
 		priv->set_abs_params = alps_set_abs_params_st;
 		priv->x_max = 1023;
 		priv->y_max = 767;
 		break;
 	case ALPS_PROTO_V3:
 		priv->hw_init = alps_hw_init_v3;
 		priv->process_packet = alps_process_packet_v3;
 		priv->set_abs_params = alps_set_abs_params_mt;
 		priv->decode_fields = alps_decode_pinnacle;
 		priv->nibble_commands = alps_v3_nibble_commands;
 		priv->addr_command = PSMOUSE_CMD_RESET_WRAP;
 		break;
 	case ALPS_PROTO_V4:
 		priv->hw_init = alps_hw_init_v4;
 		priv->process_packet = alps_process_packet_v4;
 		priv->set_abs_params = alps_set_abs_params_mt;
 		priv->nibble_commands = alps_v4_nibble_commands;
 		priv->addr_command = PSMOUSE_CMD_DISABLE;
 		break;
 	case ALPS_PROTO_V5:
 		priv->hw_init = alps_hw_init_dolphin_v1;
 		priv->process_packet = alps_process_touchpad_packet_v3_v5;
 		priv->decode_fields = alps_decode_dolphin;
 		priv->set_abs_params = alps_set_abs_params_mt;
 		priv->nibble_commands = alps_v3_nibble_commands;
 		priv->addr_command = PSMOUSE_CMD_RESET_WRAP;
 		priv->byte0 = 0xc8;
 		priv->mask0 = 0xd8;
 		priv->flags = 0;
 		priv->x_max = 1360;
 		priv->y_max = 660;
 		priv->x_bits = 23;
 		priv->y_bits = 12;
 		break;
 	case ALPS_PROTO_V6:
 		priv->hw_init = alps_hw_init_v6;
 		priv->process_packet = alps_process_packet_v6;
 		priv->set_abs_params = alps_set_abs_params_st;
 		priv->nibble_commands = alps_v6_nibble_commands;
 		priv->x_max = 2047;
 		priv->y_max = 1535;
 		break;
 	case ALPS_PROTO_V7:
 		priv->hw_init = alps_hw_init_v7;
 		priv->process_packet = alps_process_packet_v7;
 		priv->decode_fields = alps_decode_packet_v7;
 		priv->set_abs_params = alps_set_abs_params_mt;
 		priv->nibble_commands = alps_v3_nibble_commands;
 		priv->addr_command = PSMOUSE_CMD_RESET_WRAP;
 		priv->x_max = 0xfff;
 		priv->y_max = 0x7ff;
 		priv->byte0 = 0x48;
 		priv->mask0 = 0x48;
 		if (priv->fw_ver[1] != 0xba)
 			priv->flags |= ALPS_BUTTONPAD;
 		break;
 	}
 }
 static int alps_match_table(struct psmouse *psmouse, struct alps_data *priv,
 			    unsigned char *e7, unsigned char *ec)
 {
 	const struct alps_model_info *model;
 	int i;
 	for (i = 0; i < ARRAY_SIZE(alps_model_data); i++) {
 		model = &alps_model_data[i];
 		if (!memcmp(e7, model->signature, sizeof(model->signature)) &&
 		    (!model->command_mode_resp ||
 		     model->command_mode_resp == ec[2])) {
 			priv->proto_version = model->proto_version;
 			alps_set_defaults(priv);
 			priv->flags = model->flags;
 			priv->byte0 = model->byte0;
 			priv->mask0 = model->mask0;
 			return 0;
 		}
 	}
 	return -EINVAL;
 }
 static int alps_identify(struct psmouse *psmouse, struct alps_data *priv)
 {
 	unsigned char e6[4], e7[4], ec[4];
 	/*
 	 * First try "E6 report".
 	 * ALPS should return 0,0,10 or 0,0,100 if no buttons are pressed.
 	 * The bits 0-2 of the first byte will be 1s if some buttons are
 	 * pressed.
 	 */
 	if (alps_rpt_cmd(psmouse, PSMOUSE_CMD_SETRES,
 			 PSMOUSE_CMD_SETSCALE11, e6))
 		return -EIO;
 	if ((e6[0] & 0xf8) != 0 || e6[1] != 0 || (e6[2] != 10 && e6[2] != 100))
 		return -EINVAL;
 	/*
 	 * Now get the "E7" and "EC" reports.  These will uniquely identify
 	 * most ALPS touchpads.
 	 */
 	if (alps_rpt_cmd(psmouse, PSMOUSE_CMD_SETRES,
 			 PSMOUSE_CMD_SETSCALE21, e7) ||
 	    alps_rpt_cmd(psmouse, PSMOUSE_CMD_SETRES,
 			 PSMOUSE_CMD_RESET_WRAP, ec) ||
 	    alps_exit_command_mode(psmouse))
 		return -EIO;
 	/* Save the Firmware version */
 	memcpy(priv->fw_ver, ec, 3);
 	if (alps_match_table(psmouse, priv, e7, ec) == 0) {
 		return 0;
 	} else if (e7[0] == 0x73 && e7[1] == 0x03 && e7[2] == 0x50 &&
 		   ec[0] == 0x73 && (ec[1] == 0x01 || ec[1] == 0x02)) {
 		priv->proto_version = ALPS_PROTO_V5;
 		alps_set_defaults(priv);
 		if (alps_dolphin_get_device_area(psmouse, priv))
 			return -EIO;
 		else
 			return 0;
 	} else if (ec[0] == 0x88 &&
 		   ((ec[1] & 0xf0) == 0xb0 || (ec[1] & 0xf0) == 0xc0)) {
 		priv->proto_version = ALPS_PROTO_V7;
 		alps_set_defaults(priv);
 		return 0;
 	} else if (ec[0] == 0x88 && ec[1] == 0x08) {
 		priv->proto_version = ALPS_PROTO_V3;
 		alps_set_defaults(priv);
 		priv->hw_init = alps_hw_init_rushmore_v3;
 		priv->decode_fields = alps_decode_rushmore;
 		priv->x_bits = 16;
 		priv->y_bits = 12;
 		priv->flags |= ALPS_IS_RUSHMORE;
 		/* hack to make addr_command, nibble_command available */
 		psmouse->private = priv;
 		if (alps_probe_trackstick_v3(psmouse, ALPS_REG_BASE_RUSHMORE))
 			priv->flags &= ~ALPS_DUALPOINT;
 		return 0;
 	} else if (ec[0] == 0x88 && ec[1] == 0x07 &&
 		   ec[2] >= 0x90 && ec[2] <= 0x9d) {
 		priv->proto_version = ALPS_PROTO_V3;
 		alps_set_defaults(priv);
 		return 0;
 	}
 	psmouse_dbg(psmouse,
 		    "Likely not an ALPS touchpad: E7=%3ph, EC=%3ph\n", e7, ec);
 	return -EINVAL;
 }
 static int alps_reconnect(struct psmouse *psmouse)
 {
 	struct alps_data *priv = psmouse->private;
 	psmouse_reset(psmouse);
 	if (alps_identify(psmouse, priv) < 0)
 		return -1;
 	return priv->hw_init(psmouse);
 }
 static void alps_disconnect(struct psmouse *psmouse)
 {
 	struct alps_data *priv = psmouse->private;
 	psmouse_reset(psmouse);
 	del_timer_sync(&priv->timer);
 	input_unregister_device(priv->dev2);
 	kfree(priv);
 }
 static void alps_set_abs_params_st(struct alps_data *priv,
 				   struct input_dev *dev1)
 {
 	input_set_abs_params(dev1, ABS_X, 0, priv->x_max, 0, 0);
 	input_set_abs_params(dev1, ABS_Y, 0, priv->y_max, 0, 0);
 }
 static void alps_set_abs_params_mt(struct alps_data *priv,
 				   struct input_dev *dev1)
 {
 	input_set_abs_params(dev1, ABS_MT_POSITION_X, 0, priv->x_max, 0, 0);
 	input_set_abs_params(dev1, ABS_MT_POSITION_Y, 0, priv->y_max, 0, 0);
 	input_abs_set_res(dev1, ABS_MT_POSITION_X, priv->x_res);
 	input_abs_set_res(dev1, ABS_MT_POSITION_Y, priv->y_res);
 	input_mt_init_slots(dev1, MAX_TOUCHES, INPUT_MT_POINTER |
 		INPUT_MT_DROP_UNUSED | INPUT_MT_TRACK | INPUT_MT_SEMI_MT);
 	set_bit(BTN_TOOL_TRIPLETAP, dev1->keybit);
 	set_bit(BTN_TOOL_QUADTAP, dev1->keybit);
 	/* V7 is real multi-touch */
 	if (priv->proto_version == ALPS_PROTO_V7)
 		clear_bit(INPUT_PROP_SEMI_MT, dev1->propbit);
 }
 int alps_init(struct psmouse *psmouse)
 {
 	struct alps_data *priv;
 	struct input_dev *dev1 = psmouse->dev, *dev2;
 	priv = kzalloc(sizeof(struct alps_data), GFP_KERNEL);
 	dev2 = input_allocate_device();
 	if (!priv || !dev2)
 		goto init_fail;
 	priv->dev2 = dev2;
 	setup_timer(&priv->timer, alps_flush_packet, (unsigned long)psmouse);
 	psmouse->private = priv;
 	psmouse_reset(psmouse);
 	if (alps_identify(psmouse, priv) < 0)
 		goto init_fail;
 	if (priv->hw_init(psmouse))
 		goto init_fail;
 	/*
 	 * Undo part of setup done for us by psmouse core since touchpad
 	 * is not a relative device.
 	 */
 	__clear_bit(EV_REL, dev1->evbit);
 	__clear_bit(REL_X, dev1->relbit);
 	__clear_bit(REL_Y, dev1->relbit);
 	/*
 	 * Now set up our capabilities.
 	 */
 	dev1->evbit[BIT_WORD(EV_KEY)] |= BIT_MASK(EV_KEY);
 	dev1->keybit[BIT_WORD(BTN_TOUCH)] |= BIT_MASK(BTN_TOUCH);
 	dev1->keybit[BIT_WORD(BTN_TOOL_FINGER)] |= BIT_MASK(BTN_TOOL_FINGER);
 	dev1->keybit[BIT_WORD(BTN_LEFT)] |=
 		BIT_MASK(BTN_LEFT) | BIT_MASK(BTN_RIGHT);
 	dev1->evbit[BIT_WORD(EV_ABS)] |= BIT_MASK(EV_ABS);
 	priv->set_abs_params(priv, dev1);
 	/* No pressure on V7 */
 	if (priv->proto_version != ALPS_PROTO_V7)
 		input_set_abs_params(dev1, ABS_PRESSURE, 0, 127, 0, 0);
 	if (priv->flags & ALPS_WHEEL) {
 		dev1->evbit[BIT_WORD(EV_REL)] |= BIT_MASK(EV_REL);
 		dev1->relbit[BIT_WORD(REL_WHEEL)] |= BIT_MASK(REL_WHEEL);
 	}
 	if (priv->flags & (ALPS_FW_BK_1 | ALPS_FW_BK_2)) {
 		dev1->keybit[BIT_WORD(BTN_FORWARD)] |= BIT_MASK(BTN_FORWARD);
 		dev1->keybit[BIT_WORD(BTN_BACK)] |= BIT_MASK(BTN_BACK);
 	}
 	if (priv->flags & ALPS_FOUR_BUTTONS) {
 		dev1->keybit[BIT_WORD(BTN_0)] |= BIT_MASK(BTN_0);
 		dev1->keybit[BIT_WORD(BTN_1)] |= BIT_MASK(BTN_1);
 		dev1->keybit[BIT_WORD(BTN_2)] |= BIT_MASK(BTN_2);
 		dev1->keybit[BIT_WORD(BTN_3)] |= BIT_MASK(BTN_3);
 	} else if (priv->flags & ALPS_BUTTONPAD) {
 		set_bit(INPUT_PROP_BUTTONPAD, dev1->propbit);
 		clear_bit(BTN_RIGHT, dev1->keybit);
 	} else {
 		dev1->keybit[BIT_WORD(BTN_MIDDLE)] |= BIT_MASK(BTN_MIDDLE);
 	}
 	snprintf(priv->phys, sizeof(priv->phys), "%s/input1", psmouse->ps2dev.serio->phys);
 	dev2->phys = priv->phys;
 	dev2->name = (priv->flags & ALPS_DUALPOINT) ?
 		     "DualPoint Stick" : "ALPS PS/2 Device";
 	dev2->id.bustype = BUS_I8042;
 	dev2->id.vendor  = 0x0002;
 	dev2->id.product = PSMOUSE_ALPS;
 	dev2->id.version = 0x0000;
 	dev2->dev.parent = &psmouse->ps2dev.serio->dev;
 	dev2->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
 	dev2->relbit[BIT_WORD(REL_X)] = BIT_MASK(REL_X) | BIT_MASK(REL_Y);
 	dev2->keybit[BIT_WORD(BTN_LEFT)] =
 		BIT_MASK(BTN_LEFT) | BIT_MASK(BTN_MIDDLE) | BIT_MASK(BTN_RIGHT);
 	__set_bit(INPUT_PROP_POINTER, dev2->propbit);
 	if (priv->flags & ALPS_DUALPOINT)
 		__set_bit(INPUT_PROP_POINTING_STICK, dev2->propbit);
 	if (input_register_device(priv->dev2))
 		goto init_fail;
 	psmouse->protocol_handler = alps_process_byte;
 	psmouse->poll = alps_poll;
 	psmouse->disconnect = alps_disconnect;
 	psmouse->reconnect = alps_reconnect;
 	psmouse->pktsize = priv->proto_version == ALPS_PROTO_V4 ? 8 : 6;
 	/* We are having trouble resyncing ALPS touchpads so disable it for now */
 	psmouse->resync_time = 0;
+	/* Allow 2 invalid packets without resetting device */
+	psmouse->resetafter = psmouse->pktsize * 2;
 	return 0;
 init_fail:
 	psmouse_reset(psmouse);
 	input_free_device(dev2);
 	kfree(priv);
 	psmouse->private = NULL;
 	return -1;
 }
 int alps_detect(struct psmouse *psmouse, bool set_properties)
 {
 	struct alps_data dummy;
 	if (alps_identify(psmouse, &dummy) < 0)
 		return -1;
 	if (set_properties) {
 		psmouse->vendor = "ALPS";
 		psmouse->name = dummy.flags & ALPS_DUALPOINT ?
 				"DualPoint TouchPad" : "GlidePoint";
 		psmouse->model = dummy.proto_version << 8;
 	}
 	return 0;
 }

drivers/input/mouse/elantech.c

Diff comments View file @ 56c381f

 /*
  * Elantech Touchpad driver (v6)
  *
  * Copyright (C) 2007-2009 Arjan Opmeer <arjan@opmeer.net>
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 as published
  * by the Free Software Foundation.
  *
  * Trademarks are the property of their respective owners.
  */
 #include <linux/delay.h>
 #include <linux/dmi.h>
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/input.h>
 #include <linux/input/mt.h>
 #include <linux/serio.h>
 #include <linux/libps2.h>
 #include <asm/unaligned.h>
 #include "psmouse.h"
 #include "elantech.h"
 #define elantech_debug(fmt, ...)					\
 	do {								\
 		if (etd->debug)						\
 			psmouse_printk(KERN_DEBUG, psmouse,		\
 					fmt, ##__VA_ARGS__);		\
 	} while (0)
 /*
  * Send a Synaptics style sliced query command
  */
 static int synaptics_send_cmd(struct psmouse *psmouse, unsigned char c,
 				unsigned char *param)
 {
 	if (psmouse_sliced_command(psmouse, c) ||
 	    ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO)) {
 		psmouse_err(psmouse, "%s query 0x%02x failed.\n", __func__, c);
 		return -1;
 	}
 	return 0;
 }
 /*
  * V3 and later support this fast command
  */
 static int elantech_send_cmd(struct psmouse *psmouse, unsigned char c,
 				unsigned char *param)
 {
 	struct ps2dev *ps2dev = &psmouse->ps2dev;
 	if (ps2_command(ps2dev, NULL, ETP_PS2_CUSTOM_COMMAND) ||
 	    ps2_command(ps2dev, NULL, c) ||
 	    ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) {
 		psmouse_err(psmouse, "%s query 0x%02x failed.\n", __func__, c);
 		return -1;
 	}
 	return 0;
 }
 /*
  * A retrying version of ps2_command
  */
 static int elantech_ps2_command(struct psmouse *psmouse,
 				unsigned char *param, int command)
 {
 	struct ps2dev *ps2dev = &psmouse->ps2dev;
 	struct elantech_data *etd = psmouse->private;
 	int rc;
 	int tries = ETP_PS2_COMMAND_TRIES;
 	do {
 		rc = ps2_command(ps2dev, param, command);
 		if (rc == 0)
 			break;
 		tries--;
 		elantech_debug("retrying ps2 command 0x%02x (%d).\n",
 				command, tries);
 		msleep(ETP_PS2_COMMAND_DELAY);
 	} while (tries > 0);
 	if (rc)
 		psmouse_err(psmouse, "ps2 command 0x%02x failed.\n", command);
 	return rc;
 }
 /*
  * Send an Elantech style special command to read a value from a register
  */
 static int elantech_read_reg(struct psmouse *psmouse, unsigned char reg,
 				unsigned char *val)
 {
 	struct elantech_data *etd = psmouse->private;
 	unsigned char param[3];
 	int rc = 0;
 	if (reg < 0x07 || reg > 0x26)
 		return -1;
 	if (reg > 0x11 && reg < 0x20)
 		return -1;
 	switch (etd->hw_version) {
 	case 1:
 		if (psmouse_sliced_command(psmouse, ETP_REGISTER_READ) ||
 		    psmouse_sliced_command(psmouse, reg) ||
 		    ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO)) {
 			rc = -1;
 		}
 		break;
 	case 2:
 		if (elantech_ps2_command(psmouse,  NULL, ETP_PS2_CUSTOM_COMMAND) ||
 		    elantech_ps2_command(psmouse,  NULL, ETP_REGISTER_READ) ||
 		    elantech_ps2_command(psmouse,  NULL, ETP_PS2_CUSTOM_COMMAND) ||
 		    elantech_ps2_command(psmouse,  NULL, reg) ||
 		    elantech_ps2_command(psmouse, param, PSMOUSE_CMD_GETINFO)) {
 			rc = -1;
 		}
 		break;
 	case 3 ... 4:
 		if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
 		    elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READWRITE) ||
 		    elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
 		    elantech_ps2_command(psmouse, NULL, reg) ||
 		    elantech_ps2_command(psmouse, param, PSMOUSE_CMD_GETINFO)) {
 			rc = -1;
 		}
 		break;
 	}
 	if (rc)
 		psmouse_err(psmouse, "failed to read register 0x%02x.\n", reg);
 	else if (etd->hw_version != 4)
 		*val = param[0];
 	else
 		*val = param[1];
 	return rc;
 }
 /*
  * Send an Elantech style special command to write a register with a value
  */
 static int elantech_write_reg(struct psmouse *psmouse, unsigned char reg,
 				unsigned char val)
 {
 	struct elantech_data *etd = psmouse->private;
 	int rc = 0;
 	if (reg < 0x07 || reg > 0x26)
 		return -1;
 	if (reg > 0x11 && reg < 0x20)
 		return -1;
 	switch (etd->hw_version) {
 	case 1:
 		if (psmouse_sliced_command(psmouse, ETP_REGISTER_WRITE) ||
 		    psmouse_sliced_command(psmouse, reg) ||
 		    psmouse_sliced_command(psmouse, val) ||
 		    ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSCALE11)) {
 			rc = -1;
 		}
 		break;
 	case 2:
 		if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
 		    elantech_ps2_command(psmouse, NULL, ETP_REGISTER_WRITE) ||
 		    elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
 		    elantech_ps2_command(psmouse, NULL, reg) ||
 		    elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
 		    elantech_ps2_command(psmouse, NULL, val) ||
 		    elantech_ps2_command(psmouse, NULL, PSMOUSE_CMD_SETSCALE11)) {
 			rc = -1;
 		}
 		break;
 	case 3:
 		if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
 		    elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READWRITE) ||
 		    elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
 		    elantech_ps2_command(psmouse, NULL, reg) ||
 		    elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
 		    elantech_ps2_command(psmouse, NULL, val) ||
 		    elantech_ps2_command(psmouse, NULL, PSMOUSE_CMD_SETSCALE11)) {
 			rc = -1;
 		}
 		break;
 	case 4:
 		if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
 		    elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READWRITE) ||
 		    elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
 		    elantech_ps2_command(psmouse, NULL, reg) ||
 		    elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
 		    elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READWRITE) ||
 		    elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
 		    elantech_ps2_command(psmouse, NULL, val) ||
 		    elantech_ps2_command(psmouse, NULL, PSMOUSE_CMD_SETSCALE11)) {
 			rc = -1;
 		}
 		break;
 	}
 	if (rc)
 		psmouse_err(psmouse,
 			    "failed to write register 0x%02x with value 0x%02x.\n",
 			    reg, val);
 	return rc;
 }
 /*
  * Dump a complete mouse movement packet to the syslog
  */
 static void elantech_packet_dump(struct psmouse *psmouse)
 {
 	int	i;
 	psmouse_printk(KERN_DEBUG, psmouse, "PS/2 packet [");
 	for (i = 0; i < psmouse->pktsize; i++)
 		printk("%s0x%02x ", i ? ", " : " ", psmouse->packet[i]);
 	printk("]\n");
 }
 /*
  * Interpret complete data packets and report absolute mode input events for
  * hardware version 1. (4 byte packets)
  */
 static void elantech_report_absolute_v1(struct psmouse *psmouse)
 {
 	struct input_dev *dev = psmouse->dev;
 	struct elantech_data *etd = psmouse->private;
 	unsigned char *packet = psmouse->packet;
 	int fingers;
 	if (etd->fw_version < 0x020000) {
 		/*
 		 * byte 0:  D   U  p1  p2   1  p3   R   L
 		 * byte 1:  f   0  th  tw  x9  x8  y9  y8
 		 */
 		fingers = ((packet[1] & 0x80) >> 7) +
 				((packet[1] & 0x30) >> 4);
 	} else {
 		/*
 		 * byte 0: n1  n0  p2  p1   1  p3   R   L
 		 * byte 1:  0   0   0   0  x9  x8  y9  y8
 		 */
 		fingers = (packet[0] & 0xc0) >> 6;
 	}
 	if (etd->jumpy_cursor) {
 		if (fingers != 1) {
 			etd->single_finger_reports = 0;
 		} else if (etd->single_finger_reports < 2) {
 			/* Discard first 2 reports of one finger, bogus */
 			etd->single_finger_reports++;
 			elantech_debug("discarding packet\n");
 			return;
 		}
 	}
 	input_report_key(dev, BTN_TOUCH, fingers != 0);
 	/*
 	 * byte 2: x7  x6  x5  x4  x3  x2  x1  x0
 	 * byte 3: y7  y6  y5  y4  y3  y2  y1  y0
 	 */
 	if (fingers) {
 		input_report_abs(dev, ABS_X,
 			((packet[1] & 0x0c) << 6) | packet[2]);
 		input_report_abs(dev, ABS_Y,
 			etd->y_max - (((packet[1] & 0x03) << 8) | packet[3]));
 	}
 	input_report_key(dev, BTN_TOOL_FINGER, fingers == 1);
 	input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2);
 	input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3);
 	input_report_key(dev, BTN_LEFT, packet[0] & 0x01);
 	input_report_key(dev, BTN_RIGHT, packet[0] & 0x02);
 	if (etd->fw_version < 0x020000 &&
 	    (etd->capabilities[0] & ETP_CAP_HAS_ROCKER)) {
 		/* rocker up */
 		input_report_key(dev, BTN_FORWARD, packet[0] & 0x40);
 		/* rocker down */
 		input_report_key(dev, BTN_BACK, packet[0] & 0x80);
 	}
 	input_sync(dev);
 }
 static void elantech_set_slot(struct input_dev *dev, int slot, bool active,
 			      unsigned int x, unsigned int y)
 {
 	input_mt_slot(dev, slot);
 	input_mt_report_slot_state(dev, MT_TOOL_FINGER, active);
 	if (active) {
 		input_report_abs(dev, ABS_MT_POSITION_X, x);
 		input_report_abs(dev, ABS_MT_POSITION_Y, y);
 	}
 }
 /* x1 < x2 and y1 < y2 when two fingers, x = y = 0 when not pressed */
 static void elantech_report_semi_mt_data(struct input_dev *dev,
 					 unsigned int num_fingers,
 					 unsigned int x1, unsigned int y1,
 					 unsigned int x2, unsigned int y2)
 {
 	elantech_set_slot(dev, 0, num_fingers != 0, x1, y1);
 	elantech_set_slot(dev, 1, num_fingers == 2, x2, y2);
 }
 /*
  * Interpret complete data packets and report absolute mode input events for
  * hardware version 2. (6 byte packets)
  */
 static void elantech_report_absolute_v2(struct psmouse *psmouse)
 {
 	struct elantech_data *etd = psmouse->private;
 	struct input_dev *dev = psmouse->dev;
 	unsigned char *packet = psmouse->packet;
 	unsigned int fingers, x1 = 0, y1 = 0, x2 = 0, y2 = 0;
 	unsigned int width = 0, pres = 0;
 	/* byte 0: n1  n0   .   .   .   .   R   L */
 	fingers = (packet[0] & 0xc0) >> 6;
 	switch (fingers) {
 	case 3:
 		/*
 		 * Same as one finger, except report of more than 3 fingers:
 		 * byte 3:  n4  .   w1  w0   .   .   .   .
 		 */
 		if (packet[3] & 0x80)
 			fingers = 4;
 		/* pass through... */
 	case 1:
 		/*
 		 * byte 1:  .   .   .   .  x11 x10 x9  x8
 		 * byte 2: x7  x6  x5  x4  x4  x2  x1  x0
 		 */
 		x1 = ((packet[1] & 0x0f) << 8) | packet[2];
 		/*
 		 * byte 4:  .   .   .   .  y11 y10 y9  y8
 		 * byte 5: y7  y6  y5  y4  y3  y2  y1  y0
 		 */
 		y1 = etd->y_max - (((packet[4] & 0x0f) << 8) | packet[5]);
 		pres = (packet[1] & 0xf0) | ((packet[4] & 0xf0) >> 4);
 		width = ((packet[0] & 0x30) >> 2) | ((packet[3] & 0x30) >> 4);
 		break;
 	case 2:
 		/*
 		 * The coordinate of each finger is reported separately
 		 * with a lower resolution for two finger touches:
 		 * byte 0:  .   .  ay8 ax8  .   .   .   .
 		 * byte 1: ax7 ax6 ax5 ax4 ax3 ax2 ax1 ax0
 		 */
 		x1 = (((packet[0] & 0x10) << 4) | packet[1]) << 2;
 		/* byte 2: ay7 ay6 ay5 ay4 ay3 ay2 ay1 ay0 */
 		y1 = etd->y_max -
 			((((packet[0] & 0x20) << 3) | packet[2]) << 2);
 		/*
 		 * byte 3:  .   .  by8 bx8  .   .   .   .
 		 * byte 4: bx7 bx6 bx5 bx4 bx3 bx2 bx1 bx0
 		 */
 		x2 = (((packet[3] & 0x10) << 4) | packet[4]) << 2;
 		/* byte 5: by7 by8 by5 by4 by3 by2 by1 by0 */
 		y2 = etd->y_max -
 			((((packet[3] & 0x20) << 3) | packet[5]) << 2);
 		/* Unknown so just report sensible values */
 		pres = 127;
 		width = 7;
 		break;
 	}
 	input_report_key(dev, BTN_TOUCH, fingers != 0);
 	if (fingers != 0) {
 		input_report_abs(dev, ABS_X, x1);
 		input_report_abs(dev, ABS_Y, y1);
 	}
 	elantech_report_semi_mt_data(dev, fingers, x1, y1, x2, y2);
 	input_report_key(dev, BTN_TOOL_FINGER, fingers == 1);
 	input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2);
 	input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3);
 	input_report_key(dev, BTN_TOOL_QUADTAP, fingers == 4);
 	input_report_key(dev, BTN_LEFT, packet[0] & 0x01);
 	input_report_key(dev, BTN_RIGHT, packet[0] & 0x02);
 	if (etd->reports_pressure) {
 		input_report_abs(dev, ABS_PRESSURE, pres);
 		input_report_abs(dev, ABS_TOOL_WIDTH, width);
 	}
 	input_sync(dev);
 }
 static void elantech_report_trackpoint(struct psmouse *psmouse,
 				       int packet_type)
 {
 	/*
 	 * byte 0:  0   0  sx  sy   0   M   R   L
 	 * byte 1:~sx   0   0   0   0   0   0   0
 	 * byte 2:~sy   0   0   0   0   0   0   0
 	 * byte 3:  0   0 ~sy ~sx   0   1   1   0
 	 * byte 4: x7  x6  x5  x4  x3  x2  x1  x0
 	 * byte 5: y7  y6  y5  y4  y3  y2  y1  y0
 	 *
 	 * x and y are written in two's complement spread
 	 * over 9 bits with sx/sy the relative top bit and
 	 * x7..x0 and y7..y0 the lower bits.
 	 * The sign of y is opposite to what the input driver
 	 * expects for a relative movement
 	 */
 	struct elantech_data *etd = psmouse->private;
 	struct input_dev *tp_dev = etd->tp_dev;
 	unsigned char *packet = psmouse->packet;
 	int x, y;
 	u32 t;
 	if (dev_WARN_ONCE(&psmouse->ps2dev.serio->dev,
 			  !tp_dev,
 			  psmouse_fmt("Unexpected trackpoint message\n"))) {
 		if (etd->debug == 1)
 			elantech_packet_dump(psmouse);
 		return;
 	}
 	t = get_unaligned_le32(&packet[0]);
 	switch (t & ~7U) {
 	case 0x06000030U:
 	case 0x16008020U:
 	case 0x26800010U:
 	case 0x36808000U:
 		x = packet[4] - (int)((packet[1]^0x80) << 1);
 		y = (int)((packet[2]^0x80) << 1) - packet[5];
 		input_report_key(tp_dev, BTN_LEFT, packet[0] & 0x01);
 		input_report_key(tp_dev, BTN_RIGHT, packet[0] & 0x02);
 		input_report_key(tp_dev, BTN_MIDDLE, packet[0] & 0x04);
 		input_report_rel(tp_dev, REL_X, x);
 		input_report_rel(tp_dev, REL_Y, y);
 		input_sync(tp_dev);
 		break;
 	default:
 		/* Dump unexpected packet sequences if debug=1 (default) */
 		if (etd->debug == 1)
 			elantech_packet_dump(psmouse);
 		break;
 	}
 }
 /*
  * Interpret complete data packets and report absolute mode input events for
  * hardware version 3. (12 byte packets for two fingers)
  */
 static void elantech_report_absolute_v3(struct psmouse *psmouse,
 					int packet_type)
 {
 	struct input_dev *dev = psmouse->dev;
 	struct elantech_data *etd = psmouse->private;
 	unsigned char *packet = psmouse->packet;
 	unsigned int fingers = 0, x1 = 0, y1 = 0, x2 = 0, y2 = 0;
 	unsigned int width = 0, pres = 0;
 	/* byte 0: n1  n0   .   .   .   .   R   L */
 	fingers = (packet[0] & 0xc0) >> 6;
 	switch (fingers) {
 	case 3:
 	case 1:
 		/*
 		 * byte 1:  .   .   .   .  x11 x10 x9  x8
 		 * byte 2: x7  x6  x5  x4  x4  x2  x1  x0
 		 */
 		x1 = ((packet[1] & 0x0f) << 8) | packet[2];
 		/*
 		 * byte 4:  .   .   .   .  y11 y10 y9  y8
 		 * byte 5: y7  y6  y5  y4  y3  y2  y1  y0
 		 */
 		y1 = etd->y_max - (((packet[4] & 0x0f) << 8) | packet[5]);
 		break;
 	case 2:
 		if (packet_type == PACKET_V3_HEAD) {
 			/*
 			 * byte 1:   .    .    .    .  ax11 ax10 ax9  ax8
 			 * byte 2: ax7  ax6  ax5  ax4  ax3  ax2  ax1  ax0
 			 */
 			etd->mt[0].x = ((packet[1] & 0x0f) << 8) | packet[2];
 			/*
 			 * byte 4:   .    .    .    .  ay11 ay10 ay9  ay8
 			 * byte 5: ay7  ay6  ay5  ay4  ay3  ay2  ay1  ay0
 			 */
 			etd->mt[0].y = etd->y_max -
 				(((packet[4] & 0x0f) << 8) | packet[5]);
 			/*
 			 * wait for next packet
 			 */
 			return;
 		}
 		/* packet_type == PACKET_V3_TAIL */
 		x1 = etd->mt[0].x;
 		y1 = etd->mt[0].y;
 		x2 = ((packet[1] & 0x0f) << 8) | packet[2];
 		y2 = etd->y_max - (((packet[4] & 0x0f) << 8) | packet[5]);
 		break;
 	}
 	pres = (packet[1] & 0xf0) | ((packet[4] & 0xf0) >> 4);
 	width = ((packet[0] & 0x30) >> 2) | ((packet[3] & 0x30) >> 4);
 	input_report_key(dev, BTN_TOUCH, fingers != 0);
 	if (fingers != 0) {
 		input_report_abs(dev, ABS_X, x1);
 		input_report_abs(dev, ABS_Y, y1);
 	}
 	elantech_report_semi_mt_data(dev, fingers, x1, y1, x2, y2);
 	input_report_key(dev, BTN_TOOL_FINGER, fingers == 1);
 	input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2);
 	input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3);
 	/* For clickpads map both buttons to BTN_LEFT */
 	if (etd->fw_version & 0x001000) {
 		input_report_key(dev, BTN_LEFT, packet[0] & 0x03);
 	} else {
 		input_report_key(dev, BTN_LEFT, packet[0] & 0x01);
 		input_report_key(dev, BTN_RIGHT, packet[0] & 0x02);
 	}
 	input_report_abs(dev, ABS_PRESSURE, pres);
 	input_report_abs(dev, ABS_TOOL_WIDTH, width);
 	input_sync(dev);
 }
 static void elantech_input_sync_v4(struct psmouse *psmouse)
 {
 	struct input_dev *dev = psmouse->dev;
 	struct elantech_data *etd = psmouse->private;
 	unsigned char *packet = psmouse->packet;
 	/* For clickpads map both buttons to BTN_LEFT */
 	if (etd->fw_version & 0x001000) {
 		input_report_key(dev, BTN_LEFT, packet[0] & 0x03);
 	} else {
 		input_report_key(dev, BTN_LEFT, packet[0] & 0x01);
 		input_report_key(dev, BTN_RIGHT, packet[0] & 0x02);
+		input_report_key(dev, BTN_MIDDLE, packet[0] & 0x04);
 	}
 	input_mt_report_pointer_emulation(dev, true);
 	input_sync(dev);
 }
 static void process_packet_status_v4(struct psmouse *psmouse)
 {
 	struct input_dev *dev = psmouse->dev;
 	unsigned char *packet = psmouse->packet;
 	unsigned fingers;
 	int i;
 	/* notify finger state change */
 	fingers = packet[1] & 0x1f;
 	for (i = 0; i < ETP_MAX_FINGERS; i++) {
 		if ((fingers & (1 << i)) == 0) {
 			input_mt_slot(dev, i);
 			input_mt_report_slot_state(dev, MT_TOOL_FINGER, false);
 		}
 	}
 	elantech_input_sync_v4(psmouse);
 }
 static void process_packet_head_v4(struct psmouse *psmouse)
 {
 	struct input_dev *dev = psmouse->dev;
 	struct elantech_data *etd = psmouse->private;
 	unsigned char *packet = psmouse->packet;
 	int id = ((packet[3] & 0xe0) >> 5) - 1;
 	int pres, traces;
 	if (id < 0)
 		return;
 	etd->mt[id].x = ((packet[1] & 0x0f) << 8) | packet[2];
 	etd->mt[id].y = etd->y_max - (((packet[4] & 0x0f) << 8) | packet[5]);
 	pres = (packet[1] & 0xf0) | ((packet[4] & 0xf0) >> 4);
 	traces = (packet[0] & 0xf0) >> 4;
 	input_mt_slot(dev, id);
 	input_mt_report_slot_state(dev, MT_TOOL_FINGER, true);
 	input_report_abs(dev, ABS_MT_POSITION_X, etd->mt[id].x);
 	input_report_abs(dev, ABS_MT_POSITION_Y, etd->mt[id].y);
 	input_report_abs(dev, ABS_MT_PRESSURE, pres);
 	input_report_abs(dev, ABS_MT_TOUCH_MAJOR, traces * etd->width);
 	/* report this for backwards compatibility */
 	input_report_abs(dev, ABS_TOOL_WIDTH, traces);
 	elantech_input_sync_v4(psmouse);
 }
 static void process_packet_motion_v4(struct psmouse *psmouse)
 {
 	struct input_dev *dev = psmouse->dev;
 	struct elantech_data *etd = psmouse->private;
 	unsigned char *packet = psmouse->packet;
 	int weight, delta_x1 = 0, delta_y1 = 0, delta_x2 = 0, delta_y2 = 0;
 	int id, sid;
 	id = ((packet[0] & 0xe0) >> 5) - 1;
 	if (id < 0)
 		return;
 	sid = ((packet[3] & 0xe0) >> 5) - 1;
 	weight = (packet[0] & 0x10) ? ETP_WEIGHT_VALUE : 1;
 	/*
 	 * Motion packets give us the delta of x, y values of specific fingers,
 	 * but in two's complement. Let the compiler do the conversion for us.
 	 * Also _enlarge_ the numbers to int, in case of overflow.
 	 */
 	delta_x1 = (signed char)packet[1];
 	delta_y1 = (signed char)packet[2];
 	delta_x2 = (signed char)packet[4];
 	delta_y2 = (signed char)packet[5];
 	etd->mt[id].x += delta_x1 * weight;
 	etd->mt[id].y -= delta_y1 * weight;
 	input_mt_slot(dev, id);
 	input_report_abs(dev, ABS_MT_POSITION_X, etd->mt[id].x);
 	input_report_abs(dev, ABS_MT_POSITION_Y, etd->mt[id].y);
 	if (sid >= 0) {
 		etd->mt[sid].x += delta_x2 * weight;
 		etd->mt[sid].y -= delta_y2 * weight;
 		input_mt_slot(dev, sid);
 		input_report_abs(dev, ABS_MT_POSITION_X, etd->mt[sid].x);
 		input_report_abs(dev, ABS_MT_POSITION_Y, etd->mt[sid].y);
 	}
 	elantech_input_sync_v4(psmouse);
 }
 static void elantech_report_absolute_v4(struct psmouse *psmouse,
 					int packet_type)
 {
 	switch (packet_type) {
 	case PACKET_V4_STATUS:
 		process_packet_status_v4(psmouse);
 		break;
 	case PACKET_V4_HEAD:
 		process_packet_head_v4(psmouse);
 		break;
 	case PACKET_V4_MOTION:
 		process_packet_motion_v4(psmouse);
 		break;
 	case PACKET_UNKNOWN:
 	default:
 		/* impossible to get here */
 		break;
 	}
 }
 static int elantech_packet_check_v1(struct psmouse *psmouse)
 {
 	struct elantech_data *etd = psmouse->private;
 	unsigned char *packet = psmouse->packet;
 	unsigned char p1, p2, p3;
 	/* Parity bits are placed differently */
 	if (etd->fw_version < 0x020000) {
 		/* byte 0:  D   U  p1  p2   1  p3   R   L */
 		p1 = (packet[0] & 0x20) >> 5;
 		p2 = (packet[0] & 0x10) >> 4;
 	} else {
 		/* byte 0: n1  n0  p2  p1   1  p3   R   L */
 		p1 = (packet[0] & 0x10) >> 4;
 		p2 = (packet[0] & 0x20) >> 5;
 	}
 	p3 = (packet[0] & 0x04) >> 2;
 	return etd->parity[packet[1]] == p1 &&
 	       etd->parity[packet[2]] == p2 &&
 	       etd->parity[packet[3]] == p3;
 }
 static int elantech_debounce_check_v2(struct psmouse *psmouse)
 {
         /*
          * When we encounter packet that matches this exactly, it means the
          * hardware is in debounce status. Just ignore the whole packet.
          */
         const u8 debounce_packet[] = { 0x84, 0xff, 0xff, 0x02, 0xff, 0xff };
         unsigned char *packet = psmouse->packet;
         return !memcmp(packet, debounce_packet, sizeof(debounce_packet));
 }
 static int elantech_packet_check_v2(struct psmouse *psmouse)
 {
 	struct elantech_data *etd = psmouse->private;
 	unsigned char *packet = psmouse->packet;
 	/*
 	 * V2 hardware has two flavors. Older ones that do not report pressure,
 	 * and newer ones that reports pressure and width. With newer ones, all
 	 * packets (1, 2, 3 finger touch) have the same constant bits. With
 	 * older ones, 1/3 finger touch packets and 2 finger touch packets
 	 * have different constant bits.
 	 * With all three cases, if the constant bits are not exactly what I
 	 * expected, I consider them invalid.
 	 */
 	if (etd->reports_pressure)
 		return (packet[0] & 0x0c) == 0x04 &&
 		       (packet[3] & 0x0f) == 0x02;
 	if ((packet[0] & 0xc0) == 0x80)
 		return (packet[0] & 0x0c) == 0x0c &&
 		       (packet[3] & 0x0e) == 0x08;
 	return (packet[0] & 0x3c) == 0x3c &&
 	       (packet[1] & 0xf0) == 0x00 &&
 	       (packet[3] & 0x3e) == 0x38 &&
 	       (packet[4] & 0xf0) == 0x00;
 }
 /*
  * We check the constant bits to determine what packet type we get,
  * so packet checking is mandatory for v3 and later hardware.
  */
 static int elantech_packet_check_v3(struct psmouse *psmouse)
 {
 	struct elantech_data *etd = psmouse->private;
 	const u8 debounce_packet[] = { 0xc4, 0xff, 0xff, 0x02, 0xff, 0xff };
 	unsigned char *packet = psmouse->packet;
 	/*
 	 * check debounce first, it has the same signature in byte 0
 	 * and byte 3 as PACKET_V3_HEAD.
 	 */
 	if (!memcmp(packet, debounce_packet, sizeof(debounce_packet)))
 		return PACKET_DEBOUNCE;
 	/*
 	 * If the hardware flag 'crc_enabled' is set the packets have
 	 * different signatures.
 	 */
 	if (etd->crc_enabled) {
 		if ((packet[3] & 0x09) == 0x08)
 			return PACKET_V3_HEAD;
 		if ((packet[3] & 0x09) == 0x09)
 			return PACKET_V3_TAIL;
 	} else {
 		if ((packet[0] & 0x0c) == 0x04 && (packet[3] & 0xcf) == 0x02)
 			return PACKET_V3_HEAD;
 		if ((packet[0] & 0x0c) == 0x0c && (packet[3] & 0xce) == 0x0c)
 			return PACKET_V3_TAIL;
 		if ((packet[3] & 0x0f) == 0x06)
 			return PACKET_TRACKPOINT;
 	}
 	return PACKET_UNKNOWN;
 }
 static int elantech_packet_check_v4(struct psmouse *psmouse)
 {
 	struct elantech_data *etd = psmouse->private;
 	unsigned char *packet = psmouse->packet;
 	unsigned char packet_type = packet[3] & 0x03;
 	bool sanity_check;
+	if ((packet[3] & 0x0f) == 0x06)
+		return PACKET_TRACKPOINT;
 	/*
 	 * Sanity check based on the constant bits of a packet.
 	 * The constant bits change depending on the value of
 	 * the hardware flag 'crc_enabled' but are the same for
 	 * every packet, regardless of the type.
 	 */
 	if (etd->crc_enabled)
 		sanity_check = ((packet[3] & 0x08) == 0x00);
 	else
 		sanity_check = ((packet[0] & 0x0c) == 0x04 &&
 				(packet[3] & 0x1c) == 0x10);
 	if (!sanity_check)
 		return PACKET_UNKNOWN;
 	switch (packet_type) {
 	case 0:
 		return PACKET_V4_STATUS;
 	case 1:
 		return PACKET_V4_HEAD;
 	case 2:
 		return PACKET_V4_MOTION;
 	}
 	return PACKET_UNKNOWN;
 }
 /*
  * Process byte stream from mouse and handle complete packets
  */
 static psmouse_ret_t elantech_process_byte(struct psmouse *psmouse)
 {
 	struct elantech_data *etd = psmouse->private;
 	int packet_type;
 	if (psmouse->pktcnt < psmouse->pktsize)
 		return PSMOUSE_GOOD_DATA;
 	if (etd->debug > 1)
 		elantech_packet_dump(psmouse);
 	switch (etd->hw_version) {
 	case 1:
 		if (etd->paritycheck && !elantech_packet_check_v1(psmouse))
 			return PSMOUSE_BAD_DATA;
 		elantech_report_absolute_v1(psmouse);
 		break;
 	case 2:
 		/* ignore debounce */
 		if (elantech_debounce_check_v2(psmouse))
 			return PSMOUSE_FULL_PACKET;
 		if (etd->paritycheck && !elantech_packet_check_v2(psmouse))
 			return PSMOUSE_BAD_DATA;
 		elantech_report_absolute_v2(psmouse);
 		break;
 	case 3:
 		packet_type = elantech_packet_check_v3(psmouse);
 		switch (packet_type) {
 		case PACKET_UNKNOWN:
 			return PSMOUSE_BAD_DATA;
 		case PACKET_DEBOUNCE:
 			/* ignore debounce */
 			break;
 		case PACKET_TRACKPOINT:
 			elantech_report_trackpoint(psmouse, packet_type);
 			break;
 		default:
 			elantech_report_absolute_v3(psmouse, packet_type);
 			break;
 		}
 		break;
 	case 4:
 		packet_type = elantech_packet_check_v4(psmouse);
-		if (packet_type == PACKET_UNKNOWN)
+		switch (packet_type) {
+		case PACKET_UNKNOWN:
 			return PSMOUSE_BAD_DATA;
-		elantech_report_absolute_v4(psmouse, packet_type);
+		case PACKET_TRACKPOINT:
+			elantech_report_trackpoint(psmouse, packet_type);
+			break;
+		default:
+			elantech_report_absolute_v4(psmouse, packet_type);
+			break;
+		}
 		break;
 	}
 	return PSMOUSE_FULL_PACKET;
 }
 /*
  * Put the touchpad into absolute mode
  */
 static int elantech_set_absolute_mode(struct psmouse *psmouse)
 {
 	struct elantech_data *etd = psmouse->private;
 	unsigned char val;
 	int tries = ETP_READ_BACK_TRIES;
 	int rc = 0;
 	switch (etd->hw_version) {
 	case 1:
 		etd->reg_10 = 0x16;
 		etd->reg_11 = 0x8f;
 		if (elantech_write_reg(psmouse, 0x10, etd->reg_10) ||
 		    elantech_write_reg(psmouse, 0x11, etd->reg_11)) {
 			rc = -1;
 		}
 		break;
 	case 2:
 					/* Windows driver values */
 		etd->reg_10 = 0x54;
 		etd->reg_11 = 0x88;	/* 0x8a */
 		etd->reg_21 = 0x60;	/* 0x00 */
 		if (elantech_write_reg(psmouse, 0x10, etd->reg_10) ||
 		    elantech_write_reg(psmouse, 0x11, etd->reg_11) ||
 		    elantech_write_reg(psmouse, 0x21, etd->reg_21)) {
 			rc = -1;
 		}
 		break;
 	case 3:
 		if (etd->set_hw_resolution)
 			etd->reg_10 = 0x0b;
 		else
 			etd->reg_10 = 0x01;
 		if (elantech_write_reg(psmouse, 0x10, etd->reg_10))
 			rc = -1;
 		break;
 	case 4:
 		etd->reg_07 = 0x01;
 		if (elantech_write_reg(psmouse, 0x07, etd->reg_07))
 			rc = -1;
 		goto skip_readback_reg_10; /* v4 has no reg 0x10 to read */
 	}
 	if (rc == 0) {
 		/*
 		 * Read back reg 0x10. For hardware version 1 we must make
 		 * sure the absolute mode bit is set. For hardware version 2
 		 * the touchpad is probably initializing and not ready until
 		 * we read back the value we just wrote.
 		 */
 		do {
 			rc = elantech_read_reg(psmouse, 0x10, &val);
 			if (rc == 0)
 				break;
 			tries--;
 			elantech_debug("retrying read (%d).\n", tries);
 			msleep(ETP_READ_BACK_DELAY);
 		} while (tries > 0);
 		if (rc) {
 			psmouse_err(psmouse,
 				    "failed to read back register 0x10.\n");
 		} else if (etd->hw_version == 1 &&
 			   !(val & ETP_R10_ABSOLUTE_MODE)) {
 			psmouse_err(psmouse,
 				    "touchpad refuses to switch to absolute mode.\n");
 			rc = -1;
 		}
 	}
  skip_readback_reg_10:
 	if (rc)
 		psmouse_err(psmouse, "failed to initialise registers.\n");
 	return rc;
 }
 static int elantech_set_range(struct psmouse *psmouse,
 			      unsigned int *x_min, unsigned int *y_min,
 			      unsigned int *x_max, unsigned int *y_max,
 			      unsigned int *width)
 {
 	struct elantech_data *etd = psmouse->private;
 	unsigned char param[3];
 	unsigned char traces;
 	switch (etd->hw_version) {
 	case 1:
 		*x_min = ETP_XMIN_V1;
 		*y_min = ETP_YMIN_V1;
 		*x_max = ETP_XMAX_V1;
 		*y_max = ETP_YMAX_V1;
 		break;
 	case 2:
 		if (etd->fw_version == 0x020800 ||
 		    etd->fw_version == 0x020b00 ||
 		    etd->fw_version == 0x020030) {
 			*x_min = ETP_XMIN_V2;
 			*y_min = ETP_YMIN_V2;
 			*x_max = ETP_XMAX_V2;
 			*y_max = ETP_YMAX_V2;
 		} else {
 			int i;
 			int fixed_dpi;
 			i = (etd->fw_version > 0x020800 &&
 			     etd->fw_version < 0x020900) ? 1 : 2;
 			if (etd->send_cmd(psmouse, ETP_FW_ID_QUERY, param))
 				return -1;
 			fixed_dpi = param[1] & 0x10;
 			if (((etd->fw_version >> 16) == 0x14) && fixed_dpi) {
 				if (etd->send_cmd(psmouse, ETP_SAMPLE_QUERY, param))
 					return -1;
 				*x_max = (etd->capabilities[1] - i) * param[1] / 2;
 				*y_max = (etd->capabilities[2] - i) * param[2] / 2;
 			} else if (etd->fw_version == 0x040216) {
 				*x_max = 819;
 				*y_max = 405;
 			} else if (etd->fw_version == 0x040219 || etd->fw_version == 0x040215) {
 				*x_max = 900;
 				*y_max = 500;
 			} else {
 				*x_max = (etd->capabilities[1] - i) * 64;
 				*y_max = (etd->capabilities[2] - i) * 64;
 			}
 		}
 		break;
 	case 3:
 		if (etd->send_cmd(psmouse, ETP_FW_ID_QUERY, param))
 			return -1;
 		*x_max = (0x0f & param[0]) << 8 | param[1];
 		*y_max = (0xf0 & param[0]) << 4 | param[2];
 		break;
 	case 4:
 		if (etd->send_cmd(psmouse, ETP_FW_ID_QUERY, param))
 			return -1;
 		*x_max = (0x0f & param[0]) << 8 | param[1];
 		*y_max = (0xf0 & param[0]) << 4 | param[2];
 		traces = etd->capabilities[1];
 		if ((traces < 2) || (traces > *x_max))
 			return -1;
 		*width = *x_max / (traces - 1);
 		break;
 	}
 	return 0;
 }
 /*
  * (value from firmware) * 10 + 790 = dpi
  * we also have to convert dpi to dots/mm (*10/254 to avoid floating point)
  */
 static unsigned int elantech_convert_res(unsigned int val)
 {
 	return (val * 10 + 790) * 10 / 254;
 }
 static int elantech_get_resolution_v4(struct psmouse *psmouse,
 				      unsigned int *x_res,
 				      unsigned int *y_res)
 {
 	unsigned char param[3];
 	if (elantech_send_cmd(psmouse, ETP_RESOLUTION_QUERY, param))
 		return -1;
 	*x_res = elantech_convert_res(param[1] & 0x0f);
 	*y_res = elantech_convert_res((param[1] & 0xf0) >> 4);
 	return 0;
 }
 /*
  * Advertise INPUT_PROP_BUTTONPAD for clickpads. The testing of bit 12 in
  * fw_version for this is based on the following fw_version & caps table:
  *
  * Laptop-model:           fw_version:     caps:           buttons:
  * Acer S3                 0x461f00        10, 13, 0e      clickpad
  * Acer S7-392             0x581f01        50, 17, 0d      clickpad
  * Acer V5-131             0x461f02        01, 16, 0c      clickpad
  * Acer V5-551             0x461f00        ?               clickpad
  * Asus K53SV              0x450f01        78, 15, 0c      2 hw buttons
  * Asus G46VW              0x460f02        00, 18, 0c      2 hw buttons
  * Asus G750JX             0x360f00        00, 16, 0c      2 hw buttons
  * Asus UX31               0x361f00        20, 15, 0e      clickpad
  * Asus UX32VD             0x361f02        00, 15, 0e      clickpad
  * Avatar AVIU-145A2       0x361f00        ?               clickpad
  * Fujitsu H730            0x570f00        c0, 14, 0c      3 hw buttons (**)
  * Gigabyte U2442          0x450f01        58, 17, 0c      2 hw buttons
  * Lenovo L430             0x350f02        b9, 15, 0c      2 hw buttons (*)
  * Lenovo L530             0x350f02        b9, 15, 0c      2 hw buttons (*)
  * Samsung NF210           0x150b00        78, 14, 0a      2 hw buttons
  * Samsung NP770Z5E        0x575f01        10, 15, 0f      clickpad
  * Samsung NP700Z5B        0x361f06        21, 15, 0f      clickpad
  * Samsung NP900X3E-A02    0x575f03        ?               clickpad
  * Samsung NP-QX410        0x851b00        19, 14, 0c      clickpad
  * Samsung RC512           0x450f00        08, 15, 0c      2 hw buttons
  * Samsung RF710           0x450f00        ?               2 hw buttons
  * System76 Pangolin       0x250f01        ?               2 hw buttons
  * (*) + 3 trackpoint buttons
  * (**) + 0 trackpoint buttons
  * Note: Lenovo L430 and Lenovo L430 have the same fw_version/caps
  */
 static void elantech_set_buttonpad_prop(struct psmouse *psmouse)
 {
 	struct input_dev *dev = psmouse->dev;
 	struct elantech_data *etd = psmouse->private;
 	if (etd->fw_version & 0x001000) {
 		__set_bit(INPUT_PROP_BUTTONPAD, dev->propbit);
 		__clear_bit(BTN_RIGHT, dev->keybit);
 	}
 }
 /*
+ * Some hw_version 4 models do have a middle button
+ */
+static const struct dmi_system_id elantech_dmi_has_middle_button[] = {
+#if defined(CONFIG_DMI) && defined(CONFIG_X86)
+	{
+		/* Fujitsu H730 has a middle button */
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "CELSIUS H730"),
+		},
+	},
+#endif
+	{ }
+};
+/*
  * Set the appropriate event bits for the input subsystem
  */
 static int elantech_set_input_params(struct psmouse *psmouse)
 {
 	struct input_dev *dev = psmouse->dev;
 	struct elantech_data *etd = psmouse->private;
 	unsigned int x_min = 0, y_min = 0, x_max = 0, y_max = 0, width = 0;
 	unsigned int x_res = 0, y_res = 0;
 	if (elantech_set_range(psmouse, &x_min, &y_min, &x_max, &y_max, &width))
 		return -1;
 	__set_bit(INPUT_PROP_POINTER, dev->propbit);
 	__set_bit(EV_KEY, dev->evbit);
 	__set_bit(EV_ABS, dev->evbit);
 	__clear_bit(EV_REL, dev->evbit);
 	__set_bit(BTN_LEFT, dev->keybit);
+	if (dmi_check_system(elantech_dmi_has_middle_button))
+		__set_bit(BTN_MIDDLE, dev->keybit);
 	__set_bit(BTN_RIGHT, dev->keybit);
 	__set_bit(BTN_TOUCH, dev->keybit);
 	__set_bit(BTN_TOOL_FINGER, dev->keybit);
 	__set_bit(BTN_TOOL_DOUBLETAP, dev->keybit);
 	__set_bit(BTN_TOOL_TRIPLETAP, dev->keybit);
 	switch (etd->hw_version) {
 	case 1:
 		/* Rocker button */
 		if (etd->fw_version < 0x020000 &&
 		    (etd->capabilities[0] & ETP_CAP_HAS_ROCKER)) {
 			__set_bit(BTN_FORWARD, dev->keybit);
 			__set_bit(BTN_BACK, dev->keybit);
 		}
 		input_set_abs_params(dev, ABS_X, x_min, x_max, 0, 0);
 		input_set_abs_params(dev, ABS_Y, y_min, y_max, 0, 0);
 		break;
 	case 2:
 		__set_bit(BTN_TOOL_QUADTAP, dev->keybit);
 		__set_bit(INPUT_PROP_SEMI_MT, dev->propbit);
 		/* fall through */
 	case 3:
 		if (etd->hw_version == 3)
 			elantech_set_buttonpad_prop(psmouse);
 		input_set_abs_params(dev, ABS_X, x_min, x_max, 0, 0);
 		input_set_abs_params(dev, ABS_Y, y_min, y_max, 0, 0);
 		if (etd->reports_pressure) {
 			input_set_abs_params(dev, ABS_PRESSURE, ETP_PMIN_V2,
 					     ETP_PMAX_V2, 0, 0);
 			input_set_abs_params(dev, ABS_TOOL_WIDTH, ETP_WMIN_V2,
 					     ETP_WMAX_V2, 0, 0);
 		}
 		input_mt_init_slots(dev, 2, 0);
 		input_set_abs_params(dev, ABS_MT_POSITION_X, x_min, x_max, 0, 0);
 		input_set_abs_params(dev, ABS_MT_POSITION_Y, y_min, y_max, 0, 0);
 		break;
 	case 4:
 		if (elantech_get_resolution_v4(psmouse, &x_res, &y_res)) {
 			/*
 			 * if query failed, print a warning and leave the values
 			 * zero to resemble synaptics.c behavior.
 			 */
 			psmouse_warn(psmouse, "couldn't query resolution data.\n");
 		}
 		elantech_set_buttonpad_prop(psmouse);
 		__set_bit(BTN_TOOL_QUADTAP, dev->keybit);
 		/* For X to recognize me as touchpad. */
 		input_set_abs_params(dev, ABS_X, x_min, x_max, 0, 0);
 		input_set_abs_params(dev, ABS_Y, y_min, y_max, 0, 0);
 		input_abs_set_res(dev, ABS_X, x_res);
 		input_abs_set_res(dev, ABS_Y, y_res);
 		/*
 		 * range of pressure and width is the same as v2,
 		 * report ABS_PRESSURE, ABS_TOOL_WIDTH for compatibility.
 		 */
 		input_set_abs_params(dev, ABS_PRESSURE, ETP_PMIN_V2,
 				     ETP_PMAX_V2, 0, 0);
 		input_set_abs_params(dev, ABS_TOOL_WIDTH, ETP_WMIN_V2,
 				     ETP_WMAX_V2, 0, 0);
 		/* Multitouch capable pad, up to 5 fingers. */
 		input_mt_init_slots(dev, ETP_MAX_FINGERS, 0);
 		input_set_abs_params(dev, ABS_MT_POSITION_X, x_min, x_max, 0, 0);
 		input_set_abs_params(dev, ABS_MT_POSITION_Y, y_min, y_max, 0, 0);
 		input_abs_set_res(dev, ABS_MT_POSITION_X, x_res);
 		input_abs_set_res(dev, ABS_MT_POSITION_Y, y_res);
 		input_set_abs_params(dev, ABS_MT_PRESSURE, ETP_PMIN_V2,
 				     ETP_PMAX_V2, 0, 0);
 		/*
 		 * The firmware reports how many trace lines the finger spans,
 		 * convert to surface unit as Protocol-B requires.
 		 */
 		input_set_abs_params(dev, ABS_MT_TOUCH_MAJOR, 0,
 				     ETP_WMAX_V2 * width, 0, 0);
 		break;
 	}
 	etd->y_max = y_max;
 	etd->width = width;
 	return 0;
 }
 struct elantech_attr_data {
 	size_t		field_offset;
 	unsigned char	reg;
 };
 /*
  * Display a register value by reading a sysfs entry
  */
 static ssize_t elantech_show_int_attr(struct psmouse *psmouse, void *data,
 					char *buf)
 {
 	struct elantech_data *etd = psmouse->private;
 	struct elantech_attr_data *attr = data;
 	unsigned char *reg = (unsigned char *) etd + attr->field_offset;
 	int rc = 0;
 	if (attr->reg)
 		rc = elantech_read_reg(psmouse, attr->reg, reg);
 	return sprintf(buf, "0x%02x\n", (attr->reg && rc) ? -1 : *reg);
 }
 /*
  * Write a register value by writing a sysfs entry
  */
 static ssize_t elantech_set_int_attr(struct psmouse *psmouse,
 				     void *data, const char *buf, size_t count)
 {
 	struct elantech_data *etd = psmouse->private;
 	struct elantech_attr_data *attr = data;
 	unsigned char *reg = (unsigned char *) etd + attr->field_offset;
 	unsigned char value;
 	int err;
 	err = kstrtou8(buf, 16, &value);
 	if (err)
 		return err;
 	/* Do we need to preserve some bits for version 2 hardware too? */
 	if (etd->hw_version == 1) {
 		if (attr->reg == 0x10)
 			/* Force absolute mode always on */
 			value |= ETP_R10_ABSOLUTE_MODE;
 		else if (attr->reg == 0x11)
 			/* Force 4 byte mode always on */
 			value |= ETP_R11_4_BYTE_MODE;
 	}
 	if (!attr->reg || elantech_write_reg(psmouse, attr->reg, value) == 0)
 		*reg = value;
 	return count;
 }
 #define ELANTECH_INT_ATTR(_name, _register)				\
 	static struct elantech_attr_data elantech_attr_##_name = {	\
 		.field_offset = offsetof(struct elantech_data, _name),	\
 		.reg = _register,					\
 	};								\
 	PSMOUSE_DEFINE_ATTR(_name, S_IWUSR | S_IRUGO,			\
 			    &elantech_attr_##_name,			\
 			    elantech_show_int_attr,			\
 			    elantech_set_int_attr)
 ELANTECH_INT_ATTR(reg_07, 0x07);
 ELANTECH_INT_ATTR(reg_10, 0x10);
 ELANTECH_INT_ATTR(reg_11, 0x11);
 ELANTECH_INT_ATTR(reg_20, 0x20);
 ELANTECH_INT_ATTR(reg_21, 0x21);
 ELANTECH_INT_ATTR(reg_22, 0x22);
 ELANTECH_INT_ATTR(reg_23, 0x23);
 ELANTECH_INT_ATTR(reg_24, 0x24);
 ELANTECH_INT_ATTR(reg_25, 0x25);
 ELANTECH_INT_ATTR(reg_26, 0x26);
 ELANTECH_INT_ATTR(debug, 0);
 ELANTECH_INT_ATTR(paritycheck, 0);
+ELANTECH_INT_ATTR(crc_enabled, 0);
 static struct attribute *elantech_attrs[] = {
 	&psmouse_attr_reg_07.dattr.attr,
 	&psmouse_attr_reg_10.dattr.attr,
 	&psmouse_attr_reg_11.dattr.attr,
 	&psmouse_attr_reg_20.dattr.attr,
 	&psmouse_attr_reg_21.dattr.attr,
 	&psmouse_attr_reg_22.dattr.attr,
 	&psmouse_attr_reg_23.dattr.attr,
 	&psmouse_attr_reg_24.dattr.attr,
 	&psmouse_attr_reg_25.dattr.attr,
 	&psmouse_attr_reg_26.dattr.attr,
 	&psmouse_attr_debug.dattr.attr,
 	&psmouse_attr_paritycheck.dattr.attr,
+	&psmouse_attr_crc_enabled.dattr.attr,
 	NULL
 };
 static struct attribute_group elantech_attr_group = {
 	.attrs = elantech_attrs,
 };
 static bool elantech_is_signature_valid(const unsigned char *param)
 {
 	static const unsigned char rates[] = { 200, 100, 80, 60, 40, 20, 10 };
 	int i;
 	if (param[0] == 0)
 		return false;
 	if (param[1] == 0)
 		return true;
 	/*
 	 * Some models have a revision higher then 20. Meaning param[2] may
 	 * be 10 or 20, skip the rates check for these.
 	 */
 	if (param[0] == 0x46 && (param[1] & 0xef) == 0x0f && param[2] < 40)
 		return true;
 	for (i = 0; i < ARRAY_SIZE(rates); i++)
 		if (param[2] == rates[i])
 			return false;
 	return true;
 }
 /*
  * Use magic knock to detect Elantech touchpad
  */
 int elantech_detect(struct psmouse *psmouse, bool set_properties)
 {
 	struct ps2dev *ps2dev = &psmouse->ps2dev;
 	unsigned char param[3];
 	ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS);
 	if (ps2_command(ps2dev,  NULL, PSMOUSE_CMD_DISABLE) ||
 	    ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE11) ||
 	    ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE11) ||
 	    ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE11) ||
 	    ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) {
 		psmouse_dbg(psmouse, "sending Elantech magic knock failed.\n");
 		return -1;
 	}
 	/*
 	 * Report this in case there are Elantech models that use a different
 	 * set of magic numbers
 	 */
 	if (param[0] != 0x3c || param[1] != 0x03 ||
 	    (param[2] != 0xc8 && param[2] != 0x00)) {
 		psmouse_dbg(psmouse,
 			    "unexpected magic knock result 0x%02x, 0x%02x, 0x%02x.\n",
 			    param[0], param[1], param[2]);
 		return -1;
 	}
 	/*
 	 * Query touchpad's firmware version and see if it reports known
 	 * value to avoid mis-detection. Logitech mice are known to respond
 	 * to Elantech magic knock and there might be more.
 	 */
 	if (synaptics_send_cmd(psmouse, ETP_FW_VERSION_QUERY, param)) {
 		psmouse_dbg(psmouse, "failed to query firmware version.\n");
 		return -1;
 	}
 	psmouse_dbg(psmouse,
 		    "Elantech version query result 0x%02x, 0x%02x, 0x%02x.\n",
 		    param[0], param[1], param[2]);
 	if (!elantech_is_signature_valid(param)) {
 		psmouse_dbg(psmouse,
 			    "Probably not a real Elantech touchpad. Aborting.\n");
 		return -1;
 	}
 	if (set_properties) {
 		psmouse->vendor = "Elantech";
 		psmouse->name = "Touchpad";
 	}
 	return 0;
 }
 /*
  * Clean up sysfs entries when disconnecting
  */
 static void elantech_disconnect(struct psmouse *psmouse)
 {
 	struct elantech_data *etd = psmouse->private;
 	if (etd->tp_dev)
 		input_unregister_device(etd->tp_dev);
 	sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj,
 			   &elantech_attr_group);
 	kfree(psmouse->private);
 	psmouse->private = NULL;
 }
 /*
  * Put the touchpad back into absolute mode when reconnecting
  */
 static int elantech_reconnect(struct psmouse *psmouse)
 {
 	psmouse_reset(psmouse);
 	if (elantech_detect(psmouse, 0))
 		return -1;
 	if (elantech_set_absolute_mode(psmouse)) {
 		psmouse_err(psmouse,
 			    "failed to put touchpad back into absolute mode.\n");
 		return -1;
 	}
 	return 0;
 }
 /*
+ * Some hw_version 4 models do not work with crc_disabled
+ */
+static const struct dmi_system_id elantech_dmi_force_crc_enabled[] = {
+#if defined(CONFIG_DMI) && defined(CONFIG_X86)
+	{
+		/* Fujitsu H730 does not work with crc_enabled == 0 */
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "CELSIUS H730"),
+		},
+	},
+#endif
+	{ }
+};
+/*
  * Some hw_version 3 models go into error state when we try to set
  * bit 3 and/or bit 1 of r10.
  */
 static const struct dmi_system_id no_hw_res_dmi_table[] = {
 #if defined(CONFIG_DMI) && defined(CONFIG_X86)
 	{
 		/* Gigabyte U2442 */
 		.matches = {
 			DMI_MATCH(DMI_SYS_VENDOR, "GIGABYTE"),
 			DMI_MATCH(DMI_PRODUCT_NAME, "U2442"),
 		},
 	},
 #endif
 	{ }
 };
 /*
  * determine hardware version and set some properties according to it.
  */
 static int elantech_set_properties(struct elantech_data *etd)
 {
 	/* This represents the version of IC body. */
 	int ver = (etd->fw_version & 0x0f0000) >> 16;
 	/* Early version of Elan touchpads doesn't obey the rule. */
 	if (etd->fw_version < 0x020030 || etd->fw_version == 0x020600)
 		etd->hw_version = 1;
 	else {
 		switch (ver) {
 		case 2:
 		case 4:
 			etd->hw_version = 2;
 			break;
 		case 5:
 			etd->hw_version = 3;
 			break;
 		case 6:
 		case 7:
 		case 8:
 		case 9:
 			etd->hw_version = 4;
 			break;
 		default:
 			return -1;
 		}
 	}
 	/* decide which send_cmd we're gonna use early */
 	etd->send_cmd = etd->hw_version >= 3 ? elantech_send_cmd :
 					       synaptics_send_cmd;
 	/* Turn on packet checking by default */
 	etd->paritycheck = 1;
 	/*
 	 * This firmware suffers from misreporting coordinates when
 	 * a touch action starts causing the mouse cursor or scrolled page
 	 * to jump. Enable a workaround.
 	 */
 	etd->jumpy_cursor =
 		(etd->fw_version == 0x020022 || etd->fw_version == 0x020600);
 	if (etd->hw_version > 1) {
 		/* For now show extra debug information */
 		etd->debug = 1;
 		if (etd->fw_version >= 0x020800)
 			etd->reports_pressure = true;
 	}
 	/*
 	 * The signatures of v3 and v4 packets change depending on the
 	 * value of this hardware flag.
 	 */
-	etd->crc_enabled = ((etd->fw_version & 0x4000) == 0x4000);
+	etd->crc_enabled = (etd->fw_version & 0x4000) == 0x4000 ||
+			   dmi_check_system(elantech_dmi_force_crc_enabled);
 	/* Enable real hardware resolution on hw_version 3 ? */
 	etd->set_hw_resolution = !dmi_check_system(no_hw_res_dmi_table);
 	return 0;
 }
 /*
  * Initialize the touchpad and create sysfs entries
  */
 int elantech_init(struct psmouse *psmouse)
 {
 	struct elantech_data *etd;
 	int i;
 	int error = -EINVAL;
 	unsigned char param[3];
 	struct input_dev *tp_dev;
 	psmouse->private = etd = kzalloc(sizeof(struct elantech_data), GFP_KERNEL);
 	if (!etd)
 		return -ENOMEM;
 	psmouse_reset(psmouse);
 	etd->parity[0] = 1;
 	for (i = 1; i < 256; i++)
 		etd->parity[i] = etd->parity[i & (i - 1)] ^ 1;
 	/*
 	 * Do the version query again so we can store the result
 	 */
 	if (synaptics_send_cmd(psmouse, ETP_FW_VERSION_QUERY, param)) {
 		psmouse_err(psmouse, "failed to query firmware version.\n");
 		goto init_fail;
 	}
 	etd->fw_version = (param[0] << 16) | (param[1] << 8) | param[2];
 	if (elantech_set_properties(etd)) {
 		psmouse_err(psmouse, "unknown hardware version, aborting...\n");
 		goto init_fail;
 	}
 	psmouse_info(psmouse,
 		     "assuming hardware version %d (with firmware version 0x%02x%02x%02x)\n",
 		     etd->hw_version, param[0], param[1], param[2]);
 	if (etd->send_cmd(psmouse, ETP_CAPABILITIES_QUERY,
 	    etd->capabilities)) {
 		psmouse_err(psmouse, "failed to query capabilities.\n");
 		goto init_fail;
 	}
 	psmouse_info(psmouse,
 		     "Synaptics capabilities query result 0x%02x, 0x%02x, 0x%02x.\n",
 		     etd->capabilities[0], etd->capabilities[1],
 		     etd->capabilities[2]);
 	if (elantech_set_absolute_mode(psmouse)) {
 		psmouse_err(psmouse,
 			    "failed to put touchpad into absolute mode.\n");
 		goto init_fail;
 	}
 	if (elantech_set_input_params(psmouse)) {
 		psmouse_err(psmouse, "failed to query touchpad range.\n");
 		goto init_fail;
 	}
 	error = sysfs_create_group(&psmouse->ps2dev.serio->dev.kobj,
 				   &elantech_attr_group);
 	if (error) {
 		psmouse_err(psmouse,
 			    "failed to create sysfs attributes, error: %d.\n",
 			    error);
 		goto init_fail;
 	}
 	/* The MSB indicates the presence of the trackpoint */
 	if ((etd->capabilities[0] & 0x80) == 0x80) {
 		tp_dev = input_allocate_device();
 		if (!tp_dev) {
 			error = -ENOMEM;
 			goto init_fail_tp_alloc;
 		}
 		etd->tp_dev = tp_dev;
 		snprintf(etd->tp_phys, sizeof(etd->tp_phys), "%s/input1",
 			psmouse->ps2dev.serio->phys);
 		tp_dev->phys = etd->tp_phys;
 		tp_dev->name = "Elantech PS/2 TrackPoint";
 		tp_dev->id.bustype = BUS_I8042;
 		tp_dev->id.vendor  = 0x0002;
 		tp_dev->id.product = PSMOUSE_ELANTECH;
 		tp_dev->id.version = 0x0000;
 		tp_dev->dev.parent = &psmouse->ps2dev.serio->dev;
 		tp_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
 		tp_dev->relbit[BIT_WORD(REL_X)] =
 			BIT_MASK(REL_X) | BIT_MASK(REL_Y);
 		tp_dev->keybit[BIT_WORD(BTN_LEFT)] =
 			BIT_MASK(BTN_LEFT) | BIT_MASK(BTN_MIDDLE) |
 			BIT_MASK(BTN_RIGHT);
 		__set_bit(INPUT_PROP_POINTER, tp_dev->propbit);
 		__set_bit(INPUT_PROP_POINTING_STICK, tp_dev->propbit);
 		error = input_register_device(etd->tp_dev);
 		if (error < 0)
 			goto init_fail_tp_reg;
 	}
 	psmouse->protocol_handler = elantech_process_byte;
 	psmouse->disconnect = elantech_disconnect;
 	psmouse->reconnect = elantech_reconnect;
 	psmouse->pktsize = etd->hw_version > 1 ? 6 : 4;
 	return 0;
  init_fail_tp_reg:
 	input_free_device(tp_dev);
  init_fail_tp_alloc:
 	sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj,
 			   &elantech_attr_group);
  init_fail:
 	psmouse_reset(psmouse);
 	kfree(etd);
 	return error;
 }

drivers/input/mouse/synaptics.c

Diff comments View file @ 56c381f

 /*
  * Synaptics TouchPad PS/2 mouse driver
  *
  *   2003 Dmitry Torokhov <dtor@mail.ru>
  *     Added support for pass-through port. Special thanks to Peter Berg Larsen
  *     for explaining various Synaptics quirks.
  *
  *   2003 Peter Osterlund <petero2@telia.com>
  *     Ported to 2.5 input device infrastructure.
  *
  *   Copyright (C) 2001 Stefan Gmeiner <riddlebox@freesurf.ch>
  *     start merging tpconfig and gpm code to a xfree-input module
  *     adding some changes and extensions (ex. 3rd and 4th button)
  *
  *   Copyright (c) 1997 C. Scott Ananian <cananian@alumni.priceton.edu>
  *   Copyright (c) 1998-2000 Bruce Kalk <kall@compass.com>
  *     code for the special synaptics commands (from the tpconfig-source)
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 as published by
  * the Free Software Foundation.
  *
  * Trademarks are the property of their respective owners.
  */
 #include <linux/module.h>
 #include <linux/delay.h>
 #include <linux/dmi.h>
 #include <linux/input/mt.h>
 #include <linux/serio.h>
 #include <linux/libps2.h>
 #include <linux/slab.h>
 #include "psmouse.h"
 #include "synaptics.h"
 /*
  * The x/y limits are taken from the Synaptics TouchPad interfacing Guide,
  * section 2.3.2, which says that they should be valid regardless of the
  * actual size of the sensor.
  * Note that newer firmware allows querying device for maximum useable
  * coordinates.
  */
 #define XMIN 0
 #define XMAX 6143
 #define YMIN 0
 #define YMAX 6143
 #define XMIN_NOMINAL 1472
 #define XMAX_NOMINAL 5472
 #define YMIN_NOMINAL 1408
 #define YMAX_NOMINAL 4448
 /* Size in bits of absolute position values reported by the hardware */
 #define ABS_POS_BITS 13
 /*
  * These values should represent the absolute maximum value that will
  * be reported for a positive position value. Some Synaptics firmware
  * uses this value to indicate a finger near the edge of the touchpad
  * whose precise position cannot be determined.
  *
  * At least one touchpad is known to report positions in excess of this
  * value which are actually negative values truncated to the 13-bit
  * reporting range. These values have never been observed to be lower
  * than 8184 (i.e. -8), so we treat all values greater than 8176 as
  * negative and any other value as positive.
  */
 #define X_MAX_POSITIVE 8176
 #define Y_MAX_POSITIVE 8176
 /*****************************************************************************
  *	Stuff we need even when we do not want native Synaptics support
  ****************************************************************************/
 /*
  * Set the synaptics touchpad mode byte by special commands
  */
 static int synaptics_mode_cmd(struct psmouse *psmouse, unsigned char mode)
 {
 	unsigned char param[1];
 	if (psmouse_sliced_command(psmouse, mode))
 		return -1;
 	param[0] = SYN_PS_SET_MODE2;
 	if (ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_SETRATE))
 		return -1;
 	return 0;
 }
 int synaptics_detect(struct psmouse *psmouse, bool set_properties)
 {
 	struct ps2dev *ps2dev = &psmouse->ps2dev;
 	unsigned char param[4];
 	param[0] = 0;
 	ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
 	ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
 	ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
 	ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES);
 	ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO);
 	if (param[1] != 0x47)
 		return -ENODEV;
 	if (set_properties) {
 		psmouse->vendor = "Synaptics";
 		psmouse->name = "TouchPad";
 	}
 	return 0;
 }
 void synaptics_reset(struct psmouse *psmouse)
 {
 	/* reset touchpad back to relative mode, gestures enabled */
 	synaptics_mode_cmd(psmouse, 0);
 }
 #ifdef CONFIG_MOUSE_PS2_SYNAPTICS
 static bool cr48_profile_sensor;
 struct min_max_quirk {
 	const char * const *pnp_ids;
 	int x_min, x_max, y_min, y_max;
 };
 static const struct min_max_quirk min_max_pnpid_table[] = {
 	{
 		(const char * const []){"LEN0033", NULL},
 		1024, 5052, 2258, 4832
 	},
 	{
 		(const char * const []){"LEN0035", "LEN0042", NULL},
 		1232, 5710, 1156, 4696
 	},
 	{
-		(const char * const []){"LEN0034", "LEN0036", "LEN2002",
+		(const char * const []){"LEN0034", "LEN0036", "LEN0039",
-					"LEN2004", NULL},
+					"LEN2002", "LEN2004", NULL},
 		1024, 5112, 2024, 4832
 	},
 	{
 		(const char * const []){"LEN2001", NULL},
 		1024, 5022, 2508, 4832
 	},
 	{ }
 };
 /* This list has been kindly provided by Synaptics. */
 static const char * const topbuttonpad_pnp_ids[] = {
 	"LEN0017",
 	"LEN0018",
 	"LEN0019",
 	"LEN0023",
 	"LEN002A",
 	"LEN002B",
 	"LEN002C",
 	"LEN002D",
 	"LEN002E",
 	"LEN0033", /* Helix */
 	"LEN0034", /* T431s, L440, L540, T540, W540, X1 Carbon 2nd */
 	"LEN0035", /* X240 */
 	"LEN0036", /* T440 */
 	"LEN0037",
 	"LEN0038",
+	"LEN0039", /* T440s */
 	"LEN0041",
 	"LEN0042", /* Yoga */
 	"LEN0045",
 	"LEN0046",
 	"LEN0047",
 	"LEN0048",
 	"LEN0049",
 	"LEN2000",
 	"LEN2001", /* Edge E431 */
 	"LEN2002", /* Edge E531 */
 	"LEN2003",
 	"LEN2004", /* L440 */
 	"LEN2005",
 	"LEN2006",
 	"LEN2007",
 	"LEN2008",
 	"LEN2009",
 	"LEN200A",
 	"LEN200B",
 	NULL
 };
 /*****************************************************************************
  *	Synaptics communications functions
  ****************************************************************************/
 /*
  * Synaptics touchpads report the y coordinate from bottom to top, which is
  * opposite from what userspace expects.
  * This function is used to invert y before reporting.
  */
 static int synaptics_invert_y(int y)
 {
 	return YMAX_NOMINAL + YMIN_NOMINAL - y;
 }
 /*
  * Send a command to the synpatics touchpad by special commands
  */
 static int synaptics_send_cmd(struct psmouse *psmouse, unsigned char c, unsigned char *param)
 {
 	if (psmouse_sliced_command(psmouse, c))
 		return -1;
 	if (ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO))
 		return -1;
 	return 0;
 }
 /*
  * Read the model-id bytes from the touchpad
  * see also SYN_MODEL_* macros
  */
 static int synaptics_model_id(struct psmouse *psmouse)
 {
 	struct synaptics_data *priv = psmouse->private;
 	unsigned char mi[3];
 	if (synaptics_send_cmd(psmouse, SYN_QUE_MODEL, mi))
 		return -1;
 	priv->model_id = (mi[0]<<16) | (mi[1]<<8) | mi[2];
 	return 0;
 }
 /*
  * Read the board id from the touchpad
  * The board id is encoded in the "QUERY MODES" response
  */
 static int synaptics_board_id(struct psmouse *psmouse)
 {
 	struct synaptics_data *priv = psmouse->private;
 	unsigned char bid[3];
 	if (synaptics_send_cmd(psmouse, SYN_QUE_MODES, bid))
 		return -1;
 	priv->board_id = ((bid[0] & 0xfc) << 6) | bid[1];
 	return 0;
 }
 /*
  * Read the firmware id from the touchpad
  */
 static int synaptics_firmware_id(struct psmouse *psmouse)
 {
 	struct synaptics_data *priv = psmouse->private;
 	unsigned char fwid[3];
 	if (synaptics_send_cmd(psmouse, SYN_QUE_FIRMWARE_ID, fwid))
 		return -1;
 	priv->firmware_id = (fwid[0] << 16) | (fwid[1] << 8) | fwid[2];
 	return 0;
 }
 /*
  * Read the capability-bits from the touchpad
  * see also the SYN_CAP_* macros
  */
 static int synaptics_capability(struct psmouse *psmouse)
 {
 	struct synaptics_data *priv = psmouse->private;
 	unsigned char cap[3];
 	if (synaptics_send_cmd(psmouse, SYN_QUE_CAPABILITIES, cap))
 		return -1;
 	priv->capabilities = (cap[0] << 16) | (cap[1] << 8) | cap[2];
 	priv->ext_cap = priv->ext_cap_0c = 0;
 	/*
 	 * Older firmwares had submodel ID fixed to 0x47
 	 */
 	if (SYN_ID_FULL(priv->identity) < 0x705 &&
 	    SYN_CAP_SUBMODEL_ID(priv->capabilities) != 0x47) {
 		return -1;
 	}
 	/*
 	 * Unless capExtended is set the rest of the flags should be ignored
 	 */
 	if (!SYN_CAP_EXTENDED(priv->capabilities))
 		priv->capabilities = 0;
 	if (SYN_EXT_CAP_REQUESTS(priv->capabilities) >= 1) {
 		if (synaptics_send_cmd(psmouse, SYN_QUE_EXT_CAPAB, cap)) {
 			psmouse_warn(psmouse,
 				     "device claims to have extended capabilities, but I'm not able to read them.\n");
 		} else {
 			priv->ext_cap = (cap[0] << 16) | (cap[1] << 8) | cap[2];
 			/*
 			 * if nExtBtn is greater than 8 it should be considered
 			 * invalid and treated as 0
 			 */
 			if (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap) > 8)
 				priv->ext_cap &= 0xff0fff;
 		}
 	}
 	if (SYN_EXT_CAP_REQUESTS(priv->capabilities) >= 4) {
 		if (synaptics_send_cmd(psmouse, SYN_QUE_EXT_CAPAB_0C, cap)) {
 			psmouse_warn(psmouse,
 				     "device claims to have extended capability 0x0c, but I'm not able to read it.\n");
 		} else {
 			priv->ext_cap_0c = (cap[0] << 16) | (cap[1] << 8) | cap[2];
 		}
 	}
 	return 0;
 }
 /*
  * Identify Touchpad
  * See also the SYN_ID_* macros
  */
 static int synaptics_identify(struct psmouse *psmouse)
 {
 	struct synaptics_data *priv = psmouse->private;
 	unsigned char id[3];
 	if (synaptics_send_cmd(psmouse, SYN_QUE_IDENTIFY, id))
 		return -1;
 	priv->identity = (id[0]<<16) | (id[1]<<8) | id[2];
 	if (SYN_ID_IS_SYNAPTICS(priv->identity))
 		return 0;
 	return -1;
 }
 /*
  * Read touchpad resolution and maximum reported coordinates
  * Resolution is left zero if touchpad does not support the query
  */
 static int synaptics_resolution(struct psmouse *psmouse)
 {
 	struct synaptics_data *priv = psmouse->private;
 	unsigned char resp[3];
 	int i;
 	if (SYN_ID_MAJOR(priv->identity) < 4)
 		return 0;
 	if (synaptics_send_cmd(psmouse, SYN_QUE_RESOLUTION, resp) == 0) {
 		if (resp[0] != 0 && (resp[1] & 0x80) && resp[2] != 0) {
 			priv->x_res = resp[0]; /* x resolution in units/mm */
 			priv->y_res = resp[2]; /* y resolution in units/mm */
 		}
 	}
 	for (i = 0; min_max_pnpid_table[i].pnp_ids; i++) {
 		if (psmouse_matches_pnp_id(psmouse,
 					   min_max_pnpid_table[i].pnp_ids)) {
 			priv->x_min = min_max_pnpid_table[i].x_min;
 			priv->x_max = min_max_pnpid_table[i].x_max;
 			priv->y_min = min_max_pnpid_table[i].y_min;
 			priv->y_max = min_max_pnpid_table[i].y_max;
 			return 0;
 		}
 	}
 	if (SYN_EXT_CAP_REQUESTS(priv->capabilities) >= 5 &&
 	    SYN_CAP_MAX_DIMENSIONS(priv->ext_cap_0c)) {
 		if (synaptics_send_cmd(psmouse, SYN_QUE_EXT_MAX_COORDS, resp)) {
 			psmouse_warn(psmouse,
 				     "device claims to have max coordinates query, but I'm not able to read it.\n");
 		} else {
 			priv->x_max = (resp[0] << 5) | ((resp[1] & 0x0f) << 1);
 			priv->y_max = (resp[2] << 5) | ((resp[1] & 0xf0) >> 3);
 		}
 	}
 	if (SYN_EXT_CAP_REQUESTS(priv->capabilities) >= 7 &&
 	    SYN_CAP_MIN_DIMENSIONS(priv->ext_cap_0c)) {
 		if (synaptics_send_cmd(psmouse, SYN_QUE_EXT_MIN_COORDS, resp)) {
 			psmouse_warn(psmouse,
 				     "device claims to have min coordinates query, but I'm not able to read it.\n");
 		} else {
 			priv->x_min = (resp[0] << 5) | ((resp[1] & 0x0f) << 1);
 			priv->y_min = (resp[2] << 5) | ((resp[1] & 0xf0) >> 3);
 		}
 	}
 	return 0;
 }
 static int synaptics_query_hardware(struct psmouse *psmouse)
 {
 	if (synaptics_identify(psmouse))
 		return -1;
 	if (synaptics_model_id(psmouse))
 		return -1;
 	if (synaptics_firmware_id(psmouse))
 		return -1;
 	if (synaptics_board_id(psmouse))
 		return -1;
 	if (synaptics_capability(psmouse))
 		return -1;
 	if (synaptics_resolution(psmouse))
 		return -1;
 	return 0;
 }
 static int synaptics_set_advanced_gesture_mode(struct psmouse *psmouse)
 {
 	static unsigned char param = 0xc8;
 	struct synaptics_data *priv = psmouse->private;
 	if (!(SYN_CAP_ADV_GESTURE(priv->ext_cap_0c) ||
 	      SYN_CAP_IMAGE_SENSOR(priv->ext_cap_0c)))
 		return 0;
 	if (psmouse_sliced_command(psmouse, SYN_QUE_MODEL))
 		return -1;
 	if (ps2_command(&psmouse->ps2dev, &param, PSMOUSE_CMD_SETRATE))
 		return -1;
 	/* Advanced gesture mode also sends multi finger data */
 	priv->capabilities |= BIT(1);
 	return 0;
 }
 static int synaptics_set_mode(struct psmouse *psmouse)
 {
 	struct synaptics_data *priv = psmouse->private;
 	priv->mode = 0;
 	if (priv->absolute_mode)
 		priv->mode |= SYN_BIT_ABSOLUTE_MODE;
 	if (priv->disable_gesture)
 		priv->mode |= SYN_BIT_DISABLE_GESTURE;
 	if (psmouse->rate >= 80)
 		priv->mode |= SYN_BIT_HIGH_RATE;
 	if (SYN_CAP_EXTENDED(priv->capabilities))
 		priv->mode |= SYN_BIT_W_MODE;
 	if (synaptics_mode_cmd(psmouse, priv->mode))
 		return -1;
 	if (priv->absolute_mode &&
 	    synaptics_set_advanced_gesture_mode(psmouse)) {
 		psmouse_err(psmouse, "Advanced gesture mode init failed.\n");
 		return -1;
 	}
 	return 0;
 }
 static void synaptics_set_rate(struct psmouse *psmouse, unsigned int rate)
 {
 	struct synaptics_data *priv = psmouse->private;
 	if (rate >= 80) {
 		priv->mode |= SYN_BIT_HIGH_RATE;
 		psmouse->rate = 80;
 	} else {
 		priv->mode &= ~SYN_BIT_HIGH_RATE;
 		psmouse->rate = 40;
 	}
 	synaptics_mode_cmd(psmouse, priv->mode);
 }
 /*****************************************************************************
  *	Synaptics pass-through PS/2 port support
  ****************************************************************************/
 static int synaptics_pt_write(struct serio *serio, unsigned char c)
 {
 	struct psmouse *parent = serio_get_drvdata(serio->parent);
 	char rate_param = SYN_PS_CLIENT_CMD; /* indicates that we want pass-through port */
 	if (psmouse_sliced_command(parent, c))
 		return -1;
 	if (ps2_command(&parent->ps2dev, &rate_param, PSMOUSE_CMD_SETRATE))
 		return -1;
 	return 0;
 }
 static int synaptics_pt_start(struct serio *serio)
 {
 	struct psmouse *parent = serio_get_drvdata(serio->parent);
 	struct synaptics_data *priv = parent->private;
 	serio_pause_rx(parent->ps2dev.serio);
 	priv->pt_port = serio;
 	serio_continue_rx(parent->ps2dev.serio);
 	return 0;
 }
 static void synaptics_pt_stop(struct serio *serio)
 {
 	struct psmouse *parent = serio_get_drvdata(serio->parent);
 	struct synaptics_data *priv = parent->private;
 	serio_pause_rx(parent->ps2dev.serio);
 	priv->pt_port = NULL;
 	serio_continue_rx(parent->ps2dev.serio);
 }
 static int synaptics_is_pt_packet(unsigned char *buf)
 {
 	return (buf[0] & 0xFC) == 0x84 && (buf[3] & 0xCC) == 0xC4;
 }
 static void synaptics_pass_pt_packet(struct serio *ptport, unsigned char *packet)
 {
 	struct psmouse *child = serio_get_drvdata(ptport);
 	if (child && child->state == PSMOUSE_ACTIVATED) {
 		serio_interrupt(ptport, packet[1], 0);
 		serio_interrupt(ptport, packet[4], 0);
 		serio_interrupt(ptport, packet[5], 0);
 		if (child->pktsize == 4)
 			serio_interrupt(ptport, packet[2], 0);
 	} else
 		serio_interrupt(ptport, packet[1], 0);
 }
 static void synaptics_pt_activate(struct psmouse *psmouse)
 {
 	struct synaptics_data *priv = psmouse->private;
 	struct psmouse *child = serio_get_drvdata(priv->pt_port);
 	/* adjust the touchpad to child's choice of protocol */
 	if (child) {
 		if (child->pktsize == 4)
 			priv->mode |= SYN_BIT_FOUR_BYTE_CLIENT;
 		else
 			priv->mode &= ~SYN_BIT_FOUR_BYTE_CLIENT;
 		if (synaptics_mode_cmd(psmouse, priv->mode))
 			psmouse_warn(psmouse,
 				     "failed to switch guest protocol\n");
 	}
 }
 static void synaptics_pt_create(struct psmouse *psmouse)
 {
 	struct serio *serio;
 	serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
 	if (!serio) {
 		psmouse_err(psmouse,
 			    "not enough memory for pass-through port\n");
 		return;
 	}
 	serio->id.type = SERIO_PS_PSTHRU;
 	strlcpy(serio->name, "Synaptics pass-through", sizeof(serio->name));
 	strlcpy(serio->phys, "synaptics-pt/serio0", sizeof(serio->name));
 	serio->write = synaptics_pt_write;
 	serio->start = synaptics_pt_start;
 	serio->stop = synaptics_pt_stop;
 	serio->parent = psmouse->ps2dev.serio;
 	psmouse->pt_activate = synaptics_pt_activate;
 	psmouse_info(psmouse, "serio: %s port at %s\n",
 		     serio->name, psmouse->phys);
 	serio_register_port(serio);
 }
 /*****************************************************************************
  *	Functions to interpret the absolute mode packets
  ****************************************************************************/
 static void synaptics_mt_state_set(struct synaptics_mt_state *state, int count,
 				   int sgm, int agm)
 {
 	state->count = count;
 	state->sgm = sgm;
 	state->agm = agm;
 }
 static void synaptics_parse_agm(const unsigned char buf[],
 				struct synaptics_data *priv,
 				struct synaptics_hw_state *hw)
 {
 	struct synaptics_hw_state *agm = &priv->agm;
 	int agm_packet_type;
 	agm_packet_type = (buf[5] & 0x30) >> 4;
 	switch (agm_packet_type) {
 	case 1:
 		/* Gesture packet: (x, y, z) half resolution */
 		agm->w = hw->w;
 		agm->x = (((buf[4] & 0x0f) << 8) | buf[1]) << 1;
 		agm->y = (((buf[4] & 0xf0) << 4) | buf[2]) << 1;
 		agm->z = ((buf[3] & 0x30) | (buf[5] & 0x0f)) << 1;
 		break;
 	case 2:
 		/* AGM-CONTACT packet: (count, sgm, agm) */
 		synaptics_mt_state_set(&agm->mt_state, buf[1], buf[2], buf[4]);
 		break;
 	default:
 		break;
 	}
 	/* Record that at least one AGM has been received since last SGM */
 	priv->agm_pending = true;
 }
 static bool is_forcepad;
 static int synaptics_parse_hw_state(const unsigned char buf[],
 				    struct synaptics_data *priv,
 				    struct synaptics_hw_state *hw)
 {
 	memset(hw, 0, sizeof(struct synaptics_hw_state));
 	if (SYN_MODEL_NEWABS(priv->model_id)) {
 		hw->w = (((buf[0] & 0x30) >> 2) |
 			 ((buf[0] & 0x04) >> 1) |
 			 ((buf[3] & 0x04) >> 2));
 		if ((SYN_CAP_ADV_GESTURE(priv->ext_cap_0c) ||
 			SYN_CAP_IMAGE_SENSOR(priv->ext_cap_0c)) &&
 		    hw->w == 2) {
 			synaptics_parse_agm(buf, priv, hw);
 			return 1;
 		}
 		hw->x = (((buf[3] & 0x10) << 8) |
 			 ((buf[1] & 0x0f) << 8) |
 			 buf[4]);
 		hw->y = (((buf[3] & 0x20) << 7) |
 			 ((buf[1] & 0xf0) << 4) |
 			 buf[5]);
 		hw->z = buf[2];
 		hw->left  = (buf[0] & 0x01) ? 1 : 0;
 		hw->right = (buf[0] & 0x02) ? 1 : 0;
 		if (is_forcepad) {
 			/*
 			 * ForcePads, like Clickpads, use middle button
 			 * bits to report primary button clicks.
 			 * Unfortunately they report primary button not
 			 * only when user presses on the pad above certain
 			 * threshold, but also when there are more than one
 			 * finger on the touchpad, which interferes with
 			 * out multi-finger gestures.
 			 */
 			if (hw->z == 0) {
 				/* No contacts */
 				priv->press = priv->report_press = false;
 			} else if (hw->w >= 4 && ((buf[0] ^ buf[3]) & 0x01)) {
 				/*
 				 * Single-finger touch with pressure above
 				 * the threshold. If pressure stays long
 				 * enough, we'll start reporting primary
 				 * button. We rely on the device continuing
 				 * sending data even if finger does not
 				 * move.
 				 */
 				if  (!priv->press) {
 					priv->press_start = jiffies;
 					priv->press = true;
 				} else if (time_after(jiffies,
 						priv->press_start +
 							msecs_to_jiffies(50))) {
 					priv->report_press = true;
 				}
 			} else {
 				priv->press = false;
 			}
 			hw->left = priv->report_press;
 		} else if (SYN_CAP_CLICKPAD(priv->ext_cap_0c)) {
 			/*
 			 * Clickpad's button is transmitted as middle button,
 			 * however, since it is primary button, we will report
 			 * it as BTN_LEFT.
 			 */
 			hw->left = ((buf[0] ^ buf[3]) & 0x01) ? 1 : 0;
 		} else if (SYN_CAP_MIDDLE_BUTTON(priv->capabilities)) {
 			hw->middle = ((buf[0] ^ buf[3]) & 0x01) ? 1 : 0;
 			if (hw->w == 2)
 				hw->scroll = (signed char)(buf[1]);
 		}
 		if (SYN_CAP_FOUR_BUTTON(priv->capabilities)) {
 			hw->up   = ((buf[0] ^ buf[3]) & 0x01) ? 1 : 0;
 			hw->down = ((buf[0] ^ buf[3]) & 0x02) ? 1 : 0;
 		}
 		if (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap) &&
 		    ((buf[0] ^ buf[3]) & 0x02)) {
 			switch (SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap) & ~0x01) {
 			default:
 				/*
 				 * if nExtBtn is greater than 8 it should be
 				 * considered invalid and treated as 0
 				 */
 				break;
 			case 8:
 				hw->ext_buttons |= ((buf[5] & 0x08)) ? 0x80 : 0;
 				hw->ext_buttons |= ((buf[4] & 0x08)) ? 0x40 : 0;
 			case 6:
 				hw->ext_buttons |= ((buf[5] & 0x04)) ? 0x20 : 0;
 				hw->ext_buttons |= ((buf[4] & 0x04)) ? 0x10 : 0;
 			case 4:
 				hw->ext_buttons |= ((buf[5] & 0x02)) ? 0x08 : 0;
 				hw->ext_buttons |= ((buf[4] & 0x02)) ? 0x04 : 0;
 			case 2:
 				hw->ext_buttons |= ((buf[5] & 0x01)) ? 0x02 : 0;
 				hw->ext_buttons |= ((buf[4] & 0x01)) ? 0x01 : 0;
 			}
 		}
 	} else {
 		hw->x = (((buf[1] & 0x1f) << 8) | buf[2]);
 		hw->y = (((buf[4] & 0x1f) << 8) | buf[5]);
 		hw->z = (((buf[0] & 0x30) << 2) | (buf[3] & 0x3F));
 		hw->w = (((buf[1] & 0x80) >> 4) | ((buf[0] & 0x04) >> 1));
 		hw->left  = (buf[0] & 0x01) ? 1 : 0;
 		hw->right = (buf[0] & 0x02) ? 1 : 0;
 	}
 	/*
 	 * Convert wrap-around values to negative. (X|Y)_MAX_POSITIVE
 	 * is used by some firmware to indicate a finger at the edge of
 	 * the touchpad whose precise position cannot be determined, so
 	 * convert these values to the maximum axis value.
 	 */
 	if (hw->x > X_MAX_POSITIVE)
 		hw->x -= 1 << ABS_POS_BITS;
 	else if (hw->x == X_MAX_POSITIVE)
 		hw->x = XMAX;
 	if (hw->y > Y_MAX_POSITIVE)
 		hw->y -= 1 << ABS_POS_BITS;
 	else if (hw->y == Y_MAX_POSITIVE)
 		hw->y = YMAX;
 	return 0;
 }
 static void synaptics_report_semi_mt_slot(struct input_dev *dev, int slot,
 					  bool active, int x, int y)
 {
 	input_mt_slot(dev, slot);
 	input_mt_report_slot_state(dev, MT_TOOL_FINGER, active);
 	if (active) {
 		input_report_abs(dev, ABS_MT_POSITION_X, x);
 		input_report_abs(dev, ABS_MT_POSITION_Y, synaptics_invert_y(y));
 	}
 }
 static void synaptics_report_semi_mt_data(struct input_dev *dev,
 					  const struct synaptics_hw_state *a,
 					  const struct synaptics_hw_state *b,
 					  int num_fingers)
 {
 	if (num_fingers >= 2) {
 		synaptics_report_semi_mt_slot(dev, 0, true, min(a->x, b->x),
 					      min(a->y, b->y));
 		synaptics_report_semi_mt_slot(dev, 1, true, max(a->x, b->x),
 					      max(a->y, b->y));
 	} else if (num_fingers == 1) {
 		synaptics_report_semi_mt_slot(dev, 0, true, a->x, a->y);
 		synaptics_report_semi_mt_slot(dev, 1, false, 0, 0);
 	} else {
 		synaptics_report_semi_mt_slot(dev, 0, false, 0, 0);
 		synaptics_report_semi_mt_slot(dev, 1, false, 0, 0);
 	}
 }
 static void synaptics_report_buttons(struct psmouse *psmouse,
 				     const struct synaptics_hw_state *hw)
 {
 	struct input_dev *dev = psmouse->dev;
 	struct synaptics_data *priv = psmouse->private;
 	int i;
 	input_report_key(dev, BTN_LEFT, hw->left);
 	input_report_key(dev, BTN_RIGHT, hw->right);
 	if (SYN_CAP_MIDDLE_BUTTON(priv->capabilities))
 		input_report_key(dev, BTN_MIDDLE, hw->middle);
 	if (SYN_CAP_FOUR_BUTTON(priv->capabilities)) {
 		input_report_key(dev, BTN_FORWARD, hw->up);
 		input_report_key(dev, BTN_BACK, hw->down);
 	}
 	for (i = 0; i < SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap); i++)
 		input_report_key(dev, BTN_0 + i, hw->ext_buttons & (1 << i));
 }
 static void synaptics_report_slot(struct input_dev *dev, int slot,
 				  const struct synaptics_hw_state *hw)
 {
 	input_mt_slot(dev, slot);
 	input_mt_report_slot_state(dev, MT_TOOL_FINGER, (hw != NULL));
 	if (!hw)
 		return;
 	input_report_abs(dev, ABS_MT_POSITION_X, hw->x);
 	input_report_abs(dev, ABS_MT_POSITION_Y, synaptics_invert_y(hw->y));
 	input_report_abs(dev, ABS_MT_PRESSURE, hw->z);
 }
 static void synaptics_report_mt_data(struct psmouse *psmouse,
 				     struct synaptics_mt_state *mt_state,
 				     const struct synaptics_hw_state *sgm)
 {
 	struct input_dev *dev = psmouse->dev;
 	struct synaptics_data *priv = psmouse->private;
 	struct synaptics_hw_state *agm = &priv->agm;
 	struct synaptics_mt_state *old = &priv->mt_state;
 	switch (mt_state->count) {
 	case 0:
 		synaptics_report_slot(dev, 0, NULL);
 		synaptics_report_slot(dev, 1, NULL);
 		break;
 	case 1:
 		if (mt_state->sgm == -1) {
 			synaptics_report_slot(dev, 0, NULL);
 			synaptics_report_slot(dev, 1, NULL);
 		} else if (mt_state->sgm == 0) {
 			synaptics_report_slot(dev, 0, sgm);
 			synaptics_report_slot(dev, 1, NULL);
 		} else {
 			synaptics_report_slot(dev, 0, NULL);
 			synaptics_report_slot(dev, 1, sgm);
 		}
 		break;
 	default:
 		/*
 		 * If the finger slot contained in SGM is valid, and either
 		 * hasn't changed, or is new, or the old SGM has now moved to
 		 * AGM, then report SGM in MTB slot 0.
 		 * Otherwise, empty MTB slot 0.
 		 */
 		if (mt_state->sgm != -1 &&
 		    (mt_state->sgm == old->sgm ||
 		     old->sgm == -1 || mt_state->agm == old->sgm))
 			synaptics_report_slot(dev, 0, sgm);
 		else
 			synaptics_report_slot(dev, 0, NULL);
 		/*
 		 * If the finger slot contained in AGM is valid, and either
 		 * hasn't changed, or is new, then report AGM in MTB slot 1.
 		 * Otherwise, empty MTB slot 1.
 		 *
 		 * However, in the case where the AGM is new, make sure that
 		 * that it is either the same as the old SGM, or there was no
 		 * SGM.
 		 *
 		 * Otherwise, if the SGM was just 1, and the new AGM is 2, then
 		 * the new AGM will keep the old SGM's tracking ID, which can
 		 * cause apparent drumroll.  This happens if in the following
 		 * valid finger sequence:
 		 *
 		 *  Action                 SGM  AGM (MTB slot:Contact)
 		 *  1. Touch contact 0    (0:0)
 		 *  2. Touch contact 1    (0:0, 1:1)
 		 *  3. Lift  contact 0    (1:1)
 		 *  4. Touch contacts 2,3 (0:2, 1:3)
 		 *
 		 * In step 4, contact 3, in AGM must not be given the same
 		 * tracking ID as contact 1 had in step 3.  To avoid this,
 		 * the first agm with contact 3 is dropped and slot 1 is
 		 * invalidated (tracking ID = -1).
 		 */
 		if (mt_state->agm != -1 &&
 		    (mt_state->agm == old->agm ||
 		     (old->agm == -1 &&
 		      (old->sgm == -1 || mt_state->agm == old->sgm))))
 			synaptics_report_slot(dev, 1, agm);
 		else
 			synaptics_report_slot(dev, 1, NULL);
 		break;
 	}
 	/* Don't use active slot count to generate BTN_TOOL events. */
 	input_mt_report_pointer_emulation(dev, false);
 	/* Send the number of fingers reported by touchpad itself. */
 	input_mt_report_finger_count(dev, mt_state->count);
 	synaptics_report_buttons(psmouse, sgm);
 	input_sync(dev);
 }
 /* Handle case where mt_state->count = 0 */
 static void synaptics_image_sensor_0f(struct synaptics_data *priv,
 				      struct synaptics_mt_state *mt_state)
 {
 	synaptics_mt_state_set(mt_state, 0, -1, -1);
 	priv->mt_state_lost = false;
 }
 /* Handle case where mt_state->count = 1 */
 static void synaptics_image_sensor_1f(struct synaptics_data *priv,
 				      struct synaptics_mt_state *mt_state)
 {
 	struct synaptics_hw_state *agm = &priv->agm;
 	struct synaptics_mt_state *old = &priv->mt_state;
 	/*
 	 * If the last AGM was (0,0,0), and there is only one finger left,
 	 * then we absolutely know that SGM contains slot 0, and all other
 	 * fingers have been removed.
 	 */
 	if (priv->agm_pending && agm->z == 0) {
 		synaptics_mt_state_set(mt_state, 1, 0, -1);
 		priv->mt_state_lost = false;
 		return;
 	}
 	switch (old->count) {
 	case 0:
 		synaptics_mt_state_set(mt_state, 1, 0, -1);
 		break;
 	case 1:
 		/*
 		 * If mt_state_lost, then the previous transition was 3->1,
 		 * and SGM now contains either slot 0 or 1, but we don't know
 		 * which.  So, we just assume that the SGM now contains slot 1.
 		 *
 		 * If pending AGM and either:
 		 *   (a) the previous SGM slot contains slot 0, or
 		 *   (b) there was no SGM slot
 		 * then, the SGM now contains slot 1
 		 *
 		 * Case (a) happens with very rapid "drum roll" gestures, where
 		 * slot 0 finger is lifted and a new slot 1 finger touches
 		 * within one reporting interval.
 		 *
 		 * Case (b) happens if initially two or more fingers tap
 		 * briefly, and all but one lift before the end of the first
 		 * reporting interval.
 		 *
 		 * (In both these cases, slot 0 will becomes empty, so SGM
 		 * contains slot 1 with the new finger)
 		 *
 		 * Else, if there was no previous SGM, it now contains slot 0.
 		 *
 		 * Otherwise, SGM still contains the same slot.
 		 */
 		if (priv->mt_state_lost ||
 		    (priv->agm_pending && old->sgm <= 0))
 			synaptics_mt_state_set(mt_state, 1, 1, -1);
 		else if (old->sgm == -1)
 			synaptics_mt_state_set(mt_state, 1, 0, -1);
 		break;
 	case 2:
 		/*
 		 * If mt_state_lost, we don't know which finger SGM contains.
 		 *
 		 * So, report 1 finger, but with both slots empty.
 		 * We will use slot 1 on subsequent 1->1
 		 */
 		if (priv->mt_state_lost) {
 			synaptics_mt_state_set(mt_state, 1, -1, -1);
 			break;
 		}
 		/*
 		 * Since the last AGM was NOT (0,0,0), it was the finger in
 		 * slot 0 that has been removed.
 		 * So, SGM now contains previous AGM's slot, and AGM is now
 		 * empty.
 		 */
 		synaptics_mt_state_set(mt_state, 1, old->agm, -1);
 		break;
 	case 3:
 		/*
 		 * Since last AGM was not (0,0,0), we don't know which finger
 		 * is left.
 		 *
 		 * So, report 1 finger, but with both slots empty.
 		 * We will use slot 1 on subsequent 1->1
 		 */
 		synaptics_mt_state_set(mt_state, 1, -1, -1);
 		priv->mt_state_lost = true;
 		break;
 	case 4:
 	case 5:
 		/* mt_state was updated by AGM-CONTACT packet */
 		break;
 	}
 }
 /* Handle case where mt_state->count = 2 */
 static void synaptics_image_sensor_2f(struct synaptics_data *priv,
 				      struct synaptics_mt_state *mt_state)
 {
 	struct synaptics_mt_state *old = &priv->mt_state;
 	switch (old->count) {
 	case 0:
 		synaptics_mt_state_set(mt_state, 2, 0, 1);
 		break;
 	case 1:
 		/*
 		 * If previous SGM contained slot 1 or higher, SGM now contains
 		 * slot 0 (the newly touching finger) and AGM contains SGM's
 		 * previous slot.
 		 *
 		 * Otherwise, SGM still contains slot 0 and AGM now contains
 		 * slot 1.
 		 */
 		if (old->sgm >= 1)
 			synaptics_mt_state_set(mt_state, 2, 0, old->sgm);
 		else
 			synaptics_mt_state_set(mt_state, 2, 0, 1);
 		break;
 	case 2:
 		/*
 		 * If mt_state_lost, SGM now contains either finger 1 or 2, but
 		 * we don't know which.
 		 * So, we just assume that the SGM contains slot 0 and AGM 1.
 		 */
 		if (priv->mt_state_lost)
 			synaptics_mt_state_set(mt_state, 2, 0, 1);
 		/*
 		 * Otherwise, use the same mt_state, since it either hasn't
 		 * changed, or was updated by a recently received AGM-CONTACT
 		 * packet.
 		 */
 		break;
 	case 3:
 		/*
 		 * 3->2 transitions have two unsolvable problems:
 		 *  1) no indication is given which finger was removed
 		 *  2) no way to tell if agm packet was for finger 3
 		 *     before 3->2, or finger 2 after 3->2.
 		 *
 		 * So, report 2 fingers, but empty all slots.
 		 * We will guess slots [0,1] on subsequent 2->2.
 		 */
 		synaptics_mt_state_set(mt_state, 2, -1, -1);
 		priv->mt_state_lost = true;
 		break;
 	case 4:
 	case 5:
 		/* mt_state was updated by AGM-CONTACT packet */
 		break;
 	}
 }
 /* Handle case where mt_state->count = 3 */
 static void synaptics_image_sensor_3f(struct synaptics_data *priv,
 				      struct synaptics_mt_state *mt_state)
 {
 	struct synaptics_mt_state *old = &priv->mt_state;
 	switch (old->count) {
 	case 0:
 		synaptics_mt_state_set(mt_state, 3, 0, 2);
 		break;
 	case 1:
 		/*
 		 * If previous SGM contained slot 2 or higher, SGM now contains
 		 * slot 0 (one of the newly touching fingers) and AGM contains
 		 * SGM's previous slot.
 		 *
 		 * Otherwise, SGM now contains slot 0 and AGM contains slot 2.
 		 */
 		if (old->sgm >= 2)
 			synaptics_mt_state_set(mt_state, 3, 0, old->sgm);
 		else
 			synaptics_mt_state_set(mt_state, 3, 0, 2);
 		break;
 	case 2:
 		/*
 		 * If the AGM previously contained slot 3 or higher, then the
 		 * newly touching finger is in the lowest available slot.
 		 *
 		 * If SGM was previously 1 or higher, then the new SGM is
 		 * now slot 0 (with a new finger), otherwise, the new finger
 		 * is now in a hidden slot between 0 and AGM's slot.
 		 *
 		 * In all such cases, the SGM now contains slot 0, and the AGM
 		 * continues to contain the same slot as before.
 		 */
 		if (old->agm >= 3) {
 			synaptics_mt_state_set(mt_state, 3, 0, old->agm);
 			break;
 		}
 		/*
 		 * After some 3->1 and all 3->2 transitions, we lose track
 		 * of which slot is reported by SGM and AGM.
 		 *
 		 * For 2->3 in this state, report 3 fingers, but empty all
 		 * slots, and we will guess (0,2) on a subsequent 0->3.
 		 *
 		 * To userspace, the resulting transition will look like:
 		 *    2:[0,1] -> 3:[-1,-1] -> 3:[0,2]
 		 */
 		if (priv->mt_state_lost) {
 			synaptics_mt_state_set(mt_state, 3, -1, -1);
 			break;
 		}
 		/*
 		 * If the (SGM,AGM) really previously contained slots (0, 1),
 		 * then we cannot know what slot was just reported by the AGM,
 		 * because the 2->3 transition can occur either before or after
 		 * the AGM packet. Thus, this most recent AGM could contain
 		 * either the same old slot 1 or the new slot 2.
 		 * Subsequent AGMs will be reporting slot 2.
 		 *
 		 * To userspace, the resulting transition will look like:
 		 *    2:[0,1] -> 3:[0,-1] -> 3:[0,2]
 		 */
 		synaptics_mt_state_set(mt_state, 3, 0, -1);
 		break;
 	case 3:
 		/*
 		 * If, for whatever reason, the previous agm was invalid,
 		 * Assume SGM now contains slot 0, AGM now contains slot 2.
 		 */
 		if (old->agm <= 2)
 			synaptics_mt_state_set(mt_state, 3, 0, 2);
 		/*
 		 * mt_state either hasn't changed, or was updated by a recently
 		 * received AGM-CONTACT packet.
 		 */
 		break;
 	case 4:
 	case 5:
 		/* mt_state was updated by AGM-CONTACT packet */
 		break;
 	}
 }
 /* Handle case where mt_state->count = 4, or = 5 */
 static void synaptics_image_sensor_45f(struct synaptics_data *priv,
 				       struct synaptics_mt_state *mt_state)
 {
 	/* mt_state was updated correctly by AGM-CONTACT packet */
 	priv->mt_state_lost = false;
 }
 static void synaptics_image_sensor_process(struct psmouse *psmouse,
 					   struct synaptics_hw_state *sgm)
 {
 	struct synaptics_data *priv = psmouse->private;
 	struct synaptics_hw_state *agm = &priv->agm;
 	struct synaptics_mt_state mt_state;
 	/* Initialize using current mt_state (as updated by last agm) */
 	mt_state = agm->mt_state;
 	/*
 	 * Update mt_state using the new finger count and current mt_state.
 	 */
 	if (sgm->z == 0)
 		synaptics_image_sensor_0f(priv, &mt_state);
 	else if (sgm->w >= 4)
 		synaptics_image_sensor_1f(priv, &mt_state);
 	else if (sgm->w == 0)
 		synaptics_image_sensor_2f(priv, &mt_state);
 	else if (sgm->w == 1 && mt_state.count <= 3)
 		synaptics_image_sensor_3f(priv, &mt_state);
 	else
 		synaptics_image_sensor_45f(priv, &mt_state);
 	/* Send resulting input events to user space */
 	synaptics_report_mt_data(psmouse, &mt_state, sgm);
 	/* Store updated mt_state */
 	priv->mt_state = agm->mt_state = mt_state;
 	priv->agm_pending = false;
 }
 static void synaptics_profile_sensor_process(struct psmouse *psmouse,
 					     struct synaptics_hw_state *sgm,
 					     int num_fingers)
 {
 	struct input_dev *dev = psmouse->dev;
 	struct synaptics_data *priv = psmouse->private;
 	struct synaptics_hw_state *hw[2] = { sgm, &priv->agm };
 	struct input_mt_pos pos[2];
 	int slot[2], nsemi, i;
 	nsemi = clamp_val(num_fingers, 0, 2);
 	for (i = 0; i < nsemi; i++) {
 		pos[i].x = hw[i]->x;
 		pos[i].y = synaptics_invert_y(hw[i]->y);
 	}
 	input_mt_assign_slots(dev, slot, pos, nsemi);
 	for (i = 0; i < nsemi; i++) {
 		input_mt_slot(dev, slot[i]);
 		input_mt_report_slot_state(dev, MT_TOOL_FINGER, true);
 		input_report_abs(dev, ABS_MT_POSITION_X, pos[i].x);
 		input_report_abs(dev, ABS_MT_POSITION_Y, pos[i].y);
 		input_report_abs(dev, ABS_MT_PRESSURE, hw[i]->z);
 	}
 	input_mt_drop_unused(dev);
 	input_mt_report_pointer_emulation(dev, false);
 	input_mt_report_finger_count(dev, num_fingers);
 	synaptics_report_buttons(psmouse, sgm);
 	input_sync(dev);
 }
 /*
  *  called for each full received packet from the touchpad
  */
 static void synaptics_process_packet(struct psmouse *psmouse)
 {
 	struct input_dev *dev = psmouse->dev;
 	struct synaptics_data *priv = psmouse->private;
 	struct synaptics_hw_state hw;
 	int num_fingers;
 	int finger_width;
 	if (synaptics_parse_hw_state(psmouse->packet, priv, &hw))
 		return;
 	if (SYN_CAP_IMAGE_SENSOR(priv->ext_cap_0c)) {
 		synaptics_image_sensor_process(psmouse, &hw);
 		return;
 	}
 	if (hw.scroll) {
 		priv->scroll += hw.scroll;
 		while (priv->scroll >= 4) {
 			input_report_key(dev, BTN_BACK, !hw.down);
 			input_sync(dev);
 			input_report_key(dev, BTN_BACK, hw.down);
 			input_sync(dev);
 			priv->scroll -= 4;
 		}
 		while (priv->scroll <= -4) {
 			input_report_key(dev, BTN_FORWARD, !hw.up);
 			input_sync(dev);
 			input_report_key(dev, BTN_FORWARD, hw.up);
 			input_sync(dev);
 			priv->scroll += 4;
 		}
 		return;
 	}
 	if (hw.z > 0 && hw.x > 1) {
 		num_fingers = 1;
 		finger_width = 5;
 		if (SYN_CAP_EXTENDED(priv->capabilities)) {
 			switch (hw.w) {
 			case 0 ... 1:
 				if (SYN_CAP_MULTIFINGER(priv->capabilities))
 					num_fingers = hw.w + 2;
 				break;
 			case 2:
 				if (SYN_MODEL_PEN(priv->model_id))
 					;   /* Nothing, treat a pen as a single finger */
 				break;
 			case 4 ... 15:
 				if (SYN_CAP_PALMDETECT(priv->capabilities))
 					finger_width = hw.w;
 				break;
 			}
 		}
 	} else {
 		num_fingers = 0;
 		finger_width = 0;
 	}
 	if (cr48_profile_sensor) {
 		synaptics_profile_sensor_process(psmouse, &hw, num_fingers);
 		return;
 	}
 	if (SYN_CAP_ADV_GESTURE(priv->ext_cap_0c))
 		synaptics_report_semi_mt_data(dev, &hw, &priv->agm,
 					      num_fingers);
 	/* Post events
 	 * BTN_TOUCH has to be first as mousedev relies on it when doing
 	 * absolute -> relative conversion
 	 */
 	if (hw.z > 30) input_report_key(dev, BTN_TOUCH, 1);
 	if (hw.z < 25) input_report_key(dev, BTN_TOUCH, 0);
 	if (num_fingers > 0) {
 		input_report_abs(dev, ABS_X, hw.x);
 		input_report_abs(dev, ABS_Y, synaptics_invert_y(hw.y));
 	}
 	input_report_abs(dev, ABS_PRESSURE, hw.z);
 	if (SYN_CAP_PALMDETECT(priv->capabilities))
 		input_report_abs(dev, ABS_TOOL_WIDTH, finger_width);
 	input_report_key(dev, BTN_TOOL_FINGER, num_fingers == 1);
 	if (SYN_CAP_MULTIFINGER(priv->capabilities)) {
 		input_report_key(dev, BTN_TOOL_DOUBLETAP, num_fingers == 2);
 		input_report_key(dev, BTN_TOOL_TRIPLETAP, num_fingers == 3);
 	}
 	synaptics_report_buttons(psmouse, &hw);
 	input_sync(dev);
 }
 static int synaptics_validate_byte(struct psmouse *psmouse,
 				   int idx, unsigned char pkt_type)
 {
 	static const unsigned char newabs_mask[]	= { 0xC8, 0x00, 0x00, 0xC8, 0x00 };
 	static const unsigned char newabs_rel_mask[]	= { 0xC0, 0x00, 0x00, 0xC0, 0x00 };
 	static const unsigned char newabs_rslt[]	= { 0x80, 0x00, 0x00, 0xC0, 0x00 };
 	static const unsigned char oldabs_mask[]	= { 0xC0, 0x60, 0x00, 0xC0, 0x60 };
 	static const unsigned char oldabs_rslt[]	= { 0xC0, 0x00, 0x00, 0x80, 0x00 };
 	const char *packet = psmouse->packet;
 	if (idx < 0 || idx > 4)
 		return 0;
 	switch (pkt_type) {
 	case SYN_NEWABS:
 	case SYN_NEWABS_RELAXED:
 		return (packet[idx] & newabs_rel_mask[idx]) == newabs_rslt[idx];
 	case SYN_NEWABS_STRICT:
 		return (packet[idx] & newabs_mask[idx]) == newabs_rslt[idx];
 	case SYN_OLDABS:
 		return (packet[idx] & oldabs_mask[idx]) == oldabs_rslt[idx];
 	default:
 		psmouse_err(psmouse, "unknown packet type %d\n", pkt_type);
 		return 0;
 	}
 }
 static unsigned char synaptics_detect_pkt_type(struct psmouse *psmouse)
 {
 	int i;
 	for (i = 0; i < 5; i++)
 		if (!synaptics_validate_byte(psmouse, i, SYN_NEWABS_STRICT)) {
 			psmouse_info(psmouse, "using relaxed packet validation\n");
 			return SYN_NEWABS_RELAXED;
 		}
 	return SYN_NEWABS_STRICT;
 }
 static psmouse_ret_t synaptics_process_byte(struct psmouse *psmouse)
 {
 	struct synaptics_data *priv = psmouse->private;
 	if (psmouse->pktcnt >= 6) { /* Full packet received */
 		if (unlikely(priv->pkt_type == SYN_NEWABS))
 			priv->pkt_type = synaptics_detect_pkt_type(psmouse);
 		if (SYN_CAP_PASS_THROUGH(priv->capabilities) &&
 		    synaptics_is_pt_packet(psmouse->packet)) {
 			if (priv->pt_port)
 				synaptics_pass_pt_packet(priv->pt_port, psmouse->packet);
 		} else
 			synaptics_process_packet(psmouse);
 		return PSMOUSE_FULL_PACKET;
 	}
 	return synaptics_validate_byte(psmouse, psmouse->pktcnt - 1, priv->pkt_type) ?
 		PSMOUSE_GOOD_DATA : PSMOUSE_BAD_DATA;
 }
 /*****************************************************************************
  *	Driver initialization/cleanup functions
  ****************************************************************************/
 static void set_abs_position_params(struct input_dev *dev,
 				    struct synaptics_data *priv, int x_code,
 				    int y_code)
 {
 	int x_min = priv->x_min ?: XMIN_NOMINAL;
 	int x_max = priv->x_max ?: XMAX_NOMINAL;
 	int y_min = priv->y_min ?: YMIN_NOMINAL;
 	int y_max = priv->y_max ?: YMAX_NOMINAL;
 	int fuzz = SYN_CAP_REDUCED_FILTERING(priv->ext_cap_0c) ?
 			SYN_REDUCED_FILTER_FUZZ : 0;
 	input_set_abs_params(dev, x_code, x_min, x_max, fuzz, 0);
 	input_set_abs_params(dev, y_code, y_min, y_max, fuzz, 0);
 	input_abs_set_res(dev, x_code, priv->x_res);
 	input_abs_set_res(dev, y_code, priv->y_res);
 }
 static void set_input_params(struct psmouse *psmouse,
 			     struct synaptics_data *priv)
 {
 	struct input_dev *dev = psmouse->dev;
 	int i;
 	/* Things that apply to both modes */
 	__set_bit(INPUT_PROP_POINTER, dev->propbit);
 	__set_bit(EV_KEY, dev->evbit);
 	__set_bit(BTN_LEFT, dev->keybit);
 	__set_bit(BTN_RIGHT, dev->keybit);
 	if (SYN_CAP_MIDDLE_BUTTON(priv->capabilities))
 		__set_bit(BTN_MIDDLE, dev->keybit);
 	if (!priv->absolute_mode) {
 		/* Relative mode */
 		__set_bit(EV_REL, dev->evbit);
 		__set_bit(REL_X, dev->relbit);
 		__set_bit(REL_Y, dev->relbit);
 		return;
 	}
 	/* Absolute mode */
 	__set_bit(EV_ABS, dev->evbit);
 	set_abs_position_params(dev, priv, ABS_X, ABS_Y);
 	input_set_abs_params(dev, ABS_PRESSURE, 0, 255, 0, 0);
 	if (cr48_profile_sensor)
 		input_set_abs_params(dev, ABS_MT_PRESSURE, 0, 255, 0, 0);
 	if (SYN_CAP_IMAGE_SENSOR(priv->ext_cap_0c)) {
 		set_abs_position_params(dev, priv, ABS_MT_POSITION_X,
 					ABS_MT_POSITION_Y);
 		/* Image sensors can report per-contact pressure */
 		input_set_abs_params(dev, ABS_MT_PRESSURE, 0, 255, 0, 0);
 		input_mt_init_slots(dev, 2, INPUT_MT_POINTER);
 		/* Image sensors can signal 4 and 5 finger clicks */
 		__set_bit(BTN_TOOL_QUADTAP, dev->keybit);
 		__set_bit(BTN_TOOL_QUINTTAP, dev->keybit);
 	} else if (SYN_CAP_ADV_GESTURE(priv->ext_cap_0c)) {
 		set_abs_position_params(dev, priv, ABS_MT_POSITION_X,
 					ABS_MT_POSITION_Y);
 		/*
 		 * Profile sensor in CR-48 tracks contacts reasonably well,
 		 * other non-image sensors with AGM use semi-mt.
 		 */
 		input_mt_init_slots(dev, 2,
 				    INPUT_MT_POINTER |
 				    (cr48_profile_sensor ?
 					INPUT_MT_TRACK : INPUT_MT_SEMI_MT));
 	}
 	if (SYN_CAP_PALMDETECT(priv->capabilities))
 		input_set_abs_params(dev, ABS_TOOL_WIDTH, 0, 15, 0, 0);
 	__set_bit(BTN_TOUCH, dev->keybit);
 	__set_bit(BTN_TOOL_FINGER, dev->keybit);
 	if (SYN_CAP_MULTIFINGER(priv->capabilities)) {
 		__set_bit(BTN_TOOL_DOUBLETAP, dev->keybit);
 		__set_bit(BTN_TOOL_TRIPLETAP, dev->keybit);
 	}
 	if (SYN_CAP_FOUR_BUTTON(priv->capabilities) ||
 	    SYN_CAP_MIDDLE_BUTTON(priv->capabilities)) {
 		__set_bit(BTN_FORWARD, dev->keybit);
 		__set_bit(BTN_BACK, dev->keybit);
 	}
 	for (i = 0; i < SYN_CAP_MULTI_BUTTON_NO(priv->ext_cap); i++)
 		__set_bit(BTN_0 + i, dev->keybit);
 	__clear_bit(EV_REL, dev->evbit);
 	__clear_bit(REL_X, dev->relbit);
 	__clear_bit(REL_Y, dev->relbit);
 	if (SYN_CAP_CLICKPAD(priv->ext_cap_0c)) {
 		__set_bit(INPUT_PROP_BUTTONPAD, dev->propbit);
 		if (psmouse_matches_pnp_id(psmouse, topbuttonpad_pnp_ids))
 			__set_bit(INPUT_PROP_TOPBUTTONPAD, dev->propbit);
 		/* Clickpads report only left button */
 		__clear_bit(BTN_RIGHT, dev->keybit);
 		__clear_bit(BTN_MIDDLE, dev->keybit);
 	}
 }
 static ssize_t synaptics_show_disable_gesture(struct psmouse *psmouse,
 					      void *data, char *buf)
 {
 	struct synaptics_data *priv = psmouse->private;
 	return sprintf(buf, "%c\n", priv->disable_gesture ? '1' : '0');
 }
 static ssize_t synaptics_set_disable_gesture(struct psmouse *psmouse,
 					     void *data, const char *buf,
 					     size_t len)
 {
 	struct synaptics_data *priv = psmouse->private;
 	unsigned int value;
 	int err;
 	err = kstrtouint(buf, 10, &value);
 	if (err)
 		return err;
 	if (value > 1)
 		return -EINVAL;
 	if (value == priv->disable_gesture)
 		return len;
 	priv->disable_gesture = value;
 	if (value)
 		priv->mode |= SYN_BIT_DISABLE_GESTURE;
 	else
 		priv->mode &= ~SYN_BIT_DISABLE_GESTURE;
 	if (synaptics_mode_cmd(psmouse, priv->mode))
 		return -EIO;
 	return len;
 }
 PSMOUSE_DEFINE_ATTR(disable_gesture, S_IWUSR | S_IRUGO, NULL,
 		    synaptics_show_disable_gesture,
 		    synaptics_set_disable_gesture);
 static void synaptics_disconnect(struct psmouse *psmouse)
 {
 	struct synaptics_data *priv = psmouse->private;
 	if (!priv->absolute_mode && SYN_ID_DISGEST_SUPPORTED(priv->identity))
 		device_remove_file(&psmouse->ps2dev.serio->dev,
 				   &psmouse_attr_disable_gesture.dattr);
 	synaptics_reset(psmouse);
 	kfree(priv);
 	psmouse->private = NULL;
 }
 static int synaptics_reconnect(struct psmouse *psmouse)
 {
 	struct synaptics_data *priv = psmouse->private;
 	struct synaptics_data old_priv = *priv;
 	unsigned char param[2];
 	int retry = 0;
 	int error;
 	do {
 		psmouse_reset(psmouse);
 		if (retry) {
 			/*
 			 * On some boxes, right after resuming, the touchpad
 			 * needs some time to finish initializing (I assume
 			 * it needs time to calibrate) and start responding
 			 * to Synaptics-specific queries, so let's wait a
 			 * bit.
 			 */
 			ssleep(1);
 		}
 		ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETID);
 		error = synaptics_detect(psmouse, 0);
 	} while (error && ++retry < 3);
 	if (error)
 		return -1;
 	if (retry > 1)
 		psmouse_dbg(psmouse, "reconnected after %d tries\n", retry);
 	if (synaptics_query_hardware(psmouse)) {
 		psmouse_err(psmouse, "Unable to query device.\n");
 		return -1;
 	}
 	if (synaptics_set_mode(psmouse)) {
 		psmouse_err(psmouse, "Unable to initialize device.\n");
 		return -1;
 	}
 	if (old_priv.identity != priv->identity ||
 	    old_priv.model_id != priv->model_id ||
 	    old_priv.capabilities != priv->capabilities ||
 	    old_priv.ext_cap != priv->ext_cap) {
 		psmouse_err(psmouse,
 			    "hardware appears to be different: id(%ld-%ld), model(%ld-%ld), caps(%lx-%lx), ext(%lx-%lx).\n",
 			    old_priv.identity, priv->identity,
 			    old_priv.model_id, priv->model_id,
 			    old_priv.capabilities, priv->capabilities,
 			    old_priv.ext_cap, priv->ext_cap);
 		return -1;
 	}
 	return 0;
 }
 static bool impaired_toshiba_kbc;
 static const struct dmi_system_id toshiba_dmi_table[] __initconst = {
 #if defined(CONFIG_DMI) && defined(CONFIG_X86)
 	{
 		/* Toshiba Satellite */
 		.matches = {
 			DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
 			DMI_MATCH(DMI_PRODUCT_NAME, "Satellite"),
 		},
 	},
 	{
 		/* Toshiba Dynabook */
 		.matches = {
 			DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
 			DMI_MATCH(DMI_PRODUCT_NAME, "dynabook"),
 		},
 	},
 	{
 		/* Toshiba Portege M300 */
 		.matches = {
 			DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
 			DMI_MATCH(DMI_PRODUCT_NAME, "PORTEGE M300"),
 		},
 	},
 	{
 		/* Toshiba Portege M300 */
 		.matches = {
 			DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
 			DMI_MATCH(DMI_PRODUCT_NAME, "Portable PC"),
 			DMI_MATCH(DMI_PRODUCT_VERSION, "Version 1.0"),
 		},
 	},
 #endif
 	{ }
 };
 static bool broken_olpc_ec;
 static const struct dmi_system_id olpc_dmi_table[] __initconst = {
 #if defined(CONFIG_DMI) && defined(CONFIG_OLPC)
 	{
 		/* OLPC XO-1 or XO-1.5 */
 		.matches = {
 			DMI_MATCH(DMI_SYS_VENDOR, "OLPC"),
 			DMI_MATCH(DMI_PRODUCT_NAME, "XO"),
 		},
 	},
 #endif
 	{ }
 };
 static const struct dmi_system_id __initconst cr48_dmi_table[] = {
 #if defined(CONFIG_DMI) && defined(CONFIG_X86)
 	{
 		/* Cr-48 Chromebook (Codename Mario) */
 		.matches = {
 			DMI_MATCH(DMI_SYS_VENDOR, "IEC"),
 			DMI_MATCH(DMI_PRODUCT_NAME, "Mario"),
 		},
 	},
 #endif
 	{ }
 };
 static const struct dmi_system_id forcepad_dmi_table[] __initconst = {
 #if defined(CONFIG_DMI) && defined(CONFIG_X86)
 	{
 		.matches = {
 			DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
 			DMI_MATCH(DMI_PRODUCT_NAME, "HP EliteBook Folio 1040 G1"),
 		},
 	},
 #endif
 	{ }
 };
 void __init synaptics_module_init(void)
 {
 	impaired_toshiba_kbc = dmi_check_system(toshiba_dmi_table);
 	broken_olpc_ec = dmi_check_system(olpc_dmi_table);
 	cr48_profile_sensor = dmi_check_system(cr48_dmi_table);
 	/*
 	 * Unfortunately ForcePad capability is not exported over PS/2,
 	 * so we have to resort to checking DMI.
 	 */
 	is_forcepad = dmi_check_system(forcepad_dmi_table);
 }
 static int __synaptics_init(struct psmouse *psmouse, bool absolute_mode)
 {
 	struct synaptics_data *priv;
 	int err = -1;
 	/*
 	 * The OLPC XO has issues with Synaptics' absolute mode; the constant
 	 * packet spew overloads the EC such that key presses on the keyboard
 	 * are missed.  Given that, don't even attempt to use Absolute mode.
 	 * Relative mode seems to work just fine.
 	 */
 	if (absolute_mode && broken_olpc_ec) {
 		psmouse_info(psmouse,
 			     "OLPC XO detected, not enabling Synaptics protocol.\n");
 		return -ENODEV;
 	}
 	psmouse->private = priv = kzalloc(sizeof(struct synaptics_data), GFP_KERNEL);
 	if (!priv)
 		return -ENOMEM;
 	psmouse_reset(psmouse);
 	if (synaptics_query_hardware(psmouse)) {
 		psmouse_err(psmouse, "Unable to query device.\n");
 		goto init_fail;
 	}
 	priv->absolute_mode = absolute_mode;
 	if (SYN_ID_DISGEST_SUPPORTED(priv->identity))
 		priv->disable_gesture = true;
 	if (synaptics_set_mode(psmouse)) {
 		psmouse_err(psmouse, "Unable to initialize device.\n");
 		goto init_fail;
 	}
 	priv->pkt_type = SYN_MODEL_NEWABS(priv->model_id) ? SYN_NEWABS : SYN_OLDABS;
 	psmouse_info(psmouse,
 		     "Touchpad model: %ld, fw: %ld.%ld, id: %#lx, caps: %#lx/%#lx/%#lx, board id: %lu, fw id: %lu\n",
 		     SYN_ID_MODEL(priv->identity),
 		     SYN_ID_MAJOR(priv->identity), SYN_ID_MINOR(priv->identity),
 		     priv->model_id,
 		     priv->capabilities, priv->ext_cap, priv->ext_cap_0c,
 		     priv->board_id, priv->firmware_id);
 	set_input_params(psmouse, priv);
 	/*
 	 * Encode touchpad model so that it can be used to set
 	 * input device->id.version and be visible to userspace.
 	 * Because version is __u16 we have to drop something.
 	 * Hardware info bits seem to be good candidates as they
 	 * are documented to be for Synaptics corp. internal use.
 	 */
 	psmouse->model = ((priv->model_id & 0x00ff0000) >> 8) |
 			  (priv->model_id & 0x000000ff);
 	if (absolute_mode) {
 		psmouse->protocol_handler = synaptics_process_byte;
 		psmouse->pktsize = 6;
 	} else {
 		/* Relative mode follows standard PS/2 mouse protocol */
 		psmouse->protocol_handler = psmouse_process_byte;
 		psmouse->pktsize = 3;
 	}
 	psmouse->set_rate = synaptics_set_rate;
 	psmouse->disconnect = synaptics_disconnect;
 	psmouse->reconnect = synaptics_reconnect;
 	psmouse->cleanup = synaptics_reset;
 	/* Synaptics can usually stay in sync without extra help */
 	psmouse->resync_time = 0;
 	if (SYN_CAP_PASS_THROUGH(priv->capabilities))
 		synaptics_pt_create(psmouse);
 	/*
 	 * Toshiba's KBC seems to have trouble handling data from
 	 * Synaptics at full rate.  Switch to a lower rate (roughly
 	 * the same rate as a standard PS/2 mouse).
 	 */
 	if (psmouse->rate >= 80 && impaired_toshiba_kbc) {
 		psmouse_info(psmouse,
 			     "Toshiba %s detected, limiting rate to 40pps.\n",
 			     dmi_get_system_info(DMI_PRODUCT_NAME));
 		psmouse->rate = 40;
 	}
 	if (!priv->absolute_mode && SYN_ID_DISGEST_SUPPORTED(priv->identity)) {
 		err = device_create_file(&psmouse->ps2dev.serio->dev,
 					 &psmouse_attr_disable_gesture.dattr);
 		if (err) {
 			psmouse_err(psmouse,
 				    "Failed to create disable_gesture attribute (%d)",
 				    err);
 			goto init_fail;
 		}
 	}
 	return 0;
  init_fail:
 	kfree(priv);
 	return err;
 }
 int synaptics_init(struct psmouse *psmouse)
 {
 	return __synaptics_init(psmouse, true);
 }
 int synaptics_init_relative(struct psmouse *psmouse)
 {
 	return __synaptics_init(psmouse, false);
 }
 bool synaptics_supported(void)
 {
 	return true;
 }
 #else /* CONFIG_MOUSE_PS2_SYNAPTICS */
 void __init synaptics_module_init(void)
 {
 }
 int synaptics_init(struct psmouse *psmouse)
 {
 	return -ENOSYS;
 }
 bool synaptics_supported(void)
 {
 	return false;
 }
 #endif /* CONFIG_MOUSE_PS2_SYNAPTICS */