rtc-m48t86.c 7.88 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
/*
 * ST M48T86 / Dallas DS12887 RTC driver
 * Copyright (c) 2006 Tower Technologies
 *
 * Author: Alessandro Zummo <a.zummo@towertech.it>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * This drivers only supports the clock running in BCD and 24H mode.
 * If it will be ever adapted to binary and 12H mode, care must be taken
 * to not introduce bugs.
 */

#include <linux/module.h>
#include <linux/rtc.h>
#include <linux/platform_device.h>
#include <linux/bcd.h>
20
#include <linux/io.h>
21

22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
#define M48T86_SEC		0x00
#define M48T86_SECALRM		0x01
#define M48T86_MIN		0x02
#define M48T86_MINALRM		0x03
#define M48T86_HOUR		0x04
#define M48T86_HOURALRM		0x05
#define M48T86_DOW		0x06 /* 1 = sunday */
#define M48T86_DOM		0x07
#define M48T86_MONTH		0x08 /* 1 - 12 */
#define M48T86_YEAR		0x09 /* 0 - 99 */
#define M48T86_A		0x0a
#define M48T86_B		0x0b
#define M48T86_B_SET		BIT(7)
#define M48T86_B_DM		BIT(2)
#define M48T86_B_H24		BIT(1)
#define M48T86_C		0x0c
#define M48T86_D		0x0d
#define M48T86_D_VRT		BIT(7)
40 41
#define M48T86_NVRAM(x)		(0x0e + (x))
#define M48T86_NVRAM_LEN	114
42

43 44 45 46 47 48 49 50 51 52 53
struct m48t86_rtc_info {
	void __iomem *index_reg;
	void __iomem *data_reg;
	struct rtc_device *rtc;
};

static unsigned char m48t86_readb(struct device *dev, unsigned long addr)
{
	struct m48t86_rtc_info *info = dev_get_drvdata(dev);
	unsigned char value;

54 55 56
	writeb(addr, info->index_reg);
	value = readb(info->data_reg);

57 58 59 60 61 62 63 64
	return value;
}

static void m48t86_writeb(struct device *dev,
			  unsigned char value, unsigned long addr)
{
	struct m48t86_rtc_info *info = dev_get_drvdata(dev);

65 66
	writeb(addr, info->index_reg);
	writeb(value, info->data_reg);
67 68
}

69 70 71 72
static int m48t86_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
	unsigned char reg;

73
	reg = m48t86_readb(dev, M48T86_B);
74

75
	if (reg & M48T86_B_DM) {
76
		/* data (binary) mode */
77 78 79 80
		tm->tm_sec	= m48t86_readb(dev, M48T86_SEC);
		tm->tm_min	= m48t86_readb(dev, M48T86_MIN);
		tm->tm_hour	= m48t86_readb(dev, M48T86_HOUR) & 0x3f;
		tm->tm_mday	= m48t86_readb(dev, M48T86_DOM);
81
		/* tm_mon is 0-11 */
82 83 84
		tm->tm_mon	= m48t86_readb(dev, M48T86_MONTH) - 1;
		tm->tm_year	= m48t86_readb(dev, M48T86_YEAR) + 100;
		tm->tm_wday	= m48t86_readb(dev, M48T86_DOW);
85 86
	} else {
		/* bcd mode */
87 88 89 90 91
		tm->tm_sec	= bcd2bin(m48t86_readb(dev, M48T86_SEC));
		tm->tm_min	= bcd2bin(m48t86_readb(dev, M48T86_MIN));
		tm->tm_hour	= bcd2bin(m48t86_readb(dev, M48T86_HOUR) &
					  0x3f);
		tm->tm_mday	= bcd2bin(m48t86_readb(dev, M48T86_DOM));
92
		/* tm_mon is 0-11 */
93 94 95
		tm->tm_mon	= bcd2bin(m48t86_readb(dev, M48T86_MONTH)) - 1;
		tm->tm_year	= bcd2bin(m48t86_readb(dev, M48T86_YEAR)) + 100;
		tm->tm_wday	= bcd2bin(m48t86_readb(dev, M48T86_DOW));
96 97 98
	}

	/* correct the hour if the clock is in 12h mode */
