1/* 2 * linux/drivers/i2c/chips/ds1337.c 3 * 4 * Copyright (C) 2005 James Chapman <jchapman@katalix.com> 5 * 6 * based on linux/drivers/acorn/char/pcf8583.c 7 * Copyright (C) 2000 Russell King 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License version 2 as 11 * published by the Free Software Foundation. 12 * 13 * Driver for Dallas Semiconductor DS1337 and DS1339 real time clock chip 14 */ 15 16#include <linux/module.h> 17#include <linux/init.h> 18#include <linux/slab.h> 19#include <linux/i2c.h> 20#include <linux/string.h> 21#include <linux/rtc.h> /* get the user-level API */ 22#include <linux/bcd.h> 23#include <linux/list.h> 24 25/* Device registers */ 26#define DS1337_REG_HOUR 2 27#define DS1337_REG_DAY 3 28#define DS1337_REG_DATE 4 29#define DS1337_REG_MONTH 5 30#define DS1337_REG_CONTROL 14 31#define DS1337_REG_STATUS 15 32 33#define DS1337_GET_DATE 0 34#define DS1337_SET_DATE 1 35 36/* 37 * Functions declaration 38 */ 39static unsigned short normal_i2c[] = { 0x68, I2C_CLIENT_END }; 40 41I2C_CLIENT_INSMOD_1(ds1337); 42 43static int ds1337_attach_adapter(struct i2c_adapter *adapter); 44static int ds1337_detect(struct i2c_adapter *adapter, int address, int kind); 45static void ds1337_init_client(struct i2c_client *client); 46static int ds1337_detach_client(struct i2c_client *client); 47static int ds1337_command(struct i2c_client *client, unsigned int cmd, 48 void *arg); 49 50/* 51 * Driver data (common to all clients) 52 */ 53static struct i2c_driver ds1337_driver = { 54 .driver = { 55 .name = "ds1337", 56 }, 57 .attach_adapter = ds1337_attach_adapter, 58 .detach_client = ds1337_detach_client, 59 .command = ds1337_command, 60}; 61 62/* 63 * Client data (each client gets its own) 64 */ 65struct ds1337_data { 66 struct i2c_client client; 67 struct list_head list; 68}; 69 70/* 71 * Internal variables 72 */ 73static LIST_HEAD(ds1337_clients); 74 75static inline int ds1337_read(struct i2c_client *client, u8 reg, u8 *value) 76{ 77 s32 tmp = i2c_smbus_read_byte_data(client, reg); 78 79 if (tmp < 0) 80 return -EIO; 81 82 *value = tmp; 83 84 return 0; 85} 86 87/* 88 * Chip access functions 89 */ 90static int ds1337_get_datetime(struct i2c_client *client, struct rtc_time *dt) 91{ 92 int result; 93 u8 buf[7]; 94 u8 val; 95 struct i2c_msg msg[2]; 96 u8 offs = 0; 97 98 if (!dt) { 99 dev_dbg(&client->dev, "%s: EINVAL: dt=NULL\n", __FUNCTION__); 100 return -EINVAL; 101 } 102 103 msg[0].addr = client->addr; 104 msg[0].flags = 0; 105 msg[0].len = 1; 106 msg[0].buf = &offs; 107 108 msg[1].addr = client->addr; 109 msg[1].flags = I2C_M_RD; 110 msg[1].len = sizeof(buf); 111 msg[1].buf = &buf[0]; 112 113 result = i2c_transfer(client->adapter, msg, 2); 114 115 dev_dbg(&client->dev, "%s: [%d] %02x %02x %02x %02x %02x %02x %02x\n", 116 __FUNCTION__, result, buf[0], buf[1], buf[2], buf[3], 117 buf[4], buf[5], buf[6]); 118 119 if (result == 2) { 120 dt->tm_sec = BCD2BIN(buf[0]); 121 dt->tm_min = BCD2BIN(buf[1]); 122 val = buf[2] & 0x3f; 123 dt->tm_hour = BCD2BIN(val); 124 dt->tm_wday = BCD2BIN(buf[3]) - 1; 125 dt->tm_mday = BCD2BIN(buf[4]); 126 val = buf[5] & 0x7f; 127 dt->tm_mon = BCD2BIN(val) - 1; 128 dt->tm_year = BCD2BIN(buf[6]); 129 if (buf[5] & 0x80) 130 dt->tm_year += 100; 131 132 dev_dbg(&client->dev, "%s: secs=%d, mins=%d, " 133 "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n", 134 __FUNCTION__, dt->tm_sec, dt->tm_min, 135 dt->tm_hour, dt->tm_mday, 136 dt->tm_mon, dt->tm_year, dt->tm_wday); 137 138 return 0; 139 } 140 141 dev_err(&client->dev, "error reading data! %d\n", result); 142 return -EIO; 143} 144 145static int ds1337_set_datetime(struct i2c_client *client, struct rtc_time *dt) 146{ 147 int result; 148 u8 buf[8]; 149 u8 val; 150 struct i2c_msg msg[1]; 151 152 if (!dt) { 153 dev_dbg(&client->dev, "%s: EINVAL: dt=NULL\n", __FUNCTION__); 154 return -EINVAL; 155 } 156 157 dev_dbg(&client->dev, "%s: secs=%d, mins=%d, hours=%d, " 158 "mday=%d, mon=%d, year=%d, wday=%d\n", __FUNCTION__, 159 dt->tm_sec, dt->tm_min, dt->tm_hour, 160 dt->tm_mday, dt->tm_mon, dt->tm_year, dt->tm_wday); 161 162 buf[0] = 0; /* reg offset */ 163 buf[1] = BIN2BCD(dt->tm_sec); 164 buf[2] = BIN2BCD(dt->tm_min); 165 buf[3] = BIN2BCD(dt->tm_hour); 166 buf[4] = BIN2BCD(dt->tm_wday + 1); 167 buf[5] = BIN2BCD(dt->tm_mday); 168 buf[6] = BIN2BCD(dt->tm_mon + 1); 169 val = dt->tm_year; 170 if (val >= 100) { 171 val -= 100; 172 buf[6] |= (1 << 7); 173 } 174 buf[7] = BIN2BCD(val); 175 176 msg[0].addr = client->addr; 177 msg[0].flags = 0; 178 msg[0].len = sizeof(buf); 179 msg[0].buf = &buf[0]; 180 181 result = i2c_transfer(client->adapter, msg, 1); 182 if (result == 1) 183 return 0; 184 185 dev_err(&client->dev, "error writing data! %d\n", result); 186 return -EIO; 187} 188 189static int ds1337_command(struct i2c_client *client, unsigned int cmd, 190 void *arg) 191{ 192 dev_dbg(&client->dev, "%s: cmd=%d\n", __FUNCTION__, cmd); 193 194 switch (cmd) { 195 case DS1337_GET_DATE: 196 return ds1337_get_datetime(client, arg); 197 198 case DS1337_SET_DATE: 199 return ds1337_set_datetime(client, arg); 200 201 default: 202 return -EINVAL; 203 } 204} 205 206/* 207 * Public API for access to specific device. Useful for low-level 208 * RTC access from kernel code. 209 */ 210int ds1337_do_command(int bus, int cmd, void *arg) 211{ 212 struct list_head *walk; 213 struct list_head *tmp; 214 struct ds1337_data *data; 215 216 list_for_each_safe(walk, tmp, &ds1337_clients) { 217 data = list_entry(walk, struct ds1337_data, list); 218 if (data->client.adapter->nr == bus) 219 return ds1337_command(&data->client, cmd, arg); 220 } 221 222 return -ENODEV; 223} 224 225static int ds1337_attach_adapter(struct i2c_adapter *adapter) 226{ 227 return i2c_probe(adapter, &addr_data, ds1337_detect); 228} 229 230/* 231 * The following function does more than just detection. If detection 232 * succeeds, it also registers the new chip. 233 */ 234static int ds1337_detect(struct i2c_adapter *adapter, int address, int kind) 235{ 236 struct i2c_client *new_client; 237 struct ds1337_data *data; 238 int err = 0; 239 const char *name = ""; 240 241 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA | 242 I2C_FUNC_I2C)) 243 goto exit; 244 245 if (!(data = kzalloc(sizeof(struct ds1337_data), GFP_KERNEL))) { 246 err = -ENOMEM; 247 goto exit; 248 } 249 INIT_LIST_HEAD(&data->list); 250 251 /* The common I2C client data is placed right before the 252 * DS1337-specific data. 253 */ 254 new_client = &data->client; 255 i2c_set_clientdata(new_client, data); 256 new_client->addr = address; 257 new_client->adapter = adapter; 258 new_client->driver = &ds1337_driver; 259 new_client->flags = 0; 260 261 /* 262 * Now we do the remaining detection. A negative kind means that 263 * the driver was loaded with no force parameter (default), so we 264 * must both detect and identify the chip. A zero kind means that 265 * the driver was loaded with the force parameter, the detection 266 * step shall be skipped. A positive kind means that the driver 267 * was loaded with the force parameter and a given kind of chip is 268 * requested, so both the detection and the identification steps 269 * are skipped. 270 * 271 * For detection, we read registers that are most likely to cause 272 * detection failure, i.e. those that have more bits with fixed 273 * or reserved values. 274 */ 275 276 /* Default to an DS1337 if forced */ 277 if (kind == 0) 278 kind = ds1337; 279 280 if (kind < 0) { /* detection and identification */ 281 u8 data; 282 283 /* Check that status register bits 6-2 are zero */ 284 if ((ds1337_read(new_client, DS1337_REG_STATUS, &data) < 0) || 285 (data & 0x7c)) 286 goto exit_free; 287 288 /* Check for a valid day register value */ 289 if ((ds1337_read(new_client, DS1337_REG_DAY, &data) < 0) || 290 (data == 0) || (data & 0xf8)) 291 goto exit_free; 292 293 /* Check for a valid date register value */ 294 if ((ds1337_read(new_client, DS1337_REG_DATE, &data) < 0) || 295 (data == 0) || (data & 0xc0) || ((data & 0x0f) > 9) || 296 (data >= 0x32)) 297 goto exit_free; 298 299 /* Check for a valid month register value */ 300 if ((ds1337_read(new_client, DS1337_REG_MONTH, &data) < 0) || 301 (data == 0) || (data & 0x60) || ((data & 0x0f) > 9) || 302 ((data >= 0x13) && (data <= 0x19))) 303 goto exit_free; 304 305 /* Check that control register bits 6-5 are zero */ 306 if ((ds1337_read(new_client, DS1337_REG_CONTROL, &data) < 0) || 307 (data & 0x60)) 308 goto exit_free; 309 310 kind = ds1337; 311 } 312 313 if (kind == ds1337) 314 name = "ds1337"; 315 316 /* We can fill in the remaining client fields */ 317 strlcpy(new_client->name, name, I2C_NAME_SIZE); 318 319 /* Tell the I2C layer a new client has arrived */ 320 if ((err = i2c_attach_client(new_client))) 321 goto exit_free; 322 323 /* Initialize the DS1337 chip */ 324 ds1337_init_client(new_client); 325 326 /* Add client to local list */ 327 list_add(&data->list, &ds1337_clients); 328 329 return 0; 330 331exit_free: 332 kfree(data); 333exit: 334 return err; 335} 336 337static void ds1337_init_client(struct i2c_client *client) 338{ 339 u8 status, control; 340 341 /* On some boards, the RTC isn't configured by boot firmware. 342 * Handle that case by starting/configuring the RTC now. 343 */ 344 status = i2c_smbus_read_byte_data(client, DS1337_REG_STATUS); 345 control = i2c_smbus_read_byte_data(client, DS1337_REG_CONTROL); 346 347 if ((status & 0x80) || (control & 0x80)) { 348 /* RTC not running */ 349 u8 buf[1+16]; /* First byte is interpreted as address */ 350 struct i2c_msg msg[1]; 351 352 dev_dbg(&client->dev, "%s: RTC not running!\n", __FUNCTION__); 353 354 /* Initialize all, including STATUS and CONTROL to zero */ 355 memset(buf, 0, sizeof(buf)); 356 357 /* Write valid values in the date/time registers */ 358 buf[1+DS1337_REG_DAY] = 1; 359 buf[1+DS1337_REG_DATE] = 1; 360 buf[1+DS1337_REG_MONTH] = 1; 361 362 msg[0].addr = client->addr; 363 msg[0].flags = 0; 364 msg[0].len = sizeof(buf); 365 msg[0].buf = &buf[0]; 366 367 i2c_transfer(client->adapter, msg, 1); 368 } else { 369 /* Running: ensure that device is set in 24-hour mode */ 370 s32 val; 371 372 val = i2c_smbus_read_byte_data(client, DS1337_REG_HOUR); 373 if ((val >= 0) && (val & (1 << 6))) 374 i2c_smbus_write_byte_data(client, DS1337_REG_HOUR, 375 val & 0x3f); 376 } 377} 378 379static int ds1337_detach_client(struct i2c_client *client) 380{ 381 int err; 382 struct ds1337_data *data = i2c_get_clientdata(client); 383 384 if ((err = i2c_detach_client(client))) 385 return err; 386 387 list_del(&data->list); 388 kfree(data); 389 return 0; 390} 391 392static int __init ds1337_init(void) 393{ 394 return i2c_add_driver(&ds1337_driver); 395} 396 397static void __exit ds1337_exit(void) 398{ 399 i2c_del_driver(&ds1337_driver); 400} 401 402MODULE_AUTHOR("James Chapman <jchapman@katalix.com>"); 403MODULE_DESCRIPTION("DS1337 RTC driver"); 404MODULE_LICENSE("GPL"); 405 406EXPORT_SYMBOL_GPL(ds1337_do_command); 407 408module_init(ds1337_init); 409module_exit(ds1337_exit); 410