1 /* 2 * Copyright (c) 2018 Fuzhou Rockchip Electronics Co., Ltd 3 * 4 * SPDX-License-Identifier: GPL-2.0 5 */ 6 7 #include <common.h> 8 #include <dm.h> 9 10 #include "rkflash_api.h" 11 #include "rkflash_blk.h" 12 13 #ifdef CONFIG_RKSFC_NOR 14 int rksfc_nor_init(struct udevice *udev) 15 { 16 struct rkflash_info *priv = dev_get_priv(udev); 17 struct SFNOR_DEV *p_dev = (struct SFNOR_DEV *)&priv->flash_dev_info; 18 19 return snor_init(p_dev); 20 } 21 22 u32 rksfc_nor_get_capacity(struct udevice *udev) 23 { 24 struct rkflash_info *priv = dev_get_priv(udev); 25 struct SFNOR_DEV *p_dev = (struct SFNOR_DEV *)&priv->flash_dev_info; 26 27 return snor_get_capacity(p_dev); 28 } 29 30 int rksfc_nor_read(struct udevice *udev, u32 sec, u32 n_sec, void *p_data) 31 { 32 u32 ret; 33 u32 offset, count = 0; 34 char *buf = (char *)p_data; 35 struct rkflash_info *priv = dev_get_priv(udev); 36 struct SFNOR_DEV *p_dev = (struct SFNOR_DEV *)&priv->flash_dev_info; 37 38 if (sec + n_sec - 1 < FLASH_VENDOR_PART_START || 39 sec > FLASH_VENDOR_PART_END) { 40 ret = snor_read(p_dev, sec, n_sec, p_data); 41 if (ret != n_sec) 42 return ret; 43 } else { 44 memset(p_data, 0, 512 * n_sec); 45 if (sec < FLASH_VENDOR_PART_START) { 46 count = FLASH_VENDOR_PART_START - sec; 47 buf = (char *)p_data; 48 ret = snor_read(p_dev, sec, count, buf); 49 if (ret != count) 50 return ret; 51 } 52 if ((sec + n_sec - 1) > FLASH_VENDOR_PART_END) { 53 count = sec + n_sec - 1 - FLASH_VENDOR_PART_END; 54 offset = FLASH_VENDOR_PART_END - sec + 1; 55 buf = (char *)p_data + offset * 512; 56 ret = snor_read(p_dev, 57 FLASH_VENDOR_PART_END + 1, 58 count, buf); 59 if (ret != count) 60 return ret; 61 } 62 } 63 64 return n_sec; 65 } 66 67 /* Workaround for GPT not aligned program */ 68 int rksfc_nor_simply_over_write(struct udevice *udev, 69 u32 sec, 70 u32 n_sec, 71 const void *p_data) 72 { 73 struct rkflash_info *priv = dev_get_priv(udev); 74 struct SFNOR_DEV *p_dev = (struct SFNOR_DEV *)&priv->flash_dev_info; 75 u8 *pbuf_temp; 76 u32 addr_aligned, offset, remain; 77 78 addr_aligned = sec / NOR_SECS_PAGE * NOR_SECS_PAGE; 79 offset = sec - addr_aligned; 80 remain = (offset + n_sec + NOR_SECS_PAGE - 1) / NOR_SECS_PAGE * NOR_SECS_PAGE; 81 82 pbuf_temp = malloc(remain * 512); 83 snor_read(p_dev, addr_aligned, remain, pbuf_temp); 84 memcpy(pbuf_temp + offset * 512, p_data, n_sec * 512); 85 snor_write(p_dev, addr_aligned, remain, pbuf_temp); 86 free(pbuf_temp); 87 88 return n_sec; 89 } 90 91 int rksfc_nor_write(struct udevice *udev, 92 u32 sec, 93 u32 n_sec, 94 const void *p_data) 95 { 96 u32 ret; 97 u32 offset, count = 0; 98 char *buf = (char *)p_data; 99 struct rkflash_info *priv = dev_get_priv(udev); 100 struct SFNOR_DEV *p_dev = (struct SFNOR_DEV *)&priv->flash_dev_info; 101 u32 sfc_nor_density = rksfc_nor_get_capacity(udev); 102 103 if (sec >= (sfc_nor_density - 33)) 104 return rksfc_nor_simply_over_write(udev, sec, n_sec, p_data); 105 106 if (sec + n_sec - 1 < FLASH_VENDOR_PART_START || 107 sec > FLASH_VENDOR_PART_END) { 108 ret = snor_write(p_dev, sec, n_sec, (void *)p_data); 109 if (ret != n_sec) 110 return ret; 111 } else { 112 if (sec < FLASH_VENDOR_PART_START) { 113 count = FLASH_VENDOR_PART_START - sec; 114 buf = (char *)p_data; 115 ret = snor_write(p_dev, sec, count, buf); 116 if (ret != count) 117 return ret; 118 } 119 if ((sec + n_sec - 1) > FLASH_VENDOR_PART_END) { 120 count = sec + n_sec - 1 - FLASH_VENDOR_PART_END; 121 offset = FLASH_VENDOR_PART_END - sec + 1; 122 buf = (char *)p_data + offset * 512; 123 ret = snor_write(p_dev, 124 FLASH_VENDOR_PART_END + 1, 125 count, buf); 126 if (ret != count) 127 return ret; 128 } 129 } 130 131 return n_sec; 132 } 133 134 int rksfc_nor_vendor_read(struct blk_desc *dev_desc, 135 u32 sec, 136 u32 n_sec, 137 void *p_data) 138 { 139 struct rkflash_info *priv = dev_get_priv(dev_desc->bdev->parent); 140 struct SFNOR_DEV *p_dev = (struct SFNOR_DEV *)&priv->flash_dev_info; 141 142 return snor_read(p_dev, sec, n_sec, p_data); 143 } 144 145 int rksfc_nor_vendor_write(struct blk_desc *dev_desc, 146 u32 sec, 147 u32 n_sec, 148 void *p_data) 149 { 150 struct rkflash_info *priv = dev_get_priv(dev_desc->bdev->parent); 151 struct SFNOR_DEV *p_dev = (struct SFNOR_DEV *)&priv->flash_dev_info; 152 153 return snor_write(p_dev, sec, n_sec, p_data); 154 } 155 156 #endif 157 158 #ifdef CONFIG_RKSFC_NAND 159 int rksfc_nand_init(struct udevice *udev) 160 { 161 int ret; 162 163 ret = sfc_nand_init(); 164 if (ret) { 165 return ret; 166 } else { 167 sfc_nand_ftl_ops_init(); 168 169 return sftl_init(); 170 } 171 } 172 173 int rksfc_nand_read(struct udevice *udev, u32 index, u32 count, void *buf) 174 { 175 int ret; 176 177 ret = sftl_read(index, count, (u8 *)buf); 178 if (!ret) 179 return count; 180 else 181 return -EIO; 182 } 183 184 int rksfc_nand_write(struct udevice *udev, 185 u32 index, 186 u32 count, 187 const void *buf) 188 { 189 int ret; 190 191 ret = sftl_write(index, count, (u8 *)buf); 192 if (!ret) 193 return count; 194 else 195 return -EIO; 196 } 197 198 u32 rksfc_nand_get_density(struct udevice *udev) 199 { 200 return sftl_get_density(); 201 } 202 203 int rksfc_nand_vendor_read(struct blk_desc *dev_desc, 204 u32 sec, 205 u32 n_sec, 206 void *p_data) 207 { 208 int ret; 209 210 ret = sftl_vendor_read(sec, n_sec, (u8 *)p_data); 211 if (!ret) 212 return n_sec; 213 else 214 return -EIO; 215 } 216 217 int rksfc_nand_vendor_write(struct blk_desc *dev_desc, 218 u32 sec, 219 u32 n_sec, 220 void *p_data) 221 { 222 int ret; 223 224 ret = sftl_vendor_write(sec, n_sec, (u8 *)p_data); 225 if (!ret) 226 return n_sec; 227 else 228 return -EIO; 229 } 230 231 #endif 232 233 #ifdef CONFIG_RKNANDC_NAND 234 int rknand_flash_init(struct udevice *udev) 235 { 236 return sftl_init(); 237 } 238 239 int rknand_flash_read(struct udevice *udev, u32 index, u32 count, void *buf) 240 { 241 int ret; 242 243 ret = sftl_read(index, count, (u8 *)buf); 244 if (!ret) 245 return count; 246 else 247 return -EIO; 248 } 249 250 int rknand_flash_write(struct udevice *udev, 251 u32 index, 252 u32 count, 253 const void *buf) 254 { 255 int ret; 256 257 ret = sftl_write(index, count, (u8 *)buf); 258 if (!ret) 259 return count; 260 else 261 return -EIO; 262 } 263 264 u32 rknand_flash_get_density(struct udevice *udev) 265 { 266 return sftl_get_density(); 267 } 268 269 int rknand_flash_vendor_read(struct blk_desc *dev_desc, 270 u32 sec, 271 u32 n_sec, 272 void *p_data) 273 { 274 int ret; 275 276 ret = sftl_vendor_read(sec, n_sec, (u8 *)p_data); 277 if (!ret) 278 return n_sec; 279 else 280 return -EIO; 281 } 282 283 int rknand_flash_vendor_write(struct blk_desc *dev_desc, 284 u32 sec, 285 u32 n_sec, 286 void *p_data) 287 { 288 int ret; 289 290 ret = sftl_vendor_write(sec, n_sec, (u8 *)p_data); 291 if (!ret) 292 return n_sec; 293 else 294 return -EIO; 295 } 296 297 #endif 298