#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>

chip_io.h 的引用(Include)关系图:

此图展示该文件直接或间接的被哪些文件引用了:

宏定义
#define	ON (true)

#define	OFF (false)

#define	POS(x) (x)

#define	MAX(a, b) (((a) > (b)) ? (a) : (b))

#define	MIN(a, b) (((a) < (b)) ? (a) : (b))

#define	BIT(x) (1UL << (uint32_t)(x))

#define	UNUSED(var) do { (void)(var); } while (0)

#define	true ((bool) 1)

#define	false ((bool) 0)

#define	BIT_31 ((uint32_t)(1 << 31))

#define	BIT_30 ((uint32_t)(1 << 30))

#define	BIT_29 ((uint32_t)(1 << 29))

#define	BIT_28 ((uint32_t)(1 << 28))

#define	BIT_27 ((uint32_t)(1 << 27))

#define	BIT_26 ((uint32_t)(1 << 26))

#define	BIT_25 ((uint32_t)(1 << 25))

#define	BIT_24 ((uint32_t)(1 << 24))

#define	BIT_23 ((uint32_t)(1 << 23))

#define	BIT_22 ((uint32_t)(1 << 22))

#define	BIT_21 ((uint32_t)(1 << 21))

#define	BIT_20 ((uint32_t)(1 << 20))

#define	BIT_19 ((uint32_t)(1 << 19))

#define	BIT_18 ((uint32_t)(1 << 18))

#define	BIT_17 ((uint32_t)(1 << 17))

#define	BIT_16 ((uint32_t)(1 << 16))

#define	BIT_15 ((uint32_t)(1 << 15))

#define	BIT_14 ((uint32_t)(1 << 14))

#define	BIT_13 ((uint32_t)(1 << 13))

#define	BIT_12 ((uint32_t)(1 << 12))

#define	BIT_11 ((uint32_t)(1 << 11))

#define	BIT_10 ((uint32_t)(1 << 10))

#define	BIT_9 ((uint32_t)(1 << 9))

#define	BIT_8 ((uint32_t)(1 << 8))

#define	BIT_7 ((uint32_t)(1 << 7))

#define	BIT_6 ((uint32_t)(1 << 6))

#define	BIT_5 ((uint32_t)(1 << 5))

#define	BIT_4 ((uint32_t)(1 << 4))

#define	BIT_3 ((uint32_t)(1 << 3))

#define	BIT_2 ((uint32_t)(1 << 2))

#define	BIT_1 ((uint32_t)(1 << 1))

#define	BIT_0 ((uint32_t)(1 << 0))

#define	writel(addr, d) ((volatile uint32_t)(uintptr_t)(addr) = (uint32_t)(d))

#define	writew(addr, d) ((volatile uint16_t)(uintptr_t)(addr) = (uint16_t)(d))

#define	writeb(addr, d) ((volatile uint8_t)(uintptr_t)(addr) = (uint8_t)(d))

#define	readl(addr) ((volatile uint32_t)(uintptr_t)(addr))

#define	readw(addr) ((volatile uint16_t)(uintptr_t)(addr))

#define	readb(addr) ((volatile uint8_t)(uintptr_t)(addr))

#define	reg(base, offset) ((volatile uint32_t )(uintptr_t)((uint32_t)(base) + (offset)))

#define	regb(base, offset) ((volatile uint8_t )(uintptr_t)((uint32_t)(base) + (offset)))

#define	regw(base, offset) ((volatile uint16_t )(uintptr_t)((uint32_t)(base) + (offset)))

#define	reg32(register) ((volatile uint32_t)(uintptr_t)(register))

#define	reg16(register) ((volatile uint16_t)(uintptr_t)(register))

#define	reg8(register) ((volatile uint8_t)(uintptr_t)(register))

#define	reg_clrbit(base, offset, pos) ((reg(base, offset)) &= ~((uint32_t)(1) << (pos)))

#define	regw_clrbit(base, offset, pos) ((regw(base, offset)) &= ~((uint16_t)(1) << (pos)))

#define	regb_clrbit(base, offset, pos) ((regb(base, offset)) &= ~((uint8_t)(1) << (pos)))

#define	reg_setbit(base, offset, pos) ((reg(base, offset)) \|= ((uint32_t)(1) << (pos)))

#define	regw_setbit(base, offset, pos) ((regw(base, offset)) \|= (uint16_t)((uint32_t)(1) << (pos)))

