FT2000+低温情况下RTC守时问题

1、背景介绍

飞腾2000+芯片通过I2C连接一块RTC时钟芯片（BellingBL5372）来实现麒麟信安系统下后的守时功能。目前BIOS支持UEFI功能，BIOS上电后能获取RTC时间，并将时间写入相应的UEFI变量或内存区域，操作系统上电后使用UEFI的APIs来读取相应的RTC时间变量或内存区域。

2、问题描述

在低温情况下（-42度），发现BIOS有概率无法获取到RTC时间，导致写入UEFI变量写入失败，从而操作系统也无法获取正确时间，变成系统出厂时间（2019年9月3日），如下图为出错情况：

 文章来源地址https://www.toymoban.com/news/detail-655017.html

但其实RTC芯片是正常工作的，当恢复到常温后又能获取到正确的时间，如下图

问题表现为低温情况下RTC守时不准。

3、原因分析

上电时BIOS通过I2C去访问RTC时钟芯片，由于FT2000+芯片商业档工作范围为0-70度，在低温-42度情况下完全有可能工作不正常，尤其是刚上电的那十几秒内，此时的I2C有概率无法读到RTC时钟芯片，导致BIOS时间无法获取，进一步导致系统下守时失败。

解决RTC问题其实就是解决一个温度问题，确保在温度满足芯片工作范围的情况下去读取RTC时钟芯片，也就是将读取时间后移，让芯片工作一段时间温度达到0度后再去读取。

对系统来说，有两种获取RTC时间的方式，一种就是从BIOS UEFI空间中去获取，另一种是调用系统下的驱动直接去读取时间。明显第二种方法是在操作系统启动过程中了，读取时间后移，能确保读到正确的时间。

4、问题解决

明确了通过加载驱动来获取RTC时间，那就按照这个思路去实现即可。

首先，在BIOS中添加RTC设备，通过dtb的方式添加，如下：

&i2c0 {
	status = "ok";
	rtc@32 {
		compatible = "beilin,bl5372";
		reg = <0x32>;
		status = "ok";
	};
};

这样驱动就能和设备匹配上，驱动代码如下：

/*
 * An I2C driver for Beilin BL5372 RTC
 */

#include <linux/i2c.h>
#include <linux/bcd.h>
#include <linux/rtc.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/of.h>

#define DEG 0

#define DRV_VERSION "2.0"

#define TIME24 0
#define RS5C_ADDR(R)		(((R) << 4) | 0)
#define RS5C372_REG_SECS	0
#define RS5C372_REG_MINS	1
#define RS5C372_REG_HOURS	2
#define RS5C372_REG_WDAY	3
#define RS5C372_REG_DAY		4
#define RS5C372_REG_MONTH	5
#define RS5C372_REG_YEAR	6
#define RS5C372_REG_TRIM	7
#define RS5C_REG_ALARM_A_MIN	8			/* or ALARM_W */
#define RS5C_REG_ALARM_A_HOURS	9
#define RS5C_REG_ALARM_A_WDAY	10

#define RS5C_REG_ALARM_B_MIN	11			/* or ALARM_D */
#define RS5C_REG_ALARM_B_HOURS	12
#define RS5C_REG_ALARM_B_WDAY	13			/* (ALARM_B only) */
#define RS5C_REG_CTRL1		14
#define RS5C_REG_CTRL2		15
#define DEVICE_ADDR        0x32	//0x5d

static unsigned rs5c_reg2hr(unsigned reg)
{
#if TIME24
	printk("<RTC> TIME24 0x%x\n",bcd2bin(reg & 0x3f));
	return bcd2bin(reg & 0x3f);
#else
	unsigned	hour;
	printk("<RTC> TIME12 0x%x\n",bcd2bin(reg & 0x1f));
	hour = bcd2bin(reg & 0x1f);
	if (hour == 12)
		hour = 0;
	if (reg & 0x20)
		hour += 12;
	printk("<RTC> TIME12 hour=%d\n",hour);
	return hour;
#endif
}

static unsigned rs5c_reg2mon(unsigned reg)
{
#if TIME24
	printk("<RTC> TIME24 0x%x\n",bcd2bin(reg & 0x3f));
	return bcd2bin(reg & 0x3f);
#else
	unsigned	month;
	printk("<RTC> TIME12 0x%x\n",bcd2bin(reg & 0x1f));
	month = bcd2bin(reg & 0x1f);
	if (month > 12)
		month -= 12;
	printk("<RTC> TIME12 hour=%d\n",month);
	return month;
#endif
}

