HID: pidff: clang-format pass

Signed-off-by: Tomasz Pakuła <tomasz.pakula.oficjalny@gmail.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 7f4c1186a44d4b5b7f660d579186983322462b17..50a8924edfcc1138f853c2cef762d90aa407bdf8 100644 (file)
--- a/drivers/hid/usbhid/hid-pidff.c
+++ b/drivers/hid/usbhid/hid-pidff.c
@@ -9,12 +9,11 @@
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
 #include "hid-pidff.h"
+#include <linux/hid.h>
 #include <linux/input.h>
+#include <linux/minmax.h>
 #include <linux/slab.h>
 #include <linux/usb.h>
-#include <linux/hid.h>
-#include <linux/minmax.h>
-
 
 #define        PID_EFFECTS_MAX         64
 #define        PID_INFINITE            U16_MAX
@@ -321,7 +320,7 @@ static s32 pidff_clamp(s32 i, struct hid_field *field)
 static int pidff_rescale(int i, int max, struct hid_field *field)
 {
        return i * (field->logical_maximum - field->logical_minimum) / max +
-               field->logical_minimum;
+              field->logical_minimum;
 }
 
 /*
@@ -367,18 +366,18 @@ static void pidff_set_signed(struct pidff_usage *usage, s16 value)
        else {
                if (value < 0)
                        usage->value[0] =
-                           pidff_rescale(-value, -S16_MIN, usage->field);
+                               pidff_rescale(-value, -S16_MIN, usage->field);
                else
                        usage->value[0] =
-                           pidff_rescale(value, S16_MAX, usage->field);
+                               pidff_rescale(value, S16_MAX, usage->field);
        }
        pr_debug("calculated from %d to %d\n", value, usage->value[0]);
 }
 
 static void pidff_set_time(struct pidff_usage *usage, u16 time)
 {
-       usage->value[0] = pidff_clamp(
-               pidff_rescale_time(time, usage->field), usage->field);
+       usage->value[0] = pidff_clamp(pidff_rescale_time(time, usage->field),
+                                     usage->field);
 }
 
 static void pidff_set_duration(struct pidff_usage *usage, u16 duration)
@@ -516,11 +515,11 @@ static void pidff_set_effect_report(struct pidff_device *pidff,
                pidff->create_new_effect_type->value[0];
 
        pidff_set_duration(&pidff->set_effect[PID_DURATION],
-               effect->replay.length);
+                          effect->replay.length);
 
        pidff->set_effect[PID_TRIGGER_BUTTON].value[0] = effect->trigger.button;
        pidff_set_time(&pidff->set_effect[PID_TRIGGER_REPEAT_INT],
-                       effect->trigger.interval);
+                      effect->trigger.interval);
        pidff->set_effect[PID_GAIN].value[0] =
                pidff->set_effect[PID_GAIN].field->logical_maximum;
 
@@ -529,10 +528,10 @@ static void pidff_set_effect_report(struct pidff_device *pidff,
        /* Omit setting delay field if it's missing */
        if (!(pidff->quirks & HID_PIDFF_QUIRK_MISSING_DELAY))
                pidff_set_time(&pidff->set_effect[PID_START_DELAY],
-                               effect->replay.delay);
+                              effect->replay.delay);
 
        hid_hw_request(pidff->hid, pidff->reports[PID_SET_EFFECT],
-                       HID_REQ_SET_REPORT);
+                      HID_REQ_SET_REPORT);
 }
 
 /*
@@ -562,10 +561,10 @@ static void pidff_set_periodic_report(struct pidff_device *pidff,
                         effect->u.periodic.offset);
        pidff_set(&pidff->set_periodic[PID_PHASE], effect->u.periodic.phase);
        pidff_set_time(&pidff->set_periodic[PID_PERIOD],
-                       effect->u.periodic.period);
+                      effect->u.periodic.period);
 
        hid_hw_request(pidff->hid, pidff->reports[PID_SET_PERIODIC],
-                       HID_REQ_SET_REPORT);
+                      HID_REQ_SET_REPORT);
 }
 
 /*
@@ -612,7 +611,7 @@ static void pidff_set_condition_report(struct pidff_device *pidff,
                pidff_set(&pidff->set_condition[PID_DEAD_BAND],
                          effect->u.condition[i].deadband);
                hid_hw_request(pidff->hid, pidff->reports[PID_SET_CONDITION],
-                               HID_REQ_SET_REPORT);
+                              HID_REQ_SET_REPORT);
        }
 }
 
@@ -675,7 +674,7 @@ static void pidff_set_gain_report(struct pidff_device *pidff, u16 gain)
 
        pidff_set(&pidff->device_gain[PID_DEVICE_GAIN_FIELD], gain);
        hid_hw_request(pidff->hid, pidff->reports[PID_DEVICE_GAIN],
-                       HID_REQ_SET_REPORT);
+                      HID_REQ_SET_REPORT);
 }
 
 /*
@@ -761,21 +760,19 @@ static void pidff_fetch_pool(struct pidff_device *pidff)
  */
 static int pidff_request_effect_upload(struct pidff_device *pidff, int efnum)
 {
-       int j;
-
        pidff->create_new_effect_type->value[0] = efnum;
        hid_hw_request(pidff->hid, pidff->reports[PID_CREATE_NEW_EFFECT],
-                       HID_REQ_SET_REPORT);
+                      HID_REQ_SET_REPORT);
        hid_dbg(pidff->hid, "create_new_effect sent, type: %d\n", efnum);
 
        pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0] = 0;
        pidff->block_load_status->value[0] = 0;
        hid_hw_wait(pidff->hid);
 
