|  | 
|  | 1 | +/* | 
|  | 2 | + * SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD | 
|  | 3 | + * | 
|  | 4 | + * SPDX-License-Identifier: Apache-2.0 OR MIT | 
|  | 5 | + */ | 
|  | 6 | + | 
|  | 7 | +#pragma once | 
|  | 8 | + | 
|  | 9 | +#define ETS_UNCACHED_ADDR(addr) (addr) | 
|  | 10 | +#define ETS_CACHED_ADDR(addr) (addr) | 
|  | 11 | + | 
|  | 12 | +//write value to register | 
|  | 13 | +#define REG_WRITE(_r, _v)  do {                                                                                        \ | 
|  | 14 | +            (*(volatile uint32_t *)(_r)) = (_v);                                                                       \ | 
|  | 15 | +        } while(0) | 
|  | 16 | + | 
|  | 17 | +//read value from register | 
|  | 18 | +#define REG_READ(_r) ({                                                                                                \ | 
|  | 19 | +            (*(volatile uint32_t *)(_r));                                                                              \ | 
|  | 20 | +        }) | 
|  | 21 | + | 
|  | 22 | +//get bit or get bits from register | 
|  | 23 | +#define REG_GET_BIT(_r, _b)  ({                                                                                        \ | 
|  | 24 | +            (*(volatile uint32_t*)(_r) & (_b));                                                                        \ | 
|  | 25 | +        }) | 
|  | 26 | + | 
|  | 27 | +//set bit or set bits to register | 
|  | 28 | +#define REG_SET_BIT(_r, _b)  do {                                                                                      \ | 
|  | 29 | +            *(volatile uint32_t*)(_r) = (*(volatile uint32_t*)(_r)) | (_b);                                            \ | 
|  | 30 | +        } while(0) | 
|  | 31 | + | 
|  | 32 | +//clear bit or clear bits of register | 
|  | 33 | +#define REG_CLR_BIT(_r, _b)  do {                                                                                      \ | 
|  | 34 | +            *(volatile uint32_t*)(_r) = (*(volatile uint32_t*)(_r)) & (~(_b));                                         \ | 
|  | 35 | +        } while(0) | 
|  | 36 | + | 
|  | 37 | +//set bits of register controlled by mask | 
|  | 38 | +#define REG_SET_BITS(_r, _b, _m) do {                                                                                  \ | 
|  | 39 | +            *(volatile uint32_t*)(_r) = (*(volatile uint32_t*)(_r) & ~(_m)) | ((_b) & (_m));                           \ | 
|  | 40 | +        } while(0) | 
|  | 41 | + | 
|  | 42 | +//get field from register, uses field _S & _V to determine mask | 
|  | 43 | +#define REG_GET_FIELD(_r, _f) ({                                                                                       \ | 
|  | 44 | +            ((REG_READ(_r) >> (_f##_S)) & (_f##_V));                                                                   \ | 
|  | 45 | +        }) | 
|  | 46 | + | 
|  | 47 | +//set field of a register from variable, uses field _S & _V to determine mask | 
|  | 48 | +#define REG_SET_FIELD(_r, _f, _v) do {                                                                                 \ | 
|  | 49 | +            REG_WRITE((_r),((REG_READ(_r) & ~((_f##_V) << (_f##_S)))|(((_v) & (_f##_V))<<(_f##_S))));                  \ | 
|  | 50 | +        } while(0) | 
|  | 51 | + | 
|  | 52 | +//get field value from a variable, used when _f is not left shifted by _f##_S | 
|  | 53 | +#define VALUE_GET_FIELD(_r, _f) (((_r) >> (_f##_S)) & (_f)) | 
|  | 54 | + | 
|  | 55 | +//get field value from a variable, used when _f is left shifted by _f##_S | 
|  | 56 | +#define VALUE_GET_FIELD2(_r, _f) (((_r) & (_f))>> (_f##_S)) | 
|  | 57 | + | 
|  | 58 | +//set field value to a variable, used when _f is not left shifted by _f##_S | 
|  | 59 | +#define VALUE_SET_FIELD(_r, _f, _v) ((_r)=(((_r) & ~((_f) << (_f##_S)))|((_v)<<(_f##_S)))) | 
|  | 60 | + | 
|  | 61 | +//set field value to a variable, used when _f is left shifted by _f##_S | 
|  | 62 | +#define VALUE_SET_FIELD2(_r, _f, _v) ((_r)=(((_r) & ~(_f))|((_v)<<(_f##_S)))) | 
|  | 63 | + | 
|  | 64 | +//generate a value from a field value, used when _f is not left shifted by _f##_S | 
|  | 65 | +#define FIELD_TO_VALUE(_f, _v) (((_v)&(_f))<<_f##_S) | 
|  | 66 | + | 
|  | 67 | +//generate a value from a field value, used when _f is left shifted by _f##_S | 
|  | 68 | +#define FIELD_TO_VALUE2(_f, _v) (((_v)<<_f##_S) & (_f)) | 
|  | 69 | + | 
|  | 70 | +//read value from register | 
|  | 71 | +#define READ_PERI_REG(addr) ({                                                                                         \ | 
|  | 72 | +            (*((volatile uint32_t *)ETS_UNCACHED_ADDR(addr)));                                                         \ | 
|  | 73 | +        }) | 
|  | 74 | + | 
|  | 75 | +//write value to register | 
|  | 76 | +#define WRITE_PERI_REG(addr, val) do {                                                                                 \ | 
|  | 77 | +            (*((volatile uint32_t *)ETS_UNCACHED_ADDR(addr))) = (uint32_t)(val);                                       \ | 
|  | 78 | +        } while(0) | 
|  | 79 | + | 
|  | 80 | +//clear bits of register controlled by mask | 
|  | 81 | +#define CLEAR_PERI_REG_MASK(reg, mask)  do {                                                                           \ | 
|  | 82 | +            WRITE_PERI_REG((reg), (READ_PERI_REG(reg)&(~(mask))));                                                     \ | 
|  | 83 | +        } while(0) | 
|  | 84 | + | 
|  | 85 | +//set bits of register controlled by mask | 
|  | 86 | +#define SET_PERI_REG_MASK(reg, mask) do {                                                                              \ | 
|  | 87 | +            WRITE_PERI_REG((reg), (READ_PERI_REG(reg)|(mask)));                                                        \ | 
|  | 88 | +        } while(0) | 
|  | 89 | + | 
|  | 90 | +//get bits of register controlled by mask | 
|  | 91 | +#define GET_PERI_REG_MASK(reg, mask) ({                                                                                \ | 
|  | 92 | +            (READ_PERI_REG(reg) & (mask));                                                                             \ | 
|  | 93 | +        }) | 
|  | 94 | + | 
|  | 95 | +//get bits of register controlled by highest bit and lowest bit | 
|  | 96 | +#define GET_PERI_REG_BITS(reg, hipos,lowpos) ({                                                                        \ | 
|  | 97 | +            ((READ_PERI_REG(reg)>>(lowpos))&((1<<((hipos)-(lowpos)+1))-1));                                            \ | 
|  | 98 | +        }) | 
|  | 99 | + | 
|  | 100 | +//set bits of register controlled by mask and shift | 
|  | 101 | +#define SET_PERI_REG_BITS(reg,bit_map,value,shift) do {                                                                \ | 
|  | 102 | +            WRITE_PERI_REG((reg),(READ_PERI_REG(reg)&(~((bit_map)<<(shift))))|(((value) & (bit_map))<<(shift)) );      \ | 
|  | 103 | +        } while(0) | 
|  | 104 | + | 
|  | 105 | +//get field of register | 
|  | 106 | +#define GET_PERI_REG_BITS2(reg, mask,shift) ({                                                                         \ | 
|  | 107 | +            ((READ_PERI_REG(reg)>>(shift))&(mask));                                                                    \ | 
|  | 108 | +        }) | 
0 commit comments