自学教程：C++ twl4030_i2c_write_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 omap3devkit9100_panel_init(struct lcd_panel *panel,				struct omapfb_device *fbdev){	printk("%s was invoked/n", __FUNCTION__);#if 0	gpio_request(LCD_PANEL_ENABLE_GPIO, "LCD enable");#else	twl4030_i2c_write_u8(TWL4030_MODULE_GPIO, 0x80, REG_GPIODATADIR1);//set to output	twl4030_i2c_write_u8(TWL4030_MODULE_LED, 0x0, 0x0);#endif/* 	gpio_request(LCD_PANEL_LR, "LCD lr");	gpio_request(LCD_PANEL_UD, "LCD ud");	gpio_request(LCD_PANEL_INI, "LCD ini");	gpio_request(LCD_PANEL_RESB, "LCD resb");	gpio_request(LCD_PANEL_QVGA, "LCD qvga");	gpio_direction_output(LCD_PANEL_RESB, 1);	gpio_direction_output(LCD_PANEL_INI, 1);	gpio_direction_output(LCD_PANEL_QVGA, 0);	gpio_direction_output(LCD_PANEL_LR, 1);	gpio_direction_output(LCD_PANEL_UD, 1);	twl4030_i2c_write_u8(TWL4030_MODULE_LED, 0x11, TWL_LED_LEDEN);	twl4030_i2c_write_u8(TWL4030_MODULE_PWMA, 0x01, TWL_PWMA_PWMAON);	twl4030_i2c_write_u8(TWL4030_MODULE_PWMA, 0x02, TWL_PWMA_PWMAOFF);	*/	return 0;}

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()) {		u8 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;}

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 enable(1)/disable(0) the voltage for TS: uses twl4030 calls */static int ads7846_vaux_control(int vaux_cntrl){	int ret = 0;#ifdef CONFIG_TWL4030_CORE	/* check for return value of ldo_use: if success it returns 0 */	if (vaux_cntrl == VAUX_ENABLE) {		if (ret != twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,			ENABLE_VAUX3_DEDICATED, TWL4030_VAUX3_DEDICATED))			return -EIO;		if (ret != twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,			ENABLE_VAUX3_DEV_GRP, TWL4030_VAUX3_DEV_GRP))			return -EIO;	} else if (vaux_cntrl == VAUX_DISABLE) {		if (ret != twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,			0x00, TWL4030_VAUX3_DEDICATED))			return -EIO;		if (ret != twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,			0x00, TWL4030_VAUX3_DEV_GRP))			return -EIO;	}#else	ret = -EIO;#endif	return ret;}

static void sdp3430_panel_disable_tv(struct omap_display *display){	twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0x00,			TWL4030_VDAC_DEDICATED);	twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0x00,			TWL4030_VDAC_DEV_GRP);}

void __init twl4030_power_init(struct twl4030_power_data *triton2_scripts){	int err = 0;	int i;	struct twl4030_resconfig *resconfig;	err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, KEY_1,				R_PROTECT_KEY);	err |= twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, KEY_2,				R_PROTECT_KEY);	if (err)		printk(KERN_ERR			"TWL4030 Unable to unlock registers/n");	for (i = 0; i < triton2_scripts->size; i++) {		err = load_triton_script(triton2_scripts->scripts[i]);		if (err)			break;	}	resconfig = triton2_scripts->resource_config;	if (resconfig) {		while (resconfig->resource) {			twl4030_configure_resource(resconfig);			resconfig++;		}	}	if (twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0, R_PROTECT_KEY))		printk(KERN_ERR			"TWL4030 Unable to relock registers/n");}

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;}

int twl4030_add_sleep_script(void){	int err;	err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, KEY_1,			R_PROTECT_KEY);	if (err) {		pr_err("twl4030: unable to unlock PROTECT_KEY/n");		return err;	}	err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, KEY_2,			R_PROTECT_KEY);	if (err) {		pr_err("twl4030: unable to unlock PROTECT_KEY/n");		return err;	}	err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, triton_sleep_script_address, R_SEQ_ADD_A2S);	if (err) {            pr_err("twl4030: unable to program sleep script address/n");            return err;        }	err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0, R_PROTECT_KEY);	if (err)		pr_err("TWL4030 Unable to relock registers/n");	return err;}

