release/src-rt-6.x/linux/linux-2.6/drivers/rtc/rtc-max6900.c

   1 /*
   2  * rtc class driver for the Maxim MAX6900 chip
   3  *
   4  * Author: Dale Farnsworth <dale@farnsworth.org>
   5  *
   6  * based on previously existing rtc class drivers
   7  *
   8  * 2007 (c) MontaVista, Software, Inc.  This file is licensed under
   9  * the terms of the GNU General Public License version 2.  This program
  10  * is licensed "as is" without any warranty of any kind, whether express
  11  * or implied.
  12  */
  13
  14 #include <linux/module.h>
  15 #include <linux/i2c.h>
  16 #include <linux/bcd.h>
  17 #include <linux/rtc.h>
  18 #include <linux/delay.h>
  19
  20 #define DRV_NAME "max6900"
  21 #define DRV_VERSION "0.1"
  22
  23 /*
  24  * register indices
  25  */
  26 #define MAX6900_REG_SC                  0       /* seconds      00-59 */
  27 #define MAX6900_REG_MN                  1       /* minutes      00-59 */
  28 #define MAX6900_REG_HR                  2       /* hours        00-23 */
  29 #define MAX6900_REG_DT                  3       /* day of month 00-31 */
  30 #define MAX6900_REG_MO                  4       /* month        01-12 */
  31 #define MAX6900_REG_DW                  5       /* day of week   1-7  */
  32 #define MAX6900_REG_YR                  6       /* year         00-99 */
  33 #define MAX6900_REG_CT                  7       /* control */
  34 #define MAX6900_REG_LEN                 8
  35
  36 #define MAX6900_REG_CT_WP               (1 << 7)        /* Write Protect */
  37
  38 /*
  39  * register read/write commands
  40  */
  41 #define MAX6900_REG_CONTROL_WRITE       0x8e
  42 #define MAX6900_REG_BURST_READ          0xbf
  43 #define MAX6900_REG_BURST_WRITE         0xbe
  44 #define MAX6900_REG_RESERVED_READ       0x96
  45
  46 #define MAX6900_IDLE_TIME_AFTER_WRITE   3       /* specification says 2.5 mS */
  47
  48 #define MAX6900_I2C_ADDR                0xa0
  49
  50 static unsigned short normal_i2c[] = {
  51         MAX6900_I2C_ADDR >> 1,
  52         I2C_CLIENT_END
  53 };
  54
  55 I2C_CLIENT_INSMOD;                      /* defines addr_data */
  56
  57 static int max6900_probe(struct i2c_adapter *adapter, int addr, int kind);
  58
  59 static int max6900_i2c_read_regs(struct i2c_client *client, u8 *buf)
  60 {
  61         u8 reg_addr[1] = { MAX6900_REG_BURST_READ };
  62         struct i2c_msg msgs[2] = {
  63                 {
  64                         .addr   = client->addr,
  65                         .flags  = 0, /* write */
  66                         .len    = sizeof(reg_addr),
  67                         .buf    = reg_addr
  68                 },
  69                 {
  70                         .addr   = client->addr,
  71                         .flags  = I2C_M_RD,
  72                         .len    = MAX6900_REG_LEN,
  73                         .buf    = buf
  74                 }
  75         };
  76         int rc;
  77
  78         rc = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
  79         if (rc != ARRAY_SIZE(msgs)) {
  80                 dev_err(&client->dev, "%s: register read failed\n",
  81                         __FUNCTION__);
  82                 return -EIO;
  83         }
  84         return 0;
  85 }
  86
  87 static int max6900_i2c_write_regs(struct i2c_client *client, u8 const *buf)
  88 {
  89         u8 i2c_buf[MAX6900_REG_LEN + 1] = { MAX6900_REG_BURST_WRITE };
  90         struct i2c_msg msgs[1] = {
  91                 {
  92                         .addr   = client->addr,
  93                         .flags  = 0, /* write */
  94                         .len    = MAX6900_REG_LEN + 1,
  95                         .buf    = i2c_buf
  96                 }
  97         };
  98         int rc;
  99
 100         memcpy(&i2c_buf[1], buf, MAX6900_REG_LEN);
 101
 102         rc = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
 103         if (rc != ARRAY_SIZE(msgs)) {
 104                 dev_err(&client->dev, "%s: register write failed\n",
 105                         __FUNCTION__);
 106                 return -EIO;
 107         }
 108         msleep(MAX6900_IDLE_TIME_AFTER_WRITE);
 109         return 0;
 110 }
 111
 112 static int max6900_i2c_validate_client(struct i2c_client *client)
 113 {
 114         u8 regs[MAX6900_REG_LEN];
 115         u8 zero_mask[MAX6900_REG_LEN] = {
 116                 0x80,   /* seconds */
 117                 0x80,   /* minutes */
 118                 0x40,   /* hours */
 119                 0xc0,   /* day of month */
 120                 0xe0,   /* month */
 121                 0xf8,   /* day of week */
 122                 0x00,   /* year */
 123                 0x7f,   /* control */
 124         };
 125         int i;
 126         int rc;
 127         int reserved;
 128
 129         reserved = i2c_smbus_read_byte_data(client, MAX6900_REG_RESERVED_READ);
 130         if (reserved != 0x07)
 131                 return -ENODEV;
 132
 133         rc = max6900_i2c_read_regs(client, regs);
 134         if (rc < 0)
 135                 return rc;
 136
 137         for (i = 0; i < MAX6900_REG_LEN; ++i) {
 138                 if (regs[i] & zero_mask[i])
 139                         return -ENODEV;
 140         }
 141
 142         return 0;
 143 }
 144
 145 static int max6900_i2c_read_time(struct i2c_client *client, struct rtc_time *tm)
 146 {
 147         int rc;
 148         u8 regs[MAX6900_REG_LEN];
 149
 150         rc = max6900_i2c_read_regs(client, regs);
 151         if (rc < 0)
 152                 return rc;
 153
 154         tm->tm_sec = BCD2BIN(regs[MAX6900_REG_SC]);
 155         tm->tm_min = BCD2BIN(regs[MAX6900_REG_MN]);
 156         tm->tm_hour = BCD2BIN(regs[MAX6900_REG_HR] & 0x3f);
 157         tm->tm_mday = BCD2BIN(regs[MAX6900_REG_DT]);
 158         tm->tm_mon = BCD2BIN(regs[MAX6900_REG_MO]) - 1;
 159         tm->tm_year = BCD2BIN(regs[MAX6900_REG_YR]) + 100;
 160         tm->tm_wday = BCD2BIN(regs[MAX6900_REG_DW]);
 161
 162         return 0;
 163 }
 164
 165 static int max6900_i2c_clear_write_protect(struct i2c_client *client)
 166 {
 167         int rc;
 168         rc = i2c_smbus_write_byte_data (client, MAX6900_REG_CONTROL_WRITE, 0);
 169         if (rc < 0) {
 170                 dev_err(&client->dev, "%s: control register write failed\n",
 171                         __FUNCTION__);
 172                 return -EIO;
 173         }
 174         return 0;
 175 }
 176
 177 static int max6900_i2c_set_time(struct i2c_client *client,
 178                                 struct rtc_time const *tm)
 179 {
 180         u8 regs[MAX6900_REG_LEN];
 181         int rc;
 182
 183         rc = max6900_i2c_clear_write_protect(client);
 184         if (rc < 0)
 185                 return rc;
 186
 187         regs[MAX6900_REG_SC] = BIN2BCD(tm->tm_sec);
 188         regs[MAX6900_REG_MN] = BIN2BCD(tm->tm_min);
 189         regs[MAX6900_REG_HR] = BIN2BCD(tm->tm_hour);
 190         regs[MAX6900_REG_DT] = BIN2BCD(tm->tm_mday);
 191         regs[MAX6900_REG_MO] = BIN2BCD(tm->tm_mon + 1);
 192         regs[MAX6900_REG_YR] = BIN2BCD(tm->tm_year - 100);
 193         regs[MAX6900_REG_DW] = BIN2BCD(tm->tm_wday);
 194         regs[MAX6900_REG_CT] = MAX6900_REG_CT_WP;       /* set write protect */
 195
 196         rc = max6900_i2c_write_regs(client, regs);
 197         if (rc < 0)
 198                 return rc;
 199
 200         return 0;
 201 }
 202
 203 static int max6900_rtc_read_time(struct device *dev, struct rtc_time *tm)
 204 {
 205         return max6900_i2c_read_time(to_i2c_client(dev), tm);
 206 }
 207
 208 static int max6900_rtc_set_time(struct device *dev, struct rtc_time *tm)
 209 {
 210         return max6900_i2c_set_time(to_i2c_client(dev), tm);
 211 }
 212
 213 static int max6900_attach_adapter(struct i2c_adapter *adapter)
 214 {
 215         return i2c_probe(adapter, &addr_data, max6900_probe);
 216 }
 217
 218 static int max6900_detach_client(struct i2c_client *client)
 219 {
 220         struct rtc_device *const rtc = i2c_get_clientdata(client);
 221
 222         if (rtc)
 223                 rtc_device_unregister(rtc);
 224
 225         return i2c_detach_client(client);
 226 }
 227
 228 static struct i2c_driver max6900_driver = {
 229         .driver         = {
 230                 .name   = DRV_NAME,
 231         },
 232         .id             = I2C_DRIVERID_MAX6900,
 233         .attach_adapter = max6900_attach_adapter,
 234         .detach_client  = max6900_detach_client,
 235 };
 236
 237 static const struct rtc_class_ops max6900_rtc_ops = {
 238         .read_time      = max6900_rtc_read_time,
 239         .set_time       = max6900_rtc_set_time,
 240 };
 241
 242 static int max6900_probe(struct i2c_adapter *adapter, int addr, int kind)
 243 {
 244         int rc = 0;
 245         struct i2c_client *client = NULL;
 246         struct rtc_device *rtc = NULL;
 247
 248         if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
 249                 rc = -ENODEV;
 250                 goto failout;
 251         }
 252
 253         client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
 254         if (client == NULL) {
 255                 rc = -ENOMEM;
 256                 goto failout;
 257         }
 258
 259         client->addr = addr;
 260         client->adapter = adapter;
 261         client->driver = &max6900_driver;
 262         strlcpy(client->name, DRV_NAME, I2C_NAME_SIZE);
 263
 264         if (kind < 0) {
 265                 rc = max6900_i2c_validate_client(client);
 266                 if (rc < 0)
 267                         goto failout;
 268         }
 269
 270         rc = i2c_attach_client(client);
 271         if (rc < 0)
 272                 goto failout;
 273
 274         dev_info(&client->dev,
 275                  "chip found, driver version " DRV_VERSION "\n");
 276
 277         rtc = rtc_device_register(max6900_driver.driver.name,
 278                                   &client->dev,
 279                                   &max6900_rtc_ops, THIS_MODULE);
 280         if (IS_ERR(rtc)) {
 281                 rc = PTR_ERR(rtc);
 282                 goto failout_detach;
 283         }
 284
 285         i2c_set_clientdata(client, rtc);
 286
 287         return 0;
 288
 289 failout_detach:
 290         i2c_detach_client(client);
 291 failout:
 292         kfree(client);
 293         return rc;
 294 }
 295
 296 static int __init max6900_init(void)
 297 {
 298         return i2c_add_driver(&max6900_driver);
 299 }
 300
 301 static void __exit max6900_exit(void)
 302 {
 303         i2c_del_driver(&max6900_driver);
 304 }
 305
 306 MODULE_DESCRIPTION("Maxim MAX6900 RTC driver");
 307 MODULE_LICENSE("GPL");
 308 MODULE_VERSION(DRV_VERSION);
 309
 310 module_init(max6900_init);
 311 module_exit(max6900_exit);