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

+24 -25

drivers/hid/hid-wacom.c

··· 230 230 input_report_key(input, BTN_RIGHT, 0); 231 231 input_report_key(input, BTN_MIDDLE, 0); 232 232 input_report_abs(input, ABS_DISTANCE, 233 - input->absmax[ABS_DISTANCE]); 233 + input_abs_get_max(input, ABS_DISTANCE)); 234 234 } else { 235 235 input_report_key(input, BTN_TOUCH, 0); 236 236 input_report_key(input, BTN_STYLUS, 0); ··· 383 383 384 384 /* Basics */ 385 385 input->evbit[0] |= BIT(EV_KEY) | BIT(EV_ABS) | BIT(EV_REL); 386 - input->absbit[0] |= BIT(ABS_X) | BIT(ABS_Y) | 387 - BIT(ABS_PRESSURE) | BIT(ABS_DISTANCE); 388 - input->relbit[0] |= BIT(REL_WHEEL); 389 - set_bit(BTN_TOOL_PEN, input->keybit); 390 - set_bit(BTN_TOUCH, input->keybit); 391 - set_bit(BTN_STYLUS, input->keybit); 392 - set_bit(BTN_STYLUS2, input->keybit); 393 - set_bit(BTN_LEFT, input->keybit); 394 - set_bit(BTN_RIGHT, input->keybit); 395 - set_bit(BTN_MIDDLE, input->keybit); 386 + 387 + __set_bit(REL_WHEEL, input->relbit); 388 + 389 + __set_bit(BTN_TOOL_PEN, input->keybit); 390 + __set_bit(BTN_TOUCH, input->keybit); 391 + __set_bit(BTN_STYLUS, input->keybit); 392 + __set_bit(BTN_STYLUS2, input->keybit); 393 + __set_bit(BTN_LEFT, input->keybit); 394 + __set_bit(BTN_RIGHT, input->keybit); 395 + __set_bit(BTN_MIDDLE, input->keybit); 396 396 397 397 /* Pad */ 398 398 input->evbit[0] |= BIT(EV_MSC); 399 - input->mscbit[0] |= BIT(MSC_SERIAL); 400 - set_bit(BTN_0, input->keybit); 401 - set_bit(BTN_1, input->keybit); 402 - set_bit(BTN_TOOL_FINGER, input->keybit); 399 + 400 + __set_bit(MSC_SERIAL, input->mscbit); 401 + 402 + __set_bit(BTN_0, input->keybit); 403 + __set_bit(BTN_1, input->keybit); 404 + __set_bit(BTN_TOOL_FINGER, input->keybit); 403 405 404 406 /* Distance, rubber and mouse */ 405 - input->absbit[0] |= BIT(ABS_DISTANCE); 406 - set_bit(BTN_TOOL_RUBBER, input->keybit); 407 - set_bit(BTN_TOOL_MOUSE, input->keybit); 407 + __set_bit(BTN_TOOL_RUBBER, input->keybit); 408 + __set_bit(BTN_TOOL_MOUSE, input->keybit); 408 409 409 - input->absmax[ABS_PRESSURE] = 511; 410 - input->absmax[ABS_DISTANCE] = 32; 411 - 412 - input->absmax[ABS_X] = 16704; 413 - input->absmax[ABS_Y] = 12064; 414 - input->absfuzz[ABS_X] = 4; 415 - input->absfuzz[ABS_Y] = 4; 410 + input_set_abs_params(input, ABS_X, 0, 16704, 4, 0); 411 + input_set_abs_params(input, ABS_Y, 0, 12064, 4, 0); 412 + input_set_abs_params(input, ABS_PRESSURE, 0, 511, 0, 0); 413 + input_set_abs_params(input, ABS_DISTANCE, 0, 32, 0, 0); 416 414 417 415 return 0; 416 + 418 417 err_free: 419 418 kfree(wdata); 420 419 return ret;

+81 -87

drivers/input/evdev.c

··· 492 492 } 493 493 494 494 #define OLD_KEY_MAX 0x1ff 495 - static int handle_eviocgbit(struct input_dev *dev, unsigned int cmd, void __user *p, int compat_mode) 495 + static int handle_eviocgbit(struct input_dev *dev, 496 + unsigned int type, unsigned int size, 497 + void __user *p, int compat_mode) 496 498 { 497 499 static unsigned long keymax_warn_time; 498 500 unsigned long *bits; 499 501 int len; 500 502 501 - switch (_IOC_NR(cmd) & EV_MAX) { 503 + switch (type) { 502 504 503 505 case 0: bits = dev->evbit; len = EV_MAX; break; 504 506 case EV_KEY: bits = dev->keybit; len = KEY_MAX; break; ··· 519 517 * EVIOCGBIT(EV_KEY, KEY_MAX) and not realize that 'len' 520 518 * should be in bytes, not in bits. 521 519 */ 522 - if ((_IOC_NR(cmd) & EV_MAX) == EV_KEY && _IOC_SIZE(cmd) == OLD_KEY_MAX) { 520 + if (type == EV_KEY && size == OLD_KEY_MAX) { 523 521 len = OLD_KEY_MAX; 524 522 if (printk_timed_ratelimit(&keymax_warn_time, 10 * 1000)) 525 523 printk(KERN_WARNING ··· 530 528 BITS_TO_LONGS(OLD_KEY_MAX) * sizeof(long)); 531 529 } 532 530 533 - return bits_to_user(bits, len, _IOC_SIZE(cmd), p, compat_mode); 531 + return bits_to_user(bits, len, size, p, compat_mode); 534 532 } 535 533 #undef OLD_KEY_MAX 536 534 ··· 544 542 struct ff_effect effect; 545 543 int __user *ip = (int __user *)p; 546 544 unsigned int i, t, u, v; 545 + unsigned int size; 547 546 int error; 548 547 548 + /* First we check for fixed-length commands */ 549 549 switch (cmd) { 550 550 551 551 case EVIOCGVERSION: ··· 614 610 return evdev_grab(evdev, client); 615 611 else 616 612 return evdev_ungrab(evdev, client); 613 + } 617 614 618 - default: 615 + size = _IOC_SIZE(cmd); 619 616 620 - if (_IOC_TYPE(cmd) != 'E') 621 - return -EINVAL; 617 + /* Now check variable-length commands */ 618 + #define EVIOC_MASK_SIZE(nr) ((nr) & ~(_IOC_SIZEMASK << _IOC_SIZESHIFT)) 622 619 623 - if (_IOC_DIR(cmd) == _IOC_READ) { 620 + switch (EVIOC_MASK_SIZE(cmd)) { 624 621 625 - if ((_IOC_NR(cmd) & ~EV_MAX) == _IOC_NR(EVIOCGBIT(0, 0))) 626 - return handle_eviocgbit(dev, cmd, p, compat_mode); 622 + case EVIOCGKEY(0): 623 + return bits_to_user(dev->key, KEY_MAX, size, p, compat_mode); 627 624 628 - if (_IOC_NR(cmd) == _IOC_NR(EVIOCGKEY(0))) 629 - return bits_to_user(dev->key, KEY_MAX, _IOC_SIZE(cmd), 630 - p, compat_mode); 625 + case EVIOCGLED(0): 626 + return bits_to_user(dev->led, LED_MAX, size, p, compat_mode); 631 627 632 - if (_IOC_NR(cmd) == _IOC_NR(EVIOCGLED(0))) 633 - return bits_to_user(dev->led, LED_MAX, _IOC_SIZE(cmd), 634 - p, compat_mode); 628 + case EVIOCGSND(0): 629 + return bits_to_user(dev->snd, SND_MAX, size, p, compat_mode); 635 630 636 - if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSND(0))) 637 - return bits_to_user(dev->snd, SND_MAX, _IOC_SIZE(cmd), 638 - p, compat_mode); 631 + case EVIOCGSW(0): 632 + return bits_to_user(dev->sw, SW_MAX, size, p, compat_mode); 639 633 640 - if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSW(0))) 641 - return bits_to_user(dev->sw, SW_MAX, _IOC_SIZE(cmd), 642 - p, compat_mode); 634 + case EVIOCGNAME(0): 635 + return str_to_user(dev->name, size, p); 643 636 644 - if (_IOC_NR(cmd) == _IOC_NR(EVIOCGNAME(0))) 645 - return str_to_user(dev->name, _IOC_SIZE(cmd), p); 637 + case EVIOCGPHYS(0): 638 + return str_to_user(dev->phys, size, p); 646 639 647 - if (_IOC_NR(cmd) == _IOC_NR(EVIOCGPHYS(0))) 648 - return str_to_user(dev->phys, _IOC_SIZE(cmd), p); 640 + case EVIOCGUNIQ(0): 641 + return str_to_user(dev->uniq, size, p); 649 642 650 - if (_IOC_NR(cmd) == _IOC_NR(EVIOCGUNIQ(0))) 651 - return str_to_user(dev->uniq, _IOC_SIZE(cmd), p); 643 + case EVIOC_MASK_SIZE(EVIOCSFF): 644 + if (input_ff_effect_from_user(p, size, &effect)) 645 + return -EFAULT; 652 646 653 - if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCGABS(0))) { 647 + error = input_ff_upload(dev, &effect, file); 654 648 655 - t = _IOC_NR(cmd) & ABS_MAX; 649 + if (put_user(effect.id, &(((struct ff_effect __user *)p)->id))) 650 + return -EFAULT; 656 651 657 - abs.value = dev->abs[t]; 658 - abs.minimum = dev->absmin[t]; 659 - abs.maximum = dev->absmax[t]; 660 - abs.fuzz = dev->absfuzz[t]; 661 - abs.flat = dev->absflat[t]; 662 - abs.resolution = dev->absres[t]; 652 + return error; 653 + } 663 654 664 - if (copy_to_user(p, &abs, min_t(size_t, 665 - _IOC_SIZE(cmd), 666 - sizeof(struct input_absinfo)))) 667 - return -EFAULT; 655 + /* Multi-number variable-length handlers */ 656 + if (_IOC_TYPE(cmd) != 'E') 657 + return -EINVAL; 668 658 669 - return 0; 670 - } 659 + if (_IOC_DIR(cmd) == _IOC_READ) { 671 660 672 - } 661 + if ((_IOC_NR(cmd) & ~EV_MAX) == _IOC_NR(EVIOCGBIT(0, 0))) 662 + return handle_eviocgbit(dev, 663 + _IOC_NR(cmd) & EV_MAX, size, 664 + p, compat_mode); 673 665 674 - if (_IOC_DIR(cmd) == _IOC_WRITE) { 666 + if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCGABS(0))) { 675 667 676 - if (_IOC_NR(cmd) == _IOC_NR(EVIOCSFF)) { 668 + t = _IOC_NR(cmd) & ABS_MAX; 669 + abs = dev->absinfo[t]; 677 670 678 - if (input_ff_effect_from_user(p, _IOC_SIZE(cmd), &effect)) 679 - return -EFAULT; 671 + if (copy_to_user(p, &abs, min_t(size_t, 672 + size, sizeof(struct input_absinfo)))) 673 + return -EFAULT; 680 674 681 - error = input_ff_upload(dev, &effect, file); 682 - 683 - if (put_user(effect.id, &(((struct ff_effect __user *)p)->id))) 684 - return -EFAULT; 685 - 686 - return error; 687 - } 688 - 689 - if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCSABS(0))) { 690 - 691 - t = _IOC_NR(cmd) & ABS_MAX; 692 - 693 - if (copy_from_user(&abs, p, min_t(size_t, 694 - _IOC_SIZE(cmd), 695 - sizeof(struct input_absinfo)))) 696 - return -EFAULT; 697 - 698 - /* We can't change number of reserved MT slots */ 699 - if (t == ABS_MT_SLOT) 700 - return -EINVAL; 701 - 702 - /* 703 - * Take event lock to ensure that we are not 704 - * changing device parameters in the middle 705 - * of event. 706 - */ 707 - spin_lock_irq(&dev->event_lock); 708 - 709 - dev->abs[t] = abs.value; 710 - dev->absmin[t] = abs.minimum; 711 - dev->absmax[t] = abs.maximum; 712 - dev->absfuzz[t] = abs.fuzz; 713 - dev->absflat[t] = abs.flat; 714 - dev->absres[t] = _IOC_SIZE(cmd) < sizeof(struct input_absinfo) ? 715 - 0 : abs.resolution; 716 - 717 - spin_unlock_irq(&dev->event_lock); 718 - 719 - return 0; 720 - } 675 + return 0; 721 676 } 722 677 } 678 + 679 + if (_IOC_DIR(cmd) == _IOC_READ) { 680 + 681 + if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCSABS(0))) { 682 + 683 + t = _IOC_NR(cmd) & ABS_MAX; 684 + 685 + if (copy_from_user(&abs, p, min_t(size_t, 686 + size, sizeof(struct input_absinfo)))) 687 + return -EFAULT; 688 + 689 + if (size < sizeof(struct input_absinfo)) 690 + abs.resolution = 0; 691 + 692 + /* We can't change number of reserved MT slots */ 693 + if (t == ABS_MT_SLOT) 694 + return -EINVAL; 695 + 696 + /* 697 + * Take event lock to ensure that we are not 698 + * changing device parameters in the middle 699 + * of event. 700 + */ 701 + spin_lock_irq(&dev->event_lock); 702 + dev->absinfo[t] = abs; 703 + spin_unlock_irq(&dev->event_lock); 704 + 705 + return 0; 706 + } 707 + } 708 + 723 709 return -EINVAL; 724 710 } 725 711

