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

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