1 /* $NetBSD: r2025.c,v 1.2 2006/03/29 06:41:24 thorpej Exp $ */ 2 3 /*- 4 * Copyright (c) 2006 Shigeyuki Fukushima. 5 * All rights reserved. 6 * 7 * Written by Shigeyuki Fukushima. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above 15 * copyright notice, this list of conditions and the following 16 * disclaimer in the documentation and/or other materials provided 17 * with the distribution. 18 * 3. The name of the author may not be used to endorse or promote 19 * products derived from this software without specific prior 20 * written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS 23 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 24 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY 26 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 28 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 30 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 31 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 32 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 33 */ 34 35 #include <sys/cdefs.h> 36 __KERNEL_RCSID(0, "$NetBSD: r2025.c,v 1.2 2006/03/29 06:41:24 thorpej Exp $"); 37 38 #include <sys/param.h> 39 #include <sys/systm.h> 40 #include <sys/device.h> 41 #include <sys/kernel.h> 42 #include <sys/fcntl.h> 43 #include <sys/uio.h> 44 #include <sys/conf.h> 45 #include <sys/event.h> 46 47 #include <dev/clock_subr.h> 48 49 #include <dev/i2c/i2cvar.h> 50 #include <dev/i2c/r2025reg.h> 51 52 struct r2025rtc_softc { 53 struct device sc_dev; 54 i2c_tag_t sc_tag; 55 int sc_address; 56 int sc_open; 57 struct todr_chip_handle sc_todr; 58 }; 59 60 static void r2025rtc_attach(struct device *, struct device *, void *); 61 static int r2025rtc_match(struct device *, struct cfdata *, void *); 62 63 CFATTACH_DECL(r2025rtc, sizeof(struct r2025rtc_softc), 64 r2025rtc_match, r2025rtc_attach, NULL, NULL); 65 66 static int r2025rtc_gettime(struct todr_chip_handle *, 67 volatile struct timeval *); 68 static int r2025rtc_settime(struct todr_chip_handle *, 69 volatile struct timeval *); 70 static int r2025rtc_getcal(struct todr_chip_handle *, int *); 71 static int r2025rtc_setcal(struct todr_chip_handle *, int); 72 73 static int r2025rtc_reg_write(struct r2025rtc_softc *, int, uint8_t*, int); 74 static int r2025rtc_reg_read(struct r2025rtc_softc *, int, uint8_t*, int); 75 76 77 static int 78 r2025rtc_match(struct device *parent, struct cfdata *cf, void *arg) 79 { 80 struct i2c_attach_args *ia = arg; 81 82 /* match only R2025 RTC devices */ 83 if (ia->ia_addr == R2025_ADDR) 84 return 1; 85 86 return 0; 87 } 88 89 static void 90 r2025rtc_attach(struct device *parent, struct device *self, void *arg) 91 { 92 struct r2025rtc_softc *sc = device_private(self); 93 struct i2c_attach_args *ia = arg; 94 95 aprint_normal(": RICOH R2025S/D Real-time Clock\n"); 96 97 sc->sc_tag = ia->ia_tag; 98 sc->sc_address = ia->ia_addr; 99 sc->sc_open = 0; 100 sc->sc_todr.cookie = sc; 101 sc->sc_todr.todr_gettime = r2025rtc_gettime; 102 sc->sc_todr.todr_settime = r2025rtc_settime; 103 sc->sc_todr.todr_getcal = r2025rtc_getcal; 104 sc->sc_todr.todr_setcal = r2025rtc_setcal; 105 sc->sc_todr.todr_setwen = NULL; 106 107 todr_attach(&sc->sc_todr); 108 } 109 110 static int 111 r2025rtc_gettime(struct todr_chip_handle *ch, volatile struct timeval *tv) 112 { 113 struct r2025rtc_softc *sc = ch->cookie; 114 struct clock_ymdhms dt; 115 uint8_t rctrl; 116 uint8_t bcd[R2025_CLK_SIZE]; 117 int hour; 118 119 memset(&dt, 0, sizeof(dt)); 120 121 if (r2025rtc_reg_read(sc, R2025_REG_CTRL1, &rctrl, 1) != 0) { 122 printf("%s: r2025rtc_gettime: failed to read registers.\n", 123 sc->sc_dev.dv_xname); 124 return -1; 125 } 126 127 if (r2025rtc_reg_read(sc, R2025_REG_SEC, &bcd[0], R2025_CLK_SIZE) 128 != 0) { 129 printf("%s: r2025rtc_gettime: failed to read registers.\n", 130 sc->sc_dev.dv_xname); 131 return -1; 132 } 133 134 dt.dt_sec = FROMBCD(bcd[R2025_REG_SEC] & R2025_REG_SEC_MASK); 135 dt.dt_min = FROMBCD(bcd[R2025_REG_MIN] & R2025_REG_MIN_MASK); 136 hour = FROMBCD(bcd[R2025_REG_HOUR] & R2025_REG_HOUR_MASK); 137 if (rctrl & R2025_REG_CTRL1_H1224) { 138 dt.dt_hour = hour; 139 } else { 140 if (hour == 12) { 141 dt.dt_hour = 0; 142 } else if (hour == 32) { 143 dt.dt_hour = 12; 144 } else if (hour > 13) { 145 dt.dt_hour = (hour - 8); 146 } else { /* (hour < 12) */ 147 dt.dt_hour = hour; 148 } 149 } 150 dt.dt_wday = FROMBCD(bcd[R2025_REG_WDAY] & R2025_REG_WDAY_MASK); 151 dt.dt_day = FROMBCD(bcd[R2025_REG_DAY] & R2025_REG_DAY_MASK); 152 dt.dt_mon = FROMBCD(bcd[R2025_REG_MON] & R2025_REG_MON_MASK); 153 dt.dt_year = FROMBCD(bcd[R2025_REG_YEAR] & R2025_REG_YEAR_MASK) 154 + ((bcd[R2025_REG_MON] & R2025_REG_MON_Y1920) ? 2000 : 1900); 155 156 tv->tv_sec = clock_ymdhms_to_secs(&dt); 157 tv->tv_usec = 0; 158 159 return 0; 160 } 161 162 static int 163 r2025rtc_settime(struct todr_chip_handle *ch, volatile struct timeval *tv) 164 { 165 struct r2025rtc_softc *sc = ch->cookie; 166 struct clock_ymdhms dt; 167 uint8_t rctrl; 168 uint8_t bcd[R2025_CLK_SIZE]; 169 170 clock_secs_to_ymdhms(tv->tv_sec, &dt); 171 172 /* Y3K problem */ 173 if (dt.dt_year >= 3000) { 174 printf("%s: r2025rtc_settime: " 175 "RTC does not support year 3000 or over.\n", 176 sc->sc_dev.dv_xname); 177 return -1; 178 } 179 180 if (r2025rtc_reg_read(sc, R2025_REG_CTRL1, &rctrl, 1) != 0) { 181 printf("%s: r2025rtc_settime: failed to read register.\n", 182 sc->sc_dev.dv_xname); 183 return -1; 184 } 185 rctrl |= R2025_REG_CTRL1_H1224; 186 187 /* setup registers 0x00-0x06 (7 byte) */ 188 bcd[R2025_REG_SEC] = TOBCD(dt.dt_sec) & R2025_REG_SEC_MASK; 189 bcd[R2025_REG_MIN] = TOBCD(dt.dt_min) & R2025_REG_MIN_MASK; 190 bcd[R2025_REG_HOUR] = TOBCD(dt.dt_hour) & R2025_REG_HOUR_MASK; 191 bcd[R2025_REG_WDAY] = TOBCD(dt.dt_wday) & R2025_REG_WDAY_MASK; 192 bcd[R2025_REG_DAY] = TOBCD(dt.dt_day) & R2025_REG_DAY_MASK; 193 bcd[R2025_REG_MON] = (TOBCD(dt.dt_mon) & R2025_REG_MON_MASK) 194 | ((dt.dt_year >= 2000) ? R2025_REG_MON_Y1920 : 0); 195 bcd[R2025_REG_YEAR] = TOBCD(dt.dt_year % 100) & R2025_REG_YEAR_MASK; 196 197 /* Write RTC register */ 198 if (r2025rtc_reg_write(sc, R2025_REG_CTRL1, &rctrl, 1) != 0) { 199 printf("%s: r2025rtc_settime: failed to write registers.\n", 200 sc->sc_dev.dv_xname); 201 return -1; 202 } 203 if (r2025rtc_reg_write(sc, R2025_REG_SEC, bcd, R2025_CLK_SIZE) != 0) { 204 printf("%s: r2025rtc_settime: failed to write registers.\n", 205 sc->sc_dev.dv_xname); 206 return -1; 207 } 208 209 return 0; 210 } 211 212 static int 213 r2025rtc_setcal(struct todr_chip_handle *ch, int cal) 214 { 215 return EOPNOTSUPP; 216 } 217 218 static int 219 r2025rtc_getcal(struct todr_chip_handle *ch, int *cal) 220 { 221 return EOPNOTSUPP; 222 } 223 224 static int 225 r2025rtc_reg_write(struct r2025rtc_softc *sc, int reg, uint8_t *val, int len) 226 { 227 int i; 228 uint8_t buf[1]; 229 uint8_t cmdbuf[1]; 230 231 if (iic_acquire_bus(sc->sc_tag, I2C_F_POLL)) { 232 printf("%s: r2025rtc_clock_write: failed to acquire I2C bus\n", 233 sc->sc_dev.dv_xname); 234 return -1; 235 } 236 237 for (i = 0 ; i < len ; i++) { 238 cmdbuf[0] = (((reg + i) << 4) & 0xf0); 239 buf[0] = val[i]; 240 if (iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP, sc->sc_address, 241 cmdbuf, 1, buf, 1, I2C_F_POLL)) { 242 iic_release_bus(sc->sc_tag, I2C_F_POLL); 243 printf("%s: r2025rtc_reg_write: " 244 "failed to write registers\n", 245 sc->sc_dev.dv_xname); 246 return -1; 247 } 248 } 249 250 iic_release_bus(sc->sc_tag, I2C_F_POLL); 251 252 return 0; 253 } 254 255 static int 256 r2025rtc_reg_read(struct r2025rtc_softc *sc, int reg, uint8_t *val, int len) 257 { 258 int i; 259 uint8_t buf[1]; 260 uint8_t cmdbuf[1]; 261 262 if (iic_acquire_bus(sc->sc_tag, I2C_F_POLL)) { 263 printf("%s: r2025rtc_clock_read: failed to acquire I2C bus\n", 264 sc->sc_dev.dv_xname); 265 return -1; 266 } 267 268 for (i = 0 ; i < len ; i++) { 269 cmdbuf[0] = (((reg + i) << 4) & 0xf0); 270 buf[0] = 0; 271 if (iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP, sc->sc_address, 272 cmdbuf, 1, buf, 1, I2C_F_POLL)) { 273 iic_release_bus(sc->sc_tag, I2C_F_POLL); 274 printf("%s: r2025rtc_reg_read: " 275 "failed to write registers\n", 276 sc->sc_dev.dv_xname); 277 return -1; 278 } 279 280 *(val + i) = buf[0]; 281 } 282 283 iic_release_bus(sc->sc_tag, I2C_F_POLL); 284 285 return 0; 286 } 287