HID: simplify implement() a bit

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;

	}

	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);

	} 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;

		}

	}

	__implement(report, offset, n, value);

}