1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2009 Nathan Whitehorn
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 ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24 * 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 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
31
32 #include <sys/param.h>
33 #include <sys/systm.h>
34 #include <sys/bus.h>
35 #include <sys/cpu.h>
36 #include <sys/kernel.h>
37 #include <sys/module.h>
38
39 #include "cpufreq_if.h"
40
41 struct dfs_softc {
42 device_t dev;
43 int dfs4;
44 };
45
46 static void dfs_identify(driver_t *driver, device_t parent);
47 static int dfs_probe(device_t dev);
48 static int dfs_attach(device_t dev);
49 static int dfs_settings(device_t dev, struct cf_setting *sets, int *count);
50 static int dfs_set(device_t dev, const struct cf_setting *set);
51 static int dfs_get(device_t dev, struct cf_setting *set);
52 static int dfs_type(device_t dev, int *type);
53
54 static device_method_t dfs_methods[] = {
55 /* Device interface */
56 DEVMETHOD(device_identify, dfs_identify),
57 DEVMETHOD(device_probe, dfs_probe),
58 DEVMETHOD(device_attach, dfs_attach),
59
60 /* cpufreq interface */
61 DEVMETHOD(cpufreq_drv_set, dfs_set),
62 DEVMETHOD(cpufreq_drv_get, dfs_get),
63 DEVMETHOD(cpufreq_drv_type, dfs_type),
64 DEVMETHOD(cpufreq_drv_settings, dfs_settings),
65 {0, 0}
66 };
67
68 static driver_t dfs_driver = {
69 "dfs",
70 dfs_methods,
71 sizeof(struct dfs_softc)
72 };
73
74 static devclass_t dfs_devclass;
75 DRIVER_MODULE(dfs, cpu, dfs_driver, dfs_devclass, 0, 0);
76
77 /*
78 * Bits of the HID1 register to enable DFS. See page 2-24 of "MPC7450
79 * RISC Microprocessor Family Reference Manual", rev. 5.
80 */
81
82 #define HID1_DFS2 (1UL << 22)
83 #define HID1_DFS4 (1UL << 23)
84
85 static void
dfs_identify(driver_t * driver,device_t parent)86 dfs_identify(driver_t *driver, device_t parent)
87 {
88 uint16_t vers;
89 vers = mfpvr() >> 16;
90
91 /* Check for an MPC 7447A or 7448 CPU */
92 switch (vers) {
93 case MPC7447A:
94 case MPC7448:
95 break;
96 default:
97 return;
98 }
99
100 /* Make sure we're not being doubly invoked. */
101 if (device_find_child(parent, "dfs", -1) != NULL)
102 return;
103
104 /*
105 * We attach a child for every CPU since settings need to
106 * be performed on every CPU in the SMP case.
107 */
108 if (BUS_ADD_CHILD(parent, 10, "dfs", -1) == NULL)
109 device_printf(parent, "add dfs child failed\n");
110 }
111
112 static int
dfs_probe(device_t dev)113 dfs_probe(device_t dev)
114 {
115 if (resource_disabled("dfs", 0))
116 return (ENXIO);
117
118 device_set_desc(dev, "Dynamic Frequency Switching");
119 return (0);
120 }
121
122 static int
dfs_attach(device_t dev)123 dfs_attach(device_t dev)
124 {
125 struct dfs_softc *sc;
126 uint16_t vers;
127
128 sc = device_get_softc(dev);
129 sc->dev = dev;
130 sc->dfs4 = 0;
131 vers = mfpvr() >> 16;
132
133 /* The 7448 supports divide-by-four as well */
134 if (vers == MPC7448)
135 sc->dfs4 = 1;
136
137 cpufreq_register(dev);
138 return (0);
139 }
140
141 static int
dfs_settings(device_t dev,struct cf_setting * sets,int * count)142 dfs_settings(device_t dev, struct cf_setting *sets, int *count)
143 {
144 struct dfs_softc *sc;
145 int states;
146
147 sc = device_get_softc(dev);
148 states = sc->dfs4 ? 3 : 2;
149 if (sets == NULL || count == NULL)
150 return (EINVAL);
151 if (*count < states)
152 return (E2BIG);
153
154 /* Return a list of valid settings for this driver. */
155 memset(sets, CPUFREQ_VAL_UNKNOWN, sizeof(*sets) * states);
156
157 sets[0].freq = 10000; sets[0].dev = dev;
158 sets[1].freq = 5000; sets[1].dev = dev;
159 if (sc->dfs4) {
160 sets[2].freq = 2500;
161 sets[2].dev = dev;
162 }
163 *count = states;
164
165 return (0);
166 }
167
168 static int
dfs_set(device_t dev,const struct cf_setting * set)169 dfs_set(device_t dev, const struct cf_setting *set)
170 {
171 register_t hid1;
172
173 if (set == NULL)
174 return (EINVAL);
175
176 hid1 = mfspr(SPR_HID1);
177 hid1 &= ~(HID1_DFS2 | HID1_DFS4);
178
179 if (set->freq == 5000)
180 hid1 |= HID1_DFS2;
181 else if (set->freq == 2500)
182 hid1 |= HID1_DFS4;
183
184 /*
185 * Now set the HID1 register with new values. Calling sequence
186 * taken from page 2-26 of the MPC7450 family CPU manual.
187 */
188
189 powerpc_sync();
190 mtspr(SPR_HID1, hid1);
191 powerpc_sync(); isync();
192
193 return (0);
194 }
195
196 static int
dfs_get(device_t dev,struct cf_setting * set)197 dfs_get(device_t dev, struct cf_setting *set)
198 {
199 struct dfs_softc *sc;
200 register_t hid1;
201
202 if (set == NULL)
203 return (EINVAL);
204 sc = device_get_softc(dev);
205
206 memset(set, CPUFREQ_VAL_UNKNOWN, sizeof(*set));
207
208 hid1 = mfspr(SPR_HID1);
209
210 set->freq = 10000;
211 if (hid1 & HID1_DFS2)
212 set->freq = 5000;
213 else if (sc->dfs4 && (hid1 & HID1_DFS4))
214 set->freq = 2500;
215
216 set->dev = dev;
217
218 return (0);
219 }
220
221 static int
dfs_type(device_t dev,int * type)222 dfs_type(device_t dev, int *type)
223 {
224
225 if (type == NULL)
226 return (EINVAL);
227
228 *type = CPUFREQ_TYPE_RELATIVE;
229 return (0);
230 }
231