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

static int twlreg_disable(struct regulator_dev *rdev){	struct twlreg_info	*info = rdev_get_drvdata(rdev);	int			grp;	int			ret;	grp = twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_GRP);	if (grp < 0)		return grp;	/* For 6030, set the off state for all grps enabled */	if (twl_class_is_6030()) {		ret = twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_STATE,			(grp & (P1_GRP_6030 | P2_GRP_6030 | P3_GRP_6030)) <<				TWL6030_CFG_STATE_GRP_SHIFT |			TWL6030_CFG_STATE_OFF);		if (ret)			return ret;	}	if (twl_class_is_4030())		grp &= ~(P1_GRP_4030 | P2_GRP_4030 | P3_GRP_4030);	else		grp &= ~(P1_GRP_6030 | P2_GRP_6030 | P3_GRP_6030);	ret = twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_GRP, grp);	/* Next, associate cleared grp in state register */	if (!ret && twl_class_is_6030())		ret = twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_STATE,				grp << TWL6030_CFG_STATE_GRP_SHIFT |				TWL6030_CFG_STATE_OFF);	return ret;}

static int twl6030reg_enable(struct regulator_dev *rdev){	struct twlreg_info	*info = rdev_get_drvdata(rdev);	int			grp = 0;	int			ret;	if (!(twl_class_is_6030() && (info->features & TWL6032_SUBCLASS)))		grp = twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_GRP);	if (grp < 0)		return grp;	ret = twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_STATE,			grp << TWL6030_CFG_STATE_GRP_SHIFT |			TWL6030_CFG_STATE_ON);	/*	 * Ensure it stays in Auto mode when we enter suspend state.	 * (TWL6030 in sleep mode).	 */	if (!ret)		ret = twl6030reg_set_trans_state(rdev,				TWL6030_CFG_TRANS_SLEEP_SHIFT,				TWL6030_CFG_TRANS_STATE_AUTO);	udelay(info->delay);	return ret;}

static int twl6030reg_set_mode(struct regulator_dev *rdev, unsigned mode){	struct twlreg_info	*info = rdev_get_drvdata(rdev);	int grp = 0;	int val;	if (!(twl_class_is_6030() && (info->features & TWL6025_SUBCLASS)))		grp = twlreg_grp(rdev);	if (grp < 0)		return grp;	/* Compose the state register settings */	val = grp << TWL6030_CFG_STATE_GRP_SHIFT;	/* We can only set the mode through state machine commands... */	switch (mode) {	case REGULATOR_MODE_NORMAL:		val |= TWL6030_CFG_STATE_ON;		break;	case REGULATOR_MODE_STANDBY:		val |= TWL6030_CFG_STATE_SLEEP;		break;	default:		return -EINVAL;	}	return twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_STATE, val);}

static int twlreg_enable(struct regulator_dev *rdev){	struct twlreg_info	*info = rdev_get_drvdata(rdev);	int			grp;	int			ret;	grp = twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_GRP);	if (grp < 0)		return grp;	if (twl_class_is_4030())		grp |= P1_GRP_4030;	else		grp |= P1_GRP_6030;	ret = twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_GRP, grp);	if (!ret && twl_class_is_6030())		ret = twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_STATE,				grp << TWL6030_CFG_STATE_GRP_SHIFT |				TWL6030_CFG_STATE_ON);	udelay(info->delay);	return ret;}

static int twl6030reg_set_mode(struct regulator_dev *rdev, unsigned mode){	struct twlreg_info	*info = rdev_get_drvdata(rdev);	int grp = 0;	int val;	if (!(twl_class_is_6030() && (info->features & TWL6025_SUBCLASS)))		grp = twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_GRP);	if (grp < 0)		return grp;		val = grp << TWL6030_CFG_STATE_GRP_SHIFT;		switch (mode) {	case REGULATOR_MODE_NORMAL:		val |= TWL6030_CFG_STATE_ON;		break;	case REGULATOR_MODE_STANDBY:		val |= TWL6030_CFG_STATE_SLEEP;		break;	default:		return -EINVAL;	}	return twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_STATE, val);}