-       for (j = 0; j < 60; j++) {
+       for (int i = 0; i < 60; i++) {
                hid_dbg(pidff->hid, "pid_block_load requested\n");
                hid_hw_request(pidff->hid, pidff->reports[PID_BLOCK_LOAD],
-                               HID_REQ_GET_REPORT);
+                              HID_REQ_GET_REPORT);
                hid_hw_wait(pidff->hid);
                if (pidff->block_load_status->value[0] ==
                    pidff->status_id[PID_BLOCK_LOAD_SUCCESS]) {
@@ -857,8 +854,8 @@ static int pidff_erase_effect(struct input_dev *dev, int effect_id)
        struct pidff_device *pidff = dev->ff->private;
        int pid_id = pidff->pid_id[effect_id];
 
-       hid_dbg(pidff->hid, "starting to erase %d/%d\n",
-               effect_id, pidff->pid_id[effect_id]);
+       hid_dbg(pidff->hid, "starting to erase %d/%d\n", effect_id,
+               pidff->pid_id[effect_id]);
 
        /*
         * Wait for the queue to clear. We do not want
@@ -978,7 +975,7 @@ static void pidff_autocenter(struct pidff_device *pidff, u16 magnitude)
                pidff->set_effect[PID_START_DELAY].value[0] = 0;
 
        hid_hw_request(pidff->hid, pidff->reports[PID_SET_EFFECT],
-                       HID_REQ_SET_REPORT);
+                      HID_REQ_SET_REPORT);
 }
 
 /*
@@ -1269,7 +1266,7 @@ static int pidff_find_special_fields(struct pidff_device *pidff)
 
        if (PIDFF_FIND_SPECIAL_KEYS(status_id, block_load_status,
                                    block_load_status) !=
-                       ARRAY_SIZE(pidff_block_load_status)) {
+           ARRAY_SIZE(pidff_block_load_status)) {
                hid_err(pidff->hid,
                        "block load status identifiers not found\n");
                return -1;
@@ -1277,7 +1274,7 @@ static int pidff_find_special_fields(struct pidff_device *pidff)
 
        if (PIDFF_FIND_SPECIAL_KEYS(operation_id, effect_operation_status,
                                    effect_operation_status) !=
-                       ARRAY_SIZE(pidff_effect_operation_status)) {
+           ARRAY_SIZE(pidff_effect_operation_status)) {
                hid_err(pidff->hid, "effect operation identifiers not found\n");
                return -1;
        }
@@ -1482,8 +1479,8 @@ static int pidff_check_autocenter(struct pidff_device *pidff,
 int hid_pidff_init_with_quirks(struct hid_device *hid, u32 initial_quirks)
 {
        struct pidff_device *pidff;
-       struct hid_input *hidinput = list_entry(hid->inputs.next,
-                                               struct hid_input, list);
+       struct hid_input *hidinput =
+               list_entry(hid->inputs.next, struct hid_input, list);
        struct input_dev *dev = hidinput->input;
        struct ff_device *ff;
        int max_effects;
@@ -1570,7 +1567,7 @@ int hid_pidff_init_with_quirks(struct hid_device *hid, u32 initial_quirks)
 
        return 0;
 
- fail:
+fail:
        hid_device_io_stop(hid);
 
        kfree(pidff);