1 /* $NetBSD: mcclock.c,v 1.23 2024/03/06 07:34:11 thorpej Exp $ */
2
3 /*-
4 * Copyright (c) 2024 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Jason R. Thorpe.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 /*
33 * Copyright (c) 1994, 1995, 1996 Carnegie-Mellon University.
34 * All rights reserved.
35 *
36 * Author: Chris G. Demetriou
37 *
38 * Permission to use, copy, modify and distribute this software and
39 * its documentation is hereby granted, provided that both the copyright
40 * notice and this permission notice appear in all copies of the
41 * software, derivative works or modified versions, and any portions
42 * thereof, and that both notices appear in supporting documentation.
43 *
44 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
45 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
46 * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
47 *
48 * Carnegie Mellon requests users of this software to return to
49 *
50 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
51 * School of Computer Science
52 * Carnegie Mellon University
53 * Pittsburgh PA 15213-3890
54 *
55 * any improvements or extensions that they make and grant Carnegie the
56 * rights to redistribute these changes.
57 */
58
59 #include <sys/cdefs.h> /* RCS ID & Copyright macro defns */
60
61 __KERNEL_RCSID(0, "$NetBSD: mcclock.c,v 1.23 2024/03/06 07:34:11 thorpej Exp $");
62
63 #include "opt_clock_compat_osf1.h"
64 #include "opt_multiprocessor.h"
65
66 #include <sys/param.h>
67 #include <sys/bus.h>
68 #include <sys/cpu.h>
69 #include <sys/device.h>
70 #include <sys/kernel.h>
71 #include <sys/lwp.h>
72 #include <sys/systm.h>
73 #if defined(MULTIPROCESSOR)
74 #include <sys/xcall.h>
75 #endif
76
77 #include <machine/cpu_counter.h>
78
79 #include <dev/clock_subr.h>
80
81 #include <dev/ic/mc146818reg.h>
82 #include <dev/ic/mc146818var.h>
83
84 #include <alpha/alpha/mcclockvar.h>
85 #include <alpha/alpha/clockvar.h>
86
87 #ifdef CLOCK_COMPAT_OSF1
88 /*
89 * According to OSF/1's /usr/sys/include/arch/alpha/clock.h,
90 * the console adjusts the RTC years 13..19 to 93..99 and
91 * 20..40 to 00..20. (historical reasons?)
92 * DEC Unix uses an offset to the year to stay outside
93 * the dangerous area for the next couple of years.
94 */
95 #define UNIX_YEAR_OFFSET 52 /* 41=>1993, 12=>2064 */
96 #else
97 #define UNIX_YEAR_OFFSET 0
98 #endif
99
100 static void mcclock_set_pcc_freq(struct mc146818_softc *);
101 static void mcclock_init(void *);
102
103 #if defined(MULTIPROCESSOR)
104 struct mcclock_trampoline_arg {
105 todr_chip_handle_t handle; /* IN */
106 struct clock_ymdhms *dt; /* IN */
107 int rv; /* OUT */
108 };
109
110 static void
mcclock_trampoline(void * arg1,void * arg2)111 mcclock_trampoline(void *arg1, void *arg2)
112 {
113 int (*func)(todr_chip_handle_t, struct clock_ymdhms *) = arg1;
114 struct mcclock_trampoline_arg *arg = arg2;
115
116 arg->rv = (*func)(arg->handle, arg->dt);
117 }
118
119 static int
mcclock_bounce(int (* func)(todr_chip_handle_t,struct clock_ymdhms *),struct mcclock_trampoline_arg * arg)120 mcclock_bounce(int (*func)(todr_chip_handle_t, struct clock_ymdhms *),
121 struct mcclock_trampoline_arg *arg)
122 {
123 /*
124 * If we're not on the primary CPU, then we need to make
125 * a cross-call to the primary to access the clock registers.
126 * But we do a little work to avoid even calling into the
127 * cross-call code if we can avoid it.
128 */
129 int bound = curlwp_bind();
130
131 if (CPU_IS_PRIMARY(curcpu())) {
132 mcclock_trampoline(func, arg);
133 curlwp_bindx(bound);
134 } else {
135 curlwp_bindx(bound);
136 uint64_t token = xc_unicast(0, mcclock_trampoline,
137 func, arg, &cpu_info_primary);
138 xc_wait(token);
139 }
140 return arg->rv;
141 }
142
143 static int
mcclock_gettime_ymdhms(todr_chip_handle_t handle,struct clock_ymdhms * dt)144 mcclock_gettime_ymdhms(todr_chip_handle_t handle, struct clock_ymdhms *dt)
145 {
146 struct mcclock_trampoline_arg arg = {
147 .handle = handle,
148 .dt = dt,
149 };
150
151 return mcclock_bounce(mc146818_gettime_ymdhms, &arg);
152 }
153
154 static int
mcclock_settime_ymdhms(todr_chip_handle_t handle,struct clock_ymdhms * dt)155 mcclock_settime_ymdhms(todr_chip_handle_t handle, struct clock_ymdhms *dt)
156 {
157 struct mcclock_trampoline_arg arg = {
158 .handle = handle,
159 .dt = dt,
160 };
161
162 return mcclock_bounce(mc146818_settime_ymdhms, &arg);
163 }
164 #endif /* MULTIPROCESSOR */
165
166 void
mcclock_attach(struct mcclock_softc * msc)167 mcclock_attach(struct mcclock_softc *msc)
168 {
169 struct mc146818_softc *sc = &msc->sc_mc146818;
170
171 KASSERT(cold);
172 KASSERT(CPU_IS_PRIMARY(curcpu()));
173
174 sc->sc_year0 = 1900 + UNIX_YEAR_OFFSET;
175 sc->sc_flag = 0; /* BINARY, 24HR */
176
177 #if defined(MULTIPROCESSOR)
178 /*
179 * Because some Alpha systems have clocks that can only be
180 * accessed by the primary CPU, we need to wrap the mc146818
181 * gettime/settime routines if we have such a clock.
182 */
183 if (msc->sc_primary_only) {
184 sc->sc_handle.todr_gettime_ymdhms = mcclock_gettime_ymdhms;
185 sc->sc_handle.todr_settime_ymdhms = mcclock_settime_ymdhms;
186 }
187 #endif
188
189 mc146818_attach(sc);
190
191 aprint_normal("\n");
192
193 /* Turn interrupts off, just in case. */
194 (*sc->sc_mcwrite)(sc, MC_REGB, MC_REGB_BINARY | MC_REGB_24HR);
195
196 mcclock_set_pcc_freq(sc);
197
198 clockattach(mcclock_init, (void *)sc);
199 }
200
201 #define NLOOP 4
202
203 static void
mcclock_set_pcc_freq(struct mc146818_softc * sc)204 mcclock_set_pcc_freq(struct mc146818_softc *sc)
205 {
206 struct cpu_info *ci;
207 uint64_t freq;
208 uint32_t ctrdiff[NLOOP], pcc_start, pcc_end;
209 uint8_t reg_a;
210 int i;
211
212 KASSERT(cold);
213 KASSERT(CPU_IS_PRIMARY(curcpu()));
214
215 /* save REG_A */
216 reg_a = (*sc->sc_mcread)(sc, MC_REGA);
217
218 /* set interval 16Hz to measure pcc */
219 (*sc->sc_mcwrite)(sc, MC_REGA, MC_BASE_32_KHz | MC_RATE_16_Hz);
220
221 /* clear interrupt flags */
222 (void)(*sc->sc_mcread)(sc, MC_REGC);
223
224 /* Run the loop an extra time to prime the cache. */
225 for (i = 0; i < NLOOP; i++) {
226
227 /* wait till the periodic interrupt flag is set */
228 while (((*sc->sc_mcread)(sc, MC_REGC) & MC_REGC_PF) == 0)
229 ;
230 pcc_start = cpu_counter32();
231
232 /* wait till the periodic interrupt flag is set again */
233 while (((*sc->sc_mcread)(sc, MC_REGC) & MC_REGC_PF) == 0)
234 ;
235 pcc_end = cpu_counter32();
236
237 ctrdiff[i] = pcc_end - pcc_start;
238 }
239
240 freq = ((ctrdiff[NLOOP - 2] + ctrdiff[NLOOP - 1]) * 16 /* Hz */) / 2;
241
242 /* restore REG_A */
243 (*sc->sc_mcwrite)(sc, MC_REGA, reg_a);
244
245 /* XXX assume all processors have the same clock and frequency */
246 for (ci = &cpu_info_primary; ci; ci = ci->ci_next)
247 ci->ci_pcc_freq = freq;
248 }
249
250 static void
mcclock_init(void * dev)251 mcclock_init(void *dev)
252 {
253 struct mc146818_softc *sc = dev;
254
255 kpreempt_disable();
256
257 /*
258 * The Alpha port calls clock init function is called on each CPU,
259 * but for this clock, we only want to do work on the primary.
260 */
261 if (CPU_IS_PRIMARY(curcpu())) {
262 /* enable interval clock interrupt */
263 (*sc->sc_mcwrite)(sc, MC_REGA,
264 MC_BASE_32_KHz | MC_RATE_1024_Hz);
265 (*sc->sc_mcwrite)(sc, MC_REGB,
266 MC_REGB_PIE | MC_REGB_SQWE | MC_REGB_BINARY | MC_REGB_24HR);
267 }
268
269 kpreempt_enable();
270 }
271