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         default:
 124                 printf("Error: unsupported location storage.\n");
 125                 return -ENODEV;
 126         }
 127
 128         if (res)
 129                 printf("Error: could not access storage.\n");
 130
 131         return res;
 132 }
 133
 134 #ifdef CONFIG_USB_STORAGE
 135 static int splash_init_usb(void)
 136 {
 137         int err;
 138
 139         err = usb_init();
 140         if (err)
 141                 return err;
 142
 143         return usb_stor_scan(1) < 0 ? -ENODEV : 0;
 144 }
 145 #else
 146 static inline int splash_init_usb(void)
 147 {
 148         printf("Cannot load splash image: no USB support\n");
 149         return -ENOSYS;
 150 }
 151 #endif
 152
 153 #ifdef CONFIG_CMD_SATA
 154 static int splash_init_sata(void)
 155 {
 156         return sata_initialize();
 157 }
 158 #else
 159 static inline int splash_init_sata(void)
 160 {
 161         printf("Cannot load splash image: no SATA support\n");
 162         return -ENOSYS;
 163 }
 164 #endif
 165
 166 #define SPLASH_SOURCE_DEFAULT_FILE_NAME         "splash.bmp"
 167
 168 static int splash_load_fs(struct splash_location *location, u32 bmp_load_addr)
 169 {
 170         int res = 0;
 171         loff_t bmp_size;
 172         char *splash_file;
 173
 174         splash_file = getenv("splashfile");
 175         if (!splash_file)
 176                 splash_file = SPLASH_SOURCE_DEFAULT_FILE_NAME;
 177
 178         if (location->storage == SPLASH_STORAGE_USB)
 179                 res = splash_init_usb();
 180
 181         if (location->storage == SPLASH_STORAGE_SATA)
 182                 res = splash_init_sata();
 183
 184         if (res)
 185                 return res;
 186
 187         res = splash_select_fs_dev(location);
 188         if (res)
 189                 return res;
 190
 191         res = fs_size(splash_file, &bmp_size);
 192         if (res) {
 193                 printf("Error (%d): cannot determine file size\n", res);
 194                 return res;
 195         }
 196
 197         if (bmp_load_addr + bmp_size >= gd->start_addr_sp) {
 198                 printf("Error: splashimage address too high. Data overwrites U-Boot and/or placed beyond DRAM boundaries.\n");
 199                 return -EFAULT;
 200         }
 201
 202         splash_select_fs_dev(location);
 203         return fs_read(splash_file, bmp_load_addr, 0, 0, NULL);
 204 }
 205
 206 /**
 207  * select_splash_location - return the splash location based on board support
 208  *                          and env variable "splashsource".
 209  *
 210  * @locations:          An array of supported splash locations.
 211  * @size:               Size of splash_locations array.
 212  *
 213  * @return: If a null set of splash locations is given, or
 214  *          splashsource env variable is set to unsupported value
 215  *                      return NULL.
 216  *          If splashsource env variable is not defined
 217  *                      return the first entry in splash_locations as default.
 218  *          If splashsource env variable contains a supported value
 219  *                      return the location selected by splashsource.
 220  */
 221 static struct splash_location *select_splash_location(
 222                             struct splash_location *locations, uint size)
 223 {
 224         int i;
 225         char *env_splashsource;
 226
 227         if (!locations || size == 0)
 228                 return NULL;
 229
 230         env_splashsource = getenv("splashsource");
 231         if (env_splashsource == NULL)
 232                 return &locations[0];
 233
 234         for (i = 0; i < size; i++) {
 235                 if (!strcmp(locations[i].name, env_splashsource))
 236                         return &locations[i];
 237         }
 238
 239         printf("splashsource env variable set to unsupported value\n");
 240         return NULL;
 241 }
 242
 243 /**
 244  * splash_source_load - load splash image from a supported location.
 245  *
 246  * Select a splash image location based on the value of splashsource environment
 247  * variable and the board supported splash source locations, and load a
 248  * splashimage to the address pointed to by splashimage environment variable.
 249  *
 250  * @locations:          An array of supported splash locations.
 251  * @size:               Size of splash_locations array.
 252  *
 253  * @return: 0 on success, negative value on failure.
 254  */
 255 int splash_source_load(struct splash_location *locations, uint size)
 256 {
 257         struct splash_location *splash_location;
 258         char *env_splashimage_value;
 259         u32 bmp_load_addr;
 260
 261         env_splashimage_value = getenv("splashimage");
 262         if (env_splashimage_value == NULL)
 263                 return -ENOENT;
 264
 265         bmp_load_addr = simple_strtoul(env_splashimage_value, 0, 16);
 266         if (bmp_load_addr == 0) {
 267                 printf("Error: bad splashimage address specified\n");
 268                 return -EFAULT;
 269         }
 270
 271         splash_location = select_splash_location(locations, size);
 272         if (!splash_location)
 273                 return -EINVAL;
 274
 275         if (splash_location->flags & SPLASH_STORAGE_RAW)
 276                 return splash_load_raw(splash_location, bmp_load_addr);
 277         else if (splash_location->flags & SPLASH_STORAGE_FS)
 278                 return splash_load_fs(splash_location, bmp_load_addr);
 279
 280         return -EINVAL;
 281 }