rtc-m48t86.c 7.11 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/*
 * ST M48T86 / Dallas DS12887 RTC driver
 * Copyright (c) 2006 Tower Technologies
 *
 * Author: Alessandro Zummo <[email protected]>
 *
 * 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>
19
#include <linux/platform_data/rtc-m48t86.h>
20
#include <linux/bcd.h>
21
#include <linux/io.h>
22

23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
#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)
41 42
#define M48T86_NVRAM(x)		(0x0e + (x))
#define M48T86_NVRAM_LEN	114
43

44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77
struct m48t86_rtc_info {
	void __iomem *index_reg;
	void __iomem *data_reg;
	struct rtc_device *rtc;
	struct m48t86_ops *ops;
};

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

	if (info->ops) {
		value = info->ops->readbyte(addr);
	} else {
		writeb(addr, info->index_reg);
		value = readb(info->data_reg);
	}
	return value;
}

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

	if (info->ops) {
		info->ops->writebyte(value, addr);
	} else {
		writeb(addr, info->index_reg);
		writeb(value, info->data_reg);
	}
}

78 79 80 81
static int m48t86_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
	unsigned char reg;

82
	reg = m48t86_readb(dev, M48T86_B);
83

84
	if (reg & M48T86_B_DM) {
85
		/* data (binary) mode */
86 87 88 89
		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);
90
		/* tm_mon is 0-11 */
91 92 93
		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);
94 95
	} else {
		/* bcd mode */
96 97 98 99 100
		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));
101
		/* tm_mon is 0-11 */
102 103 104
		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));
105 106 107
	}

	/* correct the hour if the clock is in 12h mode */
108
	if (!(reg & M48T86_B_H24))
109
		if (m48t86_readb(dev, M48T86_HOUR) & 0x80)
110 111
			tm->tm_hour += 12;

112
	return rtc_valid_tm(tm);
113 114 115 116 117 118
}

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

119
	reg = m48t86_readb(dev, M48T86_B);
120 121

	/* update flag and 24h mode */
122
	reg |= M48T86_B_SET | M48T86_B_H24;
123
	m48t86_writeb(dev, reg, M48T86_B);
124

125
	if (reg & M48T86_B_DM) {
126
		/* data (binary) mode */
127 128 129 130 131 132 133
		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);
134 135
	} else {
		/* bcd mode */
136 137 138 139 140 141 142
		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);
143 144 145
	}

	/* update ended */
146
	reg &= ~M48T86_B_SET;
147
	m48t86_writeb(dev, reg, M48T86_B);
148 149 150 151 152 153 154 155

	return 0;
}

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

156
	reg = m48t86_readb(dev, M48T86_B);
157 158

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

161
	reg = m48t86_readb(dev, M48T86_D);
162 163

	seq_printf(seq, "battery\t\t: %s\n",
164
		   (reg & M48T86_D_VRT) ? "ok" : "exhausted");
165 166 167 168

	return 0;
}

169
static const struct rtc_class_ops m48t86_rtc_ops = {
170 171 172 173 174
	.read_time	= m48t86_rtc_read_time,
	.set_time	= m48t86_rtc_set_time,
	.proc		= m48t86_rtc_proc,
};

175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203
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);

204
static int m48t86_rtc_probe(struct platform_device *pdev)
205
{
206
	struct m48t86_rtc_info *info;
207
	unsigned char reg;
208

209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230
	info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
	if (!info)
		return -ENOMEM;

	info->ops = dev_get_platdata(&pdev->dev);
	if (!info->ops) {
		struct resource *res;

		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);
	}
231

232
	dev_set_drvdata(&pdev->dev, info);
233

234 235 236 237
	info->rtc = devm_rtc_device_register(&pdev->dev, "m48t86",
					     &m48t86_rtc_ops, THIS_MODULE);
	if (IS_ERR(info->rtc))
		return PTR_ERR(info->rtc);
238 239

	/* read battery status */
240 241
	reg = m48t86_readb(&pdev->dev, M48T86_D);
	dev_info(&pdev->dev, "battery %s\n",
242
		 (reg & M48T86_D_VRT) ? "ok" : "exhausted");
243

244 245 246 247 248 249 250 251 252
	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);
253 254 255 256 257 258 259 260
	return 0;
}

static struct platform_driver m48t86_rtc_platform_driver = {
	.driver		= {
		.name	= "rtc-m48t86",
	},
	.probe		= m48t86_rtc_probe,
261
	.remove		= m48t86_rtc_remove,
262 263
};

264
module_platform_driver(m48t86_rtc_platform_driver);
265 266 267 268

MODULE_AUTHOR("Alessandro Zummo <[email protected]>");
MODULE_DESCRIPTION("M48T86 RTC driver");
MODULE_LICENSE("GPL");
269
MODULE_ALIAS("platform:rtc-m48t86");