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