1 /* 2 * An I2C driver for the Philips PCF8563 RTC 3 * Copyright 2005-06 Tower Technologies 4 * 5 * Author: Alessandro Zummo <a.zummo@towertech.it> 6 * Maintainers: http://www.nslu2-linux.org/ 7 * 8 * based on the other drivers in this same directory. 9 * 10 * http://www.semiconductors.philips.com/acrobat/datasheets/PCF8563-04.pdf 11 * 12 * This program is free software; you can redistribute it and/or modify 13 * it under the terms of the GNU General Public License version 2 as 14 * published by the Free Software Foundation. 15 */ 16 17 #include <linux/i2c.h> 18 #include <linux/bcd.h> 19 #include <linux/rtc.h> 20 21 #define DRV_VERSION "0.4.2" 22 23 /* Addresses to scan: none 24 * This chip cannot be reliably autodetected. An empty eeprom 25 * located at 0x51 will pass the validation routine due to 26 * the way the registers are implemented. 27 */ 28 static unsigned short normal_i2c[] = { I2C_CLIENT_END }; 29 30 /* Module parameters */ 31 I2C_CLIENT_INSMOD; 32 33 #define PCF8563_REG_ST1 0x00 /* status */ 34 #define PCF8563_REG_ST2 0x01 35 36 #define PCF8563_REG_SC 0x02 /* datetime */ 37 #define PCF8563_REG_MN 0x03 38 #define PCF8563_REG_HR 0x04 39 #define PCF8563_REG_DM 0x05 40 #define PCF8563_REG_DW 0x06 41 #define PCF8563_REG_MO 0x07 42 #define PCF8563_REG_YR 0x08 43 44 #define PCF8563_REG_AMN 0x09 /* alarm */ 45 #define PCF8563_REG_AHR 0x0A 46 #define PCF8563_REG_ADM 0x0B 47 #define PCF8563_REG_ADW 0x0C 48 49 #define PCF8563_REG_CLKO 0x0D /* clock out */ 50 #define PCF8563_REG_TMRC 0x0E /* timer control */ 51 #define PCF8563_REG_TMR 0x0F /* timer */ 52 53 #define PCF8563_SC_LV 0x80 /* low voltage */ 54 #define PCF8563_MO_C 0x80 /* century */ 55 56 static int pcf8563_probe(struct i2c_adapter *adapter, int address, int kind); 57 static int pcf8563_detach(struct i2c_client *client); 58 59 /* 60 * In the routines that deal directly with the pcf8563 hardware, we use 61 * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch. 62 */ 63 static int pcf8563_get_datetime(struct i2c_client *client, struct rtc_time *tm) 64 { 65 unsigned char buf[13] = { PCF8563_REG_ST1 }; 66 67 struct i2c_msg msgs[] = { 68 { client->addr, 0, 1, buf }, /* setup read ptr */ 69 { client->addr, I2C_M_RD, 13, buf }, /* read status + date */ 70 }; 71 72 /* read registers */ 73 if ((i2c_transfer(client->adapter, msgs, 2)) != 2) { 74 dev_err(&client->dev, "%s: read error\n", __FUNCTION__); 75 return -EIO; 76 } 77 78 if (buf[PCF8563_REG_SC] & PCF8563_SC_LV) 79 dev_info(&client->dev, 80 "low voltage detected, date/time is not reliable.\n"); 81 82 dev_dbg(&client->dev, 83 "%s: raw data is st1=%02x, st2=%02x, sec=%02x, min=%02x, hr=%02x, " 84 "mday=%02x, wday=%02x, mon=%02x, year=%02x\n", 85 __FUNCTION__, 86 buf[0], buf[1], buf[2], buf[3], 87 buf[4], buf[5], buf[6], buf[7], 88 buf[8]); 89 90 91 tm->tm_sec = BCD2BIN(buf[PCF8563_REG_SC] & 0x7F); 92 tm->tm_min = BCD2BIN(buf[PCF8563_REG_MN] & 0x7F); 93 tm->tm_hour = BCD2BIN(buf[PCF8563_REG_HR] & 0x3F); /* rtc hr 0-23 */ 94 tm->tm_mday = BCD2BIN(buf[PCF8563_REG_DM] & 0x3F); 95 tm->tm_wday = buf[PCF8563_REG_DW] & 0x07; 96 tm->tm_mon = BCD2BIN(buf[PCF8563_REG_MO] & 0x1F) - 1; /* rtc mn 1-12 */ 97 tm->tm_year = BCD2BIN(buf[PCF8563_REG_YR]) 98 + (buf[PCF8563_REG_MO] & PCF8563_MO_C ? 100 : 0); 99 100 dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, " 101 "mday=%d, mon=%d, year=%d, wday=%d\n", 102 __FUNCTION__, 103 tm->tm_sec, tm->tm_min, tm->tm_hour, 104 tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday); 105 106 /* the clock can give out invalid datetime, but we cannot return 107 * -EINVAL otherwise hwclock will refuse to set the time on bootup. 108 */ 109 if (rtc_valid_tm(tm) < 0) 110 dev_err(&client->dev, "retrieved date/time is not valid.\n"); 111 112 return 0; 113 } 114 115 static int pcf8563_set_datetime(struct i2c_client *client, struct rtc_time *tm) 116 { 117 int i, err; 118 unsigned char buf[9]; 119 120 dev_dbg(&client->dev, "%s: secs=%d, mins=%d, hours=%d, " 121 "mday=%d, mon=%d, year=%d, wday=%d\n", 122 __FUNCTION__, 123 tm->tm_sec, tm->tm_min, tm->tm_hour, 124 tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday); 125 126 /* hours, minutes and seconds */ 127 buf[PCF8563_REG_SC] = BIN2BCD(tm->tm_sec); 128 buf[PCF8563_REG_MN] = BIN2BCD(tm->tm_min); 129 buf[PCF8563_REG_HR] = BIN2BCD(tm->tm_hour); 130 131 buf[PCF8563_REG_DM] = BIN2BCD(tm->tm_mday); 132 133 /* month, 1 - 12 */ 134 buf[PCF8563_REG_MO] = BIN2BCD(tm->tm_mon + 1); 135 136 /* year and century */ 137 buf[PCF8563_REG_YR] = BIN2BCD(tm->tm_year % 100); 138 if (tm->tm_year / 100) 139 buf[PCF8563_REG_MO] |= PCF8563_MO_C; 140 141 buf[PCF8563_REG_DW] = tm->tm_wday & 0x07; 142 143 /* write register's data */ 144 for (i = 0; i < 7; i++) { 145 unsigned char data[2] = { PCF8563_REG_SC + i, 146 buf[PCF8563_REG_SC + i] }; 147 148 err = i2c_master_send(client, data, sizeof(data)); 149 if (err != sizeof(data)) { 150 dev_err(&client->dev, 151 "%s: err=%d addr=%02x, data=%02x\n", 152 __FUNCTION__, err, data[0], data[1]); 153 return -EIO; 154 } 155 }; 156 157 return 0; 158 } 159 160 struct pcf8563_limit 161 { 162 unsigned char reg; 163 unsigned char mask; 164 unsigned char min; 165 unsigned char max; 166 }; 167 168 static int pcf8563_validate_client(struct i2c_client *client) 169 { 170 int i; 171 172 static const struct pcf8563_limit pattern[] = { 173 /* register, mask, min, max */ 174 { PCF8563_REG_SC, 0x7F, 0, 59 }, 175 { PCF8563_REG_MN, 0x7F, 0, 59 }, 176 { PCF8563_REG_HR, 0x3F, 0, 23 }, 177 { PCF8563_REG_DM, 0x3F, 0, 31 }, 178 { PCF8563_REG_MO, 0x1F, 0, 12 }, 179 }; 180 181 /* check limits (only registers with bcd values) */ 182 for (i = 0; i < ARRAY_SIZE(pattern); i++) { 183 int xfer; 184 unsigned char value; 185 unsigned char buf = pattern[i].reg; 186 187 struct i2c_msg msgs[] = { 188 { client->addr, 0, 1, &buf }, 189 { client->addr, I2C_M_RD, 1, &buf }, 190 }; 191 192 xfer = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs)); 193 194 if (xfer != ARRAY_SIZE(msgs)) { 195 dev_err(&client->adapter->dev, 196 "%s: could not read register 0x%02X\n", 197 __FUNCTION__, pattern[i].reg); 198 199 return -EIO; 200 } 201 202 value = BCD2BIN(buf & pattern[i].mask); 203 204 if (value > pattern[i].max || 205 value < pattern[i].min) { 206 dev_dbg(&client->adapter->dev, 207 "%s: pattern=%d, reg=%x, mask=0x%02x, min=%d, " 208 "max=%d, value=%d, raw=0x%02X\n", 209 __FUNCTION__, i, pattern[i].reg, pattern[i].mask, 210 pattern[i].min, pattern[i].max, 211 value, buf); 212 213 return -ENODEV; 214 } 215 } 216 217 return 0; 218 } 219 220 static int pcf8563_rtc_read_time(struct device *dev, struct rtc_time *tm) 221 { 222 return pcf8563_get_datetime(to_i2c_client(dev), tm); 223 } 224 225 static int pcf8563_rtc_set_time(struct device *dev, struct rtc_time *tm) 226 { 227 return pcf8563_set_datetime(to_i2c_client(dev), tm); 228 } 229 230 static int pcf8563_rtc_proc(struct device *dev, struct seq_file *seq) 231 { 232 seq_printf(seq, "24hr\t\t: yes\n"); 233 return 0; 234 } 235 236 static struct rtc_class_ops pcf8563_rtc_ops = { 237 .proc = pcf8563_rtc_proc, 238 .read_time = pcf8563_rtc_read_time, 239 .set_time = pcf8563_rtc_set_time, 240 }; 241 242 static int pcf8563_attach(struct i2c_adapter *adapter) 243 { 244 return i2c_probe(adapter, &addr_data, pcf8563_probe); 245 } 246 247 static struct i2c_driver pcf8563_driver = { 248 .driver = { 249 .name = "pcf8563", 250 }, 251 .id = I2C_DRIVERID_PCF8563, 252 .attach_adapter = &pcf8563_attach, 253 .detach_client = &pcf8563_detach, 254 }; 255 256 static int pcf8563_probe(struct i2c_adapter *adapter, int address, int kind) 257 { 258 struct i2c_client *client; 259 struct rtc_device *rtc; 260 261 int err = 0; 262 263 dev_dbg(&adapter->dev, "%s\n", __FUNCTION__); 264 265 if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) { 266 err = -ENODEV; 267 goto exit; 268 } 269 270 if (!(client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL))) { 271 err = -ENOMEM; 272 goto exit; 273 } 274 275 client->addr = address; 276 client->driver = &pcf8563_driver; 277 client->adapter = adapter; 278 279 strlcpy(client->name, pcf8563_driver.driver.name, I2C_NAME_SIZE); 280 281 /* Verify the chip is really an PCF8563 */ 282 if (kind < 0) { 283 if (pcf8563_validate_client(client) < 0) { 284 err = -ENODEV; 285 goto exit_kfree; 286 } 287 } 288 289 /* Inform the i2c layer */ 290 if ((err = i2c_attach_client(client))) 291 goto exit_kfree; 292 293 dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n"); 294 295 rtc = rtc_device_register(pcf8563_driver.driver.name, &client->dev, 296 &pcf8563_rtc_ops, THIS_MODULE); 297 298 if (IS_ERR(rtc)) { 299 err = PTR_ERR(rtc); 300 dev_err(&client->dev, 301 "unable to register the class device\n"); 302 goto exit_detach; 303 } 304 305 i2c_set_clientdata(client, rtc); 306 307 return 0; 308 309 exit_detach: 310 i2c_detach_client(client); 311 312 exit_kfree: 313 kfree(client); 314 315 exit: 316 return err; 317 } 318 319 static int pcf8563_detach(struct i2c_client *client) 320 { 321 int err; 322 struct rtc_device *rtc = i2c_get_clientdata(client); 323 324 dev_dbg(&client->dev, "%s\n", __FUNCTION__); 325 326 if (rtc) 327 rtc_device_unregister(rtc); 328 329 if ((err = i2c_detach_client(client))) 330 return err; 331 332 kfree(client); 333 334 return 0; 335 } 336 337 static int __init pcf8563_init(void) 338 { 339 return i2c_add_driver(&pcf8563_driver); 340 } 341 342 static void __exit pcf8563_exit(void) 343 { 344 i2c_del_driver(&pcf8563_driver); 345 } 346 347 MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>"); 348 MODULE_DESCRIPTION("Philips PCF8563/Epson RTC8564 RTC driver"); 349 MODULE_LICENSE("GPL"); 350 MODULE_VERSION(DRV_VERSION); 351 352 module_init(pcf8563_init); 353 module_exit(pcf8563_exit); 354