libinput-measure-fuzz.py 15.1 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
#!/usr/bin/env python3
# vim: set expandtab shiftwidth=4:
# -*- Mode: python; coding: utf-8; indent-tabs-mode: nil -*- */
#
# Copyright © 2018 Red Hat, Inc.
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the 'Software'),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice (including the next
# paragraph) shall be included in all copies or substantial portions of the
# Software.
#
# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.
#

import os
import sys
import argparse
import subprocess
try:
32
    import libevdev
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71
    import pyudev
except ModuleNotFoundError as e:
    print('Error: {}'.format(str(e)), file=sys.stderr)
    print('One or more python modules are missing. Please install those '
          'modules and re-run this tool.')
    sys.exit(1)


DEFAULT_HWDB_FILE = '/usr/lib/udev/hwdb.d/60-evdev.hwdb'
OVERRIDE_HWDB_FILE = '/etc/udev/hwdb.d/99-touchpad-fuzz-override.hwdb'


class tcolors:
    GREEN = '\033[92m'
    RED = '\033[91m'
    BOLD = '\033[1m'
    NORMAL = '\033[0m'


def print_bold(msg, **kwargs):
    print(tcolors.BOLD + msg + tcolors.NORMAL, **kwargs)


def print_green(msg, **kwargs):
    print(tcolors.BOLD + tcolors.GREEN + msg + tcolors.NORMAL, **kwargs)


def print_red(msg, **kwargs):
    print(tcolors.BOLD + tcolors.RED + msg + tcolors.NORMAL, **kwargs)


class InvalidConfigurationError(Exception):
    pass


class InvalidDeviceError(Exception):
    pass


72
class Device(libevdev.Device):
73 74 75 76 77 78
    def __init__(self, path):
        if path is None:
            self.path = self.find_touch_device()
        else:
            self.path = path

79 80
        fd = open(self.path, 'rb')
        super().__init__(fd)
81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
        context = pyudev.Context()
        self.udev_device = pyudev.Devices.from_device_file(context, self.path)

    def find_touch_device(self):
        context = pyudev.Context()
        for device in context.list_devices(subsystem='input'):
            if not device.get('ID_INPUT_TOUCHPAD', 0):
                continue

            if not device.device_node or \
                    not device.device_node.startswith('/dev/input/event'):
                continue

            return device.device_node

        print('Unable to find a touch device.', file=sys.stderr)
        sys.exit(1)

    def check_property(self):
        '''Return a tuple of (xfuzz, yfuzz) with the fuzz as set in the libinput
           property. Returns None if the property doesn't exist'''

        axes = {
104 105 106 107
            0x00: self.udev_device.get('LIBINPUT_FUZZ_00'),
            0x01: self.udev_device.get('LIBINPUT_FUZZ_01'),
            0x35: self.udev_device.get('LIBINPUT_FUZZ_35'),
            0x36: self.udev_device.get('LIBINPUT_FUZZ_36'),
108 109 110 111
        }

        if axes[0x35] is not None:
            if axes[0x35] != axes[0x00]:
112
                print_bold('WARNING: fuzz mismatch ABS_X: {}, ABS_MT_POSITION_X: {}'.format(axes[0x00], axes[0x35]))
113 114 115

        if axes[0x36] is not None:
            if axes[0x36] != axes[0x01]:
116
                print_bold('WARNING: fuzz mismatch ABS_Y: {}, ABS_MT_POSITION_Y: {}'.format(axes[0x01], axes[0x36]))
117 118 119 120 121 122 123 124

        xfuzz = axes[0x35] or axes[0x00]
        yfuzz = axes[0x36] or axes[0x01]

        if xfuzz is None and yfuzz is None:
            return None

        if ((xfuzz is not None and yfuzz is None) or
125
                (xfuzz is None and yfuzz is not None)):
126 127 128 129
            raise InvalidConfigurationError('fuzz should be set for both axes')

        return (xfuzz, yfuzz)

130
    def check_axes(self):
131
        '''
132
        Returns a tuple of (xfuzz, yfuzz) with the fuzz as set on the device
133 134
        axis. Returns None if no fuzz is set.
        '''
135
        if not self.has(libevdev.EV_ABS.ABS_X) or not self.has(libevdev.EV_ABS.ABS_Y):
136 137
            raise InvalidDeviceError('device does not have x/y axes')

138
        if self.has(libevdev.EV_ABS.ABS_MT_POSITION_X) != self.has(libevdev.EV_ABS.ABS_MT_POSITION_Y):
139 140
            raise InvalidDeviceError('device does not have both multitouch axes')

141 142 143 144
        xfuzz = (self.absinfo[libevdev.EV_ABS.ABS_X].fuzz or
                 self.absinfo[libevdev.EV_ABS.ABS_MT_POSITION_X].fuzz)
        yfuzz = (self.absinfo[libevdev.EV_ABS.ABS_Y].fuzz or
                 self.absinfo[libevdev.EV_ABS.ABS_MT_POSITION_Y].fuzz)
145

146
        if xfuzz == 0 and yfuzz == 0:
147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
            return None

        return (xfuzz, yfuzz)


def print_fuzz(what, fuzz):
    print('  Checking {}... '.format(what), end='')
    if fuzz is None:
        print('not set')
    elif fuzz == (0, 0):
        print('is zero')
    else:
        print('x={} y={}'.format(*fuzz))


def handle_existing_entry(device, fuzz):
    # This is getting messy because we don't really know where the entry
    # could be or how the match rule looks like. So we just check the
    # default location only.
    # For the match comparison, we search for the property value in the
    # file. If there is more than one entry that uses the same
    # overrides this will generate false positives.
    # If the lines aren't in the same order in the file, it'll be a false
    # negative.
    overrides = {
172 173 174 175
        0x00: device.udev_device.get('EVDEV_ABS_00'),
        0x01: device.udev_device.get('EVDEV_ABS_01'),
        0x35: device.udev_device.get('EVDEV_ABS_35'),
        0x36: device.udev_device.get('EVDEV_ABS_36'),
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195
    }

    has_existing_rules = False
    for key, value in overrides.items():
        if value is not None:
            has_existing_rules = True
            break
    if not has_existing_rules:
        return False

    print_red('Error! ', end='')
    print('This device already has axis overrides defined')
    print('')
    print_bold('Searching for existing override...')

    # Construct a template that looks like a hwdb entry (values only) from
    # the udev property values
    template = [' EVDEV_ABS_00={}'.format(overrides[0x00]),
                ' EVDEV_ABS_01={}'.format(overrides[0x01])]
    if overrides[0x35] is not None:
196 197
        template += [' EVDEV_ABS_35={}'.format(overrides[0x35]),
                     ' EVDEV_ABS_36={}'.format(overrides[0x36])]
198 199 200 201 202

    print('Checking in {}... '.format(OVERRIDE_HWDB_FILE), end='')
    entry, prefix, lineno = check_file_for_lines(OVERRIDE_HWDB_FILE, template)
    if entry is not None:
        print_green('found')
203
        print('The existing hwdb entry can be overwritten')
204 205 206 207 208 209 210 211 212
        return False
    else:
        print_red('not found')
        print('Checking in {}... '.format(DEFAULT_HWDB_FILE, template), end='')
        entry, prefix, lineno = check_file_for_lines(DEFAULT_HWDB_FILE, template)
        if entry is not None:
            print_green('found')
        else:
            print_red('not found')
213
            print('The device has a hwdb override defined but it\'s not where I expected it to be.')
214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271
            print('Please look at the libinput documentation for more details.')
            print('Exiting now.')
            return True

    print_bold('Probable entry for this device found in line {}:'.format(lineno))
    print('\n'.join(prefix + entry))
    print('')

    print_bold('Suggested new entry for this device:')
    new_entry = []
    for i in range(0, len(template)):
        parts = entry[i].split(':')
        while len(parts) < 4:
            parts.append('')
        parts[3] = str(fuzz)
        new_entry.append(':'.join(parts))
    print('\n'.join(prefix + new_entry))
    print('')

    # Not going to overwrite the 60-evdev.hwdb entry with this program, too
    # risky. And it may not be our device match anyway.
    print_bold('You must now:')
    print('\n'.join((
        '1. Check the above suggestion for sanity. Does it match your device?',
        '2. Open {} and amend the existing entry'.format(DEFAULT_HWDB_FILE),
        '   as recommended above',
        '',
        '   The property format is:',
        '    EVDEV_ABS_00=min:max:resolution:fuzz',
        '',
        '   Leave the entry as-is and only add or amend the fuzz value.',
        '   A non-existent value can be skipped, e.g. this entry sets the ',
        '   resolution to 32 and the fuzz to 8',
        '    EVDEV_ABS_00=::32:8',
        '',
        '3. Save the edited file',
        '4. Say Y to the next prompt')))

    cont = input('Continue? [Y/n] ')
    if cont == 'n':
        raise KeyboardInterrupt

    if test_hwdb_entry(device, fuzz):
        print_bold('Please test the new fuzz setting by restarting libinput')
        print_bold('Then submit a pull request for this hwdb entry change to '
                   'to systemd at http://github.com/systemd/systemd')
    else:
        print_bold('The new fuzz setting did not take effect.')
        print_bold('Did you edit the correct file?')
        print('Please look at the libinput documentation for more details.')
        print('Exiting now.')

    return True


def reload_and_trigger_udev(device):
    import time

272 273
    print('Running systemd-hwdb update')
    subprocess.run(['systemd-hwdb', 'update'], check=True)
274 275 276 277 278 279 280 281 282 283 284 285
    syspath = device.path.replace('/dev/input/', '/sys/class/input/')
    time.sleep(1)
    print('Running udevadm trigger {}'.format(syspath))
    subprocess.run(['udevadm', 'trigger', syspath], check=True)
    time.sleep(1)


def test_hwdb_entry(device, fuzz):
    reload_and_trigger_udev(device)
    print_bold('Testing... ', end='')

    d = Device(device.path)
286
    f = d.check_axes()
287
    if f is not None and fuzz == f[0] and fuzz == f[1]:
288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384
        print_green('Success')
        return True
    else:
        print_red('Error')
        return False


def check_file_for_lines(path, template):
    '''
    Checks file at path for the lines given in template. If found, the
    return value is a tuple of the matching lines and the prefix (i.e. the
    two lines before the matching lines)
    '''
    try:
        lines = [l[:-1] for l in open(path).readlines()]
        idx = -1
        try:
            while idx < len(lines) - 1:
                idx += 1
                line = lines[idx]
                if not line.startswith(' EVDEV_ABS_00'):
                    continue
                if lines[idx:idx + len(template)] != template:
                    continue

                return (lines[idx:idx + len(template)], lines[idx - 2:idx], idx)

        except IndexError:
            pass
    except FileNotFoundError:
        pass

    return (None, None, None)


def write_udev_rule(device, fuzz):
    '''Write out a udev rule that may match the device, run udevadm trigger and
    check if the udev rule worked. Of course, there's plenty to go wrong...
    '''
    print('')
    print_bold('Guessing a udev rule to overwrite the fuzz')

    # Some devices match better on pvr, others on pn, so we get to try both. yay
    modalias = open('/sys/class/dmi/id/modalias').readlines()[0]
    ms = modalias.split(':')
    svn, pn, pvr = None, None, None
    for m in ms:
        if m.startswith('svn'):
            svn = m
        elif m.startswith('pn'):
            pn = m
        elif m.startswith('pvr'):
            pvr = m

    # Let's print out both to inform and/or confuse the user
    template = '\n'.join(('# {} {}',
                          'evdev:name:{}:dmi:*:{}*:{}*:',
                          ' EVDEV_ABS_00=:::{}',
                          ' EVDEV_ABS_01=:::{}',
                          ' EVDEV_ABS_35=:::{}',
                          ' EVDEV_ABS_36=:::{}',
                          ''))
    rule1 = template.format(svn[3:], device.name, device.name, svn, pvr, fuzz, fuzz, fuzz, fuzz)
    rule2 = template.format(svn[3:], device.name, device.name, svn, pn, fuzz, fuzz, fuzz, fuzz)

    print('Full modalias is: {}'.format(modalias))
    print()
    print_bold('Suggested udev rule, option 1:')
    print(rule1)
    print()
    print_bold('Suggested udev rule, option 2:')
    print(rule2)
    print('')

    # The weird hwdb matching behavior means we match on the least specific
    # rule (i.e. most wildcards) first although that was supposed to be fixed in
    # systemd 3a04b789c6f1.
    # Our rule uses dmi strings and will be more specific than what 60-evdev.hwdb
    # already has. So we basically throw up our hands because we can't do anything
    # then.
    if handle_existing_entry(device, fuzz):
        return

    while True:
        print_bold('Wich rule do you want to to test? 1 or 2? ', end='')
        yesno = input('Ctrl+C to exit ')

        if yesno == '1':
            rule = rule1
            break
        elif yesno == '2':
            rule = rule2
            break

    fname = OVERRIDE_HWDB_FILE
    try:
        fd = open(fname, 'x')
385
    except FileExistsError:
386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412
        yesno = input('File {} exists, overwrite? [Y/n] '.format(fname))
        if yesno.lower == 'n':
            return

        fd = open(fname, 'w')

    fd.write('# File generated by libinput measure fuzz\n\n')
    fd.write(rule)
    fd.close()

    if test_hwdb_entry(device, fuzz):
        print('Your hwdb override file is in {}'.format(fname))
        print_bold('Please test the new fuzz setting by restarting libinput')
        print_bold('Then submit a pull request for this hwdb entry to '
                   'systemd at http://github.com/systemd/systemd')
    else:
        print('The hwdb entry failed to apply to the device.')
        print('Removing hwdb file again.')
        os.remove(fname)
        reload_and_trigger_udev(device)
        print_bold('What now?')
        print('1. Re-run this program and try the other suggested udev rule. If that fails,')
        print('2. File a bug with the suggested udev rule at http://github.com/systemd/systemd')


def main(args):
    parser = argparse.ArgumentParser(
413
        description='Print fuzz settings and/or suggest udev rules for the fuzz to be adjusted.'
414 415 416
    )
    parser.add_argument('path', metavar='/dev/input/event0',
                        nargs='?', type=str, help='Path to device (optional)')
417
    parser.add_argument('--fuzz', type=int, help='Suggested fuzz')
418 419 420 421 422 423 424 425 426
    args = parser.parse_args()

    try:
        device = Device(args.path)
        print_bold('Using {}: {}'.format(device.name, device.path))

        fuzz = device.check_property()
        print_fuzz('udev property', fuzz)

427
        fuzz = device.check_axes()
428 429 430 431 432 433
        print_fuzz('axes', fuzz)

        userfuzz = args.fuzz
        if userfuzz is not None:
            write_udev_rule(device, userfuzz)

434
    except PermissionError:
435 436
        print('Permission denied, please re-run as root')
    except InvalidConfigurationError as e:
437
        print('Error: {}'.format(e))
438 439 440
    except InvalidDeviceError as e:
        print('Error: {}'.format(e))
    except KeyboardInterrupt:
441 442 443 444 445
        print('Exited on user request')


if __name__ == '__main__':
    main(sys.argv)