1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2012 Avionic Design GmbH 4 */ 5 6 #include <linux/bcd.h> 7 #include <linux/i2c.h> 8 #include <linux/module.h> 9 #include <linux/rtc.h> 10 #include <linux/of.h> 11 12 #define DRIVER_NAME "rtc-pcf8523" 13 14 #define REG_CONTROL1 0x00 15 #define REG_CONTROL1_CAP_SEL (1 << 7) 16 #define REG_CONTROL1_STOP (1 << 5) 17 18 #define REG_CONTROL3 0x02 19 #define REG_CONTROL3_PM_BLD (1 << 7) /* battery low detection disabled */ 20 #define REG_CONTROL3_PM_VDD (1 << 6) /* switch-over disabled */ 21 #define REG_CONTROL3_PM_DSM (1 << 5) /* direct switching mode */ 22 #define REG_CONTROL3_PM_MASK 0xe0 23 #define REG_CONTROL3_BLF (1 << 2) /* battery low bit, read-only */ 24 25 #define REG_SECONDS 0x03 26 #define REG_SECONDS_OS (1 << 7) 27 28 #define REG_MINUTES 0x04 29 #define REG_HOURS 0x05 30 #define REG_DAYS 0x06 31 #define REG_WEEKDAYS 0x07 32 #define REG_MONTHS 0x08 33 #define REG_YEARS 0x09 34 35 #define REG_OFFSET 0x0e 36 #define REG_OFFSET_MODE BIT(7) 37 38 static int pcf8523_read(struct i2c_client *client, u8 reg, u8 *valuep) 39 { 40 struct i2c_msg msgs[2]; 41 u8 value = 0; 42 int err; 43 44 msgs[0].addr = client->addr; 45 msgs[0].flags = 0; 46 msgs[0].len = sizeof(reg); 47 msgs[0].buf = ® 48 49 msgs[1].addr = client->addr; 50 msgs[1].flags = I2C_M_RD; 51 msgs[1].len = sizeof(value); 52 msgs[1].buf = &value; 53 54 err = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs)); 55 if (err < 0) 56 return err; 57 58 *valuep = value; 59 60 return 0; 61 } 62 63 static int pcf8523_write(struct i2c_client *client, u8 reg, u8 value) 64 { 65 u8 buffer[2] = { reg, value }; 66 struct i2c_msg msg; 67 int err; 68 69 msg.addr = client->addr; 70 msg.flags = 0; 71 msg.len = sizeof(buffer); 72 msg.buf = buffer; 73 74 err = i2c_transfer(client->adapter, &msg, 1); 75 if (err < 0) 76 return err; 77 78 return 0; 79 } 80 81 static int pcf8523_voltage_low(struct i2c_client *client) 82 { 83 u8 value; 84 int err; 85 86 err = pcf8523_read(client, REG_CONTROL3, &value); 87 if (err < 0) 88 return err; 89 90 return !!(value & REG_CONTROL3_BLF); 91 } 92 93 static int pcf8523_load_capacitance(struct i2c_client *client) 94 { 95 u32 load; 96 u8 value; 97 int err; 98 99 err = pcf8523_read(client, REG_CONTROL1, &value); 100 if (err < 0) 101 return err; 102 103 load = 12500; 104 of_property_read_u32(client->dev.of_node, "quartz-load-femtofarads", 105 &load); 106 107 switch (load) { 108 default: 109 dev_warn(&client->dev, "Unknown quartz-load-femtofarads value: %d. Assuming 12500", 110 load); 111 fallthrough; 112 case 12500: 113 value |= REG_CONTROL1_CAP_SEL; 114 break; 115 case 7000: 116 value &= ~REG_CONTROL1_CAP_SEL; 117 break; 118 } 119 120 err = pcf8523_write(client, REG_CONTROL1, value); 121 122 return err; 123 } 124 125 static int pcf8523_set_pm(struct i2c_client *client, u8 pm) 126 { 127 u8 value; 128 int err; 129 130 err = pcf8523_read(client, REG_CONTROL3, &value); 131 if (err < 0) 132 return err; 133 134 value = (value & ~REG_CONTROL3_PM_MASK) | pm; 135 136 err = pcf8523_write(client, REG_CONTROL3, value); 137 if (err < 0) 138 return err; 139 140 return 0; 141 } 142 143 static int pcf8523_stop_rtc(struct i2c_client *client) 144 { 145 u8 value; 146 int err; 147 148 err = pcf8523_read(client, REG_CONTROL1, &value); 149 if (err < 0) 150 return err; 151 152 value |= REG_CONTROL1_STOP; 153 154 err = pcf8523_write(client, REG_CONTROL1, value); 155 if (err < 0) 156 return err; 157 158 return 0; 159 } 160 161 static int pcf8523_start_rtc(struct i2c_client *client) 162 { 163 u8 value; 164 int err; 165 166 err = pcf8523_read(client, REG_CONTROL1, &value); 167 if (err < 0) 168 return err; 169 170 value &= ~REG_CONTROL1_STOP; 171 172 err = pcf8523_write(client, REG_CONTROL1, value); 173 if (err < 0) 174 return err; 175 176 return 0; 177 } 178 179 static int pcf8523_rtc_read_time(struct device *dev, struct rtc_time *tm) 180 { 181 struct i2c_client *client = to_i2c_client(dev); 182 u8 start = REG_SECONDS, regs[7]; 183 struct i2c_msg msgs[2]; 184 int err; 185 186 err = pcf8523_voltage_low(client); 187 if (err < 0) { 188 return err; 189 } else if (err > 0) { 190 dev_err(dev, "low voltage detected, time is unreliable\n"); 191 return -EINVAL; 192 } 193 194 msgs[0].addr = client->addr; 195 msgs[0].flags = 0; 196 msgs[0].len = 1; 197 msgs[0].buf = &start; 198 199 msgs[1].addr = client->addr; 200 msgs[1].flags = I2C_M_RD; 201 msgs[1].len = sizeof(regs); 202 msgs[1].buf = regs; 203 204 err = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs)); 205 if (err < 0) 206 return err; 207 208 if (regs[0] & REG_SECONDS_OS) 209 return -EINVAL; 210 211 tm->tm_sec = bcd2bin(regs[0] & 0x7f); 212 tm->tm_min = bcd2bin(regs[1] & 0x7f); 213 tm->tm_hour = bcd2bin(regs[2] & 0x3f); 214 tm->tm_mday = bcd2bin(regs[3] & 0x3f); 215 tm->tm_wday = regs[4] & 0x7; 216 tm->tm_mon = bcd2bin(regs[5] & 0x1f) - 1; 217 tm->tm_year = bcd2bin(regs[6]) + 100; 218 219 return 0; 220 } 221 222 static int pcf8523_rtc_set_time(struct device *dev, struct rtc_time *tm) 223 { 224 struct i2c_client *client = to_i2c_client(dev); 225 struct i2c_msg msg; 226 u8 regs[8]; 227 int err; 228 229 /* 230 * The hardware can only store values between 0 and 99 in it's YEAR 231 * register (with 99 overflowing to 0 on increment). 232 * After 2100-02-28 we could start interpreting the year to be in the 233 * interval [2100, 2199], but there is no path to switch in a smooth way 234 * because the chip handles YEAR=0x00 (and the out-of-spec 235 * YEAR=0xa0) as a leap year, but 2100 isn't. 236 */ 237 if (tm->tm_year < 100 || tm->tm_year >= 200) 238 return -EINVAL; 239 240 err = pcf8523_stop_rtc(client); 241 if (err < 0) 242 return err; 243 244 regs[0] = REG_SECONDS; 245 /* This will purposely overwrite REG_SECONDS_OS */ 246 regs[1] = bin2bcd(tm->tm_sec); 247 regs[2] = bin2bcd(tm->tm_min); 248 regs[3] = bin2bcd(tm->tm_hour); 249 regs[4] = bin2bcd(tm->tm_mday); 250 regs[5] = tm->tm_wday; 251 regs[6] = bin2bcd(tm->tm_mon + 1); 252 regs[7] = bin2bcd(tm->tm_year - 100); 253 254 msg.addr = client->addr; 255 msg.flags = 0; 256 msg.len = sizeof(regs); 257 msg.buf = regs; 258 259 err = i2c_transfer(client->adapter, &msg, 1); 260 if (err < 0) { 261 /* 262 * If the time cannot be set, restart the RTC anyway. Note 263 * that errors are ignored if the RTC cannot be started so 264 * that we have a chance to propagate the original error. 265 */ 266 pcf8523_start_rtc(client); 267 return err; 268 } 269 270 return pcf8523_start_rtc(client); 271 } 272 273 #ifdef CONFIG_RTC_INTF_DEV 274 static int pcf8523_rtc_ioctl(struct device *dev, unsigned int cmd, 275 unsigned long arg) 276 { 277 struct i2c_client *client = to_i2c_client(dev); 278 int ret; 279 280 switch (cmd) { 281 case RTC_VL_READ: 282 ret = pcf8523_voltage_low(client); 283 if (ret < 0) 284 return ret; 285 if (ret) 286 ret = RTC_VL_BACKUP_LOW; 287 288 return put_user(ret, (unsigned int __user *)arg); 289 290 default: 291 return -ENOIOCTLCMD; 292 } 293 } 294 #else 295 #define pcf8523_rtc_ioctl NULL 296 #endif 297 298 static int pcf8523_rtc_read_offset(struct device *dev, long *offset) 299 { 300 struct i2c_client *client = to_i2c_client(dev); 301 int err; 302 u8 value; 303 s8 val; 304 305 err = pcf8523_read(client, REG_OFFSET, &value); 306 if (err < 0) 307 return err; 308 309 /* sign extend the 7-bit offset value */ 310 val = value << 1; 311 *offset = (value & REG_OFFSET_MODE ? 4069 : 4340) * (val >> 1); 312 313 return 0; 314 } 315 316 static int pcf8523_rtc_set_offset(struct device *dev, long offset) 317 { 318 struct i2c_client *client = to_i2c_client(dev); 319 long reg_m0, reg_m1; 320 u8 value; 321 322 reg_m0 = clamp(DIV_ROUND_CLOSEST(offset, 4340), -64L, 63L); 323 reg_m1 = clamp(DIV_ROUND_CLOSEST(offset, 4069), -64L, 63L); 324 325 if (abs(reg_m0 * 4340 - offset) < abs(reg_m1 * 4069 - offset)) 326 value = reg_m0 & 0x7f; 327 else 328 value = (reg_m1 & 0x7f) | REG_OFFSET_MODE; 329 330 return pcf8523_write(client, REG_OFFSET, value); 331 } 332 333 static const struct rtc_class_ops pcf8523_rtc_ops = { 334 .read_time = pcf8523_rtc_read_time, 335 .set_time = pcf8523_rtc_set_time, 336 .ioctl = pcf8523_rtc_ioctl, 337 .read_offset = pcf8523_rtc_read_offset, 338 .set_offset = pcf8523_rtc_set_offset, 339 }; 340 341 static int pcf8523_probe(struct i2c_client *client, 342 const struct i2c_device_id *id) 343 { 344 struct rtc_device *rtc; 345 int err; 346 347 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) 348 return -ENODEV; 349 350 err = pcf8523_load_capacitance(client); 351 if (err < 0) 352 dev_warn(&client->dev, "failed to set xtal load capacitance: %d", 353 err); 354 355 err = pcf8523_set_pm(client, 0); 356 if (err < 0) 357 return err; 358 359 rtc = devm_rtc_device_register(&client->dev, DRIVER_NAME, 360 &pcf8523_rtc_ops, THIS_MODULE); 361 if (IS_ERR(rtc)) 362 return PTR_ERR(rtc); 363 364 return 0; 365 } 366 367 static const struct i2c_device_id pcf8523_id[] = { 368 { "pcf8523", 0 }, 369 { } 370 }; 371 MODULE_DEVICE_TABLE(i2c, pcf8523_id); 372 373 #ifdef CONFIG_OF 374 static const struct of_device_id pcf8523_of_match[] = { 375 { .compatible = "nxp,pcf8523" }, 376 { .compatible = "microcrystal,rv8523" }, 377 { } 378 }; 379 MODULE_DEVICE_TABLE(of, pcf8523_of_match); 380 #endif 381 382 static struct i2c_driver pcf8523_driver = { 383 .driver = { 384 .name = DRIVER_NAME, 385 .of_match_table = of_match_ptr(pcf8523_of_match), 386 }, 387 .probe = pcf8523_probe, 388 .id_table = pcf8523_id, 389 }; 390 module_i2c_driver(pcf8523_driver); 391 392 MODULE_AUTHOR("Thierry Reding <thierry.reding@avionic-design.de>"); 393 MODULE_DESCRIPTION("NXP PCF8523 RTC driver"); 394 MODULE_LICENSE("GPL v2"); 395