1 /* 2 * An I2C and SPI driver for the NXP PCF2127/29 RTC 3 * Copyright 2013 Til-Technologies 4 * 5 * Author: Renaud Cerrato <r.cerrato@til-technologies.fr> 6 * 7 * based on the other drivers in this same directory. 8 * 9 * Datasheet: http://cache.nxp.com/documents/data_sheet/PCF2127.pdf 10 * 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License version 2 as 13 * published by the Free Software Foundation. 14 */ 15 16 #include <linux/i2c.h> 17 #include <linux/spi/spi.h> 18 #include <linux/bcd.h> 19 #include <linux/rtc.h> 20 #include <linux/slab.h> 21 #include <linux/module.h> 22 #include <linux/of.h> 23 #include <linux/regmap.h> 24 25 #define PCF2127_REG_CTRL1 (0x00) /* Control Register 1 */ 26 #define PCF2127_REG_CTRL2 (0x01) /* Control Register 2 */ 27 28 #define PCF2127_REG_CTRL3 (0x02) /* Control Register 3 */ 29 #define PCF2127_REG_CTRL3_BLF BIT(2) 30 31 #define PCF2127_REG_SC (0x03) /* datetime */ 32 #define PCF2127_REG_MN (0x04) 33 #define PCF2127_REG_HR (0x05) 34 #define PCF2127_REG_DM (0x06) 35 #define PCF2127_REG_DW (0x07) 36 #define PCF2127_REG_MO (0x08) 37 #define PCF2127_REG_YR (0x09) 38 39 /* the pcf2127 has 512 bytes nvmem, pcf2129 doesn't */ 40 #define PCF2127_REG_RAM_addr_MSB 0x1a 41 #define PCF2127_REG_RAM_wrt_cmd 0x1c 42 #define PCF2127_REG_RAM_rd_cmd 0x1d 43 44 #define PCF2127_OSF BIT(7) /* Oscillator Fail flag */ 45 46 struct pcf2127 { 47 struct rtc_device *rtc; 48 struct regmap *regmap; 49 }; 50 51 /* 52 * In the routines that deal directly with the pcf2127 hardware, we use 53 * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch. 54 */ 55 static int pcf2127_rtc_read_time(struct device *dev, struct rtc_time *tm) 56 { 57 struct pcf2127 *pcf2127 = dev_get_drvdata(dev); 58 unsigned char buf[10]; 59 int ret; 60 int i; 61 62 for (i = 0; i <= PCF2127_REG_CTRL3; i++) { 63 ret = regmap_read(pcf2127->regmap, PCF2127_REG_CTRL1 + i, 64 (unsigned int *)(buf + i)); 65 if (ret) { 66 dev_err(dev, "%s: read error\n", __func__); 67 return ret; 68 } 69 } 70 71 ret = regmap_bulk_read(pcf2127->regmap, PCF2127_REG_SC, 72 (buf + PCF2127_REG_SC), 73 ARRAY_SIZE(buf) - PCF2127_REG_SC); 74 if (ret) { 75 dev_err(dev, "%s: read error\n", __func__); 76 return ret; 77 } 78 79 if (buf[PCF2127_REG_CTRL3] & PCF2127_REG_CTRL3_BLF) 80 dev_info(dev, 81 "low voltage detected, check/replace RTC battery.\n"); 82 83 if (buf[PCF2127_REG_SC] & PCF2127_OSF) { 84 /* 85 * no need clear the flag here, 86 * it will be cleared once the new date is saved 87 */ 88 dev_warn(dev, 89 "oscillator stop detected, date/time is not reliable\n"); 90 return -EINVAL; 91 } 92 93 dev_dbg(dev, 94 "%s: raw data is cr1=%02x, cr2=%02x, cr3=%02x, " 95 "sec=%02x, min=%02x, hr=%02x, " 96 "mday=%02x, wday=%02x, mon=%02x, year=%02x\n", 97 __func__, 98 buf[0], buf[1], buf[2], 99 buf[3], buf[4], buf[5], 100 buf[6], buf[7], buf[8], buf[9]); 101 102 103 tm->tm_sec = bcd2bin(buf[PCF2127_REG_SC] & 0x7F); 104 tm->tm_min = bcd2bin(buf[PCF2127_REG_MN] & 0x7F); 105 tm->tm_hour = bcd2bin(buf[PCF2127_REG_HR] & 0x3F); /* rtc hr 0-23 */ 106 tm->tm_mday = bcd2bin(buf[PCF2127_REG_DM] & 0x3F); 107 tm->tm_wday = buf[PCF2127_REG_DW] & 0x07; 108 tm->tm_mon = bcd2bin(buf[PCF2127_REG_MO] & 0x1F) - 1; /* rtc mn 1-12 */ 109 tm->tm_year = bcd2bin(buf[PCF2127_REG_YR]); 110 if (tm->tm_year < 70) 111 tm->tm_year += 100; /* assume we are in 1970...2069 */ 112 113 dev_dbg(dev, "%s: tm is secs=%d, mins=%d, hours=%d, " 114 "mday=%d, mon=%d, year=%d, wday=%d\n", 115 __func__, 116 tm->tm_sec, tm->tm_min, tm->tm_hour, 117 tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday); 118 119 return 0; 120 } 121 122 static int pcf2127_rtc_set_time(struct device *dev, struct rtc_time *tm) 123 { 124 struct pcf2127 *pcf2127 = dev_get_drvdata(dev); 125 unsigned char buf[7]; 126 int i = 0, err; 127 128 dev_dbg(dev, "%s: secs=%d, mins=%d, hours=%d, " 129 "mday=%d, mon=%d, year=%d, wday=%d\n", 130 __func__, 131 tm->tm_sec, tm->tm_min, tm->tm_hour, 132 tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday); 133 134 /* hours, minutes and seconds */ 135 buf[i++] = bin2bcd(tm->tm_sec); /* this will also clear OSF flag */ 136 buf[i++] = bin2bcd(tm->tm_min); 137 buf[i++] = bin2bcd(tm->tm_hour); 138 buf[i++] = bin2bcd(tm->tm_mday); 139 buf[i++] = tm->tm_wday & 0x07; 140 141 /* month, 1 - 12 */ 142 buf[i++] = bin2bcd(tm->tm_mon + 1); 143 144 /* year */ 145 buf[i++] = bin2bcd(tm->tm_year % 100); 146 147 /* write register's data */ 148 err = regmap_bulk_write(pcf2127->regmap, PCF2127_REG_SC, buf, i); 149 if (err) { 150 dev_err(dev, 151 "%s: err=%d", __func__, err); 152 return err; 153 } 154 155 return 0; 156 } 157 158 #ifdef CONFIG_RTC_INTF_DEV 159 static int pcf2127_rtc_ioctl(struct device *dev, 160 unsigned int cmd, unsigned long arg) 161 { 162 struct pcf2127 *pcf2127 = dev_get_drvdata(dev); 163 int touser; 164 int ret; 165 166 switch (cmd) { 167 case RTC_VL_READ: 168 ret = regmap_read(pcf2127->regmap, PCF2127_REG_CTRL3, &touser); 169 if (ret) 170 return ret; 171 172 touser = touser & PCF2127_REG_CTRL3_BLF ? 1 : 0; 173 174 if (copy_to_user((void __user *)arg, &touser, sizeof(int))) 175 return -EFAULT; 176 return 0; 177 default: 178 return -ENOIOCTLCMD; 179 } 180 } 181 #else 182 #define pcf2127_rtc_ioctl NULL 183 #endif 184 185 static const struct rtc_class_ops pcf2127_rtc_ops = { 186 .ioctl = pcf2127_rtc_ioctl, 187 .read_time = pcf2127_rtc_read_time, 188 .set_time = pcf2127_rtc_set_time, 189 }; 190 191 static int pcf2127_nvmem_read(void *priv, unsigned int offset, 192 void *val, size_t bytes) 193 { 194 struct pcf2127 *pcf2127 = priv; 195 int ret; 196 unsigned char offsetbuf[] = { offset >> 8, offset }; 197 198 ret = regmap_bulk_write(pcf2127->regmap, PCF2127_REG_RAM_addr_MSB, 199 offsetbuf, 2); 200 if (ret) 201 return ret; 202 203 ret = regmap_bulk_read(pcf2127->regmap, PCF2127_REG_RAM_rd_cmd, 204 val, bytes); 205 206 return ret ?: bytes; 207 } 208 209 static int pcf2127_nvmem_write(void *priv, unsigned int offset, 210 void *val, size_t bytes) 211 { 212 struct pcf2127 *pcf2127 = priv; 213 int ret; 214 unsigned char offsetbuf[] = { offset >> 8, offset }; 215 216 ret = regmap_bulk_write(pcf2127->regmap, PCF2127_REG_RAM_addr_MSB, 217 offsetbuf, 2); 218 if (ret) 219 return ret; 220 221 ret = regmap_bulk_write(pcf2127->regmap, PCF2127_REG_RAM_wrt_cmd, 222 val, bytes); 223 224 return ret ?: bytes; 225 } 226 227 static int pcf2127_probe(struct device *dev, struct regmap *regmap, 228 const char *name, bool has_nvmem) 229 { 230 struct pcf2127 *pcf2127; 231 int ret = 0; 232 233 dev_dbg(dev, "%s\n", __func__); 234 235 pcf2127 = devm_kzalloc(dev, sizeof(*pcf2127), GFP_KERNEL); 236 if (!pcf2127) 237 return -ENOMEM; 238 239 pcf2127->regmap = regmap; 240 241 dev_set_drvdata(dev, pcf2127); 242 243 pcf2127->rtc = devm_rtc_device_register(dev, name, &pcf2127_rtc_ops, 244 THIS_MODULE); 245 if (IS_ERR(pcf2127->rtc)) 246 return PTR_ERR(pcf2127->rtc); 247 248 if (has_nvmem) { 249 struct nvmem_config nvmem_cfg = { 250 .priv = pcf2127, 251 .reg_read = pcf2127_nvmem_read, 252 .reg_write = pcf2127_nvmem_write, 253 .size = 512, 254 }; 255 256 ret = rtc_nvmem_register(pcf2127->rtc, &nvmem_cfg); 257 } 258 259 return ret; 260 } 261 262 #ifdef CONFIG_OF 263 static const struct of_device_id pcf2127_of_match[] = { 264 { .compatible = "nxp,pcf2127" }, 265 { .compatible = "nxp,pcf2129" }, 266 {} 267 }; 268 MODULE_DEVICE_TABLE(of, pcf2127_of_match); 269 #endif 270 271 #if IS_ENABLED(CONFIG_I2C) 272 273 static int pcf2127_i2c_write(void *context, const void *data, size_t count) 274 { 275 struct device *dev = context; 276 struct i2c_client *client = to_i2c_client(dev); 277 int ret; 278 279 ret = i2c_master_send(client, data, count); 280 if (ret != count) 281 return ret < 0 ? ret : -EIO; 282 283 return 0; 284 } 285 286 static int pcf2127_i2c_gather_write(void *context, 287 const void *reg, size_t reg_size, 288 const void *val, size_t val_size) 289 { 290 struct device *dev = context; 291 struct i2c_client *client = to_i2c_client(dev); 292 int ret; 293 void *buf; 294 295 if (WARN_ON(reg_size != 1)) 296 return -EINVAL; 297 298 buf = kmalloc(val_size + 1, GFP_KERNEL); 299 if (!buf) 300 return -ENOMEM; 301 302 memcpy(buf, reg, 1); 303 memcpy(buf + 1, val, val_size); 304 305 ret = i2c_master_send(client, buf, val_size + 1); 306 if (ret != val_size + 1) 307 return ret < 0 ? ret : -EIO; 308 309 return 0; 310 } 311 312 static int pcf2127_i2c_read(void *context, const void *reg, size_t reg_size, 313 void *val, size_t val_size) 314 { 315 struct device *dev = context; 316 struct i2c_client *client = to_i2c_client(dev); 317 int ret; 318 319 if (WARN_ON(reg_size != 1)) 320 return -EINVAL; 321 322 ret = i2c_master_send(client, reg, 1); 323 if (ret != 1) 324 return ret < 0 ? ret : -EIO; 325 326 ret = i2c_master_recv(client, val, val_size); 327 if (ret != val_size) 328 return ret < 0 ? ret : -EIO; 329 330 return 0; 331 } 332 333 /* 334 * The reason we need this custom regmap_bus instead of using regmap_init_i2c() 335 * is that the STOP condition is required between set register address and 336 * read register data when reading from registers. 337 */ 338 static const struct regmap_bus pcf2127_i2c_regmap = { 339 .write = pcf2127_i2c_write, 340 .gather_write = pcf2127_i2c_gather_write, 341 .read = pcf2127_i2c_read, 342 }; 343 344 static struct i2c_driver pcf2127_i2c_driver; 345 346 static int pcf2127_i2c_probe(struct i2c_client *client, 347 const struct i2c_device_id *id) 348 { 349 struct regmap *regmap; 350 static const struct regmap_config config = { 351 .reg_bits = 8, 352 .val_bits = 8, 353 }; 354 355 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) 356 return -ENODEV; 357 358 regmap = devm_regmap_init(&client->dev, &pcf2127_i2c_regmap, 359 &client->dev, &config); 360 if (IS_ERR(regmap)) { 361 dev_err(&client->dev, "%s: regmap allocation failed: %ld\n", 362 __func__, PTR_ERR(regmap)); 363 return PTR_ERR(regmap); 364 } 365 366 return pcf2127_probe(&client->dev, regmap, 367 pcf2127_i2c_driver.driver.name, id->driver_data); 368 } 369 370 static const struct i2c_device_id pcf2127_i2c_id[] = { 371 { "pcf2127", 1 }, 372 { "pcf2129", 0 }, 373 { } 374 }; 375 MODULE_DEVICE_TABLE(i2c, pcf2127_i2c_id); 376 377 static struct i2c_driver pcf2127_i2c_driver = { 378 .driver = { 379 .name = "rtc-pcf2127-i2c", 380 .of_match_table = of_match_ptr(pcf2127_of_match), 381 }, 382 .probe = pcf2127_i2c_probe, 383 .id_table = pcf2127_i2c_id, 384 }; 385 386 static int pcf2127_i2c_register_driver(void) 387 { 388 return i2c_add_driver(&pcf2127_i2c_driver); 389 } 390 391 static void pcf2127_i2c_unregister_driver(void) 392 { 393 i2c_del_driver(&pcf2127_i2c_driver); 394 } 395 396 #else 397 398 static int pcf2127_i2c_register_driver(void) 399 { 400 return 0; 401 } 402 403 static void pcf2127_i2c_unregister_driver(void) 404 { 405 } 406 407 #endif 408 409 #if IS_ENABLED(CONFIG_SPI_MASTER) 410 411 static struct spi_driver pcf2127_spi_driver; 412 413 static int pcf2127_spi_probe(struct spi_device *spi) 414 { 415 static const struct regmap_config config = { 416 .reg_bits = 8, 417 .val_bits = 8, 418 .read_flag_mask = 0xa0, 419 .write_flag_mask = 0x20, 420 }; 421 struct regmap *regmap; 422 423 regmap = devm_regmap_init_spi(spi, &config); 424 if (IS_ERR(regmap)) { 425 dev_err(&spi->dev, "%s: regmap allocation failed: %ld\n", 426 __func__, PTR_ERR(regmap)); 427 return PTR_ERR(regmap); 428 } 429 430 return pcf2127_probe(&spi->dev, regmap, pcf2127_spi_driver.driver.name, 431 spi_get_device_id(spi)->driver_data); 432 } 433 434 static const struct spi_device_id pcf2127_spi_id[] = { 435 { "pcf2127", 1 }, 436 { "pcf2129", 0 }, 437 { } 438 }; 439 MODULE_DEVICE_TABLE(spi, pcf2127_spi_id); 440 441 static struct spi_driver pcf2127_spi_driver = { 442 .driver = { 443 .name = "rtc-pcf2127-spi", 444 .of_match_table = of_match_ptr(pcf2127_of_match), 445 }, 446 .probe = pcf2127_spi_probe, 447 .id_table = pcf2127_spi_id, 448 }; 449 450 static int pcf2127_spi_register_driver(void) 451 { 452 return spi_register_driver(&pcf2127_spi_driver); 453 } 454 455 static void pcf2127_spi_unregister_driver(void) 456 { 457 spi_unregister_driver(&pcf2127_spi_driver); 458 } 459 460 #else 461 462 static int pcf2127_spi_register_driver(void) 463 { 464 return 0; 465 } 466 467 static void pcf2127_spi_unregister_driver(void) 468 { 469 } 470 471 #endif 472 473 static int __init pcf2127_init(void) 474 { 475 int ret; 476 477 ret = pcf2127_i2c_register_driver(); 478 if (ret) { 479 pr_err("Failed to register pcf2127 i2c driver: %d\n", ret); 480 return ret; 481 } 482 483 ret = pcf2127_spi_register_driver(); 484 if (ret) { 485 pr_err("Failed to register pcf2127 spi driver: %d\n", ret); 486 pcf2127_i2c_unregister_driver(); 487 } 488 489 return ret; 490 } 491 module_init(pcf2127_init) 492 493 static void __exit pcf2127_exit(void) 494 { 495 pcf2127_spi_unregister_driver(); 496 pcf2127_i2c_unregister_driver(); 497 } 498 module_exit(pcf2127_exit) 499 500 MODULE_AUTHOR("Renaud Cerrato <r.cerrato@til-technologies.fr>"); 501 MODULE_DESCRIPTION("NXP PCF2127/29 RTC driver"); 502 MODULE_LICENSE("GPL v2"); 503