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

/* * To mask and unmask MMC Card Detect Interrupt * mask : 1 * unmask : 0 */static int mask_cd2_interrupt(int mask){	u8 reg = 0, ret = 0;	ret = twl4030_i2c_read_u8(TWL4030_MODULE_GPIO, &reg, TWL_GPIO_IMR1A);	if (ret != 0)		goto err;	reg = (mask == 1) ? (reg | GPIO_1_BIT_POS) : (reg & ~GPIO_1_BIT_POS);	ret = twl4030_i2c_write_u8(TWL4030_MODULE_GPIO, reg, TWL_GPIO_IMR1A);	if (ret != 0)		goto err;	ret = twl4030_i2c_read_u8(TWL4030_MODULE_GPIO, &reg, TWL_GPIO_ISR1A);	if (ret != 0)		goto err;	reg = (mask == 1) ? (reg | GPIO_1_BIT_POS) : (reg & ~GPIO_1_BIT_POS);	ret = twl4030_i2c_write_u8(TWL4030_MODULE_GPIO, reg, TWL_GPIO_ISR1A);	if (ret != 0)		goto err;err:	return ret;}

static int __init config_warmreset_sequence(u8 address){	int err = 0;	u8 rd_data;	/* Set WARM RESET SEQ address for P1 */	err |= twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, address,					R_SEQ_ADD_WARM);	/* P1/P2/P3 enable WARMRESET */	err |= twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &rd_data,					R_P1_SW_EVENTS);	rd_data |= ENABLE_WARMRESET;	err |= twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, rd_data,					R_P1_SW_EVENTS);	err |= twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &rd_data,					R_P2_SW_EVENTS);	rd_data |= ENABLE_WARMRESET;	err |= twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, rd_data,					R_P2_SW_EVENTS);	err |= twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &rd_data,					R_P3_SW_EVENTS);	rd_data |= ENABLE_WARMRESET;	err |= twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, rd_data,					R_P3_SW_EVENTS);	if (err)		printk(KERN_ERR			"TWL4030 warmreset seq config error/n");	return err;}

/* This is called from twl4030-core.c and is required by * MUSB and EHCI on new OMAP3BUG. */void usb_gpio_settings(void){	unsigned char val;	/* enable VAUX2 for EHCI */	/*	twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,			TWL4030_VAUX2_1P8V, TWL4030_VAUX2_DEDICATED);	twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,			ENABLE_VAUX2_DEV_GRP, TWL4030_VAUX2_DEV_GRP);	*/	/* Enable TWL GPIO Module */	twl4030_i2c_write_u8(TWL4030_MODULE_GPIO, 0x04, REG_GPIO_CTRL);	/*	 * Configure GPIO-6 as output	 */	twl4030_i2c_read_u8(TWL4030_MODULE_GPIO, &val, REG_GPIODATADIR1);	val |= 0x4;	twl4030_i2c_write_u8(TWL4030_MODULE_GPIO, val, REG_GPIODATADIR1);	/* Set GPIO6 = 1 */	twl4030_i2c_read_u8(TWL4030_MODULE_GPIO, &val, REG_GPIODATAOUT1);	val |= 0x40;	twl4030_i2c_write_u8(TWL4030_MODULE_GPIO, val, REG_GPIODATAOUT1);}

/* * Interrupt service routine *  * Attends to BCI interruptions events,  * specifically BATSTS (battery connection and removal) * VBATOV (main battery voltage threshold) events *  */static irqreturn_t twl4030battery_interrupt(int irq, void *dev_id){	int ret;	u8 isr1a_val, isr2a_val, clear_2a, clear_1a;	if ((ret = twl4030_i2c_read_u8(TWL4030_MODULE_INTERRUPTS, &isr1a_val, 				REG_BCIISR1A)))			return IRQ_NONE;		if ((ret = twl4030_i2c_read_u8(TWL4030_MODULE_INTERRUPTS, &isr2a_val, 				REG_BCIISR2A)))		return IRQ_NONE;		clear_2a = (isr2a_val & VBATLVL_ISR1)? (VBATLVL_ISR1): 0;	clear_1a = (isr1a_val & BATSTS_ISR1)? (BATSTS_ISR1): 0;		/* cleaning BCI interrupt status flags */	if ((ret = twl4030_i2c_write_u8(TWL4030_MODULE_INTERRUPTS, 			clear_1a , REG_BCIISR1A)))	return IRQ_NONE;		if ((ret = twl4030_i2c_write_u8(TWL4030_MODULE_INTERRUPTS, 			clear_2a , REG_BCIISR2A)))	return IRQ_NONE;						/* battery connetion or removal event */	if (isr1a_val & BATSTS_ISR1)	{		ret = twl4030battery_presence_evt();		if (ret == -ENXIO)		{			twl4030battery_hw_presence_en(EVT_DISABLE);			return IRQ_HANDLED;		}		if (ret)			return IRQ_NONE;			}			/* battery voltage threshold event*/	else if (isr2a_val & VBATLVL_ISR1)	{		ret = twl4030battery_level_evt();		if (ret == -ENXIO)		{			twl4030battery_hw_level_en(EVT_DISABLE);			return IRQ_HANDLED;		}			if (ret)			return IRQ_NONE;	}	/* Only for debuging purpouses this branch never be taken */	else		return IRQ_NONE;				return IRQ_HANDLED;		}

