自学教程：C++ GPIO_BIT函数代码示例

static int gpio_get_cfg(int gpio){	struct s5p_gpio_bank *bank = gpio_get_bank(gpio);	int shift = GPIO_BIT(gpio) << 2;	return (readl(&bank->con) & CON_MASK(GPIO_BIT(gpio))) >> shift;}

void stm32_gpio_digital_write(int pin, int value){    if (value)        GPIO_SetBits(GPIO_PORT(pin), GPIO_BIT(pin));    else        GPIO_ResetBits(GPIO_PORT(pin), GPIO_BIT(pin));}

voidpxa_gpio_set(int gpio, int on){    if (on)        GPSR(gpio) = GPIO_BIT(gpio);    else        GPCR(gpio) = GPIO_BIT(gpio);}

void gpio_cfg_pin(int gpio, int cfg){	unsigned int value;	struct s5p_gpio_bank *bank = gpio_get_bank(gpio);	value = readl(&bank->con);	value &= ~CON_MASK(GPIO_BIT(gpio));	value |= CON_SFR(GPIO_BIT(gpio), cfg);	writel(value, &bank->con);}

void gpio_set_value(int gp, int value){	struct davinci_gpio *bank;	bank = GPIO_BANK(gp);	if (value)		bank->set_data = 1U << GPIO_BIT(gp);	else		bank->clr_data = 1U << GPIO_BIT(gp);}

int gpio_set_value(unsigned gpio, int value){	struct davinci_gpio *bank;	bank = GPIO_BANK(gpio);	if (value)		bank->set_data = 1U << GPIO_BIT(gpio);	else		bank->clr_data = 1U << GPIO_BIT(gpio);	return 0;}

