1 files changed, 15 insertions, 18 deletions

diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index bdb8cc89cacc..9985c0ab7c7f 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -1129,49 +1129,46 @@ EXPORT_SYMBOL_GPL(hid_field_extract);
 static void __implement(u8 *report, unsigned offset, int n, u32 value)
 {
         unsigned int idx = offset / 8;
-        unsigned int size = offset + n;
         unsigned int bit_shift = offset % 8;
         int bits_to_set = 8 - bit_shift;
-        u8 bit_mask = 0xff << bit_shift;
 
         while (n - bits_to_set >= 0) {
-                report[idx] &= ~bit_mask;
+                report[idx] &= ~(0xff << bit_shift);
                 report[idx] |= value << bit_shift;
                 value >>= bits_to_set;
                 n -= bits_to_set;
                 bits_to_set = 8;
-                bit_mask = 0xff;
                 bit_shift = 0;
                 idx++;
         }
 
         /* last nibble */
         if (n) {
-                if (size % 8)
-                        bit_mask &= (1U << (size % 8)) - 1;
-                report[idx] &= ~bit_mask;
-                report[idx] |= (value << bit_shift) & bit_mask;
+                u8 bit_mask = ((1U << n) - 1);
+                report[idx] &= ~(bit_mask << bit_shift);
+                report[idx] |= value << bit_shift;
         }
 }
 
 static void implement(const struct hid_device *hid, u8 *report,
                       unsigned offset, unsigned n, u32 value)
 {
-        u64 m;
-
-        if (n > 32) {
+        if (unlikely(n > 32)) {
                 hid_warn(hid, "%s() called with n (%d) > 32! (%s)\n",
                          __func__, n, current->comm);
                 n = 32;
+        } else if (n < 32) {
+                u32 m = (1U << n) - 1;
+
+                if (unlikely(value > m)) {
+                        hid_warn(hid,
+                                 "%s() called with too large value %d (n: %d)! (%s)\n",
+                                 __func__, value, n, current->comm);
+                        WARN_ON(1);
+                        value &= m;
+                }
         }
 
-        m = (1ULL << n) - 1;
-        if (value > m)
-                hid_warn(hid, "%s() called with too large value %d! (%s)\n",
-                         __func__, value, current->comm);
-        WARN_ON(value > m);
-        value &= m;
-
         __implement(report, offset, n, value);
 }