liyepan/openloongarch-linux-5.10
1
0
Fork 0
mirror of https://gitee.com/open-loongarch/linux-5.10.git synced 2026-10-25 20:57:11 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
master
openloongarch-linux-5.10/drivers/rtc/rtc-ls2x.c
T
michael e08a4045bd init src a7f3115
2024-06-17 20:18:01 +08:00

345 lines
8.3 KiB
C
Raw Permalink Blame History

// SPDX-License-Identifier: GPL-2.0
/*
* Loongson-2H/7A Real Time Clock interface for Linux
*
* Author: Shaozong Liu <liushaozong@loongson.cn>
* Huacai Chen <chenhc@lemote.com>
*
*/
#include <linux/acpi.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/ioport.h>
#include <linux/delay.h>
#include <linux/rtc.h>
#include <linux/bcd.h>
#include <linux/platform_device.h>
#include <linux/time.h>
#include <linux/spinlock.h>
#include <linux/device.h>
#include <asm/io.h>
#include <asm/time.h>
#include <loongson.h>
/**
* Loongson-2H/7A rtc register
*/
#define TOY_TRIM_REG 0x20
#define TOY_WRITE0_REG 0x24
#define TOY_WRITE1_REG 0x28
#define TOY_READ0_REG 0x2c
#define TOY_READ1_REG 0x30
#define TOY_MATCH0_REG 0x34
#define TOY_MATCH1_REG 0x38
#define TOY_MATCH2_REG 0x3c
#define RTC_CTRL_REG 0x40
#define RTC_TRIM_REG 0x60
#define RTC_WRITE0_REG 0x64
#define RTC_READE0_REG 0x68
#define RTC_MATCH0_REG 0x6c
#define RTC_MATCH1_REG 0x70
#define RTC_MATCH2_REG 0x74
/**
* shift bits and filed mask
*/
#define TOY_MON_MASK 0x3f
#define TOY_DAY_MASK 0x1f
#define TOY_HOUR_MASK 0x1f
#define TOY_MIN_MASK 0x3f
#define TOY_SEC_MASK 0x3f
#define TOY_MSEC_MASK 0xf
#define TOY_MON_SHIFT 26
#define TOY_DAY_SHIFT 21
#define TOY_HOUR_SHIFT 16
#define TOY_MIN_SHIFT 10
#define TOY_SEC_SHIFT 4
#define TOY_MSEC_SHIFT 0
/* shift bits for TOY_MATCH */
#define TOY_MATCH_YEAR_SHIFT 26
#define TOY_MATCH_MON_SHIFT 22
#define TOY_MATCH_DAY_SHIFT 17
#define TOY_MATCH_HOUR_SHIFT 12
#define TOY_MATCH_MIN_SHIFT 6
#define TOY_MATCH_SEC_SHIFT 0
/* Filed mask bits for TOY_MATCH */
#define TOY_MATCH_YEAR_MASK 0x3f
#define TOY_MATCH_MON_MASK 0xf
#define TOY_MATCH_DAY_MASK 0x1f
#define TOY_MATCH_HOUR_MASK 0x1f
#define TOY_MATCH_MIN_MASK 0x3f
#define TOY_MATCH_SEC_MASK 0x3f
/* TOY Enable bits */
#define RTC_ENABLE_BIT (1UL << 13)
#define TOY_ENABLE_BIT (1UL << 11)
#define OSC_ENABLE_BIT (1UL << 8)
/* ACPI and RTC offset */
#define ACPI_RTC_OFFSET 0x100
/* support rtc wakeup */
#define PM1_STS_FOR_RTC 0x10
#define RTC_STS_WAKEUP_BIT (0x1 << 10)
#define ACPI_FOR_RTC_WAKEUP_BASE \
(rtc_reg_base - ACPI_RTC_OFFSET + PM1_STS_FOR_RTC)
/* interface for rtc read and write */
#define rtc_write(val, addr) writel(val, rtc_reg_base + (addr))
#define rtc_read(addr) readl(rtc_reg_base + (addr))
DEFINE_SPINLOCK(rtc_lock);
struct ls2x_rtc_info {
struct platform_device *pdev;
struct rtc_device *rtc_dev;
struct resource *mem_res;
void __iomem *rtc_base;
int irq_base;
};
static void __iomem *rtc_reg_base;
static int ls2x_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
unsigned int val;
unsigned long flags;
spin_lock_irqsave(&rtc_lock, flags);
val = rtc_read(TOY_READ1_REG);
tm->tm_year = val;
val = rtc_read(TOY_READ0_REG);
tm->tm_sec = (val >> TOY_SEC_SHIFT) & TOY_SEC_MASK;
tm->tm_min = (val >> TOY_MIN_SHIFT) & TOY_MIN_MASK;
tm->tm_hour = (val >> TOY_HOUR_SHIFT) & TOY_HOUR_MASK;
tm->tm_mday = (val >> TOY_DAY_SHIFT) & TOY_DAY_MASK;
tm->tm_mon = ((val >> TOY_MON_SHIFT) & TOY_MON_MASK) - 1;
spin_unlock_irqrestore(&rtc_lock, flags);
return 0;
}
static int ls2x_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
unsigned int val = 0;
unsigned long flags;
spin_lock_irqsave(&rtc_lock, flags);
val |= (tm->tm_sec << TOY_SEC_SHIFT);
val |= (tm->tm_min << TOY_MIN_SHIFT);
val |= (tm->tm_hour << TOY_HOUR_SHIFT);
val |= (tm->tm_mday << TOY_DAY_SHIFT);
val |= ((tm->tm_mon + 1) << TOY_MON_SHIFT);
rtc_write(val, TOY_WRITE0_REG);
val = tm->tm_year;
rtc_write(val, TOY_WRITE1_REG);
spin_unlock_irqrestore(&rtc_lock, flags);
return 0;
}
static int ls2x_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{
unsigned int val;
unsigned long flags;
struct rtc_time *tm = &alrm->time;
spin_lock_irqsave(&rtc_lock, flags);
val = rtc_read(TOY_MATCH0_REG);
tm->tm_sec = (val >> TOY_MATCH_SEC_SHIFT) & TOY_MATCH_SEC_MASK;
tm->tm_min = (val >> TOY_MATCH_MIN_SHIFT) & TOY_MATCH_MIN_MASK;
tm->tm_hour = (val >> TOY_MATCH_HOUR_SHIFT) & TOY_MATCH_HOUR_MASK;
tm->tm_mday = (val >> TOY_MATCH_DAY_SHIFT) & TOY_MATCH_DAY_MASK;
tm->tm_mon = ((val >> TOY_MATCH_MON_SHIFT) & TOY_MATCH_MON_MASK) - 1;
tm->tm_year = ((val >> TOY_MATCH_YEAR_SHIFT) & TOY_MATCH_YEAR_MASK);
spin_unlock_irqrestore(&rtc_lock, flags);
return 0;
}
static int ls2x_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{
unsigned int val = 0;
unsigned int temp = 0;
unsigned long flags;
struct rtc_time *tm = &alrm->time;
spin_lock_irqsave(&rtc_lock, flags);
val |= (tm->tm_sec << TOY_MATCH_SEC_SHIFT);
val |= (tm->tm_min << TOY_MATCH_MIN_SHIFT);
val |= (tm->tm_hour << TOY_MATCH_HOUR_SHIFT);
val |= (tm->tm_mday << TOY_MATCH_DAY_SHIFT);
val |= ((tm->tm_mon + 1) << TOY_MATCH_MON_SHIFT);
val |= ((tm->tm_year & TOY_MATCH_YEAR_MASK) << TOY_MATCH_YEAR_SHIFT);
rtc_write(val, TOY_MATCH0_REG);
/* enalbe acpi rtc wakeup */
temp = readl(ACPI_FOR_RTC_WAKEUP_BASE) | RTC_STS_WAKEUP_BIT;
writel(temp, ACPI_FOR_RTC_WAKEUP_BASE);
spin_unlock_irqrestore(&rtc_lock, flags);
return 0;
}
static struct rtc_class_ops ls2x_rtc_ops = {
.read_time = ls2x_rtc_read_time,
.set_time = ls2x_rtc_set_time,
.read_alarm = ls2x_rtc_read_alarm,
.set_alarm = ls2x_rtc_set_alarm,
};
static int ls2x_rtc_probe(struct platform_device *pdev)
{
struct resource *res, *mem;
struct device *dev = &pdev->dev;
struct rtc_device *rtc;
struct ls2x_rtc_info *info;
unsigned int reg_val;
info = kzalloc(sizeof(struct ls2x_rtc_info), GFP_KERNEL);
if (!info) {
pr_err("%s: no enough memory\n", pdev->name);
return -ENOMEM;
}
info->pdev = pdev;
info->irq_base = platform_get_irq(pdev, 0);
if (info->irq_base <= 0) {
pr_err("%s: no irq?\n", pdev->name);
return -ENOENT;
}
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
pr_err("%s: RTC resource data missing\n", pdev->name);
return -ENOENT;
}
mem = request_mem_region(res->start, resource_size(res), pdev->name);
if (!mem) {
pr_err("%s: RTC registers at %x are not free\n",
pdev->name, (unsigned int)res->start);
return -EBUSY;
}
info->mem_res = mem;
info->rtc_base = ioremap(res->start, resource_size(res));
if (!info->rtc_base) {
pr_err("%s: RTC registers can't be mapped\n", pdev->name);
goto fail1;
}
rtc_reg_base = info->rtc_base;
/* loongson: init rtc trim register, otherwise rtc will not update */
rtc_write(0x0, TOY_TRIM_REG);
rtc_write(0x0, RTC_TRIM_REG);
/* enable rtc */
reg_val = rtc_read(RTC_CTRL_REG);
reg_val |= TOY_ENABLE_BIT | OSC_ENABLE_BIT;
rtc_write(reg_val, RTC_CTRL_REG);
device_init_wakeup(dev, 1);
rtc = info->rtc_dev = devm_rtc_device_register(&pdev->dev, pdev->name,
&ls2x_rtc_ops, THIS_MODULE);
/* There don't need alarm interrupt */
info->rtc_dev->uie_unsupported = 1;
if (IS_ERR(info->rtc_dev)) {
pr_err("%s: can't register RTC device, err %ld\n",
pdev->name, PTR_ERR(rtc));
goto fail0;
}
platform_set_drvdata(pdev, info);
dev_set_drvdata(&rtc->dev, info);
check_and_init_vaild_rtc_time(rtc);
return 0;
fail0:
iounmap(info->rtc_base);
fail1:
release_resource(mem);
kfree(info);
return -EIO;
}
static int ls2x_rtc_remove(struct platform_device *pdev)
{
struct ls2x_rtc_info *info = platform_get_drvdata(pdev);
struct rtc_device *rtc = info->rtc_dev;
iounmap(info->rtc_base);
release_resource(dev_get_drvdata(&rtc->dev));
release_resource(info->mem_res);
kfree(info);
return 0;
}
#ifdef CONFIG_OF
static struct of_device_id ls2x_rtc_id_table[] = {
{.compatible = "loongson,ls2h-rtc"},
{.compatible = "loongson,ls2k-rtc"},
{.compatible = "loongson,ls7a-rtc"},
{},
};
#endif
static const struct acpi_device_id ls2x_rtc_acpi_match[] = {
{"LOON0001"},
{}
};
MODULE_DEVICE_TABLE(acpi, ls2x_rtc_acpi_match);
static struct platform_driver ls2x_rtc_driver = {
.probe = ls2x_rtc_probe,
.remove = ls2x_rtc_remove,
.driver = {
.name = "ls2x-rtc",
.owner = THIS_MODULE,
#ifdef CONFIG_OF
.of_match_table = of_match_ptr(ls2x_rtc_id_table),
#endif
.acpi_match_table = ACPI_PTR(ls2x_rtc_acpi_match),
},
};
static int __init rtc_init(void)
{
return platform_driver_register(&ls2x_rtc_driver);
}
static void __exit rtc_exit(void)
{
platform_driver_unregister(&ls2x_rtc_driver);
}
module_init(rtc_init);
module_exit(rtc_exit);
MODULE_AUTHOR("Liu Shaozong");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:ls2x-rtc");
Reference in New Issue View Git Blame Copy Permalink