599e976bf01488595e6213ebebb3d35f5f0f6661
[linux-2.6.git] / drivers / rtc / rtc-ds1390.c
1 /*
2  * rtc-ds1390.c -- driver for DS1390/93/94
3  *
4  * Copyright (C) 2008 Mercury IMC Ltd
5  * Written by Mark Jackson <mpfj@mimc.co.uk>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  *
11  * NOTE : Currently this driver only supports the bare minimum for read
12  * and write the RTC.  The extra features provided by the chip family
13  * (alarms, trickle charger, different control registers) are unavailable.
14  */
15
16 #include <linux/platform_device.h>
17 #include <linux/rtc.h>
18 #include <linux/spi/spi.h>
19 #include <linux/bcd.h>
20
21 #define DS1390_REG_100THS               0x00
22 #define DS1390_REG_SECONDS              0x01
23 #define DS1390_REG_MINUTES              0x02
24 #define DS1390_REG_HOURS                0x03
25 #define DS1390_REG_DAY                  0x04
26 #define DS1390_REG_DATE                 0x05
27 #define DS1390_REG_MONTH_CENT           0x06
28 #define DS1390_REG_YEAR                 0x07
29
30 #define DS1390_REG_ALARM_100THS         0x08
31 #define DS1390_REG_ALARM_SECONDS        0x09
32 #define DS1390_REG_ALARM_MINUTES        0x0A
33 #define DS1390_REG_ALARM_HOURS          0x0B
34 #define DS1390_REG_ALARM_DAY_DATE       0x0C
35
36 #define DS1390_REG_CONTROL              0x0D
37 #define DS1390_REG_STATUS               0x0E
38 #define DS1390_REG_TRICKLE              0x0F
39
40 struct ds1390 {
41         struct rtc_device *rtc;
42         u8 txrx_buf[9]; /* cmd + 8 registers */
43 };
44
45 static void ds1390_set_reg(struct device *dev, unsigned char address,
46                                 unsigned char data)
47 {
48         struct spi_device *spi = to_spi_device(dev);
49         struct ds1390 *chip = dev_get_drvdata(dev);
50
51         /* Set MSB to indicate write */
52         chip->txrx_buf[0] = address | 0x80;
53         chip->txrx_buf[1] = data;
54
55         /* do the i/o */
56         spi_write_then_read(spi, chip->txrx_buf, 2, NULL, 0);
57 }
58
59 static int ds1390_get_reg(struct device *dev, unsigned char address,
60                                 unsigned char *data)
61 {
62         struct spi_device *spi = to_spi_device(dev);
63         struct ds1390 *chip = dev_get_drvdata(dev);
64         int status;
65
66         if (!data)
67                 return -EINVAL;
68
69         /* Clear MSB to indicate read */
70         chip->txrx_buf[0] = address & 0x7f;
71         /* do the i/o */
72         status = spi_write_then_read(spi, chip->txrx_buf, 1, chip->txrx_buf, 1);
73         if (status != 0)
74                 return status;
75
76         *data = chip->txrx_buf[1];
77
78         return 0;
79 }
80
81 static int ds1390_get_datetime(struct device *dev, struct rtc_time *dt)
82 {
83         struct spi_device *spi = to_spi_device(dev);
84         struct ds1390 *chip = dev_get_drvdata(dev);
85         int status;
86
87         /* build the message */
88         chip->txrx_buf[0] = DS1390_REG_SECONDS;
89
90         /* do the i/o */
91         status = spi_write_then_read(spi, chip->txrx_buf, 1, chip->txrx_buf, 8);
92         if (status != 0)
93                 return status;
94
95         /* The chip sends data in this order:
96          * Seconds, Minutes, Hours, Day, Date, Month / Century, Year */
97         dt->tm_sec      = bcd2bin(chip->txrx_buf[0]);
98         dt->tm_min      = bcd2bin(chip->txrx_buf[1]);
99         dt->tm_hour     = bcd2bin(chip->txrx_buf[2]);
100         dt->tm_wday     = bcd2bin(chip->txrx_buf[3]);
101         dt->tm_mday     = bcd2bin(chip->txrx_buf[4]);
102         /* mask off century bit */
103         dt->tm_mon      = bcd2bin(chip->txrx_buf[5] & 0x7f) - 1;
104         /* adjust for century bit */
105         dt->tm_year = bcd2bin(chip->txrx_buf[6]) + ((chip->txrx_buf[5] & 0x80) ? 100 : 0);
106
107         return rtc_valid_tm(dt);
108 }
109
110 static int ds1390_set_datetime(struct device *dev, struct rtc_time *dt)
111 {
112         struct spi_device *spi = to_spi_device(dev);
113         struct ds1390 *chip = dev_get_drvdata(dev);
114
115         /* build the message */
116         chip->txrx_buf[0] = DS1390_REG_SECONDS | 0x80;
117         chip->txrx_buf[1] = bin2bcd(dt->tm_sec);
118         chip->txrx_buf[2] = bin2bcd(dt->tm_min);
119         chip->txrx_buf[3] = bin2bcd(dt->tm_hour);
120         chip->txrx_buf[4] = bin2bcd(dt->tm_wday);
121         chip->txrx_buf[5] = bin2bcd(dt->tm_mday);
122         chip->txrx_buf[6] = bin2bcd(dt->tm_mon + 1) |
123                                 ((dt->tm_year > 99) ? 0x80 : 0x00);
124         chip->txrx_buf[7] = bin2bcd(dt->tm_year % 100);
125
126         /* do the i/o */
127         return spi_write_then_read(spi, chip->txrx_buf, 8, NULL, 0);
128 }
129
130 static int ds1390_read_time(struct device *dev, struct rtc_time *tm)
131 {
132         return ds1390_get_datetime(dev, tm);
133 }
134
135 static int ds1390_set_time(struct device *dev, struct rtc_time *tm)
136 {
137         return ds1390_set_datetime(dev, tm);
138 }
139
140 static const struct rtc_class_ops ds1390_rtc_ops = {
141         .read_time      = ds1390_read_time,
142         .set_time       = ds1390_set_time,
143 };
144
145 static int __devinit ds1390_probe(struct spi_device *spi)
146 {
147         struct rtc_device *rtc;
148         unsigned char tmp;
149         struct ds1390 *chip;
150         int res;
151
152         printk(KERN_DEBUG "DS1390 SPI RTC driver\n");
153
154         rtc = rtc_device_register("ds1390",
155                                 &spi->dev, &ds1390_rtc_ops, THIS_MODULE);
156         if (IS_ERR(rtc)) {
157                 printk(KERN_ALERT "RTC : unable to register device\n");
158                 return PTR_ERR(rtc);
159         }
160
161         spi->mode = SPI_MODE_3;
162         spi->bits_per_word = 8;
163         spi_setup(spi);
164
165         chip = kzalloc(sizeof *chip, GFP_KERNEL);
166         if (!chip) {
167                 printk(KERN_ALERT "RTC : unable to allocate device memory\n");
168                 rtc_device_unregister(rtc);
169                 return -ENOMEM;
170         }
171         chip->rtc = rtc;
172         dev_set_drvdata(&spi->dev, chip);
173
174         res = ds1390_get_reg(&spi->dev, DS1390_REG_SECONDS, &tmp);
175         if (res) {
176                 printk(KERN_ALERT "RTC : unable to read device\n");
177                 rtc_device_unregister(rtc);
178                 return res;
179         }
180
181         return 0;
182 }
183
184 static int __devexit ds1390_remove(struct spi_device *spi)
185 {
186         struct ds1390 *chip = platform_get_drvdata(spi);
187         struct rtc_device *rtc = chip->rtc;
188
189         if (rtc)
190                 rtc_device_unregister(rtc);
191
192         kfree(chip);
193
194         return 0;
195 }
196
197 static struct spi_driver ds1390_driver = {
198         .driver = {
199                 .name   = "rtc-ds1390",
200                 .owner  = THIS_MODULE,
201         },
202         .probe  = ds1390_probe,
203         .remove = __devexit_p(ds1390_remove),
204 };
205
206 static __init int ds1390_init(void)
207 {
208         return spi_register_driver(&ds1390_driver);
209 }
210 module_init(ds1390_init);
211
212 static __exit void ds1390_exit(void)
213 {
214         spi_unregister_driver(&ds1390_driver);
215 }
216 module_exit(ds1390_exit);
217
218 MODULE_DESCRIPTION("DS1390/93/94 SPI RTC driver");
219 MODULE_AUTHOR("Mark Jackson <mpfj@mimc.co.uk>");
220 MODULE_LICENSE("GPL");