static int __init twl4030_config_wakeup12_sequence(u8 address){	int err = 0;	u8 data;	/* Set SLEEP to ACTIVE SEQ address for P1 and P2 */	err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, address,				R_SEQ_ADD_S2A12);	if (err)		goto out;	/* P1/P2 LVL_WAKEUP should be on LEVEL */	err = twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &data,				R_P1_SW_EVENTS);	if (err)		goto out;	data |= LVL_WAKEUP;	err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, data,				R_P1_SW_EVENTS);	if (err)		goto out;	err = twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &data,				R_P2_SW_EVENTS);	if (err)		goto out;	data |= LVL_WAKEUP;	err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, data,				R_P2_SW_EVENTS);	if (err)		goto out;	if (machine_is_omap_3430sdp() || machine_is_omap_ldp()) {		/* Disabling AC charger effect on sleep-active transitions */		err = twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &data,					R_CFG_P1_TRANSITION);		if (err)			goto out;		data &= ~(1<<1);		err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, data ,					R_CFG_P1_TRANSITION);		if (err)			goto out;	}out:	if (err)		pr_err("TWL4030 wakeup sequence for P1 and P2" /			"config error/n");	return err;}

void __led_toggle(led_id_t mask){	int toggle_gpio = 0;#ifdef CONFIG_LED_STATUS0	if (!toggle_gpio && CONFIG_LED_STATUS_BIT & mask)		toggle_gpio = TRICORDER_STATUS_LED_GREEN;#endif#ifdef CONFIG_LED_STATUS1	if (!toggle_gpio && CONFIG_LED_STATUS_BIT1 & mask)		toggle_gpio = TRICORDER_STATUS_LED_YELLOW;#endif#ifdef CONFIG_LED_STATUS2	if (!toggle_gpio && CONFIG_LED_STATUS_BIT2 & mask) {		uint8_t val;		twl4030_i2c_read_u8(TWL4030_CHIP_LED, TWL4030_LED_LEDEN,				    &val);		val ^= (TWL4030_LED_LEDEN_LEDAON | TWL4030_LED_LEDEN_LEDAPWM);		twl4030_i2c_write_u8(TWL4030_CHIP_LED, TWL4030_LED_LEDEN,				     val);	}#endif	if (toggle_gpio) {		int state;		gpio_request(toggle_gpio, "");		state = gpio_get_value(toggle_gpio);		gpio_set_value(toggle_gpio, !state);	}}

static int twl4030_button_stop_off_disable(void){	int err = 0;	u8 uninitialized_var(rd_data);	err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, TWL4030_LOCK_KEY_1,			R_PROTECT_KEY);	if (err) {		pr_warning("twl4030: button off unable to unlock PROTECT_KEY 1, %x/n",TWL4030_LOCK_KEY_1);		return err;	}	err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, TWL4030_LOCK_KEY_2,			R_PROTECT_KEY);	if (err) {		pr_warning("twl4030:  button off unable to unlock PROTECT_KEY 2, %x/n",TWL4030_LOCK_KEY_2);		return err;	}	err |= twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &rd_data, PWR_P1_SW_EVENTS);	rd_data &= ~STOPON_PWRON;	err |= twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, rd_data, PWR_P1_SW_EVENTS);	err |= twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0, R_PROTECT_KEY);	if (err)		printk(KERN_ERR "TWL4030 button off config error/n");	return err;}

