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, ®_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, ®_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; }
/* * Disable all TWL RTC module interrupts. * Sets status flag to free. */ static int __devexit twl_rtc_remove(struct platform_device *pdev) { /* leave rtc running, but disable irqs */ struct rtc_device *rtc = platform_get_drvdata(pdev); int irq = platform_get_irq(pdev, 0); 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); } free_irq(irq, rtc); rtc_device_unregister(rtc); platform_set_drvdata(pdev, NULL); return 0; }
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 */ ); }
static int __devinit 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); } /* Check RTC module status, Enable if it is off */ ret = twl_rtc_read_u8(&rd_reg, REG_RTC_CTRL_REG); if (ret < 0) goto out1; if (!(rd_reg & BIT_RTC_CTRL_REG_STOP_RTC_M)) { dev_info(&pdev->dev, "Enabling TWL-RTC.\n"); rd_reg = BIT_RTC_CTRL_REG_STOP_RTC_M; ret = twl_rtc_write_u8(rd_reg, REG_RTC_CTRL_REG); if (ret < 0) goto out1; } /* 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, dev_name(&rtc->dev), rtc); if (ret < 0) { dev_err(&pdev->dev, "IRQ is not free.\n"); goto out2; } if (enable_irq_wake(irq) < 0) dev_warn(&pdev->dev, "Cannot enable wakeup for IRQ %d\n", irq); platform_set_drvdata(pdev, rtc); return 0; out2: rtc_device_unregister(rtc); out1: return ret; }
/** * 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); }
static int __devinit twl_rtc_probe(struct platform_device *pdev) { struct rtc_device *rtc; int ret = 0; int irq = platform_get_irq(pdev, 0); u8 rd_reg; unsigned char rtc_init_year; unsigned char rtc_init_month; unsigned char rtc_init_day; unsigned char roll_back_date=0; if (irq <= 0) return -EINVAL; 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 out0; } platform_set_drvdata(pdev, rtc); 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; ret = request_threaded_irq(irq, NULL,twl_rtc_interrupt, IRQF_TRIGGER_RISING, dev_name(&rtc->dev), rtc); if (ret < 0) { dev_err(&pdev->dev, "IRQ is not free.\n"); 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); } /* Check RTC module status, Enable if it is off */ ret = twl_rtc_read_u8(&rd_reg, REG_RTC_CTRL_REG); if (ret < 0) goto out2; if (!(rd_reg & BIT_RTC_CTRL_REG_STOP_RTC_M)) { dev_info(&pdev->dev, "Enabling TWL-RTC.\n"); rd_reg = BIT_RTC_CTRL_REG_STOP_RTC_M; ret = twl_rtc_write_u8(rd_reg, REG_RTC_CTRL_REG); if (ret < 0) goto out2; } ret = twl_rtc_read_u8(&rtc_init_year, REG_YEARS_REG); ret = twl_rtc_read_u8(&rtc_init_month, REG_MONTHS_REG); ret = twl_rtc_read_u8(&rtc_init_day, REG_DAYS_REG); if(rtc_init_year<0x11) { roll_back_date=1; } else if((rtc_init_year==0x11)&&(rtc_init_month==0x01)) { roll_back_date=1; } /* init cached IRQ enable bits */ ret = twl_rtc_read_u8(&rtc_irq_bits, REG_RTC_INTERRUPTS_REG); if (ret < 0) goto out2; return ret; out2: free_irq(irq, rtc); out1: rtc_device_unregister(rtc); out0: return ret; }
static int __devinit twl_rtc_probe(struct platform_device *pdev) { struct rtc_device *rtc; int ret = 0; int irq = platform_get_irq(pdev, 0); u8 rd_reg; //COMMON_L1 [email protected] RTC_2011_2_1_SET //AO¨öA AU¥ìaAO UI ¢¯¢®¨ù¡© A¢´¨öA ¨ùoA¢´¥ìC¢¬e ¡íeA| ¢¯a¢¬A unsigned char rtc_init_year; unsigned char rtc_init_month; unsigned char rtc_init_day; unsigned char roll_back_date=0; if (irq <= 0) return -EINVAL; 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 out0; } platform_set_drvdata(pdev, rtc); 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; //Jags_13_04_11 RTC Randome Wakeup Fail Fix ++ ret = request_threaded_irq(irq, NULL,twl_rtc_interrupt, IRQF_TRIGGER_RISING, dev_name(&rtc->dev), rtc); //Jags_13_04_11 RTC Randome Wakeup Fail Fix -- /* ret = request_irq(irq, twl_rtc_interrupt, IRQF_TRIGGER_RISING, dev_name(&rtc->dev), rtc); */ if (ret < 0) { dev_err(&pdev->dev, "IRQ is not free.\n"); 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); } /* Check RTC module status, Enable if it is off */ ret = twl_rtc_read_u8(&rd_reg, REG_RTC_CTRL_REG); if (ret < 0) goto out2; if (!(rd_reg & BIT_RTC_CTRL_REG_STOP_RTC_M)) { dev_info(&pdev->dev, "Enabling TWL-RTC.\n"); rd_reg = BIT_RTC_CTRL_REG_STOP_RTC_M; ret = twl_rtc_write_u8(rd_reg, REG_RTC_CTRL_REG); if (ret < 0) goto out2; } //COMMON_L1 [email protected] RTC_2011_2_1_SET //AO¨öA AU¥ìaAO UI ¢¯¢®¨ù¡© A¢´¨öA ¨ùoA¢´¥ìC¢¬e ¡íeA| ¢¯a¢¬A ret = twl_rtc_read_u8(&rtc_init_year, REG_YEARS_REG); ret = twl_rtc_read_u8(&rtc_init_month, REG_MONTHS_REG); ret = twl_rtc_read_u8(&rtc_init_day, REG_DAYS_REG); if(rtc_init_year<0x11) { roll_back_date=1; } else if((rtc_init_year==0x11)&&(rtc_init_month==0x01)) { roll_back_date=1; } /* 2011-02-18 : Block for QM2 temporary, It should be considered in ATT SW if(roll_back_date) { twl_rtc_write_u8(0x11,REG_YEARS_REG); twl_rtc_write_u8(0x02,REG_MONTHS_REG); twl_rtc_write_u8(0x01,REG_DAYS_REG); } */ /* init cached IRQ enable bits */ ret = twl_rtc_read_u8(&rtc_irq_bits, REG_RTC_INTERRUPTS_REG); if (ret < 0) goto out2; return ret; out2: free_irq(irq, rtc); out1: rtc_device_unregister(rtc); out0: return ret; }
u8 omap_twl_sleep_cmd(const u8 vsel) { if (!twl_class_is_6030()) return vsel; return (0x3 << 6) | (vsel & 0x3f); }
static int __devinit twl_rtc_probe(struct platform_device *pdev) { struct rtc_device *rtc; int ret = 0; int irq = platform_get_irq(pdev, 0); u8 rd_reg; if (irq <= 0) return -EINVAL; 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 out0; } platform_set_drvdata(pdev, rtc); /* Starting backup batery charge - configuration 3v, 25uA */ ret = twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0x14, 0x12 /*BB_CFG*/); 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; ret = request_irq(irq, twl_rtc_interrupt, IRQF_TRIGGER_RISING, dev_name(&rtc->dev), rtc); if (ret < 0) { dev_err(&pdev->dev, "IRQ is not free.\n"); 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); } /* Check RTC module status, Enable if it is off */ ret = twl_rtc_read_u8(&rd_reg, REG_RTC_CTRL_REG); if (ret < 0) goto out2; if (!(rd_reg & BIT_RTC_CTRL_REG_STOP_RTC_M)) { dev_info(&pdev->dev, "Enabling TWL-RTC.\n"); rd_reg = BIT_RTC_CTRL_REG_STOP_RTC_M; ret = twl_rtc_write_u8(rd_reg, REG_RTC_CTRL_REG); if (ret < 0) goto out2; } /* init cached IRQ enable bits */ ret = twl_rtc_read_u8(&rtc_irq_bits, REG_RTC_INTERRUPTS_REG); if (ret < 0) goto out2; #ifdef WORKQUEUE_RTC omap_rtc_wq = create_workqueue(MY_WORK_QUEUE_NAME); #endif return ret; out2: free_irq(irq, rtc); out1: rtc_device_unregister(rtc); out0: return ret; }
/* * 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 problem fail_vlow: free_irq(irq_num, &irq_event); #endif fail_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; }