#define	regb_setbit(base, offset, pos) ((regb(base, offset)) \|= ((uint8_t)(1) << (pos)))

#define	reg_clrbits(base, offset, pos, bits) (reg(base, offset) &= ~((((uint32_t)1 << (bits)) - 1) << (pos)))

#define	regw_clrbits(base, offset, pos, bits) (regw(base, offset) &= ~((((uint16_t)1 << (bits)) - 1) << (pos)))

#define	regb_clrbits(base, offset, pos, bits) (regb(base, offset) &= ~((((uint8_t)1 << (bits)) - 1) << (pos)))

#define	reg_setbits(b, r, pos, bits, val)

#define	regw_setbits(b, r, pos, bits, val)

#define	regb_setbits(b, r, pos, bits, val)

#define	reg_getbits(base, offset, pos, bits) ((reg(base, offset) >> (pos)) & (((uint32_t)1 << (bits)) - 1))

#define	regw_getbits(base, offset, pos, bits) ((regw(base, offset) >> (pos)) & (((uint16_t)1 << (bits)) - 1))

#define	regb_getbits(base, offset, pos, bits) ((regb(base, offset) >> (pos)) & (((uint8_t) 1<< (bits)) - 1))

#define	reg_clrbitmsk(base, offset, msk) ((reg(base, offset)) &= ~(msk))

#define	regw_clrbitmsk(base, offset, msk) ((regw(base, offset)) &= ~(msk))

#define	regb_clrbitmsk(base, offset, msk) ((regb(base, offset)) &= ~(msk))

#define	reg_setbitmsk(base, offset, msk) ((reg(base, offset)) \|= (msk))

#define	regw_setbitmsk(base, offset, msk) ((regw(base, offset)) \|= (msk))

#define	regb_setbitmsk(base, offset, msk) ((regb(base, offset)) \|= (msk))

#define	reg_read(base, offset, result) ((result) = reg(base, offset))

#define	reg_readw(base, offset, result) ((result) = regw(base, offset))

#define	reg_readb(base, offset, result) ((result) = regb(base, offset))

#define	reg_write(base, offset, data) (reg(base, offset) = (data))

#define	reg_writew(base, offset, data) (regw(base, offset) = (data))

#define	reg_writeb(base, offset, data) (regb(base, offset) = (data))

#define	reg32_clrbit(register, pos) (reg32(register) &= ~((uint32_t)((1U) << (uint32_t)(pos))))

#define	reg16_clrbit(register, pos) (reg16(register) &= ~((uint16_t)((1U) << (uint16_t)(pos))))

#define	reg8_clrbit(register, pos) (reg8(register) &= ~((uint8_t)((1U) << (pos))))

#define	reg32_setbit(register, pos) (reg32(register) \|= ((uint32_t)((1U) << (uint32_t)(pos))))

#define	reg16_setbit(register, pos) (reg16(register) \|= ((uint16_t)((1U) << (uint16_t)(pos))))

#define	reg8_setbit(register, pos) (reg8(register) \|= ((uint8_t)((1U) << (pos))))

#define	reg32_getbit(register, pos) ((reg32(register) >> (pos)) & ((uint32_t)(1U)))

#define	reg16_getbit(register, pos) ((reg16(register) >> (pos)) & ((uint16_t)(1U)))

#define	reg8_getbit(register, pos) ((reg8(register) >> (pos)) & ((uint8_t)(1U)))

#define	reg32_clrbits(register, pos, bits) (reg32(register) &= ~((((uint32_t)1 << (bits)) - 1) << (pos)))

#define	reg16_clrbits(register, pos, bits)

#define	reg8_clrbits(register, pos, bits)

#define	reg32_setbits(r, p, b, v)

#define	reg16_setbits(r, p, b, v)

#define	reg8_setbits(r, p, b, v)

#define	reg32_getbits(register, pos, bits) ((reg32(register) >> (pos)) & (((uint32_t)1 << (bits)) - 1))

#define	reg16_getbits(register, pos, bits)

#define	reg8_getbits(register, pos, bits) ((reg8(register) >> (pos)) & (((uint8_t)1 << (bits)) - 1))

#define	reg32_clrbitmsk(register, msk) ((reg32(register)) &= ~(msk))

#define	reg16_clrbitmsk(register, msk) ((reg16(register)) &= ~(msk))

