]> CyberLeo.Net >> Repos - FreeBSD/FreeBSD.git/blob - sys/powerpc/mpc85xx/ds1553_core.c
sys/{x86,amd64}: remove one of doubled ;s
[FreeBSD/FreeBSD.git] / sys / powerpc / mpc85xx / ds1553_core.c
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3  *
4  * Copyright (C) 2006-2008 Semihalf, Grzegorz Bernacki
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26  * SUCH DAMAGE.
27  *
28  */
29
30 #include <sys/cdefs.h>
31 __FBSDID("$FreeBSD$");
32
33 #include <sys/param.h>
34 #include <sys/systm.h>
35 #include <sys/bus.h>
36 #include <sys/clock.h>
37 #include <sys/lock.h>
38 #include <sys/mutex.h>
39
40 #include <machine/bus.h>
41
42 #include <powerpc/mpc85xx/ds1553_reg.h>
43
44 static uint8_t ds1553_direct_read(device_t, bus_size_t);
45 static void ds1553_direct_write(device_t, bus_size_t, uint8_t);
46
47 int
48 ds1553_attach(device_t dev)
49 {
50         struct ds1553_softc *sc;
51         uint8_t sec, flags;
52
53         sc = device_get_softc(dev);
54
55         if (mtx_initialized(&sc->sc_mtx) == 0) {
56                 device_printf(dev, "%s: mutex not initialized\n", __func__);
57                 return (ENXIO);
58         }
59
60         if (sc->sc_read == NULL)
61                 sc->sc_read = ds1553_direct_read;
62         if (sc->sc_write == NULL)
63                 sc->sc_write = ds1553_direct_write;
64
65         sc->year_offset = POSIX_BASE_YEAR;
66
67         mtx_lock_spin(&sc->sc_mtx);
68
69         /* Turn RTC on if it was not on */
70         sec = (*sc->sc_read)(dev, DS1553_OFF_SECONDS);
71         if (sec & DS1553_BIT_OSC) {
72                 sec &= ~(DS1553_BIT_OSC);
73                 (*sc->sc_write)(dev, DS1553_OFF_SECONDS, sec);
74         }
75
76         /* Low-battery check */
77         flags = (*sc->sc_read)(dev, DS1553_OFF_FLAGS);
78         if (flags & DS1553_BIT_BLF)
79                 device_printf(dev, "voltage-low detected.\n");
80
81         mtx_unlock_spin(&sc->sc_mtx);
82
83         return (0);
84 }
85
86 /*
87  * Get time of day and convert it to a struct timespec.
88  * Return 0 on success, an error number otherwise.
89  */
90 int
91 ds1553_gettime(device_t dev, struct timespec *ts)
92 {
93         struct clocktime ct;
94         struct ds1553_softc *sc;
95         uint8_t control;
96
97         sc = device_get_softc(dev);
98
99         mtx_lock_spin(&sc->sc_mtx);
100
101         control = (*sc->sc_read)(dev, DS1553_OFF_CONTROL) | DS1553_BIT_READ;
102         (*sc->sc_write)(dev, DS1553_OFF_CONTROL, control);
103
104         ct.nsec = 0;
105         ct.sec = FROMBCD((*sc->sc_read)(dev, DS1553_OFF_SECONDS) &
106             DS1553_MASK_SECONDS);
107         ct.min = FROMBCD((*sc->sc_read)(dev, DS1553_OFF_MINUTES) &
108             DS1553_MASK_MINUTES);
109         ct.hour = FROMBCD((*sc->sc_read)(dev, DS1553_OFF_HOURS) &
110             DS1553_MASK_HOUR);
111         ct.dow = FROMBCD((*sc->sc_read)(dev, DS1553_OFF_DAYOFWEEK) &
112             DS1553_MASK_DAYOFWEEK) - 1;
113         ct.day = FROMBCD((*sc->sc_read)(dev, DS1553_OFF_DATE) &
114             DS1553_MASK_DATE);
115         ct.mon = FROMBCD((*sc->sc_read)(dev, DS1553_OFF_MONTH) &
116             DS1553_MASK_MONTH);
117         ct.year = FROMBCD((*sc->sc_read)(dev, DS1553_OFF_YEAR));
118
119         control &= ~DS1553_BIT_READ;
120         (*sc->sc_write)(dev, DS1553_OFF_CONTROL, control);
121
122         ct.year += sc->year_offset;
123
124         mtx_unlock_spin(&sc->sc_mtx);
125
126         return (clock_ct_to_ts(&ct, ts));
127 }
128
129 /*
130  * Set the time of day clock based on the value of the struct timespec arg.
131  * Return 0 on success, an error number otherwise.
132  */
133 int
134 ds1553_settime(device_t dev, struct timespec *ts)
135 {
136         struct clocktime ct;
137         struct ds1553_softc *sc;
138         uint8_t control;
139
140         sc = device_get_softc(dev);
141         bzero(&ct, sizeof(struct clocktime));
142
143         /* Accuracy is only one second. */
144         if (ts->tv_nsec >= 500000000)
145                 ts->tv_sec++;
146         ts->tv_nsec = 0;
147         clock_ts_to_ct(ts, &ct);
148
149         ct.year -= sc->year_offset;
150
151         mtx_lock_spin(&sc->sc_mtx);
152
153         /* Halt updates to external registers */
154         control = (*sc->sc_read)(dev, DS1553_OFF_CONTROL) | DS1553_BIT_WRITE;
155         (*sc->sc_write)(dev, DS1553_OFF_CONTROL, control);
156
157         (*sc->sc_write)(dev, DS1553_OFF_SECONDS, TOBCD(ct.sec) &
158             DS1553_MASK_SECONDS);
159         (*sc->sc_write)(dev, DS1553_OFF_MINUTES, TOBCD(ct.min) &
160             DS1553_MASK_MINUTES);
161         (*sc->sc_write)(dev, DS1553_OFF_HOURS, TOBCD(ct.hour) &
162             DS1553_MASK_HOUR);
163         (*sc->sc_write)(dev, DS1553_OFF_DAYOFWEEK, TOBCD(ct.dow + 1) &
164             DS1553_MASK_DAYOFWEEK);
165         (*sc->sc_write)(dev, DS1553_OFF_DATE, TOBCD(ct.day) &
166             DS1553_MASK_DATE);
167         (*sc->sc_write)(dev, DS1553_OFF_MONTH, TOBCD(ct.mon) &
168             DS1553_MASK_MONTH);
169         (*sc->sc_write)(dev, DS1553_OFF_YEAR, TOBCD(ct.year));
170
171         /* Resume updates to external registers */
172         control &= ~DS1553_BIT_WRITE;
173         (*sc->sc_write)(dev, DS1553_OFF_CONTROL, control);
174
175         mtx_unlock_spin(&sc->sc_mtx);
176
177         return (0);
178 }
179
180 static uint8_t
181 ds1553_direct_read(device_t dev, bus_size_t off)
182 {
183         struct ds1553_softc *sc;
184
185         sc = device_get_softc(dev);
186         return (bus_space_read_1(sc->sc_bst, sc->sc_bsh, off));
187 }
188
189 static void
190 ds1553_direct_write(device_t dev, bus_size_t off, uint8_t val)
191 {
192         struct ds1553_softc *sc;
193
194         sc = device_get_softc(dev);
195         bus_space_write_1(sc->sc_bst, sc->sc_bsh, off, val);
196 }