99
	if (!(reg & M48T86_B_H24))
100
		if (m48t86_readb(dev, M48T86_HOUR) & 0x80)
101 102
			tm->tm_hour += 12;

103
	return rtc_valid_tm(tm);
104 105 106 107 108 109
}

static int m48t86_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
	unsigned char reg;

110
	reg = m48t86_readb(dev, M48T86_B);
111 112

	/* update flag and 24h mode */
113
	reg |= M48T86_B_SET | M48T86_B_H24;
114
	m48t86_writeb(dev, reg, M48T86_B);
115

116
	if (reg & M48T86_B_DM) {
117
		/* data (binary) mode */
118 119 120 121 122 123 124
		m48t86_writeb(dev, tm->tm_sec, M48T86_SEC);
		m48t86_writeb(dev, tm->tm_min, M48T86_MIN);
		m48t86_writeb(dev, tm->tm_hour, M48T86_HOUR);
		m48t86_writeb(dev, tm->tm_mday, M48T86_DOM);
		m48t86_writeb(dev, tm->tm_mon + 1, M48T86_MONTH);
		m48t86_writeb(dev, tm->tm_year % 100, M48T86_YEAR);
		m48t86_writeb(dev, tm->tm_wday, M48T86_DOW);
125 126
	} else {
		/* bcd mode */
127 128 129 130 131 132 133
		m48t86_writeb(dev, bin2bcd(tm->tm_sec), M48T86_SEC);
		m48t86_writeb(dev, bin2bcd(tm->tm_min), M48T86_MIN);
		m48t86_writeb(dev, bin2bcd(tm->tm_hour), M48T86_HOUR);
		m48t86_writeb(dev, bin2bcd(tm->tm_mday), M48T86_DOM);
		m48t86_writeb(dev, bin2bcd(tm->tm_mon + 1), M48T86_MONTH);
		m48t86_writeb(dev, bin2bcd(tm->tm_year % 100), M48T86_YEAR);
		m48t86_writeb(dev, bin2bcd(tm->tm_wday), M48T86_DOW);
134 135 136
	}

	/* update ended */
137
	reg &= ~M48T86_B_SET;
138
	m48t86_writeb(dev, reg, M48T86_B);
139 140 141 142 143 144 145 146

	return 0;
}

static int m48t86_rtc_proc(struct device *dev, struct seq_file *seq)
{
	unsigned char reg;

147
	reg = m48t86_readb(dev, M48T86_B);
148 149

	seq_printf(seq, "mode\t\t: %s\n",
150
		   (reg & M48T86_B_DM) ? "binary" : "bcd");
151

152
	reg = m48t86_readb(dev, M48T86_D);
153 154

	seq_printf(seq, "battery\t\t: %s\n",
155
		   (reg & M48T86_D_VRT) ? "ok" : "exhausted");
156 157 158 159

	return 0;
}

160
static const struct rtc_class_ops m48t86_rtc_ops = {
161 162 163 164 165
	.read_time	= m48t86_rtc_read_time,
	.set_time	= m48t86_rtc_set_time,
	.proc		= m48t86_rtc_proc,
};

166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194
static ssize_t m48t86_nvram_read(struct file *filp, struct kobject *kobj,
				 struct bin_attribute *attr,
				 char *buf, loff_t off, size_t count)
{
	struct device *dev = kobj_to_dev(kobj);
	unsigned int i;

	for (i = 0; i < count; i++)
		buf[i] = m48t86_readb(dev, M48T86_NVRAM(off + i));

	return count;
}

static ssize_t m48t86_nvram_write(struct file *filp, struct kobject *kobj,
				  struct bin_attribute *attr,
				  char *buf, loff_t off, size_t count)
{
	struct device *dev = kobj_to_dev(kobj);
	unsigned int i;

	for (i = 0; i < count; i++)
		m48t86_writeb(dev, buf[i], M48T86_NVRAM(off + i));

	return count;
}