static int __init config_wakeup12_sequence(u8 address){	int err = 0;	/* Set SLEEP to ACTIVE SEQ address for P1 and P2 */	err |= twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, address,				  R_SEQ_ADD_SA12);	/* P1/P2/P3 LVL_WAKEUP should be on LEVEL */	err |= twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, LVL_WAKEUP,					R_P1_SW_EVENTS);	err |= twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, LVL_WAKEUP,					R_P2_SW_EVENTS);	if (machine_is_omap_3430sdp() || machine_is_omap_ldp() ||	    machine_is_omap_zoom2() || machine_is_omap_zoom3() ||	    machine_is_omap3630_edp1() || machine_is_omap3621_edp1()) {		u8 uninitialized_var(data);		/* Disabling AC charger effect on sleep-active transitions */		err |= twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &data,						R_CFG_P1_TRANSITION);		data &= ~(1<<1);		err |= twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, data ,						R_CFG_P1_TRANSITION);	}	if (err)		printk(KERN_ERR "TWL4030 wakeup sequence for P1 and P2" /				"config error/n");	return err;}

void twl4030_poweroff(void){	u8 val;	int err;	err = twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &val,				  PWR_P1_SW_EVENTS);	if (err) {		printk(KERN_WARNING "I2C error %d while reading TWL4030"					"PM_MASTER P1_SW_EVENTS/n", err);		return ;	}	val |= PWR_DEVOFF;	err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, val,				   PWR_P1_SW_EVENTS);	if (err) {		printk(KERN_WARNING "I2C error %d while writing TWL4030"					"PM_MASTER P1_SW_EVENTS/n", err);		return ;	}	return;}

