diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index ec873f09c763..cc020fb7a2a9 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -271,6 +271,8 @@ config RTC_DRV_DS1307_CENTURY
 
 config RTC_DRV_DS1374
 	tristate "Dallas/Maxim DS1374"
+	depends on MFD_DS1374
+
 	help
 	  If you say yes here you get support for Dallas Semiconductor
 	  DS1374 real-time clock chips. If an interrupt is associated
@@ -279,13 +281,6 @@ config RTC_DRV_DS1374
 	  This driver can also be built as a module. If so, the module
 	  will be called rtc-ds1374.
 
-config RTC_DRV_DS1374_WDT
-	bool "Dallas/Maxim DS1374 watchdog timer"
-	depends on RTC_DRV_DS1374
-	help
-	  If you say Y here you will get support for the
-	  watchdog timer in the Dallas Semiconductor DS1374
-	  real-time clock chips.
 
 config RTC_DRV_DS1672
 	tristate "Dallas/Maxim DS1672"
diff --git a/drivers/rtc/rtc-ds1374.c b/drivers/rtc/rtc-ds1374.c
index 9c51a12cf70f..d8ff0fbba52c 100644
--- a/drivers/rtc/rtc-ds1374.c
+++ b/drivers/rtc/rtc-ds1374.c
@@ -1,17 +1,16 @@
+// SPDX-License-Identifier: GPL-2.0
 /*
  * RTC client/driver for the Maxim/Dallas DS1374 Real-Time Clock over I2C
  *
  * Based on code by Randy Vinson <rvinson@mvista.com>,
  * which was based on the m41t00.c by Mark Greer <mgreer@mvista.com>.
  *
+ * Copyright (C) 2020 Johnson Chen <johnsonch.chen@moxa.com>
  * Copyright (C) 2014 Rose Technology
  * Copyright (C) 2006-2007 Freescale Semiconductor
- *
- * 2005 (c) MontaVista Software, Inc. This file is licensed under
- * the terms of the GNU General Public License version 2. This program
- * is licensed "as is" without any warranty of any kind, whether express
- * or implied.
+ * Copyright (C) 2005 MontaVista Software, Inc.
  */
+
 /*
  * It would be more efficient to use i2c msgs/i2c_transfer directly but, as
  * recommended in .../Documentation/i2c/writing-clients.rst section
@@ -25,17 +24,10 @@
 #include <linux/interrupt.h>
 #include <linux/i2c.h>
 #include <linux/rtc.h>
-#include <linux/bcd.h>
 #include <linux/workqueue.h>
-#include <linux/slab.h>
-#include <linux/pm.h>
-#ifdef CONFIG_RTC_DRV_DS1374_WDT
-#include <linux/fs.h>
-#include <linux/ioctl.h>
-#include <linux/miscdevice.h>
-#include <linux/reboot.h>
-#include <linux/watchdog.h>
-#endif
+#include <linux/platform_device.h>
+
+#define DEVNAME "ds1374_rtc"
 
 #define DS1374_REG_TOD0		0x00 /* Time of Day */
 #define DS1374_REG_TOD1		0x01
@@ -53,21 +45,7 @@
 #define DS1374_REG_SR_AF	0x01 /* Alarm Flag */
 #define DS1374_REG_TCR		0x09 /* Trickle Charge */
 
