xref: /linux/drivers/firmware/meson/meson_sm.c (revision 07fdad3a93756b872da7b53647715c48d0f4a2d0) 
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Amlogic Secure Monitor driver
4  *
5  * Copyright (C) 2016 Endless Mobile, Inc.
6  * Author: Carlo Caione <carlo@endlessm.com>
7  */
8 
9 #define pr_fmt(fmt) "meson-sm: " fmt
10 
11 #include <linux/arm-smccc.h>
12 #include <linux/bug.h>
13 #include <linux/io.h>
14 #include <linux/module.h>
15 #include <linux/of.h>
16 #include <linux/of_platform.h>
17 #include <linux/platform_device.h>
18 #include <linux/printk.h>
19 #include <linux/property.h>
20 #include <linux/types.h>
21 #include <linux/sizes.h>
22  #include <linux/slab.h>
23 
24 #include <linux/firmware/meson/meson_sm.h>
25 
26 struct meson_sm_cmd {
27 	unsigned int index;
28 	u32 smc_id;
29 };
30 #define CMD(d, s) { .index = (d), .smc_id = (s), }
31 
32 struct meson_sm_chip {
33 	unsigned int shmem_size;
34 	u32 cmd_shmem_in_base;
35 	u32 cmd_shmem_out_base;
36 	struct meson_sm_cmd cmd[];
37 };
38 
39 static const struct meson_sm_chip gxbb_chip = {
40 	.shmem_size		= SZ_4K,
41 	.cmd_shmem_in_base	= 0x82000020,
42 	.cmd_shmem_out_base	= 0x82000021,
43 	.cmd = {
44 		CMD(SM_EFUSE_READ,	0x82000030),
45 		CMD(SM_EFUSE_WRITE,	0x82000031),
46 		CMD(SM_EFUSE_USER_MAX,	0x82000033),
47 		CMD(SM_GET_CHIP_ID,	0x82000044),
48 		CMD(SM_A1_PWRC_SET,	0x82000093),
49 		CMD(SM_A1_PWRC_GET,	0x82000095),
50 		{ /* sentinel */ },
51 	},
52 };
53 
54 struct meson_sm_firmware {
55 	const struct meson_sm_chip *chip;
56 	void __iomem *sm_shmem_in_base;
57 	void __iomem *sm_shmem_out_base;
58 };
59 
60 static u32 meson_sm_get_cmd(const struct meson_sm_chip *chip,
61 			    unsigned int cmd_index)
62 {
63 	const struct meson_sm_cmd *cmd = chip->cmd;
64 
65 	while (cmd->smc_id && cmd->index != cmd_index)
66 		cmd++;
67 
68 	return cmd->smc_id;
69 }
70 
71 static s32 __meson_sm_call(u32 cmd, u32 arg0, u32 arg1, u32 arg2,
72 			   u32 arg3, u32 arg4)
73 {
74 	struct arm_smccc_res res;
75 
76 	arm_smccc_smc(cmd, arg0, arg1, arg2, arg3, arg4, 0, 0, &res);
77 	return res.a0;
78 }
79 
80 static void __iomem *meson_sm_map_shmem(u32 cmd_shmem, unsigned int size)
81 {
82 	u32 sm_phy_base;
83 
84 	sm_phy_base = __meson_sm_call(cmd_shmem, 0, 0, 0, 0, 0);
85 	if (!sm_phy_base)
86 		return NULL;
87 
88 	return ioremap_cache(sm_phy_base, size);
89 }
90 
91 /**
92  * meson_sm_call - generic SMC32 call to the secure-monitor
93  *
94  * @fw:		Pointer to secure-monitor firmware
95  * @cmd_index:	Index of the SMC32 function ID
96  * @ret:	Returned value
97  * @arg0:	SMC32 Argument 0
98  * @arg1:	SMC32 Argument 1
99  * @arg2:	SMC32 Argument 2
100  * @arg3:	SMC32 Argument 3
101  * @arg4:	SMC32 Argument 4
102  *
103  * Return:	0 on success, a negative value on error
104  */
105 int meson_sm_call(struct meson_sm_firmware *fw, unsigned int cmd_index,
106 		  s32 *ret, u32 arg0, u32 arg1, u32 arg2, u32 arg3, u32 arg4)
107 {
108 	u32 cmd;
109 	s32 lret;
110 
111 	if (!fw->chip)
112 		return -ENOENT;
113 
114 	cmd = meson_sm_get_cmd(fw->chip, cmd_index);
115 	if (!cmd)
116 		return -EINVAL;
117 
118 	lret = __meson_sm_call(cmd, arg0, arg1, arg2, arg3, arg4);
119 
120 	if (ret)
121 		*ret = lret;
122 
123 	return 0;
124 }
125 EXPORT_SYMBOL(meson_sm_call);
126 
127 /**
128  * meson_sm_call_read - retrieve data from secure-monitor
129  *
130  * @fw:		Pointer to secure-monitor firmware
131  * @buffer:	Buffer to store the retrieved data
132  * @bsize:	Size of the buffer
133  * @cmd_index:	Index of the SMC32 function ID
134  * @arg0:	SMC32 Argument 0
135  * @arg1:	SMC32 Argument 1
136  * @arg2:	SMC32 Argument 2
137  * @arg3:	SMC32 Argument 3
138  * @arg4:	SMC32 Argument 4
139  *
140  * Return:	size of read data on success, a negative value on error
141  *		When 0 is returned there is no guarantee about the amount of
142  *		data read and bsize bytes are copied in buffer.
143  */
144 int meson_sm_call_read(struct meson_sm_firmware *fw, void *buffer,
145 		       unsigned int bsize, unsigned int cmd_index, u32 arg0,
146 		       u32 arg1, u32 arg2, u32 arg3, u32 arg4)
147 {
148 	s32 size;
149 	int ret;
150 
151 	if (!fw->chip)
152 		return -ENOENT;
153 
154 	if (!fw->chip->cmd_shmem_out_base)
155 		return -EINVAL;
156 
157 	if (bsize > fw->chip->shmem_size)
158 		return -EINVAL;
159 
160 	if (meson_sm_call(fw, cmd_index, &size, arg0, arg1, arg2, arg3, arg4) < 0)
161 		return -EINVAL;
162 
163 	if (size < 0 || size > bsize)
164 		return -EINVAL;
165 
166 	ret = size;
167 
168 	/* In some cases (for example GET_CHIP_ID command),
169 	 * SMC doesn't return the number of bytes read, even
170 	 * though the bytes were actually read into sm_shmem_out.
171 	 * So this check is needed.
172 	 */
173 	if (!size)
174 		size = bsize;
175 
176 	if (buffer)
177 		memcpy(buffer, fw->sm_shmem_out_base, size);
178 
179 	return ret;
180 }
181 EXPORT_SYMBOL(meson_sm_call_read);
182 
183 /**
184  * meson_sm_call_write - send data to secure-monitor
185  *
186  * @fw:		Pointer to secure-monitor firmware
187  * @buffer:	Buffer containing data to send
188  * @size:	Size of the data to send
189  * @cmd_index:	Index of the SMC32 function ID
190  * @arg0:	SMC32 Argument 0
191  * @arg1:	SMC32 Argument 1
192  * @arg2:	SMC32 Argument 2
193  * @arg3:	SMC32 Argument 3
194  * @arg4:	SMC32 Argument 4
195  *
196  * Return:	size of sent data on success, a negative value on error
197  */
198 int meson_sm_call_write(struct meson_sm_firmware *fw, void *buffer,
199 			unsigned int size, unsigned int cmd_index, u32 arg0,
200 			u32 arg1, u32 arg2, u32 arg3, u32 arg4)
201 {
202 	s32 written;
203 
204 	if (!fw->chip)
205 		return -ENOENT;
206 
207 	if (size > fw->chip->shmem_size)
208 		return -EINVAL;
209 
210 	if (!fw->chip->cmd_shmem_in_base)
211 		return -EINVAL;
212 
213 	memcpy(fw->sm_shmem_in_base, buffer, size);
214 
215 	if (meson_sm_call(fw, cmd_index, &written, arg0, arg1, arg2, arg3, arg4) < 0)
216 		return -EINVAL;
217 
218 	if (written <= 0 || written > size)
219 		return -EINVAL;
220 
221 	return written;
222 }
223 EXPORT_SYMBOL(meson_sm_call_write);
224 
225 /**
226  * meson_sm_get - get pointer to meson_sm_firmware structure.
227  *
228  * @sm_node:		Pointer to the secure-monitor Device Tree node.
229  *
230  * Return:		NULL is the secure-monitor device is not ready.
231  */
232 struct meson_sm_firmware *meson_sm_get(struct device_node *sm_node)
233 {
234 	struct platform_device *pdev = of_find_device_by_node(sm_node);
235 	struct meson_sm_firmware *fw;
236 
237 	if (!pdev)
238 		return NULL;
239 
240 	fw = platform_get_drvdata(pdev);
241 
242 	put_device(&pdev->dev);
243 
244 	return fw;
245 }
246 EXPORT_SYMBOL_GPL(meson_sm_get);
247 
248 #define SM_CHIP_ID_LENGTH	119
249 #define SM_CHIP_ID_OFFSET	4
250 #define SM_CHIP_ID_SIZE		12
251 
252 static ssize_t serial_show(struct device *dev, struct device_attribute *attr,
253 			 char *buf)
254 {
255 	struct platform_device *pdev = to_platform_device(dev);
256 	struct meson_sm_firmware *fw;
257 	uint8_t *id_buf;
258 	int ret;
259 
260 	fw = platform_get_drvdata(pdev);
261 
262 	id_buf = kmalloc(SM_CHIP_ID_LENGTH, GFP_KERNEL);
263 	if (!id_buf)
264 		return -ENOMEM;
265 
266 	ret = meson_sm_call_read(fw, id_buf, SM_CHIP_ID_LENGTH, SM_GET_CHIP_ID,
267 				 0, 0, 0, 0, 0);
268 	if (ret < 0) {
269 		kfree(id_buf);
270 		return ret;
271 	}
272 
273 	ret = sprintf(buf, "%12phN\n", &id_buf[SM_CHIP_ID_OFFSET]);
274 
275 	kfree(id_buf);
276 
277 	return ret;
278 }
279 
280 static DEVICE_ATTR_RO(serial);
281 
282 static struct attribute *meson_sm_sysfs_attrs[] = {
283 	&dev_attr_serial.attr,
284 	NULL,
285 };
286 ATTRIBUTE_GROUPS(meson_sm_sysfs);
287 
288 static const struct of_device_id meson_sm_ids[] = {
289 	{ .compatible = "amlogic,meson-gxbb-sm", .data = &gxbb_chip },
290 	{ /* sentinel */ },
291 };
292 
293 static int __init meson_sm_probe(struct platform_device *pdev)
294 {
295 	struct device *dev = &pdev->dev;
296 	const struct meson_sm_chip *chip;
297 	struct meson_sm_firmware *fw;
298 
299 	fw = devm_kzalloc(dev, sizeof(*fw), GFP_KERNEL);
300 	if (!fw)
301 		return -ENOMEM;
302 
303 	chip = device_get_match_data(dev);
304 	if (!chip)
305 		return -EINVAL;
306 
307 	if (chip->cmd_shmem_in_base) {
308 		fw->sm_shmem_in_base = meson_sm_map_shmem(chip->cmd_shmem_in_base,
309 							  chip->shmem_size);
310 		if (WARN_ON(!fw->sm_shmem_in_base))
311 			goto out;
312 	}
313 
314 	if (chip->cmd_shmem_out_base) {
315 		fw->sm_shmem_out_base = meson_sm_map_shmem(chip->cmd_shmem_out_base,
316 							   chip->shmem_size);
317 		if (WARN_ON(!fw->sm_shmem_out_base))
318 			goto unmap_in_base;
319 	}
320 
321 	fw->chip = chip;
322 
323 	platform_set_drvdata(pdev, fw);
324 
325 	if (devm_of_platform_populate(dev))
326 		goto unmap_out_base;
327 
328 	pr_info("secure-monitor enabled\n");
329 
330 	return 0;
331 
332 unmap_out_base:
333 	iounmap(fw->sm_shmem_out_base);
334 unmap_in_base:
335 	iounmap(fw->sm_shmem_in_base);
336 out:
337 	return -EINVAL;
338 }
339 
340 static struct platform_driver meson_sm_driver = {
341 	.driver = {
342 		.name = "meson-sm",
343 		.of_match_table = of_match_ptr(meson_sm_ids),
344 		.dev_groups = meson_sm_sysfs_groups,
345 	},
346 };
347 module_platform_driver_probe(meson_sm_driver, meson_sm_probe);
348 MODULE_DESCRIPTION("Amlogic Secure Monitor driver");
349 MODULE_LICENSE("GPL v2");
350