static int mrst_read_alarm(struct device *dev, struct rtc_wkalrm *t) { struct mrst_rtc *mrst = dev_get_drvdata(dev); unsigned char rtc_control; if (mrst->irq <= 0) return -EIO; /* Basic alarms only support hour, minute, and seconds fields. * Some also support day and month, for alarms up to a year in * the future. */ t->time.tm_mday = -1; t->time.tm_mon = -1; t->time.tm_year = -1; /* vRTC only supports binary mode */ spin_lock_irq(&rtc_lock); t->time.tm_sec = vrtc_cmos_read(RTC_SECONDS_ALARM); t->time.tm_min = vrtc_cmos_read(RTC_MINUTES_ALARM); t->time.tm_hour = vrtc_cmos_read(RTC_HOURS_ALARM); rtc_control = vrtc_cmos_read(RTC_CONTROL); spin_unlock_irq(&rtc_lock); t->enabled = !!(rtc_control & RTC_AIE); t->pending = 0; return 0; }
static int mrst_resume(struct device *dev) { struct mrst_rtc *mrst = dev_get_drvdata(dev); unsigned char tmp = mrst->suspend_ctrl; /* Re-enable any irqs previously active */ if (tmp & RTC_IRQMASK) { unsigned char mask; if (mrst->enabled_wake) { disable_irq_wake(mrst->irq); mrst->enabled_wake = 0; } spin_lock_irq(&rtc_lock); do { vrtc_cmos_write(tmp, RTC_CONTROL); mask = vrtc_cmos_read(RTC_INTR_FLAGS); mask &= (tmp & RTC_IRQMASK) | RTC_IRQF; if (!is_intr(mask)) break; rtc_update_irq(mrst->rtc, 1, mask); tmp &= ~RTC_AIE; } while (mask & RTC_AIE); spin_unlock_irq(&rtc_lock); } dev_dbg(&mrst_rtc.rtc->dev, "resume, ctrl %02x\n", tmp); return 0; }
/* * We want RTC alarms to wake us from the deep power saving state */ static inline int mrst_poweroff(struct device *dev) { unsigned char test_hrs, test_min, test_sec; unsigned char rtc_control; int retval; retval = mrst_suspend(dev); test_sec = vrtc_cmos_read(RTC_SECONDS_ALARM); test_min = vrtc_cmos_read(RTC_MINUTES_ALARM); test_hrs = vrtc_cmos_read(RTC_HOURS_ALARM); rtc_control = vrtc_cmos_read(RTC_CONTROL); printk(KERN_ALERT"rtc mrst_poweroff backread hrs=%d,min=%d,sec=%d control =0x%02x\r\n",test_hrs,test_min,test_sec,rtc_control); return retval; }
/* * When vRTC IRQ is captured by SCU FW, FW will clear the AIE bit in * Reg B, so no need for this driver to clear it */ static irqreturn_t mrst_rtc_irq(int irq, void *p) { u8 irqstat; int ret = 0; spin_lock(&rtc_lock); /* This read will clear all IRQ flags inside Reg C */ irqstat = vrtc_cmos_read(RTC_INTR_FLAGS); irqstat &= RTC_IRQMASK | RTC_IRQF; ret = is_valid_af(irqstat); spin_unlock(&rtc_lock); if (is_intr(irqstat)) { /* If it's an alarm-interrupt, update RTC-IRQ only if it's * for current day. Alarms beyond 24-hours will result in * interrupts at given time, everyday till actual alarm-date. * From hardware perspective, it's still a valid interrupt, * hence need to return IRQ_HANDLED. */ if (ret) rtc_update_irq(p, 1, irqstat); return IRQ_HANDLED; } else { printk(KERN_ERR "vRTC: error in IRQ handler\n"); return IRQ_NONE; } }
static int mrst_suspend(struct device *dev, pm_message_t mesg) { struct mrst_rtc *mrst = dev_get_drvdata(dev); unsigned char tmp; /* Only the alarm might be a wakeup event source */ spin_lock_irq(&rtc_lock); mrst->suspend_ctrl = tmp = vrtc_cmos_read(RTC_CONTROL); if (tmp & (RTC_PIE | RTC_AIE)) { unsigned char mask; if (device_may_wakeup(dev)) mask = RTC_IRQMASK & ~RTC_AIE; else mask = RTC_IRQMASK; tmp &= ~mask; vrtc_cmos_write(tmp, RTC_CONTROL); mrst_checkintr(mrst, tmp); } spin_unlock_irq(&rtc_lock); if (tmp & RTC_AIE) { mrst->enabled_wake = 1; enable_irq_wake(mrst->irq); } dev_dbg(&mrst_rtc.rtc->dev, "suspend%s, ctrl %02x\n", (tmp & RTC_AIE) ? ", alarm may wake" : "", tmp); return 0; }
static int mrst_procfs(struct device *dev, struct seq_file *seq) { unsigned char rtc_control, valid; spin_lock_irq(&rtc_lock); rtc_control = vrtc_cmos_read(RTC_CONTROL); valid = vrtc_cmos_read(RTC_VALID); spin_unlock_irq(&rtc_lock); return seq_printf(seq, "periodic_IRQ\t: %s\n" "alarm\t\t: %s\n" "BCD\t\t: no\n" "periodic_freq\t: daily (not adjustable)\n", (rtc_control & RTC_PIE) ? "on" : "off", (rtc_control & RTC_AIE) ? "on" : "off"); }
unsigned long vrtc_get_time(void) { u8 sec, min, hour, mday, mon; unsigned long flags; u32 year; spin_lock_irqsave(&rtc_lock, flags); while ((vrtc_cmos_read(RTC_FREQ_SELECT) & RTC_UIP)) cpu_relax(); sec = vrtc_cmos_read(RTC_SECONDS); min = vrtc_cmos_read(RTC_MINUTES); hour = vrtc_cmos_read(RTC_HOURS); mday = vrtc_cmos_read(RTC_DAY_OF_MONTH); mon = vrtc_cmos_read(RTC_MONTH); year = vrtc_cmos_read(RTC_YEAR); spin_unlock_irqrestore(&rtc_lock, flags); /* vRTC YEAR reg contains the offset to 1972 */ year += 1972; pr_info("vRTC: sec: %d min: %d hour: %d day: %d " "mon: %d year: %d\n", sec, min, hour, mday, mon, year); return mktime(year, mon, mday, hour, min, sec); }
static void mrst_irq_disable(struct mrst_rtc *mrst, unsigned char mask) { unsigned char rtc_control; rtc_control = vrtc_cmos_read(RTC_CONTROL); rtc_control &= ~mask; vrtc_cmos_write(rtc_control, RTC_CONTROL); mrst_checkintr(mrst, rtc_control); }
static inline unsigned char vrtc_is_updating(void) { unsigned char uip; unsigned long flags; spin_lock_irqsave(&rtc_lock, flags); uip = (vrtc_cmos_read(RTC_FREQ_SELECT) & RTC_UIP); spin_unlock_irqrestore(&rtc_lock, flags); return uip; }
static void mrst_checkintr(struct mrst_rtc *mrst, unsigned char rtc_control) { unsigned char rtc_intr; /* * NOTE after changing RTC_xIE bits we always read INTR_FLAGS; * allegedly some older rtcs need that to handle irqs properly */ rtc_intr = vrtc_cmos_read(RTC_INTR_FLAGS); rtc_intr &= (rtc_control & RTC_IRQMASK) | RTC_IRQF; if (is_intr(rtc_intr)) rtc_update_irq(mrst->rtc, 1, rtc_intr); }
/* If the interrupt is of alarm-type-RTC_AF, then check if it's for * the correct day. With the support for alarms more than 24-hours, * alarm-date is compared with date-fields in OSHOB, as the vRTC * doesn't have date-fields for alarm */ static int is_valid_af(u8 rtc_intr) { char *p; unsigned long vrtc_date, oshob_date; if ((__intel_mid_cpu_chip == INTEL_MID_CPU_CHIP_PENWELL) || (__intel_mid_cpu_chip == INTEL_MID_CPU_CHIP_CLOVERVIEW)) { if (rtc_intr & RTC_AF) { p = (char *) &vrtc_date; *(p+1) = vrtc_cmos_read(RTC_DAY_OF_MONTH); *(p+2) = vrtc_cmos_read(RTC_MONTH); *(p+3) = vrtc_cmos_read(RTC_YEAR); oshob_date = readl(oshob_addr); if ((oshob_date & 0xFFFFFF00) != (vrtc_date & 0xFFFFFF00)) return false; } } return true; }
/* * When vRTC IRQ is captured by SCU FW, FW will clear the AIE bit in * Reg B, so no need for this driver to clear it */ static irqreturn_t mrst_rtc_irq(int irq, void *p) { u8 irqstat; spin_lock(&rtc_lock); /* This read will clear all IRQ flags inside Reg C */ irqstat = vrtc_cmos_read(RTC_INTR_FLAGS); spin_unlock(&rtc_lock); irqstat &= RTC_IRQMASK | RTC_IRQF; if (is_intr(irqstat)) { rtc_update_irq(p, 1, irqstat); return IRQ_HANDLED; } return IRQ_NONE; }
static void mrst_irq_enable(struct mrst_rtc *mrst, unsigned char mask) { unsigned char rtc_control; /* * Flush any pending IRQ status, notably for update irqs, * before we enable new IRQs */ rtc_control = vrtc_cmos_read(RTC_CONTROL); mrst_checkintr(mrst, rtc_control); rtc_control |= mask; vrtc_cmos_write(rtc_control, RTC_CONTROL); mrst_checkintr(mrst, rtc_control); }
/* Only care about the minutes and seconds */ int vrtc_set_mmss(unsigned long nowtime) { int real_sec, real_min; unsigned long flags; int vrtc_min; spin_lock_irqsave(&rtc_lock, flags); vrtc_min = vrtc_cmos_read(RTC_MINUTES); real_sec = nowtime % 60; real_min = nowtime / 60; if (((abs(real_min - vrtc_min) + 15)/30) & 1) real_min += 30; real_min %= 60; vrtc_cmos_write(real_sec, RTC_SECONDS); vrtc_cmos_write(real_min, RTC_MINUTES); spin_unlock_irqrestore(&rtc_lock, flags); return 0; }
/* * rtc_time's year contains the increment over 1900, but vRTC's YEAR * register can't be programmed to value larger than 0x64, so vRTC * driver chose to use 1972 (1970 is UNIX time start point) as the base, * and does the translation at read/write time. * * Why not just use 1970 as the offset? it's because using 1972 will * make it consistent in leap year setting for both vrtc and low-level * physical rtc devices. Then why not use 1960 as the offset? If we use * 1960, for a device's first use, its YEAR register is 0 and the system * year will be parsed as 1960 which is not a valid UNIX time and will * cause many applications to fail mysteriously. */ static int mrst_read_time(struct device *dev, struct rtc_time *time) { unsigned long flags; if (vrtc_is_updating()) mdelay(20); spin_lock_irqsave(&rtc_lock, flags); time->tm_sec = vrtc_cmos_read(RTC_SECONDS); time->tm_min = vrtc_cmos_read(RTC_MINUTES); time->tm_hour = vrtc_cmos_read(RTC_HOURS); time->tm_mday = vrtc_cmos_read(RTC_DAY_OF_MONTH); time->tm_mon = vrtc_cmos_read(RTC_MONTH); time->tm_year = vrtc_cmos_read(RTC_YEAR); spin_unlock_irqrestore(&rtc_lock, flags); /* Adjust for the 1972/1900 */ time->tm_year += 72; time->tm_mon--; return rtc_valid_tm(time); }
static int vrtc_mrst_do_probe(struct device *dev, struct resource *iomem, int rtc_irq) { int retval = 0; unsigned char rtc_control; unsigned char enable_bit_save = 0; /* There can be only one ... */ if (mrst_rtc.dev) return -EBUSY; if (!iomem) return -ENODEV; iomem = request_mem_region(iomem->start, iomem->end + 1 - iomem->start, driver_name); if (!iomem) { dev_dbg(dev, "i/o mem already in use.\n"); return -EBUSY; } mrst_rtc.irq = rtc_irq; mrst_rtc.iomem = iomem; mrst_rtc.dev = dev; dev_set_drvdata(dev, &mrst_rtc); mrst_rtc.rtc = rtc_device_register(driver_name, dev, &mrst_rtc_ops, THIS_MODULE); if (IS_ERR(mrst_rtc.rtc)) { retval = PTR_ERR(mrst_rtc.rtc); goto cleanup0; } rename_region(iomem, dev_name(&mrst_rtc.rtc->dev)); printk(KERN_ALERT"(%s) +------------rtc info-----------+\n",__func__); spin_lock_irq(&rtc_lock); enable_bit_save = vrtc_cmos_read(RTC_CONTROL); enable_bit_save &= (RTC_PIE | RTC_AIE); mrst_irq_disable(&mrst_rtc, RTC_PIE | RTC_AIE); rtc_control = vrtc_cmos_read(RTC_CONTROL); spin_unlock_irq(&rtc_lock); printk(KERN_ALERT"read PIE_AIE_save = 0x%02x, then clear. rtc_control = 0x%02x\n",enable_bit_save,rtc_control); if (!(rtc_control & RTC_24H) || (rtc_control & (RTC_DM_BINARY))) dev_dbg(dev, "TODO: support more than 24-hr BCD mode\n"); if (is_valid_irq(rtc_irq)) { retval = request_irq(rtc_irq, mrst_rtc_irq, IRQF_NO_SUSPEND, dev_name(&mrst_rtc.rtc->dev), mrst_rtc.rtc); if (retval < 0) { dev_dbg(dev, "IRQ %d is already in use, err %d\n", rtc_irq, retval); goto cleanup1; } } /* make RTC device wake capable from sleep */ device_init_wakeup(dev, true); if ((__intel_mid_cpu_chip == INTEL_MID_CPU_CHIP_PENWELL) || (__intel_mid_cpu_chip == INTEL_MID_CPU_CHIP_CLOVERVIEW)) { retval = rpmsg_send_command(vrtc_mrst_instance, IPCMSG_GET_HOBADDR, 0, NULL, &oshob_base, 0, 1); if (retval < 0) { dev_dbg(dev, "Unable to get OSHOB base address, err %d\n", retval); goto cleanup1; } oshob_addr = ioremap_nocache(oshob_base+OSHOB_ALARM_OFFSET, 4); if (!oshob_addr) { dev_dbg(dev, "Unable to do ioremap for OSHOB\n"); retval = -ENOMEM; goto cleanup1; } } spin_lock_irq(&rtc_lock); if(enable_bit_save) mrst_irq_enable(&mrst_rtc, enable_bit_save);//add for power off rtc issue spin_unlock_irq(&rtc_lock); rtc_control = vrtc_cmos_read(RTC_CONTROL); printk(KERN_ALERT"read resume rtc_control = 0x%02x.\n",rtc_control); printk(KERN_ALERT"(%s) +-------------------------------+\n",__func__); dev_dbg(dev, "vRTC driver initialised\n"); return 0; cleanup1: rtc_device_unregister(mrst_rtc.rtc); cleanup0: dev_set_drvdata(dev, NULL); mrst_rtc.dev = NULL; release_mem_region(iomem->start, resource_size(iomem)); dev_err(dev, "rtc-mrst: unable to initialise\n"); return retval; }
static int __devinit vrtc_mrst_do_probe(struct device *dev, struct resource *iomem, int rtc_irq) { int retval = 0; unsigned char rtc_control; /* There can be only one ... */ if (mrst_rtc.dev) return -EBUSY; if (!iomem) return -ENODEV; iomem = request_mem_region(iomem->start, resource_size(iomem), driver_name); if (!iomem) { dev_dbg(dev, "i/o mem already in use.\n"); return -EBUSY; } mrst_rtc.irq = rtc_irq; mrst_rtc.iomem = iomem; mrst_rtc.dev = dev; dev_set_drvdata(dev, &mrst_rtc); mrst_rtc.rtc = rtc_device_register(driver_name, dev, &mrst_rtc_ops, THIS_MODULE); if (IS_ERR(mrst_rtc.rtc)) { retval = PTR_ERR(mrst_rtc.rtc); goto cleanup0; } rename_region(iomem, dev_name(&mrst_rtc.rtc->dev)); spin_lock_irq(&rtc_lock); mrst_irq_disable(&mrst_rtc, RTC_PIE | RTC_AIE); rtc_control = vrtc_cmos_read(RTC_CONTROL); spin_unlock_irq(&rtc_lock); if (!(rtc_control & RTC_24H) || (rtc_control & (RTC_DM_BINARY))) dev_dbg(dev, "TODO: support more than 24-hr BCD mode\n"); if (rtc_irq) { retval = request_irq(rtc_irq, mrst_rtc_irq, IRQF_DISABLED, dev_name(&mrst_rtc.rtc->dev), mrst_rtc.rtc); if (retval < 0) { dev_dbg(dev, "IRQ %d is already in use, err %d\n", rtc_irq, retval); goto cleanup1; } } dev_dbg(dev, "initialised\n"); return 0; cleanup1: rtc_device_unregister(mrst_rtc.rtc); cleanup0: dev_set_drvdata(dev, NULL); mrst_rtc.dev = NULL; release_mem_region(iomem->start, resource_size(iomem)); dev_err(dev, "rtc-mrst: unable to initialise\n"); return retval; }