Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland...
[linux-2.6] / drivers / rtc / rtc-ds1390.c
1 /*
2  * rtc-ds1390.c -- driver for the Dallas/Maxim DS1390/93/94 SPI RTC
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/init.h>
17 #include <linux/module.h>
18 #include <linux/platform_device.h>
19 #include <linux/rtc.h>
20 #include <linux/spi/spi.h>
21 #include <linux/bcd.h>
22
23 #define DS1390_REG_100THS               0x00
24 #define DS1390_REG_SECONDS              0x01
25 #define DS1390_REG_MINUTES              0x02
26 #define DS1390_REG_HOURS                0x03
27 #define DS1390_REG_DAY                  0x04
28 #define DS1390_REG_DATE                 0x05
29 #define DS1390_REG_MONTH_CENT           0x06
30 #define DS1390_REG_YEAR                 0x07
31
32 #define DS1390_REG_ALARM_100THS         0x08
33 #define DS1390_REG_ALARM_SECONDS        0x09
34 #define DS1390_REG_ALARM_MINUTES        0x0A
35 #define DS1390_REG_ALARM_HOURS          0x0B
36 #define DS1390_REG_ALARM_DAY_DATE       0x0C
37
38 #define DS1390_REG_CONTROL              0x0D
39 #define DS1390_REG_STATUS               0x0E
40 #define DS1390_REG_TRICKLE              0x0F
41
42 struct ds1390 {
43         struct rtc_device *rtc;
44         u8 txrx_buf[9]; /* cmd + 8 registers */
45 };
46
47 static int ds1390_get_reg(struct device *dev, unsigned char address,
48                                 unsigned char *data)
49 {
50         struct spi_device *spi = to_spi_device(dev);
51         struct ds1390 *chip = dev_get_drvdata(dev);
52         int status;
53
54         if (!data)
55                 return -EINVAL;
56
57         /* Clear MSB to indicate read */
58         chip->txrx_buf[0] = address & 0x7f;
59         /* do the i/o */
60         status = spi_write_then_read(spi, chip->txrx_buf, 1, chip->txrx_buf, 1);
61         if (status != 0)
62                 return status;
63
64         *data = chip->txrx_buf[1];
65
66         return 0;
67 }
68
69 static int ds1390_read_time(struct device *dev, struct rtc_time *dt)
70 {
71         struct spi_device *spi = to_spi_device(dev);
72         struct ds1390 *chip = dev_get_drvdata(dev);
73         int status;
74
75         /* build the message */
76         chip->txrx_buf[0] = DS1390_REG_SECONDS;
77
78         /* do the i/o */
79         status = spi_write_then_read(spi, chip->txrx_buf, 1, chip->txrx_buf, 8);
80         if (status != 0)
81                 return status;
82
83         /* The chip sends data in this order:
84          * Seconds, Minutes, Hours, Day, Date, Month / Century, Year */
85         dt->tm_sec      = bcd2bin(chip->txrx_buf[0]);
86         dt->tm_min      = bcd2bin(chip->txrx_buf[1]);
87         dt->tm_hour     = bcd2bin(chip->txrx_buf[2]);
88         dt->tm_wday     = bcd2bin(chip->txrx_buf[3]);
89         dt->tm_mday     = bcd2bin(chip->txrx_buf[4]);
90         /* mask off century bit */
91         dt->tm_mon      = bcd2bin(chip->txrx_buf[5] & 0x7f) - 1;
92         /* adjust for century bit */
93         dt->tm_year = bcd2bin(chip->txrx_buf[6]) + ((chip->txrx_buf[5] & 0x80) ? 100 : 0);
94
95         return rtc_valid_tm(dt);
96 }
97
98 static int ds1390_set_time(struct device *dev, struct rtc_time *dt)
99 {
100         struct spi_device *spi = to_spi_device(dev);
101         struct ds1390 *chip = dev_get_drvdata(dev);
102
103         /* build the message */
104         chip->txrx_buf[0] = DS1390_REG_SECONDS | 0x80;
105         chip->txrx_buf[1] = bin2bcd(dt->tm_sec);
106         chip->txrx_buf[2] = bin2bcd(dt->tm_min);
107         chip->txrx_buf[3] = bin2bcd(dt->tm_hour);
108         chip->txrx_buf[4] = bin2bcd(dt->tm_wday);
109         chip->txrx_buf[5] = bin2bcd(dt->tm_mday);
110         chip->txrx_buf[6] = bin2bcd(dt->tm_mon + 1) |
111                                 ((dt->tm_year > 99) ? 0x80 : 0x00);
112         chip->txrx_buf[7] = bin2bcd(dt->tm_year % 100);
113
114         /* do the i/o */
115         return spi_write_then_read(spi, chip->txrx_buf, 8, NULL, 0);
116 }
117
118 static const struct rtc_class_ops ds1390_rtc_ops = {
119         .read_time      = ds1390_read_time,
120         .set_time       = ds1390_set_time,
121 };
122
123 static int __devinit ds1390_probe(struct spi_device *spi)
124 {
125         struct rtc_device *rtc;
126         unsigned char tmp;
127         struct ds1390 *chip;
128         int res;
129
130         spi->mode = SPI_MODE_3;
131         spi->bits_per_word = 8;
132         spi_setup(spi);
133
134         chip = kzalloc(sizeof *chip, GFP_KERNEL);
135         if (!chip) {
136                 dev_err(&spi->dev, "unable to allocate device memory\n");
137                 return -ENOMEM;
138         }
139         dev_set_drvdata(&spi->dev, chip);
140
141         res = ds1390_get_reg(&spi->dev, DS1390_REG_SECONDS, &tmp);
142         if (res != 0) {
143                 dev_err(&spi->dev, "unable to read device\n");
144                 kfree(chip);
145                 return res;
146         }
147
148         chip->rtc = rtc_device_register("ds1390",
149                                 &spi->dev, &ds1390_rtc_ops, THIS_MODULE);
150         if (IS_ERR(chip->rtc)) {
151                 dev_err(&spi->dev, "unable to register device\n");
152                 res = PTR_ERR(chip->rtc);
153                 kfree(chip);
154         }
155
156         return res;
157 }
158
159 static int __devexit ds1390_remove(struct spi_device *spi)
160 {
161         struct ds1390 *chip = platform_get_drvdata(spi);
162
163         rtc_device_unregister(chip->rtc);
164         kfree(chip);
165
166         return 0;
167 }
168
169 static struct spi_driver ds1390_driver = {
170         .driver = {
171                 .name   = "rtc-ds1390",
172                 .owner  = THIS_MODULE,
173         },
174         .probe  = ds1390_probe,
175         .remove = __devexit_p(ds1390_remove),
176 };
177
178 static __init int ds1390_init(void)
179 {
180         return spi_register_driver(&ds1390_driver);
181 }
182 module_init(ds1390_init);
183
184 static __exit void ds1390_exit(void)
185 {
186         spi_unregister_driver(&ds1390_driver);
187 }
188 module_exit(ds1390_exit);
189
190 MODULE_DESCRIPTION("Dallas/Maxim DS1390/93/94 SPI RTC driver");
191 MODULE_AUTHOR("Mark Jackson <mpfj@mimc.co.uk>");
192 MODULE_LICENSE("GPL");