-static const struct i2c_device_id ds1374_id[] = {
-	{ "ds1374", 0 },
-	{ }
-};
-MODULE_DEVICE_TABLE(i2c, ds1374_id);
-
-#ifdef CONFIG_OF
-static const struct of_device_id ds1374_of_match[] = {
-	{ .compatible = "dallas,ds1374" },
-	{ }
-};
-MODULE_DEVICE_TABLE(of, ds1374_of_match);
-#endif
-
-struct ds1374 {
+struct ds1374_rtc {
 	struct i2c_client *client;
 	struct rtc_device *rtc;
 	struct work_struct work;
@@ -80,8 +58,6 @@ struct ds1374 {
 	int exiting;
 };
 
-static struct i2c_driver ds1374_driver;
-
 static int ds1374_read_rtc(struct i2c_client *client, u32 *time,
 			   int reg, int nbytes)
 {
@@ -158,7 +134,7 @@ static int ds1374_check_rtc_status(struct i2c_client *client)
 
 static int ds1374_read_time(struct device *dev, struct rtc_time *time)
 {
-	struct i2c_client *client = to_i2c_client(dev);
+	struct i2c_client *client = to_i2c_client(dev->parent);
 	u32 itime;
 	int ret;
 
@@ -171,21 +147,21 @@ static int ds1374_read_time(struct device *dev, struct rtc_time *time)
 
 static int ds1374_set_time(struct device *dev, struct rtc_time *time)
 {
-	struct i2c_client *client = to_i2c_client(dev);
+	struct i2c_client *client = to_i2c_client(dev->parent);
 	unsigned long itime = rtc_tm_to_time64(time);
 
 	return ds1374_write_rtc(client, itime, DS1374_REG_TOD0, 4);
 }
 
-#ifndef CONFIG_RTC_DRV_DS1374_WDT
+#ifndef CONFIG_DS1374_WATCHDOG
 /* The ds1374 has a decrementer for an alarm, rather than a comparator.
  * If the time of day is changed, then the alarm will need to be
  * reset.
  */
 static int ds1374_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 {
-	struct i2c_client *client = to_i2c_client(dev);
-	struct ds1374 *ds1374 = i2c_get_clientdata(client);
+	struct i2c_client *client = to_i2c_client(dev->parent);
+	struct ds1374_rtc *drv_data = dev->driver_data;
 	u32 now, cur_alarm;
 	int cr, sr;
 	int ret = 0;
@@ -193,7 +169,7 @@ static int ds1374_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 	if (client->irq <= 0)
 		return -EINVAL;
 
-	mutex_lock(&ds1374->mutex);
+	mutex_lock(&drv_data->mutex);
 
 	cr = ret = i2c_smbus_read_byte_data(client, DS1374_REG_CR);
 	if (ret < 0)
@@ -216,14 +192,14 @@ static int ds1374_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 	alarm->pending = !!(sr & DS1374_REG_SR_AF);
 
 out:
-	mutex_unlock(&ds1374->mutex);
+	mutex_unlock(&drv_data->mutex);
 	return ret;
 }
 
 static int ds1374_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 {
-	struct i2c_client *client = to_i2c_client(dev);
-	struct ds1374 *ds1374 = i2c_get_clientdata(client);
+	struct i2c_client *client = to_i2c_client(dev->parent);
+	struct ds1374_rtc *drv_data = dev->driver_data;
 	struct rtc_time now;
 	unsigned long new_alarm, itime;
 	int cr;
@@ -250,7 +226,7 @@ static int ds1374_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 	else
 		new_alarm -= itime;
 
-	mutex_lock(&ds1374->mutex);
+	mutex_lock(&drv_data->mutex);
 
 	ret = cr = i2c_smbus_read_byte_data(client, DS1374_REG_CR);
 	if (ret < 0)
@@ -276,28 +252,29 @@ static int ds1374_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 	}
 
 out:
-	mutex_unlock(&ds1374->mutex);
+	mutex_unlock(&drv_data->mutex);
 	return ret;
 }
 #endif
 
 static irqreturn_t ds1374_irq(int irq, void *dev_id)
 {
-	struct i2c_client *client = dev_id;
-	struct ds1374 *ds1374 = i2c_get_clientdata(client);
+	struct platform_device *pdev = dev_id;
+	struct ds1374_rtc *drv_data = platform_get_drvdata(pdev);
 
 	disable_irq_nosync(irq);
-	schedule_work(&ds1374->work);
+	schedule_work(&drv_data->work);
 	return IRQ_HANDLED;
 }
 
 static void ds1374_work(struct work_struct *work)
 {
-	struct ds1374 *ds1374 = container_of(work, struct ds1374, work);
-	struct i2c_client *client = ds1374->client;
+	struct ds1374_rtc *drv_data = container_of(work,
+						struct ds1374_rtc, work);
+	struct i2c_client *client = drv_data->client;
 	int stat, control;
 
-	mutex_lock(&ds1374->mutex);
+	mutex_lock(&drv_data->mutex);
 
 	stat = i2c_smbus_read_byte_data(client, DS1374_REG_SR);
 	if (stat < 0)
@@ -314,24 +291,24 @@ static void ds1374_work(struct work_struct *work)
 		control &= ~(DS1374_REG_CR_WACE | DS1374_REG_CR_AIE);
 		i2c_smbus_write_byte_data(client, DS1374_REG_CR, control);
 
-		rtc_update_irq(ds1374->rtc, 1, RTC_AF | RTC_IRQF);
+		rtc_update_irq(drv_data->rtc, 1, RTC_AF | RTC_IRQF);
 	}
 
 out:
-	if (!ds1374->exiting)
+	if (!drv_data->exiting)
 		enable_irq(client->irq);
 unlock:
-	mutex_unlock(&ds1374->mutex);
+	mutex_unlock(&drv_data->mutex);
 }
 
-#ifndef CONFIG_RTC_DRV_DS1374_WDT
+#ifndef CONFIG_DS1374_WATCHDOG
 static int ds1374_alarm_irq_enable(struct device *dev, unsigned int enabled)
 {
-	struct i2c_client *client = to_i2c_client(dev);
-	struct ds1374 *ds1374 = i2c_get_clientdata(client);
+	struct i2c_client *client = to_i2c_client(dev->parent);
+	struct ds1374_rtc *drv_data = dev->driver_data;
 	int ret;
 
-	mutex_lock(&ds1374->mutex);
+	mutex_lock(&drv_data->mutex);
 
 	ret = i2c_smbus_read_byte_data(client, DS1374_REG_CR);
 	if (ret < 0)
@@ -346,383 +323,96 @@ static int ds1374_alarm_irq_enable(struct device *dev, unsigned int enabled)
 	ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, ret);
 
 out:
-	mutex_unlock(&ds1374->mutex);
+	mutex_unlock(&drv_data->mutex);
 	return ret;
 }
 #endif
 
 static const struct rtc_class_ops ds1374_rtc_ops = {
-	.read_time = ds1374_read_time,
-	.set_time = ds1374_set_time,
-#ifndef CONFIG_RTC_DRV_DS1374_WDT
-	.read_alarm = ds1374_read_alarm,
-	.set_alarm = ds1374_set_alarm,
+	.read_time        = ds1374_read_time,
+	.set_time         = ds1374_set_time,
+#ifndef CONFIG_DS1374_WATCHDOG
+	.read_alarm       = ds1374_read_alarm,
+	.set_alarm        = ds1374_set_alarm,
 	.alarm_irq_enable = ds1374_alarm_irq_enable,
 #endif
 };
 
-#ifdef CONFIG_RTC_DRV_DS1374_WDT
-/*
- *****************************************************************************
- *
- * Watchdog Driver
- *
- *****************************************************************************
- */
-static struct i2c_client *save_client;
-/* Default margin */
-#define WD_TIMO 131762
-
-#define DRV_NAME "DS1374 Watchdog"
-
-static int wdt_margin = WD_TIMO;
-static unsigned long wdt_is_open;
-module_param(wdt_margin, int, 0);
-MODULE_PARM_DESC(wdt_margin, "Watchdog timeout in seconds (default 32s)");
-
-static const struct watchdog_info ds1374_wdt_info = {
-	.identity       = "DS1374 WTD",
-	.options        = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING |
-						WDIOF_MAGICCLOSE,
-};
-
-static int ds1374_wdt_settimeout(unsigned int timeout)
+static int ds1374_rtc_probe(struct platform_device *pdev)
 {
-	int ret = -ENOIOCTLCMD;
-	int cr;
-
-	ret = cr = i2c_smbus_read_byte_data(save_client, DS1374_REG_CR);
-	if (ret < 0)
-		goto out;
-
-	/* Disable any existing watchdog/alarm before setting the new one */
-	cr &= ~DS1374_REG_CR_WACE;
-
-	ret = i2c_smbus_write_byte_data(save_client, DS1374_REG_CR, cr);
-	if (ret < 0)
-		goto out;
-
-	/* Set new watchdog time */
-	ret = ds1374_write_rtc(save_client, timeout, DS1374_REG_WDALM0, 3);
-	if (ret) {
-		pr_info("couldn't set new watchdog time\n");
-		goto out;
-	}
-
-	/* Enable watchdog timer */
-	cr |= DS1374_REG_CR_WACE | DS1374_REG_CR_WDALM;
-	cr &= ~DS1374_REG_CR_AIE;
-
-	ret = i2c_smbus_write_byte_data(save_client, DS1374_REG_CR, cr);
-	if (ret < 0)
-		goto out;
-
-	return 0;
-out:
-	return ret;
-}
-
-
-/*
- * Reload the watchdog timer.  (ie, pat the watchdog)
- */
-static void ds1374_wdt_ping(void)
-{
-	u32 val;
-	int ret = 0;
-
-	ret = ds1374_read_rtc(save_client, &val, DS1374_REG_WDALM0, 3);
-	if (ret)
-		pr_info("WD TICK FAIL!!!!!!!!!! %i\n", ret);
-}
-
-static void ds1374_wdt_disable(void)
-{
-	int cr;
-
-	cr = i2c_smbus_read_byte_data(save_client, DS1374_REG_CR);
-	/* Disable watchdog timer */
-	cr &= ~DS1374_REG_CR_WACE;
-
-	i2c_smbus_write_byte_data(save_client, DS1374_REG_CR, cr);
-}
-
-/*
- * Watchdog device is opened, and watchdog starts running.
- */
-static int ds1374_wdt_open(struct inode *inode, struct file *file)
-{
-	struct ds1374 *ds1374 = i2c_get_clientdata(save_client);
-
-	if (MINOR(inode->i_rdev) == WATCHDOG_MINOR) {
-		mutex_lock(&ds1374->mutex);
-		if (test_and_set_bit(0, &wdt_is_open)) {
-			mutex_unlock(&ds1374->mutex);
-			return -EBUSY;
-		}
-		/*
-		 *      Activate
-		 */
-		wdt_is_open = 1;
-		mutex_unlock(&ds1374->mutex);
-		return stream_open(inode, file);
-	}
-	return -ENODEV;
-}
-
-/*
- * Close the watchdog device.
- */
-static int ds1374_wdt_release(struct inode *inode, struct file *file)
-{
-	if (MINOR(inode->i_rdev) == WATCHDOG_MINOR)
-		clear_bit(0, &wdt_is_open);
-
-	return 0;
-}
-
-/*
- * Pat the watchdog whenever device is written to.
- */
-static ssize_t ds1374_wdt_write(struct file *file, const char __user *data,
-				size_t len, loff_t *ppos)
-{
-	if (len) {
-		ds1374_wdt_ping();
-		return 1;
-	}
-	return 0;
-}
-
-static ssize_t ds1374_wdt_read(struct file *file, char __user *data,
-				size_t len, loff_t *ppos)
-{
-	return 0;
-}
-
-/*
- * Handle commands from user-space.
- */
-static long ds1374_wdt_ioctl(struct file *file, unsigned int cmd,
-							unsigned long arg)
-{
-	int new_margin, options;
-
-	switch (cmd) {
-	case WDIOC_GETSUPPORT:
-		return copy_to_user((struct watchdog_info __user *)arg,
-		&ds1374_wdt_info, sizeof(ds1374_wdt_info)) ? -EFAULT : 0;
-
-	case WDIOC_GETSTATUS:
-	case WDIOC_GETBOOTSTATUS:
-		return put_user(0, (int __user *)arg);
-	case WDIOC_KEEPALIVE:
-		ds1374_wdt_ping();
-		return 0;
-	case WDIOC_SETTIMEOUT:
-		if (get_user(new_margin, (int __user *)arg))
-			return -EFAULT;
-
-		/* the hardware's tick rate is 4096 Hz, so
-		 * the counter value needs to be scaled accordingly
-		 */
-		new_margin <<= 12;
-		if (new_margin < 1 || new_margin > 16777216)
-			return -EINVAL;
-
-		wdt_margin = new_margin;
-		ds1374_wdt_settimeout(new_margin);
-		ds1374_wdt_ping();
-		/* fallthrough */
-	case WDIOC_GETTIMEOUT:
-		/* when returning ... inverse is true */
-		return put_user((wdt_margin >> 12), (int __user *)arg);
-	case WDIOC_SETOPTIONS:
-		if (copy_from_user(&options, (int __user *)arg, sizeof(int)))
-			return -EFAULT;
-
-		if (options & WDIOS_DISABLECARD) {
-			pr_info("disable watchdog\n");
-			ds1374_wdt_disable();
-			return 0;
-		}
-
-		if (options & WDIOS_ENABLECARD) {
-			pr_info("enable watchdog\n");
-			ds1374_wdt_settimeout(wdt_margin);
-			ds1374_wdt_ping();
-			return 0;
-		}
-		return -EINVAL;
-	}
-	return -ENOTTY;
-}
-
-static long ds1374_wdt_unlocked_ioctl(struct file *file, unsigned int cmd,
-			unsigned long arg)
-{
-	int ret;
-	struct ds1374 *ds1374 = i2c_get_clientdata(save_client);
-
-	mutex_lock(&ds1374->mutex);
-	ret = ds1374_wdt_ioctl(file, cmd, arg);
-	mutex_unlock(&ds1374->mutex);
-
-	return ret;
-}
-
-static int ds1374_wdt_notify_sys(struct notifier_block *this,
-			unsigned long code, void *unused)
-{
-	if (code == SYS_DOWN || code == SYS_HALT)
-		/* Disable Watchdog */
-		ds1374_wdt_disable();
-	return NOTIFY_DONE;
-}
-
-static const struct file_operations ds1374_wdt_fops = {
-	.owner			= THIS_MODULE,
-	.read			= ds1374_wdt_read,
-	.unlocked_ioctl		= ds1374_wdt_unlocked_ioctl,
-	.compat_ioctl		= compat_ptr_ioctl,
-	.write			= ds1374_wdt_write,
-	.open                   = ds1374_wdt_open,
-	.release                = ds1374_wdt_release,
-	.llseek			= no_llseek,
-};
-
-static struct miscdevice ds1374_miscdev = {
-	.minor          = WATCHDOG_MINOR,
-	.name           = "watchdog",
-	.fops           = &ds1374_wdt_fops,
-};
-
-static struct notifier_block ds1374_wdt_notifier = {
-	.notifier_call = ds1374_wdt_notify_sys,
-};
-
-#endif /*CONFIG_RTC_DRV_DS1374_WDT*/
-/*
- *****************************************************************************
- *
- *	Driver Interface
- *
- *****************************************************************************
- */
-static int ds1374_probe(struct i2c_client *client,
-			const struct i2c_device_id *id)
-{
-	struct ds1374 *ds1374;
+	struct ds1374_rtc *drv_data;
+	struct i2c_client *client = to_i2c_client(pdev->dev.parent);
 	int ret;
 
-	ds1374 = devm_kzalloc(&client->dev, sizeof(struct ds1374), GFP_KERNEL);
-	if (!ds1374)
+	drv_data = devm_kzalloc(&pdev->dev, sizeof(struct ds1374_rtc),
+				GFP_KERNEL);
+	if (!drv_data)
 		return -ENOMEM;
 
-	ds1374->rtc = devm_rtc_allocate_device(&client->dev);
-	if (IS_ERR(ds1374->rtc))
-		return PTR_ERR(ds1374->rtc);
+	drv_data->rtc = devm_rtc_allocate_device(&pdev->dev);
+	if (IS_ERR(drv_data->rtc))
+		return PTR_ERR(drv_data->rtc);
 
-	ds1374->client = client;
-	i2c_set_clientdata(client, ds1374);
+	drv_data->client = client;
 
-	INIT_WORK(&ds1374->work, ds1374_work);
-	mutex_init(&ds1374->mutex);
+	INIT_WORK(&drv_data->work, ds1374_work);
+	mutex_init(&drv_data->mutex);
 
 	ret = ds1374_check_rtc_status(client);
 	if (ret)
 		return ret;
 
 	if (client->irq > 0) {
-		ret = devm_request_irq(&client->dev, client->irq, ds1374_irq, 0,
-					"ds1374", client);
+		ret = devm_request_irq(&pdev->dev, client->irq, ds1374_irq, 0,
+					"ds1374_rtc", pdev);
 		if (ret) {
-			dev_err(&client->dev, "unable to request IRQ\n");
+			dev_err(&pdev->dev, "unable to request IRQ\n");
 			return ret;
 		}
 
-		device_set_wakeup_capable(&client->dev, 1);
+		device_set_wakeup_capable(&pdev->dev, 1);
 	}
 
-	ds1374->rtc->ops = &ds1374_rtc_ops;
-	ds1374->rtc->range_max = U32_MAX;
+	drv_data->rtc->ops = &ds1374_rtc_ops;
+	drv_data->rtc->range_max = U32_MAX;
+	platform_set_drvdata(pdev, drv_data);
 
-	ret = rtc_register_device(ds1374->rtc);
+	ret = rtc_register_device(drv_data->rtc);
 	if (ret)
 		return ret;
 
-#ifdef CONFIG_RTC_DRV_DS1374_WDT
-	save_client = client;
-	ret = misc_register(&ds1374_miscdev);
-	if (ret)
-		return ret;
-	ret = register_reboot_notifier(&ds1374_wdt_notifier);
-	if (ret) {
-		misc_deregister(&ds1374_miscdev);
-		return ret;
-	}
-	ds1374_wdt_settimeout(131072);
-#endif
-
 	return 0;
 }
 
-static int ds1374_remove(struct i2c_client *client)
+static int ds1374_rtc_remove(struct platform_device *pdev)
 {
-	struct ds1374 *ds1374 = i2c_get_clientdata(client);
-#ifdef CONFIG_RTC_DRV_DS1374_WDT
-	misc_deregister(&ds1374_miscdev);
-	ds1374_miscdev.parent = NULL;
-	unregister_reboot_notifier(&ds1374_wdt_notifier);
-#endif
+	struct ds1374_rtc *drv_data = platform_get_drvdata(pdev);
+	struct i2c_client *client = to_i2c_client(pdev->dev.parent);
 
 	if (client->irq > 0) {
-		mutex_lock(&ds1374->mutex);
-		ds1374->exiting = 1;
-		mutex_unlock(&ds1374->mutex);
+		mutex_lock(&drv_data->mutex);
+		drv_data->exiting = 1;
+		mutex_unlock(&drv_data->mutex);
 
 		devm_free_irq(&client->dev, client->irq, client);
-		cancel_work_sync(&ds1374->work);
+		cancel_work_sync(&drv_data->work);
 	}
 
 	return 0;
 }
 
-#ifdef CONFIG_PM_SLEEP
-static int ds1374_suspend(struct device *dev)
-{
-	struct i2c_client *client = to_i2c_client(dev);
-
-	if (client->irq > 0 && device_may_wakeup(&client->dev))
-		enable_irq_wake(client->irq);
-	return 0;
-}
-
-static int ds1374_resume(struct device *dev)
-{
-	struct i2c_client *client = to_i2c_client(dev);
-
-	if (client->irq > 0 && device_may_wakeup(&client->dev))
-		disable_irq_wake(client->irq);
-	return 0;
-}
-#endif
-
-static SIMPLE_DEV_PM_OPS(ds1374_pm, ds1374_suspend, ds1374_resume);
-
-static struct i2c_driver ds1374_driver = {
-	.driver = {
-		.name = "rtc-ds1374",
-		.of_match_table = of_match_ptr(ds1374_of_match),
-		.pm = &ds1374_pm,
+static struct platform_driver ds1374_rtc = {
+	.driver	       = {
+		.owner = THIS_MODULE,
+		.name  = DEVNAME,
 	},
-	.probe = ds1374_probe,
-	.remove = ds1374_remove,
-	.id_table = ds1374_id,
+	.probe         = ds1374_rtc_probe,
+	.remove        = ds1374_rtc_remove,
 };
 
-module_i2c_driver(ds1374_driver);
+module_platform_driver(ds1374_rtc);
 
 MODULE_AUTHOR("Scott Wood <scottwood@freescale.com>");
 MODULE_DESCRIPTION("Maxim/Dallas DS1374 RTC Driver");
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("Platform:ds1374_rtc");
