Move Watchdog function to ds1374_wdt.c which is in the Watchdog
subsystem, and just keep RTC and Alarm function in rtc-ds1374.c.
Besides, Move I2C client to ds1374.c which is in MFD subsystem.
Signed-off-by: Johnson Chen <johnsonch.c...@moxa.com>
---
drivers/rtc/Kconfig | 9 +-
drivers/rtc/rtc-ds1374.c | 458 +++++++--------------------------------
2 files changed, 76 insertions(+), 391 deletions(-)
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 <rvin...@mvista.com>,
* which was based on the m41t00.c by Mark Greer <mgr...@mvista.com>.
*
+ * Copyright (C) 2020 Johnson Chen <johnsonch.c...@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 <scottw...@freescale.com>");
MODULE_DESCRIPTION("Maxim/Dallas DS1374 RTC Driver");
MODULE_LICENSE("GPL");
+MODULE_ALIAS("Platform:ds1374_rtc");
--
2.20.1