#define	reg8_clrbitmsk(register, msk) ((reg8(register)) &= ~(msk))

#define	reg32_setbitmsk(register, msk) ((reg32(register)) \|= (msk))

#define	reg16_setbitmsk(register, msk) ((reg16(register)) \|= (msk))

#define	reg8_setbitmsk(register, msk) ((reg8(register)) \|= (msk))

#define	reg32_read(register, result) ((result) = reg32(register))

#define	reg16_read(register, result) ((result) = reg16(register))

#define	reg8_read(register, result) ((result) = reg8(register))

#define	reg32_write(register, data) (reg32(register) = (data))

#define	reg16_write(register, data) (reg16(register) = (data))

#define	reg8_write(register, data) (reg8(register) = (data))

#define	p8(addr) (((volatile uint8_t)(addr)))

#define	p16(addr) (((volatile uint16_t)(addr)))

#define	p32(addr) (((volatile uint32_t)(addr)))

#define	point8_setbit(point, pos) (p8(point) \|= (uint8_t)((1U) << (pos)))

#define	point16_setbit(point, pos) (p16(point) \|= (uint16_t)((1U) << (pos)))

#define	point32_setbit(point, pos) (p32(point) \|= (uint32_t)((1U) << (pos)))

#define	point8_setbits(p, pos, b, v)

#define	point16_setbits(p, pos, b, v)

#define	point32_setbits(p, pos, b, v)

#define	point8_clrbit(point, pos) (p8(point) &= ~(uint8_t)((1U) << (pos)))

#define	point16_clrbit(point, pos) (p16(point) &= ~(uint16_t)((1U) << (pos)))

#define	point32_clrbit(point, pos) (p32(point) &= ~(uint32_t)((1U) << (pos)))

#define	point8_clrbits(point, pos, bits) (p8(point) &= ~((((uint8_t)1 << (bits)) - 1) << (pos)))

#define	point16_clrbits(point, pos, bits) (p16(point) &= ~((((uint16_t)1 << (bits)) - 1) << (pos)))

#define	point32_clrbits(point, pos, bits) (p32(point) &= ~((((uint32_t)1 << (bits)) - 1) << (pos)))

枚举
enum	switch_type_t { TURN_OFF , TURN_ON }

enum	REG32_POS { POS_16 = 16 , POS_17 , POS_18 , POS_19 , POS_20 , POS_21 , POS_22 , POS_23 , POS_24 , POS_25 , POS_26 , POS_27 , POS_28 , POS_29 , POS_30 , POS_31 }

enum	REG16_POS { POS_0 , POS_1 , POS_2 , POS_3 , POS_4 , POS_5 , POS_6 , POS_7 , POS_8 , POS_9 , POS_10 , POS_11 , POS_12 , POS_13 , POS_14 , POS_15 }

宏定义说明

◆ BIT

#define BIT ( x ) (1UL << (uint32_t)(x))

◆ BIT_0

#define BIT_0 ((uint32_t)(1 << 0))

◆ BIT_1

#define BIT_1 ((uint32_t)(1 << 1))

◆ BIT_10

#define BIT_10 ((uint32_t)(1 << 10))

◆ BIT_11

#define BIT_11 ((uint32_t)(1 << 11))

◆ BIT_12

#define BIT_12 ((uint32_t)(1 << 12))

◆ BIT_13

#define BIT_13 ((uint32_t)(1 << 13))

◆ BIT_14

#define BIT_14 ((uint32_t)(1 << 14))

◆ BIT_15

#define BIT_15 ((uint32_t)(1 << 15))

◆ BIT_16

#define BIT_16 ((uint32_t)(1 << 16))

◆ BIT_17

#define BIT_17 ((uint32_t)(1 << 17))

◆ BIT_18

#define BIT_18 ((uint32_t)(1 << 18))

◆ BIT_19

#define BIT_19 ((uint32_t)(1 << 19))

◆ BIT_2

#define BIT_2 ((uint32_t)(1 << 2))

◆ BIT_20

#define BIT_20 ((uint32_t)(1 << 20))

◆ BIT_21

#define BIT_21 ((uint32_t)(1 << 21))

◆ BIT_22

#define BIT_22 ((uint32_t)(1 << 22))

◆ BIT_23

#define BIT_23 ((uint32_t)(1 << 23))

◆ BIT_24

#define BIT_24 ((uint32_t)(1 << 24))

◆ BIT_25

