common/splash_source.c

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