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, 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 return sftl_init(); 140 } 141 142 int rksfc_nand_read(struct udevice *udev, u32 index, u32 count, void *buf) 143 { 144 int ret; 145 146 ret = sftl_read(index, count, (u8 *)buf); 147 if (!ret) 148 return count; 149 else 150 return -EIO; 151 } 152 153 int rksfc_nand_write(struct udevice *udev, 154 u32 index, 155 u32 count, 156 const void *buf) 157 { 158 int ret; 159 160 ret = sftl_write(index, count, (u8 *)buf); 161 if (!ret) 162 return count; 163 else 164 return -EIO; 165 } 166 167 u32 rksfc_nand_get_density(struct udevice *udev) 168 { 169 return sftl_get_density(); 170 } 171 172 int rksfc_nand_vendor_read(struct blk_desc *dev_desc, 173 u32 sec, 174 u32 n_sec, 175 void *p_data) 176 { 177 int ret; 178 179 ret = sftl_vendor_read(sec, n_sec, (u8 *)p_data); 180 if (!ret) 181 return n_sec; 182 else 183 return -EIO; 184 } 185 186 int rksfc_nand_vendor_write(struct blk_desc *dev_desc, 187 u32 sec, 188 u32 n_sec, 189 void *p_data) 190 { 191 int ret; 192 193 ret = sftl_vendor_write(sec, n_sec, (u8 *)p_data); 194 if (!ret) 195 return n_sec; 196 else 197 return -EIO; 198 } 199 200 #endif 201 202 #ifdef CONFIG_RKNANDC_NAND 203 int rknand_flash_init(struct udevice *udev) 204 { 205 return sftl_init(); 206 } 207 208 int rknand_flash_read(struct udevice *udev, u32 index, u32 count, void *buf) 209 { 210 int ret; 211 212 ret = sftl_read(index, count, (u8 *)buf); 213 if (!ret) 214 return count; 215 else 216 return -EIO; 217 } 218 219 int rknand_flash_write(struct udevice *udev, 220 u32 index, 221 u32 count, 222 const void *buf) 223 { 224 int ret; 225 226 ret = sftl_write(index, count, (u8 *)buf); 227 if (!ret) 228 return count; 229 else 230 return -EIO; 231 } 232 233 u32 rknand_flash_get_density(struct udevice *udev) 234 { 235 return sftl_get_density(); 236 } 237 238 int rknand_flash_vendor_read(struct blk_desc *dev_desc, 239 u32 sec, 240 u32 n_sec, 241 void *p_data) 242 { 243 int ret; 244 245 ret = sftl_vendor_read(sec, n_sec, (u8 *)p_data); 246 if (!ret) 247 return n_sec; 248 else 249 return -EIO; 250 } 251 252 int rknand_flash_vendor_write(struct blk_desc *dev_desc, 253 u32 sec, 254 u32 n_sec, 255 void *p_data) 256 { 257 int ret; 258 259 ret = sftl_vendor_write(sec, n_sec, (u8 *)p_data); 260 if (!ret) 261 return n_sec; 262 else 263 return -EIO; 264 } 265 266 #endif 267