#define BIT_25 ((uint32_t)(1 << 25))

◆ BIT_26

#define BIT_26 ((uint32_t)(1 << 26))

◆ BIT_27

#define BIT_27 ((uint32_t)(1 << 27))

◆ BIT_28

#define BIT_28 ((uint32_t)(1 << 28))

◆ BIT_29

#define BIT_29 ((uint32_t)(1 << 29))

◆ BIT_3

#define BIT_3 ((uint32_t)(1 << 3))

◆ BIT_30

#define BIT_30 ((uint32_t)(1 << 30))

◆ BIT_31

#define BIT_31 ((uint32_t)(1 << 31))

◆ BIT_4

#define BIT_4 ((uint32_t)(1 << 4))

◆ BIT_5

#define BIT_5 ((uint32_t)(1 << 5))

◆ BIT_6

#define BIT_6 ((uint32_t)(1 << 6))

◆ BIT_7

#define BIT_7 ((uint32_t)(1 << 7))

◆ BIT_8

#define BIT_8 ((uint32_t)(1 << 8))

◆ BIT_9

#define BIT_9 ((uint32_t)(1 << 9))

◆ false

#define false ((bool) 0)

◆ MAX

#define MAX	(	a,
		b
	)	(((a) > (b)) ? (a) : (b))

◆ MIN

#define MIN	(	a,
		b
	)	(((a) < (b)) ? (a) : (b))

◆ OFF

#define OFF (false)

◆ ON

#define ON (true)

◆ p16

#define p16 ( addr ) (*((volatile uint16_t*)(addr)))

◆ p32

#define p32 ( addr ) (*((volatile uint32_t*)(addr)))

◆ p8

#define p8 ( addr ) (*((volatile uint8_t*)(addr)))

◆ point16_clrbit

#define point16_clrbit	(	point,
		pos
	)	(p16(point) &= ~(uint16_t)((1U) << (pos)))

◆ point16_clrbits

#define point16_clrbits	(	point,
		pos,
		bits
	)	(p16(point) &= ~((((uint16_t)1 << (bits)) - 1) << (pos)))

◆ point16_setbit

#define point16_setbit	(	point,
		pos
	)	(p16(point) \|= (uint16_t)((1U) << (pos)))

◆ point16_setbits

#define point16_setbits	(	p,
		pos,
		b,
		v
	)

值:

                                                (p16(p) = (uint16_t)(p16(p) & \
                                                (~((((uint16_t)1 << (uint16_t)(b)) - 1) << (uint16_t)(pos)))) \
                                                | ((uint16_t)((uint16_t)(v) & \
                                                (((uint16_t)1 << (uint16_t)(b)) - 1)) << (uint16_t)(pos)))

◆ point32_clrbit

#define point32_clrbit	(	point,
		pos
	)	(p32(point) &= ~(uint32_t)((1U) << (pos)))

◆ point32_clrbits

#define point32_clrbits	(	point,
		pos,
		bits
	)	(p32(point) &= ~((((uint32_t)1 << (bits)) - 1) << (pos)))

◆ point32_setbit

#define point32_setbit	(	point,
		pos
	)	(p32(point) \|= (uint32_t)((1U) << (pos)))

◆ point32_setbits

#define point32_setbits	(	p,
		pos,
		b,
		v
	)

值:

(p32(p) = (uint32_t)(p32(p) & (~((((uint32_t)1 << (b)) - 1) << (pos)))) \

| ((uint32_t)((v) & (((uint32_t)1 << (b)) - 1)) << (pos)))

p32

#define p32(addr)

Definition chip_io.h:302

◆ point8_clrbit

#define point8_clrbit	(	point,
		pos
	)	(p8(point) &= ~(uint8_t)((1U) << (pos)))

◆ point8_clrbits

#define point8_clrbits	(	point,
		pos,
		bits
	)	(p8(point) &= ~((((uint8_t)1 << (bits)) - 1) << (pos)))

◆ point8_setbit

#define point8_setbit	(	point,
		pos
	)	(p8(point) \|= (uint8_t)((1U) << (pos)))

◆ point8_setbits

#define point8_setbits	(	p,
		pos,
		b,
		v
	)

值:

(p8(p) = (uint8_t)(p8(p) & (~((((uint8_t)1 << (b)) - 1) << (pos)))) \

| ((uint8_t)((v) & (((uint8_t)1 << (b)) - 1)) << (pos)))

