1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * sst25l.c 4 * 5 * Driver for SST25L SPI Flash chips 6 * 7 * Copyright © 2009 Bluewater Systems Ltd 8 * Author: Andre Renaud <andre@bluewatersys.com> 9 * Author: Ryan Mallon 10 * 11 * Based on m25p80.c 12 */ 13 14 #include <linux/module.h> 15 #include <linux/device.h> 16 #include <linux/mutex.h> 17 #include <linux/interrupt.h> 18 #include <linux/slab.h> 19 #include <linux/sched.h> 20 21 #include <linux/mtd/mtd.h> 22 #include <linux/mtd/partitions.h> 23 24 #include <linux/spi/spi.h> 25 #include <linux/spi/flash.h> 26 27 /* Erases can take up to 3 seconds! */ 28 #define MAX_READY_WAIT_JIFFIES msecs_to_jiffies(3000) 29 30 #define SST25L_CMD_WRSR 0x01 /* Write status register */ 31 #define SST25L_CMD_WRDI 0x04 /* Write disable */ 32 #define SST25L_CMD_RDSR 0x05 /* Read status register */ 33 #define SST25L_CMD_WREN 0x06 /* Write enable */ 34 #define SST25L_CMD_READ 0x03 /* High speed read */ 35 36 #define SST25L_CMD_EWSR 0x50 /* Enable write status register */ 37 #define SST25L_CMD_SECTOR_ERASE 0x20 /* Erase sector */ 38 #define SST25L_CMD_READ_ID 0x90 /* Read device ID */ 39 #define SST25L_CMD_AAI_PROGRAM 0xaf /* Auto address increment */ 40 41 #define SST25L_STATUS_BUSY (1 << 0) /* Chip is busy */ 42 #define SST25L_STATUS_WREN (1 << 1) /* Write enabled */ 43 #define SST25L_STATUS_BP0 (1 << 2) /* Block protection 0 */ 44 #define SST25L_STATUS_BP1 (1 << 3) /* Block protection 1 */ 45 46 struct sst25l_flash { 47 struct spi_device *spi; 48 struct mutex lock; 49 struct mtd_info mtd; 50 }; 51 52 struct flash_info { 53 const char *name; 54 uint16_t device_id; 55 unsigned page_size; 56 unsigned nr_pages; 57 unsigned erase_size; 58 }; 59 60 #define to_sst25l_flash(x) container_of(x, struct sst25l_flash, mtd) 61 62 static struct flash_info sst25l_flash_info[] = { 63 {"sst25lf020a", 0xbf43, 256, 1024, 4096}, 64 {"sst25lf040a", 0xbf44, 256, 2048, 4096}, 65 }; 66 67 static int sst25l_status(struct sst25l_flash *flash, int *status) 68 { 69 struct spi_message m; 70 struct spi_transfer t; 71 unsigned char cmd_resp[2]; 72 int err; 73 74 spi_message_init(&m); 75 memset(&t, 0, sizeof(struct spi_transfer)); 76 77 cmd_resp[0] = SST25L_CMD_RDSR; 78 cmd_resp[1] = 0xff; 79 t.tx_buf = cmd_resp; 80 t.rx_buf = cmd_resp; 81 t.len = sizeof(cmd_resp); 82 spi_message_add_tail(&t, &m); 83 err = spi_sync(flash->spi, &m); 84 if (err < 0) 85 return err; 86 87 *status = cmd_resp[1]; 88 return 0; 89 } 90 91 static int sst25l_write_enable(struct sst25l_flash *flash, int enable) 92 { 93 unsigned char command[2]; 94 int status, err; 95 96 command[0] = enable ? SST25L_CMD_WREN : SST25L_CMD_WRDI; 97 err = spi_write(flash->spi, command, 1); 98 if (err) 99 return err; 100 101 command[0] = SST25L_CMD_EWSR; 102 err = spi_write(flash->spi, command, 1); 103 if (err) 104 return err; 105 106 command[0] = SST25L_CMD_WRSR; 107 command[1] = enable ? 0 : SST25L_STATUS_BP0 | SST25L_STATUS_BP1; 108 err = spi_write(flash->spi, command, 2); 109 if (err) 110 return err; 111 112 if (enable) { 113 err = sst25l_status(flash, &status); 114 if (err) 115 return err; 116 if (!(status & SST25L_STATUS_WREN)) 117 return -EROFS; 118 } 119 120 return 0; 121 } 122 123 static int sst25l_wait_till_ready(struct sst25l_flash *flash) 124 { 125 unsigned long deadline; 126 int status, err; 127 128 deadline = jiffies + MAX_READY_WAIT_JIFFIES; 129 do { 130 err = sst25l_status(flash, &status); 131 if (err) 132 return err; 133 if (!(status & SST25L_STATUS_BUSY)) 134 return 0; 135 136 cond_resched(); 137 } while (!time_after_eq(jiffies, deadline)); 138 139 return -ETIMEDOUT; 140 } 141 142 static int sst25l_erase_sector(struct sst25l_flash *flash, uint32_t offset) 143 { 144 unsigned char command[4]; 145 int err; 146 147 err = sst25l_write_enable(flash, 1); 148 if (err) 149 return err; 150 151 command[0] = SST25L_CMD_SECTOR_ERASE; 152 command[1] = offset >> 16; 153 command[2] = offset >> 8; 154 command[3] = offset; 155 err = spi_write(flash->spi, command, 4); 156 if (err) 157 return err; 158 159 err = sst25l_wait_till_ready(flash); 160 if (err) 161 return err; 162 163 return sst25l_write_enable(flash, 0); 164 } 165 166 static int sst25l_erase(struct mtd_info *mtd, struct erase_info *instr) 167 { 168 struct sst25l_flash *flash = to_sst25l_flash(mtd); 169 uint32_t addr, end; 170 int err; 171 172 /* Sanity checks */ 173 if ((uint32_t)instr->len % mtd->erasesize) 174 return -EINVAL; 175 176 if ((uint32_t)instr->addr % mtd->erasesize) 177 return -EINVAL; 178 179 addr = instr->addr; 180 end = addr + instr->len; 181 182 mutex_lock(&flash->lock); 183 184 err = sst25l_wait_till_ready(flash); 185 if (err) { 186 mutex_unlock(&flash->lock); 187 return err; 188 } 189 190 while (addr < end) { 191 err = sst25l_erase_sector(flash, addr); 192 if (err) { 193 mutex_unlock(&flash->lock); 194 dev_err(&flash->spi->dev, "Erase failed\n"); 195 return err; 196 } 197 198 addr += mtd->erasesize; 199 } 200 201 mutex_unlock(&flash->lock); 202 203 return 0; 204 } 205 206 static int sst25l_read(struct mtd_info *mtd, loff_t from, size_t len, 207 size_t *retlen, unsigned char *buf) 208 { 209 struct sst25l_flash *flash = to_sst25l_flash(mtd); 210 struct spi_transfer transfer[2]; 211 struct spi_message message; 212 unsigned char command[4]; 213 int ret; 214 215 spi_message_init(&message); 216 memset(&transfer, 0, sizeof(transfer)); 217 218 command[0] = SST25L_CMD_READ; 219 command[1] = from >> 16; 220 command[2] = from >> 8; 221 command[3] = from; 222 223 transfer[0].tx_buf = command; 224 transfer[0].len = sizeof(command); 225 spi_message_add_tail(&transfer[0], &message); 226 227 transfer[1].rx_buf = buf; 228 transfer[1].len = len; 229 spi_message_add_tail(&transfer[1], &message); 230 231 mutex_lock(&flash->lock); 232 233 /* Wait for previous write/erase to complete */ 234 ret = sst25l_wait_till_ready(flash); 235 if (ret) { 236 mutex_unlock(&flash->lock); 237 return ret; 238 } 239 240 spi_sync(flash->spi, &message); 241 242 if (retlen && message.actual_length > sizeof(command)) 243 *retlen += message.actual_length - sizeof(command); 244 245 mutex_unlock(&flash->lock); 246 return 0; 247 } 248 249 static int sst25l_write(struct mtd_info *mtd, loff_t to, size_t len, 250 size_t *retlen, const unsigned char *buf) 251 { 252 struct sst25l_flash *flash = to_sst25l_flash(mtd); 253 int i, j, ret, bytes, copied = 0; 254 unsigned char command[5]; 255 256 if ((uint32_t)to % mtd->writesize) 257 return -EINVAL; 258 259 mutex_lock(&flash->lock); 260 261 ret = sst25l_write_enable(flash, 1); 262 if (ret) 263 goto out; 264 265 for (i = 0; i < len; i += mtd->writesize) { 266 ret = sst25l_wait_till_ready(flash); 267 if (ret) 268 goto out; 269 270 /* Write the first byte of the page */ 271 command[0] = SST25L_CMD_AAI_PROGRAM; 272 command[1] = (to + i) >> 16; 273 command[2] = (to + i) >> 8; 274 command[3] = (to + i); 275 command[4] = buf[i]; 276 ret = spi_write(flash->spi, command, 5); 277 if (ret < 0) 278 goto out; 279 copied++; 280 281 /* 282 * Write the remaining bytes using auto address 283 * increment mode 284 */ 285 bytes = min_t(uint32_t, mtd->writesize, len - i); 286 for (j = 1; j < bytes; j++, copied++) { 287 ret = sst25l_wait_till_ready(flash); 288 if (ret) 289 goto out; 290 291 command[1] = buf[i + j]; 292 ret = spi_write(flash->spi, command, 2); 293 if (ret) 294 goto out; 295 } 296 } 297 298 out: 299 ret = sst25l_write_enable(flash, 0); 300 301 if (retlen) 302 *retlen = copied; 303 304 mutex_unlock(&flash->lock); 305 return ret; 306 } 307 308 static struct flash_info *sst25l_match_device(struct spi_device *spi) 309 { 310 struct flash_info *flash_info = NULL; 311 struct spi_message m; 312 struct spi_transfer t; 313 unsigned char cmd_resp[6]; 314 int i, err; 315 uint16_t id; 316 317 spi_message_init(&m); 318 memset(&t, 0, sizeof(struct spi_transfer)); 319 320 cmd_resp[0] = SST25L_CMD_READ_ID; 321 cmd_resp[1] = 0; 322 cmd_resp[2] = 0; 323 cmd_resp[3] = 0; 324 cmd_resp[4] = 0xff; 325 cmd_resp[5] = 0xff; 326 t.tx_buf = cmd_resp; 327 t.rx_buf = cmd_resp; 328 t.len = sizeof(cmd_resp); 329 spi_message_add_tail(&t, &m); 330 err = spi_sync(spi, &m); 331 if (err < 0) { 332 dev_err(&spi->dev, "error reading device id\n"); 333 return NULL; 334 } 335 336 id = (cmd_resp[4] << 8) | cmd_resp[5]; 337 338 for (i = 0; i < ARRAY_SIZE(sst25l_flash_info); i++) 339 if (sst25l_flash_info[i].device_id == id) 340 flash_info = &sst25l_flash_info[i]; 341 342 if (!flash_info) 343 dev_err(&spi->dev, "unknown id %.4x\n", id); 344 345 return flash_info; 346 } 347 348 static int sst25l_probe(struct spi_device *spi) 349 { 350 struct flash_info *flash_info; 351 struct sst25l_flash *flash; 352 struct flash_platform_data *data; 353 int ret; 354 355 flash_info = sst25l_match_device(spi); 356 if (!flash_info) 357 return -ENODEV; 358 359 flash = devm_kzalloc(&spi->dev, sizeof(*flash), GFP_KERNEL); 360 if (!flash) 361 return -ENOMEM; 362 363 flash->spi = spi; 364 mutex_init(&flash->lock); 365 spi_set_drvdata(spi, flash); 366 367 data = dev_get_platdata(&spi->dev); 368 if (data && data->name) 369 flash->mtd.name = data->name; 370 371 flash->mtd.dev.parent = &spi->dev; 372 flash->mtd.type = MTD_NORFLASH; 373 flash->mtd.flags = MTD_CAP_NORFLASH; 374 flash->mtd.erasesize = flash_info->erase_size; 375 flash->mtd.writesize = flash_info->page_size; 376 flash->mtd.writebufsize = flash_info->page_size; 377 flash->mtd.size = flash_info->page_size * flash_info->nr_pages; 378 flash->mtd._erase = sst25l_erase; 379 flash->mtd._read = sst25l_read; 380 flash->mtd._write = sst25l_write; 381 382 dev_info(&spi->dev, "%s (%lld KiB)\n", flash_info->name, 383 (long long)flash->mtd.size >> 10); 384 385 pr_debug("mtd .name = %s, .size = 0x%llx (%lldMiB) " 386 ".erasesize = 0x%.8x (%uKiB) .numeraseregions = %d\n", 387 flash->mtd.name, 388 (long long)flash->mtd.size, (long long)(flash->mtd.size >> 20), 389 flash->mtd.erasesize, flash->mtd.erasesize / 1024, 390 flash->mtd.numeraseregions); 391 392 393 ret = mtd_device_register(&flash->mtd, data ? data->parts : NULL, 394 data ? data->nr_parts : 0); 395 if (ret) 396 return -ENODEV; 397 398 return 0; 399 } 400 401 static int sst25l_remove(struct spi_device *spi) 402 { 403 struct sst25l_flash *flash = spi_get_drvdata(spi); 404 405 return mtd_device_unregister(&flash->mtd); 406 } 407 408 static struct spi_driver sst25l_driver = { 409 .driver = { 410 .name = "sst25l", 411 }, 412 .probe = sst25l_probe, 413 .remove = sst25l_remove, 414 }; 415 416 module_spi_driver(sst25l_driver); 417 418 MODULE_DESCRIPTION("MTD SPI driver for SST25L Flash chips"); 419 MODULE_AUTHOR("Andre Renaud <andre@bluewatersys.com>, " 420 "Ryan Mallon"); 421 MODULE_LICENSE("GPL"); 422