1 /* 2 * RTC client/driver for the Maxim/Dallas DS1374 Real-Time Clock over I2C 3 * 4 * Based on code by Randy Vinson <rvinson@mvista.com>, 5 * which was based on the m41t00.c by Mark Greer <mgreer@mvista.com>. 6 * 7 * Copyright (C) 2006-2007 Freescale Semiconductor 8 * 9 * 2005 (c) MontaVista Software, Inc. This file is licensed under 10 * the terms of the GNU General Public License version 2. This program 11 * is licensed "as is" without any warranty of any kind, whether express 12 * or implied. 13 */ 14 /* 15 * It would be more efficient to use i2c msgs/i2c_transfer directly but, as 16 * recommened in .../Documentation/i2c/writing-clients section 17 * "Sending and receiving", using SMBus level communication is preferred. 18 */ 19 20 #include <linux/kernel.h> 21 #include <linux/module.h> 22 #include <linux/interrupt.h> 23 #include <linux/i2c.h> 24 #include <linux/rtc.h> 25 #include <linux/bcd.h> 26 #include <linux/workqueue.h> 27 #include <linux/slab.h> 28 29 #define DS1374_REG_TOD0 0x00 /* Time of Day */ 30 #define DS1374_REG_TOD1 0x01 31 #define DS1374_REG_TOD2 0x02 32 #define DS1374_REG_TOD3 0x03 33 #define DS1374_REG_WDALM0 0x04 /* Watchdog/Alarm */ 34 #define DS1374_REG_WDALM1 0x05 35 #define DS1374_REG_WDALM2 0x06 36 #define DS1374_REG_CR 0x07 /* Control */ 37 #define DS1374_REG_CR_AIE 0x01 /* Alarm Int. Enable */ 38 #define DS1374_REG_CR_WDALM 0x20 /* 1=Watchdog, 0=Alarm */ 39 #define DS1374_REG_CR_WACE 0x40 /* WD/Alarm counter enable */ 40 #define DS1374_REG_SR 0x08 /* Status */ 41 #define DS1374_REG_SR_OSF 0x80 /* Oscillator Stop Flag */ 42 #define DS1374_REG_SR_AF 0x01 /* Alarm Flag */ 43 #define DS1374_REG_TCR 0x09 /* Trickle Charge */ 44 45 static const struct i2c_device_id ds1374_id[] = { 46 { "ds1374", 0 }, 47 { } 48 }; 49 MODULE_DEVICE_TABLE(i2c, ds1374_id); 50 51 struct ds1374 { 52 struct i2c_client *client; 53 struct rtc_device *rtc; 54 struct work_struct work; 55 56 /* The mutex protects alarm operations, and prevents a race 57 * between the enable_irq() in the workqueue and the free_irq() 58 * in the remove function. 59 */ 60 struct mutex mutex; 61 int exiting; 62 }; 63 64 static struct i2c_driver ds1374_driver; 65 66 static int ds1374_read_rtc(struct i2c_client *client, u32 *time, 67 int reg, int nbytes) 68 { 69 u8 buf[4]; 70 int ret; 71 int i; 72 73 if (nbytes > 4) { 74 WARN_ON(1); 75 return -EINVAL; 76 } 77 78 ret = i2c_smbus_read_i2c_block_data(client, reg, nbytes, buf); 79 80 if (ret < 0) 81 return ret; 82 if (ret < nbytes) 83 return -EIO; 84 85 for (i = nbytes - 1, *time = 0; i >= 0; i--) 86 *time = (*time << 8) | buf[i]; 87 88 return 0; 89 } 90 91 static int ds1374_write_rtc(struct i2c_client *client, u32 time, 92 int reg, int nbytes) 93 { 94 u8 buf[4]; 95 int i; 96 97 if (nbytes > 4) { 98 WARN_ON(1); 99 return -EINVAL; 100 } 101 102 for (i = 0; i < nbytes; i++) { 103 buf[i] = time & 0xff; 104 time >>= 8; 105 } 106 107 return i2c_smbus_write_i2c_block_data(client, reg, nbytes, buf); 108 } 109 110 static int ds1374_check_rtc_status(struct i2c_client *client) 111 { 112 int ret = 0; 113 int control, stat; 114 115 stat = i2c_smbus_read_byte_data(client, DS1374_REG_SR); 116 if (stat < 0) 117 return stat; 118 119 if (stat & DS1374_REG_SR_OSF) 120 dev_warn(&client->dev, 121 "oscillator discontinuity flagged, " 122 "time unreliable\n"); 123 124 stat &= ~(DS1374_REG_SR_OSF | DS1374_REG_SR_AF); 125 126 ret = i2c_smbus_write_byte_data(client, DS1374_REG_SR, stat); 127 if (ret < 0) 128 return ret; 129 130 /* If the alarm is pending, clear it before requesting 131 * the interrupt, so an interrupt event isn't reported 132 * before everything is initialized. 133 */ 134 135 control = i2c_smbus_read_byte_data(client, DS1374_REG_CR); 136 if (control < 0) 137 return control; 138 139 control &= ~(DS1374_REG_CR_WACE | DS1374_REG_CR_AIE); 140 return i2c_smbus_write_byte_data(client, DS1374_REG_CR, control); 141 } 142 143 static int ds1374_read_time(struct device *dev, struct rtc_time *time) 144 { 145 struct i2c_client *client = to_i2c_client(dev); 146 u32 itime; 147 int ret; 148 149 ret = ds1374_read_rtc(client, &itime, DS1374_REG_TOD0, 4); 150 if (!ret) 151 rtc_time_to_tm(itime, time); 152 153 return ret; 154 } 155 156 static int ds1374_set_time(struct device *dev, struct rtc_time *time) 157 { 158 struct i2c_client *client = to_i2c_client(dev); 159 unsigned long itime; 160 161 rtc_tm_to_time(time, &itime); 162 return ds1374_write_rtc(client, itime, DS1374_REG_TOD0, 4); 163 } 164 165 /* The ds1374 has a decrementer for an alarm, rather than a comparator. 166 * If the time of day is changed, then the alarm will need to be 167 * reset. 168 */ 169 static int ds1374_read_alarm(struct device *dev, struct rtc_wkalrm *alarm) 170 { 171 struct i2c_client *client = to_i2c_client(dev); 172 struct ds1374 *ds1374 = i2c_get_clientdata(client); 173 u32 now, cur_alarm; 174 int cr, sr; 175 int ret = 0; 176 177 if (client->irq <= 0) 178 return -EINVAL; 179 180 mutex_lock(&ds1374->mutex); 181 182 cr = ret = i2c_smbus_read_byte_data(client, DS1374_REG_CR); 183 if (ret < 0) 184 goto out; 185 186 sr = ret = i2c_smbus_read_byte_data(client, DS1374_REG_SR); 187 if (ret < 0) 188 goto out; 189 190 ret = ds1374_read_rtc(client, &now, DS1374_REG_TOD0, 4); 191 if (ret) 192 goto out; 193 194 ret = ds1374_read_rtc(client, &cur_alarm, DS1374_REG_WDALM0, 3); 195 if (ret) 196 goto out; 197 198 rtc_time_to_tm(now + cur_alarm, &alarm->time); 199 alarm->enabled = !!(cr & DS1374_REG_CR_WACE); 200 alarm->pending = !!(sr & DS1374_REG_SR_AF); 201 202 out: 203 mutex_unlock(&ds1374->mutex); 204 return ret; 205 } 206 207 static int ds1374_set_alarm(struct device *dev, struct rtc_wkalrm *alarm) 208 { 209 struct i2c_client *client = to_i2c_client(dev); 210 struct ds1374 *ds1374 = i2c_get_clientdata(client); 211 struct rtc_time now; 212 unsigned long new_alarm, itime; 213 int cr; 214 int ret = 0; 215 216 if (client->irq <= 0) 217 return -EINVAL; 218 219 ret = ds1374_read_time(dev, &now); 220 if (ret < 0) 221 return ret; 222 223 rtc_tm_to_time(&alarm->time, &new_alarm); 224 rtc_tm_to_time(&now, &itime); 225 226 /* This can happen due to races, in addition to dates that are 227 * truly in the past. To avoid requiring the caller to check for 228 * races, dates in the past are assumed to be in the recent past 229 * (i.e. not something that we'd rather the caller know about via 230 * an error), and the alarm is set to go off as soon as possible. 231 */ 232 if (time_before_eq(new_alarm, itime)) 233 new_alarm = 1; 234 else 235 new_alarm -= itime; 236 237 mutex_lock(&ds1374->mutex); 238 239 ret = cr = i2c_smbus_read_byte_data(client, DS1374_REG_CR); 240 if (ret < 0) 241 goto out; 242 243 /* Disable any existing alarm before setting the new one 244 * (or lack thereof). */ 245 cr &= ~DS1374_REG_CR_WACE; 246 247 ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, cr); 248 if (ret < 0) 249 goto out; 250 251 ret = ds1374_write_rtc(client, new_alarm, DS1374_REG_WDALM0, 3); 252 if (ret) 253 goto out; 254 255 if (alarm->enabled) { 256 cr |= DS1374_REG_CR_WACE | DS1374_REG_CR_AIE; 257 cr &= ~DS1374_REG_CR_WDALM; 258 259 ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, cr); 260 } 261 262 out: 263 mutex_unlock(&ds1374->mutex); 264 return ret; 265 } 266 267 static irqreturn_t ds1374_irq(int irq, void *dev_id) 268 { 269 struct i2c_client *client = dev_id; 270 struct ds1374 *ds1374 = i2c_get_clientdata(client); 271 272 disable_irq_nosync(irq); 273 schedule_work(&ds1374->work); 274 return IRQ_HANDLED; 275 } 276 277 static void ds1374_work(struct work_struct *work) 278 { 279 struct ds1374 *ds1374 = container_of(work, struct ds1374, work); 280 struct i2c_client *client = ds1374->client; 281 int stat, control; 282 283 mutex_lock(&ds1374->mutex); 284 285 stat = i2c_smbus_read_byte_data(client, DS1374_REG_SR); 286 if (stat < 0) 287 goto unlock; 288 289 if (stat & DS1374_REG_SR_AF) { 290 stat &= ~DS1374_REG_SR_AF; 291 i2c_smbus_write_byte_data(client, DS1374_REG_SR, stat); 292 293 control = i2c_smbus_read_byte_data(client, DS1374_REG_CR); 294 if (control < 0) 295 goto out; 296 297 control &= ~(DS1374_REG_CR_WACE | DS1374_REG_CR_AIE); 298 i2c_smbus_write_byte_data(client, DS1374_REG_CR, control); 299 300 rtc_update_irq(ds1374->rtc, 1, RTC_AF | RTC_IRQF); 301 } 302 303 out: 304 if (!ds1374->exiting) 305 enable_irq(client->irq); 306 unlock: 307 mutex_unlock(&ds1374->mutex); 308 } 309 310 static int ds1374_ioctl(struct device *dev, unsigned int cmd, unsigned long arg) 311 { 312 struct i2c_client *client = to_i2c_client(dev); 313 struct ds1374 *ds1374 = i2c_get_clientdata(client); 314 int ret = -ENOIOCTLCMD; 315 316 mutex_lock(&ds1374->mutex); 317 318 switch (cmd) { 319 case RTC_AIE_OFF: 320 ret = i2c_smbus_read_byte_data(client, DS1374_REG_CR); 321 if (ret < 0) 322 goto out; 323 324 ret &= ~DS1374_REG_CR_WACE; 325 326 ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, ret); 327 if (ret < 0) 328 goto out; 329 330 break; 331 332 case RTC_AIE_ON: 333 ret = i2c_smbus_read_byte_data(client, DS1374_REG_CR); 334 if (ret < 0) 335 goto out; 336 337 ret |= DS1374_REG_CR_WACE | DS1374_REG_CR_AIE; 338 ret &= ~DS1374_REG_CR_WDALM; 339 340 ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, ret); 341 if (ret < 0) 342 goto out; 343 344 break; 345 } 346 347 out: 348 mutex_unlock(&ds1374->mutex); 349 return ret; 350 } 351 352 static const struct rtc_class_ops ds1374_rtc_ops = { 353 .read_time = ds1374_read_time, 354 .set_time = ds1374_set_time, 355 .read_alarm = ds1374_read_alarm, 356 .set_alarm = ds1374_set_alarm, 357 .ioctl = ds1374_ioctl, 358 }; 359 360 static int ds1374_probe(struct i2c_client *client, 361 const struct i2c_device_id *id) 362 { 363 struct ds1374 *ds1374; 364 int ret; 365 366 ds1374 = kzalloc(sizeof(struct ds1374), GFP_KERNEL); 367 if (!ds1374) 368 return -ENOMEM; 369 370 ds1374->client = client; 371 i2c_set_clientdata(client, ds1374); 372 373 INIT_WORK(&ds1374->work, ds1374_work); 374 mutex_init(&ds1374->mutex); 375 376 ret = ds1374_check_rtc_status(client); 377 if (ret) 378 goto out_free; 379 380 if (client->irq > 0) { 381 ret = request_irq(client->irq, ds1374_irq, 0, 382 "ds1374", client); 383 if (ret) { 384 dev_err(&client->dev, "unable to request IRQ\n"); 385 goto out_free; 386 } 387 388 device_set_wakeup_capable(&client->dev, 1); 389 } 390 391 ds1374->rtc = rtc_device_register(client->name, &client->dev, 392 &ds1374_rtc_ops, THIS_MODULE); 393 if (IS_ERR(ds1374->rtc)) { 394 ret = PTR_ERR(ds1374->rtc); 395 dev_err(&client->dev, "unable to register the class device\n"); 396 goto out_irq; 397 } 398 399 return 0; 400 401 out_irq: 402 if (client->irq > 0) 403 free_irq(client->irq, client); 404 405 out_free: 406 kfree(ds1374); 407 return ret; 408 } 409 410 static int __devexit ds1374_remove(struct i2c_client *client) 411 { 412 struct ds1374 *ds1374 = i2c_get_clientdata(client); 413 414 if (client->irq > 0) { 415 mutex_lock(&ds1374->mutex); 416 ds1374->exiting = 1; 417 mutex_unlock(&ds1374->mutex); 418 419 free_irq(client->irq, client); 420 flush_scheduled_work(); 421 } 422 423 rtc_device_unregister(ds1374->rtc); 424 kfree(ds1374); 425 return 0; 426 } 427 428 #ifdef CONFIG_PM 429 static int ds1374_suspend(struct i2c_client *client, pm_message_t state) 430 { 431 if (client->irq >= 0 && device_may_wakeup(&client->dev)) 432 enable_irq_wake(client->irq); 433 return 0; 434 } 435 436 static int ds1374_resume(struct i2c_client *client) 437 { 438 if (client->irq >= 0 && device_may_wakeup(&client->dev)) 439 disable_irq_wake(client->irq); 440 return 0; 441 } 442 #else 443 #define ds1374_suspend NULL 444 #define ds1374_resume NULL 445 #endif 446 447 static struct i2c_driver ds1374_driver = { 448 .driver = { 449 .name = "rtc-ds1374", 450 .owner = THIS_MODULE, 451 }, 452 .probe = ds1374_probe, 453 .suspend = ds1374_suspend, 454 .resume = ds1374_resume, 455 .remove = __devexit_p(ds1374_remove), 456 .id_table = ds1374_id, 457 }; 458 459 static int __init ds1374_init(void) 460 { 461 return i2c_add_driver(&ds1374_driver); 462 } 463 464 static void __exit ds1374_exit(void) 465 { 466 i2c_del_driver(&ds1374_driver); 467 } 468 469 module_init(ds1374_init); 470 module_exit(ds1374_exit); 471 472 MODULE_AUTHOR("Scott Wood <scottwood@freescale.com>"); 473 MODULE_DESCRIPTION("Maxim/Dallas DS1374 RTC Driver"); 474 MODULE_LICENSE("GPL"); 475