p8

#define p8(addr)

Definition chip_io.h:300

◆ POS

#define POS ( x ) (x)

◆ readb

#define readb ( addr ) (*(volatile uint8_t*)(uintptr_t)(addr))

◆ readl

#define readl ( addr ) (*(volatile uint32_t*)(uintptr_t)(addr))

◆ readw

#define readw ( addr ) (*(volatile uint16_t*)(uintptr_t)(addr))

◆ reg

#define reg	(	base,
		offset
	)	((volatile uint32_t )(uintptr_t)((uint32_t)(base) + (offset)))

◆ reg16

#define reg16 ( register ) (*(volatile uint16_t*)(uintptr_t)(register))

◆ reg16_clrbit

#define reg16_clrbit	(	register,
		pos
	)	(reg16(register) &= ~((uint16_t)((1U) << (uint16_t)(pos))))

◆ reg16_clrbitmsk

#define reg16_clrbitmsk	(	register,
		msk
	)	((reg16(register)) &= ~(msk))

◆ reg16_clrbits

#define reg16_clrbits	(	register,
		pos,
		bits
	)

值:

(reg16(register) &= \

~(uint16_t)((((uint32_t)1 << (bits)) - 1) << (pos)))

reg16

#define reg16(register)

Definition chip_io.h:183

◆ reg16_getbit

#define reg16_getbit	(	register,
		pos
	)	((reg16(register) >> (pos)) & ((uint16_t)(1U)))

◆ reg16_getbits

#define reg16_getbits	(	register,
		pos,
		bits
	)

值:

((reg16(register) >> (pos)) & \

((uint16_t)((uint32_t)1 << (bits)) - 1))

◆ reg16_read

#define reg16_read	(	register,
		result
	)	((result) = reg16(register))

◆ reg16_setbit

#define reg16_setbit	(	register,
		pos
	)	(reg16(register) \|= ((uint16_t)((1U) << (uint16_t)(pos))))

◆ reg16_setbitmsk

#define reg16_setbitmsk	(	register,
		msk
	)	((reg16(register)) \|= (msk))

◆ reg16_setbits

#define reg16_setbits	(	r,
		p,
		b,
		v
	)

值:

                                              (reg16(r) = (reg16(r) & \
                                              (uint16_t)(~((((uint32_t)1 << (uint16_t)(b)) - 1) << (uint16_t)(p)))) \
                                              | (uint16_t)((uint32_t)((uint16_t)(v) & \
                                              (((uint32_t)1 << (uint16_t)(b)) - 1)) << (uint16_t)(p)))

◆ reg16_write

#define reg16_write	(	register,
		data
	)	(reg16(register) = (data))

◆ reg32

#define reg32 ( register ) (*(volatile uint32_t*)(uintptr_t)(register))

◆ reg32_clrbit

#define reg32_clrbit	(	register,
		pos
	)	(reg32(register) &= ~((uint32_t)((1U) << (uint32_t)(pos))))

◆ reg32_clrbitmsk

#define reg32_clrbitmsk	(	register,
		msk
	)	((reg32(register)) &= ~(msk))

◆ reg32_clrbits

#define reg32_clrbits	(	register,
		pos,
		bits
	)	(reg32(register) &= ~((((uint32_t)1 << (bits)) - 1) << (pos)))

◆ reg32_getbit

#define reg32_getbit	(	register,
		pos
	)	((reg32(register) >> (pos)) & ((uint32_t)(1U)))

◆ reg32_getbits

#define reg32_getbits	(	register,
		pos,
		bits
	)	((reg32(register) >> (pos)) & (((uint32_t)1 << (bits)) - 1))

◆ reg32_read

#define reg32_read	(	register,
		result
	)	((result) = reg32(register))

◆ reg32_setbit

#define reg32_setbit	(	register,
		pos
	)	(reg32(register) \|= ((uint32_t)((1U) << (uint32_t)(pos))))

◆ reg32_setbitmsk

#define reg32_setbitmsk	(	register,
		msk
	)	((reg32(register)) \|= (msk))

◆ reg32_setbits

#define reg32_setbits	(	r,
		p,
		b,
		v
	)

值:

                                              (reg32(r) = (reg32(r) & \
                                              (~((((uint32_t)1 << (uint32_t)(b)) - 1) << (uint32_t)(p)))) \
                                              | ((uint32_t)((uint32_t)(v) & \
                                              (((uint32_t)1 << (uint32_t)(b)) - 1)) << (uint32_t)(p)))