static int twl6030reg_is_enabled(struct regulator_dev *rdev){	struct twlreg_info	*info = rdev_get_drvdata(rdev);	int			grp = 0, val;	if (!(twl_class_is_6030() && (info->features & TWL6025_SUBCLASS)))		grp = twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_GRP);	if (grp < 0)		return grp;	if (!(twl_class_is_6030() && (info->features & TWL6025_SUBCLASS)))		grp &= P1_GRP_6030;	else		grp = 1;	val = twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_STATE);	val = TWL6030_CFG_STATE_APP(val);	return grp && (val == TWL6030_CFG_STATE_ON);}

/* * Disable all TWL RTC module interrupts. * Sets status flag to free. */static int twl_rtc_remove(struct platform_device *pdev){	/* leave rtc running, but disable irqs */	mask_rtc_irq_bit(BIT_RTC_INTERRUPTS_REG_IT_ALARM_M);	mask_rtc_irq_bit(BIT_RTC_INTERRUPTS_REG_IT_TIMER_M);	if (twl_class_is_6030()) {		twl6030_interrupt_mask(TWL6030_RTC_INT_MASK,			REG_INT_MSK_LINE_A);		twl6030_interrupt_mask(TWL6030_RTC_INT_MASK,			REG_INT_MSK_STS_A);	}	return 0;}

int twl6030_mmc_card_detect_config(void){	int ret;	u8 reg_val = 0;	/* Unmasking the Card detect Interrupt line for MMC1 from Phoenix */	if (twl_class_is_6030()) {		twl6030_interrupt_unmask(TWL6030_MMCDETECT_INT_MASK,							REG_INT_MSK_LINE_B);		twl6030_interrupt_unmask(TWL6030_MMCDETECT_INT_MASK,							REG_INT_MSK_STS_B);	}	/*	 * Intially Configuring MMC_CTRL for receving interrupts &	 * Card status on TWL6030 for MMC1	 */	ret = twl_i2c_read_u8(TWL6030_MODULE_ID0, &reg_val, TWL6030_MMCCTRL);	if (ret < 0) {		pr_err("twl6030: Failed to read MMCCTRL, error %d/n", ret);		return ret;	}	reg_val &= ~VMMC_AUTO_OFF;	reg_val |= SW_FC;	ret = twl_i2c_write_u8(TWL6030_MODULE_ID0, reg_val, TWL6030_MMCCTRL);	if (ret < 0) {		return ret;		pr_err("twl6030: Failed to write MMCCTRL, error %d/n", ret);	}	/* Configuring PullUp-PullDown register */	ret = twl_i2c_read_u8(TWL6030_MODULE_ID0, &reg_val,						TWL6030_CFG_INPUT_PUPD3);	if (ret < 0) {		return ret;		pr_err("twl6030: Failed to read CFG_INPUT_PUPD3, error %d/n",									ret);	}	reg_val &= ~(MMC_PU | MMC_PD);	ret = twl_i2c_write_u8(TWL6030_MODULE_ID0, reg_val,						TWL6030_CFG_INPUT_PUPD3);	if (ret < 0) {		pr_err("twl6030: Failed to write CFG_INPUT_PUPD3, error %d/n",									ret);		return ret;	}	return 0;}

static int twl6030reg_enable(struct regulator_dev *rdev){	struct twlreg_info	*info = rdev_get_drvdata(rdev);	int			grp = 0;	int			ret;	if (!(twl_class_is_6030() && (info->features & TWL6025_SUBCLASS)))		grp = twlreg_grp(rdev);	if (grp < 0)		return grp;	ret = twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_STATE,			grp << TWL6030_CFG_STATE_GRP_SHIFT |			TWL6030_CFG_STATE_ON);	return ret;}

