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