◆ reg32_write

#define reg32_write	(	register,
		data
	)	(reg32(register) = (data))

◆ reg8

#define reg8 ( register ) (*(volatile uint8_t*)(uintptr_t)(register))

◆ reg8_clrbit

#define reg8_clrbit	(	register,
		pos
	)	(reg8(register) &= ~((uint8_t)((1U) << (pos))))

◆ reg8_clrbitmsk

#define reg8_clrbitmsk	(	register,
		msk
	)	((reg8(register)) &= ~(msk))

◆ reg8_clrbits

#define reg8_clrbits	(	register,
		pos,
		bits
	)

值:

(reg8(register) &= \

~(uint8_t)((((uint32_t)1 << (bits)) - 1) << (pos)))

reg8

#define reg8(register)

Definition chip_io.h:184

◆ reg8_getbit

#define reg8_getbit	(	register,
		pos
	)	((reg8(register) >> (pos)) & ((uint8_t)(1U)))

◆ reg8_getbits

#define reg8_getbits	(	register,
		pos,
		bits
	)	((reg8(register) >> (pos)) & (((uint8_t)1 << (bits)) - 1))

◆ reg8_read

#define reg8_read	(	register,
		result
	)	((result) = reg8(register))

◆ reg8_setbit

#define reg8_setbit	(	register,
		pos
	)	(reg8(register) \|= ((uint8_t)((1U) << (pos))))

◆ reg8_setbitmsk

#define reg8_setbitmsk	(	register,
		msk
	)	((reg8(register)) \|= (msk))

◆ reg8_setbits

#define reg8_setbits	(	r,
		p,
		b,
		v
	)

值:

(reg8(r) = (reg8(r) & (~((((uint8_t)1 << (b)) - 1) << (p)))) \

| ((uint8_t)((v) & (((uint8_t)1 << (b)) - 1)) << (p)))

◆ reg8_write

#define reg8_write	(	register,
		data
	)	(reg8(register) = (data))

◆ reg_clrbit

#define reg_clrbit	(	base,
		offset,
		pos
	)	((reg(base, offset)) &= ~((uint32_t)(1) << (pos)))

◆ reg_clrbitmsk

#define reg_clrbitmsk	(	base,
		offset,
		msk
	)	((reg(base, offset)) &= ~(msk))

◆ reg_clrbits

#define reg_clrbits	(	base,
		offset,
		pos,
		bits
	)	(reg(base, offset) &= ~((((uint32_t)1 << (bits)) - 1) << (pos)))

◆ reg_getbits

#define reg_getbits	(	base,
		offset,
		pos,
		bits
	)	((reg(base, offset) >> (pos)) & (((uint32_t)1 << (bits)) - 1))

◆ reg_read

#define reg_read	(	base,
		offset,
		result
	)	((result) = reg(base, offset))

◆ reg_readb

#define reg_readb	(	base,
		offset,
		result
	)	((result) = regb(base, offset))

◆ reg_readw

#define reg_readw	(	base,
		offset,
		result
	)	((result) = regw(base, offset))

◆ reg_setbit

#define reg_setbit	(	base,
		offset,
		pos
	)	((reg(base, offset)) \|= ((uint32_t)(1) << (pos)))

◆ reg_setbitmsk

#define reg_setbitmsk	(	base,
		offset,
		msk
	)	((reg(base, offset)) \|= (msk))

◆ reg_setbits

#define reg_setbits	(	b,
		r,
		pos,
		bits,
		val
	)

值:

(reg(b, r) = (reg(b, r) & (~((((uint32_t)1 << (bits)) - 1) << (pos)))) \

| ((uint32_t)((val) & (((uint32_t)1 << (bits)) - 1)) << (pos)))

reg

#define reg(base, offset)

Definition chip_io.h:178

◆ reg_write

#define reg_write	(	base,
		offset,
		data
	)	(reg(base, offset) = (data))

◆ reg_writeb

#define reg_writeb	(	base,
		offset,
		data
	)	(regb(base, offset) = (data))

◆ reg_writew

#define reg_writew	(	base,
		offset,
		data
	)	(regw(base, offset) = (data))

◆ regb

#define regb	(	base,
		offset
	)	((volatile uint8_t )(uintptr_t)((uint32_t)(base) + (offset)))