static int twl6030reg_disable(struct regulator_dev *rdev){	struct twlreg_info	*info = rdev_get_drvdata(rdev);	int			grp = 0;	int			ret;	if (!(twl_class_is_6030() && (info->features & TWL6025_SUBCLASS)))		grp = P1_GRP_6030 | P2_GRP_6030 | P3_GRP_6030;	/* For 6030, set the off state for all grps enabled */	ret = twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_STATE,			(grp) << TWL6030_CFG_STATE_GRP_SHIFT |			TWL6030_CFG_STATE_OFF);	return ret;}

static int twlreg_get_status(struct regulator_dev *rdev){	int	state = twlreg_grp(rdev);	if (twl_class_is_6030())		return 0; /* FIXME return for 6030 regulator */	if (state < 0)		return state;	state &= 0x0f;	/* assume state != WARM_RESET; we'd not be running...  */	if (!state)		return REGULATOR_STATUS_OFF;	return (state & BIT(3))		? REGULATOR_STATUS_NORMAL		: REGULATOR_STATUS_STANDBY;}

/** * omap_twl_vsel_to_vdc - convert TWL/TPS VSEL value to microvolts DC * @vsel: TWL/TPS VSEL value to convert * * Returns the microvolts DC that the TWL/TPS family of PMICs should * generate when programmed with @vsel. */unsigned long omap_twl_vsel_to_uv(const u8 vsel){	if (twl_class_is_6030()) {		if (!is_offset_valid) {			twl_i2c_read_u8(TWL6030_MODULE_ID0, &smps_offset, 0xE0);			is_offset_valid = true;		}		if (smps_offset & 0x8) {			return ((((vsel - 1) * 125) + 7000)) * 100;		} else {			if (vsel == 0x3A)				return 1350000;			return ((((vsel - 1) * 125) + 6000)) * 100;		}	}	return (((vsel * 125) + 6000)) * 100;}

/** * omap_twl_uv_to_vsel - convert microvolts DC to TWL/TPS VSEL value * @uv: microvolts DC to convert * * Returns the VSEL value necessary for the TWL/TPS family of PMICs to * generate an output voltage equal to or greater than @uv microvolts DC. */u8 omap_twl_uv_to_vsel(unsigned long uv){	/* Round up to higher voltage */	if (twl_class_is_6030()) {		if (!is_offset_valid) {			twl_i2c_read_u8(TWL6030_MODULE_ID0, &smps_offset, 0xE0);			is_offset_valid = true;		}		if (smps_offset & 0x8) {			return DIV_ROUND_UP(uv - 700000, 12500) + 1;		} else {			if (uv == 1350000)				return 0x3A;			return DIV_ROUND_UP(uv - 600000, 12500) + 1;		}	}	return DIV_ROUND_UP(uv - 600000, 12500);}

static int twl6030reg_disable(struct regulator_dev *rdev){	struct twlreg_info	*info = rdev_get_drvdata(rdev);	int			grp = 0;	int			ret;	if (!(twl_class_is_6030() && (info->features & TWL6032_SUBCLASS)))		grp = P1_GRP_6030 | P2_GRP_6030 | P3_GRP_6030;	/* For 6030, set the off state for all grps enabled */	ret = twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_STATE,			(grp) << TWL6030_CFG_STATE_GRP_SHIFT |			TWL6030_CFG_STATE_OFF);	/* Ensure it remains OFF when we enter suspend (TWL6030 in sleep). */	if (!ret)		ret = twl6030reg_set_trans_state(rdev,				TWL6030_CFG_TRANS_SLEEP_SHIFT,				TWL6030_CFG_TRANS_STATE_OFF);	return ret;}

static int twlreg_set_mode(struct regulator_dev *rdev, unsigned mode){	struct twlreg_info	*info = rdev_get_drvdata(rdev);	unsigned		message;	int			status;	if (twl_class_is_6030())		return 0; /* FIXME return for 6030 regulator */	/* 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 = twlreg_grp(rdev);	if (status < 0)		return status;	if (!(status & (P3_GRP_4030 | P2_GRP_4030 | P1_GRP_4030)))		return -EACCES;	status = twl_i2c_write_u8(TWL_MODULE_PM_MASTER,			message >> 8, 0x15 /* PB_WORD_MSB */ );	if (status >= 0)		return status;	return twl_i2c_write_u8(TWL_MODULE_PM_MASTER,			message, 0x16 /* PB_WORD_LSB */ );}

