1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Defines interfaces for interacting with the Raspberry Pi firmware's 4 * property channel. 5 * 6 * Copyright © 2015 Broadcom 7 */ 8 9 #include <linux/dma-mapping.h> 10 #include <linux/kref.h> 11 #include <linux/mailbox_client.h> 12 #include <linux/mailbox_controller.h> 13 #include <linux/module.h> 14 #include <linux/of.h> 15 #include <linux/of_platform.h> 16 #include <linux/platform_device.h> 17 #include <linux/slab.h> 18 #include <soc/bcm2835/raspberrypi-firmware.h> 19 20 #define MBOX_MSG(chan, data28) (((data28) & ~0xf) | ((chan) & 0xf)) 21 #define MBOX_CHAN(msg) ((msg) & 0xf) 22 #define MBOX_DATA28(msg) ((msg) & ~0xf) 23 #define MBOX_CHAN_PROPERTY 8 24 25 static struct platform_device *rpi_hwmon; 26 static struct platform_device *rpi_clk; 27 28 struct rpi_firmware { 29 struct mbox_client cl; 30 struct mbox_chan *chan; /* The property channel. */ 31 struct completion c; 32 u32 enabled; 33 34 struct kref consumers; 35 }; 36 37 static DEFINE_MUTEX(transaction_lock); 38 39 static void response_callback(struct mbox_client *cl, void *msg) 40 { 41 struct rpi_firmware *fw = container_of(cl, struct rpi_firmware, cl); 42 complete(&fw->c); 43 } 44 45 /* 46 * Sends a request to the firmware through the BCM2835 mailbox driver, 47 * and synchronously waits for the reply. 48 */ 49 static int 50 rpi_firmware_transaction(struct rpi_firmware *fw, u32 chan, u32 data) 51 { 52 u32 message = MBOX_MSG(chan, data); 53 int ret; 54 55 WARN_ON(data & 0xf); 56 57 mutex_lock(&transaction_lock); 58 reinit_completion(&fw->c); 59 ret = mbox_send_message(fw->chan, &message); 60 if (ret >= 0) { 61 if (wait_for_completion_timeout(&fw->c, HZ)) { 62 ret = 0; 63 } else { 64 ret = -ETIMEDOUT; 65 WARN_ONCE(1, "Firmware transaction timeout"); 66 } 67 } else { 68 dev_err(fw->cl.dev, "mbox_send_message returned %d\n", ret); 69 } 70 mutex_unlock(&transaction_lock); 71 72 return ret; 73 } 74 75 /** 76 * rpi_firmware_property_list - Submit firmware property list 77 * @fw: Pointer to firmware structure from rpi_firmware_get(). 78 * @data: Buffer holding tags. 79 * @tag_size: Size of tags buffer. 80 * 81 * Submits a set of concatenated tags to the VPU firmware through the 82 * mailbox property interface. 83 * 84 * The buffer header and the ending tag are added by this function and 85 * don't need to be supplied, just the actual tags for your operation. 86 * See struct rpi_firmware_property_tag_header for the per-tag 87 * structure. 88 */ 89 int rpi_firmware_property_list(struct rpi_firmware *fw, 90 void *data, size_t tag_size) 91 { 92 size_t size = tag_size + 12; 93 u32 *buf; 94 dma_addr_t bus_addr; 95 int ret; 96 97 /* Packets are processed a dword at a time. */ 98 if (size & 3) 99 return -EINVAL; 100 101 buf = dma_alloc_coherent(fw->chan->mbox->dev, PAGE_ALIGN(size), 102 &bus_addr, GFP_ATOMIC); 103 if (!buf) 104 return -ENOMEM; 105 106 /* The firmware will error out without parsing in this case. */ 107 WARN_ON(size >= 1024 * 1024); 108 109 buf[0] = size; 110 buf[1] = RPI_FIRMWARE_STATUS_REQUEST; 111 memcpy(&buf[2], data, tag_size); 112 buf[size / 4 - 1] = RPI_FIRMWARE_PROPERTY_END; 113 wmb(); 114 115 ret = rpi_firmware_transaction(fw, MBOX_CHAN_PROPERTY, bus_addr); 116 117 rmb(); 118 memcpy(data, &buf[2], tag_size); 119 if (ret == 0 && buf[1] != RPI_FIRMWARE_STATUS_SUCCESS) { 120 /* 121 * The tag name here might not be the one causing the 122 * error, if there were multiple tags in the request. 123 * But single-tag is the most common, so go with it. 124 */ 125 dev_err(fw->cl.dev, "Request 0x%08x returned status 0x%08x\n", 126 buf[2], buf[1]); 127 ret = -EINVAL; 128 } 129 130 dma_free_coherent(fw->chan->mbox->dev, PAGE_ALIGN(size), buf, bus_addr); 131 132 return ret; 133 } 134 EXPORT_SYMBOL_GPL(rpi_firmware_property_list); 135 136 /** 137 * rpi_firmware_property - Submit single firmware property 138 * @fw: Pointer to firmware structure from rpi_firmware_get(). 139 * @tag: One of enum_mbox_property_tag. 140 * @tag_data: Tag data buffer. 141 * @buf_size: Buffer size. 142 * 143 * Submits a single tag to the VPU firmware through the mailbox 144 * property interface. 145 * 146 * This is a convenience wrapper around 147 * rpi_firmware_property_list() to avoid some of the 148 * boilerplate in property calls. 149 */ 150 int rpi_firmware_property(struct rpi_firmware *fw, 151 u32 tag, void *tag_data, size_t buf_size) 152 { 153 struct rpi_firmware_property_tag_header *header; 154 int ret; 155 156 /* Some mailboxes can use over 1k bytes. Rather than checking 157 * size and using stack or kmalloc depending on requirements, 158 * just use kmalloc. Mailboxes don't get called enough to worry 159 * too much about the time taken in the allocation. 160 */ 161 void *data = kmalloc(sizeof(*header) + buf_size, GFP_KERNEL); 162 163 if (!data) 164 return -ENOMEM; 165 166 header = data; 167 header->tag = tag; 168 header->buf_size = buf_size; 169 header->req_resp_size = 0; 170 memcpy(data + sizeof(*header), tag_data, buf_size); 171 172 ret = rpi_firmware_property_list(fw, data, buf_size + sizeof(*header)); 173 174 memcpy(tag_data, data + sizeof(*header), buf_size); 175 176 kfree(data); 177 178 return ret; 179 } 180 EXPORT_SYMBOL_GPL(rpi_firmware_property); 181 182 static void 183 rpi_firmware_print_firmware_revision(struct rpi_firmware *fw) 184 { 185 time64_t date_and_time; 186 u32 packet; 187 int ret = rpi_firmware_property(fw, 188 RPI_FIRMWARE_GET_FIRMWARE_REVISION, 189 &packet, sizeof(packet)); 190 191 if (ret) 192 return; 193 194 /* This is not compatible with y2038 */ 195 date_and_time = packet; 196 dev_info(fw->cl.dev, "Attached to firmware from %ptT\n", &date_and_time); 197 } 198 199 static void 200 rpi_register_hwmon_driver(struct device *dev, struct rpi_firmware *fw) 201 { 202 u32 packet; 203 int ret = rpi_firmware_property(fw, RPI_FIRMWARE_GET_THROTTLED, 204 &packet, sizeof(packet)); 205 206 if (ret) 207 return; 208 209 rpi_hwmon = platform_device_register_data(dev, "raspberrypi-hwmon", 210 -1, NULL, 0); 211 } 212 213 static void rpi_register_clk_driver(struct device *dev) 214 { 215 struct device_node *firmware; 216 217 /* 218 * Earlier DTs don't have a node for the firmware clocks but 219 * rely on us creating a platform device by hand. If we do 220 * have a node for the firmware clocks, just bail out here. 221 */ 222 firmware = of_get_compatible_child(dev->of_node, 223 "raspberrypi,firmware-clocks"); 224 if (firmware) { 225 of_node_put(firmware); 226 return; 227 } 228 229 rpi_clk = platform_device_register_data(dev, "raspberrypi-clk", 230 -1, NULL, 0); 231 } 232 233 unsigned int rpi_firmware_clk_get_max_rate(struct rpi_firmware *fw, unsigned int id) 234 { 235 struct rpi_firmware_clk_rate_request msg = 236 RPI_FIRMWARE_CLK_RATE_REQUEST(id); 237 int ret; 238 239 ret = rpi_firmware_property(fw, RPI_FIRMWARE_GET_MAX_CLOCK_RATE, 240 &msg, sizeof(msg)); 241 if (ret) 242 /* 243 * If our firmware doesn't support that operation, or fails, we 244 * assume the maximum clock rate is absolute maximum we can 245 * store over our type. 246 */ 247 return UINT_MAX; 248 249 return le32_to_cpu(msg.rate); 250 } 251 EXPORT_SYMBOL_GPL(rpi_firmware_clk_get_max_rate); 252 253 static void rpi_firmware_delete(struct kref *kref) 254 { 255 struct rpi_firmware *fw = container_of(kref, struct rpi_firmware, 256 consumers); 257 258 mbox_free_channel(fw->chan); 259 kfree(fw); 260 } 261 262 void rpi_firmware_put(struct rpi_firmware *fw) 263 { 264 kref_put(&fw->consumers, rpi_firmware_delete); 265 } 266 EXPORT_SYMBOL_GPL(rpi_firmware_put); 267 268 static void devm_rpi_firmware_put(void *data) 269 { 270 struct rpi_firmware *fw = data; 271 272 rpi_firmware_put(fw); 273 } 274 275 static int rpi_firmware_probe(struct platform_device *pdev) 276 { 277 struct device *dev = &pdev->dev; 278 struct rpi_firmware *fw; 279 280 /* 281 * Memory will be freed by rpi_firmware_delete() once all users have 282 * released their firmware handles. Don't use devm_kzalloc() here. 283 */ 284 fw = kzalloc(sizeof(*fw), GFP_KERNEL); 285 if (!fw) 286 return -ENOMEM; 287 288 fw->cl.dev = dev; 289 fw->cl.rx_callback = response_callback; 290 fw->cl.tx_block = true; 291 292 fw->chan = mbox_request_channel(&fw->cl, 0); 293 if (IS_ERR(fw->chan)) { 294 int ret = PTR_ERR(fw->chan); 295 kfree(fw); 296 return dev_err_probe(dev, ret, "Failed to get mbox channel\n"); 297 } 298 299 init_completion(&fw->c); 300 kref_init(&fw->consumers); 301 302 platform_set_drvdata(pdev, fw); 303 304 rpi_firmware_print_firmware_revision(fw); 305 rpi_register_hwmon_driver(dev, fw); 306 rpi_register_clk_driver(dev); 307 308 return 0; 309 } 310 311 static void rpi_firmware_shutdown(struct platform_device *pdev) 312 { 313 struct rpi_firmware *fw = platform_get_drvdata(pdev); 314 315 if (!fw) 316 return; 317 318 rpi_firmware_property(fw, RPI_FIRMWARE_NOTIFY_REBOOT, NULL, 0); 319 } 320 321 static void rpi_firmware_remove(struct platform_device *pdev) 322 { 323 struct rpi_firmware *fw = platform_get_drvdata(pdev); 324 325 platform_device_unregister(rpi_hwmon); 326 rpi_hwmon = NULL; 327 platform_device_unregister(rpi_clk); 328 rpi_clk = NULL; 329 330 rpi_firmware_put(fw); 331 } 332 333 static const struct of_device_id rpi_firmware_of_match[] = { 334 { .compatible = "raspberrypi,bcm2835-firmware", }, 335 {}, 336 }; 337 MODULE_DEVICE_TABLE(of, rpi_firmware_of_match); 338 339 struct device_node *rpi_firmware_find_node(void) 340 { 341 return of_find_matching_node(NULL, rpi_firmware_of_match); 342 } 343 EXPORT_SYMBOL_GPL(rpi_firmware_find_node); 344 345 /** 346 * rpi_firmware_get - Get pointer to rpi_firmware structure. 347 * @firmware_node: Pointer to the firmware Device Tree node. 348 * 349 * The reference to rpi_firmware has to be released with rpi_firmware_put(). 350 * 351 * Returns NULL is the firmware device is not ready. 352 */ 353 struct rpi_firmware *rpi_firmware_get(struct device_node *firmware_node) 354 { 355 struct platform_device *pdev = of_find_device_by_node(firmware_node); 356 struct rpi_firmware *fw; 357 358 if (!pdev) 359 return NULL; 360 361 fw = platform_get_drvdata(pdev); 362 if (!fw) 363 goto err_put_device; 364 365 if (!kref_get_unless_zero(&fw->consumers)) 366 goto err_put_device; 367 368 put_device(&pdev->dev); 369 370 return fw; 371 372 err_put_device: 373 put_device(&pdev->dev); 374 return NULL; 375 } 376 EXPORT_SYMBOL_GPL(rpi_firmware_get); 377 378 /** 379 * devm_rpi_firmware_get - Get pointer to rpi_firmware structure. 380 * @dev: The firmware device structure 381 * @firmware_node: Pointer to the firmware Device Tree node. 382 * 383 * Returns NULL is the firmware device is not ready. 384 */ 385 struct rpi_firmware *devm_rpi_firmware_get(struct device *dev, 386 struct device_node *firmware_node) 387 { 388 struct rpi_firmware *fw; 389 390 fw = rpi_firmware_get(firmware_node); 391 if (!fw) 392 return NULL; 393 394 if (devm_add_action_or_reset(dev, devm_rpi_firmware_put, fw)) 395 return NULL; 396 397 return fw; 398 } 399 EXPORT_SYMBOL_GPL(devm_rpi_firmware_get); 400 401 static struct platform_driver rpi_firmware_driver = { 402 .driver = { 403 .name = "raspberrypi-firmware", 404 .of_match_table = rpi_firmware_of_match, 405 }, 406 .probe = rpi_firmware_probe, 407 .shutdown = rpi_firmware_shutdown, 408 .remove_new = rpi_firmware_remove, 409 }; 410 module_platform_driver(rpi_firmware_driver); 411 412 MODULE_AUTHOR("Eric Anholt <eric@anholt.net>"); 413 MODULE_DESCRIPTION("Raspberry Pi firmware driver"); 414 MODULE_LICENSE("GPL v2"); 415