Simon Schwarz | 9ea5c6e | 2011-09-14 15:33:34 -0400 | [diff] [blame] | 1 | /* |
| 2 | * (C) Copyright 2010 |
| 3 | * Texas Instruments, <www.ti.com> |
| 4 | * |
| 5 | * Aneesh V <aneesh@ti.com> |
| 6 | * |
Wolfgang Denk | 1a45966 | 2013-07-08 09:37:19 +0200 | [diff] [blame] | 7 | * SPDX-License-Identifier: GPL-2.0+ |
Simon Schwarz | 9ea5c6e | 2011-09-14 15:33:34 -0400 | [diff] [blame] | 8 | */ |
| 9 | #include <common.h> |
Simon Glass | dc3dedf | 2015-06-23 15:38:51 -0600 | [diff] [blame] | 10 | #include <dm.h> |
Tom Rini | 47f7bca | 2012-08-13 12:03:19 -0700 | [diff] [blame] | 11 | #include <spl.h> |
Paul Kocialkowski | 91199f4 | 2015-04-27 10:20:22 +0200 | [diff] [blame] | 12 | #include <linux/compiler.h> |
Simon Schwarz | 9ea5c6e | 2011-09-14 15:33:34 -0400 | [diff] [blame] | 13 | #include <asm/u-boot.h> |
Nikita Kiryanov | 4188ba3 | 2015-11-08 17:11:44 +0200 | [diff] [blame^] | 14 | #include <errno.h> |
Simon Schwarz | 9ea5c6e | 2011-09-14 15:33:34 -0400 | [diff] [blame] | 15 | #include <mmc.h> |
Tom Rini | e4c444b | 2013-06-28 14:43:01 -0400 | [diff] [blame] | 16 | #include <image.h> |
Simon Schwarz | 9ea5c6e | 2011-09-14 15:33:34 -0400 | [diff] [blame] | 17 | |
| 18 | DECLARE_GLOBAL_DATA_PTR; |
| 19 | |
Paul Kocialkowski | b97300b | 2014-11-08 23:14:56 +0100 | [diff] [blame] | 20 | static int mmc_load_image_raw_sector(struct mmc *mmc, unsigned long sector) |
Simon Schwarz | 9ea5c6e | 2011-09-14 15:33:34 -0400 | [diff] [blame] | 21 | { |
Paul Kocialkowski | 3bc37b6 | 2015-05-22 12:45:35 +0200 | [diff] [blame] | 22 | unsigned long count; |
Peter Korsgaard | 2e22210 | 2013-03-21 04:55:17 +0000 | [diff] [blame] | 23 | u32 image_size_sectors; |
| 24 | struct image_header *header; |
Simon Schwarz | 9ea5c6e | 2011-09-14 15:33:34 -0400 | [diff] [blame] | 25 | |
| 26 | header = (struct image_header *)(CONFIG_SYS_TEXT_BASE - |
Paul Kocialkowski | 91199f4 | 2015-04-27 10:20:22 +0200 | [diff] [blame] | 27 | sizeof(struct image_header)); |
Simon Schwarz | 9ea5c6e | 2011-09-14 15:33:34 -0400 | [diff] [blame] | 28 | |
| 29 | /* read image header to find the image size & load address */ |
Paul Kocialkowski | 3bc37b6 | 2015-05-22 12:45:35 +0200 | [diff] [blame] | 30 | count = mmc->block_dev.block_read(0, sector, 1, header); |
Simon Glass | fdfa39d | 2015-06-23 15:38:47 -0600 | [diff] [blame] | 31 | debug("read sector %lx, count=%lu\n", sector, count); |
Paul Kocialkowski | 3bc37b6 | 2015-05-22 12:45:35 +0200 | [diff] [blame] | 32 | if (count == 0) |
Simon Schwarz | 9ea5c6e | 2011-09-14 15:33:34 -0400 | [diff] [blame] | 33 | goto end; |
| 34 | |
Simon Glass | fdfa39d | 2015-06-23 15:38:47 -0600 | [diff] [blame] | 35 | if (image_get_magic(header) != IH_MAGIC) { |
| 36 | puts("bad magic\n"); |
Tom Rini | e4c444b | 2013-06-28 14:43:01 -0400 | [diff] [blame] | 37 | return -1; |
Simon Glass | fdfa39d | 2015-06-23 15:38:47 -0600 | [diff] [blame] | 38 | } |
Tom Rini | e4c444b | 2013-06-28 14:43:01 -0400 | [diff] [blame] | 39 | |
Simon Schwarz | 9ea5c6e | 2011-09-14 15:33:34 -0400 | [diff] [blame] | 40 | spl_parse_image_header(header); |
| 41 | |
| 42 | /* convert size to sectors - round up */ |
Tom Rini | f088125 | 2012-08-14 10:25:15 -0700 | [diff] [blame] | 43 | image_size_sectors = (spl_image.size + mmc->read_bl_len - 1) / |
Paul Kocialkowski | 91199f4 | 2015-04-27 10:20:22 +0200 | [diff] [blame] | 44 | mmc->read_bl_len; |
Simon Schwarz | 9ea5c6e | 2011-09-14 15:33:34 -0400 | [diff] [blame] | 45 | |
| 46 | /* Read the header too to avoid extra memcpy */ |
Paul Kocialkowski | 3bc37b6 | 2015-05-22 12:45:35 +0200 | [diff] [blame] | 47 | count = mmc->block_dev.block_read(0, sector, image_size_sectors, |
Gong Qianyu | 7ef4c45 | 2015-07-30 14:07:12 +0800 | [diff] [blame] | 48 | (void *)(ulong)spl_image.load_addr); |
Simon Glass | fdfa39d | 2015-06-23 15:38:47 -0600 | [diff] [blame] | 49 | debug("read %x sectors to %x\n", image_size_sectors, |
| 50 | spl_image.load_addr); |
Simon Schwarz | 9ea5c6e | 2011-09-14 15:33:34 -0400 | [diff] [blame] | 51 | |
| 52 | end: |
Paul Kocialkowski | 1ec2646 | 2015-06-03 18:48:51 +0200 | [diff] [blame] | 53 | if (count == 0) { |
Paul Burton | 8112f5f | 2013-09-04 16:12:24 +0100 | [diff] [blame] | 54 | #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT |
Paul Kocialkowski | 1ec2646 | 2015-06-03 18:48:51 +0200 | [diff] [blame] | 55 | puts("spl: mmc block read error\n"); |
Paul Burton | 8112f5f | 2013-09-04 16:12:24 +0100 | [diff] [blame] | 56 | #endif |
Paul Kocialkowski | 3bc37b6 | 2015-05-22 12:45:35 +0200 | [diff] [blame] | 57 | return -1; |
Paul Kocialkowski | 1ec2646 | 2015-06-03 18:48:51 +0200 | [diff] [blame] | 58 | } |
Paul Kocialkowski | 3bc37b6 | 2015-05-22 12:45:35 +0200 | [diff] [blame] | 59 | |
| 60 | return 0; |
Simon Schwarz | 9ea5c6e | 2011-09-14 15:33:34 -0400 | [diff] [blame] | 61 | } |
| 62 | |
Nikita Kiryanov | 4188ba3 | 2015-11-08 17:11:44 +0200 | [diff] [blame^] | 63 | #ifdef CONFIG_DM_MMC |
| 64 | static int spl_mmc_find_device(struct mmc **mmc) |
| 65 | { |
| 66 | struct udevice *dev; |
| 67 | int err; |
| 68 | |
| 69 | err = mmc_initialize(NULL); |
| 70 | if (err) { |
| 71 | #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT |
| 72 | printf("spl: could not initialize mmc. error: %d\n", err); |
| 73 | #endif |
| 74 | return err; |
| 75 | } |
| 76 | |
| 77 | err = uclass_get_device(UCLASS_MMC, 0, &dev); |
| 78 | if (err) { |
| 79 | #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT |
| 80 | printf("spl: could not find mmc device. error: %d\n", err); |
| 81 | #endif |
| 82 | return err; |
| 83 | } |
| 84 | |
| 85 | *mmc = NULL; |
| 86 | *mmc = mmc_get_mmc_dev(dev); |
| 87 | return *mmc != NULL ? 0 : -ENODEV; |
| 88 | } |
| 89 | #else |
| 90 | static int spl_mmc_find_device(struct mmc **mmc) |
| 91 | { |
| 92 | int err; |
| 93 | |
| 94 | err = mmc_initialize(gd->bd); |
| 95 | if (err) { |
| 96 | #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT |
| 97 | printf("spl: could not initialize mmc. error: %d\n", err); |
| 98 | #endif |
| 99 | return err; |
| 100 | } |
| 101 | |
| 102 | /* We register only one device. So, the dev id is always 0 */ |
| 103 | *mmc = find_mmc_device(0); |
| 104 | if (!*mmc) { |
| 105 | #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT |
| 106 | puts("spl: mmc device not found\n"); |
| 107 | #endif |
| 108 | return -ENODEV; |
| 109 | } |
| 110 | |
| 111 | return 0; |
| 112 | } |
| 113 | #endif |
| 114 | |
Paul Kocialkowski | b97300b | 2014-11-08 23:14:56 +0100 | [diff] [blame] | 115 | #ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION |
| 116 | static int mmc_load_image_raw_partition(struct mmc *mmc, int partition) |
| 117 | { |
| 118 | disk_partition_t info; |
Paul Kocialkowski | 3bc37b6 | 2015-05-22 12:45:35 +0200 | [diff] [blame] | 119 | int err; |
Paul Kocialkowski | b97300b | 2014-11-08 23:14:56 +0100 | [diff] [blame] | 120 | |
Paul Kocialkowski | 3bc37b6 | 2015-05-22 12:45:35 +0200 | [diff] [blame] | 121 | err = get_partition_info(&mmc->block_dev, partition, &info); |
| 122 | if (err) { |
Paul Kocialkowski | b97300b | 2014-11-08 23:14:56 +0100 | [diff] [blame] | 123 | #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT |
Paul Kocialkowski | 1ec2646 | 2015-06-03 18:48:51 +0200 | [diff] [blame] | 124 | puts("spl: partition error\n"); |
Paul Kocialkowski | b97300b | 2014-11-08 23:14:56 +0100 | [diff] [blame] | 125 | #endif |
| 126 | return -1; |
| 127 | } |
| 128 | |
Stefan Roese | 4bfcc54 | 2015-07-20 11:20:39 +0200 | [diff] [blame] | 129 | #ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR |
| 130 | return mmc_load_image_raw_sector(mmc, info.start + |
| 131 | CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR); |
| 132 | #else |
Paul Kocialkowski | b97300b | 2014-11-08 23:14:56 +0100 | [diff] [blame] | 133 | return mmc_load_image_raw_sector(mmc, info.start); |
Stefan Roese | 4bfcc54 | 2015-07-20 11:20:39 +0200 | [diff] [blame] | 134 | #endif |
Paul Kocialkowski | b97300b | 2014-11-08 23:14:56 +0100 | [diff] [blame] | 135 | } |
| 136 | #endif |
| 137 | |
Peter Korsgaard | 2b75b0a | 2013-05-13 08:36:29 +0000 | [diff] [blame] | 138 | #ifdef CONFIG_SPL_OS_BOOT |
| 139 | static int mmc_load_image_raw_os(struct mmc *mmc) |
| 140 | { |
Paul Kocialkowski | 3bc37b6 | 2015-05-22 12:45:35 +0200 | [diff] [blame] | 141 | unsigned long count; |
Paul Kocialkowski | 91199f4 | 2015-04-27 10:20:22 +0200 | [diff] [blame] | 142 | |
Paul Kocialkowski | 3bc37b6 | 2015-05-22 12:45:35 +0200 | [diff] [blame] | 143 | count = mmc->block_dev.block_read(0, |
| 144 | CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTOR, |
| 145 | CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTORS, |
| 146 | (void *) CONFIG_SYS_SPL_ARGS_ADDR); |
| 147 | if (count == 0) { |
Paul Burton | 8112f5f | 2013-09-04 16:12:24 +0100 | [diff] [blame] | 148 | #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT |
Paul Kocialkowski | 1ec2646 | 2015-06-03 18:48:51 +0200 | [diff] [blame] | 149 | puts("spl: mmc block read error\n"); |
Paul Burton | 8112f5f | 2013-09-04 16:12:24 +0100 | [diff] [blame] | 150 | #endif |
Peter Korsgaard | 2b75b0a | 2013-05-13 08:36:29 +0000 | [diff] [blame] | 151 | return -1; |
| 152 | } |
| 153 | |
Paul Kocialkowski | b97300b | 2014-11-08 23:14:56 +0100 | [diff] [blame] | 154 | return mmc_load_image_raw_sector(mmc, |
Paul Kocialkowski | 91199f4 | 2015-04-27 10:20:22 +0200 | [diff] [blame] | 155 | CONFIG_SYS_MMCSD_RAW_MODE_KERNEL_SECTOR); |
Peter Korsgaard | 2b75b0a | 2013-05-13 08:36:29 +0000 | [diff] [blame] | 156 | } |
| 157 | #endif |
| 158 | |
Simon Schwarz | 9ea5c6e | 2011-09-14 15:33:34 -0400 | [diff] [blame] | 159 | void spl_mmc_load_image(void) |
| 160 | { |
| 161 | struct mmc *mmc; |
Simon Schwarz | 9ea5c6e | 2011-09-14 15:33:34 -0400 | [diff] [blame] | 162 | u32 boot_mode; |
Simon Glass | dc3dedf | 2015-06-23 15:38:51 -0600 | [diff] [blame] | 163 | int err = 0; |
Paul Kocialkowski | 91199f4 | 2015-04-27 10:20:22 +0200 | [diff] [blame] | 164 | __maybe_unused int part; |
Simon Schwarz | 9ea5c6e | 2011-09-14 15:33:34 -0400 | [diff] [blame] | 165 | |
Nikita Kiryanov | 4188ba3 | 2015-11-08 17:11:44 +0200 | [diff] [blame^] | 166 | if (spl_mmc_find_device(&mmc)) |
Simon Schwarz | 9ea5c6e | 2011-09-14 15:33:34 -0400 | [diff] [blame] | 167 | hang(); |
Simon Schwarz | 9ea5c6e | 2011-09-14 15:33:34 -0400 | [diff] [blame] | 168 | |
Nikita Kiryanov | 4188ba3 | 2015-11-08 17:11:44 +0200 | [diff] [blame^] | 169 | err = mmc_init(mmc); |
Simon Schwarz | 9ea5c6e | 2011-09-14 15:33:34 -0400 | [diff] [blame] | 170 | if (err) { |
Paul Burton | 8112f5f | 2013-09-04 16:12:24 +0100 | [diff] [blame] | 171 | #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT |
Paul Kocialkowski | 91199f4 | 2015-04-27 10:20:22 +0200 | [diff] [blame] | 172 | printf("spl: mmc init failed with error: %d\n", err); |
Paul Burton | 8112f5f | 2013-09-04 16:12:24 +0100 | [diff] [blame] | 173 | #endif |
Simon Schwarz | 9ea5c6e | 2011-09-14 15:33:34 -0400 | [diff] [blame] | 174 | hang(); |
| 175 | } |
Peter Korsgaard | 79adb7a | 2013-05-13 08:36:25 +0000 | [diff] [blame] | 176 | |
Tom Rini | 37189a1 | 2012-08-14 09:19:44 -0700 | [diff] [blame] | 177 | boot_mode = spl_boot_mode(); |
Paul Kocialkowski | 91199f4 | 2015-04-27 10:20:22 +0200 | [diff] [blame] | 178 | switch (boot_mode) { |
| 179 | case MMCSD_MODE_RAW: |
| 180 | debug("spl: mmc boot mode: raw\n"); |
| 181 | |
Peter Korsgaard | 2b75b0a | 2013-05-13 08:36:29 +0000 | [diff] [blame] | 182 | #ifdef CONFIG_SPL_OS_BOOT |
Paul Kocialkowski | 91199f4 | 2015-04-27 10:20:22 +0200 | [diff] [blame] | 183 | if (!spl_start_uboot()) { |
| 184 | err = mmc_load_image_raw_os(mmc); |
| 185 | if (!err) |
| 186 | return; |
| 187 | } |
Peter Korsgaard | 2b75b0a | 2013-05-13 08:36:29 +0000 | [diff] [blame] | 188 | #endif |
Paul Kocialkowski | 3ae8f4c | 2015-06-08 23:05:09 +0200 | [diff] [blame] | 189 | #if defined(CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION) |
Paul Kocialkowski | b97300b | 2014-11-08 23:14:56 +0100 | [diff] [blame] | 190 | err = mmc_load_image_raw_partition(mmc, |
| 191 | CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION); |
Paul Kocialkowski | 91199f4 | 2015-04-27 10:20:22 +0200 | [diff] [blame] | 192 | if (!err) |
| 193 | return; |
Paul Kocialkowski | 3ae8f4c | 2015-06-08 23:05:09 +0200 | [diff] [blame] | 194 | #elif defined(CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR) |
| 195 | err = mmc_load_image_raw_sector(mmc, |
| 196 | CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR); |
| 197 | if (!err) |
| 198 | return; |
| 199 | #endif |
Nikita Kiryanov | fd61d39 | 2015-11-08 17:11:43 +0200 | [diff] [blame] | 200 | break; |
Paul Kocialkowski | 91199f4 | 2015-04-27 10:20:22 +0200 | [diff] [blame] | 201 | case MMCSD_MODE_FS: |
| 202 | debug("spl: mmc boot mode: fs\n"); |
| 203 | |
Paul Kocialkowski | 3ae8f4c | 2015-06-08 23:05:09 +0200 | [diff] [blame] | 204 | #ifdef CONFIG_SYS_MMCSD_FS_BOOT_PARTITION |
Guillaume GARDET | 592f922 | 2014-10-15 17:53:12 +0200 | [diff] [blame] | 205 | #ifdef CONFIG_SPL_FAT_SUPPORT |
Peter Korsgaard | 7ad2cc7 | 2013-05-13 08:36:27 +0000 | [diff] [blame] | 206 | #ifdef CONFIG_SPL_OS_BOOT |
Paul Kocialkowski | 91199f4 | 2015-04-27 10:20:22 +0200 | [diff] [blame] | 207 | if (!spl_start_uboot()) { |
| 208 | err = spl_load_image_fat_os(&mmc->block_dev, |
| 209 | CONFIG_SYS_MMCSD_FS_BOOT_PARTITION); |
| 210 | if (!err) |
| 211 | return; |
| 212 | } |
Peter Korsgaard | 7ad2cc7 | 2013-05-13 08:36:27 +0000 | [diff] [blame] | 213 | #endif |
Paul Kocialkowski | 3ae8f4c | 2015-06-08 23:05:09 +0200 | [diff] [blame] | 214 | #ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME |
Dan Murphy | 773b594 | 2014-01-16 11:23:29 -0600 | [diff] [blame] | 215 | err = spl_load_image_fat(&mmc->block_dev, |
Paul Kocialkowski | 91199f4 | 2015-04-27 10:20:22 +0200 | [diff] [blame] | 216 | CONFIG_SYS_MMCSD_FS_BOOT_PARTITION, |
| 217 | CONFIG_SPL_FS_LOAD_PAYLOAD_NAME); |
| 218 | if (!err) |
| 219 | return; |
| 220 | #endif |
Paul Kocialkowski | 3ae8f4c | 2015-06-08 23:05:09 +0200 | [diff] [blame] | 221 | #endif |
Guillaume GARDET | 592f922 | 2014-10-15 17:53:12 +0200 | [diff] [blame] | 222 | #ifdef CONFIG_SPL_EXT_SUPPORT |
| 223 | #ifdef CONFIG_SPL_OS_BOOT |
Paul Kocialkowski | 91199f4 | 2015-04-27 10:20:22 +0200 | [diff] [blame] | 224 | if (!spl_start_uboot()) { |
| 225 | err = spl_load_image_ext_os(&mmc->block_dev, |
| 226 | CONFIG_SYS_MMCSD_FS_BOOT_PARTITION); |
| 227 | if (!err) |
| 228 | return; |
| 229 | } |
Tom Rini | 0da113e | 2012-08-10 09:27:14 -0700 | [diff] [blame] | 230 | #endif |
Paul Kocialkowski | 3ae8f4c | 2015-06-08 23:05:09 +0200 | [diff] [blame] | 231 | #ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME |
Guillaume GARDET | 592f922 | 2014-10-15 17:53:12 +0200 | [diff] [blame] | 232 | err = spl_load_image_ext(&mmc->block_dev, |
Paul Kocialkowski | 91199f4 | 2015-04-27 10:20:22 +0200 | [diff] [blame] | 233 | CONFIG_SYS_MMCSD_FS_BOOT_PARTITION, |
| 234 | CONFIG_SPL_FS_LOAD_PAYLOAD_NAME); |
| 235 | if (!err) |
| 236 | return; |
| 237 | #endif |
| 238 | #endif |
Paul Kocialkowski | 3ae8f4c | 2015-06-08 23:05:09 +0200 | [diff] [blame] | 239 | #endif |
Nikita Kiryanov | fd61d39 | 2015-11-08 17:11:43 +0200 | [diff] [blame] | 240 | break; |
Tom Rini | 7dbe63b | 2014-02-05 10:24:18 -0500 | [diff] [blame] | 241 | #ifdef CONFIG_SUPPORT_EMMC_BOOT |
Paul Kocialkowski | 91199f4 | 2015-04-27 10:20:22 +0200 | [diff] [blame] | 242 | case MMCSD_MODE_EMMCBOOT: |
Tom Rini | 7dbe63b | 2014-02-05 10:24:18 -0500 | [diff] [blame] | 243 | /* |
| 244 | * We need to check what the partition is configured to. |
| 245 | * 1 and 2 match up to boot0 / boot1 and 7 is user data |
| 246 | * which is the first physical partition (0). |
| 247 | */ |
Paul Kocialkowski | 91199f4 | 2015-04-27 10:20:22 +0200 | [diff] [blame] | 248 | part = (mmc->part_config >> 3) & PART_ACCESS_MASK; |
Tom Rini | 7dbe63b | 2014-02-05 10:24:18 -0500 | [diff] [blame] | 249 | |
| 250 | if (part == 7) |
| 251 | part = 0; |
| 252 | |
| 253 | if (mmc_switch_part(0, part)) { |
| 254 | #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT |
Paul Kocialkowski | 91199f4 | 2015-04-27 10:20:22 +0200 | [diff] [blame] | 255 | puts("spl: mmc partition switch failed\n"); |
Tom Rini | 7dbe63b | 2014-02-05 10:24:18 -0500 | [diff] [blame] | 256 | #endif |
| 257 | hang(); |
| 258 | } |
Paul Kocialkowski | 91199f4 | 2015-04-27 10:20:22 +0200 | [diff] [blame] | 259 | |
Tom Rini | 7dbe63b | 2014-02-05 10:24:18 -0500 | [diff] [blame] | 260 | #ifdef CONFIG_SPL_OS_BOOT |
Paul Kocialkowski | 91199f4 | 2015-04-27 10:20:22 +0200 | [diff] [blame] | 261 | if (!spl_start_uboot()) { |
| 262 | err = mmc_load_image_raw_os(mmc); |
| 263 | if (!err) |
| 264 | return; |
| 265 | } |
Tom Rini | 7dbe63b | 2014-02-05 10:24:18 -0500 | [diff] [blame] | 266 | #endif |
Paul Kocialkowski | 3ae8f4c | 2015-06-08 23:05:09 +0200 | [diff] [blame] | 267 | #if defined(CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION) |
Paul Kocialkowski | ecb3013 | 2015-04-27 10:20:23 +0200 | [diff] [blame] | 268 | err = mmc_load_image_raw_partition(mmc, |
| 269 | CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION); |
Paul Kocialkowski | 91199f4 | 2015-04-27 10:20:22 +0200 | [diff] [blame] | 270 | if (!err) |
| 271 | return; |
Paul Kocialkowski | 3ae8f4c | 2015-06-08 23:05:09 +0200 | [diff] [blame] | 272 | #elif defined(CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR) |
| 273 | err = mmc_load_image_raw_sector(mmc, |
| 274 | CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR); |
| 275 | if (!err) |
| 276 | return; |
| 277 | #endif |
Nikita Kiryanov | fd61d39 | 2015-11-08 17:11:43 +0200 | [diff] [blame] | 278 | break; |
Tom Rini | 7dbe63b | 2014-02-05 10:24:18 -0500 | [diff] [blame] | 279 | #endif |
Paul Kocialkowski | 91199f4 | 2015-04-27 10:20:22 +0200 | [diff] [blame] | 280 | case MMCSD_MODE_UNDEFINED: |
Guillaume GARDET | 2c84c9a | 2014-12-16 12:00:44 +0100 | [diff] [blame] | 281 | #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT |
Nikita Kiryanov | fd61d39 | 2015-11-08 17:11:43 +0200 | [diff] [blame] | 282 | default: |
| 283 | puts("spl: mmc: wrong boot mode\n"); |
Guillaume GARDET | 2c84c9a | 2014-12-16 12:00:44 +0100 | [diff] [blame] | 284 | #endif |
Paul Kocialkowski | 91199f4 | 2015-04-27 10:20:22 +0200 | [diff] [blame] | 285 | } |
Nikita Kiryanov | fd61d39 | 2015-11-08 17:11:43 +0200 | [diff] [blame] | 286 | |
| 287 | hang(); |
Simon Schwarz | 9ea5c6e | 2011-09-14 15:33:34 -0400 | [diff] [blame] | 288 | } |