HID: pidff: Use macros instead of hardcoded min/max values for shorts

Makes it obvious these magic values ARE in fact derived from min and
max values for s16 and u16

Signed-off-by: Tomasz Pakuła <tomasz.pakula.oficjalny@gmail.com>
Reviewed-by: Michał Kopeć <michal@nozomi.space>
Reviewed-by: Paul Dino Jones <paul@spacefreak18.xyz>
Tested-by: Paul Dino Jones <paul@spacefreak18.xyz>
Tested-by: Cristóferson Bueno <cbueno81@gmail.com>
Tested-by: Pablo Cisneros <patchkez@protonmail.com>
Signed-off-by: Jiri Kosina <jkosina@suse.com>

diff --git a/drivers/hid/usbhid/hid-pidff.c b/drivers/hid/usbhid/hid-pidff.c
index 8083eb7684e5e40a989ed3845c381af586a1df09..b21e844f5f3a3179993fc6db249a3113726d1ba9 100644 (file)
--- a/drivers/hid/usbhid/hid-pidff.c
+++ b/drivers/hid/usbhid/hid-pidff.c
@@ -21,7 +21,7 @@
 
 
 #define        PID_EFFECTS_MAX         64
-#define        PID_INFINITE            0xffff
+#define        PID_INFINITE            U16_MAX
 
 /* Linux Force Feedback API uses miliseconds as time unit */
 #define FF_TIME_EXPONENT       -3
@@ -226,12 +226,12 @@ static int pidff_rescale(int i, int max, struct hid_field *field)
 }
 
 /*
- * Scale a signed value in range -0x8000..0x7fff for the given field
+ * Scale a signed value in range S16_MIN..S16_MAX for the given field
  */
 static int pidff_rescale_signed(int i, struct hid_field *field)
 {
-       if (i > 0) return i * field->logical_maximum / 0x7fff;
-       if (i < 0) return i * field->logical_minimum / -0x8000;
+       if (i > 0) return i * field->logical_maximum / S16_MAX;
+       if (i < 0) return i * field->logical_minimum / S16_MIN;
        return 0;
 }
 
@@ -255,7 +255,7 @@ static u32 pidff_rescale_time(u16 time, struct hid_field *field)
 
 static void pidff_set(struct pidff_usage *usage, u16 value)
 {
-       usage->value[0] = pidff_rescale(value, 0xffff, usage->field);
+       usage->value[0] = pidff_rescale(value, U16_MAX, usage->field);
        pr_debug("calculated from %d to %d\n", value, usage->value[0]);
 }
 
@@ -266,10 +266,10 @@ static void pidff_set_signed(struct pidff_usage *usage, s16 value)
        else {
                if (value < 0)
                        usage->value[0] =
-                           pidff_rescale(-value, 0x8000, usage->field);
+                           pidff_rescale(-value, -S16_MIN, usage->field);
                else
                        usage->value[0] =
-                           pidff_rescale(value, 0x7fff, usage->field);
+                           pidff_rescale(value, S16_MAX, usage->field);
        }
        pr_debug("calculated from %d to %d\n", value, usage->value[0]);
 }
@@ -306,11 +306,11 @@ static void pidff_set_envelope_report(struct pidff_device *pidff,
 
        pidff->set_envelope[PID_ATTACK_LEVEL].value[0] =
            pidff_rescale(envelope->attack_level >
-                         0x7fff ? 0x7fff : envelope->attack_level, 0x7fff,
+                         S16_MAX ? S16_MAX : envelope->attack_level, S16_MAX,
                          pidff->set_envelope[PID_ATTACK_LEVEL].field);
        pidff->set_envelope[PID_FADE_LEVEL].value[0] =
            pidff_rescale(envelope->fade_level >
-                         0x7fff ? 0x7fff : envelope->fade_level, 0x7fff,
+                         S16_MAX ? S16_MAX : envelope->fade_level, S16_MAX,
                          pidff->set_envelope[PID_FADE_LEVEL].field);
 
        pidff_set_time(&pidff->set_envelope[PID_ATTACK_TIME],
@@ -399,7 +399,7 @@ static void pidff_set_effect_report(struct pidff_device *pidff,
        pidff->effect_direction->value[0] = pidff_rescale(
                pidff->quirks & HID_PIDFF_QUIRK_FIX_WHEEL_DIRECTION ?
                PIDFF_FIXED_WHEEL_DIRECTION : effect->direction,
-               0xffff, pidff->effect_direction);
+               U16_MAX, pidff->effect_direction);
 
        /* Omit setting delay field if it's missing */
        if (!(pidff->quirks & HID_PIDFF_QUIRK_MISSING_DELAY))
@@ -1366,7 +1366,7 @@ static int pidff_check_autocenter(struct pidff_device *pidff,
 
        if (pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0] ==
            pidff->block_load[PID_EFFECT_BLOCK_INDEX].field->logical_minimum + 1) {
-               pidff_autocenter(pidff, 0xffff);
+               pidff_autocenter(pidff, U16_MAX);
                set_bit(FF_AUTOCENTER, dev->ffbit);
        } else {
                hid_notice(pidff->hid,
@@ -1424,7 +1424,7 @@ int hid_pidff_init_with_quirks(struct hid_device *hid, u32 initial_quirks)
        if (error)
                goto fail;
 
-       pidff_set_gain_report(pidff, 0xffff);
+       pidff_set_gain_report(pidff, U16_MAX);
        error = pidff_check_autocenter(pidff, dev);
        if (error)
                goto fail;