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");