+42 -4

drivers/input/input.c

··· 182 182 is_mt_event = code >= ABS_MT_FIRST && code <= ABS_MT_LAST; 183 183 184 184 if (!is_mt_event) { 185 - pold = &dev->abs[code]; 185 + pold = &dev->absinfo[code].value; 186 186 } else if (dev->mt) { 187 187 struct input_mt_slot *mtslot = &dev->mt[dev->slot]; 188 188 pold = &mtslot->abs[code - ABS_MT_FIRST]; ··· 196 196 197 197 if (pold) { 198 198 *pval = input_defuzz_abs_event(*pval, *pold, 199 - dev->absfuzz[code]); 199 + dev->absinfo[code].fuzz); 200 200 if (*pold == *pval) 201 201 return INPUT_IGNORE_EVENT; 202 202 ··· 204 204 } 205 205 206 206 /* Flush pending "slot" event */ 207 - if (is_mt_event && dev->slot != dev->abs[ABS_MT_SLOT]) { 208 - dev->abs[ABS_MT_SLOT] = dev->slot; 207 + if (is_mt_event && dev->slot != input_abs_get_val(dev, ABS_MT_SLOT)) { 208 + input_abs_set_val(dev, ABS_MT_SLOT, dev->slot); 209 209 input_pass_event(dev, EV_ABS, ABS_MT_SLOT, dev->slot); 210 210 } 211 211 ··· 389 389 } 390 390 } 391 391 EXPORT_SYMBOL(input_inject_event); 392 + 393 + /** 394 + * input_alloc_absinfo - allocates array of input_absinfo structs 395 + * @dev: the input device emitting absolute events 396 + * 397 + * If the absinfo struct the caller asked for is already allocated, this 398 + * functions will not do anything. 399 + */ 400 + void input_alloc_absinfo(struct input_dev *dev) 401 + { 402 + if (!dev->absinfo) 403 + dev->absinfo = kcalloc(ABS_CNT, sizeof(struct input_absinfo), 404 + GFP_KERNEL); 405 + 406 + WARN(!dev->absinfo, "%s(): kcalloc() failed?\n", __func__); 407 + } 408 + EXPORT_SYMBOL(input_alloc_absinfo); 409 + 410 + void input_set_abs_params(struct input_dev *dev, unsigned int axis, 411 + int min, int max, int fuzz, int flat) 412 + { 413 + struct input_absinfo *absinfo; 414 + 415 + input_alloc_absinfo(dev); 416 + if (!dev->absinfo) 417 + return; 418 + 419 + absinfo = &dev->absinfo[axis]; 420 + absinfo->minimum = min; 421 + absinfo->maximum = max; 422 + absinfo->fuzz = fuzz; 423 + absinfo->flat = flat; 424 + 425 + dev->absbit[BIT_WORD(axis)] |= BIT_MASK(axis); 426 + } 427 + EXPORT_SYMBOL(input_set_abs_params); 428 + 392 429 393 430 /** 394 431 * input_grab_device - grabs device for exclusive use ··· 1345 1308 1346 1309 input_ff_destroy(dev); 1347 1310 input_mt_destroy_slots(dev); 1311 + kfree(dev->absinfo); 1348 1312 kfree(dev); 1349 1313 1350 1314 module_put(THIS_MODULE);

+16 -15

drivers/input/joydev.c

··· 530 530 { 531 531 struct input_dev *dev = joydev->handle.dev; 532 532 size_t len; 533 - int i, j; 533 + int i; 534 534 const char *name; 535 535 536 536 /* Process fixed-sized commands. */ ··· 562 562 case JSIOCSCORR: 563 563 if (copy_from_user(joydev->corr, argp, 564 564 sizeof(joydev->corr[0]) * joydev->nabs)) 565 - return -EFAULT; 565 + return -EFAULT; 566 566 567 567 for (i = 0; i < joydev->nabs; i++) { 568 - j = joydev->abspam[i]; 569 - joydev->abs[i] = joydev_correct(dev->abs[j], 570 - &joydev->corr[i]); 568 + int val = input_abs_get_val(dev, joydev->abspam[i]); 569 + joydev->abs[i] = joydev_correct(val, &joydev->corr[i]); 571 570 } 572 571 return 0; 573 572 ··· 847 848 848 849 for (i = 0; i < joydev->nabs; i++) { 849 850 j = joydev->abspam[i]; 850 - if (dev->absmax[j] == dev->absmin[j]) { 851 + if (input_abs_get_max(dev, j) == input_abs_get_min(dev, j)) { 851 852 joydev->corr[i].type = JS_CORR_NONE; 852 - joydev->abs[i] = dev->abs[j]; 853 + joydev->abs[i] = input_abs_get_val(dev, j); 853 854 continue; 854 855 } 855 856 joydev->corr[i].type = JS_CORR_BROKEN; 856 - joydev->corr[i].prec = dev->absfuzz[j]; 857 - joydev->corr[i].coef[0] = 858 - (dev->absmax[j] + dev->absmin[j]) / 2 - dev->absflat[j]; 859 - joydev->corr[i].coef[1] = 860 - (dev->absmax[j] + dev->absmin[j]) / 2 + dev->absflat[j]; 857 + joydev->corr[i].prec = input_abs_get_fuzz(dev, j); 861 858 862 - t = (dev->absmax[j] - dev->absmin[j]) / 2 - 2 * dev->absflat[j]; 859 + t = (input_abs_get_max(dev, j) + input_abs_get_min(dev, j)) / 2; 860 + joydev->corr[i].coef[0] = t - input_abs_get_flat(dev, j); 861 + joydev->corr[i].coef[1] = t + input_abs_get_flat(dev, j); 862 + 863 + t = (input_abs_get_max(dev, j) - input_abs_get_min(dev, j)) / 2 864 + - 2 * input_abs_get_flat(dev, j); 863 865 if (t) { 864 866 joydev->corr[i].coef[2] = (1 << 29) / t; 865 867 joydev->corr[i].coef[3] = (1 << 29) / t; 866 868 867 - joydev->abs[i] = joydev_correct(dev->abs[j], 868 - joydev->corr + i); 869 + joydev->abs[i] = 870 + joydev_correct(input_abs_get_val(dev, j), 871 + joydev->corr + i); 869 872 } 870 873 } 871 874

+2 -1

drivers/input/joystick/a3d.c

··· 342 342 343 343 for (i = 0; i < 4; i++) { 344 344 if (i < 2) 345 - input_set_abs_params(input_dev, axes[i], 48, input_dev->abs[axes[i]] * 2 - 48, 0, 8); 345 + input_set_abs_params(input_dev, axes[i], 346 + 48, input_abs_get_val(input_dev, axes[i]) * 2 - 48, 0, 8); 346 347 else 347 348 input_set_abs_params(input_dev, axes[i], 2, 253, 0, 0); 348 349 input_set_abs_params(input_dev, ABS_HAT0X + i, -1, 1, 0, 0);

+1 -1

drivers/input/joystick/adi.c

··· 452 452 for (i = 0; i < adi->axes10 + adi->axes8 + (adi->hats + (adi->pad != -1)) * 2; i++) { 453 453 454 454 t = adi->abs[i]; 455 - x = adi->dev->abs[t]; 455 + x = input_abs_get_val(adi->dev, t); 456 456 457 457 if (t == ABS_THROTTLE || t == ABS_RUDDER || adi->id == ADI_ID_WGPE) 458 458 x = i < adi->axes10 ? 512 : 128;

+2 -2

drivers/input/joystick/amijoy.c

··· 139 139 amijoy_dev[i]->keybit[BIT_WORD(BTN_LEFT)] = BIT_MASK(BTN_LEFT) | 140 140 BIT_MASK(BTN_MIDDLE) | BIT_MASK(BTN_RIGHT); 141 141 for (j = 0; j < 2; j++) { 142 - amijoy_dev[i]->absmin[ABS_X + j] = -1; 143 - amijoy_dev[i]->absmax[ABS_X + j] = 1; 142 + XXinput_set_abs_params(amijoy_dev[i], ABS_X + j, 143 + -1, 1, 0, 0); 144 144 } 145 145 146 146 err = input_register_device(amijoy_dev[i]);

+10 -10

drivers/input/joystick/gf2k.c

··· 318 318 for (i = 0; i < gf2k_axes[gf2k->id]; i++) 319 319 set_bit(gf2k_abs[i], input_dev->absbit); 320 320 321 - for (i = 0; i < gf2k_hats[gf2k->id]; i++) { 322 - set_bit(ABS_HAT0X + i, input_dev->absbit); 323 - input_dev->absmin[ABS_HAT0X + i] = -1; 324 - input_dev->absmax[ABS_HAT0X + i] = 1; 325 - } 321 + for (i = 0; i < gf2k_hats[gf2k->id]; i++) 322 + input_set_abs_params(input_dev, ABS_HAT0X + i, -1, 1, 0, 0); 326 323 327 324 for (i = 0; i < gf2k_joys[gf2k->id]; i++) 328 325 set_bit(gf2k_btn_joy[i], input_dev->keybit); ··· 331 334 gf2k_read(gf2k, data); 332 335 333 336 for (i = 0; i < gf2k_axes[gf2k->id]; i++) { 334 - input_dev->absmax[gf2k_abs[i]] = (i < 2) ? input_dev->abs[gf2k_abs[i]] * 2 - 32 : 335 - input_dev->abs[gf2k_abs[0]] + input_dev->abs[gf2k_abs[1]] - 32; 336 - input_dev->absmin[gf2k_abs[i]] = 32; 337 - input_dev->absfuzz[gf2k_abs[i]] = 8; 338 - input_dev->absflat[gf2k_abs[i]] = (i < 2) ? 24 : 0; 337 + int max = i < 2 ? 338 + input_abs_get_val(input_dev, gf2k_abs[i]) * 2 : 339 + input_abs_get_val(input_dev, gf2k_abs[0]) + 340 + input_abs_get_val(input_dev, gf2k_abs[1]); 341 + int flat = i < 2 ? 24 : 0; 342 + 343 + input_set_abs_params(input_dev, gf2k_abs[i], 344 + 32, max - 32, 8, flat); 339 345 } 340 346 341 347 err = input_register_device(gf2k->dev);

+5 -9

drivers/input/joystick/interact.c

··· 270 270 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); 271 271 272 272 for (i = 0; (t = interact_type[interact->type].abs[i]) >= 0; i++) { 273 - set_bit(t, input_dev->absbit); 274 - if (i < interact_type[interact->type].b8) { 275 - input_dev->absmin[t] = 0; 276 - input_dev->absmax[t] = 255; 277 - } else { 278 - input_dev->absmin[t] = -1; 279 - input_dev->absmax[t] = 1; 280 - } 273 + if (i < interact_type[interact->type].b8) 274 + input_set_abs_params(input_dev, t, 0, 255, 0, 0); 275 + else 276 + input_set_abs_params(input_dev, t, -1, 1, 0, 0); 281 277 } 282 278 283 279 for (i = 0; (t = interact_type[interact->type].btn[i]) >= 0; i++) 284 - set_bit(t, input_dev->keybit); 280 + __set_bit(t, input_dev->keybit); 285 281 286 282 err = input_register_device(interact->dev); 287 283 if (err)

+11 -7

drivers/input/joystick/sidewinder.c

··· 761 761 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); 762 762 763 763 for (j = 0; (bits = sw_bit[sw->type][j]); j++) { 764 + int min, max, fuzz, flat; 765 + 764 766 code = sw_abs[sw->type][j]; 765 - set_bit(code, input_dev->absbit); 766 - input_dev->absmax[code] = (1 << bits) - 1; 767 - input_dev->absmin[code] = (bits == 1) ? -1 : 0; 768 - input_dev->absfuzz[code] = ((bits >> 1) >= 2) ? (1 << ((bits >> 1) - 2)) : 0; 769 - if (code != ABS_THROTTLE) 770 - input_dev->absflat[code] = (bits >= 5) ? (1 << (bits - 5)) : 0; 767 + min = bits == 1 ? -1 : 0; 768 + max = (1 << bits) - 1; 769 + fuzz = (bits >> 1) >= 2 ? 1 << ((bits >> 1) - 2) : 0; 770 + flat = code == ABS_THROTTLE || bits < 5 ? 771 + 0 : 1 << (bits - 5); 772 + 773 + input_set_abs_params(input_dev, code, 774 + min, max, fuzz, flat); 771 775 } 772 776 773 777 for (j = 0; (code = sw_btn[sw->type][j]); j++) 774 - set_bit(code, input_dev->keybit); 778 + __set_bit(code, input_dev->keybit); 775 779 776 780 dbg("%s%s [%d-bit id %d data %d]\n", sw->name, comment, m, l, k); 777 781

+1

drivers/input/joystick/xpad.c

··· 148 148 { 0x0e6f, 0x0005, "Eclipse wireless Controller", 0, XTYPE_XBOX }, 149 149 { 0x0e6f, 0x0006, "Edge wireless Controller", 0, XTYPE_XBOX }, 150 150 { 0x0e6f, 0x0006, "Pelican 'TSZ' Wired Xbox 360 Controller", 0, XTYPE_XBOX360 }, 151 + { 0x0e6f, 0x0201, "Pelican PL-3601 'TSZ' Wired Xbox 360 Controller", 0, XTYPE_XBOX360 }, 151 152 { 0x0e8f, 0x0201, "SmartJoy Frag Xpad/PS2 adaptor", 0, XTYPE_XBOX }, 152 153 { 0x0f30, 0x0202, "Joytech Advanced Controller", 0, XTYPE_XBOX }, 153 154 { 0x0f30, 0x8888, "BigBen XBMiniPad Controller", 0, XTYPE_XBOX },

+22

drivers/input/keyboard/gpio_keys.c

··· 39 39 struct input_dev *input; 40 40 struct mutex disable_lock; 41 41 unsigned int n_buttons; 42 + int (*enable)(struct device *dev); 43 + void (*disable)(struct device *dev); 42 44 struct gpio_button_data data[0]; 43 45 }; 44 46 ··· 425 423 return error; 426 424 } 427 425 426 + static int gpio_keys_open(struct input_dev *input) 427 + { 428 + struct gpio_keys_drvdata *ddata = input_get_drvdata(input); 429 + 430 + return ddata->enable ? ddata->enable(input->dev.parent) : 0; 431 + } 432 + 433 + static void gpio_keys_close(struct input_dev *input) 434 + { 435 + struct gpio_keys_drvdata *ddata = input_get_drvdata(input); 436 + 437 + if (ddata->disable) 438 + ddata->disable(input->dev.parent); 439 + } 440 + 428 441 static int __devinit gpio_keys_probe(struct platform_device *pdev) 429 442 { 430 443 struct gpio_keys_platform_data *pdata = pdev->dev.platform_data; ··· 461 444 462 445 ddata->input = input; 463 446 ddata->n_buttons = pdata->nbuttons; 447 + ddata->enable = pdata->enable; 448 + ddata->disable = pdata->disable; 464 449 mutex_init(&ddata->disable_lock); 465 450 466 451 platform_set_drvdata(pdev, ddata); 452 + input_set_drvdata(input, ddata); 467 453 468 454 input->name = pdev->name; 469 455 input->phys = "gpio-keys/input0"; 470 456 input->dev.parent = &pdev->dev; 457 + input->open = gpio_keys_open; 458 + input->close = gpio_keys_close; 471 459 472 460 input->id.bustype = BUS_HOST; 473 461 input->id.vendor = 0x0001;

+12 -9

drivers/input/keyboard/hil_kbd.c

··· 232 232 if (absdev) { 233 233 val = lo + (hi << 8); 234 234 #ifdef TABLET_AUTOADJUST 235 - if (val < dev->absmin[ABS_X + i]) 236 - dev->absmin[ABS_X + i] = val; 237 - if (val > dev->absmax[ABS_X + i]) 238 - dev->absmax[ABS_X + i] = val; 235 + if (val < input_abs_min(dev, ABS_X + i)) 236 + input_abs_set_min(dev, ABS_X + i, val); 237 + if (val > input_abs_max(dev, ABS_X + i)) 238 + XXinput_abs_set_max(dev, ABS_X + i, val); 239 239 #endif 240 - if (i%3) val = dev->absmax[ABS_X + i] - val; 240 + if (i % 3) 241 + val = input_abs_max(dev, ABS_X + i) - val; 241 242 input_report_abs(dev, ABS_X + i, val); 242 243 } else { 243 - val = (int) (((int8_t)lo) | ((int8_t)hi << 8)); 244 + val = (int) (((int8_t) lo) | ((int8_t) hi << 8)); 244 245 if (i % 3) 245 246 val *= -1; 246 247 input_report_rel(dev, REL_X + i, val); ··· 388 387 389 388 #ifdef TABLET_AUTOADJUST 390 389 for (i = 0; i < ABS_MAX; i++) { 391 - int diff = input_dev->absmax[ABS_X + i] / 10; 392 - input_dev->absmin[ABS_X + i] += diff; 393 - input_dev->absmax[ABS_X + i] -= diff; 390 + int diff = input_abs_max(input_dev, ABS_X + i) / 10; 391 + input_abs_set_min(input_dev, ABS_X + i, 392 + input_abs_min(input_dev, ABS_X + i) + diff) 393 + XXinput_abs_set_max(input_dev, ABS_X + i, 394 + input_abs_max(input_dev, ABS_X + i) - diff) 394 395 } 395 396 #endif 396 397

-1

drivers/input/misc/adxl34x.c

··· 724 724 pdata = &ac->pdata; 725 725 726 726 ac->input = input_dev; 727 - ac->disabled = true; 728 727 ac->dev = dev; 729 728 ac->irq = irq; 730 729 ac->bops = bops;

+17 -12

drivers/input/misc/uinput.c

··· 304 304 if (!test_bit(cnt, dev->absbit)) 305 305 continue; 306 306 307 - if ((dev->absmax[cnt] <= dev->absmin[cnt])) { 307 + if (input_abs_get_max(dev, cnt) <= input_abs_get_min(dev, cnt)) { 308 308 printk(KERN_DEBUG 309 309 "%s: invalid abs[%02x] min:%d max:%d\n", 310 310 UINPUT_NAME, cnt, 311 - dev->absmin[cnt], dev->absmax[cnt]); 311 + input_abs_get_min(dev, cnt), 312 + input_abs_get_max(dev, cnt)); 312 313 retval = -EINVAL; 313 314 break; 314 315 } 315 316 316 - if (dev->absflat[cnt] > (dev->absmax[cnt] - dev->absmin[cnt])) { 317 + if (input_abs_get_flat(dev, cnt) > 318 + input_abs_get_max(dev, cnt) - input_abs_get_min(dev, cnt)) { 317 319 printk(KERN_DEBUG 318 - "%s: absflat[%02x] out of range: %d " 320 + "%s: abs_flat #%02x out of range: %d " 319 321 "(min:%d/max:%d)\n", 320 - UINPUT_NAME, cnt, dev->absflat[cnt], 321 - dev->absmin[cnt], dev->absmax[cnt]); 322 + UINPUT_NAME, cnt, 323 + input_abs_get_flat(dev, cnt), 324 + input_abs_get_min(dev, cnt), 325 + input_abs_get_max(dev, cnt)); 322 326 retval = -EINVAL; 323 327 break; 324 328 } ··· 347 343 struct uinput_user_dev *user_dev; 348 344 struct input_dev *dev; 349 345 char *name; 350 - int size; 346 + int i, size; 351 347 int retval; 352 348 353 349 if (count != sizeof(struct uinput_user_dev)) ··· 391 387 dev->id.product = user_dev->id.product; 392 388 dev->id.version = user_dev->id.version; 393 389 394 - size = sizeof(int) * ABS_CNT; 395 - memcpy(dev->absmax, user_dev->absmax, size); 396 - memcpy(dev->absmin, user_dev->absmin, size); 397 - memcpy(dev->absfuzz, user_dev->absfuzz, size); 398 - memcpy(dev->absflat, user_dev->absflat, size); 390 + for (i = 0; i < ABS_CNT; i++) { 391 + input_abs_set_max(dev, i, user_dev->absmax[i]); 392 + input_abs_set_min(dev, i, user_dev->absmin[i]); 393 + input_abs_set_fuzz(dev, i, user_dev->absfuzz[i]); 394 + input_abs_set_flat(dev, i, user_dev->absflat[i]); 395 + } 399 396 400 397 /* check if absmin/absmax/absfuzz/absflat are filled as 401 398 * told in Documentation/input/input-programming.txt */

+20 -11

drivers/input/mouse/elantech.c

··· 185 185 struct elantech_data *etd = psmouse->private; 186 186 unsigned char *packet = psmouse->packet; 187 187 int fingers; 188 - static int old_fingers; 189 188 190 189 if (etd->fw_version < 0x020000) { 191 190 /* ··· 202 203 } 203 204 204 205 if (etd->jumpy_cursor) { 205 - /* Discard packets that are likely to have bogus coordinates */ 206 - if (fingers > old_fingers) { 206 + if (fingers != 1) { 207 + etd->single_finger_reports = 0; 208 + } else if (etd->single_finger_reports < 2) { 209 + /* Discard first 2 reports of one finger, bogus */ 210 + etd->single_finger_reports++; 207 211 elantech_debug("discarding packet\n"); 208 - goto discard_packet_v1; 212 + return; 209 213 } 210 214 } 211 215 ··· 240 238 } 241 239 242 240 input_sync(dev); 243 - 244 - discard_packet_v1: 245 - old_fingers = fingers; 246 241 } 247 242 248 243 /* ··· 257 258 input_report_key(dev, BTN_TOUCH, fingers != 0); 258 259 259 260 switch (fingers) { 261 + case 3: 262 + /* 263 + * Same as one finger, except report of more than 3 fingers: 264 + * byte 3: n4 . w1 w0 . . . . 265 + */ 266 + if (packet[3] & 0x80) 267 + fingers = 4; 268 + /* pass through... */ 260 269 case 1: 261 270 /* 262 271 * byte 1: . . . . . x10 x9 x8 ··· 317 310 input_report_key(dev, BTN_TOOL_FINGER, fingers == 1); 318 311 input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2); 319 312 input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3); 313 + input_report_key(dev, BTN_TOOL_QUADTAP, fingers == 4); 320 314 input_report_key(dev, BTN_LEFT, packet[0] & 0x01); 321 315 input_report_key(dev, BTN_RIGHT, packet[0] & 0x02); 322 316 ··· 475 467 break; 476 468 477 469 case 2: 470 + __set_bit(BTN_TOOL_QUADTAP, dev->keybit); 478 471 input_set_abs_params(dev, ABS_X, ETP_XMIN_V2, ETP_XMAX_V2, 0, 0); 479 472 input_set_abs_params(dev, ABS_Y, ETP_YMIN_V2, ETP_YMAX_V2, 0, 0); 480 473 input_set_abs_params(dev, ABS_HAT0X, ETP_2FT_XMIN, ETP_2FT_XMAX, 0, 0); ··· 742 733 etd->capabilities = param[0]; 743 734 744 735 /* 745 - * This firmware seems to suffer from misreporting coordinates when 736 + * This firmware suffers from misreporting coordinates when 746 737 * a touch action starts causing the mouse cursor or scrolled page 747 738 * to jump. Enable a workaround. 748 739 */ 749 - if (etd->fw_version == 0x020022) { 750 - pr_info("firmware version 2.0.34 detected, enabling jumpy cursor workaround\n"); 751 - etd->jumpy_cursor = 1; 740 + if (etd->fw_version == 0x020022 || etd->fw_version == 0x020600) { 741 + pr_info("firmware version 2.0.34/2.6.0 detected, enabling jumpy cursor workaround\n"); 742 + etd->jumpy_cursor = true; 752 743 } 753 744 754 745 if (elantech_set_absolute_mode(psmouse)) {

+4 -3

drivers/input/mouse/elantech.h

··· 100 100 unsigned char reg_26; 101 101 unsigned char debug; 102 102 unsigned char capabilities; 103 - unsigned char paritycheck; 104 - unsigned char jumpy_cursor; 103 + bool paritycheck; 104 + bool jumpy_cursor; 105 105 unsigned char hw_version; 106 - unsigned int fw_version; 106 + unsigned int fw_version; 107 + unsigned int single_finger_reports; 107 108 unsigned char parity[256]; 108 109 }; 109 110

+2 -2

drivers/input/mouse/pc110pad.c

··· 145 145 pc110pad_dev->absbit[0] = BIT_MASK(ABS_X) | BIT_MASK(ABS_Y); 146 146 pc110pad_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); 147 147 148 - pc110pad_dev->absmax[ABS_X] = 0x1ff; 149 - pc110pad_dev->absmax[ABS_Y] = 0x0ff; 148 + input_abs_set_max(pc110pad_dev, ABS_X, 0x1ff); 149 + input_abs_set_max(pc110pad_dev, ABS_Y, 0x0ff); 150 150 151 151 pc110pad_dev->open = pc110pad_open; 152 152 pc110pad_dev->close = pc110pad_close;

+2 -2

drivers/input/mouse/synaptics.c

··· 635 635 __clear_bit(REL_X, dev->relbit); 636 636 __clear_bit(REL_Y, dev->relbit); 637 637 638 - dev->absres[ABS_X] = priv->x_res; 639 - dev->absres[ABS_Y] = priv->y_res; 638 + input_abs_set_res(dev, ABS_X, priv->x_res); 639 + input_abs_set_res(dev, ABS_Y, priv->y_res); 640 640 641 641 if (SYN_CAP_CLICKPAD(priv->ext_cap_0c)) { 642 642 /* Clickpads report only left button */

+26 -18

drivers/input/mousedev.c

··· 22 22 #include <linux/random.h> 23 23 #include <linux/major.h> 24 24 #include <linux/device.h> 25 + #include <linux/kernel.h> 25 26 #ifdef CONFIG_INPUT_MOUSEDEV_PSAUX 26 27 #include <linux/miscdevice.h> 27 28 #endif ··· 135 134 switch (code) { 136 135 137 136 case ABS_X: 137 + 138 138 fx(0) = value; 139 139 if (mousedev->touch && mousedev->pkt_count >= 2) { 140 - size = dev->absmax[ABS_X] - dev->absmin[ABS_X]; 140 + size = input_abs_get_min(dev, ABS_X) - 141 + input_abs_get_max(dev, ABS_X); 141 142 if (size == 0) 142 143 size = 256 * 2; 144 + 143 145 tmp = ((value - fx(2)) * 256 * FRACTION_DENOM) / size; 144 146 tmp += mousedev->frac_dx; 145 147 mousedev->packet.dx = tmp / FRACTION_DENOM; ··· 154 150 case ABS_Y: 155 151 fy(0) = value; 156 152 if (mousedev->touch && mousedev->pkt_count >= 2) { 157 - /* use X size to keep the same scale */ 158 - size = dev->absmax[ABS_X] - dev->absmin[ABS_X]; 153 + /* use X size for ABS_Y to keep the same scale */ 154 + size = input_abs_get_min(dev, ABS_X) - 155 + input_abs_get_max(dev, ABS_X); 159 156 if (size == 0) 160 157 size = 256 * 2; 158 + 161 159 tmp = -((value - fy(2)) * 256 * FRACTION_DENOM) / size; 162 160 tmp += mousedev->frac_dy; 163 161 mousedev->packet.dy = tmp / FRACTION_DENOM; ··· 173 167 static void mousedev_abs_event(struct input_dev *dev, struct mousedev *mousedev, 174 168 unsigned int code, int value) 175 169 { 176 - int size; 170 + int min, max, size; 177 171 178 172 switch (code) { 179 173 180 174 case ABS_X: 181 - size = dev->absmax[ABS_X] - dev->absmin[ABS_X]; 175 + min = input_abs_get_min(dev, ABS_X); 176 + max = input_abs_get_max(dev, ABS_X); 177 + 178 + size = max - min; 182 179 if (size == 0) 183 180 size = xres ? : 1; 184 - if (value > dev->absmax[ABS_X]) 185 - value = dev->absmax[ABS_X]; 186 - if (value < dev->absmin[ABS_X]) 187 - value = dev->absmin[ABS_X]; 188 - mousedev->packet.x = 189 - ((value - dev->absmin[ABS_X]) * xres) / size; 181 + 182 + clamp(value, min, max); 183 + 184 + mousedev->packet.x = ((value - min) * xres) / size; 190 185 mousedev->packet.abs_event = 1; 191 186 break; 192 187 193 188 case ABS_Y: 194 - size = dev->absmax[ABS_Y] - dev->absmin[ABS_Y]; 189 + min = input_abs_get_min(dev, ABS_Y); 190 + max = input_abs_get_max(dev, ABS_Y); 191 + 192 + size = max - min; 195 193 if (size == 0) 196 194 size = yres ? : 1; 197 - if (value > dev->absmax[ABS_Y]) 198 - value = dev->absmax[ABS_Y]; 199 - if (value < dev->absmin[ABS_Y]) 200 - value = dev->absmin[ABS_Y]; 201 - mousedev->packet.y = yres - 202 - ((value - dev->absmin[ABS_Y]) * yres) / size; 195 + 196 + clamp(value, min, max); 197 + 198 + mousedev->packet.y = yres - ((value - min) * yres) / size; 203 199 mousedev->packet.abs_event = 1; 204 200 break; 205 201 }

+6 -9

drivers/input/tablet/aiptek.c

··· 987 987 /* Query getXextension */ 988 988 if ((ret = aiptek_query(aiptek, 0x01, 0x00)) < 0) 989 989 return ret; 990 - aiptek->inputdev->absmin[ABS_X] = 0; 991 - aiptek->inputdev->absmax[ABS_X] = ret - 1; 990 + input_set_abs_params(aiptek->inputdev, ABS_X, 0, ret - 1, 0, 0); 992 991 993 992 /* Query getYextension */ 994 993 if ((ret = aiptek_query(aiptek, 0x01, 0x01)) < 0) 995 994 return ret; 996 - aiptek->inputdev->absmin[ABS_Y] = 0; 997 - aiptek->inputdev->absmax[ABS_Y] = ret - 1; 995 + input_set_abs_params(aiptek->inputdev, ABS_Y, 0, ret - 1, 0, 0); 998 996 999 997 /* Query getPressureLevels */ 1000 998 if ((ret = aiptek_query(aiptek, 0x08, 0x00)) < 0) 1001 999 return ret; 1002 - aiptek->inputdev->absmin[ABS_PRESSURE] = 0; 1003 - aiptek->inputdev->absmax[ABS_PRESSURE] = ret - 1; 1000 + input_set_abs_params(aiptek->inputdev, ABS_PRESSURE, 0, ret - 1, 0, 0); 1004 1001 1005 1002 /* Depending on whether we are in absolute or relative mode, we will 1006 1003 * do a switchToTablet(absolute) or switchToMouse(relative) command. ··· 1051 1054 struct aiptek *aiptek = dev_get_drvdata(dev); 1052 1055 1053 1056 return snprintf(buf, PAGE_SIZE, "%dx%d\n", 1054 - aiptek->inputdev->absmax[ABS_X] + 1, 1055 - aiptek->inputdev->absmax[ABS_Y] + 1); 1057 + input_abs_get_max(aiptek->inputdev, ABS_X) + 1, 1058 + input_abs_get_max(aiptek->inputdev, ABS_Y) + 1); 1056 1059 } 1057 1060 1058 1061 /* These structs define the sysfs files, param #1 is the name of the ··· 1840 1843 for (i = 0; i < ARRAY_SIZE(speeds); ++i) { 1841 1844 aiptek->curSetting.programmableDelay = speeds[i]; 1842 1845 (void)aiptek_program_tablet(aiptek); 1843 - if (aiptek->inputdev->absmax[ABS_X] > 0) { 1846 + if (input_abs_get_max(aiptek->inputdev, ABS_X) > 0) { 1844 1847 dev_info(&intf->dev, 1845 1848 "Aiptek using %d ms programming speed\n", 1846 1849 aiptek->curSetting.programmableDelay);

+2 -2

drivers/input/tablet/wacom_wac.c

··· 687 687 * protocol. 688 688 */ 689 689 if (wacom->last_finger != finger) { 690 - if (x == input->abs[ABS_X]) 690 + if (x == input_abs_get_val(input, ABS_X)) 691 691 x++; 692 692 693 - if (y == input->abs[ABS_Y]) 693 + if (y == input_abs_get_val(input, ABS_Y)) 694 694 y++; 695 695 } 696 696

+3 -3

drivers/input/touchscreen/cy8ctmg110_ts.c

··· 75 75 unsigned char len, unsigned char *value) 76 76 { 77 77 struct i2c_client *client = tsc->client; 78 - unsigned int ret; 78 + int ret; 79 79 unsigned char i2c_data[6]; 80 80 81 81 BUG_ON(len > 5); ··· 86 86 ret = i2c_master_send(client, i2c_data, len + 1); 87 87 if (ret != 1) { 88 88 dev_err(&client->dev, "i2c write data cmd failed\n"); 89 - return ret; 89 + return ret ? ret : -EIO; 90 90 } 91 91 92 92 return 0; ··· 96 96 unsigned char *data, unsigned char len, unsigned char cmd) 97 97 { 98 98 struct i2c_client *client = tsc->client; 99 - unsigned int ret; 99 + int ret; 100 100 struct i2c_msg msg[2] = { 101 101 /* first write slave position to i2c devices */ 102 102 { client->addr, 0, 1, &cmd },

+2

include/linux/gpio_keys.h

··· 17 17 struct gpio_keys_button *buttons; 18 18 int nbuttons; 19 19 unsigned int rep:1; /* enable input subsystem auto repeat */ 20 + int (*enable)(struct device *dev); 21 + void (*disable)(struct device *dev); 20 22 }; 21 23 22 24 #endif

+30 -21

include/linux/input.h

··· 776 776 #define REP_DELAY 0x00 777 777 #define REP_PERIOD 0x01 778 778 #define REP_MAX 0x01 779 + #define REP_CNT (REP_MAX+1) 779 780 780 781 /* 781 782 * Sounds ··· 1100 1099 * @repeat_key: stores key code of the last key pressed; used to implement 1101 1100 * software autorepeat 1102 1101 * @timer: timer for software autorepeat 1103 - * @abs: current values for reports from absolute axes 1104 1102 * @rep: current values for autorepeat parameters (delay, rate) 1105 1103 * @mt: pointer to array of struct input_mt_slot holding current values 1106 1104 * of tracked contacts 1107 1105 * @mtsize: number of MT slots the device uses 1108 1106 * @slot: MT slot currently being transmitted 1107 + * @absinfo: array of &struct absinfo elements holding information 1108 + * about absolute axes (current value, min, max, flat, fuzz, 1109 + * resolution) 1109 1110 * @key: reflects current state of device's keys/buttons 1110 1111 * @led: reflects current state of device's LEDs 1111 1112 * @snd: reflects current state of sound effects 1112 1113 * @sw: reflects current state of device's switches 1113 - * @absmax: maximum values for events coming from absolute axes 1114 - * @absmin: minimum values for events coming from absolute axes 1115 - * @absfuzz: describes noisiness for axes 1116 - * @absflat: size of the center flat position (used by joydev) 1117 - * @absres: resolution used for events coming form absolute axes 1118 1114 * @open: this method is called when the very first user calls 1119 1115 * input_open_device(). The driver must prepare the device 1120 1116 * to start generating events (start polling thread, ··· 1178 1180 unsigned int repeat_key; 1179 1181 struct timer_list timer; 1180 1182 1181 - int abs[ABS_CNT]; 1182 - int rep[REP_MAX + 1]; 1183 + int rep[REP_CNT]; 1183 1184 1184 1185 struct input_mt_slot *mt; 1185 1186 int mtsize; 1186 1187 int slot; 1187 1188 1189 + struct input_absinfo *absinfo; 1190 + 1188 1191 unsigned long key[BITS_TO_LONGS(KEY_CNT)]; 1189 1192 unsigned long led[BITS_TO_LONGS(LED_CNT)]; 1190 1193 unsigned long snd[BITS_TO_LONGS(SND_CNT)]; 1191 1194 unsigned long sw[BITS_TO_LONGS(SW_CNT)]; 1192 - 1193 - int absmax[ABS_CNT]; 1194 - int absmin[ABS_CNT]; 1195 - int absfuzz[ABS_CNT]; 1196 - int absflat[ABS_CNT]; 1197 - int absres[ABS_CNT]; 1198 1195 1199 1196 int (*open)(struct input_dev *dev); 1200 1197 void (*close)(struct input_dev *dev); ··· 1452 1459 dev->hint_events_per_packet = n_events; 1453 1460 } 1454 1461 1455 - static inline void input_set_abs_params(struct input_dev *dev, int axis, int min, int max, int fuzz, int flat) 1456 - { 1457 - dev->absmin[axis] = min; 1458 - dev->absmax[axis] = max; 1459 - dev->absfuzz[axis] = fuzz; 1460 - dev->absflat[axis] = flat; 1462 + void input_alloc_absinfo(struct input_dev *dev); 1463 + void input_set_abs_params(struct input_dev *dev, unsigned int axis, 1464 + int min, int max, int fuzz, int flat); 1461 1465 1462 - dev->absbit[BIT_WORD(axis)] |= BIT_MASK(axis); 1466 + #define INPUT_GENERATE_ABS_ACCESSORS(_suffix, _item) \ 1467 + static inline int input_abs_get_##_suffix(struct input_dev *dev, \ 1468 + unsigned int axis) \ 1469 + { \ 1470 + return dev->absinfo ? dev->absinfo[axis]._item : 0; \ 1471 + } \ 1472 + \ 1473 + static inline void input_abs_set_##_suffix(struct input_dev *dev, \ 1474 + unsigned int axis, int val) \ 1475 + { \ 1476 + input_alloc_absinfo(dev); \ 1477 + if (dev->absinfo) \ 1478 + dev->absinfo[axis]._item = val; \ 1463 1479 } 1480 + 1481 + INPUT_GENERATE_ABS_ACCESSORS(val, value) 1482 + INPUT_GENERATE_ABS_ACCESSORS(min, minimum) 1483 + INPUT_GENERATE_ABS_ACCESSORS(max, maximum) 1484 + INPUT_GENERATE_ABS_ACCESSORS(fuzz, fuzz) 1485 + INPUT_GENERATE_ABS_ACCESSORS(flat, flat) 1486 + INPUT_GENERATE_ABS_ACCESSORS(res, resolution) 1464 1487 1465 1488 int input_get_keycode(struct input_dev *dev, 1466 1489 unsigned int scancode, unsigned int *keycode);