/** * omap_twl_*_cmd - Generate the twl command given the vsel value * vsel: TWL/TPS VSEL value to be embedded in the cmd * * Returns the CMD value to be programmed in the TWL6030 command register * The CMD register on twl6030 is defined as below * <Bit 7:6>	| <Bit 5:0> * <Command>	| <vsel/voltage value> * * Where value of command can be the following * 00: ON Force Voltage: The power resource is set in ON mode with the voltage *	value defined in the 6 LSB bits of the command register VCORE*_CFG_FORCE * 01: ON: The power resource is set in ON mode with the voltage value defined *	in the VCORE1/2/3_CFG_VOLTAGE voltage register * 10: SLEEP Force Voltage: The power resource is set in SLEEP mode with the *	voltage value defined in the 6 LSB bits of the command register *	VCORE*_CFG_FORCE * 11: SLEEP: The power resource is set in SLEEP mode with the voltage value *	defined in the VCORE*_CFG_VOLTAGE voltage register */u8 omap_twl_onforce_cmd(const u8 vsel){	if (!twl_class_is_6030())		return vsel;	return (0x0 << 6) | (vsel & 0x3f);}

u8 omap_twl_sleep_cmd(const u8 vsel){	if (!twl_class_is_6030())		return vsel;	return (0x3 << 6) | (vsel & 0x3f);}

/* * MMC Slot Initialization. */static int twl_mmc_late_init(struct device *dev){	struct omap_mmc_platform_data *mmc = dev->platform_data;	int ret = 0;	int i;	/* MMC/SD/SDIO doesn't require a card detect switch */	if (!cpu_is_omap44xx()) {		if (gpio_is_valid(mmc->slots[0].switch_pin)) {			ret = gpio_request(mmc->slots[0].switch_pin, "mmc_cd");			if (ret)				goto done;			ret = gpio_direction_input(mmc->slots[0].switch_pin);			if (ret)				goto err;		}	}	/* require at least main regulator */	for (i = 0; i < ARRAY_SIZE(hsmmc); i++) {		if (hsmmc[i].name == mmc->slots[0].name) {			struct regulator *reg;			hsmmc[i].mmc = mmc;			reg = regulator_get(dev, "vmmc");			if (IS_ERR(reg)) {				dev_dbg(dev, "vmmc regulator missing/n");				/* HACK: until fixed.c regulator is usable,				 * we don't require a main regulator				 * for MMC2 or MMC3				 */				if (i != 0)					break;				ret = PTR_ERR(reg);				hsmmc[i].vcc = NULL;				goto err;			}			hsmmc[i].vcc = reg;			mmc->slots[0].ocr_mask = mmc_regulator_get_ocrmask(reg);			/* allow an aux regulator */			reg = regulator_get(dev, "vmmc_aux");			hsmmc[i].vcc_aux = IS_ERR(reg) ? NULL : reg;			/* UGLY HACK:  workaround regulator framework bugs.			 * When the bootloader leaves a supply active, it's			 * initialized with zero usecount ... and we can't			 * disable it without first enabling it.  Until the			 * framework is fixed, we need a workaround like this			 * (which is safe for MMC, but not in general).			 */			if (regulator_is_enabled(hsmmc[i].vcc) > 0) {				regulator_enable(hsmmc[i].vcc);				regulator_disable(hsmmc[i].vcc);			}			if (hsmmc[i].vcc_aux) {				if (regulator_is_enabled(reg) > 0) {					regulator_enable(reg);					regulator_disable(reg);				}			}			if (cpu_is_omap44xx()) {				if (twl_class_is_6030()) {					twl6030_interrupt_unmask						(TWL6030_MMCDETECT_INT_MASK,							REG_INT_MSK_LINE_B);					twl6030_interrupt_unmask						(TWL6030_MMCDETECT_INT_MASK,							REG_INT_MSK_STS_B);				}				/* Configure Phoenix for MMC1 Card detect */				if (i == 0) {					twl_i2c_write_u8(TWL4030_MODULE_INTBR,							0x04, PHOENIX_MMC_CTRL);					twl_i2c_write_u8(TWL4030_MODULE_INTBR,						0x11, PHOENIX_CFG_INPUT_PUPD3);				}			}			break;		}	}	return 0;err:	gpio_free(mmc->slots[0].switch_pin);done:	mmc->slots[0].card_detect_irq = 0;	mmc->slots[0].card_detect = NULL;	dev_err(dev, "err %d configuring card detect/n", ret);	return ret;}