static void boxer_panel_disable_tv(struct omap_dss_device *dssdev){	twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0x00,			TWL4030_VDAC_DEDICATED);	twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0x00,			TWL4030_VDAC_DEV_GRP);}

/* 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);}

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);}

void __led_set(led_id_t mask, int state){#ifdef CONFIG_LED_STATUS0	if (CONFIG_LED_STATUS_BIT & mask) {		gpio_request(TRICORDER_STATUS_LED_GREEN, "");		gpio_direction_output(TRICORDER_STATUS_LED_GREEN, 0);		gpio_set_value(TRICORDER_STATUS_LED_GREEN, state);	}#endif#ifdef CONFIG_LED_STATUS1	if (CONFIG_LED_STATUS_BIT1 & mask) {		gpio_request(TRICORDER_STATUS_LED_YELLOW, "");		gpio_direction_output(TRICORDER_STATUS_LED_YELLOW, 0);		gpio_set_value(TRICORDER_STATUS_LED_YELLOW, state);	}#endif#ifdef CONFIG_LED_STATUS2	if (CONFIG_LED_STATUS_BIT2 & mask) {		if (CONFIG_LED_STATUS_OFF == state)			twl4030_i2c_write_u8(TWL4030_CHIP_LED,					     TWL4030_LED_LEDEN, 0);		else			twl4030_i2c_write_u8(TWL4030_CHIP_LED,					     TWL4030_LED_LEDEN,					     (TWL4030_LED_LEDEN_LEDAON |					      TWL4030_LED_LEDEN_LEDAPWM));	}#endif}

/* * 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 void omap3devkit9100_panel_disable(struct lcd_panel *panel){#if 0	gpio_set_value(LCD_PANEL_ENABLE_GPIO, 0);#else	twl4030_i2c_write_u8(TWL4030_MODULE_GPIO, 0x00, REG_GPIODATAOUT1);	twl4030_i2c_write_u8(TWL4030_MODULE_LED, 0x33, 0x0);#endif}

static int enable_vpll2_power(int enable){	twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,				(enable) ? ENABLE_VPLL2_DEDICATED : 0,				TWL4030_VPLL2_DEDICATED);	twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,				(enable) ? ENABLE_VPLL2_DEV_GRP : 0,				TWL4030_VPLL2_DEV_GRP);	return 0;}

static int omap3devkit9100_panel_enable(struct lcd_panel *panel){#if 0	gpio_set_value(LCD_PANEL_ENABLE_GPIO, 1);#else	twl4030_i2c_write_u8(TWL4030_MODULE_GPIO, 0x80, REG_GPIODATAOUT1);//output '1'	twl4030_i2c_write_u8(TWL4030_MODULE_LED, 0x0, 0x0);#endif	return 0;}

static void zoom2_panel_disable_lcd(struct omap_dss_device *dssdev){	twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0,				TWL4030_VPLL2_DEDICATED);	twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0,				TWL4030_VPLL2_DEV_GRP);	gpio_direction_output(LCD_PANEL_ENABLE_GPIO, 0);	gpio_direction_output(LCD_PANEL_BACKLIGHT_GPIO, 0);}

/* * Set Device Group and Voltage */void twl4030_pmrecv_vsel_cfg(u8 vsel_reg, u8 vsel_val,				u8 dev_grp, u8 dev_grp_sel){	/* Select the Device Group */	twl4030_i2c_write_u8(TWL4030_CHIP_PM_RECEIVER, dev_grp_sel,				dev_grp);	/* Select the Voltage */	twl4030_i2c_write_u8(TWL4030_CHIP_PM_RECEIVER, vsel_val,				vsel_reg);}

static int __init twl4030_write_script_byte(u8 address, u8 byte){	int err;	err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, address,					R_MEMORY_ADDRESS);	err |= twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, byte,					R_MEMORY_DATA);	return err;}

