1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * (C) Copyright 2019 Rockchip Electronics Co., Ltd.
4 *
5 * Copyright (C) 2019 Collabora Inc - https://www.collabora.com/
6 *      Rohan Garg <rohan.garg@collabora.com>
7 *
8 * Based on puma-rk3399.c:
9 *      (C) Copyright 2017 Theobroma Systems Design und Consulting GmbH
10 */
11#include <common.h>
12#include <clk.h>
13#include <cpu_func.h>
14#include <env.h>
15#include <dm.h>
16#include <dm/uclass-internal.h>
17#include <efi_loader.h>
18#include <fastboot.h>
19#include <hash.h>
20#include <init.h>
21#include <log.h>
22#include <mmc.h>
23#include <dm/uclass-internal.h>
24#include <misc.h>
25#include <part.h>
26#include <ram.h>
27#include <syscon.h>
28#include <uuid.h>
29#include <u-boot/crc.h>
30#include <u-boot/sha256.h>
31#include <asm/cache.h>
32#include <asm/io.h>
33#include <asm/arch-rockchip/boot_mode.h>
34#include <asm/arch-rockchip/clock.h>
35#include <asm/arch-rockchip/periph.h>
36#include <power/regulator.h>
37
38#if IS_ENABLED(CONFIG_EFI_HAVE_CAPSULE_SUPPORT) && IS_ENABLED(CONFIG_EFI_PARTITION)
39
40#define DFU_ALT_BUF_LEN			SZ_1K
41
42static struct efi_fw_image *fw_images;
43
44static bool updatable_image(struct disk_partition *info)
45{
46	int i;
47	bool ret = false;
48	efi_guid_t image_type_guid;
49
50	uuid_str_to_bin(info->type_guid, image_type_guid.b,
51			UUID_STR_FORMAT_GUID);
52
53	for (i = 0; i < update_info.num_images; i++) {
54		if (!guidcmp(&fw_images[i].image_type_id, &image_type_guid)) {
55			ret = true;
56			break;
57		}
58	}
59
60	return ret;
61}
62
63static void set_image_index(struct disk_partition *info, int index)
64{
65	int i;
66	efi_guid_t image_type_guid;
67
68	uuid_str_to_bin(info->type_guid, image_type_guid.b,
69			UUID_STR_FORMAT_GUID);
70
71	for (i = 0; i < update_info.num_images; i++) {
72		if (!guidcmp(&fw_images[i].image_type_id, &image_type_guid)) {
73			fw_images[i].image_index = index;
74			break;
75		}
76	}
77}
78
79static int get_mmc_desc(struct blk_desc **desc)
80{
81	int ret;
82	struct mmc *mmc;
83	struct udevice *dev;
84
85	/*
86	 * For now the firmware images are assumed to
87	 * be on the SD card
88	 */
89	ret = uclass_get_device(UCLASS_MMC, 1, &dev);
90	if (ret)
91		return -1;
92
93	mmc = mmc_get_mmc_dev(dev);
94	if (!mmc)
95		return -ENODEV;
96
97	if ((ret = mmc_init(mmc)))
98		return ret;
99
100	*desc = mmc_get_blk_desc(mmc);
101	if (!*desc)
102		return -1;
103
104	return 0;
105}
106
107void set_dfu_alt_info(char *interface, char *devstr)
108{
109	const char *name;
110	bool first = true;
111	int p, len, devnum, ret;
112	char buf[DFU_ALT_BUF_LEN];
113	struct disk_partition info;
114	struct blk_desc *desc = NULL;
115
116	ret = get_mmc_desc(&desc);
117	if (ret) {
118		log_err("Unable to get mmc desc\n");
119		return;
120	}
121
122	memset(buf, 0, sizeof(buf));
123	name = blk_get_uclass_name(desc->uclass_id);
124	devnum = desc->devnum;
125	len = strlen(buf);
126
127	len += snprintf(buf + len, DFU_ALT_BUF_LEN - len,
128			 "%s %d=", name, devnum);
129
130	for (p = 1; p <= MAX_SEARCH_PARTITIONS; p++) {
131		if (part_get_info(desc, p, &info))
132			continue;
133
134		/* Add entry to dfu_alt_info only for updatable images */
135		if (updatable_image(&info)) {
136			if (!first)
137				len += snprintf(buf + len,
138						DFU_ALT_BUF_LEN - len, ";");
139
140			len += snprintf(buf + len, DFU_ALT_BUF_LEN - len,
141					"%s%d_%s part %d %d",
142					name, devnum, info.name, devnum, p);
143			first = false;
144		}
145	}
146
147	log_debug("dfu_alt_info => %s\n", buf);
148	env_set("dfu_alt_info", buf);
149}
150
151__weak void rockchip_capsule_update_board_setup(void)
152{
153}
154
155static void gpt_capsule_update_setup(void)
156{
157	int p, i, ret;
158	struct disk_partition info;
159	struct blk_desc *desc = NULL;
160
161	fw_images = update_info.images;
162	rockchip_capsule_update_board_setup();
163
164	ret = get_mmc_desc(&desc);
165	if (ret) {
166		log_err("Unable to get mmc desc\n");
167		return;
168	}
169
170	for (p = 1, i = 1; p <= MAX_SEARCH_PARTITIONS; p++) {
171		if (part_get_info(desc, p, &info))
172			continue;
173
174		/*
175		 * Since we have a GPT partitioned device, the updatable
176		 * images could be stored in any order. Populate the
177		 * image_index at runtime.
178		 */
179		if (updatable_image(&info)) {
180			set_image_index(&info, i);
181			i++;
182		}
183	}
184}
185#endif /* CONFIG_EFI_HAVE_CAPSULE_SUPPORT && CONFIG_EFI_PARTITION */
186
187__weak int rk_board_late_init(void)
188{
189	return 0;
190}
191
192int board_late_init(void)
193{
194	setup_boot_mode();
195
196#if IS_ENABLED(CONFIG_EFI_HAVE_CAPSULE_SUPPORT) && IS_ENABLED(CONFIG_EFI_PARTITION)
197	gpt_capsule_update_setup();
198#endif
199
200	return rk_board_late_init();
201}
202
203int board_init(void)
204{
205	int ret;
206
207#ifdef CONFIG_DM_REGULATOR
208	ret = regulators_enable_boot_on(false);
209	if (ret)
210		debug("%s: Cannot enable boot on regulator\n", __func__);
211#endif
212
213	return 0;
214}
215
216#if !defined(CONFIG_SYS_DCACHE_OFF) && !defined(CONFIG_ARM64)
217void enable_caches(void)
218{
219	/* Enable D-cache. I-cache is already enabled in start.S */
220	dcache_enable();
221}
222#endif
223
224#if IS_ENABLED(CONFIG_USB_GADGET)
225#include <usb.h>
226
227#if IS_ENABLED(CONFIG_USB_GADGET_DOWNLOAD)
228#define ROCKCHIP_G_DNL_UMS_PRODUCT_NUM	0x0010
229
230int g_dnl_bind_fixup(struct usb_device_descriptor *dev, const char *name)
231{
232	if (!strcmp(name, "usb_dnl_ums"))
233		put_unaligned(ROCKCHIP_G_DNL_UMS_PRODUCT_NUM, &dev->idProduct);
234	else
235		put_unaligned(CONFIG_USB_GADGET_PRODUCT_NUM, &dev->idProduct);
236
237	return 0;
238}
239#endif /* CONFIG_USB_GADGET_DOWNLOAD */
240
241#if IS_ENABLED(CONFIG_USB_GADGET_DWC2_OTG) && !IS_ENABLED(CONFIG_DM_USB_GADGET)
242#include <linux/usb/otg.h>
243#include <usb/dwc2_udc.h>
244
245static struct dwc2_plat_otg_data otg_data = {
246	.rx_fifo_sz	= 512,
247	.np_tx_fifo_sz	= 16,
248	.tx_fifo_sz	= 128,
249};
250
251int board_usb_init(int index, enum usb_init_type init)
252{
253	ofnode node;
254	bool matched = false;
255
256	/* find the usb_otg node */
257	node = ofnode_by_compatible(ofnode_null(), "snps,dwc2");
258	while (ofnode_valid(node)) {
259		switch (usb_get_dr_mode(node)) {
260		case USB_DR_MODE_OTG:
261		case USB_DR_MODE_PERIPHERAL:
262			matched = true;
263			break;
264
265		default:
266			break;
267		}
268
269		if (matched)
270			break;
271
272		node = ofnode_by_compatible(node, "snps,dwc2");
273	}
274	if (!matched) {
275		debug("Not found usb_otg device\n");
276		return -ENODEV;
277	}
278	otg_data.regs_otg = ofnode_get_addr(node);
279
280#ifdef CONFIG_ROCKCHIP_USB2_PHY
281	int ret;
282	u32 phandle, offset;
283	ofnode phy_node;
284
285	ret = ofnode_read_u32(node, "phys", &phandle);
286	if (ret)
287		return ret;
288
289	node = ofnode_get_by_phandle(phandle);
290	if (!ofnode_valid(node)) {
291		debug("Not found usb phy device\n");
292		return -ENODEV;
293	}
294
295	phy_node = ofnode_get_parent(node);
296	if (!ofnode_valid(node)) {
297		debug("Not found usb phy device\n");
298		return -ENODEV;
299	}
300
301	otg_data.phy_of_node = phy_node;
302	ret = ofnode_read_u32(node, "reg", &offset);
303	if (ret)
304		return ret;
305	otg_data.regs_phy =  offset +
306		(u32)syscon_get_first_range(ROCKCHIP_SYSCON_GRF);
307#endif
308	return dwc2_udc_probe(&otg_data);
309}
310
311int board_usb_cleanup(int index, enum usb_init_type init)
312{
313	return 0;
314}
315#endif /* CONFIG_USB_GADGET_DWC2_OTG */
316#endif /* CONFIG_USB_GADGET */
317
318#if IS_ENABLED(CONFIG_FASTBOOT)
319int fastboot_set_reboot_flag(enum fastboot_reboot_reason reason)
320{
321	if (reason != FASTBOOT_REBOOT_REASON_BOOTLOADER)
322		return -ENOTSUPP;
323
324	printf("Setting reboot to fastboot flag ...\n");
325	/* Set boot mode to fastboot */
326	writel(BOOT_FASTBOOT, CONFIG_ROCKCHIP_BOOT_MODE_REG);
327
328	return 0;
329}
330#endif
331
332#ifdef CONFIG_MISC_INIT_R
333int rockchip_setup_macaddr(void)
334{
335#if CONFIG_IS_ENABLED(HASH) && CONFIG_IS_ENABLED(SHA256)
336	int ret;
337	const char *cpuid = env_get("cpuid#");
338	u8 hash[SHA256_SUM_LEN];
339	int size = sizeof(hash);
340	u8 mac_addr[6];
341
342	/* Only generate a MAC address, if none is set in the environment */
343	if (env_get("ethaddr"))
344		return 0;
345
346	if (!cpuid) {
347		debug("%s: could not retrieve 'cpuid#'\n", __func__);
348		return -1;
349	}
350
351	ret = hash_block("sha256", (void *)cpuid, strlen(cpuid), hash, &size);
352	if (ret) {
353		debug("%s: failed to calculate SHA256\n", __func__);
354		return -1;
355	}
356
357	/* Copy 6 bytes of the hash to base the MAC address on */
358	memcpy(mac_addr, hash, 6);
359
360	/* Make this a valid MAC address and set it */
361	mac_addr[0] &= 0xfe;  /* clear multicast bit */
362	mac_addr[0] |= 0x02;  /* set local assignment bit (IEEE802) */
363	eth_env_set_enetaddr("ethaddr", mac_addr);
364
365	/* Make a valid MAC address for ethernet1 */
366	mac_addr[5] ^= 0x01;
367	eth_env_set_enetaddr("eth1addr", mac_addr);
368#endif
369	return 0;
370}
371
372int rockchip_cpuid_from_efuse(const u32 cpuid_offset,
373			      const u32 cpuid_length,
374			      u8 *cpuid)
375{
376#if IS_ENABLED(CONFIG_ROCKCHIP_EFUSE) || IS_ENABLED(CONFIG_ROCKCHIP_OTP)
377	struct udevice *dev;
378	int ret;
379
380	/* retrieve the device */
381#if IS_ENABLED(CONFIG_ROCKCHIP_EFUSE)
382	ret = uclass_get_device_by_driver(UCLASS_MISC,
383					  DM_DRIVER_GET(rockchip_efuse), &dev);
384#elif IS_ENABLED(CONFIG_ROCKCHIP_OTP)
385	ret = uclass_get_device_by_driver(UCLASS_MISC,
386					  DM_DRIVER_GET(rockchip_otp), &dev);
387#endif
388	if (ret) {
389		debug("%s: could not find efuse device\n", __func__);
390		return -1;
391	}
392
393	/* read the cpu_id range from the efuses */
394	ret = misc_read(dev, cpuid_offset, cpuid, cpuid_length);
395	if (ret < 0) {
396		debug("%s: reading cpuid from the efuses failed\n",
397		      __func__);
398		return -1;
399	}
400#endif
401	return 0;
402}
403
404int rockchip_cpuid_set(const u8 *cpuid, const u32 cpuid_length)
405{
406	u8 low[cpuid_length / 2], high[cpuid_length / 2];
407	char cpuid_str[cpuid_length * 2 + 1];
408	u64 serialno;
409	char serialno_str[17];
410	const char *oldid;
411	int i;
412
413	memset(cpuid_str, 0, sizeof(cpuid_str));
414	for (i = 0; i < cpuid_length; i++)
415		sprintf(&cpuid_str[i * 2], "%02x", cpuid[i]);
416
417	debug("cpuid: %s\n", cpuid_str);
418
419	/*
420	 * Mix the cpuid bytes using the same rules as in
421	 *   ${linux}/drivers/soc/rockchip/rockchip-cpuinfo.c
422	 */
423	for (i = 0; i < cpuid_length / 2; i++) {
424		low[i] = cpuid[1 + (i << 1)];
425		high[i] = cpuid[i << 1];
426	}
427
428	serialno = crc32_no_comp(0, low, cpuid_length / 2);
429	serialno |= (u64)crc32_no_comp(serialno, high, cpuid_length / 2) << 32;
430	snprintf(serialno_str, sizeof(serialno_str), "%016llx", serialno);
431
432	oldid = env_get("cpuid#");
433	if (oldid && strcmp(oldid, cpuid_str) != 0)
434		printf("cpuid: value %s present in env does not match hardware %s\n",
435		       oldid, cpuid_str);
436
437	env_set("cpuid#", cpuid_str);
438
439	/* Only generate serial# when none is set yet */
440	if (!env_get("serial#"))
441		env_set("serial#", serialno_str);
442
443	return 0;
444}
445
446__weak int rockchip_early_misc_init_r(void)
447{
448	return 0;
449}
450
451__weak int misc_init_r(void)
452{
453	const u32 cpuid_offset = CFG_CPUID_OFFSET;
454	const u32 cpuid_length = 0x10;
455	u8 cpuid[cpuid_length];
456	int ret;
457
458	ret = rockchip_early_misc_init_r();
459	if (ret)
460		return ret;
461
462	ret = rockchip_cpuid_from_efuse(cpuid_offset, cpuid_length, cpuid);
463	if (ret)
464		return ret;
465
466	ret = rockchip_cpuid_set(cpuid, cpuid_length);
467	if (ret)
468		return ret;
469
470	ret = rockchip_setup_macaddr();
471
472	return ret;
473}
474#endif
475
476#if IS_ENABLED(CONFIG_BOARD_RNG_SEED) && IS_ENABLED(CONFIG_RNG_ROCKCHIP)
477#include <rng.h>
478
479/* Use hardware rng to seed Linux random. */
480__weak int board_rng_seed(struct abuf *buf)
481{
482	struct udevice *dev;
483	size_t len = 0x8;
484	u64 *data;
485
486	data = malloc(len);
487	if (!data) {
488		printf("Out of memory\n");
489		return -ENOMEM;
490	}
491
492	if (uclass_get_device(UCLASS_RNG, 0, &dev) || !dev) {
493		printf("No RNG device\n");
494		return -ENODEV;
495	}
496
497	if (dm_rng_read(dev, data, len)) {
498		printf("Reading RNG failed\n");
499		return -EIO;
500	}
501
502	abuf_init_set(buf, data, len);
503
504	return 0;
505}
506#endif
507
508int mmc_get_env_dev(void)
509{
510	int devnum;
511	const char *boot_device;
512	struct udevice *dev;
513
514#ifdef CONFIG_SYS_MMC_ENV_DEV
515	devnum = CONFIG_SYS_MMC_ENV_DEV;
516#else
517	devnum = 0;
518#endif
519
520	boot_device = ofnode_read_chosen_string("u-boot,spl-boot-device");
521	if (!boot_device) {
522		debug("%s: /chosen/u-boot,spl-boot-device not set\n", __func__);
523		return devnum;
524	}
525
526	debug("%s: booted from %s\n", __func__, boot_device);
527
528	if (uclass_find_device_by_ofnode(UCLASS_MMC, ofnode_path(boot_device), &dev)) {
529		debug("%s: no U-Boot device found for %s\n", __func__, boot_device);
530		return devnum;
531	}
532
533	devnum = dev->seq_;
534	debug("%s: get MMC env from mmc%d\n", __func__, devnum);
535	return devnum;
536}
537