common/splash_source.c

   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 <nand.h>
  11 #include <errno.h>
  12 #include <splash.h>
  13 #include <spi_flash.h>
  14 #include <spi.h>
  15 #include <usb.h>
  16 #include <sata.h>
  17 #include <bmp_layout.h>
  18 #include <fs.h>
  19
  20 DECLARE_GLOBAL_DATA_PTR;
  21
  22 #ifdef CONFIG_SPI_FLASH
  23 static struct spi_flash *sf;
  24 static int splash_sf_read_raw(u32 bmp_load_addr, int offset, size_t read_size)
  25 {
  26         if (!sf) {
  27                 sf = spi_flash_probe(CONFIG_SF_DEFAULT_BUS,
  28                                      CONFIG_SF_DEFAULT_CS,
  29                                      CONFIG_SF_DEFAULT_SPEED,
  30                                      CONFIG_SF_DEFAULT_MODE);
  31                 if (!sf)
  32                         return -ENODEV;
  33         }
  34
  35         return spi_flash_read(sf, offset, read_size, (void *)bmp_load_addr);
  36 }
  37 #else
  38 static int splash_sf_read_raw(u32 bmp_load_addr, int offset, size_t read_size)
  39 {
  40         debug("%s: sf support not available\n", __func__);
  41         return -ENOSYS;
  42 }
  43 #endif
  44
  45 #ifdef CONFIG_CMD_NAND
  46 static int splash_nand_read_raw(u32 bmp_load_addr, int offset, size_t read_size)
  47 {
  48         return nand_read_skip_bad(nand_info[nand_curr_device], offset,
  49                                   &read_size, NULL,
  50                                   nand_info[nand_curr_device]->size,
  51                                   (u_char *)bmp_load_addr);
  52 }
  53 #else
  54 static int splash_nand_read_raw(u32 bmp_load_addr, int offset, size_t read_size)
  55 {
  56         debug("%s: nand support not available\n", __func__);
  57         return -ENOSYS;
  58 }
  59 #endif
  60
  61 static int splash_storage_read_raw(struct splash_location *location,
  62                                u32 bmp_load_addr, size_t read_size)
  63 {
  64         u32 offset;
  65
  66         if (!location)
  67                 return -EINVAL;
  68
  69         offset = location->offset;
  70         switch (location->storage) {
  71         case SPLASH_STORAGE_NAND:
  72                 return splash_nand_read_raw(bmp_load_addr, offset, read_size);
  73         case SPLASH_STORAGE_SF:
  74                 return splash_sf_read_raw(bmp_load_addr, offset, read_size);
  75         default:
  76                 printf("Unknown splash location\n");
  77         }
  78
  79         return -EINVAL;
  80 }
  81
  82 static int splash_load_raw(struct splash_location *location, u32 bmp_load_addr)
  83 {
  84         struct bmp_header *bmp_hdr;
  85         int res;
  86         size_t bmp_size, bmp_header_size = sizeof(struct bmp_header);
  87
  88         if (bmp_load_addr + bmp_header_size >= gd->start_addr_sp)
  89                 goto splash_address_too_high;
  90
  91         res = splash_storage_read_raw(location, bmp_load_addr, bmp_header_size);
  92         if (res < 0)
  93                 return res;
  94
  95         bmp_hdr = (struct bmp_header *)bmp_load_addr;
  96         bmp_size = le32_to_cpu(bmp_hdr->file_size);
  97
  98         if (bmp_load_addr + bmp_size >= gd->start_addr_sp)
  99                 goto splash_address_too_high;
 100
 101         return splash_storage_read_raw(location, bmp_load_addr, bmp_size);
 102
 103 splash_address_too_high:
 104         printf("Error: splashimage address too high. Data overwrites U-Boot and/or placed beyond DRAM boundaries.\n");
 105
 106         return -EFAULT;
 107 }
 108
 109 static int splash_select_fs_dev(struct splash_location *location)
 110 {
 111         int res;
 112
 113         switch (location->storage) {
 114         case SPLASH_STORAGE_MMC:
 115                 res = fs_set_blk_dev("mmc", location->devpart, FS_TYPE_ANY);
 116                 break;
 117         case SPLASH_STORAGE_USB:
 118                 res = fs_set_blk_dev("usb", location->devpart, FS_TYPE_ANY);
 119                 break;
 120         case SPLASH_STORAGE_SATA:
 121                 res = fs_set_blk_dev("sata", location->devpart, FS_TYPE_ANY);
 122                 break;
 123         case SPLASH_STORAGE_NAND:
 124                 if (location->ubivol != NULL)
 125                         res = fs_set_blk_dev("ubi", NULL, FS_TYPE_UBIFS);
 126                 else
 127                         res = -ENODEV;
 128                 break;
 129         default:
 130                 printf("Error: unsupported location storage.\n");
 131                 return -ENODEV;
 132         }
 133
 134         if (res)
 135                 printf("Error: could not access storage.\n");
 136
 137         return res;
 138 }
 139
 140 #ifdef CONFIG_USB_STORAGE
 141 static int splash_init_usb(void)
 142 {
 143         int err;
 144
 145         err = usb_init();
 146         if (err)
 147                 return err;
 148
 149         return usb_stor_scan(1) < 0 ? -ENODEV : 0;
 150 }
 151 #else
 152 static inline int splash_init_usb(void)
 153 {
 154         printf("Cannot load splash image: no USB support\n");
 155         return -ENOSYS;
 156 }
 157 #endif
 158
 159 #ifdef CONFIG_CMD_SATA
 160 static int splash_init_sata(void)
 161 {
 162         return sata_initialize();
 163 }
 164 #else
 165 static inline int splash_init_sata(void)
 166 {
 167         printf("Cannot load splash image: no SATA support\n");
 168         return -ENOSYS;
 169 }
 170 #endif
 171
 172 #ifdef CONFIG_CMD_UBIFS
 173 static int splash_mount_ubifs(struct splash_location *location)
 174 {
 175         int res;
 176         char cmd[32];
 177
 178         sprintf(cmd, "ubi part %s", location->mtdpart);
 179         res = run_command(cmd, 0);
 180         if (res)
 181                 return res;
 182
 183         sprintf(cmd, "ubifsmount %s", location->ubivol);
 184         res = run_command(cmd, 0);
 185
 186         return res;
 187 }
 188
 189 static inline int splash_umount_ubifs(void)
 190 {
 191         return run_command("ubifsumount", 0);
 192 }
 193 #else
 194 static inline int splash_mount_ubifs(struct splash_location *location)
 195 {
 196         printf("Cannot load splash image: no UBIFS support\n");
 197         return -ENOSYS;
 198 }
 199
 200 static inline int splash_umount_ubifs(void)
 201 {
 202         printf("Cannot unmount UBIFS: no UBIFS support\n");
 203         return -ENOSYS;
 204 }
 205 #endif
 206
 207 #define SPLASH_SOURCE_DEFAULT_FILE_NAME         "splash.bmp"
 208
 209 static int splash_load_fs(struct splash_location *location, u32 bmp_load_addr)
 210 {
 211         int res = 0;
 212         loff_t bmp_size;
 213         char *splash_file;
 214
 215         splash_file = getenv("splashfile");
 216         if (!splash_file)
 217                 splash_file = SPLASH_SOURCE_DEFAULT_FILE_NAME;
 218
 219         if (location->storage == SPLASH_STORAGE_USB)
 220                 res = splash_init_usb();
 221
 222         if (location->storage == SPLASH_STORAGE_SATA)
 223                 res = splash_init_sata();
 224
 225         if (location->ubivol != NULL)
 226                 res = splash_mount_ubifs(location);
 227
 228         if (res)
 229                 return res;
 230
 231         res = splash_select_fs_dev(location);
 232         if (res)
 233                 goto out;
 234
 235         res = fs_size(splash_file, &bmp_size);
 236         if (res) {
 237                 printf("Error (%d): cannot determine file size\n", res);
 238                 goto out;
 239         }
 240
 241         if (bmp_load_addr + bmp_size >= gd->start_addr_sp) {
 242                 printf("Error: splashimage address too high. Data overwrites U-Boot and/or placed beyond DRAM boundaries.\n");
 243                 res = -EFAULT;
 244                 goto out;
 245         }
 246
 247         splash_select_fs_dev(location);
 248         res = fs_read(splash_file, bmp_load_addr, 0, 0, NULL);
 249
 250 out:
 251         if (location->ubivol != NULL)
 252                 splash_umount_ubifs();
 253
 254         return res;
 255 }
 256
 257 /**
 258  * select_splash_location - return the splash location based on board support
 259  *                          and env variable "splashsource".
 260  *
 261  * @locations:          An array of supported splash locations.
 262  * @size:               Size of splash_locations array.
 263  *
 264  * @return: If a null set of splash locations is given, or
 265  *          splashsource env variable is set to unsupported value
 266  *                      return NULL.
 267  *          If splashsource env variable is not defined
 268  *                      return the first entry in splash_locations as default.
 269  *          If splashsource env variable contains a supported value
 270  *                      return the location selected by splashsource.
 271  */
 272 static struct splash_location *select_splash_location(
 273                             struct splash_location *locations, uint size)
 274 {
 275         int i;
 276         char *env_splashsource;
 277
 278         if (!locations || size == 0)
 279                 return NULL;
 280
 281         env_splashsource = getenv("splashsource");
 282         if (env_splashsource == NULL)
 283                 return &locations[0];
 284
 285         for (i = 0; i < size; i++) {
 286                 if (!strcmp(locations[i].name, env_splashsource))
 287                         return &locations[i];
 288         }
 289
 290         printf("splashsource env variable set to unsupported value\n");
 291         return NULL;
 292 }
 293
 294 /**
 295  * splash_source_load - load splash image from a supported location.
 296  *
 297  * Select a splash image location based on the value of splashsource environment
 298  * variable and the board supported splash source locations, and load a
 299  * splashimage to the address pointed to by splashimage environment variable.
 300  *
 301  * @locations:          An array of supported splash locations.
 302  * @size:               Size of splash_locations array.
 303  *
 304  * @return: 0 on success, negative value on failure.
 305  */
 306 int splash_source_load(struct splash_location *locations, uint size)
 307 {
 308         struct splash_location *splash_location;
 309         char *env_splashimage_value;
 310         u32 bmp_load_addr;
 311
 312         env_splashimage_value = getenv("splashimage");
 313         if (env_splashimage_value == NULL)
 314                 return -ENOENT;
 315
 316         bmp_load_addr = simple_strtoul(env_splashimage_value, 0, 16);
 317         if (bmp_load_addr == 0) {
 318                 printf("Error: bad splashimage address specified\n");
 319                 return -EFAULT;
 320         }
 321
 322         splash_location = select_splash_location(locations, size);
 323         if (!splash_location)
 324                 return -EINVAL;
 325
 326         if (splash_location->flags & SPLASH_STORAGE_RAW)
 327                 return splash_load_raw(splash_location, bmp_load_addr);
 328         else if (splash_location->flags & SPLASH_STORAGE_FS)
 329                 return splash_load_fs(splash_location, bmp_load_addr);
 330
 331         return -EINVAL;
 332 }