LEVEL CGpio::GetPin(GPIO_GROUP group, int num){	volatile ULONG *pDAT = (volatile ULONG *)GetDat(group);	if(pDAT == NULL) return ERROR;//	SetDir(group, num, GPIO_IN);	if((*pDAT & GPIO_BIT(num)) == GPIO_BIT(num))		return HIGH;	else		return LOW;}

int gpio_set_value(unsigned gpio, int value){	unsigned int val;	struct s5p_gpio_bank *bank = gpio_get_bank(gpio);	val = readl(&bank->dat);	val &= ~DAT_MASK(GPIO_BIT(gpio));	if (value)		val |= DAT_SET(GPIO_BIT(gpio));	writel(val, &bank->dat);	return 0;}

int gpio_amlogic_direction_output(struct gpio_chip *chip,unsigned offset, int value){	unsigned int reg,bit;	if(offset==GPIO_BSD_EN){		aml_clr_reg32_mask(P_PREG_PAD_GPIO0_O,1<<29);#ifndef CONFIG_MESON_TRUSTZONE		aml_set_reg32_mask(P_AO_SECURE_REG0,1<<0);#else		meson_secure_reg_write(P_AO_SECURE_REG0, meson_secure_reg_read(P_AO_SECURE_REG0) | (1<<0));#endif		if(value)			aml_set_reg32_mask(P_PREG_PAD_GPIO0_O,1<<31);//out put high		else			aml_clr_reg32_mask(P_PREG_PAD_GPIO0_O,1<<31);//out put low		aml_clr_reg32_mask(P_PREG_PAD_GPIO0_O,1<<30);//out put enable		return 0;	}	if(offset==GPIO_TEST_N){		if(value)			aml_set_reg32_mask(P_AO_GPIO_O_EN_N,1<<31);//out put high		else			aml_clr_reg32_mask(P_AO_GPIO_O_EN_N,1<<31);//out put low#ifndef CONFIG_MESON_TRUSTZONE		aml_set_reg32_mask(P_AO_SECURE_REG0,1);// out put enable#else		meson_secure_reg_write(P_AO_SECURE_REG0, meson_secure_reg_read(P_AO_SECURE_REG0) | (1<<0));#endif		return 0;	}	if(value){		reg=GPIO_REG(amlogic_pins[offset].out_value_reg_bit);		bit=GPIO_BIT(amlogic_pins[offset].out_value_reg_bit);		aml_set_reg32_mask(p_gpio_output_addr[reg],1<<bit);		gpio_print("out reg=%x,value=%x/n",p_gpio_output_addr[reg],aml_read_reg32(p_gpio_output_addr[reg]));	}	else{		reg=GPIO_REG(amlogic_pins[offset].out_value_reg_bit);		bit=GPIO_BIT(amlogic_pins[offset].out_value_reg_bit);		aml_clr_reg32_mask(p_gpio_output_addr[reg],1<<bit);		gpio_print("out reg=%x,value=%x/n",p_gpio_output_addr[reg],aml_read_reg32(p_gpio_output_addr[reg]));	}	reg=GPIO_REG(amlogic_pins[offset].out_en_reg_bit);	bit=GPIO_BIT(amlogic_pins[offset].out_en_reg_bit);	aml_clr_reg32_mask(p_gpio_oen_addr[reg],1<<bit);	gpio_print("==%s==%d/n",__FUNCTION__,__LINE__);	gpio_print("oen reg=%x,value=%x/n",p_gpio_oen_addr[reg],aml_read_reg32(p_gpio_oen_addr[reg]));	gpio_print("value=%d/n",value);	return 0;}

int gpio_direction_output(unsigned gpio, int value){	unsigned int val;	struct s5p_gpio_bank *bank = gpio_get_bank(gpio);	gpio_cfg_pin(gpio, EXYNOS_GPIO_OUTPUT);	val = readl(&bank->dat);	val &= ~DAT_MASK(GPIO_BIT(gpio));	if (value)		val |= DAT_SET(GPIO_BIT(gpio));	writel(val, &bank->dat);	return 0;}

int stm32_gpio_set_pin_mode(int pin, gpio_pin_mode_t mode){    GPIO_InitTypeDef GPIO_InitStructure;    STM32_GPIO_PERIPH_ENABLE(GPIO_PERIPH(pin));    GPIO_InitStructure.GPIO_Pin = GPIO_BIT(pin);     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;    /* XXX: not all pins are actually available */    switch (mode)    {    case GPIO_PM_INPUT:        STM32_GPIO_PIN_TYPE_IN(GPIO_InitStructure);        GPIO_Init(GPIO_PORT(pin), &GPIO_InitStructure);        break;    case GPIO_PM_OUTPUT:        STM32_GPIO_PIN_TYPE_OUT(GPIO_InitStructure);        GPIO_Init(GPIO_PORT(pin), &GPIO_InitStructure);        break;    case GPIO_PM_INPUT_PULLUP:        STM32_GPIO_PIN_TYPE_IN_PU(GPIO_InitStructure);        GPIO_Init(GPIO_PORT(pin), &GPIO_InitStructure);        break;    case GPIO_PM_INPUT_PULLDOWN:        STM32_GPIO_PIN_TYPE_IN_PD(GPIO_InitStructure);        GPIO_Init(GPIO_PORT(pin), &GPIO_InitStructure);        break;    default:        tp_err("Pinmode %d is not supported yet/n", mode);        return -1;    }    return 0;}

void __gpio_set(int gpio, u32 value){	int port = GPIO_PORT(gpio);	int bit = GPIO_BIT(gpio);	writel(value, __GPIO_BASE(port) + (0x4 << bit));}

int pnx4008_gpio_unregister_pin(unsigned short pin){	unsigned long bit = GPIO_BIT(pin);	int ret = -EFAULT;	/* Not registered */	gpio_lock();	if (GPIO_ISBID(pin)) {		if (~access_map[GPIO_INDEX] & bit)			goto out;		access_map[GPIO_INDEX] &= ~bit;	} else if (GPIO_ISRAM(pin)) {		if (~access_map[GPIO_INDEX] & bit)			goto out;		access_map[GPIO_INDEX] &= ~bit;	} else if (GPIO_ISMUX(pin)) {		if (~access_map[MUX_INDEX] & bit)			goto out;		access_map[MUX_INDEX] &= ~bit;	} else if (GPIO_ISOUT(pin)) {		if (~access_map[OUTP_INDEX] & bit)			goto out;		access_map[OUTP_INDEX] &= ~bit;	} else if (GPIO_ISIN(pin)) {		if (~access_map[INP_INDEX] & bit)			goto out;		access_map[INP_INDEX] &= ~bit;	} else		goto out;	ret = 0;out:	gpio_unlock();	return ret;}

/* The following functions don't check the gpio value, for speed */u32 __gpio_get(int gpio){	int port = GPIO_PORT(gpio);	int bit = GPIO_BIT(gpio);	return readl(__GPIO_DAT(port)) & (1 << bit);}

static int __init gumstix_init(void){	printk("gumstix_init: Initialising board.../n"); 	pxa_map_io();	pxa_generic_init(); 	/* Set up nPWE */	pxa_gpio_mode(GPIO49_nPWE_MD);	/* Set up the chip selects */ 	pxa_gpio_mode(GPIO15_nCS_1_MD);	(void) platform_add_devices(devices, ARRAY_SIZE(devices));		pxa_gpio_func(36, GPIO_MODE, GPIO_IN);	/* Set rising edge detect for GPIO 36 */ 	GFER(36) &= ~GPIO_BIT(36); 	GRER(36) |= (GPIO_BIT(36)); 	/* We assume that the bootloader has set up the rest for us */ 	//        set_irq_type(IBOX_ETH_IRQ, IRQT_RISING);		return 0;}

int gpio_amlogic_get(struct gpio_chip *chip,unsigned offset){	unsigned int reg,bit;	gpio_print("==%s==%d/n",__FUNCTION__,__LINE__);	reg=GPIO_REG(amlogic_pins[offset].input_value_reg_bit);	bit=GPIO_BIT(amlogic_pins[offset].input_value_reg_bit);	return aml_get_reg32_bits(p_gpio_input_addr[reg],bit,1);}

int gpio_direction_input(int gp){	struct davinci_gpio *bank;	bank = GPIO_BANK(gp);	setbits_le32(&bank->dir, 1U << GPIO_BIT(gp));	return 0;}

int gpio_get_value(unsigned gpio){	unsigned int value;	struct s5p_gpio_bank *bank = gpio_get_bank(gpio);	value = readl(&bank->dat);	return !!(value & DAT_MASK(GPIO_BIT(gpio)));}

int gpio_amlogic_direction_input(struct gpio_chip *chip,unsigned offset){	unsigned int reg,bit;	gpio_print("==%s==%d/n",__FUNCTION__,__LINE__);	reg=GPIO_REG(amlogic_pins[offset].out_en_reg_bit);	bit=GPIO_BIT(amlogic_pins[offset].out_en_reg_bit);	aml_set_reg32_mask(p_gpio_oen_addr[reg],1<<bit);	return 0;}

int gpio_get_value(int gp){	struct davinci_gpio *bank;	unsigned int ip;	bank = GPIO_BANK(gp);	ip = in_le32(&bank->in_data) & (1U << GPIO_BIT(gp));	return ip ? 1 : 0;}

int gpio_direction_output(int gp, int value){	struct davinci_gpio *bank;	bank = GPIO_BANK(gp);	clrbits_le32(&bank->dir, 1U << GPIO_BIT(gp));	gpio_set_value(gp, value);	return 0;}

static inline uint32_tgpio_read(struct tegra_gpio_softc *sc, bus_size_t reg, struct gpio_pin *pin){	int bit;	uint32_t val;	bit = GPIO_BIT(pin->gp_pin);	val = bus_read_4(sc->mem_res, reg + GPIO_REGNUM(pin->gp_pin));	return (val >> bit) & 1;}

void gpio_set_rate(int gpio, int mode){	unsigned int value;	struct s5p_gpio_bank *bank = gpio_get_bank(gpio);	value = readl(&bank->drv);	value &= ~RATE_MASK(GPIO_BIT(gpio));	switch (mode) {	case EXYNOS_GPIO_DRV_FAST:	case EXYNOS_GPIO_DRV_SLOW:		value |= RATE_SET(GPIO_BIT(gpio));		break;	default:		return;	}	writel(value, &bank->drv);}

void gpio_set_pull(int gpio, int mode){	unsigned int value;	struct s5p_gpio_bank *bank = gpio_get_bank(gpio);	value = readl(&bank->pull);	value &= ~PULL_MASK(GPIO_BIT(gpio));	switch (mode) {	case EXYNOS_GPIO_PULL_DOWN:	case EXYNOS_GPIO_PULL_UP:		value |= PULL_MODE(GPIO_BIT(gpio), mode);		break;	default:		break;	}	writel(value, &bank->pull);}

void CGpio::SetPin(GPIO_GROUP group, int num, LEVEL level){	volatile ULONG *pDAT = (volatile ULONG *)GetDat(group);	if(pDAT == NULL) return;//	SetDir(group, num, GPIO_OUT);	(level) ? (*pDAT |= GPIO_BIT(num)) : (*pDAT &= ~GPIO_BIT(num));}

static inline void ti_arm_mcu_pin_mode_i2c(int pin, int scl, int i2c_af){    ti_arm_mcu_periph_enable(ti_arm_mcu_gpio_periph(pin));    if (i2c_af)        MAP_GPIOPinConfigure(i2c_af);    MAP_GPIOPinTypeI2C(ti_arm_mcu_gpio_base(pin), GPIO_BIT(pin));    if (scl)        ti_arm_mcu_pin_config(pin, GPIO_PIN_TYPE_STD_WPU);    else        ti_arm_mcu_pin_config(pin, GPIO_PIN_TYPE_OD);}

void	gpio_amlogic_set(struct gpio_chip *chip,unsigned offset, int value){	unsigned int reg,bit;	reg=GPIO_REG(amlogic_pins[offset].out_value_reg_bit);	bit=GPIO_BIT(amlogic_pins[offset].out_value_reg_bit);	gpio_print("==%s==%d/n",__FUNCTION__,__LINE__);	if(value)		aml_set_reg32_mask(p_gpio_output_addr[reg],1<<bit);	else		aml_clr_reg32_mask(p_gpio_output_addr[reg],1<<bit);}

/* * Routine: gpio_config_uart * Description: Force GPIO_PI3 low on Seaboard so UART4 works. */void gpio_config_uart(void){	int gp = GPIO_PI3;	struct gpio_ctlr *gpio = (struct gpio_ctlr *)NV_PA_GPIO_BASE;	struct gpio_ctlr_bank *bank = &gpio->gpio_bank[GPIO_BANK(gp)];	u32 val;	/* Enable UART via GPIO_PI3 (port 8, bit 3) so serial console works */	val = readl(&bank->gpio_config[GPIO_PORT(gp)]);	val |= 1 << GPIO_BIT(gp);	writel(val, &bank->gpio_config[GPIO_PORT(gp)]);	val = readl(&bank->gpio_out[GPIO_PORT(gp)]);	val &= ~(1 << GPIO_BIT(gp));	writel(val, &bank->gpio_out[GPIO_PORT(gp)]);	val = readl(&bank->gpio_dir_out[GPIO_PORT(gp)]);	val |= 1 << GPIO_BIT(gp);	writel(val, &bank->gpio_dir_out[GPIO_PORT(gp)]);}

/* -------------------------------------------------------------------------- * * Interrupts * */static inline voidintr_write_masked(struct tegra_gpio_softc *sc, bus_addr_t reg,    struct tegra_gpio_irqsrc *tgi, uint32_t val){	uint32_t tmp;	int bit;	bit = GPIO_BIT(tgi->irq);	tmp = 0x100 << bit;		/* mask */	tmp |= (val & 1) << bit;	/* value */	bus_write_4(sc->mem_res, reg + GPIO_REGNUM(tgi->irq), tmp);}

void gpio_set_drv(int gpio, int mode){	unsigned int value;	struct s5p_gpio_bank *bank = gpio_get_bank(gpio);	value = readl(&bank->drv);	value &= ~DRV_MASK(GPIO_BIT(gpio));	switch (mode) {	case EXYNOS_GPIO_DRV_1X:	case EXYNOS_GPIO_DRV_2X:	case EXYNOS_GPIO_DRV_3X:	case EXYNOS_GPIO_DRV_4X:		value |= DRV_SET(GPIO_BIT(gpio), mode);		break;	default:		return;	}	writel(value, &bank->drv);}