static unsigned rs5c_hr2reg(unsigned hour)
{

#if TIME24
	printk("<RTC> TIME24 0x%x\n",bin2bcd(hour));
	return bin2bcd(hour);

#else
	if (hour > 12)
	{
		printk("<RTC> TIME12(>12) 0x%x\n",(0x20 | bin2bcd(hour - 12)));
		return 0x20 | bin2bcd(hour - 12);
	}
	if (hour == 12)
	{
		printk("<RTC> TIME12(==12) 0x%x\n",(0x20 | bin2bcd(12)));
		return 0x20 | bin2bcd(12);
	}
	if (hour == 0)
	{
		printk("<RTC> TIME12(==0) 0x%x\n",bin2bcd(12));
		return bin2bcd(12);
	}
	printk("<RTC> TIME12(<12) 0x%x\n",bin2bcd(hour));
	return bin2bcd(hour);
#endif
}

//-----------------------------------------------
static struct i2c_driver bl5372_driver;

struct bl5372 {
	struct rtc_device *rtc;
	struct device *dev;
	int irq;
 	/*
	unsigned char sec;
	unsigned char min;
	unsigned char hour;
	unsigned char week;
	unsigned char day;
	unsigned char month;
	unsigned int year;
	*/
};


static int i2c_write_bytes(struct i2c_client *client, uint8_t *data, uint16_t len)
{
        struct i2c_msg msg;
        int ret=-1;

        msg.flags = !I2C_M_RD;
        msg.addr = client->addr;
        msg.len = len;
        msg.buf = data;

        ret=i2c_transfer(client->adapter, &msg,1);
        return ret;
}

static int bl5372_get_datetime(struct i2c_client *client, struct rtc_time *tm)
{
	struct bl5372 *bl5372 = i2c_get_clientdata(client);
	unsigned char buf[7] = { RS5C_ADDR(RS5C372_REG_SECS) };

	printk("<RTC>bsl5372_get_datetime\n");
	struct i2c_msg msgs[] = {
		{/* setup read ptr */
			.addr = client->addr,
			.flags = 0,/* write */
			.len = 1,
			.buf = buf
		},
		{/* read the sec,min,hour,week,day,month,year */
			.addr = client->addr,
			.flags = I2C_M_RD,/* read */
			.len = 7,
			.buf = buf
		},
	};

	//int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
	//@num: Number of messages to be executed.
	//ÕâÀïÓÐÁœžöÏûÏ¢£¬ msgs[]µÄŽóС
	/* read registers */
	if ((i2c_transfer(client->adapter, msgs, 2)) != 2) {
		dev_err(&client->dev, "%s: read error\n", __func__);
		return -EIO;
	}

	printk("<RTC> buf[2]=0x%x\n",buf[2]);
	tm->tm_sec = bcd2bin(buf[0] & 0x7f);
	tm->tm_min = bcd2bin(buf[1] & 0x7f);
	printk("<RTC> Get hour Label*****\n");
	tm->tm_hour = rs5c_reg2hr(buf[2]);
	tm->tm_mday = bcd2bin(buf[4] & 0x7f);
	tm->tm_wday = bcd2bin(buf[3] & 0x7f);
	printk("<RTC> Get month Label*****\n");
	//tm->tm_mon = rs5c_reg2hr(buf[5])-1;
	tm->tm_mon = rs5c_reg2mon(buf[5])-1;
	tm->tm_year = bcd2bin(buf[6] & 0x7f)+100;
	printk("<RTC>@GET1 year%d month%d mday%d wday%d hour%d min%d sec%d\n",tm->tm_year,tm->tm_mon,tm->tm_mday,tm->tm_wday,tm->tm_hour,tm->tm_min,tm->tm_sec);

#if 1
	//------------------------------------
	buf[0]= RS5C_ADDR(RS5C_REG_CTRL2);
	struct i2c_msg msgs2[] = {
		{/* setup read  */
			.addr = client->addr,
			.len = 1,
			.buf = buf
		},
		{/* read is_24hour */
			.addr = client->addr,
			.flags = I2C_M_RD,
			.len = 1,
			.buf = buf
		},
	};

	/* read registers */
	if ((i2c_transfer(client->adapter, msgs2, 2)) != 2) {
		dev_err(&client->dev, "%s: read error\n", __func__);
		return -EIO;
	}

	if(buf[0]&0x20)
	{
		printk("24小时\n");
		tm->tm_hour= (tm->tm_hour<24)? (tm->tm_hour):(24-tm->tm_hour);
	}
	else
	{
		tm->tm_hour=(tm->tm_hour<24)? (tm->tm_hour):(tm->tm_hour+24);
	//	tm->tm_mday=(tm->tm_mday<7)? (tm->tm_mday):(tm->tm_mday+8-24);
	//	tm->tm_hour=tm->tm_hour+8;
	}

#endif


	//tm->tm_hour= (tm->tm_hour<24)? (tm->tm_hour):(tm->tm_hour-24);
	/* the clock can give out invalid datetime, but we cannot return
	 * -EINVAL otherwise hwclock will refuse to set the time on bootup.
	 */
	printk("<RTC>@GET2 year%d month%d mday%d wday%d hour%d min%d sec%d\n",tm->tm_year,tm->tm_mon,tm->tm_mday,tm->tm_wday,tm->tm_hour,tm->tm_min,tm->tm_sec);
	if (rtc_valid_tm(tm) < 0)
		dev_err(&client->dev, "retrieved date/time is not valid.\n");

	return 0;
}

