 @@ -1,14 +1,14 @@
-/* $NetBSD: r2025.c,v 1.9 2020/01/02 17:03:05 thorpej Exp $ */
+/* $NetBSD: r2025.c,v 1.10 2020/01/02 19:00:34 thorpej Exp $ */
 /*-
  * Copyright (c) 2006 Shigeyuki Fukushima.
  * All rights reserved.
+ *
  * Written by Shigeyuki Fukushima.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above
 @@ -23,27 +23,27 @@
  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: r2025.c,v 1.9 2020/01/02 17:03:05 thorpej Exp $");
+__KERNEL_RCSID(0, "$NetBSD: r2025.c,v 1.10 2020/01/02 19:00:34 thorpej Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/device.h>
 #include <sys/kernel.h>
 #include <sys/fcntl.h>
 #include <sys/uio.h>
 #include <sys/conf.h>
 #include <sys/event.h>
 #include <dev/clock_subr.h>
 #include <dev/i2c/i2cvar.h>
 @@ -53,28 +53,30 @@ struct r2025rtc_softc {
 	device_t		sc_dev;
 	i2c_tag_t		sc_tag;
 	int			sc_address;
 	int			sc_open;
 	struct todr_chip_handle	sc_todr;
 };
 static void	r2025rtc_attach(device_t, device_t, void *);
 static int	r2025rtc_match(device_t, cfdata_t, void *);
 CFATTACH_DECL_NEW(r2025rtc, sizeof(struct r2025rtc_softc),
 	r2025rtc_match, r2025rtc_attach, NULL, NULL);
-static int	r2025rtc_gettime(struct todr_chip_handle *, struct timeval *);
+static int	r2025rtc_gettime_ymdhms(struct todr_chip_handle *,
-static int	r2025rtc_settime(struct todr_chip_handle *, struct timeval *);
+					struct clock_ymdhms *);
 static int	r2025rtc_settime_ymdhms(struct todr_chip_handle *,
 					struct clock_ymdhms *);
 static int	r2025rtc_reg_write(struct r2025rtc_softc *, int, uint8_t*, int);
 static int	r2025rtc_reg_read(struct r2025rtc_softc *, int, uint8_t*, int);
 static int
 r2025rtc_match(device_t parent, cfdata_t cf, void *arg)
+{
 	struct i2c_attach_args *ia = arg;
 	/* match only R2025 RTC devices */
 	if (ia->ia_addr == R2025_ADDR)
 		return I2C_MATCH_ADDRESS_ONLY;
 @@ -84,121 +86,116 @@ r2025rtc_match(device_t parent, cfdata_t
 static void
 r2025rtc_attach(device_t parent, device_t self, void *arg)
+{
 	struct r2025rtc_softc *sc = device_private(self);
 	struct i2c_attach_args *ia = arg;
 	aprint_normal(": RICOH R2025S/D Real-time Clock\n");
 	sc->sc_tag = ia->ia_tag;
 	sc->sc_address = ia->ia_addr;
 	sc->sc_dev = self;
 	sc->sc_open = 0;
 	sc->sc_todr.cookie = sc;
-	sc->sc_todr.todr_gettime = r2025rtc_gettime;
+	sc->sc_todr.todr_gettime = NULL;
-	sc->sc_todr.todr_settime = r2025rtc_settime;
+	sc->sc_todr.todr_settime = NULL;
 	sc->sc_todr.todr_gettime_ymdhms = r2025rtc_gettime_ymdhms;
 	sc->sc_todr.todr_settime_ymdhms = r2025rtc_settime_ymdhms;
 	sc->sc_todr.todr_setwen = NULL;
 	todr_attach(&sc->sc_todr);
+}
 static int
-r2025rtc_gettime(struct todr_chip_handle *ch, struct timeval *tv)
+r2025rtc_gettime_ymdhms(struct todr_chip_handle *ch, struct clock_ymdhms *dt)
+{
 	struct r2025rtc_softc *sc = ch->cookie;
 	struct clock_ymdhms dt;
 	uint8_t rctrl;
 	uint8_t bcd[R2025_CLK_SIZE];
 	int hour;
 	int error;
-	memset(&dt, 0, sizeof(dt));
+	memset(dt, 0, sizeof(*dt));
 	if ((error = r2025rtc_reg_read(sc, R2025_REG_CTRL1, &rctrl, 1)) != 0) {
 		aprint_error_dev(sc->sc_dev,
 		    "r2025rtc_gettime: failed to read registers.\n");
 		return error;
+	}
 	if ((error = r2025rtc_reg_read(sc, R2025_REG_SEC, &bcd[0],
 				       R2025_CLK_SIZE)) != 0) {
 		aprint_error_dev(sc->sc_dev,
 		    "r2025rtc_gettime: failed to read registers.\n");
 		return error;
+	}
-	dt.dt_sec = bcdtobin(bcd[R2025_REG_SEC] & R2025_REG_SEC_MASK);
+	dt->dt_sec = bcdtobin(bcd[R2025_REG_SEC] & R2025_REG_SEC_MASK);
-	dt.dt_min = bcdtobin(bcd[R2025_REG_MIN] & R2025_REG_MIN_MASK);
+	dt->dt_min = bcdtobin(bcd[R2025_REG_MIN] & R2025_REG_MIN_MASK);
 	hour = bcdtobin(bcd[R2025_REG_HOUR] & R2025_REG_HOUR_MASK);
 	if (rctrl & R2025_REG_CTRL1_H1224) {
-		dt.dt_hour = hour;
+		dt->dt_hour = hour;
 	} else {
 		if (hour == 12) {
-			dt.dt_hour = 0;
+			dt->dt_hour = 0;
 		} else if (hour == 32) {
-			dt.dt_hour = 12;
+			dt->dt_hour = 12;
 		} else if (hour > 13) {
-			dt.dt_hour = (hour - 8);
+			dt->dt_hour = (hour - 8);
 		} else { /* (hour < 12) */
-			dt.dt_hour = hour;
+			dt->dt_hour = hour;
+		}
+	}
-	dt.dt_wday = bcdtobin(bcd[R2025_REG_WDAY] & R2025_REG_WDAY_MASK);
+	dt->dt_wday = bcdtobin(bcd[R2025_REG_WDAY] & R2025_REG_WDAY_MASK);
-	dt.dt_day = bcdtobin(bcd[R2025_REG_DAY] & R2025_REG_DAY_MASK);
+	dt->dt_day = bcdtobin(bcd[R2025_REG_DAY] & R2025_REG_DAY_MASK);
-	dt.dt_mon = bcdtobin(bcd[R2025_REG_MON] & R2025_REG_MON_MASK);
+	dt->dt_mon = bcdtobin(bcd[R2025_REG_MON] & R2025_REG_MON_MASK);
-	dt.dt_year = bcdtobin(bcd[R2025_REG_YEAR] & R2025_REG_YEAR_MASK)
+	dt->dt_year = bcdtobin(bcd[R2025_REG_YEAR] & R2025_REG_YEAR_MASK)
 		+ ((bcd[R2025_REG_MON] & R2025_REG_MON_Y1920) ? 2000 : 1900);
 	tv->tv_sec = clock_ymdhms_to_secs(&dt);
 	tv->tv_usec = 0;
 	return 0;
+}
 static int
-r2025rtc_settime(struct todr_chip_handle *ch, struct timeval *tv)
+r2025rtc_settime_ymdhms(struct todr_chip_handle *ch, struct clock_ymdhms *dt)
+{
 	struct r2025rtc_softc *sc = ch->cookie;
 	struct clock_ymdhms dt;
 	uint8_t rctrl;
 	uint8_t bcd[R2025_CLK_SIZE];
 	int error;
 	clock_secs_to_ymdhms(tv->tv_sec, &dt);
 	/* Y3K problem */
-	if (dt.dt_year >= 3000) {
+	if (dt->dt_year >= 3000) {
 		aprint_error_dev(sc->sc_dev,
 		    "r2025rtc_settime: "
 		    "RTC does not support year 3000 or over.\n");
 		return EINVAL;
+	}
 	if ((error = r2025rtc_reg_read(sc, R2025_REG_CTRL1, &rctrl, 1)) != 0) {
 		aprint_error_dev(sc->sc_dev,
 		    "r2025rtc_settime: failed to read register.\n");
 		return error;
+	}
 	rctrl |= R2025_REG_CTRL1_H1224;
 	/* setup registers 0x00-0x06 (7 byte) */
-	bcd[R2025_REG_SEC] = bintobcd(dt.dt_sec) & R2025_REG_SEC_MASK;
+	bcd[R2025_REG_SEC] = bintobcd(dt->dt_sec) & R2025_REG_SEC_MASK;
-	bcd[R2025_REG_MIN] = bintobcd(dt.dt_min) & R2025_REG_MIN_MASK;
+	bcd[R2025_REG_MIN] = bintobcd(dt->dt_min) & R2025_REG_MIN_MASK;
-	bcd[R2025_REG_HOUR] = bintobcd(dt.dt_hour) & R2025_REG_HOUR_MASK;
+	bcd[R2025_REG_HOUR] = bintobcd(dt->dt_hour) & R2025_REG_HOUR_MASK;
-	bcd[R2025_REG_WDAY] = bintobcd(dt.dt_wday) & R2025_REG_WDAY_MASK;
+	bcd[R2025_REG_WDAY] = bintobcd(dt->dt_wday) & R2025_REG_WDAY_MASK;
-	bcd[R2025_REG_DAY] = bintobcd(dt.dt_day) & R2025_REG_DAY_MASK;
+	bcd[R2025_REG_DAY] = bintobcd(dt->dt_day) & R2025_REG_DAY_MASK;
-	bcd[R2025_REG_MON] = (bintobcd(dt.dt_mon) & R2025_REG_MON_MASK)
+	bcd[R2025_REG_MON] = (bintobcd(dt->dt_mon) & R2025_REG_MON_MASK)
-		| ((dt.dt_year >= 2000) ? R2025_REG_MON_Y1920 : 0);
+		| ((dt->dt_year >= 2000) ? R2025_REG_MON_Y1920 : 0);
-	bcd[R2025_REG_YEAR] = bintobcd(dt.dt_year % 100) & R2025_REG_YEAR_MASK;
+	bcd[R2025_REG_YEAR] = bintobcd(dt->dt_year % 100) & R2025_REG_YEAR_MASK;
 	/* Write RTC register */
 	if ((error = r2025rtc_reg_write(sc, R2025_REG_CTRL1, &rctrl, 1)) != 0) {
 		aprint_error_dev(sc->sc_dev,
 		    "r2025rtc_settime: failed to write registers.\n");
 		return error;
+	}
 	if ((error = r2025rtc_reg_write(sc, R2025_REG_SEC, bcd,
 					R2025_CLK_SIZE)) != 0) {
 		aprint_error_dev(sc->sc_dev,
 		    "r2025rtc_settime: failed to write registers.\n");
 		return error;
+	}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: s390.c,v 1.5 2020/01/02 17:26:37 thorpej Exp $	*/
+/*	$NetBSD: s390.c,v 1.6 2020/01/02 19:00:34 thorpej Exp $	*/
 /*-
  * Copyright (c) 2011 Frank Wille.
  * All rights reserved.
+ *
  * Written by Frank Wille for The NetBSD Project.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
 @@ -19,55 +19,55 @@
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: s390.c,v 1.5 2020/01/02 17:26:37 thorpej Exp $");
+__KERNEL_RCSID(0, "$NetBSD: s390.c,v 1.6 2020/01/02 19:00:34 thorpej Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/device.h>
 #include <sys/conf.h>
 #include <dev/clock_subr.h>
 #include <dev/i2c/i2cvar.h>
 #include <dev/i2c/s390reg.h>
 struct s390rtc_softc {
 	device_t sc_dev;
 	i2c_tag_t sc_tag;
 	i2c_addr_t sc_addr;
 	struct todr_chip_handle sc_todr;
 };
 static int s390rtc_match(device_t, cfdata_t, void *);
 static void s390rtc_attach(device_t, device_t, void *);
 CFATTACH_DECL_NEW(s390rtc, sizeof(struct s390rtc_softc),
     s390rtc_match, s390rtc_attach, NULL, NULL);
-static int s390rtc_gettime(struct todr_chip_handle *, struct timeval *);
+static int s390rtc_gettime_ymdhms(struct todr_chip_handle *,
-static int s390rtc_settime(struct todr_chip_handle *, struct timeval *);
+				  struct clock_ymdhms *);
-static int s390rtc_clock_read(struct s390rtc_softc *, struct clock_ymdhms *);
+static int s390rtc_settime_ymdhms(struct todr_chip_handle *,
-static int s390rtc_clock_write(struct s390rtc_softc *, struct clock_ymdhms *);
+				  struct clock_ymdhms *);
 static int s390rtc_read(struct s390rtc_softc *, int, uint8_t *, size_t);
 static int s390rtc_write(struct s390rtc_softc *, int, uint8_t *, size_t);
 static uint8_t bitreverse(uint8_t);
 static int
 s390rtc_match(device_t parent, cfdata_t cf, void *arg)
+{
 	struct i2c_attach_args *ia = arg;
 	int match_result;
 	if (iic_use_direct_match(ia, cf, NULL, &match_result))
 		return match_result;
 @@ -101,91 +101,62 @@ s390rtc_attach(device_t parent, device_t
 			return;
+	}
 	/* Disable the test mode, when enabled. */
 	if (s390rtc_read(sc, S390_STATUS2, reg, sizeof(reg)))
 		return;
 	if ((reg[0] & S390_ST2_TEST)) {
 		reg[0] &= ~S390_ST2_TEST;
 		if (s390rtc_write(sc, S390_STATUS2, reg, sizeof(reg)))
 			return;
+	}
 	sc->sc_todr.cookie = sc;
-	sc->sc_todr.todr_gettime = s390rtc_gettime;
+	sc->sc_todr.todr_gettime = NULL;
-	sc->sc_todr.todr_settime = s390rtc_settime;
+	sc->sc_todr.todr_settime = NULL;
 	sc->sc_todr.todr_gettime_ymdhms = s390rtc_gettime_ymdhms;
 	sc->sc_todr.todr_settime_ymdhms = s390rtc_settime_ymdhms;
 	sc->sc_todr.todr_setwen = NULL;
 	todr_attach(&sc->sc_todr);
+}
 static int
-s390rtc_gettime(struct todr_chip_handle *ch, struct timeval *tv)
+s390rtc_gettime_ymdhms(struct todr_chip_handle *ch, struct clock_ymdhms *dt)
+{
 	struct s390rtc_softc *sc = ch->cookie;
 	struct clock_ymdhms dt;
 	int error;
 	memset(&dt, 0, sizeof(dt));
 	if ((error = s390rtc_clock_read(sc, &dt)) != 0)
 		return error;
 	tv->tv_sec = clock_ymdhms_to_secs(&dt);
 	tv->tv_usec = 0;
 	return 0;
 static int
 s390rtc_settime(struct todr_chip_handle *ch, struct timeval *tv)
 	struct s390rtc_softc *sc = ch->cookie;
 	struct clock_ymdhms dt;
 	int error;
 	clock_secs_to_ymdhms(tv->tv_sec, &dt);
 	if ((error = s390rtc_clock_write(sc, &dt)) != 0)
 		return error;
 	return 0;
 static int
 s390rtc_clock_read(struct s390rtc_softc *sc, struct clock_ymdhms *dt)
 	uint8_t bcd[S390_RT1_NBYTES];
 	int error;
 	if ((error = s390rtc_read(sc, S390_REALTIME1, bcd,
 				  S390_RT1_NBYTES)) != 0)
 		return error;
 	/*
 	 * Convert the register values into something useable.
 	 */
 	dt->dt_sec = bcdtobin(bcd[S390_RT1_SECOND]);
 	dt->dt_min = bcdtobin(bcd[S390_RT1_MINUTE]);
 	dt->dt_hour = bcdtobin(bcd[S390_RT1_HOUR] & 0x3f);
 	dt->dt_day = bcdtobin(bcd[S390_RT1_DAY]);
 	dt->dt_mon = bcdtobin(bcd[S390_RT1_MONTH]);
 	dt->dt_year = bcdtobin(bcd[S390_RT1_YEAR]) + 2000;
 	return 0;
+}
 static int
-s390rtc_clock_write(struct s390rtc_softc *sc, struct clock_ymdhms *dt)
+s390rtc_settime_ymdhms(struct todr_chip_handle *ch, struct clock_ymdhms *dt)
+{
 	struct s390rtc_softc *sc = ch->cookie;
 	uint8_t bcd[S390_RT1_NBYTES];
 	/*
 	 * Convert our time representation into something the S-xx390
 	 * can understand.
 	 */
 	bcd[S390_RT1_SECOND] = bintobcd(dt->dt_sec);
 	bcd[S390_RT1_MINUTE] = bintobcd(dt->dt_min);
 	bcd[S390_RT1_HOUR] = bintobcd(dt->dt_hour);
 	bcd[S390_RT1_DAY] = bintobcd(dt->dt_day);
 	bcd[S390_RT1_WDAY] = bintobcd(dt->dt_wday);
 	bcd[S390_RT1_MONTH] = bintobcd(dt->dt_mon);
 	bcd[S390_RT1_YEAR] = bintobcd(dt->dt_year % 100);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: x1226.c,v 1.22 2020/01/02 17:40:27 thorpej Exp $	*/
+/*	$NetBSD: x1226.c,v 1.23 2020/01/02 19:00:34 thorpej Exp $	*/
 /*
  * Copyright (c) 2003 Shigeyuki Fukushima.
  * All rights reserved.
+ *
  * Written by Shigeyuki Fukushima for the NetBSD Project.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
 @@ -26,27 +26,27 @@
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL SHIGEYUKI FUKUSHIMA
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: x1226.c,v 1.22 2020/01/02 17:40:27 thorpej Exp $");
+__KERNEL_RCSID(0, "$NetBSD: x1226.c,v 1.23 2020/01/02 19:00:34 thorpej Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/device.h>
 #include <sys/kernel.h>
 #include <sys/fcntl.h>
 #include <sys/uio.h>
 #include <sys/conf.h>
 #include <sys/event.h>
 #include <dev/clock_subr.h>
 #include <dev/i2c/i2cvar.h>
 @@ -79,29 +79,30 @@ const struct cdevsw xrtc_cdevsw = {
 	.d_read = xrtc_read,
 	.d_write = xrtc_write,
 	.d_ioctl = noioctl,
 	.d_stop = nostop,
 	.d_tty = notty,
 	.d_poll = nopoll,
 	.d_mmap = nommap,
 	.d_kqfilter = nokqfilter,
 	.d_discard = nodiscard,
 	.d_flag = D_OTHER
 };
 static int xrtc_clock_read(struct xrtc_softc *, struct clock_ymdhms *);
-static int xrtc_clock_write(struct xrtc_softc *, struct clock_ymdhms *);
+static int xrtc_gettime_ymdhms(struct todr_chip_handle *,
-static int xrtc_gettime(struct todr_chip_handle *, struct timeval *);
+			       struct clock_ymdhms *);
-static int xrtc_settime(struct todr_chip_handle *, struct timeval *);
+static int xrtc_settime_ymdhms(struct todr_chip_handle *,
 			       struct clock_ymdhms *);
 /*
  * xrtc_match()
  */
 static int
 xrtc_match(device_t parent, cfdata_t cf, void *arg)
+{
 	struct i2c_attach_args *ia = arg;
 	/* match only this RTC devices */
 	if (ia->ia_addr == X1226_ADDR)
 		return (I2C_MATCH_ADDRESS_ONLY);
 @@ -115,28 +116,30 @@ static void
 xrtc_attach(device_t parent, device_t self, void *arg)
+{
 	struct xrtc_softc *sc = device_private(self);
 	struct i2c_attach_args *ia = arg;
 	aprint_naive(": Real-time Clock/NVRAM\n");
 	aprint_normal(": Xicor X1226 Real-time Clock/NVRAM\n");
 	sc->sc_tag = ia->ia_tag;
 	sc->sc_address = ia->ia_addr;
 	sc->sc_dev = self;
 	sc->sc_open = 0;
 	sc->sc_todr.cookie = sc;
-	sc->sc_todr.todr_gettime = xrtc_gettime;
+	sc->sc_todr.todr_gettime = NULL;
-	sc->sc_todr.todr_settime = xrtc_settime;
+	sc->sc_todr.todr_settime = NULL;
 	sc->sc_todr.todr_gettime_ymdhms = xrtc_gettime_ymdhms;
 	sc->sc_todr.todr_settime_ymdhms = xrtc_settime_ymdhms;
 	sc->sc_todr.todr_setwen = NULL;
 	todr_attach(&sc->sc_todr);
+}
 /*ARGSUSED*/
 int
 xrtc_open(dev_t dev, int flag, int fmt, struct lwp *l)
+{
 	struct xrtc_softc *sc;
 	if ((sc = device_lookup_private(&xrtc_cd, minor(dev))) == NULL)
 @@ -237,62 +240,48 @@ xrtc_write(dev_t dev, struct uio *uio, i
 			    "xrtc_write: write failed at 0x%x\n",
 				(int)uio->uio_offset);
 			return (error);
+		}
+	}
 	iic_release_bus(sc->sc_tag, 0);
 	return (0);
+}
 static int
-xrtc_gettime(struct todr_chip_handle *ch, struct timeval *tv)
+xrtc_gettime_ymdhms(struct todr_chip_handle *ch, struct clock_ymdhms *dt)
+{
 	struct xrtc_softc *sc = ch->cookie;
-	struct clock_ymdhms dt, check;
+	struct clock_ymdhms check;
 	int retries;
 	int error;
-	memset(&dt, 0, sizeof(dt));
+	memset(dt, 0, sizeof(*dt));
 	memset(&check, 0, sizeof(check));
 	retries = 5;
 	do {
-		if ((error = xrtc_clock_read(sc, &dt)) == 0)
+		if ((error = xrtc_clock_read(sc, dt)) == 0)
 			error = xrtc_clock_read(sc, &check);
 		if (error)
 			return error;
-	} while (memcmp(&dt, &check, sizeof(check)) != 0 && --retries);
+	} while (memcmp(dt, &check, sizeof(check)) != 0 && --retries);
 	tv->tv_sec = clock_ymdhms_to_secs(&dt);
 	tv->tv_usec = 0;
 	return (0);
+}
 static int
 xrtc_settime(struct todr_chip_handle *ch, struct timeval *tv)
 	struct xrtc_softc *sc = ch->cookie;
 	struct clock_ymdhms dt;
 	clock_secs_to_ymdhms(tv->tv_sec, &dt);
 	return xrtc_clock_write(sc, &dt);
 static int
 xrtc_clock_read(struct xrtc_softc *sc, struct clock_ymdhms *dt)
+{
 	int i = 0;
 	u_int8_t bcd[X1226_REG_RTC_SIZE], cmdbuf[2];
 	int error;
 	if ((error = iic_acquire_bus(sc->sc_tag, 0)) != 0) {
 		aprint_error_dev(sc->sc_dev,
 		    "xrtc_clock_read: failed to acquire I2C bus\n");
 		return (error);
+	}
 	/* Read each RTC register in order */
 @@ -338,28 +327,29 @@ xrtc_clock_read(struct xrtc_softc *sc, s
 	dt->dt_day = bcdtobin(bcd[X1226_REG_DT - X1226_REG_RTC_BASE]
 			& X1226_REG_DT_MASK);
 	dt->dt_mon = bcdtobin(bcd[X1226_REG_MO - X1226_REG_RTC_BASE]
 			& X1226_REG_MO_MASK);
 	dt->dt_year = bcdtobin(bcd[X1226_REG_YR - X1226_REG_RTC_BASE]
 			& X1226_REG_YR_MASK);
 	dt->dt_year += bcdtobin(bcd[X1226_REG_Y2K - X1226_REG_RTC_BASE]
 			& X1226_REG_Y2K_MASK) * 100;
 	return (0);
+}
 static int
-xrtc_clock_write(struct xrtc_softc *sc, struct clock_ymdhms *dt)
+xrtc_settime_ymdhms(struct todr_chip_handle *ch, struct clock_ymdhms *dt)
+{
 	struct xrtc_softc *sc = ch->cookie;
 	int i = 0, addr;
 	u_int8_t bcd[X1226_REG_RTC_SIZE], cmdbuf[3];
 	int error, error2;
 	/*
 	 * Convert our time to bcd values
 	 */
 	bcd[X1226_REG_SC - X1226_REG_RTC_BASE] = bintobcd(dt->dt_sec);
 	bcd[X1226_REG_MN - X1226_REG_RTC_BASE] = bintobcd(dt->dt_min);
 	bcd[X1226_REG_HR - X1226_REG_RTC_BASE] = bintobcd(dt->dt_hour)
 						| X1226_FLAG_HR_24H;
 	bcd[X1226_REG_DW - X1226_REG_RTC_BASE] = bintobcd(dt->dt_wday);
 	bcd[X1226_REG_DT - X1226_REG_RTC_BASE] = bintobcd(dt->dt_day);