LXR linux/arch/x86/platform/intel-mid/intel_mid

   1/*
   2 * intel_mid_vrtc.c: Driver for virtual RTC device on Intel MID platform
   3 *
   4 * (C) Copyright 2009 Intel Corporation
   5 *
   6 * This program is free software; you can redistribute it and/or
   7 * modify it under the terms of the GNU General Public License
   8 * as published by the Free Software Foundation; version 2
   9 * of the License.
  10 *
  11 * Note:
  12 * VRTC is emulated by system controller firmware, the real HW
  13 * RTC is located in the PMIC device. SCU FW shadows PMIC RTC
  14 * in a memory mapped IO space that is visible to the host IA
  15 * processor.
  16 *
  17 * This driver is based on RTC CMOS driver.
  18 */
  19
  20#include <linux/kernel.h>
  21#include <linux/export.h>
  22#include <linux/init.h>
  23#include <linux/sfi.h>
  24#include <linux/platform_device.h>
  25
  26#include <asm/intel-mid.h>
  27#include <asm/intel_mid_vrtc.h>
  28#include <asm/time.h>
  29#include <asm/fixmap.h>
  30
  31static unsigned char __iomem *vrtc_virt_base;
  32
  33unsigned char vrtc_cmos_read(unsigned char reg)
  34{
  35        unsigned char retval;
  36
  37        /* vRTC's registers range from 0x0 to 0xD */
  38        if (reg > 0xd || !vrtc_virt_base)
  39                return 0xff;
  40
  41        lock_cmos_prefix(reg);
  42        retval = __raw_readb(vrtc_virt_base + (reg << 2));
  43        lock_cmos_suffix(reg);
  44        return retval;
  45}
  46EXPORT_SYMBOL_GPL(vrtc_cmos_read);
  47
  48void vrtc_cmos_write(unsigned char val, unsigned char reg)
  49{
  50        if (reg > 0xd || !vrtc_virt_base)
  51                return;
  52
  53        lock_cmos_prefix(reg);
  54        __raw_writeb(val, vrtc_virt_base + (reg << 2));
  55        lock_cmos_suffix(reg);
  56}
  57EXPORT_SYMBOL_GPL(vrtc_cmos_write);
  58
  59void vrtc_get_time(struct timespec *now)
  60{
  61        u8 sec, min, hour, mday, mon;
  62        unsigned long flags;
  63        u32 year;
  64
  65        spin_lock_irqsave(&rtc_lock, flags);
  66
  67        while ((vrtc_cmos_read(RTC_FREQ_SELECT) & RTC_UIP))
  68                cpu_relax();
  69
  70        sec = vrtc_cmos_read(RTC_SECONDS);
  71        min = vrtc_cmos_read(RTC_MINUTES);
  72        hour = vrtc_cmos_read(RTC_HOURS);
  73        mday = vrtc_cmos_read(RTC_DAY_OF_MONTH);
  74        mon = vrtc_cmos_read(RTC_MONTH);
  75        year = vrtc_cmos_read(RTC_YEAR);
  76
  77        spin_unlock_irqrestore(&rtc_lock, flags);
  78
  79        /* vRTC YEAR reg contains the offset to 1972 */
  80        year += 1972;
  81
  82        pr_info("vRTC: sec: %d min: %d hour: %d day: %d "
  83                "mon: %d year: %d\n", sec, min, hour, mday, mon, year);
  84
  85        now->tv_sec = mktime(year, mon, mday, hour, min, sec);
  86        now->tv_nsec = 0;
  87}
  88
  89int vrtc_set_mmss(const struct timespec *now)
  90{
  91        unsigned long flags;
  92        struct rtc_time tm;
  93        int year;
  94        int retval = 0;
  95
  96        rtc_time_to_tm(now->tv_sec, &tm);
  97        if (!rtc_valid_tm(&tm) && tm.tm_year >= 72) {
  98                /*
  99                 * tm.year is the number of years since 1900, and the
 100                 * vrtc need the years since 1972.
 101                 */
 102                year = tm.tm_year - 72;
 103                spin_lock_irqsave(&rtc_lock, flags);
 104                vrtc_cmos_write(year, RTC_YEAR);
 105                vrtc_cmos_write(tm.tm_mon, RTC_MONTH);
 106                vrtc_cmos_write(tm.tm_mday, RTC_DAY_OF_MONTH);
 107                vrtc_cmos_write(tm.tm_hour, RTC_HOURS);
 108                vrtc_cmos_write(tm.tm_min, RTC_MINUTES);
 109                vrtc_cmos_write(tm.tm_sec, RTC_SECONDS);
 110                spin_unlock_irqrestore(&rtc_lock, flags);
 111        } else {
 112                pr_err("%s: Invalid vRTC value: write of %lx to vRTC failed\n",
 113                        __FUNCTION__, now->tv_sec);
 114                retval = -EINVAL;
 115        }
 116        return retval;
 117}
 118
 119void __init intel_mid_rtc_init(void)
 120{
 121        unsigned long vrtc_paddr;
 122
 123        sfi_table_parse(SFI_SIG_MRTC, NULL, NULL, sfi_parse_mrtc);
 124
 125        vrtc_paddr = sfi_mrtc_array[0].phys_addr;
 126        if (!sfi_mrtc_num || !vrtc_paddr)
 127                return;
 128
 129        vrtc_virt_base = (void __iomem *)set_fixmap_offset_nocache(FIX_LNW_VRTC,
 130                                                                vrtc_paddr);
 131        x86_platform.get_wallclock = vrtc_get_time;
 132        x86_platform.set_wallclock = vrtc_set_mmss;
 133}
 134
 135/*
 136 * The Moorestown platform has a memory mapped virtual RTC device that emulates
 137 * the programming interface of the RTC.
 138 */
 139
 140static struct resource vrtc_resources[] = {
 141        [0] = {
 142                .flags  = IORESOURCE_MEM,
 143        },
 144        [1] = {
 145                .flags  = IORESOURCE_IRQ,
 146        }
 147};
 148
 149static struct platform_device vrtc_device = {
 150        .name           = "rtc_mrst",
 151        .id             = -1,
 152        .resource       = vrtc_resources,
 153        .num_resources  = ARRAY_SIZE(vrtc_resources),
 154};
 155
 156/* Register the RTC device if appropriate */
 157static int __init intel_mid_device_create(void)
 158{
 159        /* No Moorestown, no device */
 160        if (!intel_mid_identify_cpu())
 161                return -ENODEV;
 162        /* No timer, no device */
 163        if (!sfi_mrtc_num)
 164                return -ENODEV;
 165
 166        /* iomem resource */
 167        vrtc_resources[0].start = sfi_mrtc_array[0].phys_addr;
 168        vrtc_resources[0].end = sfi_mrtc_array[0].phys_addr +
 169                                MRST_VRTC_MAP_SZ;
 170        /* irq resource */
 171        vrtc_resources[1].start = sfi_mrtc_array[0].irq;
 172        vrtc_resources[1].end = sfi_mrtc_array[0].irq;
 173
 174        return platform_device_register(&vrtc_device);
 175}
 176
 177module_init(intel_mid_device_create);
 178