1 /* 2 * (C) Copyright 2019 Rockchip Electronics Co., Ltd 3 * 4 * SPDX-License-Identifier: GPL-2.0+ 5 */ 6 #include <common.h> 7 #include <boot_rkimg.h> 8 #include <dm.h> 9 #include <malloc.h> 10 #include <of_live.h> 11 #include <dm/root.h> 12 #include <asm/arch/hotkey.h> 13 14 DECLARE_GLOBAL_DATA_PTR; 15 16 /* Here, only fixup cru phandle, pmucru is not included */ 17 static int phandles_fixup_cru(const void *fdt) 18 { 19 const char *props[] = { "clocks", "assigned-clocks", "resets"}; 20 struct udevice *dev; 21 struct uclass *uc; 22 const char *comp; 23 u32 id, nclocks; 24 u32 *clocks; 25 int phandle, ncells; 26 int off, offset; 27 int ret, length; 28 int i, j; 29 int first_phandle = -1; 30 31 phandle = -ENODATA; 32 ncells = -ENODATA; 33 34 /* fdt points to kernel dtb, getting cru phandle and "#clock-cells" */ 35 for (offset = fdt_next_node(fdt, 0, NULL); 36 offset >= 0; 37 offset = fdt_next_node(fdt, offset, NULL)) { 38 comp = fdt_getprop(fdt, offset, "compatible", NULL); 39 if (!comp) 40 continue; 41 42 /* Actually, this is not a good method to get cru node */ 43 off = strlen(comp) - strlen("-cru"); 44 if (off > 0 && !strncmp(comp + off, "-cru", 4)) { 45 phandle = fdt_get_phandle(fdt, offset); 46 ncells = fdtdec_get_int(fdt, offset, 47 "#clock-cells", -ENODATA); 48 break; 49 } 50 } 51 52 if (phandle == -ENODATA || ncells == -ENODATA) 53 return 0; 54 55 debug("%s: target cru: clock-cells:%d, phandle:0x%x\n", 56 __func__, ncells, fdt32_to_cpu(phandle)); 57 58 /* Try to fixup all cru phandle from U-Boot dtb nodes */ 59 for (id = 0; id < UCLASS_COUNT; id++) { 60 ret = uclass_get(id, &uc); 61 if (ret) 62 continue; 63 64 if (list_empty(&uc->dev_head)) 65 continue; 66 67 list_for_each_entry(dev, &uc->dev_head, uclass_node) { 68 /* Only U-Boot node go further */ 69 if (!dev_read_bool(dev, "u-boot,dm-pre-reloc") && 70 !dev_read_bool(dev, "u-boot,dm-spl")) 71 continue; 72 73 for (i = 0; i < ARRAY_SIZE(props); i++) { 74 if (!dev_read_prop(dev, props[i], &length)) 75 continue; 76 77 clocks = malloc(length); 78 if (!clocks) 79 return -ENOMEM; 80 81 /* Read "props[]" which contains cru phandle */ 82 nclocks = length / sizeof(u32); 83 if (dev_read_u32_array(dev, props[i], 84 clocks, nclocks)) { 85 free(clocks); 86 continue; 87 } 88 89 /* Fixup with kernel cru phandle */ 90 for (j = 0; j < nclocks; j += (ncells + 1)) { 91 /* 92 * Check: update pmucru phandle with cru 93 * phandle by mistake. 94 */ 95 if (first_phandle == -1) 96 first_phandle = clocks[j]; 97 98 if (clocks[j] != first_phandle) { 99 debug("WARN: %s: first cru phandle=%d, this=%d\n", 100 dev_read_name(dev), 101 first_phandle, clocks[j]); 102 continue; 103 } 104 105 clocks[j] = phandle; 106 } 107 108 /* 109 * Override live dt nodes but not fdt nodes, 110 * because all U-Boot nodes has been imported 111 * to live dt nodes, should use "dev_xxx()". 112 */ 113 dev_write_u32_array(dev, props[i], 114 clocks, nclocks); 115 free(clocks); 116 } 117 } 118 } 119 120 return 0; 121 } 122 123 static int phandles_fixup_gpio(const void *fdt, void *ufdt) 124 { 125 struct udevice *dev; 126 struct uclass *uc; 127 const char *prop = "gpios"; 128 const char *comp; 129 char *gpio_name[10]; 130 int gpio_off[10]; 131 int pinctrl; 132 int offset; 133 int i = 0; 134 int n = 0; 135 136 pinctrl = fdt_path_offset(fdt, "/pinctrl"); 137 if (pinctrl < 0) 138 return 0; 139 140 memset(gpio_name, 0, sizeof(gpio_name)); 141 for (offset = fdt_first_subnode(fdt, pinctrl); 142 offset >= 0; 143 offset = fdt_next_subnode(fdt, offset)) { 144 /* assume the font nodes are gpio node */ 145 if (++i >= ARRAY_SIZE(gpio_name)) 146 break; 147 148 comp = fdt_getprop(fdt, offset, "compatible", NULL); 149 if (!comp) 150 continue; 151 152 if (!strcmp(comp, "rockchip,gpio-bank")) { 153 gpio_name[n] = (char *)fdt_get_name(fdt, offset, NULL); 154 gpio_off[n] = offset; 155 n++; 156 } 157 } 158 159 if (!gpio_name[0]) 160 return 0; 161 162 if (uclass_get(UCLASS_KEY, &uc) || list_empty(&uc->dev_head)) 163 return 0; 164 165 list_for_each_entry(dev, &uc->dev_head, uclass_node) { 166 u32 new_phd, phd_old; 167 char *name; 168 ofnode ofn; 169 170 if (!dev_read_bool(dev, "u-boot,dm-pre-reloc") && 171 !dev_read_bool(dev, "u-boot,dm-spl")) 172 continue; 173 174 if (dev_read_u32_array(dev, prop, &phd_old, 1)) 175 continue; 176 177 ofn = ofnode_get_by_phandle(phd_old); 178 if (!ofnode_valid(ofn)) 179 continue; 180 181 name = (char *)ofnode_get_name(ofn); 182 if (!name) 183 continue; 184 185 for (i = 0; i < ARRAY_SIZE(gpio_name); i++) { 186 if (gpio_name[i] && !strcmp(name, gpio_name[i])) { 187 new_phd = fdt_get_phandle(fdt, gpio_off[i]); 188 dev_write_u32_array(dev, prop, &new_phd, 1); 189 break; 190 } 191 } 192 } 193 194 return 0; 195 } 196 197 __weak int board_mmc_dm_reinit(struct udevice *dev) 198 { 199 return 0; 200 } 201 202 static int mmc_dm_reinit(void) 203 { 204 struct udevice *dev; 205 struct uclass *uc; 206 int ret; 207 208 if (uclass_get(UCLASS_MMC, &uc) || list_empty(&uc->dev_head)) 209 return 0; 210 211 list_for_each_entry(dev, &uc->dev_head, uclass_node) { 212 ret = board_mmc_dm_reinit(dev); 213 if (ret) 214 return ret; 215 } 216 217 return 0; 218 } 219 220 /* Check by property: "/compatible" */ 221 static int dtb_check_ok(void *kfdt, void *ufdt) 222 { 223 const char *compat; 224 int index; 225 226 /* TODO */ 227 return 1; 228 229 for (index = 0; 230 compat = fdt_stringlist_get(ufdt, 0, "compatible", 231 index, NULL), compat; 232 index++) { 233 debug("u-compat: %s\n", compat); 234 if (!fdt_node_check_compatible(kfdt, 0, compat)) 235 return 1; 236 } 237 238 return 0; 239 } 240 241 int init_kernel_dtb(void) 242 { 243 ulong fdt_addr = 0; 244 void *ufdt_blob; 245 int ret = -ENODEV; 246 247 /* 248 * If memory size <= 128MB, we firstly try to get "fdt_addr1_r". 249 */ 250 if (gd->ram_size <= SZ_128M) 251 fdt_addr = env_get_ulong("fdt_addr1_r", 16, 0); 252 253 if (!fdt_addr) 254 fdt_addr = env_get_ulong("fdt_addr_r", 16, 0); 255 if (!fdt_addr) { 256 printf("No Found FDT Load Address.\n"); 257 return -ENODEV; 258 } 259 260 if (IS_ENABLED(CONFIG_EMBED_KERNEL_DTB_ALWAYS)) { 261 printf("Always embed kernel dtb\n"); 262 goto dtb_embed; 263 } 264 265 ret = rockchip_read_dtb_file((void *)fdt_addr); 266 if (!ret) { 267 if (!dtb_check_ok((void *)fdt_addr, (void *)gd->fdt_blob)) { 268 ret = -EINVAL; 269 printf("Kernel dtb mismatch this platform!\n"); 270 } else { 271 goto dtb_okay; 272 } 273 } 274 275 dtb_embed: 276 if (gd->fdt_blob_kern) { 277 if (!dtb_check_ok((void *)gd->fdt_blob_kern, (void *)gd->fdt_blob)) { 278 printf("Embedded kernel dtb mismatch this platform!\n"); 279 return -EINVAL; 280 } 281 282 fdt_addr = (ulong)memalign(ARCH_DMA_MINALIGN, 283 fdt_totalsize(gd->fdt_blob_kern)); 284 if (!fdt_addr) 285 return -ENOMEM; 286 287 /* 288 * Alloc another space for this embed kernel dtb. 289 * Because "fdt_addr_r" *MUST* be the fdt passed to kernel. 290 */ 291 memcpy((void *)fdt_addr, gd->fdt_blob_kern, 292 fdt_totalsize(gd->fdt_blob_kern)); 293 printf("DTB: %s\n", CONFIG_EMBED_KERNEL_DTB_PATH); 294 } else { 295 printf("Failed to get kernel dtb, ret=%d\n", ret); 296 return -ENOENT; 297 } 298 299 dtb_okay: 300 ufdt_blob = (void *)gd->fdt_blob; 301 gd->fdt_blob = (void *)fdt_addr; 302 303 hotkey_run(HK_FDT); 304 305 /* 306 * There is a phandle miss match between U-Boot and kernel dtb node, 307 * we fixup it in U-Boot live dt nodes. 308 * 309 * CRU: all nodes. 310 * GPIO: key nodes. 311 */ 312 phandles_fixup_cru((void *)gd->fdt_blob); 313 phandles_fixup_gpio((void *)gd->fdt_blob, (void *)ufdt_blob); 314 315 gd->flags |= GD_FLG_KDTB_READY; 316 of_live_build((void *)gd->fdt_blob, (struct device_node **)&gd->of_root); 317 dm_scan_fdt((void *)gd->fdt_blob, false); 318 319 /* 320 * There maybe something for the mmc devices to do after kernel dtb 321 * dm setup, eg: regain the clock device binding from kernel dtb. 322 */ 323 mmc_dm_reinit(); 324 325 /* Reserve 'reserved-memory' */ 326 ret = boot_fdt_add_sysmem_rsv_regions((void *)gd->fdt_blob); 327 if (ret) 328 return ret; 329 330 return 0; 331 } 332