Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 1 | /* |
| 2 | * SPI flash operations |
| 3 | * |
| 4 | * Copyright (C) 2008 Atmel Corporation |
| 5 | * Copyright (C) 2010 Reinhard Meyer, EMK Elektronik |
| 6 | * Copyright (C) 2013 Jagannadha Sutradharudu Teki, Xilinx Inc. |
| 7 | * |
Jagannadha Sutradharudu Teki | 0c88a84 | 2013-10-10 22:32:55 +0530 | [diff] [blame] | 8 | * SPDX-License-Identifier: GPL-2.0+ |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 9 | */ |
| 10 | |
| 11 | #include <common.h> |
Jagannadha Sutradharudu Teki | c6136aa | 2014-02-04 21:36:13 +0530 | [diff] [blame] | 12 | #include <errno.h> |
Jagannadha Sutradharudu Teki | ff063ed | 2014-01-11 16:50:45 +0530 | [diff] [blame] | 13 | #include <malloc.h> |
Jagan Teki | 3847c0c | 2015-12-11 21:36:34 +0530 | [diff] [blame] | 14 | #include <mapmem.h> |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 15 | #include <spi.h> |
| 16 | #include <spi_flash.h> |
Fabio Estevam | 41b358d | 2015-11-05 12:43:41 -0200 | [diff] [blame] | 17 | #include <linux/log2.h> |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 18 | |
Jagannadha Sutradharudu Teki | 898e76c | 2013-09-26 16:00:15 +0530 | [diff] [blame] | 19 | #include "sf_internal.h" |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 20 | |
Jagan Teki | 3847c0c | 2015-12-11 21:36:34 +0530 | [diff] [blame] | 21 | DECLARE_GLOBAL_DATA_PTR; |
| 22 | |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 23 | static void spi_flash_addr(u32 addr, u8 *cmd) |
| 24 | { |
| 25 | /* cmd[0] is actual command */ |
| 26 | cmd[1] = addr >> 16; |
| 27 | cmd[2] = addr >> 8; |
| 28 | cmd[3] = addr >> 0; |
| 29 | } |
| 30 | |
Jagan Teki | 0edae52 | 2015-11-04 00:27:35 +0530 | [diff] [blame] | 31 | /* Read commands array */ |
| 32 | static u8 spi_read_cmds_array[] = { |
| 33 | CMD_READ_ARRAY_SLOW, |
| 34 | CMD_READ_ARRAY_FAST, |
| 35 | CMD_READ_DUAL_OUTPUT_FAST, |
| 36 | CMD_READ_DUAL_IO_FAST, |
| 37 | CMD_READ_QUAD_OUTPUT_FAST, |
| 38 | CMD_READ_QUAD_IO_FAST, |
| 39 | }; |
| 40 | |
Jagan Teki | cb37518 | 2015-09-29 22:29:33 +0530 | [diff] [blame] | 41 | static int read_sr(struct spi_flash *flash, u8 *rs) |
Jagannadha Sutradharudu Teki | 9f4322f | 2013-12-30 22:16:23 +0530 | [diff] [blame] | 42 | { |
| 43 | int ret; |
| 44 | u8 cmd; |
| 45 | |
| 46 | cmd = CMD_READ_STATUS; |
| 47 | ret = spi_flash_read_common(flash, &cmd, 1, rs, 1); |
| 48 | if (ret < 0) { |
| 49 | debug("SF: fail to read status register\n"); |
| 50 | return ret; |
| 51 | } |
| 52 | |
| 53 | return 0; |
| 54 | } |
| 55 | |
Jagan Teki | baaaa75 | 2015-09-29 16:54:31 +0530 | [diff] [blame] | 56 | static int read_fsr(struct spi_flash *flash, u8 *fsr) |
| 57 | { |
| 58 | int ret; |
| 59 | const u8 cmd = CMD_FLAG_STATUS; |
| 60 | |
| 61 | ret = spi_flash_read_common(flash, &cmd, 1, fsr, 1); |
| 62 | if (ret < 0) { |
| 63 | debug("SF: fail to read flag status register\n"); |
| 64 | return ret; |
| 65 | } |
| 66 | |
| 67 | return 0; |
| 68 | } |
| 69 | |
Jagan Teki | cb37518 | 2015-09-29 22:29:33 +0530 | [diff] [blame] | 70 | static int write_sr(struct spi_flash *flash, u8 ws) |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 71 | { |
| 72 | u8 cmd; |
| 73 | int ret; |
| 74 | |
| 75 | cmd = CMD_WRITE_STATUS; |
Jagannadha Sutradharudu Teki | 2ba863f | 2014-01-12 21:38:21 +0530 | [diff] [blame] | 76 | ret = spi_flash_write_common(flash, &cmd, 1, &ws, 1); |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 77 | if (ret < 0) { |
| 78 | debug("SF: fail to write status register\n"); |
| 79 | return ret; |
| 80 | } |
| 81 | |
| 82 | return 0; |
| 83 | } |
| 84 | |
Jagannadha Sutradharudu Teki | 9f4322f | 2013-12-30 22:16:23 +0530 | [diff] [blame] | 85 | #if defined(CONFIG_SPI_FLASH_SPANSION) || defined(CONFIG_SPI_FLASH_WINBOND) |
Jagan Teki | cb37518 | 2015-09-29 22:29:33 +0530 | [diff] [blame] | 86 | static int read_cr(struct spi_flash *flash, u8 *rc) |
Jagannadha Sutradharudu Teki | 0679512 | 2013-12-26 14:13:36 +0530 | [diff] [blame] | 87 | { |
Jagannadha Sutradharudu Teki | 0679512 | 2013-12-26 14:13:36 +0530 | [diff] [blame] | 88 | int ret; |
Jagannadha Sutradharudu Teki | 9f4322f | 2013-12-30 22:16:23 +0530 | [diff] [blame] | 89 | u8 cmd; |
Jagannadha Sutradharudu Teki | 0679512 | 2013-12-26 14:13:36 +0530 | [diff] [blame] | 90 | |
Jagannadha Sutradharudu Teki | 9f4322f | 2013-12-30 22:16:23 +0530 | [diff] [blame] | 91 | cmd = CMD_READ_CONFIG; |
| 92 | ret = spi_flash_read_common(flash, &cmd, 1, rc, 1); |
Jagannadha Sutradharudu Teki | 0679512 | 2013-12-26 14:13:36 +0530 | [diff] [blame] | 93 | if (ret < 0) { |
Jagannadha Sutradharudu Teki | 9f4322f | 2013-12-30 22:16:23 +0530 | [diff] [blame] | 94 | debug("SF: fail to read config register\n"); |
Jagannadha Sutradharudu Teki | 0679512 | 2013-12-26 14:13:36 +0530 | [diff] [blame] | 95 | return ret; |
| 96 | } |
| 97 | |
Jagannadha Sutradharudu Teki | 9f4322f | 2013-12-30 22:16:23 +0530 | [diff] [blame] | 98 | return 0; |
Jagannadha Sutradharudu Teki | 0679512 | 2013-12-26 14:13:36 +0530 | [diff] [blame] | 99 | } |
Jagannadha Sutradharudu Teki | 0679512 | 2013-12-26 14:13:36 +0530 | [diff] [blame] | 100 | |
Jagan Teki | cb37518 | 2015-09-29 22:29:33 +0530 | [diff] [blame] | 101 | static int write_cr(struct spi_flash *flash, u8 wc) |
Jagannadha Sutradharudu Teki | 6cba6fd | 2013-12-23 15:47:48 +0530 | [diff] [blame] | 102 | { |
| 103 | u8 data[2]; |
| 104 | u8 cmd; |
| 105 | int ret; |
| 106 | |
Jagan Teki | cb37518 | 2015-09-29 22:29:33 +0530 | [diff] [blame] | 107 | ret = read_sr(flash, &data[0]); |
Jagannadha Sutradharudu Teki | 9f4322f | 2013-12-30 22:16:23 +0530 | [diff] [blame] | 108 | if (ret < 0) |
Jagannadha Sutradharudu Teki | 6cba6fd | 2013-12-23 15:47:48 +0530 | [diff] [blame] | 109 | return ret; |
Jagannadha Sutradharudu Teki | 6cba6fd | 2013-12-23 15:47:48 +0530 | [diff] [blame] | 110 | |
| 111 | cmd = CMD_WRITE_STATUS; |
Jagannadha Sutradharudu Teki | 9f4322f | 2013-12-30 22:16:23 +0530 | [diff] [blame] | 112 | data[1] = wc; |
Jagannadha Sutradharudu Teki | 6cba6fd | 2013-12-23 15:47:48 +0530 | [diff] [blame] | 113 | ret = spi_flash_write_common(flash, &cmd, 1, &data, 2); |
| 114 | if (ret) { |
| 115 | debug("SF: fail to write config register\n"); |
| 116 | return ret; |
| 117 | } |
| 118 | |
| 119 | return 0; |
| 120 | } |
Jagannadha Sutradharudu Teki | d08a1ba | 2013-12-26 13:54:57 +0530 | [diff] [blame] | 121 | #endif |
| 122 | |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 123 | #ifdef CONFIG_SPI_FLASH_BAR |
Jagan Teki | cb37518 | 2015-09-29 22:29:33 +0530 | [diff] [blame] | 124 | static int spi_flash_write_bar(struct spi_flash *flash, u32 offset) |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 125 | { |
Jagan Teki | 70ccf59 | 2015-09-02 11:39:48 +0530 | [diff] [blame] | 126 | u8 cmd, bank_sel; |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 127 | int ret; |
| 128 | |
Jagan Teki | 70ccf59 | 2015-09-02 11:39:48 +0530 | [diff] [blame] | 129 | bank_sel = offset / (SPI_FLASH_16MB_BOUN << flash->shift); |
| 130 | if (bank_sel == flash->bank_curr) |
| 131 | goto bar_end; |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 132 | |
| 133 | cmd = flash->bank_write_cmd; |
| 134 | ret = spi_flash_write_common(flash, &cmd, 1, &bank_sel, 1); |
| 135 | if (ret < 0) { |
| 136 | debug("SF: fail to write bank register\n"); |
| 137 | return ret; |
| 138 | } |
Jagan Teki | 70ccf59 | 2015-09-02 11:39:48 +0530 | [diff] [blame] | 139 | |
| 140 | bar_end: |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 141 | flash->bank_curr = bank_sel; |
Jagan Teki | 70ccf59 | 2015-09-02 11:39:48 +0530 | [diff] [blame] | 142 | return flash->bank_curr; |
Jagannadha Sutradharudu Teki | 6152dd1 | 2013-10-08 23:26:47 +0530 | [diff] [blame] | 143 | } |
Jagan Teki | 0edae52 | 2015-11-04 00:27:35 +0530 | [diff] [blame] | 144 | |
Jagan Teki | cb37518 | 2015-09-29 22:29:33 +0530 | [diff] [blame] | 145 | static int spi_flash_read_bar(struct spi_flash *flash, u8 idcode0) |
Jagan Teki | 0edae52 | 2015-11-04 00:27:35 +0530 | [diff] [blame] | 146 | { |
| 147 | u8 curr_bank = 0; |
| 148 | int ret; |
| 149 | |
| 150 | if (flash->size <= SPI_FLASH_16MB_BOUN) |
| 151 | goto bank_end; |
| 152 | |
| 153 | switch (idcode0) { |
| 154 | case SPI_FLASH_CFI_MFR_SPANSION: |
| 155 | flash->bank_read_cmd = CMD_BANKADDR_BRRD; |
| 156 | flash->bank_write_cmd = CMD_BANKADDR_BRWR; |
Jagan Teki | b6a2c43 | 2015-11-20 13:00:15 +0530 | [diff] [blame] | 157 | break; |
Jagan Teki | 0edae52 | 2015-11-04 00:27:35 +0530 | [diff] [blame] | 158 | default: |
| 159 | flash->bank_read_cmd = CMD_EXTNADDR_RDEAR; |
| 160 | flash->bank_write_cmd = CMD_EXTNADDR_WREAR; |
| 161 | } |
| 162 | |
| 163 | ret = spi_flash_read_common(flash, &flash->bank_read_cmd, 1, |
| 164 | &curr_bank, 1); |
| 165 | if (ret) { |
| 166 | debug("SF: fail to read bank addr register\n"); |
| 167 | return ret; |
| 168 | } |
| 169 | |
| 170 | bank_end: |
| 171 | flash->bank_curr = curr_bank; |
| 172 | return 0; |
| 173 | } |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 174 | #endif |
| 175 | |
Jagannadha Sutradharudu Teki | b902e07 | 2014-01-11 15:25:04 +0530 | [diff] [blame] | 176 | #ifdef CONFIG_SF_DUAL_FLASH |
Jagan Teki | cb37518 | 2015-09-29 22:29:33 +0530 | [diff] [blame] | 177 | static void spi_flash_dual(struct spi_flash *flash, u32 *addr) |
Jagannadha Sutradharudu Teki | f77f469 | 2014-01-12 21:40:11 +0530 | [diff] [blame] | 178 | { |
| 179 | switch (flash->dual_flash) { |
| 180 | case SF_DUAL_STACKED_FLASH: |
| 181 | if (*addr >= (flash->size >> 1)) { |
| 182 | *addr -= flash->size >> 1; |
| 183 | flash->spi->flags |= SPI_XFER_U_PAGE; |
| 184 | } else { |
| 185 | flash->spi->flags &= ~SPI_XFER_U_PAGE; |
| 186 | } |
| 187 | break; |
Jagannadha Sutradharudu Teki | 056fbc7 | 2014-01-07 00:11:35 +0530 | [diff] [blame] | 188 | case SF_DUAL_PARALLEL_FLASH: |
| 189 | *addr >>= flash->shift; |
| 190 | break; |
Jagannadha Sutradharudu Teki | f77f469 | 2014-01-12 21:40:11 +0530 | [diff] [blame] | 191 | default: |
| 192 | debug("SF: Unsupported dual_flash=%d\n", flash->dual_flash); |
| 193 | break; |
| 194 | } |
| 195 | } |
Jagannadha Sutradharudu Teki | b902e07 | 2014-01-11 15:25:04 +0530 | [diff] [blame] | 196 | #endif |
Jagannadha Sutradharudu Teki | f77f469 | 2014-01-12 21:40:11 +0530 | [diff] [blame] | 197 | |
Jagan Teki | baaaa75 | 2015-09-29 16:54:31 +0530 | [diff] [blame] | 198 | static int spi_flash_sr_ready(struct spi_flash *flash) |
Siva Durga Prasad Paladugu | 06bc175 | 2015-03-11 14:47:57 +0530 | [diff] [blame] | 199 | { |
Jagan Teki | 4efad20 | 2015-09-02 11:39:50 +0530 | [diff] [blame] | 200 | u8 sr; |
Jagan Teki | baaaa75 | 2015-09-29 16:54:31 +0530 | [diff] [blame] | 201 | int ret; |
| 202 | |
Jagan Teki | cb37518 | 2015-09-29 22:29:33 +0530 | [diff] [blame] | 203 | ret = read_sr(flash, &sr); |
Jagan Teki | baaaa75 | 2015-09-29 16:54:31 +0530 | [diff] [blame] | 204 | if (ret < 0) |
| 205 | return ret; |
| 206 | |
| 207 | return !(sr & STATUS_WIP); |
| 208 | } |
| 209 | |
| 210 | static int spi_flash_fsr_ready(struct spi_flash *flash) |
| 211 | { |
| 212 | u8 fsr; |
| 213 | int ret; |
| 214 | |
| 215 | ret = read_fsr(flash, &fsr); |
| 216 | if (ret < 0) |
| 217 | return ret; |
| 218 | |
| 219 | return fsr & STATUS_PEC; |
| 220 | } |
| 221 | |
| 222 | static int spi_flash_ready(struct spi_flash *flash) |
| 223 | { |
| 224 | int sr, fsr; |
| 225 | |
| 226 | sr = spi_flash_sr_ready(flash); |
| 227 | if (sr < 0) |
| 228 | return sr; |
| 229 | |
| 230 | fsr = 1; |
| 231 | if (flash->flags & SNOR_F_USE_FSR) { |
| 232 | fsr = spi_flash_fsr_ready(flash); |
| 233 | if (fsr < 0) |
| 234 | return fsr; |
| 235 | } |
| 236 | |
| 237 | return sr && fsr; |
| 238 | } |
| 239 | |
Jagan Teki | 6fa40e7 | 2015-09-29 18:26:08 +0530 | [diff] [blame] | 240 | static int spi_flash_cmd_wait_ready(struct spi_flash *flash, |
| 241 | unsigned long timeout) |
Jagan Teki | baaaa75 | 2015-09-29 16:54:31 +0530 | [diff] [blame] | 242 | { |
Jagan Teki | 4efad20 | 2015-09-02 11:39:50 +0530 | [diff] [blame] | 243 | int timebase, ret; |
Siva Durga Prasad Paladugu | 06bc175 | 2015-03-11 14:47:57 +0530 | [diff] [blame] | 244 | |
Jagan Teki | 4efad20 | 2015-09-02 11:39:50 +0530 | [diff] [blame] | 245 | timebase = get_timer(0); |
Siva Durga Prasad Paladugu | 06bc175 | 2015-03-11 14:47:57 +0530 | [diff] [blame] | 246 | |
Jagan Teki | 4efad20 | 2015-09-02 11:39:50 +0530 | [diff] [blame] | 247 | while (get_timer(timebase) < timeout) { |
Jagan Teki | baaaa75 | 2015-09-29 16:54:31 +0530 | [diff] [blame] | 248 | ret = spi_flash_ready(flash); |
Siva Durga Prasad Paladugu | 06bc175 | 2015-03-11 14:47:57 +0530 | [diff] [blame] | 249 | if (ret < 0) |
| 250 | return ret; |
Jagan Teki | baaaa75 | 2015-09-29 16:54:31 +0530 | [diff] [blame] | 251 | if (ret) |
Jagan Teki | 4efad20 | 2015-09-02 11:39:50 +0530 | [diff] [blame] | 252 | return 0; |
Siva Durga Prasad Paladugu | 06bc175 | 2015-03-11 14:47:57 +0530 | [diff] [blame] | 253 | } |
| 254 | |
Jagan Teki | 4efad20 | 2015-09-02 11:39:50 +0530 | [diff] [blame] | 255 | printf("SF: Timeout!\n"); |
| 256 | |
| 257 | return -ETIMEDOUT; |
Siva Durga Prasad Paladugu | 06bc175 | 2015-03-11 14:47:57 +0530 | [diff] [blame] | 258 | } |
| 259 | |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 260 | int spi_flash_write_common(struct spi_flash *flash, const u8 *cmd, |
| 261 | size_t cmd_len, const void *buf, size_t buf_len) |
| 262 | { |
| 263 | struct spi_slave *spi = flash->spi; |
| 264 | unsigned long timeout = SPI_FLASH_PROG_TIMEOUT; |
| 265 | int ret; |
| 266 | |
| 267 | if (buf == NULL) |
| 268 | timeout = SPI_FLASH_PAGE_ERASE_TIMEOUT; |
| 269 | |
| 270 | ret = spi_claim_bus(flash->spi); |
| 271 | if (ret) { |
| 272 | debug("SF: unable to claim SPI bus\n"); |
| 273 | return ret; |
| 274 | } |
| 275 | |
| 276 | ret = spi_flash_cmd_write_enable(flash); |
| 277 | if (ret < 0) { |
| 278 | debug("SF: enabling write failed\n"); |
| 279 | return ret; |
| 280 | } |
| 281 | |
| 282 | ret = spi_flash_cmd_write(spi, cmd, cmd_len, buf, buf_len); |
| 283 | if (ret < 0) { |
| 284 | debug("SF: write cmd failed\n"); |
| 285 | return ret; |
| 286 | } |
| 287 | |
| 288 | ret = spi_flash_cmd_wait_ready(flash, timeout); |
| 289 | if (ret < 0) { |
| 290 | debug("SF: write %s timed out\n", |
| 291 | timeout == SPI_FLASH_PROG_TIMEOUT ? |
| 292 | "program" : "page erase"); |
| 293 | return ret; |
| 294 | } |
| 295 | |
| 296 | spi_release_bus(spi); |
| 297 | |
| 298 | return ret; |
| 299 | } |
| 300 | |
Jagannadha Sutradharudu Teki | a5e8199 | 2013-10-02 19:38:49 +0530 | [diff] [blame] | 301 | int spi_flash_cmd_erase_ops(struct spi_flash *flash, u32 offset, size_t len) |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 302 | { |
Jagannadha Sutradharudu Teki | f77f469 | 2014-01-12 21:40:11 +0530 | [diff] [blame] | 303 | u32 erase_size, erase_addr; |
Jagannadha Sutradharudu Teki | ff063ed | 2014-01-11 16:50:45 +0530 | [diff] [blame] | 304 | u8 cmd[SPI_FLASH_CMD_LEN]; |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 305 | int ret = -1; |
| 306 | |
Jagannadha Sutradharudu Teki | f4f51a8 | 2013-10-02 19:36:58 +0530 | [diff] [blame] | 307 | erase_size = flash->erase_size; |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 308 | if (offset % erase_size || len % erase_size) { |
| 309 | debug("SF: Erase offset/length not multiple of erase size\n"); |
| 310 | return -1; |
| 311 | } |
| 312 | |
Bin Meng | 439fcb9 | 2015-11-13 02:46:26 -0800 | [diff] [blame] | 313 | if (flash->flash_is_locked) { |
| 314 | if (flash->flash_is_locked(flash, offset, len) > 0) { |
| 315 | printf("offset 0x%x is protected and cannot be erased\n", |
| 316 | offset); |
| 317 | return -EINVAL; |
| 318 | } |
Fabio Estevam | c3c016c | 2015-11-05 12:43:42 -0200 | [diff] [blame] | 319 | } |
| 320 | |
Jagannadha Sutradharudu Teki | f4f51a8 | 2013-10-02 19:36:58 +0530 | [diff] [blame] | 321 | cmd[0] = flash->erase_cmd; |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 322 | while (len) { |
Jagannadha Sutradharudu Teki | f77f469 | 2014-01-12 21:40:11 +0530 | [diff] [blame] | 323 | erase_addr = offset; |
| 324 | |
Jagannadha Sutradharudu Teki | b902e07 | 2014-01-11 15:25:04 +0530 | [diff] [blame] | 325 | #ifdef CONFIG_SF_DUAL_FLASH |
Jagannadha Sutradharudu Teki | f77f469 | 2014-01-12 21:40:11 +0530 | [diff] [blame] | 326 | if (flash->dual_flash > SF_SINGLE_FLASH) |
Jagan Teki | cb37518 | 2015-09-29 22:29:33 +0530 | [diff] [blame] | 327 | spi_flash_dual(flash, &erase_addr); |
Jagannadha Sutradharudu Teki | b902e07 | 2014-01-11 15:25:04 +0530 | [diff] [blame] | 328 | #endif |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 329 | #ifdef CONFIG_SPI_FLASH_BAR |
Jagan Teki | cb37518 | 2015-09-29 22:29:33 +0530 | [diff] [blame] | 330 | ret = spi_flash_write_bar(flash, erase_addr); |
Jagannadha Sutradharudu Teki | 6152dd1 | 2013-10-08 23:26:47 +0530 | [diff] [blame] | 331 | if (ret < 0) |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 332 | return ret; |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 333 | #endif |
Jagannadha Sutradharudu Teki | f77f469 | 2014-01-12 21:40:11 +0530 | [diff] [blame] | 334 | spi_flash_addr(erase_addr, cmd); |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 335 | |
| 336 | debug("SF: erase %2x %2x %2x %2x (%x)\n", cmd[0], cmd[1], |
Jagannadha Sutradharudu Teki | f77f469 | 2014-01-12 21:40:11 +0530 | [diff] [blame] | 337 | cmd[2], cmd[3], erase_addr); |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 338 | |
| 339 | ret = spi_flash_write_common(flash, cmd, sizeof(cmd), NULL, 0); |
| 340 | if (ret < 0) { |
| 341 | debug("SF: erase failed\n"); |
| 342 | break; |
| 343 | } |
| 344 | |
| 345 | offset += erase_size; |
| 346 | len -= erase_size; |
| 347 | } |
| 348 | |
| 349 | return ret; |
| 350 | } |
| 351 | |
Jagannadha Sutradharudu Teki | a5e8199 | 2013-10-02 19:38:49 +0530 | [diff] [blame] | 352 | int spi_flash_cmd_write_ops(struct spi_flash *flash, u32 offset, |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 353 | size_t len, const void *buf) |
| 354 | { |
| 355 | unsigned long byte_addr, page_size; |
Jagannadha Sutradharudu Teki | f77f469 | 2014-01-12 21:40:11 +0530 | [diff] [blame] | 356 | u32 write_addr; |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 357 | size_t chunk_len, actual; |
Jagannadha Sutradharudu Teki | ff063ed | 2014-01-11 16:50:45 +0530 | [diff] [blame] | 358 | u8 cmd[SPI_FLASH_CMD_LEN]; |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 359 | int ret = -1; |
| 360 | |
| 361 | page_size = flash->page_size; |
| 362 | |
Bin Meng | 439fcb9 | 2015-11-13 02:46:26 -0800 | [diff] [blame] | 363 | if (flash->flash_is_locked) { |
| 364 | if (flash->flash_is_locked(flash, offset, len) > 0) { |
| 365 | printf("offset 0x%x is protected and cannot be written\n", |
| 366 | offset); |
| 367 | return -EINVAL; |
| 368 | } |
Fabio Estevam | c3c016c | 2015-11-05 12:43:42 -0200 | [diff] [blame] | 369 | } |
| 370 | |
Jagannadha Sutradharudu Teki | 3163aaa | 2014-01-11 15:13:11 +0530 | [diff] [blame] | 371 | cmd[0] = flash->write_cmd; |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 372 | for (actual = 0; actual < len; actual += chunk_len) { |
Jagannadha Sutradharudu Teki | f77f469 | 2014-01-12 21:40:11 +0530 | [diff] [blame] | 373 | write_addr = offset; |
| 374 | |
Jagannadha Sutradharudu Teki | b902e07 | 2014-01-11 15:25:04 +0530 | [diff] [blame] | 375 | #ifdef CONFIG_SF_DUAL_FLASH |
Jagannadha Sutradharudu Teki | f77f469 | 2014-01-12 21:40:11 +0530 | [diff] [blame] | 376 | if (flash->dual_flash > SF_SINGLE_FLASH) |
Jagan Teki | cb37518 | 2015-09-29 22:29:33 +0530 | [diff] [blame] | 377 | spi_flash_dual(flash, &write_addr); |
Jagannadha Sutradharudu Teki | b902e07 | 2014-01-11 15:25:04 +0530 | [diff] [blame] | 378 | #endif |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 379 | #ifdef CONFIG_SPI_FLASH_BAR |
Jagan Teki | cb37518 | 2015-09-29 22:29:33 +0530 | [diff] [blame] | 380 | ret = spi_flash_write_bar(flash, write_addr); |
Jagannadha Sutradharudu Teki | 6152dd1 | 2013-10-08 23:26:47 +0530 | [diff] [blame] | 381 | if (ret < 0) |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 382 | return ret; |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 383 | #endif |
| 384 | byte_addr = offset % page_size; |
Masahiro Yamada | b414119 | 2014-11-07 03:03:31 +0900 | [diff] [blame] | 385 | chunk_len = min(len - actual, (size_t)(page_size - byte_addr)); |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 386 | |
| 387 | if (flash->spi->max_write_size) |
Masahiro Yamada | b414119 | 2014-11-07 03:03:31 +0900 | [diff] [blame] | 388 | chunk_len = min(chunk_len, |
| 389 | (size_t)flash->spi->max_write_size); |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 390 | |
Jagannadha Sutradharudu Teki | f77f469 | 2014-01-12 21:40:11 +0530 | [diff] [blame] | 391 | spi_flash_addr(write_addr, cmd); |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 392 | |
Jagannadha Sutradharudu Teki | 2ba863f | 2014-01-12 21:38:21 +0530 | [diff] [blame] | 393 | debug("SF: 0x%p => cmd = { 0x%02x 0x%02x%02x%02x } chunk_len = %zu\n", |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 394 | buf + actual, cmd[0], cmd[1], cmd[2], cmd[3], chunk_len); |
| 395 | |
| 396 | ret = spi_flash_write_common(flash, cmd, sizeof(cmd), |
| 397 | buf + actual, chunk_len); |
| 398 | if (ret < 0) { |
| 399 | debug("SF: write failed\n"); |
| 400 | break; |
| 401 | } |
| 402 | |
| 403 | offset += chunk_len; |
| 404 | } |
| 405 | |
| 406 | return ret; |
| 407 | } |
| 408 | |
| 409 | int spi_flash_read_common(struct spi_flash *flash, const u8 *cmd, |
| 410 | size_t cmd_len, void *data, size_t data_len) |
| 411 | { |
| 412 | struct spi_slave *spi = flash->spi; |
| 413 | int ret; |
| 414 | |
| 415 | ret = spi_claim_bus(flash->spi); |
| 416 | if (ret) { |
| 417 | debug("SF: unable to claim SPI bus\n"); |
| 418 | return ret; |
| 419 | } |
| 420 | |
| 421 | ret = spi_flash_cmd_read(spi, cmd, cmd_len, data, data_len); |
| 422 | if (ret < 0) { |
| 423 | debug("SF: read cmd failed\n"); |
| 424 | return ret; |
| 425 | } |
| 426 | |
| 427 | spi_release_bus(spi); |
| 428 | |
| 429 | return ret; |
| 430 | } |
| 431 | |
Tom Rini | 146bad9 | 2015-08-17 13:29:54 +0530 | [diff] [blame] | 432 | void __weak spi_flash_copy_mmap(void *data, void *offset, size_t len) |
| 433 | { |
| 434 | memcpy(data, offset, len); |
| 435 | } |
| 436 | |
Jagannadha Sutradharudu Teki | a5e8199 | 2013-10-02 19:38:49 +0530 | [diff] [blame] | 437 | int spi_flash_cmd_read_ops(struct spi_flash *flash, u32 offset, |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 438 | size_t len, void *data) |
| 439 | { |
Jagannadha Sutradharudu Teki | ab92224 | 2014-01-11 16:57:07 +0530 | [diff] [blame] | 440 | u8 *cmd, cmdsz; |
Jagannadha Sutradharudu Teki | f77f469 | 2014-01-12 21:40:11 +0530 | [diff] [blame] | 441 | u32 remain_len, read_len, read_addr; |
Jagannadha Sutradharudu Teki | ab92224 | 2014-01-11 16:57:07 +0530 | [diff] [blame] | 442 | int bank_sel = 0; |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 443 | int ret = -1; |
| 444 | |
| 445 | /* Handle memory-mapped SPI */ |
| 446 | if (flash->memory_map) { |
Poddar, Sourav | ac5cce3 | 2013-11-14 21:01:15 +0530 | [diff] [blame] | 447 | ret = spi_claim_bus(flash->spi); |
| 448 | if (ret) { |
| 449 | debug("SF: unable to claim SPI bus\n"); |
| 450 | return ret; |
| 451 | } |
Poddar, Sourav | 004f15b | 2013-10-07 15:53:01 +0530 | [diff] [blame] | 452 | spi_xfer(flash->spi, 0, NULL, NULL, SPI_XFER_MMAP); |
Tom Rini | 146bad9 | 2015-08-17 13:29:54 +0530 | [diff] [blame] | 453 | spi_flash_copy_mmap(data, flash->memory_map + offset, len); |
Poddar, Sourav | 004f15b | 2013-10-07 15:53:01 +0530 | [diff] [blame] | 454 | spi_xfer(flash->spi, 0, NULL, NULL, SPI_XFER_MMAP_END); |
Poddar, Sourav | ac5cce3 | 2013-11-14 21:01:15 +0530 | [diff] [blame] | 455 | spi_release_bus(flash->spi); |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 456 | return 0; |
| 457 | } |
| 458 | |
Jagannadha Sutradharudu Teki | ff063ed | 2014-01-11 16:50:45 +0530 | [diff] [blame] | 459 | cmdsz = SPI_FLASH_CMD_LEN + flash->dummy_byte; |
Jagannadha Sutradharudu Teki | c6136aa | 2014-02-04 21:36:13 +0530 | [diff] [blame] | 460 | cmd = calloc(1, cmdsz); |
| 461 | if (!cmd) { |
| 462 | debug("SF: Failed to allocate cmd\n"); |
| 463 | return -ENOMEM; |
| 464 | } |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 465 | |
Jagannadha Sutradharudu Teki | ff063ed | 2014-01-11 16:50:45 +0530 | [diff] [blame] | 466 | cmd[0] = flash->read_cmd; |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 467 | while (len) { |
Jagannadha Sutradharudu Teki | f77f469 | 2014-01-12 21:40:11 +0530 | [diff] [blame] | 468 | read_addr = offset; |
| 469 | |
Jagannadha Sutradharudu Teki | b902e07 | 2014-01-11 15:25:04 +0530 | [diff] [blame] | 470 | #ifdef CONFIG_SF_DUAL_FLASH |
Jagannadha Sutradharudu Teki | f77f469 | 2014-01-12 21:40:11 +0530 | [diff] [blame] | 471 | if (flash->dual_flash > SF_SINGLE_FLASH) |
Jagan Teki | cb37518 | 2015-09-29 22:29:33 +0530 | [diff] [blame] | 472 | spi_flash_dual(flash, &read_addr); |
Jagannadha Sutradharudu Teki | b902e07 | 2014-01-11 15:25:04 +0530 | [diff] [blame] | 473 | #endif |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 474 | #ifdef CONFIG_SPI_FLASH_BAR |
Jagan Teki | cb37518 | 2015-09-29 22:29:33 +0530 | [diff] [blame] | 475 | ret = spi_flash_write_bar(flash, read_addr); |
Jagan Teki | 70ccf59 | 2015-09-02 11:39:48 +0530 | [diff] [blame] | 476 | if (ret < 0) |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 477 | return ret; |
Jagan Teki | 70ccf59 | 2015-09-02 11:39:48 +0530 | [diff] [blame] | 478 | bank_sel = flash->bank_curr; |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 479 | #endif |
Jagannadha Sutradharudu Teki | 056fbc7 | 2014-01-07 00:11:35 +0530 | [diff] [blame] | 480 | remain_len = ((SPI_FLASH_16MB_BOUN << flash->shift) * |
| 481 | (bank_sel + 1)) - offset; |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 482 | if (len < remain_len) |
| 483 | read_len = len; |
| 484 | else |
| 485 | read_len = remain_len; |
| 486 | |
Jagannadha Sutradharudu Teki | f77f469 | 2014-01-12 21:40:11 +0530 | [diff] [blame] | 487 | spi_flash_addr(read_addr, cmd); |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 488 | |
Jagannadha Sutradharudu Teki | ff063ed | 2014-01-11 16:50:45 +0530 | [diff] [blame] | 489 | ret = spi_flash_read_common(flash, cmd, cmdsz, data, read_len); |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 490 | if (ret < 0) { |
| 491 | debug("SF: read failed\n"); |
| 492 | break; |
| 493 | } |
| 494 | |
| 495 | offset += read_len; |
| 496 | len -= read_len; |
| 497 | data += read_len; |
| 498 | } |
| 499 | |
Marek Vasut | a52a178 | 2014-07-12 18:11:31 +0530 | [diff] [blame] | 500 | free(cmd); |
Jagannadha Sutradharudu Teki | 4d5e29a | 2013-08-29 19:01:56 +0530 | [diff] [blame] | 501 | return ret; |
| 502 | } |
Jagannadha Sutradharudu Teki | 10ca45d | 2013-10-02 19:34:53 +0530 | [diff] [blame] | 503 | |
| 504 | #ifdef CONFIG_SPI_FLASH_SST |
| 505 | static int sst_byte_write(struct spi_flash *flash, u32 offset, const void *buf) |
| 506 | { |
| 507 | int ret; |
| 508 | u8 cmd[4] = { |
| 509 | CMD_SST_BP, |
| 510 | offset >> 16, |
| 511 | offset >> 8, |
| 512 | offset, |
| 513 | }; |
| 514 | |
| 515 | debug("BP[%02x]: 0x%p => cmd = { 0x%02x 0x%06x }\n", |
| 516 | spi_w8r8(flash->spi, CMD_READ_STATUS), buf, cmd[0], offset); |
| 517 | |
| 518 | ret = spi_flash_cmd_write_enable(flash); |
| 519 | if (ret) |
| 520 | return ret; |
| 521 | |
| 522 | ret = spi_flash_cmd_write(flash->spi, cmd, sizeof(cmd), buf, 1); |
| 523 | if (ret) |
| 524 | return ret; |
| 525 | |
| 526 | return spi_flash_cmd_wait_ready(flash, SPI_FLASH_PROG_TIMEOUT); |
| 527 | } |
| 528 | |
| 529 | int sst_write_wp(struct spi_flash *flash, u32 offset, size_t len, |
| 530 | const void *buf) |
| 531 | { |
| 532 | size_t actual, cmd_len; |
| 533 | int ret; |
| 534 | u8 cmd[4]; |
| 535 | |
| 536 | ret = spi_claim_bus(flash->spi); |
| 537 | if (ret) { |
| 538 | debug("SF: Unable to claim SPI bus\n"); |
| 539 | return ret; |
| 540 | } |
| 541 | |
| 542 | /* If the data is not word aligned, write out leading single byte */ |
| 543 | actual = offset % 2; |
| 544 | if (actual) { |
| 545 | ret = sst_byte_write(flash, offset, buf); |
| 546 | if (ret) |
| 547 | goto done; |
| 548 | } |
| 549 | offset += actual; |
| 550 | |
| 551 | ret = spi_flash_cmd_write_enable(flash); |
| 552 | if (ret) |
| 553 | goto done; |
| 554 | |
| 555 | cmd_len = 4; |
| 556 | cmd[0] = CMD_SST_AAI_WP; |
| 557 | cmd[1] = offset >> 16; |
| 558 | cmd[2] = offset >> 8; |
| 559 | cmd[3] = offset; |
| 560 | |
| 561 | for (; actual < len - 1; actual += 2) { |
| 562 | debug("WP[%02x]: 0x%p => cmd = { 0x%02x 0x%06x }\n", |
| 563 | spi_w8r8(flash->spi, CMD_READ_STATUS), buf + actual, |
| 564 | cmd[0], offset); |
| 565 | |
| 566 | ret = spi_flash_cmd_write(flash->spi, cmd, cmd_len, |
| 567 | buf + actual, 2); |
| 568 | if (ret) { |
| 569 | debug("SF: sst word program failed\n"); |
| 570 | break; |
| 571 | } |
| 572 | |
| 573 | ret = spi_flash_cmd_wait_ready(flash, SPI_FLASH_PROG_TIMEOUT); |
| 574 | if (ret) |
| 575 | break; |
| 576 | |
| 577 | cmd_len = 1; |
| 578 | offset += 2; |
| 579 | } |
| 580 | |
| 581 | if (!ret) |
| 582 | ret = spi_flash_cmd_write_disable(flash); |
| 583 | |
| 584 | /* If there is a single trailing byte, write it out */ |
| 585 | if (!ret && actual != len) |
| 586 | ret = sst_byte_write(flash, offset, buf + actual); |
| 587 | |
| 588 | done: |
| 589 | debug("SF: sst: program %s %zu bytes @ 0x%zx\n", |
| 590 | ret ? "failure" : "success", len, offset - actual); |
| 591 | |
| 592 | spi_release_bus(flash->spi); |
| 593 | return ret; |
| 594 | } |
Bin Meng | 74c2cee | 2014-12-12 19:36:13 +0530 | [diff] [blame] | 595 | |
| 596 | int sst_write_bp(struct spi_flash *flash, u32 offset, size_t len, |
| 597 | const void *buf) |
| 598 | { |
| 599 | size_t actual; |
| 600 | int ret; |
| 601 | |
| 602 | ret = spi_claim_bus(flash->spi); |
| 603 | if (ret) { |
| 604 | debug("SF: Unable to claim SPI bus\n"); |
| 605 | return ret; |
| 606 | } |
| 607 | |
| 608 | for (actual = 0; actual < len; actual++) { |
| 609 | ret = sst_byte_write(flash, offset, buf + actual); |
| 610 | if (ret) { |
| 611 | debug("SF: sst byte program failed\n"); |
| 612 | break; |
| 613 | } |
| 614 | offset++; |
| 615 | } |
| 616 | |
| 617 | if (!ret) |
| 618 | ret = spi_flash_cmd_write_disable(flash); |
| 619 | |
| 620 | debug("SF: sst: program %s %zu bytes @ 0x%zx\n", |
| 621 | ret ? "failure" : "success", len, offset - actual); |
| 622 | |
| 623 | spi_release_bus(flash->spi); |
| 624 | return ret; |
| 625 | } |
Jagannadha Sutradharudu Teki | 10ca45d | 2013-10-02 19:34:53 +0530 | [diff] [blame] | 626 | #endif |
Fabio Estevam | 41b358d | 2015-11-05 12:43:41 -0200 | [diff] [blame] | 627 | |
Fabio Estevam | 5168721 | 2015-11-17 16:50:53 -0200 | [diff] [blame] | 628 | #if defined(CONFIG_SPI_FLASH_STMICRO) || defined(CONFIG_SPI_FLASH_SST) |
Fabio Estevam | 41b358d | 2015-11-05 12:43:41 -0200 | [diff] [blame] | 629 | static void stm_get_locked_range(struct spi_flash *flash, u8 sr, loff_t *ofs, |
| 630 | u32 *len) |
| 631 | { |
| 632 | u8 mask = SR_BP2 | SR_BP1 | SR_BP0; |
| 633 | int shift = ffs(mask) - 1; |
| 634 | int pow; |
| 635 | |
| 636 | if (!(sr & mask)) { |
| 637 | /* No protection */ |
| 638 | *ofs = 0; |
| 639 | *len = 0; |
| 640 | } else { |
| 641 | pow = ((sr & mask) ^ mask) >> shift; |
| 642 | *len = flash->size >> pow; |
| 643 | *ofs = flash->size - *len; |
| 644 | } |
| 645 | } |
| 646 | |
| 647 | /* |
| 648 | * Return 1 if the entire region is locked, 0 otherwise |
| 649 | */ |
Fabio Estevam | c3c016c | 2015-11-05 12:43:42 -0200 | [diff] [blame] | 650 | static int stm_is_locked_sr(struct spi_flash *flash, u32 ofs, u32 len, |
Fabio Estevam | 41b358d | 2015-11-05 12:43:41 -0200 | [diff] [blame] | 651 | u8 sr) |
| 652 | { |
| 653 | loff_t lock_offs; |
| 654 | u32 lock_len; |
| 655 | |
| 656 | stm_get_locked_range(flash, sr, &lock_offs, &lock_len); |
| 657 | |
| 658 | return (ofs + len <= lock_offs + lock_len) && (ofs >= lock_offs); |
| 659 | } |
| 660 | |
| 661 | /* |
| 662 | * Check if a region of the flash is (completely) locked. See stm_lock() for |
| 663 | * more info. |
| 664 | * |
| 665 | * Returns 1 if entire region is locked, 0 if any portion is unlocked, and |
| 666 | * negative on errors. |
| 667 | */ |
Fabio Estevam | c3c016c | 2015-11-05 12:43:42 -0200 | [diff] [blame] | 668 | int stm_is_locked(struct spi_flash *flash, u32 ofs, size_t len) |
Fabio Estevam | 41b358d | 2015-11-05 12:43:41 -0200 | [diff] [blame] | 669 | { |
| 670 | int status; |
| 671 | u8 sr; |
| 672 | |
Jagan Teki | cb37518 | 2015-09-29 22:29:33 +0530 | [diff] [blame] | 673 | status = read_sr(flash, &sr); |
Fabio Estevam | 41b358d | 2015-11-05 12:43:41 -0200 | [diff] [blame] | 674 | if (status < 0) |
| 675 | return status; |
| 676 | |
| 677 | return stm_is_locked_sr(flash, ofs, len, sr); |
| 678 | } |
| 679 | |
| 680 | /* |
| 681 | * Lock a region of the flash. Compatible with ST Micro and similar flash. |
| 682 | * Supports only the block protection bits BP{0,1,2} in the status register |
| 683 | * (SR). Does not support these features found in newer SR bitfields: |
| 684 | * - TB: top/bottom protect - only handle TB=0 (top protect) |
| 685 | * - SEC: sector/block protect - only handle SEC=0 (block protect) |
| 686 | * - CMP: complement protect - only support CMP=0 (range is not complemented) |
| 687 | * |
| 688 | * Sample table portion for 8MB flash (Winbond w25q64fw): |
| 689 | * |
| 690 | * SEC | TB | BP2 | BP1 | BP0 | Prot Length | Protected Portion |
| 691 | * -------------------------------------------------------------------------- |
| 692 | * X | X | 0 | 0 | 0 | NONE | NONE |
| 693 | * 0 | 0 | 0 | 0 | 1 | 128 KB | Upper 1/64 |
| 694 | * 0 | 0 | 0 | 1 | 0 | 256 KB | Upper 1/32 |
| 695 | * 0 | 0 | 0 | 1 | 1 | 512 KB | Upper 1/16 |
| 696 | * 0 | 0 | 1 | 0 | 0 | 1 MB | Upper 1/8 |
| 697 | * 0 | 0 | 1 | 0 | 1 | 2 MB | Upper 1/4 |
| 698 | * 0 | 0 | 1 | 1 | 0 | 4 MB | Upper 1/2 |
| 699 | * X | X | 1 | 1 | 1 | 8 MB | ALL |
| 700 | * |
| 701 | * Returns negative on errors, 0 on success. |
| 702 | */ |
| 703 | int stm_lock(struct spi_flash *flash, u32 ofs, size_t len) |
| 704 | { |
| 705 | u8 status_old, status_new; |
| 706 | u8 mask = SR_BP2 | SR_BP1 | SR_BP0; |
| 707 | u8 shift = ffs(mask) - 1, pow, val; |
Fabio Estevam | a668a16 | 2015-11-17 17:13:33 -0200 | [diff] [blame] | 708 | int ret; |
Fabio Estevam | 41b358d | 2015-11-05 12:43:41 -0200 | [diff] [blame] | 709 | |
Jagan Teki | cb37518 | 2015-09-29 22:29:33 +0530 | [diff] [blame] | 710 | ret = read_sr(flash, &status_old); |
Fabio Estevam | a668a16 | 2015-11-17 17:13:33 -0200 | [diff] [blame] | 711 | if (ret < 0) |
| 712 | return ret; |
Fabio Estevam | 41b358d | 2015-11-05 12:43:41 -0200 | [diff] [blame] | 713 | |
| 714 | /* SPI NOR always locks to the end */ |
| 715 | if (ofs + len != flash->size) { |
| 716 | /* Does combined region extend to end? */ |
| 717 | if (!stm_is_locked_sr(flash, ofs + len, flash->size - ofs - len, |
| 718 | status_old)) |
| 719 | return -EINVAL; |
| 720 | len = flash->size - ofs; |
| 721 | } |
| 722 | |
| 723 | /* |
| 724 | * Need smallest pow such that: |
| 725 | * |
| 726 | * 1 / (2^pow) <= (len / size) |
| 727 | * |
| 728 | * so (assuming power-of-2 size) we do: |
| 729 | * |
| 730 | * pow = ceil(log2(size / len)) = log2(size) - floor(log2(len)) |
| 731 | */ |
| 732 | pow = ilog2(flash->size) - ilog2(len); |
| 733 | val = mask - (pow << shift); |
| 734 | if (val & ~mask) |
| 735 | return -EINVAL; |
| 736 | |
| 737 | /* Don't "lock" with no region! */ |
| 738 | if (!(val & mask)) |
| 739 | return -EINVAL; |
| 740 | |
| 741 | status_new = (status_old & ~mask) | val; |
| 742 | |
| 743 | /* Only modify protection if it will not unlock other areas */ |
| 744 | if ((status_new & mask) <= (status_old & mask)) |
| 745 | return -EINVAL; |
| 746 | |
Jagan Teki | cb37518 | 2015-09-29 22:29:33 +0530 | [diff] [blame] | 747 | write_sr(flash, status_new); |
Fabio Estevam | 41b358d | 2015-11-05 12:43:41 -0200 | [diff] [blame] | 748 | |
| 749 | return 0; |
| 750 | } |
| 751 | |
| 752 | /* |
| 753 | * Unlock a region of the flash. See stm_lock() for more info |
| 754 | * |
| 755 | * Returns negative on errors, 0 on success. |
| 756 | */ |
| 757 | int stm_unlock(struct spi_flash *flash, u32 ofs, size_t len) |
| 758 | { |
| 759 | uint8_t status_old, status_new; |
| 760 | u8 mask = SR_BP2 | SR_BP1 | SR_BP0; |
| 761 | u8 shift = ffs(mask) - 1, pow, val; |
Fabio Estevam | a668a16 | 2015-11-17 17:13:33 -0200 | [diff] [blame] | 762 | int ret; |
Fabio Estevam | 41b358d | 2015-11-05 12:43:41 -0200 | [diff] [blame] | 763 | |
Jagan Teki | cb37518 | 2015-09-29 22:29:33 +0530 | [diff] [blame] | 764 | ret = read_sr(flash, &status_old); |
Fabio Estevam | a668a16 | 2015-11-17 17:13:33 -0200 | [diff] [blame] | 765 | if (ret < 0) |
| 766 | return ret; |
Fabio Estevam | 41b358d | 2015-11-05 12:43:41 -0200 | [diff] [blame] | 767 | |
| 768 | /* Cannot unlock; would unlock larger region than requested */ |
| 769 | if (stm_is_locked_sr(flash, status_old, ofs - flash->erase_size, |
| 770 | flash->erase_size)) |
| 771 | return -EINVAL; |
| 772 | /* |
| 773 | * Need largest pow such that: |
| 774 | * |
| 775 | * 1 / (2^pow) >= (len / size) |
| 776 | * |
| 777 | * so (assuming power-of-2 size) we do: |
| 778 | * |
| 779 | * pow = floor(log2(size / len)) = log2(size) - ceil(log2(len)) |
| 780 | */ |
| 781 | pow = ilog2(flash->size) - order_base_2(flash->size - (ofs + len)); |
| 782 | if (ofs + len == flash->size) { |
| 783 | val = 0; /* fully unlocked */ |
| 784 | } else { |
| 785 | val = mask - (pow << shift); |
| 786 | /* Some power-of-two sizes are not supported */ |
| 787 | if (val & ~mask) |
| 788 | return -EINVAL; |
| 789 | } |
| 790 | |
| 791 | status_new = (status_old & ~mask) | val; |
| 792 | |
| 793 | /* Only modify protection if it will not lock other areas */ |
| 794 | if ((status_new & mask) >= (status_old & mask)) |
| 795 | return -EINVAL; |
| 796 | |
Jagan Teki | cb37518 | 2015-09-29 22:29:33 +0530 | [diff] [blame] | 797 | write_sr(flash, status_new); |
Fabio Estevam | 41b358d | 2015-11-05 12:43:41 -0200 | [diff] [blame] | 798 | |
| 799 | return 0; |
| 800 | } |
Fabio Estevam | 5168721 | 2015-11-17 16:50:53 -0200 | [diff] [blame] | 801 | #endif |
Jagan Teki | 3847c0c | 2015-12-11 21:36:34 +0530 | [diff] [blame] | 802 | |
| 803 | |
Jagan Teki | 3847c0c | 2015-12-11 21:36:34 +0530 | [diff] [blame] | 804 | #ifdef CONFIG_SPI_FLASH_MACRONIX |
| 805 | static int spi_flash_set_qeb_mxic(struct spi_flash *flash) |
| 806 | { |
| 807 | u8 qeb_status; |
| 808 | int ret; |
| 809 | |
Jagan Teki | cb37518 | 2015-09-29 22:29:33 +0530 | [diff] [blame] | 810 | ret = read_sr(flash, &qeb_status); |
Jagan Teki | 3847c0c | 2015-12-11 21:36:34 +0530 | [diff] [blame] | 811 | if (ret < 0) |
| 812 | return ret; |
| 813 | |
| 814 | if (qeb_status & STATUS_QEB_MXIC) { |
| 815 | debug("SF: mxic: QEB is already set\n"); |
| 816 | } else { |
Jagan Teki | cb37518 | 2015-09-29 22:29:33 +0530 | [diff] [blame] | 817 | ret = write_sr(flash, STATUS_QEB_MXIC); |
Jagan Teki | 3847c0c | 2015-12-11 21:36:34 +0530 | [diff] [blame] | 818 | if (ret < 0) |
| 819 | return ret; |
| 820 | } |
| 821 | |
| 822 | return ret; |
| 823 | } |
| 824 | #endif |
| 825 | |
| 826 | #if defined(CONFIG_SPI_FLASH_SPANSION) || defined(CONFIG_SPI_FLASH_WINBOND) |
| 827 | static int spi_flash_set_qeb_winspan(struct spi_flash *flash) |
| 828 | { |
| 829 | u8 qeb_status; |
| 830 | int ret; |
| 831 | |
Jagan Teki | cb37518 | 2015-09-29 22:29:33 +0530 | [diff] [blame] | 832 | ret = read_cr(flash, &qeb_status); |
Jagan Teki | 3847c0c | 2015-12-11 21:36:34 +0530 | [diff] [blame] | 833 | if (ret < 0) |
| 834 | return ret; |
| 835 | |
| 836 | if (qeb_status & STATUS_QEB_WINSPAN) { |
| 837 | debug("SF: winspan: QEB is already set\n"); |
| 838 | } else { |
Jagan Teki | cb37518 | 2015-09-29 22:29:33 +0530 | [diff] [blame] | 839 | ret = write_cr(flash, STATUS_QEB_WINSPAN); |
Jagan Teki | 3847c0c | 2015-12-11 21:36:34 +0530 | [diff] [blame] | 840 | if (ret < 0) |
| 841 | return ret; |
| 842 | } |
| 843 | |
| 844 | return ret; |
| 845 | } |
| 846 | #endif |
| 847 | |
| 848 | static int spi_flash_set_qeb(struct spi_flash *flash, u8 idcode0) |
| 849 | { |
| 850 | switch (idcode0) { |
| 851 | #ifdef CONFIG_SPI_FLASH_MACRONIX |
| 852 | case SPI_FLASH_CFI_MFR_MACRONIX: |
| 853 | return spi_flash_set_qeb_mxic(flash); |
| 854 | #endif |
| 855 | #if defined(CONFIG_SPI_FLASH_SPANSION) || defined(CONFIG_SPI_FLASH_WINBOND) |
| 856 | case SPI_FLASH_CFI_MFR_SPANSION: |
| 857 | case SPI_FLASH_CFI_MFR_WINBOND: |
| 858 | return spi_flash_set_qeb_winspan(flash); |
| 859 | #endif |
| 860 | #ifdef CONFIG_SPI_FLASH_STMICRO |
| 861 | case SPI_FLASH_CFI_MFR_STMICRO: |
| 862 | debug("SF: QEB is volatile for %02x flash\n", idcode0); |
| 863 | return 0; |
| 864 | #endif |
| 865 | default: |
| 866 | printf("SF: Need set QEB func for %02x flash\n", idcode0); |
| 867 | return -1; |
| 868 | } |
| 869 | } |
| 870 | |
Jagan Teki | 3847c0c | 2015-12-11 21:36:34 +0530 | [diff] [blame] | 871 | #if CONFIG_IS_ENABLED(OF_CONTROL) |
| 872 | int spi_flash_decode_fdt(const void *blob, struct spi_flash *flash) |
| 873 | { |
| 874 | fdt_addr_t addr; |
| 875 | fdt_size_t size; |
| 876 | int node; |
| 877 | |
| 878 | /* If there is no node, do nothing */ |
| 879 | node = fdtdec_next_compatible(blob, 0, COMPAT_GENERIC_SPI_FLASH); |
| 880 | if (node < 0) |
| 881 | return 0; |
| 882 | |
| 883 | addr = fdtdec_get_addr_size(blob, node, "memory-map", &size); |
| 884 | if (addr == FDT_ADDR_T_NONE) { |
| 885 | debug("%s: Cannot decode address\n", __func__); |
| 886 | return 0; |
| 887 | } |
| 888 | |
| 889 | if (flash->size != size) { |
| 890 | debug("%s: Memory map must cover entire device\n", __func__); |
| 891 | return -1; |
| 892 | } |
| 893 | flash->memory_map = map_sysmem(addr, size); |
| 894 | |
| 895 | return 0; |
| 896 | } |
| 897 | #endif /* CONFIG_IS_ENABLED(OF_CONTROL) */ |
| 898 | |
Jagan Teki | bfdb07e | 2015-12-06 21:33:32 +0530 | [diff] [blame^] | 899 | int spi_flash_scan(struct spi_flash *flash) |
Jagan Teki | 3847c0c | 2015-12-11 21:36:34 +0530 | [diff] [blame] | 900 | { |
Jagan Teki | bfdb07e | 2015-12-06 21:33:32 +0530 | [diff] [blame^] | 901 | struct spi_slave *spi = flash->spi; |
Jagan Teki | 3847c0c | 2015-12-11 21:36:34 +0530 | [diff] [blame] | 902 | const struct spi_flash_params *params; |
Jagan Teki | 1e90d9f | 2015-09-29 18:06:04 +0530 | [diff] [blame] | 903 | u16 jedec, ext_jedec; |
| 904 | u8 idcode[5]; |
Jagan Teki | 3847c0c | 2015-12-11 21:36:34 +0530 | [diff] [blame] | 905 | u8 cmd; |
Jagan Teki | 3847c0c | 2015-12-11 21:36:34 +0530 | [diff] [blame] | 906 | int ret; |
| 907 | |
Jagan Teki | 1e90d9f | 2015-09-29 18:06:04 +0530 | [diff] [blame] | 908 | /* Read the ID codes */ |
| 909 | ret = spi_flash_cmd(spi, CMD_READ_ID, idcode, sizeof(idcode)); |
| 910 | if (ret) { |
| 911 | printf("SF: Failed to get idcodes\n"); |
| 912 | return -EINVAL; |
| 913 | } |
| 914 | |
| 915 | #ifdef DEBUG |
| 916 | printf("SF: Got idcodes\n"); |
| 917 | print_buffer(0, idcode, 1, sizeof(idcode), 0); |
| 918 | #endif |
| 919 | |
| 920 | jedec = idcode[1] << 8 | idcode[2]; |
| 921 | ext_jedec = idcode[3] << 8 | idcode[4]; |
| 922 | |
Jagan Teki | 3847c0c | 2015-12-11 21:36:34 +0530 | [diff] [blame] | 923 | /* Validate params from spi_flash_params table */ |
| 924 | params = spi_flash_params_table; |
| 925 | for (; params->name != NULL; params++) { |
| 926 | if ((params->jedec >> 16) == idcode[0]) { |
| 927 | if ((params->jedec & 0xFFFF) == jedec) { |
| 928 | if (params->ext_jedec == 0) |
| 929 | break; |
| 930 | else if (params->ext_jedec == ext_jedec) |
| 931 | break; |
| 932 | } |
| 933 | } |
| 934 | } |
| 935 | |
| 936 | if (!params->name) { |
| 937 | printf("SF: Unsupported flash IDs: "); |
| 938 | printf("manuf %02x, jedec %04x, ext_jedec %04x\n", |
| 939 | idcode[0], jedec, ext_jedec); |
| 940 | return -EPROTONOSUPPORT; |
| 941 | } |
| 942 | |
| 943 | /* Flash powers up read-only, so clear BP# bits */ |
Jagan Teki | 6f9d670 | 2015-09-30 02:01:23 +0530 | [diff] [blame] | 944 | if (idcode[0] == SPI_FLASH_CFI_MFR_ATMEL || |
| 945 | idcode[0] == SPI_FLASH_CFI_MFR_MACRONIX || |
| 946 | idcode[0] == SPI_FLASH_CFI_MFR_SST) |
Jagan Teki | cb37518 | 2015-09-29 22:29:33 +0530 | [diff] [blame] | 947 | write_sr(flash, 0); |
Jagan Teki | 3847c0c | 2015-12-11 21:36:34 +0530 | [diff] [blame] | 948 | |
| 949 | /* Assign spi data */ |
Jagan Teki | 3847c0c | 2015-12-11 21:36:34 +0530 | [diff] [blame] | 950 | flash->name = params->name; |
| 951 | flash->memory_map = spi->memory_map; |
| 952 | flash->dual_flash = flash->spi->option; |
| 953 | |
| 954 | /* Assign spi flash flags */ |
| 955 | if (params->flags & SST_WR) |
| 956 | flash->flags |= SNOR_F_SST_WR; |
| 957 | |
| 958 | /* Assign spi_flash ops */ |
| 959 | #ifndef CONFIG_DM_SPI_FLASH |
| 960 | flash->write = spi_flash_cmd_write_ops; |
| 961 | #if defined(CONFIG_SPI_FLASH_SST) |
| 962 | if (flash->flags & SNOR_F_SST_WR) { |
| 963 | if (flash->spi->op_mode_tx & SPI_OPM_TX_BP) |
| 964 | flash->write = sst_write_bp; |
| 965 | else |
| 966 | flash->write = sst_write_wp; |
| 967 | } |
| 968 | #endif |
| 969 | flash->erase = spi_flash_cmd_erase_ops; |
| 970 | flash->read = spi_flash_cmd_read_ops; |
| 971 | #endif |
| 972 | |
| 973 | /* lock hooks are flash specific - assign them based on idcode0 */ |
| 974 | switch (idcode[0]) { |
| 975 | #if defined(CONFIG_SPI_FLASH_STMICRO) || defined(CONFIG_SPI_FLASH_SST) |
| 976 | case SPI_FLASH_CFI_MFR_STMICRO: |
| 977 | case SPI_FLASH_CFI_MFR_SST: |
| 978 | flash->flash_lock = stm_lock; |
| 979 | flash->flash_unlock = stm_unlock; |
| 980 | flash->flash_is_locked = stm_is_locked; |
| 981 | #endif |
| 982 | break; |
| 983 | default: |
| 984 | debug("SF: Lock ops not supported for %02x flash\n", idcode[0]); |
| 985 | } |
| 986 | |
| 987 | /* Compute the flash size */ |
| 988 | flash->shift = (flash->dual_flash & SF_DUAL_PARALLEL_FLASH) ? 1 : 0; |
| 989 | /* |
| 990 | * The Spansion S25FL032P and S25FL064P have 256b pages, yet use the |
| 991 | * 0x4d00 Extended JEDEC code. The rest of the Spansion flashes with |
| 992 | * the 0x4d00 Extended JEDEC code have 512b pages. All of the others |
| 993 | * have 256b pages. |
| 994 | */ |
| 995 | if (ext_jedec == 0x4d00) { |
| 996 | if ((jedec == 0x0215) || (jedec == 0x216)) |
| 997 | flash->page_size = 256; |
| 998 | else |
| 999 | flash->page_size = 512; |
| 1000 | } else { |
| 1001 | flash->page_size = 256; |
| 1002 | } |
| 1003 | flash->page_size <<= flash->shift; |
| 1004 | flash->sector_size = params->sector_size << flash->shift; |
| 1005 | flash->size = flash->sector_size * params->nr_sectors << flash->shift; |
| 1006 | #ifdef CONFIG_SF_DUAL_FLASH |
| 1007 | if (flash->dual_flash & SF_DUAL_STACKED_FLASH) |
| 1008 | flash->size <<= 1; |
| 1009 | #endif |
| 1010 | |
| 1011 | /* Compute erase sector and command */ |
| 1012 | if (params->flags & SECT_4K) { |
| 1013 | flash->erase_cmd = CMD_ERASE_4K; |
| 1014 | flash->erase_size = 4096 << flash->shift; |
| 1015 | } else if (params->flags & SECT_32K) { |
| 1016 | flash->erase_cmd = CMD_ERASE_32K; |
| 1017 | flash->erase_size = 32768 << flash->shift; |
| 1018 | } else { |
| 1019 | flash->erase_cmd = CMD_ERASE_64K; |
| 1020 | flash->erase_size = flash->sector_size; |
| 1021 | } |
| 1022 | |
| 1023 | /* Now erase size becomes valid sector size */ |
| 1024 | flash->sector_size = flash->erase_size; |
| 1025 | |
| 1026 | /* Look for the fastest read cmd */ |
| 1027 | cmd = fls(params->e_rd_cmd & flash->spi->op_mode_rx); |
| 1028 | if (cmd) { |
| 1029 | cmd = spi_read_cmds_array[cmd - 1]; |
| 1030 | flash->read_cmd = cmd; |
| 1031 | } else { |
| 1032 | /* Go for default supported read cmd */ |
| 1033 | flash->read_cmd = CMD_READ_ARRAY_FAST; |
| 1034 | } |
| 1035 | |
| 1036 | /* Not require to look for fastest only two write cmds yet */ |
| 1037 | if (params->flags & WR_QPP && flash->spi->op_mode_tx & SPI_OPM_TX_QPP) |
| 1038 | flash->write_cmd = CMD_QUAD_PAGE_PROGRAM; |
| 1039 | else |
| 1040 | /* Go for default supported write cmd */ |
| 1041 | flash->write_cmd = CMD_PAGE_PROGRAM; |
| 1042 | |
| 1043 | /* Set the quad enable bit - only for quad commands */ |
| 1044 | if ((flash->read_cmd == CMD_READ_QUAD_OUTPUT_FAST) || |
| 1045 | (flash->read_cmd == CMD_READ_QUAD_IO_FAST) || |
| 1046 | (flash->write_cmd == CMD_QUAD_PAGE_PROGRAM)) { |
| 1047 | ret = spi_flash_set_qeb(flash, idcode[0]); |
| 1048 | if (ret) { |
| 1049 | debug("SF: Fail to set QEB for %02x\n", idcode[0]); |
| 1050 | return -EINVAL; |
| 1051 | } |
| 1052 | } |
| 1053 | |
| 1054 | /* Read dummy_byte: dummy byte is determined based on the |
| 1055 | * dummy cycles of a particular command. |
| 1056 | * Fast commands - dummy_byte = dummy_cycles/8 |
| 1057 | * I/O commands- dummy_byte = (dummy_cycles * no.of lines)/8 |
| 1058 | * For I/O commands except cmd[0] everything goes on no.of lines |
| 1059 | * based on particular command but incase of fast commands except |
| 1060 | * data all go on single line irrespective of command. |
| 1061 | */ |
| 1062 | switch (flash->read_cmd) { |
| 1063 | case CMD_READ_QUAD_IO_FAST: |
| 1064 | flash->dummy_byte = 2; |
| 1065 | break; |
| 1066 | case CMD_READ_ARRAY_SLOW: |
| 1067 | flash->dummy_byte = 0; |
| 1068 | break; |
| 1069 | default: |
| 1070 | flash->dummy_byte = 1; |
| 1071 | } |
| 1072 | |
| 1073 | #ifdef CONFIG_SPI_FLASH_STMICRO |
| 1074 | if (params->flags & E_FSR) |
| 1075 | flash->flags |= SNOR_F_USE_FSR; |
| 1076 | #endif |
| 1077 | |
| 1078 | /* Configure the BAR - discover bank cmds and read current bank */ |
| 1079 | #ifdef CONFIG_SPI_FLASH_BAR |
Jagan Teki | cb37518 | 2015-09-29 22:29:33 +0530 | [diff] [blame] | 1080 | ret = spi_flash_read_bar(flash, idcode[0]); |
Jagan Teki | 3847c0c | 2015-12-11 21:36:34 +0530 | [diff] [blame] | 1081 | if (ret < 0) |
| 1082 | return ret; |
| 1083 | #endif |
| 1084 | |
| 1085 | #if CONFIG_IS_ENABLED(OF_CONTROL) |
| 1086 | ret = spi_flash_decode_fdt(gd->fdt_blob, flash); |
| 1087 | if (ret) { |
| 1088 | debug("SF: FDT decode error\n"); |
| 1089 | return -EINVAL; |
| 1090 | } |
| 1091 | #endif |
| 1092 | |
| 1093 | #ifndef CONFIG_SPL_BUILD |
| 1094 | printf("SF: Detected %s with page size ", flash->name); |
| 1095 | print_size(flash->page_size, ", erase size "); |
| 1096 | print_size(flash->erase_size, ", total "); |
| 1097 | print_size(flash->size, ""); |
| 1098 | if (flash->memory_map) |
| 1099 | printf(", mapped at %p", flash->memory_map); |
| 1100 | puts("\n"); |
| 1101 | #endif |
| 1102 | |
| 1103 | #ifndef CONFIG_SPI_FLASH_BAR |
| 1104 | if (((flash->dual_flash == SF_SINGLE_FLASH) && |
| 1105 | (flash->size > SPI_FLASH_16MB_BOUN)) || |
| 1106 | ((flash->dual_flash > SF_SINGLE_FLASH) && |
| 1107 | (flash->size > SPI_FLASH_16MB_BOUN << 1))) { |
| 1108 | puts("SF: Warning - Only lower 16MiB accessible,"); |
| 1109 | puts(" Full access #define CONFIG_SPI_FLASH_BAR\n"); |
| 1110 | } |
| 1111 | #endif |
| 1112 | |
| 1113 | return ret; |
| 1114 | } |