1 /* 2 * (C) Copyright 2014 CompuLab, Ltd. <www.compulab.co.il> 3 * 4 * Authors: Igor Grinberg <grinberg@compulab.co.il> 5 * 6 * SPDX-License-Identifier: GPL-2.0+ 7 */ 8 9 #include <common.h> 10 #include <bmp_layout.h> 11 #include <errno.h> 12 #include <fs.h> 13 #include <fdt_support.h> 14 #include <image.h> 15 #include <nand.h> 16 #include <sata.h> 17 #include <spi.h> 18 #include <spi_flash.h> 19 #include <splash.h> 20 #include <usb.h> 21 22 DECLARE_GLOBAL_DATA_PTR; 23 24 #ifdef CONFIG_SPI_FLASH 25 static struct spi_flash *sf; 26 static int splash_sf_read_raw(u32 bmp_load_addr, int offset, size_t read_size) 27 { 28 if (!sf) { 29 sf = spi_flash_probe(CONFIG_SF_DEFAULT_BUS, 30 CONFIG_SF_DEFAULT_CS, 31 CONFIG_SF_DEFAULT_SPEED, 32 CONFIG_SF_DEFAULT_MODE); 33 if (!sf) 34 return -ENODEV; 35 } 36 37 return spi_flash_read(sf, offset, read_size, (void *)bmp_load_addr); 38 } 39 #else 40 static int splash_sf_read_raw(u32 bmp_load_addr, int offset, size_t read_size) 41 { 42 debug("%s: sf support not available\n", __func__); 43 return -ENOSYS; 44 } 45 #endif 46 47 #ifdef CONFIG_CMD_NAND 48 static int splash_nand_read_raw(u32 bmp_load_addr, int offset, size_t read_size) 49 { 50 return nand_read_skip_bad(nand_info[nand_curr_device], offset, 51 &read_size, NULL, 52 nand_info[nand_curr_device]->size, 53 (u_char *)bmp_load_addr); 54 } 55 #else 56 static int splash_nand_read_raw(u32 bmp_load_addr, int offset, size_t read_size) 57 { 58 debug("%s: nand support not available\n", __func__); 59 return -ENOSYS; 60 } 61 #endif 62 63 static int splash_storage_read_raw(struct splash_location *location, 64 u32 bmp_load_addr, size_t read_size) 65 { 66 u32 offset; 67 68 if (!location) 69 return -EINVAL; 70 71 offset = location->offset; 72 switch (location->storage) { 73 case SPLASH_STORAGE_NAND: 74 return splash_nand_read_raw(bmp_load_addr, offset, read_size); 75 case SPLASH_STORAGE_SF: 76 return splash_sf_read_raw(bmp_load_addr, offset, read_size); 77 default: 78 printf("Unknown splash location\n"); 79 } 80 81 return -EINVAL; 82 } 83 84 static int splash_load_raw(struct splash_location *location, u32 bmp_load_addr) 85 { 86 struct bmp_header *bmp_hdr; 87 int res; 88 size_t bmp_size, bmp_header_size = sizeof(struct bmp_header); 89 90 if (bmp_load_addr + bmp_header_size >= gd->start_addr_sp) 91 goto splash_address_too_high; 92 93 res = splash_storage_read_raw(location, bmp_load_addr, bmp_header_size); 94 if (res < 0) 95 return res; 96 97 bmp_hdr = (struct bmp_header *)bmp_load_addr; 98 bmp_size = le32_to_cpu(bmp_hdr->file_size); 99 100 if (bmp_load_addr + bmp_size >= gd->start_addr_sp) 101 goto splash_address_too_high; 102 103 return splash_storage_read_raw(location, bmp_load_addr, bmp_size); 104 105 splash_address_too_high: 106 printf("Error: splashimage address too high. Data overwrites U-Boot and/or placed beyond DRAM boundaries.\n"); 107 108 return -EFAULT; 109 } 110 111 static int splash_select_fs_dev(struct splash_location *location) 112 { 113 int res; 114 115 switch (location->storage) { 116 case SPLASH_STORAGE_MMC: 117 res = fs_set_blk_dev("mmc", location->devpart, FS_TYPE_ANY); 118 break; 119 case SPLASH_STORAGE_USB: 120 res = fs_set_blk_dev("usb", location->devpart, FS_TYPE_ANY); 121 break; 122 case SPLASH_STORAGE_SATA: 123 res = fs_set_blk_dev("sata", location->devpart, FS_TYPE_ANY); 124 break; 125 case SPLASH_STORAGE_NAND: 126 if (location->ubivol != NULL) 127 res = fs_set_blk_dev("ubi", NULL, FS_TYPE_UBIFS); 128 else 129 res = -ENODEV; 130 break; 131 default: 132 printf("Error: unsupported location storage.\n"); 133 return -ENODEV; 134 } 135 136 if (res) 137 printf("Error: could not access storage.\n"); 138 139 return res; 140 } 141 142 #ifdef CONFIG_USB_STORAGE 143 static int splash_init_usb(void) 144 { 145 int err; 146 147 err = usb_init(); 148 if (err) 149 return err; 150 151 #ifndef CONFIG_DM_USB 152 err = usb_stor_scan(1) < 0 ? -ENODEV : 0; 153 #endif 154 155 return err; 156 } 157 #else 158 static inline int splash_init_usb(void) 159 { 160 printf("Cannot load splash image: no USB support\n"); 161 return -ENOSYS; 162 } 163 #endif 164 165 #ifdef CONFIG_CMD_SATA 166 static int splash_init_sata(void) 167 { 168 return sata_initialize(); 169 } 170 #else 171 static inline int splash_init_sata(void) 172 { 173 printf("Cannot load splash image: no SATA support\n"); 174 return -ENOSYS; 175 } 176 #endif 177 178 #ifdef CONFIG_CMD_UBIFS 179 static int splash_mount_ubifs(struct splash_location *location) 180 { 181 int res; 182 char cmd[32]; 183 184 sprintf(cmd, "ubi part %s", location->mtdpart); 185 res = run_command(cmd, 0); 186 if (res) 187 return res; 188 189 sprintf(cmd, "ubifsmount %s", location->ubivol); 190 res = run_command(cmd, 0); 191 192 return res; 193 } 194 195 static inline int splash_umount_ubifs(void) 196 { 197 return run_command("ubifsumount", 0); 198 } 199 #else 200 static inline int splash_mount_ubifs(struct splash_location *location) 201 { 202 printf("Cannot load splash image: no UBIFS support\n"); 203 return -ENOSYS; 204 } 205 206 static inline int splash_umount_ubifs(void) 207 { 208 printf("Cannot unmount UBIFS: no UBIFS support\n"); 209 return -ENOSYS; 210 } 211 #endif 212 213 #define SPLASH_SOURCE_DEFAULT_FILE_NAME "splash.bmp" 214 215 static int splash_load_fs(struct splash_location *location, u32 bmp_load_addr) 216 { 217 int res = 0; 218 loff_t bmp_size; 219 loff_t actread; 220 char *splash_file; 221 222 splash_file = getenv("splashfile"); 223 if (!splash_file) 224 splash_file = SPLASH_SOURCE_DEFAULT_FILE_NAME; 225 226 if (location->storage == SPLASH_STORAGE_USB) 227 res = splash_init_usb(); 228 229 if (location->storage == SPLASH_STORAGE_SATA) 230 res = splash_init_sata(); 231 232 if (location->ubivol != NULL) 233 res = splash_mount_ubifs(location); 234 235 if (res) 236 return res; 237 238 res = splash_select_fs_dev(location); 239 if (res) 240 goto out; 241 242 res = fs_size(splash_file, &bmp_size); 243 if (res) { 244 printf("Error (%d): cannot determine file size\n", res); 245 goto out; 246 } 247 248 if (bmp_load_addr + bmp_size >= gd->start_addr_sp) { 249 printf("Error: splashimage address too high. Data overwrites U-Boot and/or placed beyond DRAM boundaries.\n"); 250 res = -EFAULT; 251 goto out; 252 } 253 254 splash_select_fs_dev(location); 255 res = fs_read(splash_file, bmp_load_addr, 0, 0, &actread); 256 257 out: 258 if (location->ubivol != NULL) 259 splash_umount_ubifs(); 260 261 return res; 262 } 263 264 /** 265 * select_splash_location - return the splash location based on board support 266 * and env variable "splashsource". 267 * 268 * @locations: An array of supported splash locations. 269 * @size: Size of splash_locations array. 270 * 271 * @return: If a null set of splash locations is given, or 272 * splashsource env variable is set to unsupported value 273 * return NULL. 274 * If splashsource env variable is not defined 275 * return the first entry in splash_locations as default. 276 * If splashsource env variable contains a supported value 277 * return the location selected by splashsource. 278 */ 279 static struct splash_location *select_splash_location( 280 struct splash_location *locations, uint size) 281 { 282 int i; 283 char *env_splashsource; 284 285 if (!locations || size == 0) 286 return NULL; 287 288 env_splashsource = getenv("splashsource"); 289 if (env_splashsource == NULL) 290 return &locations[0]; 291 292 for (i = 0; i < size; i++) { 293 if (!strcmp(locations[i].name, env_splashsource)) 294 return &locations[i]; 295 } 296 297 printf("splashsource env variable set to unsupported value\n"); 298 return NULL; 299 } 300 301 #ifdef CONFIG_FIT 302 static int splash_load_fit(struct splash_location *location, u32 bmp_load_addr) 303 { 304 int res; 305 int node_offset; 306 int splash_offset; 307 int splash_size; 308 struct image_header *img_header; 309 const u32 *fit_header; 310 u32 fit_size; 311 const size_t header_size = sizeof(struct image_header); 312 313 /* Read in image header */ 314 res = splash_storage_read_raw(location, bmp_load_addr, header_size); 315 if (res < 0) 316 return res; 317 318 img_header = (struct image_header *)bmp_load_addr; 319 fit_size = fdt_totalsize(img_header); 320 321 /* Read in entire FIT */ 322 fit_header = (const u32 *)(bmp_load_addr + header_size); 323 res = splash_storage_read_raw(location, (u32)fit_header, fit_size); 324 if (res < 0) 325 return res; 326 327 res = fit_check_format(fit_header); 328 if (!res) { 329 debug("Could not find valid FIT image\n"); 330 return -EINVAL; 331 } 332 333 node_offset = fit_image_get_node(fit_header, location->name); 334 if (node_offset < 0) { 335 debug("Could not find splash image '%s' in FIT\n", 336 location->name); 337 return -ENOENT; 338 } 339 340 res = fit_image_get_data_offset(fit_header, node_offset, 341 &splash_offset); 342 if (res < 0) { 343 printf("Failed to load splash image (err=%d)\n", res); 344 return res; 345 } 346 347 res = fit_image_get_data_size(fit_header, node_offset, &splash_size); 348 if (res < 0) { 349 printf("Failed to load splash image (err=%d)\n", res); 350 return res; 351 } 352 353 /* Align data offset to 4-byte boundrary */ 354 fit_size = fdt_totalsize(fit_header); 355 fit_size = (fit_size + 3) & ~3; 356 357 /* Read in the splash data */ 358 location->offset = (location->offset + fit_size + splash_offset); 359 res = splash_storage_read_raw(location, bmp_load_addr , splash_size); 360 if (res < 0) 361 return res; 362 363 return 0; 364 } 365 #endif /* CONFIG_FIT */ 366 367 /** 368 * splash_source_load - load splash image from a supported location. 369 * 370 * Select a splash image location based on the value of splashsource environment 371 * variable and the board supported splash source locations, and load a 372 * splashimage to the address pointed to by splashimage environment variable. 373 * 374 * @locations: An array of supported splash locations. 375 * @size: Size of splash_locations array. 376 * 377 * @return: 0 on success, negative value on failure. 378 */ 379 int splash_source_load(struct splash_location *locations, uint size) 380 { 381 struct splash_location *splash_location; 382 char *env_splashimage_value; 383 u32 bmp_load_addr; 384 385 env_splashimage_value = getenv("splashimage"); 386 if (env_splashimage_value == NULL) 387 return -ENOENT; 388 389 bmp_load_addr = simple_strtoul(env_splashimage_value, 0, 16); 390 if (bmp_load_addr == 0) { 391 printf("Error: bad splashimage address specified\n"); 392 return -EFAULT; 393 } 394 395 splash_location = select_splash_location(locations, size); 396 if (!splash_location) 397 return -EINVAL; 398 399 if (splash_location->flags == SPLASH_STORAGE_RAW) 400 return splash_load_raw(splash_location, bmp_load_addr); 401 else if (splash_location->flags == SPLASH_STORAGE_FS) 402 return splash_load_fs(splash_location, bmp_load_addr); 403 #ifdef CONFIG_FIT 404 else if (splash_location->flags == SPLASH_STORAGE_FIT) 405 return splash_load_fit(splash_location, bmp_load_addr); 406 #endif 407 return -EINVAL; 408 } 409