Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit cc573b97 authored by Lv Zheng's avatar Lv Zheng Committed by Rafael J. Wysocki
Browse files

ACPICA: Utilities: Add power of two rounding support 

ACPICA commit cbb0294649cbd7e8bd6107e4329461a6a7a0d967

This patch adds power of two rounding support up to 32 bits.

The result of the shift operations rearching to the boundary of the cpu
word is unpredicatable, so 64-bit roundings are not supported in order to
make sure no rounded shift-overs.

This support may not be performance friendly, so the APIs might be
overridden by the hosts implementations with ACPI_USE_NATIVE_BIT_FINDER
defined.

Link: https://github.com/acpica/acpica/commit/cbb02946


Signed-off-by: default avatarLv Zheng <lv.zheng@intel.com>
Signed-off-by: default avatarBob Moore <robert.moore@intel.com>
Signed-off-by: default avatarRafael J. Wysocki <rafael.j.wysocki@intel.com>
parent dc4c7376

drivers/acpi/acpica/acmacros.h

+60 −0
Original line number Original line Diff line number Diff line
@@ -262,6 +262,66 @@ 




/* Generic (power-of-two) rounding */

/* Generic (power-of-two) rounding */





#ifndef ACPI_USE_NATIVE_BIT_FINDER



#define __ACPI_FIND_LAST_BIT_2(a, r)        ((((u8)  (a)) & 0x02) ? (r)+1 : (r))

#define __ACPI_FIND_LAST_BIT_4(a, r)        ((((u8)  (a)) & 0x0C) ? \

											 __ACPI_FIND_LAST_BIT_2  ((a)>>2,  (r)+2) : \

											 __ACPI_FIND_LAST_BIT_2  ((a), (r)))

#define __ACPI_FIND_LAST_BIT_8(a, r)        ((((u8)  (a)) & 0xF0) ? \

											 __ACPI_FIND_LAST_BIT_4  ((a)>>4,  (r)+4) : \

											 __ACPI_FIND_LAST_BIT_4  ((a), (r)))

#define __ACPI_FIND_LAST_BIT_16(a, r)       ((((u16) (a)) & 0xFF00) ? \

											 __ACPI_FIND_LAST_BIT_8  ((a)>>8,  (r)+8) : \

											 __ACPI_FIND_LAST_BIT_8  ((a), (r)))

#define __ACPI_FIND_LAST_BIT_32(a, r)       ((((u32) (a)) & 0xFFFF0000) ? \

											 __ACPI_FIND_LAST_BIT_16 ((a)>>16, (r)+16) : \

											 __ACPI_FIND_LAST_BIT_16 ((a), (r)))

#define __ACPI_FIND_LAST_BIT_64(a, r)       ((((u64) (a)) & 0xFFFFFFFF00000000) ? \

											 __ACPI_FIND_LAST_BIT_32 ((a)>>32, (r)+32) : \

											 __ACPI_FIND_LAST_BIT_32 ((a), (r)))



#define ACPI_FIND_LAST_BIT_8(a)             ((a) ? __ACPI_FIND_LAST_BIT_8 (a, 1) : 0)

#define ACPI_FIND_LAST_BIT_16(a)            ((a) ? __ACPI_FIND_LAST_BIT_16 (a, 1) : 0)

#define ACPI_FIND_LAST_BIT_32(a)            ((a) ? __ACPI_FIND_LAST_BIT_32 (a, 1) : 0)

#define ACPI_FIND_LAST_BIT_64(a)            ((a) ? __ACPI_FIND_LAST_BIT_64 (a, 1) : 0)



#define __ACPI_FIND_FIRST_BIT_2(a, r)       ((((u8) (a)) & 0x01) ? (r) : (r)+1)

#define __ACPI_FIND_FIRST_BIT_4(a, r)       ((((u8) (a)) & 0x03) ? \

											 __ACPI_FIND_FIRST_BIT_2  ((a), (r)) : \

											 __ACPI_FIND_FIRST_BIT_2  ((a)>>2, (r)+2))

#define __ACPI_FIND_FIRST_BIT_8(a, r)       ((((u8) (a)) & 0x0F) ? \

											 __ACPI_FIND_FIRST_BIT_4  ((a), (r)) : \

											 __ACPI_FIND_FIRST_BIT_4  ((a)>>4, (r)+4))

#define __ACPI_FIND_FIRST_BIT_16(a, r)      ((((u16) (a)) & 0x00FF) ? \

											 __ACPI_FIND_FIRST_BIT_8  ((a), (r)) : \

											 __ACPI_FIND_FIRST_BIT_8  ((a)>>8, (r)+8))

#define __ACPI_FIND_FIRST_BIT_32(a, r)      ((((u32) (a)) & 0x0000FFFF) ? \

											 __ACPI_FIND_FIRST_BIT_16 ((a), (r)) : \

											 __ACPI_FIND_FIRST_BIT_16 ((a)>>16, (r)+16))

#define __ACPI_FIND_FIRST_BIT_64(a, r)      ((((u64) (a)) & 0x00000000FFFFFFFF) ? \

											 __ACPI_FIND_FIRST_BIT_32 ((a), (r)) : \

											 __ACPI_FIND_FIRST_BIT_32 ((a)>>32, (r)+32))



#define ACPI_FIND_FIRST_BIT_8(a)            ((a) ? __ACPI_FIND_FIRST_BIT_8 (a, 1) : 0)

#define ACPI_FIND_FIRST_BIT_16(a)           ((a) ? __ACPI_FIND_FIRST_BIT_16 (a, 1) : 0)

#define ACPI_FIND_FIRST_BIT_32(a)           ((a) ? __ACPI_FIND_FIRST_BIT_32 (a, 1) : 0)

#define ACPI_FIND_FIRST_BIT_64(a)           ((a) ? __ACPI_FIND_FIRST_BIT_64 (a, 1) : 0)



#endif				/* ACPI_USE_NATIVE_BIT_FINDER */



#define ACPI_ROUND_UP_POWER_OF_TWO_8(a)     ((u8) \

											(((u16) 1) <<  ACPI_FIND_LAST_BIT_8  ((a)  - 1)))

#define ACPI_ROUND_DOWN_POWER_OF_TWO_8(a)   ((u8) \

											(((u16) 1) << (ACPI_FIND_LAST_BIT_8  ((a)) - 1)))

#define ACPI_ROUND_UP_POWER_OF_TWO_16(a)    ((u16) \

											(((u32) 1) <<  ACPI_FIND_LAST_BIT_16 ((a)  - 1)))

#define ACPI_ROUND_DOWN_POWER_OF_TWO_16(a)  ((u16) \

											(((u32) 1) << (ACPI_FIND_LAST_BIT_16 ((a)) - 1)))

#define ACPI_ROUND_UP_POWER_OF_TWO_32(a)    ((u32) \

											(((u64) 1) <<  ACPI_FIND_LAST_BIT_32 ((a)  - 1)))

#define ACPI_ROUND_DOWN_POWER_OF_TWO_32(a)  ((u32) \

											(((u64) 1) << (ACPI_FIND_LAST_BIT_32 ((a)) - 1)))

#define ACPI_IS_ALIGNED(a, s)               (((a) & ((s) - 1)) == 0)

#define ACPI_IS_ALIGNED(a, s)               (((a) & ((s) - 1)) == 0)

#define ACPI_IS_POWER_OF_TWO(a)             ACPI_IS_ALIGNED(a, a)

#define ACPI_IS_POWER_OF_TWO(a)             ACPI_IS_ALIGNED(a, a)