static int bl5372_set_datetime(struct i2c_client *client, struct rtc_time *tm)
{
	struct bl5372 *bl5372 = i2c_get_clientdata(client);
	int i, err;
	unsigned char buf[7];
	printk("<RTC>####bl5372_set_datetime\n");
//------------------------------------
	buf[0]= RS5C_ADDR(RS5C_REG_CTRL2);
	struct i2c_msg msgs2[] = {
		{/* setup read  */
			.addr = client->addr,
			.len = 1,
			.buf = buf
		},
		{/* read is_24hour */
			.addr = client->addr,
			.flags = I2C_M_RD,
			.len = 1,
			.buf = buf
		},
	};

	/* read registers */
	if ((i2c_transfer(client->adapter, msgs2, 2)) != 2) {
		dev_err(&client->dev, "%s: read error\n", __func__);
		return -EIO;
	}


/*	if((buf[0]&0x20)== 0)
	{
		printk("RTC 12xiaoshi\n");rs5c_hr2reg
		buf[0] |= (1<<5);
		err = i2c_master_send(client, buf, 1);

	}
*/
	printk("<RTC>IN####year%d month%d mday%d wday%d hour%d min%d sec%d\n",tm->tm_year,tm->tm_mon,tm->tm_mday,tm->tm_wday,tm->tm_hour,tm->tm_min,tm->tm_sec);


//------------------------
	/* hours, minutes and seconds */
	buf[0] = bin2bcd(tm->tm_sec);
	buf[1] = bin2bcd(tm->tm_min);
	printk("<RTC> Set hour Label*****\n");
	buf[2] = rs5c_hr2reg(tm->tm_hour);
	buf[3] = bin2bcd(tm->tm_wday & 0x07); //week 0~6
	buf[4] = bin2bcd(tm->tm_mday);
	buf[5] = bin2bcd(tm->tm_mon)+1;// 0~11
	tm->tm_year -= 100;
	buf[6] = bin2bcd(tm->tm_year % 100);// start at 1900  2018=>118
//
printk("###########write data to rtc \n");

for(i=0;i<7;i++)
{
printk("buf[%d] is 0x%x\n",i,buf[i]);
}

  	err = i2c_smbus_write_byte_data(client, RS5C_ADDR(RS5C372_REG_SECS),   buf[0]);
 	i2c_smbus_write_byte_data(client, RS5C_ADDR(RS5C372_REG_MINS) ,  buf[1]);
	i2c_smbus_write_byte_data(client, RS5C_ADDR(RS5C372_REG_HOURS) , buf[2]);
	i2c_smbus_write_byte_data(client, RS5C_ADDR(RS5C372_REG_WDAY) ,  buf[3]);
	i2c_smbus_write_byte_data(client, RS5C_ADDR(RS5C372_REG_DAY) ,   buf[4]);
	i2c_smbus_write_byte_data(client, RS5C_ADDR(RS5C372_REG_MONTH) , buf[5]);
	i2c_smbus_write_byte_data(client, RS5C_ADDR(RS5C372_REG_YEAR) ,  buf[6]);

	return 0;
}

#ifdef CONFIG_RTC_INTF_DEV
static int bl5372_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
{
	struct bl5372 *bl5372 = i2c_get_clientdata(to_i2c_client(dev));
	struct rtc_time tm;

	switch (cmd) {
	case RTC_RD_TIME:
		//bl5372_get_datetime(to_i2c_client(dev), &tm);
		return 0;
	case RTC_SET_TIME:
		if (copy_from_user(&tm, arg, sizeof(tm)))
                        return -EFAULT;

		bl5372_set_datetime(to_i2c_client(dev), &tm);
		return 0;
	default:
		return -ENOIOCTLCMD;
	}

}
#else
#define bl5372_rtc_ioctl NULL
#endif