void __init twl4030_power_init(struct twl4030_power_data *twl4030_scripts){	int err = 0;	int i;	struct twl4030_resconfig *resconfig;	u8 address = twl4030_start_script_address;	err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, R_KEY_1,				R_PROTECT_KEY);	if (err)		goto unlock;	err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, R_KEY_2,				R_PROTECT_KEY);	if (err)		goto unlock;	for (i = 0; i < twl4030_scripts->num; i++) {		err = load_twl4030_script(twl4030_scripts->scripts[i], address);		if (err)			goto load;		address += twl4030_scripts->scripts[i]->size;	}	resconfig = twl4030_scripts->resource_config;	if (resconfig) {		while (resconfig->resource) {			err = twl4030_configure_resource(resconfig);			if (err)				goto resource;			resconfig++;		}	}	err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0, R_PROTECT_KEY);	if (err)		pr_err("TWL4030 Unable to relock registers/n");	return;unlock:	if (err)		pr_err("TWL4030 Unable to unlock registers/n");	return;load:	if (err)		pr_err("TWL4030 failed to load scripts/n");	return;resource:	if (err)		pr_err("TWL4030 failed to configure resource/n");	return;}

static int boxer_panel_enable_tv(struct omap_dss_device *dssdev){#define ENABLE_VDAC_DEDICATED           0x03#define ENABLE_VDAC_DEV_GRP             0x20	twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,			ENABLE_VDAC_DEDICATED,			TWL4030_VDAC_DEDICATED);	twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,			ENABLE_VDAC_DEV_GRP, TWL4030_VDAC_DEV_GRP);	return 0;}

static int zoom2_panel_enable_lcd(struct omap_dss_device *dssdev){	twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,				ENABLE_VPLL2_DEDICATED,				TWL4030_VPLL2_DEDICATED);	twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,				ENABLE_VPLL2_DEV_GRP,				TWL4030_VPLL2_DEV_GRP);	gpio_direction_output(LCD_PANEL_ENABLE_GPIO, 1);	gpio_direction_output(LCD_PANEL_BACKLIGHT_GPIO, 1);	return 0;}

/* * Routine: reset_net_chip * Description: reset the Ethernet controller via TPS65930 GPIO */static void reset_net_chip(void){	/* Set GPIO1 of TPS65930 as output */	twl4030_i2c_write_u8(TWL4030_CHIP_GPIO, 0x02,			     TWL4030_BASEADD_GPIO+0x03);	/* Send a pulse on the GPIO pin */	twl4030_i2c_write_u8(TWL4030_CHIP_GPIO, 0x02,			     TWL4030_BASEADD_GPIO+0x0C);	udelay(1);	twl4030_i2c_write_u8(TWL4030_CHIP_GPIO, 0x02,			     TWL4030_BASEADD_GPIO+0x09);	udelay(1);	twl4030_i2c_write_u8(TWL4030_CHIP_GPIO, 0x02,			     TWL4030_BASEADD_GPIO+0x0C);}

static int twl4030reg_set_mode(struct regulator_dev *rdev, unsigned mode){	struct twlreg_info	*info = rdev_get_drvdata(rdev);	unsigned		message;	int			status;	/* We can only set the mode through state machine commands... */	switch (mode) {	case REGULATOR_MODE_NORMAL:		message = MSG_SINGULAR(DEV_GRP_P1, info->id, RES_STATE_ACTIVE);		break;	case REGULATOR_MODE_STANDBY:		message = MSG_SINGULAR(DEV_GRP_P1, info->id, RES_STATE_SLEEP);		break;	default:		return -EINVAL;	}	/* Ensure the resource is associated with some group */	status = twl4030reg_grp(rdev);	if (status < 0)		return status;	if (!(status & (P3_GRP | P2_GRP | P1_GRP)))		return -EACCES;	status = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER,			message >> 8, 0x15 /* PB_WORD_MSB */ );	if (status >= 0)		return status;	return twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER,			message, 0x16 /* PB_WORD_LSB */ );}