1 // SPDX-License-Identifier: GPL-2.0
3 * Defines interfaces for interacting wtih the Raspberry Pi firmware's
6 * Copyright © 2015 Broadcom
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 <soc/bcm2835/raspberrypi-firmware.h>
17 #define MBOX_MSG(chan, data28) (((data28) & ~0xf) | ((chan) & 0xf))
18 #define MBOX_CHAN(msg) ((msg) & 0xf)
19 #define MBOX_DATA28(msg) ((msg) & ~0xf)
20 #define MBOX_CHAN_PROPERTY 8
22 static struct platform_device
*rpi_hwmon
;
25 struct mbox_client cl
;
26 struct mbox_chan
*chan
; /* The property channel. */
31 static DEFINE_MUTEX(transaction_lock
);
33 static void response_callback(struct mbox_client
*cl
, void *msg
)
35 struct rpi_firmware
*fw
= container_of(cl
, struct rpi_firmware
, cl
);
40 * Sends a request to the firmware through the BCM2835 mailbox driver,
41 * and synchronously waits for the reply.
44 rpi_firmware_transaction(struct rpi_firmware
*fw
, u32 chan
, u32 data
)
46 u32 message
= MBOX_MSG(chan
, data
);
51 mutex_lock(&transaction_lock
);
52 reinit_completion(&fw
->c
);
53 ret
= mbox_send_message(fw
->chan
, &message
);
55 if (wait_for_completion_timeout(&fw
->c
, HZ
)) {
59 WARN_ONCE(1, "Firmware transaction timeout");
62 dev_err(fw
->cl
.dev
, "mbox_send_message returned %d\n", ret
);
64 mutex_unlock(&transaction_lock
);
70 * rpi_firmware_property_list - Submit firmware property list
71 * @fw: Pointer to firmware structure from rpi_firmware_get().
72 * @data: Buffer holding tags.
73 * @tag_size: Size of tags buffer.
75 * Submits a set of concatenated tags to the VPU firmware through the
76 * mailbox property interface.
78 * The buffer header and the ending tag are added by this function and
79 * don't need to be supplied, just the actual tags for your operation.
80 * See struct rpi_firmware_property_tag_header for the per-tag
83 int rpi_firmware_property_list(struct rpi_firmware
*fw
,
84 void *data
, size_t tag_size
)
86 size_t size
= tag_size
+ 12;
91 /* Packets are processed a dword at a time. */
95 buf
= dma_alloc_coherent(fw
->cl
.dev
, PAGE_ALIGN(size
), &bus_addr
,
100 /* The firmware will error out without parsing in this case. */
101 WARN_ON(size
>= 1024 * 1024);
104 buf
[1] = RPI_FIRMWARE_STATUS_REQUEST
;
105 memcpy(&buf
[2], data
, tag_size
);
106 buf
[size
/ 4 - 1] = RPI_FIRMWARE_PROPERTY_END
;
109 ret
= rpi_firmware_transaction(fw
, MBOX_CHAN_PROPERTY
, bus_addr
);
112 memcpy(data
, &buf
[2], tag_size
);
113 if (ret
== 0 && buf
[1] != RPI_FIRMWARE_STATUS_SUCCESS
) {
115 * The tag name here might not be the one causing the
116 * error, if there were multiple tags in the request.
117 * But single-tag is the most common, so go with it.
119 dev_err(fw
->cl
.dev
, "Request 0x%08x returned status 0x%08x\n",
124 dma_free_coherent(fw
->cl
.dev
, PAGE_ALIGN(size
), buf
, bus_addr
);
128 EXPORT_SYMBOL_GPL(rpi_firmware_property_list
);
131 * rpi_firmware_property - Submit single firmware property
132 * @fw: Pointer to firmware structure from rpi_firmware_get().
133 * @tag: One of enum_mbox_property_tag.
134 * @tag_data: Tag data buffer.
135 * @buf_size: Buffer size.
137 * Submits a single tag to the VPU firmware through the mailbox
138 * property interface.
140 * This is a convenience wrapper around
141 * rpi_firmware_property_list() to avoid some of the
142 * boilerplate in property calls.
144 int rpi_firmware_property(struct rpi_firmware
*fw
,
145 u32 tag
, void *tag_data
, size_t buf_size
)
147 struct rpi_firmware_property_tag_header
*header
;
150 /* Some mailboxes can use over 1k bytes. Rather than checking
151 * size and using stack or kmalloc depending on requirements,
152 * just use kmalloc. Mailboxes don't get called enough to worry
153 * too much about the time taken in the allocation.
155 void *data
= kmalloc(sizeof(*header
) + buf_size
, GFP_KERNEL
);
162 header
->buf_size
= buf_size
;
163 header
->req_resp_size
= 0;
164 memcpy(data
+ sizeof(*header
), tag_data
, buf_size
);
166 ret
= rpi_firmware_property_list(fw
, data
, buf_size
+ sizeof(*header
));
168 memcpy(tag_data
, data
+ sizeof(*header
), buf_size
);
174 EXPORT_SYMBOL_GPL(rpi_firmware_property
);
177 rpi_firmware_print_firmware_revision(struct rpi_firmware
*fw
)
180 int ret
= rpi_firmware_property(fw
,
181 RPI_FIRMWARE_GET_FIRMWARE_REVISION
,
182 &packet
, sizeof(packet
));
187 time64_to_tm(packet
, 0, &tm
);
190 "Attached to firmware from %04ld-%02d-%02d %02d:%02d\n",
191 tm
.tm_year
+ 1900, tm
.tm_mon
+ 1, tm
.tm_mday
,
192 tm
.tm_hour
, tm
.tm_min
);
197 rpi_register_hwmon_driver(struct device
*dev
, struct rpi_firmware
*fw
)
200 int ret
= rpi_firmware_property(fw
, RPI_FIRMWARE_GET_THROTTLED
,
201 &packet
, sizeof(packet
));
206 rpi_hwmon
= platform_device_register_data(dev
, "raspberrypi-hwmon",
210 static int rpi_firmware_probe(struct platform_device
*pdev
)
212 struct device
*dev
= &pdev
->dev
;
213 struct rpi_firmware
*fw
;
215 fw
= devm_kzalloc(dev
, sizeof(*fw
), GFP_KERNEL
);
220 fw
->cl
.rx_callback
= response_callback
;
221 fw
->cl
.tx_block
= true;
223 fw
->chan
= mbox_request_channel(&fw
->cl
, 0);
224 if (IS_ERR(fw
->chan
)) {
225 int ret
= PTR_ERR(fw
->chan
);
226 if (ret
!= -EPROBE_DEFER
)
227 dev_err(dev
, "Failed to get mbox channel: %d\n", ret
);
231 init_completion(&fw
->c
);
233 platform_set_drvdata(pdev
, fw
);
235 rpi_firmware_print_firmware_revision(fw
);
236 rpi_register_hwmon_driver(dev
, fw
);
241 static int rpi_firmware_remove(struct platform_device
*pdev
)
243 struct rpi_firmware
*fw
= platform_get_drvdata(pdev
);
245 platform_device_unregister(rpi_hwmon
);
247 mbox_free_channel(fw
->chan
);
253 * rpi_firmware_get - Get pointer to rpi_firmware structure.
254 * @firmware_node: Pointer to the firmware Device Tree node.
256 * Returns NULL is the firmware device is not ready.
258 struct rpi_firmware
*rpi_firmware_get(struct device_node
*firmware_node
)
260 struct platform_device
*pdev
= of_find_device_by_node(firmware_node
);
265 return platform_get_drvdata(pdev
);
267 EXPORT_SYMBOL_GPL(rpi_firmware_get
);
269 static const struct of_device_id rpi_firmware_of_match
[] = {
270 { .compatible
= "raspberrypi,bcm2835-firmware", },
273 MODULE_DEVICE_TABLE(of
, rpi_firmware_of_match
);
275 static struct platform_driver rpi_firmware_driver
= {
277 .name
= "raspberrypi-firmware",
278 .of_match_table
= rpi_firmware_of_match
,
280 .probe
= rpi_firmware_probe
,
281 .remove
= rpi_firmware_remove
,
283 module_platform_driver(rpi_firmware_driver
);
285 MODULE_AUTHOR("Eric Anholt <eric@anholt.net>");
286 MODULE_DESCRIPTION("Raspberry Pi firmware driver");
287 MODULE_LICENSE("GPL v2");