mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
173 lines
4.2 KiB
173 lines
4.2 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/* |
|
* intel_mid_vrtc.c: Driver for virtual RTC device on Intel MID platform |
|
* |
|
* (C) Copyright 2009 Intel Corporation |
|
* |
|
* Note: |
|
* VRTC is emulated by system controller firmware, the real HW |
|
* RTC is located in the PMIC device. SCU FW shadows PMIC RTC |
|
* in a memory mapped IO space that is visible to the host IA |
|
* processor. |
|
* |
|
* This driver is based on RTC CMOS driver. |
|
*/ |
|
|
|
#include <linux/kernel.h> |
|
#include <linux/export.h> |
|
#include <linux/init.h> |
|
#include <linux/sfi.h> |
|
#include <linux/platform_device.h> |
|
#include <linux/mc146818rtc.h> |
|
|
|
#include <asm/intel-mid.h> |
|
#include <asm/intel_mid_vrtc.h> |
|
#include <asm/time.h> |
|
#include <asm/fixmap.h> |
|
|
|
static unsigned char __iomem *vrtc_virt_base; |
|
|
|
unsigned char vrtc_cmos_read(unsigned char reg) |
|
{ |
|
unsigned char retval; |
|
|
|
/* vRTC's registers range from 0x0 to 0xD */ |
|
if (reg > 0xd || !vrtc_virt_base) |
|
return 0xff; |
|
|
|
lock_cmos_prefix(reg); |
|
retval = __raw_readb(vrtc_virt_base + (reg << 2)); |
|
lock_cmos_suffix(reg); |
|
return retval; |
|
} |
|
EXPORT_SYMBOL_GPL(vrtc_cmos_read); |
|
|
|
void vrtc_cmos_write(unsigned char val, unsigned char reg) |
|
{ |
|
if (reg > 0xd || !vrtc_virt_base) |
|
return; |
|
|
|
lock_cmos_prefix(reg); |
|
__raw_writeb(val, vrtc_virt_base + (reg << 2)); |
|
lock_cmos_suffix(reg); |
|
} |
|
EXPORT_SYMBOL_GPL(vrtc_cmos_write); |
|
|
|
void vrtc_get_time(struct timespec64 *now) |
|
{ |
|
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); |
|
|
|
now->tv_sec = mktime64(year, mon, mday, hour, min, sec); |
|
now->tv_nsec = 0; |
|
} |
|
|
|
int vrtc_set_mmss(const struct timespec64 *now) |
|
{ |
|
unsigned long flags; |
|
struct rtc_time tm; |
|
int year; |
|
int retval = 0; |
|
|
|
rtc_time64_to_tm(now->tv_sec, &tm); |
|
if (!rtc_valid_tm(&tm) && tm.tm_year >= 72) { |
|
/* |
|
* tm.year is the number of years since 1900, and the |
|
* vrtc need the years since 1972. |
|
*/ |
|
year = tm.tm_year - 72; |
|
spin_lock_irqsave(&rtc_lock, flags); |
|
vrtc_cmos_write(year, RTC_YEAR); |
|
vrtc_cmos_write(tm.tm_mon, RTC_MONTH); |
|
vrtc_cmos_write(tm.tm_mday, RTC_DAY_OF_MONTH); |
|
vrtc_cmos_write(tm.tm_hour, RTC_HOURS); |
|
vrtc_cmos_write(tm.tm_min, RTC_MINUTES); |
|
vrtc_cmos_write(tm.tm_sec, RTC_SECONDS); |
|
spin_unlock_irqrestore(&rtc_lock, flags); |
|
} else { |
|
pr_err("%s: Invalid vRTC value: write of %llx to vRTC failed\n", |
|
__func__, (s64)now->tv_sec); |
|
retval = -EINVAL; |
|
} |
|
return retval; |
|
} |
|
|
|
void __init intel_mid_rtc_init(void) |
|
{ |
|
unsigned long vrtc_paddr; |
|
|
|
sfi_table_parse(SFI_SIG_MRTC, NULL, NULL, sfi_parse_mrtc); |
|
|
|
vrtc_paddr = sfi_mrtc_array[0].phys_addr; |
|
if (!sfi_mrtc_num || !vrtc_paddr) |
|
return; |
|
|
|
vrtc_virt_base = (void __iomem *)set_fixmap_offset_nocache(FIX_LNW_VRTC, |
|
vrtc_paddr); |
|
x86_platform.get_wallclock = vrtc_get_time; |
|
x86_platform.set_wallclock = vrtc_set_mmss; |
|
} |
|
|
|
/* |
|
* The Moorestown platform has a memory mapped virtual RTC device that emulates |
|
* the programming interface of the RTC. |
|
*/ |
|
|
|
static struct resource vrtc_resources[] = { |
|
[0] = { |
|
.flags = IORESOURCE_MEM, |
|
}, |
|
[1] = { |
|
.flags = IORESOURCE_IRQ, |
|
} |
|
}; |
|
|
|
static struct platform_device vrtc_device = { |
|
.name = "rtc_mrst", |
|
.id = -1, |
|
.resource = vrtc_resources, |
|
.num_resources = ARRAY_SIZE(vrtc_resources), |
|
}; |
|
|
|
/* Register the RTC device if appropriate */ |
|
static int __init intel_mid_device_create(void) |
|
{ |
|
/* No Moorestown, no device */ |
|
if (!intel_mid_identify_cpu()) |
|
return -ENODEV; |
|
/* No timer, no device */ |
|
if (!sfi_mrtc_num) |
|
return -ENODEV; |
|
|
|
/* iomem resource */ |
|
vrtc_resources[0].start = sfi_mrtc_array[0].phys_addr; |
|
vrtc_resources[0].end = sfi_mrtc_array[0].phys_addr + |
|
MRST_VRTC_MAP_SZ; |
|
/* irq resource */ |
|
vrtc_resources[1].start = sfi_mrtc_array[0].irq; |
|
vrtc_resources[1].end = sfi_mrtc_array[0].irq; |
|
|
|
return platform_device_register(&vrtc_device); |
|
} |
|
device_initcall(intel_mid_device_create);
|
|
|