static BIN_ATTR(nvram, 0644, m48t86_nvram_read, m48t86_nvram_write,
		M48T86_NVRAM_LEN);

195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225
/*
 * The RTC is an optional feature at purchase time on some Technologic Systems
 * boards. Verify that it actually exists by checking if the last two bytes
 * of the NVRAM can be changed.
 *
 * This is based on the method used in their rtc7800.c example.
 */
static bool m48t86_verify_chip(struct platform_device *pdev)
{
	unsigned int offset0 = M48T86_NVRAM(M48T86_NVRAM_LEN - 2);
	unsigned int offset1 = M48T86_NVRAM(M48T86_NVRAM_LEN - 1);
	unsigned char tmp0, tmp1;

	tmp0 = m48t86_readb(&pdev->dev, offset0);
	tmp1 = m48t86_readb(&pdev->dev, offset1);

	m48t86_writeb(&pdev->dev, 0x00, offset0);
	m48t86_writeb(&pdev->dev, 0x55, offset1);
	if (m48t86_readb(&pdev->dev, offset1) == 0x55) {
		m48t86_writeb(&pdev->dev, 0xaa, offset1);
		if (m48t86_readb(&pdev->dev, offset1) == 0xaa &&
		    m48t86_readb(&pdev->dev, offset0) == 0x00) {
			m48t86_writeb(&pdev->dev, tmp0, offset0);
			m48t86_writeb(&pdev->dev, tmp1, offset1);

			return true;
		}
	}
	return false;
}

226
static int m48t86_rtc_probe(struct platform_device *pdev)
227
{
228
	struct m48t86_rtc_info *info;
229
	struct resource *res;
230
	unsigned char reg;
231

232 233 234 235
	info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
	if (!info)
		return -ENOMEM;

236 237 238 239 240 241 242 243 244 245 246 247 248
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!res)
		return -ENODEV;
	info->index_reg = devm_ioremap_resource(&pdev->dev, res);
	if (IS_ERR(info->index_reg))
		return PTR_ERR(info->index_reg);

	res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
	if (!res)
		return -ENODEV;
	info->data_reg = devm_ioremap_resource(&pdev->dev, res);
	if (IS_ERR(info->data_reg))
		return PTR_ERR(info->data_reg);
249

250
	dev_set_drvdata(&pdev->dev, info);
251

252 253 254 255 256
	if (!m48t86_verify_chip(pdev)) {
		dev_info(&pdev->dev, "RTC not present\n");
		return -ENODEV;
	}

257 258 259 260
	info->rtc = devm_rtc_device_register(&pdev->dev, "m48t86",
					     &m48t86_rtc_ops, THIS_MODULE);
	if (IS_ERR(info->rtc))
		return PTR_ERR(info->rtc);
261 262

	/* read battery status */
263 264
	reg = m48t86_readb(&pdev->dev, M48T86_D);
	dev_info(&pdev->dev, "battery %s\n",
265
		 (reg & M48T86_D_VRT) ? "ok" : "exhausted");
266

267 268 269 270 271 272 273 274 275
	if (device_create_bin_file(&pdev->dev, &bin_attr_nvram))
		dev_err(&pdev->dev, "failed to create nvram sysfs entry\n");

	return 0;
}

static int m48t86_rtc_remove(struct platform_device *pdev)
{
	device_remove_bin_file(&pdev->dev, &bin_attr_nvram);
276 277 278 279 280 281 282 283
	return 0;
}

static struct platform_driver m48t86_rtc_platform_driver = {
	.driver		= {
		.name	= "rtc-m48t86",
	},
	.probe		= m48t86_rtc_probe,
284
	.remove		= m48t86_rtc_remove,
285 286
};

287
module_platform_driver(m48t86_rtc_platform_driver);
288 289 290 291

MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
MODULE_DESCRIPTION("M48T86 RTC driver");
MODULE_LICENSE("GPL");
292
MODULE_ALIAS("platform:rtc-m48t86");