static int bl5372_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
	return bl5372_get_datetime(to_i2c_client(dev), tm);
}

static int bl5372_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
	return bl5372_set_datetime(to_i2c_client(dev), tm);
}

static int bl5372_rtc_getalarm(struct device *dev, struct rtc_wkalrm *wkalrm)
{
	struct bl5372 *bl5372 = i2c_get_clientdata(to_i2c_client(dev));
	return 0;
}

static int bl5372_rtc_setalarm(struct device *dev, struct rtc_wkalrm *wkalrm)
{
	struct bl5372 *bl5372 = i2c_get_clientdata(to_i2c_client(dev));
	return 0;
}

static int bl5372_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
{
        //struct bl5372 *bl5372 = dev_get_drvdata(dev);
	struct bl5372 *bl5372 = i2c_get_clientdata(to_i2c_client(dev));

        return 0;
}

static const struct rtc_class_ops bl5372_rtc_ops = {
	.ioctl		= bl5372_rtc_ioctl,
	.read_time	= bl5372_rtc_read_time,
	.set_time	= bl5372_rtc_set_time,
	.read_alarm        = bl5372_rtc_getalarm,
    .set_alarm         = bl5372_rtc_setalarm,
    .alarm_irq_enable  = bl5372_rtc_alarm_irq_enable
};

static int bl5372_probe(struct i2c_client *client,
				const struct i2c_device_id *id)
{

	struct bl5372 *bl5372;

	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
	{

		return -ENODEV;
	}
	bl5372 = devm_kzalloc(&client->dev, sizeof(struct bl5372),
				GFP_KERNEL);
	if (!bl5372)
	{

		return -ENOMEM;
	}
	device_init_wakeup(&client->dev, 1);

	i2c_set_clientdata(client, bl5372);

	bl5372->rtc = devm_rtc_device_register(&client->dev,
				bl5372_driver.driver.name,
				&bl5372_rtc_ops, THIS_MODULE);

	if (IS_ERR(bl5372->rtc))
	{
		return PTR_ERR(bl5372->rtc);
	}

	bl5372->rtc->uie_unsupported = 1;

	return 0;
}

static int bl5372_remove(struct i2c_client *client)
{

	return 0;
}

static const struct i2c_device_id bl5372_id[] = {
	{ "bl5372", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, bl5372_id);

#ifdef CONFIG_OF
static const struct of_device_id bl5372_of_match[] = {
	{ .compatible = "beilin,bl5372" },
	{}
};
MODULE_DEVICE_TABLE(of, bl5372_of_match);
#endif

static struct i2c_driver bl5372_driver = {
	.driver		= {
		.name	= "rtc-bl5372",
		.owner	= THIS_MODULE,
		.of_match_table = of_match_ptr(bl5372_of_match),
	},
	.probe		= bl5372_probe,
	.remove		= bl5372_remove,
	.id_table	= bl5372_id,
};

module_i2c_driver(bl5372_driver);

MODULE_AUTHOR("Zhengweiqing <1548889230@qq.com>");
MODULE_DESCRIPTION("Beilin BL5372 RTC driver");
MODULE_LICENSE("GPL");
MODULE_VERSION(DRV_VERSION);

下面是Makefile

obj-m +=rtc_bl5372.o

KDIR=/lib/modules/$(shell uname -r)/build

all:
	make -C $(KDIR) M=$(PWD) modules
clean:
	make -C $(KDIR) M=$(PWD) clean

编译成ko，然后包进内核里面

将驱动编到内核里面后重新上电能发现系统下面有两个rtc设备，其中rtc0是系统采用BIOS UEFI方式产生的，rtc1是系统加载驱动产生的，如下图

由于系统时间默认采用的是从rtc0获取的时间，需要改为从rtc1（通过加载驱动产生的设备）获取时间。

在/etc/udev/rules.d下创建文件，这里命名为rtc1.rules

文件内容如下：

KERNEL=="rtc0",SYMLINK+="rtc_old"

KERNEL=="rtc1",SYMLINK+="rtc"

上述规则将原来命名为rtc0的设备链接到rtc old，将rtc1设备链接到rtc。这样，系统会将rtc1设备作为默认的时钟设备。

然后重新加载udev规则，使修改生效

udevadm control --reload-rules

重启系统即可。

重启后输入dmesg能看到后面又多出来一段内容，那就是配置系统时间时读取rtc1时间了：

到了这里，关于FT2000+低温情况下RTC守时问题的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！