Igor Grinberg | 86ec16b | 2014-11-03 11:32:20 +0200 | [diff] [blame] | 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> |
Nikita Kiryanov | f58c509 | 2015-01-14 10:42:49 +0200 | [diff] [blame] | 11 | #include <errno.h> |
Nikita Kiryanov | 7f9ceea | 2015-01-14 10:42:54 +0200 | [diff] [blame] | 12 | #include <splash.h> |
Nikita Kiryanov | 1ab4c76 | 2015-01-14 10:42:52 +0200 | [diff] [blame] | 13 | #include <spi_flash.h> |
| 14 | #include <spi.h> |
Nikita Kiryanov | bf5c3cc | 2015-10-29 11:54:42 +0200 | [diff] [blame] | 15 | #include <usb.h> |
Nikita Kiryanov | 80ca30d | 2015-10-29 11:54:43 +0200 | [diff] [blame] | 16 | #include <sata.h> |
Igor Grinberg | 86ec16b | 2014-11-03 11:32:20 +0200 | [diff] [blame] | 17 | #include <bmp_layout.h> |
Nikita Kiryanov | 7428271 | 2015-10-29 11:54:41 +0200 | [diff] [blame] | 18 | #include <fs.h> |
Igor Grinberg | 86ec16b | 2014-11-03 11:32:20 +0200 | [diff] [blame] | 19 | |
| 20 | DECLARE_GLOBAL_DATA_PTR; |
| 21 | |
Nikita Kiryanov | 1ab4c76 | 2015-01-14 10:42:52 +0200 | [diff] [blame] | 22 | #ifdef CONFIG_SPI_FLASH |
| 23 | static struct spi_flash *sf; |
Nikita Kiryanov | b8183de | 2015-10-29 11:54:40 +0200 | [diff] [blame] | 24 | static int splash_sf_read_raw(u32 bmp_load_addr, int offset, size_t read_size) |
Nikita Kiryanov | 1ab4c76 | 2015-01-14 10:42:52 +0200 | [diff] [blame] | 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 |
Nikita Kiryanov | b8183de | 2015-10-29 11:54:40 +0200 | [diff] [blame] | 38 | static int splash_sf_read_raw(u32 bmp_load_addr, int offset, size_t read_size) |
Nikita Kiryanov | 1ab4c76 | 2015-01-14 10:42:52 +0200 | [diff] [blame] | 39 | { |
| 40 | debug("%s: sf support not available\n", __func__); |
| 41 | return -ENOSYS; |
| 42 | } |
| 43 | #endif |
| 44 | |
Igor Grinberg | 86ec16b | 2014-11-03 11:32:20 +0200 | [diff] [blame] | 45 | #ifdef CONFIG_CMD_NAND |
Nikita Kiryanov | b8183de | 2015-10-29 11:54:40 +0200 | [diff] [blame] | 46 | static int splash_nand_read_raw(u32 bmp_load_addr, int offset, size_t read_size) |
Nikita Kiryanov | 4b4bfd6 | 2015-01-14 10:42:50 +0200 | [diff] [blame] | 47 | { |
Scott Wood | 2c1b7e1 | 2016-05-30 13:57:55 -0500 | [diff] [blame] | 48 | return nand_read_skip_bad(nand_info[nand_curr_device], offset, |
Nikita Kiryanov | 4b4bfd6 | 2015-01-14 10:42:50 +0200 | [diff] [blame] | 49 | &read_size, NULL, |
Scott Wood | 2c1b7e1 | 2016-05-30 13:57:55 -0500 | [diff] [blame] | 50 | nand_info[nand_curr_device]->size, |
Nikita Kiryanov | 4b4bfd6 | 2015-01-14 10:42:50 +0200 | [diff] [blame] | 51 | (u_char *)bmp_load_addr); |
| 52 | } |
| 53 | #else |
Nikita Kiryanov | b8183de | 2015-10-29 11:54:40 +0200 | [diff] [blame] | 54 | static int splash_nand_read_raw(u32 bmp_load_addr, int offset, size_t read_size) |
Nikita Kiryanov | 4b4bfd6 | 2015-01-14 10:42:50 +0200 | [diff] [blame] | 55 | { |
| 56 | debug("%s: nand support not available\n", __func__); |
| 57 | return -ENOSYS; |
| 58 | } |
| 59 | #endif |
| 60 | |
Nikita Kiryanov | b8183de | 2015-10-29 11:54:40 +0200 | [diff] [blame] | 61 | static int splash_storage_read_raw(struct splash_location *location, |
Nikita Kiryanov | c2a07e3 | 2015-01-14 10:42:51 +0200 | [diff] [blame] | 62 | u32 bmp_load_addr, size_t read_size) |
Nikita Kiryanov | 4b4bfd6 | 2015-01-14 10:42:50 +0200 | [diff] [blame] | 63 | { |
Nikita Kiryanov | c2a07e3 | 2015-01-14 10:42:51 +0200 | [diff] [blame] | 64 | u32 offset; |
| 65 | |
| 66 | if (!location) |
| 67 | return -EINVAL; |
| 68 | |
| 69 | offset = location->offset; |
| 70 | switch (location->storage) { |
| 71 | case SPLASH_STORAGE_NAND: |
Nikita Kiryanov | b8183de | 2015-10-29 11:54:40 +0200 | [diff] [blame] | 72 | return splash_nand_read_raw(bmp_load_addr, offset, read_size); |
Nikita Kiryanov | 1ab4c76 | 2015-01-14 10:42:52 +0200 | [diff] [blame] | 73 | case SPLASH_STORAGE_SF: |
Nikita Kiryanov | b8183de | 2015-10-29 11:54:40 +0200 | [diff] [blame] | 74 | return splash_sf_read_raw(bmp_load_addr, offset, read_size); |
Nikita Kiryanov | c2a07e3 | 2015-01-14 10:42:51 +0200 | [diff] [blame] | 75 | default: |
| 76 | printf("Unknown splash location\n"); |
| 77 | } |
| 78 | |
| 79 | return -EINVAL; |
Nikita Kiryanov | 4b4bfd6 | 2015-01-14 10:42:50 +0200 | [diff] [blame] | 80 | } |
| 81 | |
Nikita Kiryanov | c2a07e3 | 2015-01-14 10:42:51 +0200 | [diff] [blame] | 82 | static int splash_load_raw(struct splash_location *location, u32 bmp_load_addr) |
Igor Grinberg | 86ec16b | 2014-11-03 11:32:20 +0200 | [diff] [blame] | 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 | |
Nikita Kiryanov | b8183de | 2015-10-29 11:54:40 +0200 | [diff] [blame] | 91 | res = splash_storage_read_raw(location, bmp_load_addr, bmp_header_size); |
Igor Grinberg | 86ec16b | 2014-11-03 11:32:20 +0200 | [diff] [blame] | 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 | |
Nikita Kiryanov | b8183de | 2015-10-29 11:54:40 +0200 | [diff] [blame] | 101 | return splash_storage_read_raw(location, bmp_load_addr, bmp_size); |
Igor Grinberg | 86ec16b | 2014-11-03 11:32:20 +0200 | [diff] [blame] | 102 | |
| 103 | splash_address_too_high: |
Nikita Kiryanov | 7f9ceea | 2015-01-14 10:42:54 +0200 | [diff] [blame] | 104 | printf("Error: splashimage address too high. Data overwrites U-Boot and/or placed beyond DRAM boundaries.\n"); |
Igor Grinberg | 86ec16b | 2014-11-03 11:32:20 +0200 | [diff] [blame] | 105 | |
Nikita Kiryanov | f58c509 | 2015-01-14 10:42:49 +0200 | [diff] [blame] | 106 | return -EFAULT; |
Igor Grinberg | 86ec16b | 2014-11-03 11:32:20 +0200 | [diff] [blame] | 107 | } |
Igor Grinberg | 86ec16b | 2014-11-03 11:32:20 +0200 | [diff] [blame] | 108 | |
Nikita Kiryanov | 7428271 | 2015-10-29 11:54:41 +0200 | [diff] [blame] | 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; |
Nikita Kiryanov | bf5c3cc | 2015-10-29 11:54:42 +0200 | [diff] [blame] | 117 | case SPLASH_STORAGE_USB: |
| 118 | res = fs_set_blk_dev("usb", location->devpart, FS_TYPE_ANY); |
| 119 | break; |
Nikita Kiryanov | 80ca30d | 2015-10-29 11:54:43 +0200 | [diff] [blame] | 120 | case SPLASH_STORAGE_SATA: |
| 121 | res = fs_set_blk_dev("sata", location->devpart, FS_TYPE_ANY); |
| 122 | break; |
Nikita Kiryanov | 7428271 | 2015-10-29 11:54:41 +0200 | [diff] [blame] | 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 | } |
Nikita Kiryanov | bf5c3cc | 2015-10-29 11:54:42 +0200 | [diff] [blame] | 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 |
Nikita Kiryanov | 7428271 | 2015-10-29 11:54:41 +0200 | [diff] [blame] | 152 | |
Nikita Kiryanov | 80ca30d | 2015-10-29 11:54:43 +0200 | [diff] [blame] | 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 | |
Nikita Kiryanov | 7428271 | 2015-10-29 11:54:41 +0200 | [diff] [blame] | 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 | { |
Nikita Kiryanov | bf5c3cc | 2015-10-29 11:54:42 +0200 | [diff] [blame] | 170 | int res = 0; |
Nikita Kiryanov | 7428271 | 2015-10-29 11:54:41 +0200 | [diff] [blame] | 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 | |
Nikita Kiryanov | bf5c3cc | 2015-10-29 11:54:42 +0200 | [diff] [blame] | 178 | if (location->storage == SPLASH_STORAGE_USB) |
| 179 | res = splash_init_usb(); |
| 180 | |
Nikita Kiryanov | 80ca30d | 2015-10-29 11:54:43 +0200 | [diff] [blame] | 181 | if (location->storage == SPLASH_STORAGE_SATA) |
| 182 | res = splash_init_sata(); |
| 183 | |
Nikita Kiryanov | bf5c3cc | 2015-10-29 11:54:42 +0200 | [diff] [blame] | 184 | if (res) |
| 185 | return res; |
| 186 | |
Nikita Kiryanov | 7428271 | 2015-10-29 11:54:41 +0200 | [diff] [blame] | 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 | |
Nikita Kiryanov | c2a07e3 | 2015-01-14 10:42:51 +0200 | [diff] [blame] | 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) |
Igor Grinberg | 86ec16b | 2014-11-03 11:32:20 +0200 | [diff] [blame] | 223 | { |
Nikita Kiryanov | c2a07e3 | 2015-01-14 10:42:51 +0200 | [diff] [blame] | 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 | |
Nikita Kiryanov | 7f9ceea | 2015-01-14 10:42:54 +0200 | [diff] [blame] | 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) |
Nikita Kiryanov | c2a07e3 | 2015-01-14 10:42:51 +0200 | [diff] [blame] | 256 | { |
| 257 | struct splash_location *splash_location; |
Igor Grinberg | 86ec16b | 2014-11-03 11:32:20 +0200 | [diff] [blame] | 258 | char *env_splashimage_value; |
| 259 | u32 bmp_load_addr; |
| 260 | |
| 261 | env_splashimage_value = getenv("splashimage"); |
| 262 | if (env_splashimage_value == NULL) |
Nikita Kiryanov | f58c509 | 2015-01-14 10:42:49 +0200 | [diff] [blame] | 263 | return -ENOENT; |
Igor Grinberg | 86ec16b | 2014-11-03 11:32:20 +0200 | [diff] [blame] | 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"); |
Nikita Kiryanov | f58c509 | 2015-01-14 10:42:49 +0200 | [diff] [blame] | 268 | return -EFAULT; |
Igor Grinberg | 86ec16b | 2014-11-03 11:32:20 +0200 | [diff] [blame] | 269 | } |
| 270 | |
Nikita Kiryanov | c2a07e3 | 2015-01-14 10:42:51 +0200 | [diff] [blame] | 271 | splash_location = select_splash_location(locations, size); |
| 272 | if (!splash_location) |
| 273 | return -EINVAL; |
| 274 | |
Nikita Kiryanov | 7428271 | 2015-10-29 11:54:41 +0200 | [diff] [blame] | 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; |
Igor Grinberg | 86ec16b | 2014-11-03 11:32:20 +0200 | [diff] [blame] | 281 | } |