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 int rksfc_nor_write(struct udevice *udev, 68 u32 sec, 69 u32 n_sec, 70 const void *p_data) 71 { 72 u32 ret; 73 u32 offset, count = 0; 74 char *buf = (char *)p_data; 75 struct rkflash_info *priv = dev_get_priv(udev); 76 struct SFNOR_DEV *p_dev = (struct SFNOR_DEV *)&priv->flash_dev_info; 77 78 if (sec + n_sec - 1 < FLASH_VENDOR_PART_START || 79 sec > FLASH_VENDOR_PART_END) { 80 ret = snor_write(p_dev, sec, n_sec, (void *)p_data); 81 if (ret != n_sec) 82 return ret; 83 } else { 84 if (sec < FLASH_VENDOR_PART_START) { 85 count = FLASH_VENDOR_PART_START - sec; 86 buf = (char *)p_data; 87 ret = snor_write(p_dev, sec, count, buf); 88 if (ret != count) 89 return ret; 90 } 91 if ((sec + n_sec - 1) > FLASH_VENDOR_PART_END) { 92 count = sec + n_sec - 1 - FLASH_VENDOR_PART_END; 93 offset = FLASH_VENDOR_PART_END - sec + 1; 94 buf = (char *)p_data + offset * 512; 95 ret = snor_write(p_dev, 96 FLASH_VENDOR_PART_END + 1, 97 count, buf); 98 if (ret != count) 99 return ret; 100 } 101 } 102 103 return n_sec; 104 } 105 106 int rksfc_nor_vendor_read(struct blk_desc *dev_desc, 107 u32 sec, 108 u32 n_sec, 109 void *p_data) 110 { 111 struct rkflash_info *priv = dev_get_priv(dev_desc->bdev->parent); 112 struct SFNOR_DEV *p_dev = (struct SFNOR_DEV *)&priv->flash_dev_info; 113 114 return snor_read(p_dev, sec, n_sec, p_data); 115 } 116 117 int rksfc_nor_vendor_write(struct blk_desc *dev_desc, 118 u32 sec, 119 u32 n_sec, 120 void *p_data) 121 { 122 struct rkflash_info *priv = dev_get_priv(dev_desc->bdev->parent); 123 struct SFNOR_DEV *p_dev = (struct SFNOR_DEV *)&priv->flash_dev_info; 124 125 return snor_write(p_dev, sec, n_sec, p_data); 126 } 127 128 #endif 129 130 #ifdef CONFIG_RKSFC_NAND 131 int rksfc_nand_init(struct udevice *udev) 132 { 133 int ret; 134 135 ret = sfc_nand_init(); 136 if (ret) { 137 return ret; 138 } else { 139 sfc_nand_ftl_ops_init(); 140 141 return sftl_init(); 142 } 143 } 144 145 int rksfc_nand_read(struct udevice *udev, u32 index, u32 count, void *buf) 146 { 147 int ret; 148 149 ret = sftl_read(index, count, (u8 *)buf); 150 if (!ret) 151 return count; 152 else 153 return -EIO; 154 } 155 156 int rksfc_nand_write(struct udevice *udev, 157 u32 index, 158 u32 count, 159 const void *buf) 160 { 161 int ret; 162 163 ret = sftl_write(index, count, (u8 *)buf); 164 if (!ret) 165 return count; 166 else 167 return -EIO; 168 } 169 170 u32 rksfc_nand_get_density(struct udevice *udev) 171 { 172 return sftl_get_density(); 173 } 174 175 int rksfc_nand_vendor_read(struct blk_desc *dev_desc, 176 u32 sec, 177 u32 n_sec, 178 void *p_data) 179 { 180 int ret; 181 182 ret = sftl_vendor_read(sec, n_sec, (u8 *)p_data); 183 if (!ret) 184 return n_sec; 185 else 186 return -EIO; 187 } 188 189 int rksfc_nand_vendor_write(struct blk_desc *dev_desc, 190 u32 sec, 191 u32 n_sec, 192 void *p_data) 193 { 194 int ret; 195 196 ret = sftl_vendor_write(sec, n_sec, (u8 *)p_data); 197 if (!ret) 198 return n_sec; 199 else 200 return -EIO; 201 } 202 203 #endif 204 205 #ifdef CONFIG_RKNANDC_NAND 206 int rknand_flash_init(struct udevice *udev) 207 { 208 return sftl_init(); 209 } 210 211 int rknand_flash_read(struct udevice *udev, u32 index, u32 count, void *buf) 212 { 213 int ret; 214 215 ret = sftl_read(index, count, (u8 *)buf); 216 if (!ret) 217 return count; 218 else 219 return -EIO; 220 } 221 222 int rknand_flash_write(struct udevice *udev, 223 u32 index, 224 u32 count, 225 const void *buf) 226 { 227 int ret; 228 229 ret = sftl_write(index, count, (u8 *)buf); 230 if (!ret) 231 return count; 232 else 233 return -EIO; 234 } 235 236 u32 rknand_flash_get_density(struct udevice *udev) 237 { 238 return sftl_get_density(); 239 } 240 241 int rknand_flash_vendor_read(struct blk_desc *dev_desc, 242 u32 sec, 243 u32 n_sec, 244 void *p_data) 245 { 246 int ret; 247 248 ret = sftl_vendor_read(sec, n_sec, (u8 *)p_data); 249 if (!ret) 250 return n_sec; 251 else 252 return -EIO; 253 } 254 255 int rknand_flash_vendor_write(struct blk_desc *dev_desc, 256 u32 sec, 257 u32 n_sec, 258 void *p_data) 259 { 260 int ret; 261 262 ret = sftl_vendor_write(sec, n_sec, (u8 *)p_data); 263 if (!ret) 264 return n_sec; 265 else 266 return -EIO; 267 } 268 269 #endif 270