1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (C) 2022 Rockchip Electronics Co., Ltd.
4 */
5 #include <linux/delay.h>
6 #include <linux/kernel.h>
7 #include <linux/mailbox_client.h>
8 #include <linux/mm.h>
9 #include <linux/of.h>
10 #include <linux/of_address.h>
11 #include <linux/of_device.h>
12 #include <linux/platform_device.h>
13 #include <linux/reset.h>
14 #include <linux/soc/rockchip/rockchip_thunderboot_service.h>
15 #include <soc/rockchip/rockchip-mailbox.h>
16
17 #define CMD_MCU_STATUS (0x0000f00d)
18 #define MCU_STATUS_DONE (0xdeadbeef)
19
20 struct rk_tb_serv {
21 struct device *dev;
22 struct mbox_chan *mbox_rx_chan;
23 struct mbox_client mbox_cl;
24 struct reset_control *rsts;
25 phys_addr_t mem_start;
26 size_t mem_size;
27 };
28
29 static atomic_t mcu_done = ATOMIC_INIT(0);
30 static LIST_HEAD(clients_list);
31 static DEFINE_SPINLOCK(lock);
32
rk_tb_mcu_is_done(void)33 bool rk_tb_mcu_is_done(void)
34 {
35 return atomic_read(&mcu_done);
36 }
37 EXPORT_SYMBOL(rk_tb_mcu_is_done);
38
rk_tb_client_register_cb(struct rk_tb_client * client)39 int rk_tb_client_register_cb(struct rk_tb_client *client)
40 {
41 if (!client || !client->cb)
42 return -EINVAL;
43
44 spin_lock(&lock);
45 if (rk_tb_mcu_is_done()) {
46 spin_unlock(&lock);
47 client->cb(client->data);
48 return 0;
49 }
50
51 list_add_tail(&client->node, &clients_list);
52 spin_unlock(&lock);
53
54 return 0;
55 }
56 EXPORT_SYMBOL(rk_tb_client_register_cb);
57
rk_tb_client_register_cb_head(struct rk_tb_client * client)58 int rk_tb_client_register_cb_head(struct rk_tb_client *client)
59 {
60 if (!client || !client->cb)
61 return -EINVAL;
62
63 spin_lock(&lock);
64 if (rk_tb_mcu_is_done()) {
65 spin_unlock(&lock);
66 client->cb(client->data);
67 return 0;
68 }
69
70 list_add(&client->node, &clients_list);
71 spin_unlock(&lock);
72
73 return 0;
74 }
75 EXPORT_SYMBOL(rk_tb_client_register_cb_head);
76
do_mcu_done(struct rk_tb_serv * serv)77 static void do_mcu_done(struct rk_tb_serv *serv)
78 {
79 struct rk_tb_client *client, *client_s;
80 struct rockchip_mbox_msg msg;
81
82 rockchip_mbox_read_msg(serv->mbox_rx_chan, &msg);
83 if (msg.cmd == CMD_MCU_STATUS && msg.data == MCU_STATUS_DONE) {
84 void *start, *end;
85
86 /* make sure mcu is wfi */
87 udelay(15);
88 reset_control_assert(serv->rsts);
89
90 start = phys_to_virt(serv->mem_start);
91 end = start + serv->mem_size;
92 free_reserved_area(start, end, -1, "rtos");
93
94 spin_lock(&lock);
95 if (atomic_read(&mcu_done)) {
96 spin_unlock(&lock);
97 return;
98 }
99
100 list_for_each_entry_safe(client, client_s, &clients_list, node) {
101 spin_unlock(&lock);
102 if (client->cb)
103 client->cb(client->data);
104 spin_lock(&lock);
105 list_del(&client->node);
106 }
107 atomic_set(&mcu_done, 1);
108 spin_unlock(&lock);
109 }
110 }
111
rk_tb_rx_callback(struct mbox_client * mbox_cl,void * message)112 static void rk_tb_rx_callback(struct mbox_client *mbox_cl, void *message)
113 {
114 struct rk_tb_serv *serv = dev_get_drvdata(mbox_cl->dev);
115
116 do_mcu_done(serv);
117 mbox_free_channel(serv->mbox_rx_chan);
118 }
119
rk_tb_serv_probe(struct platform_device * pdev)120 static int rk_tb_serv_probe(struct platform_device *pdev)
121 {
122 struct rk_tb_serv *serv;
123 struct mbox_client *mbox_cl;
124 struct device_node *mem;
125 struct resource reg;
126 int ret;
127
128 serv = devm_kzalloc(&pdev->dev, sizeof(*serv), GFP_KERNEL);
129 if (!serv)
130 return -ENOMEM;
131
132 mem = of_parse_phandle(pdev->dev.of_node, "memory-region", 0);
133 if (!mem) {
134 dev_err(&pdev->dev, "missing \"memory-region\" property\n");
135 return -ENODEV;
136 }
137
138 ret = of_address_to_resource(mem, 0, ®);
139 of_node_put(mem);
140 if (ret) {
141 dev_err(&pdev->dev, "missing \"reg\" property\n");
142 return -ENODEV;
143 }
144
145 serv->mem_start = reg.start;
146 serv->mem_size = resource_size(®);
147
148 serv->rsts = devm_reset_control_array_get_optional_exclusive(&pdev->dev);
149 if (IS_ERR(serv->rsts) && PTR_ERR(serv->rsts) == -EPROBE_DEFER)
150 return -EPROBE_DEFER;
151
152 platform_set_drvdata(pdev, serv);
153
154 mbox_cl = &serv->mbox_cl;
155 mbox_cl->dev = &pdev->dev;
156 mbox_cl->rx_callback = rk_tb_rx_callback;
157 serv->mbox_rx_chan = mbox_request_channel_byname(mbox_cl, "amp-rx");
158 if (IS_ERR(serv->mbox_rx_chan)) {
159 dev_err(mbox_cl->dev, "failed to request mbox rx chan\n");
160 return PTR_ERR(serv->mbox_rx_chan);
161 }
162
163 do_mcu_done(serv);
164 return 0;
165 }
166
167 #ifdef CONFIG_OF
168 static const struct of_device_id rk_tb_serv_dt_match[] = {
169 { .compatible = "rockchip,thunder-boot-service" },
170 {},
171 };
172 #endif
173
174 static struct platform_driver rk_tb_serv_driver = {
175 .probe = rk_tb_serv_probe,
176 .driver = {
177 .name = "rockchip_thunder_boot_service",
178 .of_match_table = rk_tb_serv_dt_match,
179 },
180 };
181
rk_tb_serv_init(void)182 static int __init rk_tb_serv_init(void)
183 {
184 return platform_driver_register(&rk_tb_serv_driver);
185 }
186
187 arch_initcall(rk_tb_serv_init);
188