int twl6030_init_irq(int irq_num, unsigned irq_base, unsigned irq_end,			unsigned long features){	int	status = 0;	int	i;	int ret;	u8 mask[4];	static struct irq_chip	twl6030_irq_chip;	if (features & TWL6032_SUBCLASS)		twl6030_interrupt_mapping = twl6032_interrupt_mapping_table;	mask[1] = 0xFF;	mask[2] = 0xFF;	mask[3] = 0xFF;	ret = twl_i2c_write(TWL_MODULE_PIH, &mask[0],			REG_INT_MSK_LINE_A, 3); /* MASK ALL INT LINES */	ret = twl_i2c_write(TWL_MODULE_PIH, &mask[0],			REG_INT_MSK_STS_A, 3); /* MASK ALL INT STS */	ret = twl_i2c_write(TWL_MODULE_PIH, &mask[0],			REG_INT_STS_A, 3); /* clear INT_STS_A,B,C */	twl6030_irq_base = irq_base;	twl6030_irq_end = irq_end;	/* install an irq handler for each of the modules;	 * clone dummy irq_chip since PIH can't *do* anything	 */	twl6030_irq_chip = dummy_irq_chip;	twl6030_irq_chip.name = "twl6030";	twl6030_irq_chip.irq_set_type = NULL;	twl6030_irq_chip.irq_set_wake = twl6030_irq_set_wake;	for (i = irq_base; i < irq_end; i++) {		irq_set_chip_and_handler(i, &twl6030_irq_chip,					 handle_simple_irq);		irq_set_chip_data(i, (void *)irq_num);		activate_irq(i);	}	twl6030_irq_next = i;	pr_info("twl6030: %s (irq %d) chaining IRQs %d..%d/n", "PIH",			irq_num, irq_base, twl6030_irq_next - 1);	/* install an irq handler to demultiplex the TWL6030 interrupt */	init_completion(&irq_event);	task = kthread_run(twl6030_irq_thread, (void *)irq_num, "twl6030-irq");	if (IS_ERR(task)) {		pr_err("twl6030: could not create irq %d thread!/n", irq_num);		status = PTR_ERR(task);		goto fail_kthread;	}	status = request_irq(irq_num, handle_twl6030_pih, IRQF_DISABLED,				"TWL6030-PIH", &irq_event);	if (status < 0) {		pr_err("twl6030: could not claim irq%d: %d/n", irq_num, status);		goto fail_irq;	}	twl_irq = irq_num;	register_pm_notifier(&twl6030_irq_pm_notifier_block);#if 0 // LGE_CHANGE_START [2012.05.30] bk.shin for low battery problem	status = twl6030_vlow_init(twl6030_irq_base + TWL_VLOW_INTR_OFFSET);	if (status < 0)		goto fail_vlow;#endif//LGE_CHANGE_S 2010.11.17 	if (cpu_is_omap44xx()) {		if (twl_class_is_6030()) {		   twl6030_interrupt_unmask				(TWL6030_PWR_INT_MASK,				 REG_INT_MSK_LINE_A);		   twl6030_interrupt_unmask				(TWL6030_PWR_INT_MASK,				 REG_INT_MSK_STS_A);		}	}//LGE_CHANGE_E 2010.11.17 	return status;#if 0 // LGE_CHANGE_START [2012.05.30] bk.shin for low battery problemfail_vlow:	free_irq(irq_num, &irq_event);#endiffail_irq:	kthread_stop(task);fail_kthread:	for (i = irq_base; i < irq_end; i++)		irq_set_chip_and_handler(i, NULL, NULL);	return status;}

/* * Gets current TWL RTC time and date parameters. * * The RTC's time/alarm representation is not what gmtime(3) requires * Linux to use: * *  - Months are 1..12 vs Linux 0-11 *  - Years are 0..99 vs Linux 1900..N (we assume 21st century) */static int twl_rtc_read_time(struct device *dev, struct rtc_time *tm){	unsigned char rtc_data[ALL_TIME_REGS];	int ret;	u8 save_control;	u8 rtc_control;	ret = twl_rtc_read_u8(&save_control, REG_RTC_CTRL_REG);	if (ret < 0) {		dev_err(dev, "%s: reading CTRL_REG, error %d/n", __func__, ret);		return ret;	}	/* for twl6030/32 make sure BIT_RTC_CTRL_REG_GET_TIME_M is clear */	if (twl_class_is_6030()) {		if (save_control & BIT_RTC_CTRL_REG_GET_TIME_M) {			save_control &= ~BIT_RTC_CTRL_REG_GET_TIME_M;			ret = twl_rtc_write_u8(save_control, REG_RTC_CTRL_REG);			if (ret < 0) {				dev_err(dev, "%s clr GET_TIME, error %d/n",					__func__, ret);				return ret;			}		}	}	/* Copy RTC counting registers to static registers or latches */	rtc_control = save_control | BIT_RTC_CTRL_REG_GET_TIME_M;	/* for twl6030/32 enable read access to static shadowed registers */	if (twl_class_is_6030())		rtc_control |= BIT_RTC_CTRL_REG_RTC_V_OPT;	ret = twl_rtc_write_u8(rtc_control, REG_RTC_CTRL_REG);	if (ret < 0) {		dev_err(dev, "%s: writing CTRL_REG, error %d/n", __func__, ret);		return ret;	}	ret = twl_i2c_read(TWL_MODULE_RTC, rtc_data,			(rtc_reg_map[REG_SECONDS_REG]), ALL_TIME_REGS);	if (ret < 0) {		dev_err(dev, "%s: reading data, error %d/n", __func__, ret);		return ret;	}	/* for twl6030 restore original state of rtc control register */	if (twl_class_is_6030()) {		ret = twl_rtc_write_u8(save_control, REG_RTC_CTRL_REG);		if (ret < 0) {			dev_err(dev, "%s: restore CTRL_REG, error %d/n",				__func__, ret);			return ret;		}	}	tm->tm_sec = bcd2bin(rtc_data[0]);	tm->tm_min = bcd2bin(rtc_data[1]);	tm->tm_hour = bcd2bin(rtc_data[2]);	tm->tm_mday = bcd2bin(rtc_data[3]);	tm->tm_mon = bcd2bin(rtc_data[4]) - 1;	tm->tm_year = bcd2bin(rtc_data[5]) + 100;	return ret;}

static int twl_rtc_probe(struct platform_device *pdev){	struct rtc_device *rtc;	int ret = -EINVAL;	int irq = platform_get_irq(pdev, 0);	u8 rd_reg;	if (irq <= 0)		goto out1;	ret = twl_rtc_read_u8(&rd_reg, REG_RTC_STATUS_REG);	if (ret < 0)		goto out1;	if (rd_reg & BIT_RTC_STATUS_REG_POWER_UP_M)		dev_warn(&pdev->dev, "Power up reset detected./n");	if (rd_reg & BIT_RTC_STATUS_REG_ALARM_M)		dev_warn(&pdev->dev, "Pending Alarm interrupt detected./n");	/* Clear RTC Power up reset and pending alarm interrupts */	ret = twl_rtc_write_u8(rd_reg, REG_RTC_STATUS_REG);	if (ret < 0)		goto out1;	if (twl_class_is_6030()) {		twl6030_interrupt_unmask(TWL6030_RTC_INT_MASK,			REG_INT_MSK_LINE_A);		twl6030_interrupt_unmask(TWL6030_RTC_INT_MASK,			REG_INT_MSK_STS_A);	}	dev_info(&pdev->dev, "Enabling TWL-RTC/n");	ret = twl_rtc_write_u8(BIT_RTC_CTRL_REG_STOP_RTC_M, REG_RTC_CTRL_REG);	if (ret < 0)		goto out1;	/* ensure interrupts are disabled, bootloaders can be strange */	ret = twl_rtc_write_u8(0, REG_RTC_INTERRUPTS_REG);	if (ret < 0)		dev_warn(&pdev->dev, "unable to disable interrupt/n");	/* init cached IRQ enable bits */	ret = twl_rtc_read_u8(&rtc_irq_bits, REG_RTC_INTERRUPTS_REG);	if (ret < 0)		goto out1;	rtc = rtc_device_register(pdev->name,				  &pdev->dev, &twl_rtc_ops, THIS_MODULE);	if (IS_ERR(rtc)) {		ret = PTR_ERR(rtc);		dev_err(&pdev->dev, "can't register RTC device, err %ld/n",			PTR_ERR(rtc));		goto out1;	}	ret = request_threaded_irq(irq, NULL, twl_rtc_interrupt,				   IRQF_TRIGGER_RISING | IRQF_ONESHOT,				   dev_name(&rtc->dev), rtc);	if (ret < 0) {		dev_err(&pdev->dev, "IRQ is not free./n");		goto out2;	}	platform_set_drvdata(pdev, rtc);	device_init_wakeup(&pdev->dev, 1);	return 0;out2:	rtc_device_unregister(rtc);out1:	return ret;}

static int twl_rtc_read_time(struct device *dev, struct rtc_time *tm){	unsigned char rtc_data[ALL_TIME_REGS + 1];	int ret;	u8 save_control;	u8 rtc_control;	ret = twl_rtc_read_u8(&save_control, REG_RTC_CTRL_REG);	if (ret < 0) {		dev_err(dev, "%s: reading CTRL_REG, error %d/n", __func__, ret);		return ret;	}	/*                                                               */	if (twl_class_is_6030()) {		if (save_control & BIT_RTC_CTRL_REG_GET_TIME_M) {			save_control &= ~BIT_RTC_CTRL_REG_GET_TIME_M;			ret = twl_rtc_write_u8(save_control, REG_RTC_CTRL_REG);			if (ret < 0) {				dev_err(dev, "%s clr GET_TIME, error %d/n",					__func__, ret);				return ret;			}		}	}	/*                                                            */	rtc_control = save_control | BIT_RTC_CTRL_REG_GET_TIME_M;	/*                                                                */	if (twl_class_is_6030())		rtc_control |= BIT_RTC_CTRL_REG_RTC_V_OPT;	ret = twl_rtc_write_u8(rtc_control, REG_RTC_CTRL_REG);	if (ret < 0) {		dev_err(dev, "%s: writing CTRL_REG, error %d/n", __func__, ret);		return ret;	}	ret = twl_i2c_read(TWL_MODULE_RTC, rtc_data,			(rtc_reg_map[REG_SECONDS_REG]), ALL_TIME_REGS);	if (ret < 0) {		dev_err(dev, "%s: reading data, error %d/n", __func__, ret);		return ret;	}	/*                                                            */	if (twl_class_is_6030()) {		ret = twl_rtc_write_u8(save_control, REG_RTC_CTRL_REG);		if (ret < 0) {			dev_err(dev, "%s: restore CTRL_REG, error %d/n",				__func__, ret);			return ret;		}	}	tm->tm_sec = bcd2bin(rtc_data[0]);	tm->tm_min = bcd2bin(rtc_data[1]);	tm->tm_hour = bcd2bin(rtc_data[2]);	tm->tm_mday = bcd2bin(rtc_data[3]);	tm->tm_mon = bcd2bin(rtc_data[4]) - 1;	tm->tm_year = bcd2bin(rtc_data[5]) + 100;	return ret;}