1 /* 2 * (C) Copyright 2019 Rockchip Electronics Co., Ltd 3 * 4 * SPDX-License-Identifier: GPL-2.0+ 5 */ 6 7 #include <common.h> 8 #include <blk.h> 9 #include <boot_rkimg.h> 10 #include <dm.h> 11 #include <errno.h> 12 #include <malloc.h> 13 #include <nand.h> 14 #include <part.h> 15 #include <dm/device-internal.h> 16 17 #define MTD_PART_NAND_HEAD "mtdparts=" 18 #define MTD_PART_INFO_MAX_SIZE 512 19 #define MTD_SINGLE_PART_INFO_MAX_SIZE 40 20 21 #define MTD_BLK_TABLE_BLOCK_UNKNOWN (-2) 22 #define MTD_BLK_TABLE_BLOCK_SHIFT (-1) 23 24 static int *mtd_map_blk_table; 25 26 int mtd_blk_map_table_init(struct blk_desc *desc, 27 loff_t offset, 28 size_t length) 29 { 30 u32 blk_total, blk_begin, blk_cnt; 31 struct mtd_info *mtd = NULL; 32 int i, j; 33 34 if (!desc) 35 return -ENODEV; 36 37 if (desc->devnum == BLK_MTD_NAND) { 38 #if defined(CONFIG_NAND) && !defined(CONFIG_SPL_BUILD) 39 mtd = dev_get_priv(desc->bdev->parent); 40 #endif 41 } else if (desc->devnum == BLK_MTD_SPI_NAND) { 42 #if defined(CONFIG_MTD_SPI_NAND) && !defined(CONFIG_SPL_BUILD) 43 mtd = desc->bdev->priv; 44 #endif 45 } 46 47 if (!mtd) { 48 return -ENODEV; 49 } else { 50 blk_total = (mtd->size + mtd->erasesize - 1) / mtd->erasesize; 51 if (!mtd_map_blk_table) { 52 mtd_map_blk_table = (int *)malloc(blk_total * 4); 53 memset(mtd_map_blk_table, MTD_BLK_TABLE_BLOCK_UNKNOWN, 54 blk_total * 4); 55 } 56 57 blk_begin = (u32)offset / mtd->erasesize; 58 blk_cnt = ((u32)(offset % mtd->erasesize + length) / mtd->erasesize); 59 if ((blk_begin + blk_cnt) > blk_total) 60 blk_cnt = blk_total - blk_begin; 61 62 if (mtd_map_blk_table[blk_begin] != MTD_BLK_TABLE_BLOCK_UNKNOWN) 63 return 0; 64 65 j = 0; 66 /* should not across blk_cnt */ 67 for (i = 0; i < blk_cnt; i++) { 68 if (j >= blk_cnt) 69 mtd_map_blk_table[blk_begin + i] = MTD_BLK_TABLE_BLOCK_SHIFT; 70 for (; j < blk_cnt; j++) { 71 if (!mtd_block_isbad(mtd, (blk_begin + j) * mtd->erasesize)) { 72 mtd_map_blk_table[blk_begin + i] = blk_begin + j; 73 j++; 74 if (j == blk_cnt) 75 j++; 76 break; 77 } 78 } 79 } 80 81 return 0; 82 } 83 } 84 85 static __maybe_unused int mtd_map_read(struct mtd_info *mtd, loff_t offset, 86 size_t *length, size_t *actual, 87 loff_t lim, u_char *buffer) 88 { 89 size_t left_to_read = *length; 90 u_char *p_buffer = buffer; 91 u32 erasesize = mtd->erasesize; 92 int rval; 93 94 while (left_to_read > 0) { 95 size_t block_offset = offset & (erasesize - 1); 96 size_t read_length; 97 loff_t mapped_offset; 98 bool mapped; 99 100 if (offset >= mtd->size) 101 return 0; 102 103 mapped_offset = offset; 104 mapped = false; 105 if (mtd_map_blk_table && 106 mtd_map_blk_table[(u64)offset / erasesize] != 107 MTD_BLK_TABLE_BLOCK_UNKNOWN) { 108 mapped = true; 109 mapped_offset = (loff_t)((u32)mtd_map_blk_table[(u64)offset / 110 erasesize] * erasesize + block_offset); 111 } 112 113 if (!mapped) { 114 if (mtd_block_isbad(mtd, offset & ~(erasesize - 1))) { 115 printf("Skip bad block 0x%08llx\n", 116 offset & ~(erasesize - 1)); 117 offset += erasesize - block_offset; 118 continue; 119 } 120 } 121 122 if (left_to_read < (erasesize - block_offset)) 123 read_length = left_to_read; 124 else 125 read_length = erasesize - block_offset; 126 127 rval = mtd_read(mtd, mapped_offset, read_length, &read_length, 128 p_buffer); 129 if (rval && rval != -EUCLEAN) { 130 printf("NAND read from offset %llx failed %d\n", 131 mapped_offset, rval); 132 *length -= left_to_read; 133 return rval; 134 } 135 136 left_to_read -= read_length; 137 offset += read_length; 138 p_buffer += read_length; 139 } 140 141 return 0; 142 } 143 144 char *mtd_part_parse(void) 145 { 146 char mtd_part_info_temp[MTD_SINGLE_PART_INFO_MAX_SIZE] = {0}; 147 u32 length, data_len = MTD_PART_INFO_MAX_SIZE; 148 struct blk_desc *dev_desc; 149 disk_partition_t info; 150 char *mtd_part_info_p; 151 struct mtd_info *mtd; 152 char *mtd_part_info; 153 int ret; 154 int p; 155 156 dev_desc = rockchip_get_bootdev(); 157 if (!dev_desc) 158 return NULL; 159 160 mtd = (struct mtd_info *)dev_desc->bdev->priv; 161 if (!mtd) 162 return NULL; 163 164 mtd_part_info = (char *)calloc(MTD_PART_INFO_MAX_SIZE, sizeof(char)); 165 if (!mtd_part_info) { 166 printf("%s: Fail to malloc!", __func__); 167 return NULL; 168 } 169 170 mtd_part_info_p = mtd_part_info; 171 snprintf(mtd_part_info_p, data_len - 1, "%s%s:", 172 MTD_PART_NAND_HEAD, 173 dev_desc->product); 174 data_len -= strlen(mtd_part_info_p); 175 mtd_part_info_p = mtd_part_info_p + strlen(mtd_part_info_p); 176 177 for (p = 1; p < MAX_SEARCH_PARTITIONS; p++) { 178 ret = part_get_info(dev_desc, p, &info); 179 if (ret) 180 break; 181 182 debug("name is %s, start addr is %x\n", info.name, 183 (int)(size_t)info.start); 184 185 snprintf(mtd_part_info_p, data_len - 1, "0x%x@0x%x(%s)", 186 (int)(size_t)info.size << 9, 187 (int)(size_t)info.start << 9, 188 info.name); 189 snprintf(mtd_part_info_temp, MTD_SINGLE_PART_INFO_MAX_SIZE - 1, 190 "0x%x@0x%x(%s)", 191 (int)(size_t)info.size << 9, 192 (int)(size_t)info.start << 9, 193 info.name); 194 strcat(mtd_part_info, ","); 195 if (part_get_info(dev_desc, p + 1, &info)) { 196 /* Nand flash is erased by block and gpt table just 197 * resserve 33 sectors for the last partition. This 198 * will erase the backup gpt table by user program, 199 * so reserve one block. 200 */ 201 snprintf(mtd_part_info_p, data_len - 1, "0x%x@0x%x(%s)", 202 (int)(size_t)(info.size - 203 (info.size - 1) % 204 (mtd->erasesize >> 9) - 1) << 9, 205 (int)(size_t)info.start << 9, 206 info.name); 207 break; 208 } 209 length = strlen(mtd_part_info_temp); 210 data_len -= length; 211 mtd_part_info_p = mtd_part_info_p + length + 1; 212 memset(mtd_part_info_temp, 0, MTD_SINGLE_PART_INFO_MAX_SIZE); 213 } 214 215 return mtd_part_info; 216 } 217 218 ulong mtd_dread(struct udevice *udev, lbaint_t start, 219 lbaint_t blkcnt, void *dst) 220 { 221 struct blk_desc *desc = dev_get_uclass_platdata(udev); 222 #if defined(CONFIG_NAND) || defined(CONFIG_MTD_SPI_NAND) || defined(CONFIG_SPI_FLASH_MTD) 223 loff_t off = (loff_t)(start * 512); 224 size_t rwsize = blkcnt * 512; 225 #endif 226 struct mtd_info *mtd; 227 int ret = 0; 228 229 if (!desc) 230 return ret; 231 232 mtd = desc->bdev->priv; 233 if (!mtd) 234 return 0; 235 236 if (blkcnt == 0) 237 return 0; 238 239 if (desc->devnum == BLK_MTD_NAND) { 240 #if defined(CONFIG_NAND) && !defined(CONFIG_SPL_BUILD) 241 mtd = dev_get_priv(udev->parent); 242 if (!mtd) 243 return 0; 244 245 ret = nand_read_skip_bad(mtd, off, &rwsize, 246 NULL, mtd->size, 247 (u_char *)(dst)); 248 #else 249 ret = mtd_map_read(mtd, off, &rwsize, 250 NULL, mtd->size, 251 (u_char *)(dst)); 252 #endif 253 if (!ret) 254 return blkcnt; 255 else 256 return 0; 257 } else if (desc->devnum == BLK_MTD_SPI_NAND) { 258 ret = mtd_map_read(mtd, off, &rwsize, 259 NULL, mtd->size, 260 (u_char *)(dst)); 261 if (!ret) 262 return blkcnt; 263 else 264 return 0; 265 } else if (desc->devnum == BLK_MTD_SPI_NOR) { 266 #if defined(CONFIG_SPI_FLASH_MTD) || defined(CONFIG_SPL_BUILD) 267 size_t retlen_nor; 268 269 mtd_read(mtd, off, rwsize, &retlen_nor, dst); 270 if (retlen_nor == rwsize) 271 return blkcnt; 272 else 273 #endif 274 return 0; 275 } else { 276 return 0; 277 } 278 } 279 280 ulong mtd_dwrite(struct udevice *udev, lbaint_t start, 281 lbaint_t blkcnt, const void *src) 282 { 283 /* Not implemented */ 284 return 0; 285 } 286 287 ulong mtd_derase(struct udevice *udev, lbaint_t start, 288 lbaint_t blkcnt) 289 { 290 /* Not implemented */ 291 return 0; 292 } 293 294 static int mtd_blk_probe(struct udevice *udev) 295 { 296 struct mtd_info *mtd = dev_get_uclass_priv(udev->parent); 297 struct blk_desc *desc = dev_get_uclass_platdata(udev); 298 int ret, i; 299 300 desc->bdev->priv = mtd; 301 sprintf(desc->vendor, "0x%.4x", 0x2207); 302 memcpy(desc->product, mtd->name, strlen(mtd->name)); 303 memcpy(desc->revision, "V1.00", sizeof("V1.00")); 304 if (mtd->type == MTD_NANDFLASH) { 305 if (desc->devnum == BLK_MTD_NAND) 306 mtd = dev_get_priv(udev->parent); 307 /* 308 * Find the first useful block in the end, 309 * and it is the end lba of the nand storage. 310 */ 311 for (i = 0; i < (mtd->size / mtd->erasesize); i++) { 312 ret = mtd_block_isbad(mtd, 313 mtd->size - mtd->erasesize * (i + 1)); 314 if (!ret) { 315 desc->lba = (mtd->size >> 9) - 316 (mtd->erasesize >> 9) * i; 317 break; 318 } 319 } 320 } else { 321 desc->lba = mtd->size >> 9; 322 } 323 324 debug("MTD: desc->lba is %lx\n", desc->lba); 325 326 return 0; 327 } 328 329 static const struct blk_ops mtd_blk_ops = { 330 .read = mtd_dread, 331 #ifndef CONFIG_SPL_BUILD 332 .write = mtd_dwrite, 333 .erase = mtd_derase, 334 #endif 335 }; 336 337 U_BOOT_DRIVER(mtd_blk) = { 338 .name = "mtd_blk", 339 .id = UCLASS_BLK, 340 .ops = &mtd_blk_ops, 341 .probe = mtd_blk_probe, 342 }; 343