1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Raspberry Pi driver for firmware controlled clocks
4  *
5  * Even though clk-bcm2835 provides an interface to the hardware registers for
6  * the system clocks we've had to factor out 'pllb' as the firmware 'owns' it.
7  * We're not allowed to change it directly as we might race with the
8  * over-temperature and under-voltage protections provided by the firmware.
9  *
10  * Copyright (C) 2019 Nicolas Saenz Julienne <nsaenzjulienne@suse.de>
11  */
12 
13 #include <linux/clkdev.h>
14 #include <linux/clk-provider.h>
15 #include <linux/io.h>
16 #include <linux/module.h>
17 #include <linux/platform_device.h>
18 
19 #include <soc/bcm2835/raspberrypi-firmware.h>
20 
21 enum rpi_firmware_clk_id {
22 	RPI_FIRMWARE_EMMC_CLK_ID = 1,
23 	RPI_FIRMWARE_UART_CLK_ID,
24 	RPI_FIRMWARE_ARM_CLK_ID,
25 	RPI_FIRMWARE_CORE_CLK_ID,
26 	RPI_FIRMWARE_V3D_CLK_ID,
27 	RPI_FIRMWARE_H264_CLK_ID,
28 	RPI_FIRMWARE_ISP_CLK_ID,
29 	RPI_FIRMWARE_SDRAM_CLK_ID,
30 	RPI_FIRMWARE_PIXEL_CLK_ID,
31 	RPI_FIRMWARE_PWM_CLK_ID,
32 	RPI_FIRMWARE_HEVC_CLK_ID,
33 	RPI_FIRMWARE_EMMC2_CLK_ID,
34 	RPI_FIRMWARE_M2MC_CLK_ID,
35 	RPI_FIRMWARE_PIXEL_BVB_CLK_ID,
36 	RPI_FIRMWARE_NUM_CLK_ID,
37 };
38 
39 static char *rpi_firmware_clk_names[] = {
40 	[RPI_FIRMWARE_EMMC_CLK_ID]	= "emmc",
41 	[RPI_FIRMWARE_UART_CLK_ID]	= "uart",
42 	[RPI_FIRMWARE_ARM_CLK_ID]	= "arm",
43 	[RPI_FIRMWARE_CORE_CLK_ID]	= "core",
44 	[RPI_FIRMWARE_V3D_CLK_ID]	= "v3d",
45 	[RPI_FIRMWARE_H264_CLK_ID]	= "h264",
46 	[RPI_FIRMWARE_ISP_CLK_ID]	= "isp",
47 	[RPI_FIRMWARE_SDRAM_CLK_ID]	= "sdram",
48 	[RPI_FIRMWARE_PIXEL_CLK_ID]	= "pixel",
49 	[RPI_FIRMWARE_PWM_CLK_ID]	= "pwm",
50 	[RPI_FIRMWARE_HEVC_CLK_ID]	= "hevc",
51 	[RPI_FIRMWARE_EMMC2_CLK_ID]	= "emmc2",
52 	[RPI_FIRMWARE_M2MC_CLK_ID]	= "m2mc",
53 	[RPI_FIRMWARE_PIXEL_BVB_CLK_ID]	= "pixel-bvb",
54 };
55 
56 #define RPI_FIRMWARE_STATE_ENABLE_BIT	BIT(0)
57 #define RPI_FIRMWARE_STATE_WAIT_BIT	BIT(1)
58 
59 struct raspberrypi_clk {
60 	struct device *dev;
61 	struct rpi_firmware *firmware;
62 	struct platform_device *cpufreq;
63 };
64 
65 struct raspberrypi_clk_data {
66 	struct clk_hw hw;
67 
68 	unsigned int id;
69 
70 	struct raspberrypi_clk *rpi;
71 };
72 
73 /*
74  * Structure of the message passed to Raspberry Pi's firmware in order to
75  * change clock rates. The 'disable_turbo' option is only available to the ARM
76  * clock (pllb) which we enable by default as turbo mode will alter multiple
77  * clocks at once.
78  *
79  * Even though we're able to access the clock registers directly we're bound to
80  * use the firmware interface as the firmware ultimately takes care of
81  * mitigating overheating/undervoltage situations and we would be changing
82  * frequencies behind his back.
83  *
84  * For more information on the firmware interface check:
85  * https://github.com/raspberrypi/firmware/wiki/Mailbox-property-interface
86  */
87 struct raspberrypi_firmware_prop {
88 	__le32 id;
89 	__le32 val;
90 	__le32 disable_turbo;
91 } __packed;
92 
93 static int raspberrypi_clock_property(struct rpi_firmware *firmware,
94 				      const struct raspberrypi_clk_data *data,
95 				      u32 tag, u32 *val)
96 {
97 	struct raspberrypi_firmware_prop msg = {
98 		.id = cpu_to_le32(data->id),
99 		.val = cpu_to_le32(*val),
100 		.disable_turbo = cpu_to_le32(1),
101 	};
102 	int ret;
103 
104 	ret = rpi_firmware_property(firmware, tag, &msg, sizeof(msg));
105 	if (ret)
106 		return ret;
107 
108 	*val = le32_to_cpu(msg.val);
109 
110 	return 0;
111 }
112 
113 static int raspberrypi_fw_is_prepared(struct clk_hw *hw)
114 {
115 	struct raspberrypi_clk_data *data =
116 		container_of(hw, struct raspberrypi_clk_data, hw);
117 	struct raspberrypi_clk *rpi = data->rpi;
118 	u32 val = 0;
119 	int ret;
120 
121 	ret = raspberrypi_clock_property(rpi->firmware, data,
122 					 RPI_FIRMWARE_GET_CLOCK_STATE, &val);
123 	if (ret)
124 		return 0;
125 
126 	return !!(val & RPI_FIRMWARE_STATE_ENABLE_BIT);
127 }
128 
129 
130 static unsigned long raspberrypi_fw_get_rate(struct clk_hw *hw,
131 					     unsigned long parent_rate)
132 {
133 	struct raspberrypi_clk_data *data =
134 		container_of(hw, struct raspberrypi_clk_data, hw);
135 	struct raspberrypi_clk *rpi = data->rpi;
136 	u32 val = 0;
137 	int ret;
138 
139 	ret = raspberrypi_clock_property(rpi->firmware, data,
140 					 RPI_FIRMWARE_GET_CLOCK_RATE, &val);
141 	if (ret)
142 		return ret;
143 
144 	return val;
145 }
146 
147 static int raspberrypi_fw_set_rate(struct clk_hw *hw, unsigned long rate,
148 				   unsigned long parent_rate)
149 {
150 	struct raspberrypi_clk_data *data =
151 		container_of(hw, struct raspberrypi_clk_data, hw);
152 	struct raspberrypi_clk *rpi = data->rpi;
153 	u32 _rate = rate;
154 	int ret;
155 
156 	ret = raspberrypi_clock_property(rpi->firmware, data,
157 					 RPI_FIRMWARE_SET_CLOCK_RATE, &_rate);
158 	if (ret)
159 		dev_err_ratelimited(rpi->dev, "Failed to change %s frequency: %d",
160 				    clk_hw_get_name(hw), ret);
161 
162 	return ret;
163 }
164 
165 static int raspberrypi_fw_dumb_determine_rate(struct clk_hw *hw,
166 					      struct clk_rate_request *req)
167 {
168 	/*
169 	 * The firmware will do the rounding but that isn't part of
170 	 * the interface with the firmware, so we just do our best
171 	 * here.
172 	 */
173 	req->rate = clamp(req->rate, req->min_rate, req->max_rate);
174 	return 0;
175 }
176 
177 static const struct clk_ops raspberrypi_firmware_clk_ops = {
178 	.is_prepared	= raspberrypi_fw_is_prepared,
179 	.recalc_rate	= raspberrypi_fw_get_rate,
180 	.determine_rate	= raspberrypi_fw_dumb_determine_rate,
181 	.set_rate	= raspberrypi_fw_set_rate,
182 };
183 
184 static struct clk_hw *raspberrypi_clk_register(struct raspberrypi_clk *rpi,
185 					       unsigned int parent,
186 					       unsigned int id)
187 {
188 	struct raspberrypi_clk_data *data;
189 	struct clk_init_data init = {};
190 	u32 min_rate, max_rate;
191 	int ret;
192 
193 	data = devm_kzalloc(rpi->dev, sizeof(*data), GFP_KERNEL);
194 	if (!data)
195 		return ERR_PTR(-ENOMEM);
196 	data->rpi = rpi;
197 	data->id = id;
198 
199 	init.name = devm_kasprintf(rpi->dev, GFP_KERNEL,
200 				   "fw-clk-%s",
201 				   rpi_firmware_clk_names[id]);
202 	init.ops = &raspberrypi_firmware_clk_ops;
203 	init.flags = CLK_GET_RATE_NOCACHE;
204 
205 	data->hw.init = &init;
206 
207 	ret = raspberrypi_clock_property(rpi->firmware, data,
208 					 RPI_FIRMWARE_GET_MIN_CLOCK_RATE,
209 					 &min_rate);
210 	if (ret) {
211 		dev_err(rpi->dev, "Failed to get clock %d min freq: %d",
212 			id, ret);
213 		return ERR_PTR(ret);
214 	}
215 
216 	ret = raspberrypi_clock_property(rpi->firmware, data,
217 					 RPI_FIRMWARE_GET_MAX_CLOCK_RATE,
218 					 &max_rate);
219 	if (ret) {
220 		dev_err(rpi->dev, "Failed to get clock %d max freq: %d\n",
221 			id, ret);
222 		return ERR_PTR(ret);
223 	}
224 
225 	ret = devm_clk_hw_register(rpi->dev, &data->hw);
226 	if (ret)
227 		return ERR_PTR(ret);
228 
229 	clk_hw_set_rate_range(&data->hw, min_rate, max_rate);
230 
231 	if (id == RPI_FIRMWARE_ARM_CLK_ID) {
232 		ret = devm_clk_hw_register_clkdev(rpi->dev, &data->hw,
233 						  NULL, "cpu0");
234 		if (ret) {
235 			dev_err(rpi->dev, "Failed to initialize clkdev\n");
236 			return ERR_PTR(ret);
237 		}
238 	}
239 
240 	return &data->hw;
241 }
242 
243 struct rpi_firmware_get_clocks_response {
244 	u32 parent;
245 	u32 id;
246 };
247 
248 static int raspberrypi_discover_clocks(struct raspberrypi_clk *rpi,
249 				       struct clk_hw_onecell_data *data)
250 {
251 	struct rpi_firmware_get_clocks_response *clks;
252 	int ret;
253 
254 	clks = devm_kcalloc(rpi->dev,
255 			    sizeof(*clks), RPI_FIRMWARE_NUM_CLK_ID,
256 			    GFP_KERNEL);
257 	if (!clks)
258 		return -ENOMEM;
259 
260 	ret = rpi_firmware_property(rpi->firmware, RPI_FIRMWARE_GET_CLOCKS,
261 				    clks,
262 				    sizeof(*clks) * RPI_FIRMWARE_NUM_CLK_ID);
263 	if (ret)
264 		return ret;
265 
266 	while (clks->id) {
267 		struct clk_hw *hw;
268 
269 		switch (clks->id) {
270 		case RPI_FIRMWARE_ARM_CLK_ID:
271 		case RPI_FIRMWARE_CORE_CLK_ID:
272 		case RPI_FIRMWARE_M2MC_CLK_ID:
273 		case RPI_FIRMWARE_V3D_CLK_ID:
274 		case RPI_FIRMWARE_PIXEL_BVB_CLK_ID:
275 			hw = raspberrypi_clk_register(rpi, clks->parent,
276 						      clks->id);
277 			if (IS_ERR(hw))
278 				return PTR_ERR(hw);
279 
280 			data->hws[clks->id] = hw;
281 			data->num = clks->id + 1;
282 			fallthrough;
283 
284 		default:
285 			clks++;
286 			break;
287 		}
288 	}
289 
290 	return 0;
291 }
292 
293 static int raspberrypi_clk_probe(struct platform_device *pdev)
294 {
295 	struct clk_hw_onecell_data *clk_data;
296 	struct device_node *firmware_node;
297 	struct device *dev = &pdev->dev;
298 	struct rpi_firmware *firmware;
299 	struct raspberrypi_clk *rpi;
300 	int ret;
301 
302 	/*
303 	 * We can be probed either through the an old-fashioned
304 	 * platform device registration or through a DT node that is a
305 	 * child of the firmware node. Handle both cases.
306 	 */
307 	if (dev->of_node)
308 		firmware_node = of_get_parent(dev->of_node);
309 	else
310 		firmware_node = of_find_compatible_node(NULL, NULL,
311 							"raspberrypi,bcm2835-firmware");
312 	if (!firmware_node) {
313 		dev_err(dev, "Missing firmware node\n");
314 		return -ENOENT;
315 	}
316 
317 	firmware = devm_rpi_firmware_get(&pdev->dev, firmware_node);
318 	of_node_put(firmware_node);
319 	if (!firmware)
320 		return -EPROBE_DEFER;
321 
322 	rpi = devm_kzalloc(dev, sizeof(*rpi), GFP_KERNEL);
323 	if (!rpi)
324 		return -ENOMEM;
325 
326 	rpi->dev = dev;
327 	rpi->firmware = firmware;
328 	platform_set_drvdata(pdev, rpi);
329 
330 	clk_data = devm_kzalloc(dev, struct_size(clk_data, hws,
331 						 RPI_FIRMWARE_NUM_CLK_ID),
332 				GFP_KERNEL);
333 	if (!clk_data)
334 		return -ENOMEM;
335 
336 	ret = raspberrypi_discover_clocks(rpi, clk_data);
337 	if (ret)
338 		return ret;
339 
340 	ret = devm_of_clk_add_hw_provider(dev, of_clk_hw_onecell_get,
341 					  clk_data);
342 	if (ret)
343 		return ret;
344 
345 	rpi->cpufreq = platform_device_register_data(dev, "raspberrypi-cpufreq",
346 						     -1, NULL, 0);
347 
348 	return 0;
349 }
350 
351 static int raspberrypi_clk_remove(struct platform_device *pdev)
352 {
353 	struct raspberrypi_clk *rpi = platform_get_drvdata(pdev);
354 
355 	platform_device_unregister(rpi->cpufreq);
356 
357 	return 0;
358 }
359 
360 static const struct of_device_id raspberrypi_clk_match[] = {
361 	{ .compatible = "raspberrypi,firmware-clocks" },
362 	{ },
363 };
364 MODULE_DEVICE_TABLE(of, raspberrypi_clk_match);
365 
366 static struct platform_driver raspberrypi_clk_driver = {
367 	.driver = {
368 		.name = "raspberrypi-clk",
369 		.of_match_table = raspberrypi_clk_match,
370 	},
371 	.probe          = raspberrypi_clk_probe,
372 	.remove		= raspberrypi_clk_remove,
373 };
374 module_platform_driver(raspberrypi_clk_driver);
375 
376 MODULE_AUTHOR("Nicolas Saenz Julienne <nsaenzjulienne@suse.de>");
377 MODULE_DESCRIPTION("Raspberry Pi firmware clock driver");
378 MODULE_LICENSE("GPL");
379 MODULE_ALIAS("platform:raspberrypi-clk");
380