rtc-m48t86.c 7.73 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 0;
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
static int m48t86_nvram_read(void *priv, unsigned int off, void *buf,
			     size_t count)
168
{
169
	struct device *dev = priv;
170 171 172
	unsigned int i;

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

175
	return 0;
176 177
}

178 179
static int m48t86_nvram_write(void *priv, unsigned int off, void *buf,
			      size_t count)
180
{
181
	struct device *dev = priv;
182 183 184
	unsigned int i;

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

187
	return 0;
188 189
}

190 191 192 193 194 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
/*
 * 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;
}

221
static int m48t86_rtc_probe(struct platform_device *pdev)
222
{
223
	struct m48t86_rtc_info *info;
224
	struct resource *res;
225
	unsigned char reg;
226
	int err;
227 228 229 230 231 232 233 234 235
	struct nvmem_config m48t86_nvmem_cfg = {
		.name = "m48t86_nvram",
		.word_size = 1,
		.stride = 1,
		.size = M48T86_NVRAM_LEN,
		.reg_read = m48t86_nvram_read,
		.reg_write = m48t86_nvram_write,
		.priv = &pdev->dev,
	};
236

237 238 239 240
	info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
	if (!info)
		return -ENOMEM;

241 242 243 244 245 246 247 248 249 250 251 252 253
	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);
254

255
	dev_set_drvdata(&pdev->dev, info);
256

257 258 259 260 261
	if (!m48t86_verify_chip(pdev)) {
		dev_info(&pdev->dev, "RTC not present\n");
		return -ENODEV;
	}

262
	info->rtc = devm_rtc_allocate_device(&pdev->dev);
263 264
	if (IS_ERR(info->rtc))
		return PTR_ERR(info->rtc);
265

266
	info->rtc->ops = &m48t86_rtc_ops;
267 268
	info->rtc->nvram_old_abi = true;

269 270 271 272
	err = rtc_register_device(info->rtc);
	if (err)
		return err;

273 274
	rtc_nvmem_register(info->rtc, &m48t86_nvmem_cfg);

275
	/* read battery status */
276 277
	reg = m48t86_readb(&pdev->dev, M48T86_D);
	dev_info(&pdev->dev, "battery %s\n",
278
		 (reg & M48T86_D_VRT) ? "ok" : "exhausted");
279 280 281 282 283 284 285 286 287 288 289

	return 0;
}

static struct platform_driver m48t86_rtc_platform_driver = {
	.driver		= {
		.name	= "rtc-m48t86",
	},
	.probe		= m48t86_rtc_probe,
};

290
module_platform_driver(m48t86_rtc_platform_driver);
291 292 293 294

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