◆ regb_clrbit

#define regb_clrbit	(	base,
		offset,
		pos
	)	((regb(base, offset)) &= ~((uint8_t)(1) << (pos)))

◆ regb_clrbitmsk

#define regb_clrbitmsk	(	base,
		offset,
		msk
	)	((regb(base, offset)) &= ~(msk))

◆ regb_clrbits

#define regb_clrbits	(	base,
		offset,
		pos,
		bits
	)	(regb(base, offset) &= ~((((uint8_t)1 << (bits)) - 1) << (pos)))

◆ regb_getbits

#define regb_getbits	(	base,
		offset,
		pos,
		bits
	)	((regb(base, offset) >> (pos)) & (((uint8_t) 1<< (bits)) - 1))

◆ regb_setbit

#define regb_setbit	(	base,
		offset,
		pos
	)	((regb(base, offset)) \|= ((uint8_t)(1) << (pos)))

◆ regb_setbitmsk

#define regb_setbitmsk	(	base,
		offset,
		msk
	)	((regb(base, offset)) \|= (msk))

◆ regb_setbits

#define regb_setbits	(	b,
		r,
		pos,
		bits,
		val
	)

值:

(regb(b, r) = (regb(b, r) & (~((((uint8_t)1 << (bits)) - 1) << (pos)))) \

| ((uint8_t)((val) & (((uint8_t)1 << (bits)) - 1)) << (pos)))

regb

#define regb(base, offset)

Definition chip_io.h:179

◆ regw

#define regw	(	base,
		offset
	)	((volatile uint16_t )(uintptr_t)((uint32_t)(base) + (offset)))

◆ regw_clrbit

#define regw_clrbit	(	base,
		offset,
		pos
	)	((regw(base, offset)) &= ~((uint16_t)(1) << (pos)))

◆ regw_clrbitmsk

#define regw_clrbitmsk	(	base,
		offset,
		msk
	)	((regw(base, offset)) &= ~(msk))

◆ regw_clrbits

#define regw_clrbits	(	base,
		offset,
		pos,
		bits
	)	(regw(base, offset) &= ~((((uint16_t)1 << (bits)) - 1) << (pos)))

◆ regw_getbits

#define regw_getbits	(	base,
		offset,
		pos,
		bits
	)	((regw(base, offset) >> (pos)) & (((uint16_t)1 << (bits)) - 1))

◆ regw_setbit

#define regw_setbit	(	base,
		offset,
		pos
	)	((regw(base, offset)) \|= (uint16_t)((uint32_t)(1) << (pos)))

◆ regw_setbitmsk

#define regw_setbitmsk	(	base,
		offset,
		msk
	)	((regw(base, offset)) \|= (msk))

◆ regw_setbits

#define regw_setbits	(	b,
		r,
		pos,
		bits,
		val
	)

值:

(regw(b, r) = (regw(b, r) & (~((((uint16_t)1 << (bits)) - 1) << (pos)))) \

| ((uint16_t)((val) & (((uint16_t)1 << (bits)) - 1)) << (pos)))

regw

#define regw(base, offset)

Definition chip_io.h:180

◆ true

#define true ((bool) 1)

◆ UNUSED

#define UNUSED ( var ) do { (void)(var); } while (0)

◆ writeb

#define writeb	(	addr,
		d
	)	((volatile uint8_t)(uintptr_t)(addr) = (uint8_t)(d))

◆ writel

#define writel	(	addr,
		d
	)	((volatile uint32_t)(uintptr_t)(addr) = (uint32_t)(d))

◆ writew

#define writew	(	addr,
		d
	)	((volatile uint16_t)(uintptr_t)(addr) = (uint16_t)(d))

枚举类型说明

◆ REG16_POS

enum REG16_POS

reg32 bit pos types

枚举值
POS_0
POS_1
POS_2
POS_3
POS_4
POS_5
POS_6
POS_7
POS_8
POS_9
POS_10
POS_11
POS_12
POS_13
POS_14
POS_15

◆ REG32_POS

enum REG32_POS

reg32 bit pos types

枚举值
POS_16
POS_17
POS_18
POS_19
POS_20
POS_21
POS_22
POS_23
POS_24
POS_25
POS_26
POS_27
POS_28
POS_29
POS_30
POS_31

◆ switch_type_t

enum switch_type_t

PMU_LPM wakeup types

枚举值
TURN_OFF
TURN_ON