static irqreturn_t powerbutton_irq(int irq, void *dev_id){	int err;	u8 value;#ifdef CONFIG_LOCKDEP	/* WORKAROUND for lockdep forcing IRQF_DISABLED on us, which	 * we don't want and can't tolerate.  Although it might be	 * friendlier not to borrow this thread context...	 */	local_irq_enable();#endif	err = twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &value,				  STS_HW_CONDITIONS);	if (!err)  {		input_report_key(powerbutton_dev, KEY_POWER,				 value & PWR_PWRON_IRQ);	} else {		pr_err("twl4030: i2c error %d while reading TWL4030"			" PM_MASTER STS_HW_CONDITIONS register/n", err);	}	return IRQ_HANDLED;}

/* * Interrupt service routine *  * Attends to TWL 4030 power module interruptions events,  * specifically USB_PRES (USB charger presence) CHG_PRES (AC charger presence) events *  */static irqreturn_t  twl4030charger_interrupt(int irq, void *dev_id){	u8 int_src, clear = 0;	int ret;	/* Reading interruption source*/	ret = twl4030_i2c_read_u8(TWL4030_MODULE_INT, &int_src, REG_PWR_ISR1);	if (ret)		return IRQ_NONE;					/* Addition to enable shared interrupt */ 	 		if(!(int_src & (USB_PRES | CHG_PRES)))		return IRQ_NONE;		/* Cleaning interruption flags */	clear = (int_src & USB_PRES)? (clear | USB_PRES): clear; 	clear = (int_src & CHG_PRES)? (clear | CHG_PRES): clear;			ret = twl4030_i2c_write_u8(TWL4030_MODULE_INT, 	clear, REG_PWR_ISR1);	if (ret)		return IRQ_NONE;	/* fuction to handle charger presence events */	ret = twl4030charger_presence_evt();	if(ret == -ENXIO)		twl4030charger_hw_presence_en(EVT_DISABLE);			if(ret)		return IRQ_NONE;			return IRQ_HANDLED;}

int ehci_hcd_init(int index, enum usb_init_type init,		struct ehci_hccr **hccr, struct ehci_hcor **hcor){	u8 val;	int offset;	if (gpio_request(SB_T35_USB_HUB_RESET_GPIO, "SB-T35 usb hub reset")) {		printf("Error: can't obtain GPIO %d for SB-T35 usb hub reset",				SB_T35_USB_HUB_RESET_GPIO);		return -1;	}	gpio_direction_output(SB_T35_USB_HUB_RESET_GPIO, 0);	udelay(10);	gpio_set_value(SB_T35_USB_HUB_RESET_GPIO, 1);	udelay(1000);	offset = TWL4030_BASEADD_GPIO + TWL4030_GPIO_GPIODATADIR1;	twl4030_i2c_read_u8(TWL4030_CHIP_GPIO, offset, &val);	/* Set GPIO6 and GPIO7 of TPS65930 as output */	val |= 0xC0;	twl4030_i2c_write_u8(TWL4030_CHIP_GPIO, offset, val);	offset = TWL4030_BASEADD_GPIO + TWL4030_GPIO_SETGPIODATAOUT1;	/* Take both PHYs out of reset */	twl4030_i2c_write_u8(TWL4030_CHIP_GPIO, offset, 0xC0);	udelay(1);	return omap_ehci_hcd_init(index, &usbhs_bdata, hccr, hcor);}

int status_get_buttons(void){ // convert button state into led state (for mirror)	int status=0;	if(GPIO_AUX >= 0)		status |= ((omap_get_gpio_datain(GPIO_AUX) == GPIO_AUX_ACTIVE) << 0);	if(GPIO_GPSEXT >= 0)		status |= ((omap_get_gpio_datain(GPIO_GPSEXT)) << 1);	if(GPIO_POWER >= 0)		status |= ((!omap_get_gpio_datain(GPIO_POWER)) << 3);	else		{		u8 val;		i2c_set_bus_num(TWL4030_I2C_BUS);	// read I2C1		twl4030_i2c_read_u8(TWL4030_CHIP_PM_MASTER, &val, TWL4030_PM_MASTER_STS_HW_CONDITIONS);	// read state of power button (bit 0) from TPS65950		status |= (((val&0x01) != 0) << 3);		}	if(GPIO_PENIRQ >= 0)		status |= ((!omap_get_gpio_datain(GPIO_PENIRQ)) << 4);	if(GPIO_KEYIRQ >= 0)		status |= ((omap_get_gpio_datain(GPIO_KEYIRQ)) << 5);	return status;#if OLD#if defined(CONFIG_OMAP3_GTA04)	u8 val;	i2c_set_bus_num(TWL4030_I2C_BUS);	// read I2C1	twl4030_i2c_read_u8(TWL4030_CHIP_PM_MASTER, &val, TWL4030_PM_MASTER_STS_HW_CONDITIONS);	// read state of power button (bit 0) from TPS65950	return ((omap_get_gpio_datain(GPIO_AUX)) << 0) |		((omap_get_gpio_datain(GPIO_GPSEXT)) << 1) |		(((val&0x01) != 0) << 3) |		((omap_get_gpio_datain(GPIO_PENIRQ)) << 4);#elif defined(CONFIG_GOLDELICO_EXPANDER_B2)	return		((omap_get_gpio_datain(GPIO_AUX)) << 0) |		((0) << 1) |	((GPIO_POWER>=0?(!omap_get_gpio_datain(GPIO_POWER)):0) << 3) |		((omap_get_gpio_datain(GPIO_PENIRQ)) << 4);#else	return		((!omap_get_gpio_datain(GPIO_AUX)) << 0) |		((omap_get_gpio_datain(GPIO_GPSEXT)) << 1) |	((GPIO_POWER>=0?(!omap_get_gpio_datain(GPIO_POWER)):0) << 3) |		((omap_get_gpio_datain(GPIO_PENIRQ)) << 4);#endif#endif}

/* * To read a TWL4030 GPIO module register */static inline int gpio_twl4030_read(u8 address){	u8 data;	int ret = 0;	ret = twl4030_i2c_read_u8(TWL4030_MODULE_GPIO, &data, address);	return (ret < 0) ? ret : data;}

static int twl4030battery_presence_evt(void){	int ret;	u8 batstsmchg, batstspchg;		/* In case of invalid service event function abandon */	if (twl4030battery_event.battery_presence == NULL)		return -ENXIO;				/* checking for battery presence in main charge*/			if ((ret = twl4030_i2c_read_u8(TWL4030_MODULE_MAIN_CHARGE, 			&batstsmchg, REG_BCIMFSTS3)))		return ret;				/* checking for battery presence in precharge*/			if ((ret = twl4030_i2c_read_u8(TWL4030_MODULE_PRECHARGE,			&batstspchg, REG_BCIMFSTS1)))		return ret;		/* In case of the battery insertion event */	if ((batstspchg & BATSTSPCHG) || (batstsmchg & BATSTSMCHG))	{					/* calling the battery presence event service function */		twl4030battery_event.battery_presence(EVT_BATTSTS_CONN);				ret = clear_n_set(TWL4030_MODULE_INTERRUPTS, BATSTS_EDRRISIN,			BATSTS_EDRFALLING, REG_BCIEDR2);		if (ret)			return ret;	}		/* In case of the battery removal event */	else	{			/* calling the battery presence event service function */		twl4030battery_event.battery_presence(EVT_BATTSTS_DISC);				ret = clear_n_set(TWL4030_MODULE_INTERRUPTS, BATSTS_EDRFALLING,			BATSTS_EDRRISIN, REG_BCIEDR2);		if (ret)			return ret;	}			return 0;}

static irqreturn_t twl4030_rtc_interrupt(int irq, void *rtc){	unsigned long events = 0;	int ret = IRQ_NONE;	int res;	u8 rd_reg;#ifdef CONFIG_LOCKDEP	/* WORKAROUND for lockdep forcing IRQF_DISABLED on us, which	 * we don't want and can't tolerate.  Although it might be	 * friendlier not to borrow this thread context...	 */	local_irq_enable();#endif	res = twl4030_rtc_read_u8(&rd_reg, REG_RTC_STATUS_REG);	if (res)		goto out;	/*	 * Figure out source of interrupt: ALARM or TIMER in RTC_STATUS_REG.	 * only one (ALARM or RTC) interrupt source may be enabled	 * at time, we also could check our results	 * by reading RTS_INTERRUPTS_REGISTER[IT_TIMER,IT_ALARM]	 */	if (rd_reg & BIT_RTC_STATUS_REG_ALARM_M)		events |= RTC_IRQF | RTC_AF;	else		events |= RTC_IRQF | RTC_UF;	res = twl4030_rtc_write_u8(rd_reg | BIT_RTC_STATUS_REG_ALARM_M,				   REG_RTC_STATUS_REG);	if (res)		goto out;	/* Clear on Read enabled. RTC_IT bit of TWL4030_INT_PWR_ISR1	 * needs 2 reads to clear the interrupt. One read is done in	 * do_twl4030_pwrirq(). Doing the second read, to clear	 * the bit.	 *	 * FIXME the reason PWR_ISR1 needs an extra read is that	 * RTC_IF retriggered until we cleared REG_ALARM_M above.	 * But re-reading like this is a bad hack; by doing so we	 * risk wrongly clearing status for some other IRQ (losing	 * the interrupt).  Be smarter about handling RTC_UF ...	 */	res = twl4030_i2c_read_u8(TWL4030_MODULE_INT,			&rd_reg, TWL4030_INT_PWR_ISR1);	if (res)		goto out;	/* Notify RTC core on event */	rtc_update_irq(rtc, 1, events);	ret = IRQ_HANDLED;out:	return ret;}

int board_mmc_getcd(struct mmc *mmc){	u8 val;	if (twl4030_i2c_read_u8(TWL4030_CHIP_GPIO, TWL4030_BASEADD_GPIO, &val))		return -1;	return !(val & 1);}

/** * @brief omap3evmdc_mdc_config - GPIO configuration for *                          GPIO 134, 54 and 136 * * @return result of operation - 0 is success */static int omap3evmdc_mdc_config(void){	if (is_dec_onboard) {		unsigned char val;		/* Set GPIO8 = 1 */		twl4030_i2c_read_u8(TWL4030_MODULE_GPIO, &val,				REG_GPIODATAOUT2);		val &= ~0x1;		twl4030_i2c_write_u8(TWL4030_MODULE_GPIO, val,				REG_GPIODATAOUT2);		/* Enable Video Decoder */		omap_cfg_reg(AA21_34XX_GPIO157);		if (gpio_request(nCAM_VD_SEL, "Vid-Dec Sel") < 0) {			printk(KERN_ERR "Failed to get GPIO 157/n");			return -EINVAL;		}		gpio_direction_output(nCAM_VD_SEL, 1);		omap_cfg_reg(C23_34XX_GPIO98);		if (gpio_request(GPIO98_VID_DEC_RES, "vid-dec reset") < 0) {			printk(KERN_ERR "failed to get GPIO98_VID_DEC_RES/n");			return -EINVAL;		}		gpio_direction_output(GPIO98_VID_DEC_RES, 1);	} else {		/* Setting the MUX configuration */		omap_cfg_reg(AG4_34XX_GPIO134);		omap_cfg_reg(U8_34XX_GPIO54);		omap_cfg_reg(AE4_34XX_GPIO136);		if (gpio_request(GPIO134_SEL_TVP_Y, "TVP5146 Vid-in") < 0) {			printk(KERN_ERR MODULE_NAME ": Can't get GPIO 134/n");			return -EINVAL;		}		if (gpio_request(GPIO54_SEL_EXP_CAM, "EXP_CAM Vid-in") < 0) {			printk(KERN_ERR MODULE_NAME ": Can't get GPIO 54/n");			return -EINVAL;		}		if (gpio_request(GPIO136_SEL_CAM, "CAM Vid-in") < 0) {			printk(KERN_ERR MODULE_NAME ": Can't get GPIO 136/n");			return -EINVAL;		}		/* Make GPIO as output */		gpio_direction_output(GPIO134_SEL_TVP_Y, 0);		gpio_direction_output(GPIO54_SEL_EXP_CAM, 0);		gpio_direction_output(GPIO136_SEL_CAM, 0);	}	return 0;}