[SCSI] bxn2i: Added support for other TMFs besides ABORT_TASK
[linux-2.6.git] / 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 #include <linux/slab.h>
23
24 #define DS1390_REG_100THS               0x00
25 #define DS1390_REG_SECONDS              0x01
26 #define DS1390_REG_MINUTES              0x02
27 #define DS1390_REG_HOURS                0x03
28 #define DS1390_REG_DAY                  0x04
29 #define DS1390_REG_DATE                 0x05
30 #define DS1390_REG_MONTH_CENT           0x06
31 #define DS1390_REG_YEAR                 0x07
32
33 #define DS1390_REG_ALARM_100THS         0x08
34 #define DS1390_REG_ALARM_SECONDS        0x09
35 #define DS1390_REG_ALARM_MINUTES        0x0A
36 #define DS1390_REG_ALARM_HOURS          0x0B
37 #define DS1390_REG_ALARM_DAY_DATE       0x0C
38
39 #define DS1390_REG_CONTROL              0x0D
40 #define DS1390_REG_STATUS               0x0E
41 #define DS1390_REG_TRICKLE              0x0F
42
43 struct ds1390 {
44         struct rtc_device *rtc;
45         u8 txrx_buf[9]; /* cmd + 8 registers */
46 };
47
48 static int ds1390_get_reg(struct device *dev, unsigned char address,
49                                 unsigned char *data)
50 {
51         struct spi_device *spi = to_spi_device(dev);
52         struct ds1390 *chip = dev_get_drvdata(dev);
53         int status;
54
55         if (!data)
56                 return -EINVAL;
57
58         /* Clear MSB to indicate read */
59         chip->txrx_buf[0] = address & 0x7f;
60         /* do the i/o */
61         status = spi_write_then_read(spi, chip->txrx_buf, 1, chip->txrx_buf, 1);
62         if (status != 0)
63                 return status;
64
65         *data = chip->txrx_buf[1];
66
67         return 0;
68 }
69
70 static int ds1390_read_time(struct device *dev, struct rtc_time *dt)
71 {
72         struct spi_device *spi = to_spi_device(dev);
73         struct ds1390 *chip = dev_get_drvdata(dev);
74         int status;
75
76         /* build the message */
77         chip->txrx_buf[0] = DS1390_REG_SECONDS;
78
79         /* do the i/o */
80         status = spi_write_then_read(spi, chip->txrx_buf, 1, chip->txrx_buf, 8);
81         if (status != 0)
82                 return status;
83
84         /* The chip sends data in this order:
85          * Seconds, Minutes, Hours, Day, Date, Month / Century, Year */
86         dt->tm_sec      = bcd2bin(chip->txrx_buf[0]);
87         dt->tm_min      = bcd2bin(chip->txrx_buf[1]);
88         dt->tm_hour     = bcd2bin(chip->txrx_buf[2]);
89         dt->tm_wday     = bcd2bin(chip->txrx_buf[3]);
90         dt->tm_mday     = bcd2bin(chip->txrx_buf[4]);
91         /* mask off century bit */
92         dt->tm_mon      = bcd2bin(chip->txrx_buf[5] & 0x7f) - 1;
93         /* adjust for century bit */
94         dt->tm_year = bcd2bin(chip->txrx_buf[6]) + ((chip->txrx_buf[5] & 0x80) ? 100 : 0);
95
96         return rtc_valid_tm(dt);
97 }
98
99 static int ds1390_set_time(struct device *dev, struct rtc_time *dt)
100 {
101         struct spi_device *spi = to_spi_device(dev);
102         struct ds1390 *chip = dev_get_drvdata(dev);
103
104         /* build the message */
105         chip->txrx_buf[0] = DS1390_REG_SECONDS | 0x80;
106         chip->txrx_buf[1] = bin2bcd(dt->tm_sec);
107         chip->txrx_buf[2] = bin2bcd(dt->tm_min);
108         chip->txrx_buf[3] = bin2bcd(dt->tm_hour);
109         chip->txrx_buf[4] = bin2bcd(dt->tm_wday);
110         chip->txrx_buf[5] = bin2bcd(dt->tm_mday);
111         chip->txrx_buf[6] = bin2bcd(dt->tm_mon + 1) |
112                                 ((dt->tm_year > 99) ? 0x80 : 0x00);
113         chip->txrx_buf[7] = bin2bcd(dt->tm_year % 100);
114
115         /* do the i/o */
116         return spi_write_then_read(spi, chip->txrx_buf, 8, NULL, 0);
117 }
118
119 static const struct rtc_class_ops ds1390_rtc_ops = {
120         .read_time      = ds1390_read_time,
121         .set_time       = ds1390_set_time,
122 };
123
124 static int __devinit ds1390_probe(struct spi_device *spi)
125 {
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");
193 MODULE_ALIAS("spi:rtc-ds1390");