1/* 2 * sst25l.c 3 * 4 * Driver for SST25L SPI Flash chips 5 * 6 * Copyright �� 2009 Bluewater Systems Ltd 7 * Author: Andre Renaud <andre@bluewatersys.com> 8 * Author: Ryan Mallon <ryan@bluewatersys.com> 9 * 10 * Based on m25p80.c 11 * 12 * This code is free software; you can redistribute it and/or modify 13 * it under the terms of the GNU General Public License version 2 as 14 * published by the Free Software Foundation. 15 * 16 */ 17 18#include <linux/init.h> 19#include <linux/module.h> 20#include <linux/device.h> 21#include <linux/mutex.h> 22#include <linux/interrupt.h> 23#include <linux/slab.h> 24#include <linux/sched.h> 25 26#include <linux/mtd/mtd.h> 27#include <linux/mtd/partitions.h> 28 29#include <linux/spi/spi.h> 30#include <linux/spi/flash.h> 31 32/* Erases can take up to 3 seconds! */ 33#define MAX_READY_WAIT_JIFFIES msecs_to_jiffies(3000) 34 35#define SST25L_CMD_WRSR 0x01 /* Write status register */ 36#define SST25L_CMD_WRDI 0x04 /* Write disable */ 37#define SST25L_CMD_RDSR 0x05 /* Read status register */ 38#define SST25L_CMD_WREN 0x06 /* Write enable */ 39#define SST25L_CMD_READ 0x03 /* High speed read */ 40 41#define SST25L_CMD_EWSR 0x50 /* Enable write status register */ 42#define SST25L_CMD_SECTOR_ERASE 0x20 /* Erase sector */ 43#define SST25L_CMD_READ_ID 0x90 /* Read device ID */ 44#define SST25L_CMD_AAI_PROGRAM 0xaf /* Auto address increment */ 45 46#define SST25L_STATUS_BUSY (1 << 0) /* Chip is busy */ 47#define SST25L_STATUS_WREN (1 << 1) /* Write enabled */ 48#define SST25L_STATUS_BP0 (1 << 2) /* Block protection 0 */ 49#define SST25L_STATUS_BP1 (1 << 3) /* Block protection 1 */ 50 51struct sst25l_flash { 52 struct spi_device *spi; 53 struct mutex lock; 54 struct mtd_info mtd; 55 56 int partitioned; 57}; 58 59struct flash_info { 60 const char *name; 61 uint16_t device_id; 62 unsigned page_size; 63 unsigned nr_pages; 64 unsigned erase_size; 65}; 66 67#define to_sst25l_flash(x) container_of(x, struct sst25l_flash, mtd) 68 69static struct flash_info __initdata sst25l_flash_info[] = { 70 {"sst25lf020a", 0xbf43, 256, 1024, 4096}, 71 {"sst25lf040a", 0xbf44, 256, 2048, 4096}, 72}; 73 74static int sst25l_status(struct sst25l_flash *flash, int *status) 75{ 76 struct spi_message m; 77 struct spi_transfer t; 78 unsigned char cmd_resp[2]; 79 int err; 80 81 spi_message_init(&m); 82 memset(&t, 0, sizeof(struct spi_transfer)); 83 84 cmd_resp[0] = SST25L_CMD_RDSR; 85 cmd_resp[1] = 0xff; 86 t.tx_buf = cmd_resp; 87 t.rx_buf = cmd_resp; 88 t.len = sizeof(cmd_resp); 89 spi_message_add_tail(&t, &m); 90 err = spi_sync(flash->spi, &m); 91 if (err < 0) 92 return err; 93 94 *status = cmd_resp[1]; 95 return 0; 96} 97 98static int sst25l_write_enable(struct sst25l_flash *flash, int enable) 99{ 100 unsigned char command[2]; 101 int status, err; 102 103 command[0] = enable ? SST25L_CMD_WREN : SST25L_CMD_WRDI; 104 err = spi_write(flash->spi, command, 1); 105 if (err) 106 return err; 107 108 command[0] = SST25L_CMD_EWSR; 109 err = spi_write(flash->spi, command, 1); 110 if (err) 111 return err; 112 113 command[0] = SST25L_CMD_WRSR; 114 command[1] = enable ? 0 : SST25L_STATUS_BP0 | SST25L_STATUS_BP1; 115 err = spi_write(flash->spi, command, 2); 116 if (err) 117 return err; 118 119 if (enable) { 120 err = sst25l_status(flash, &status); 121 if (err) 122 return err; 123 if (!(status & SST25L_STATUS_WREN)) 124 return -EROFS; 125 } 126 127 return 0; 128} 129 130static int sst25l_wait_till_ready(struct sst25l_flash *flash) 131{ 132 unsigned long deadline; 133 int status, err; 134 135 deadline = jiffies + MAX_READY_WAIT_JIFFIES; 136 do { 137 err = sst25l_status(flash, &status); 138 if (err) 139 return err; 140 if (!(status & SST25L_STATUS_BUSY)) 141 return 0; 142 143 cond_resched(); 144 } while (!time_after_eq(jiffies, deadline)); 145 146 return -ETIMEDOUT; 147} 148 149static int sst25l_erase_sector(struct sst25l_flash *flash, uint32_t offset) 150{ 151 unsigned char command[4]; 152 int err; 153 154 err = sst25l_write_enable(flash, 1); 155 if (err) 156 return err; 157 158 command[0] = SST25L_CMD_SECTOR_ERASE; 159 command[1] = offset >> 16; 160 command[2] = offset >> 8; 161 command[3] = offset; 162 err = spi_write(flash->spi, command, 4); 163 if (err) 164 return err; 165 166 err = sst25l_wait_till_ready(flash); 167 if (err) 168 return err; 169 170 return sst25l_write_enable(flash, 0); 171} 172 173static int sst25l_erase(struct mtd_info *mtd, struct erase_info *instr) 174{ 175 struct sst25l_flash *flash = to_sst25l_flash(mtd); 176 uint32_t addr, end; 177 int err; 178 179 /* Sanity checks */ 180 if (instr->addr + instr->len > flash->mtd.size) 181 return -EINVAL; 182 183 if ((uint32_t)instr->len % mtd->erasesize) 184 return -EINVAL; 185 186 if ((uint32_t)instr->addr % mtd->erasesize) 187 return -EINVAL; 188 189 addr = instr->addr; 190 end = addr + instr->len; 191 192 mutex_lock(&flash->lock); 193 194 err = sst25l_wait_till_ready(flash); 195 if (err) { 196 mutex_unlock(&flash->lock); 197 return err; 198 } 199 200 while (addr < end) { 201 err = sst25l_erase_sector(flash, addr); 202 if (err) { 203 mutex_unlock(&flash->lock); 204 instr->state = MTD_ERASE_FAILED; 205 dev_err(&flash->spi->dev, "Erase failed\n"); 206 return err; 207 } 208 209 addr += mtd->erasesize; 210 } 211 212 mutex_unlock(&flash->lock); 213 214 instr->state = MTD_ERASE_DONE; 215 mtd_erase_callback(instr); 216 return 0; 217} 218 219static int sst25l_read(struct mtd_info *mtd, loff_t from, size_t len, 220 size_t *retlen, unsigned char *buf) 221{ 222 struct sst25l_flash *flash = to_sst25l_flash(mtd); 223 struct spi_transfer transfer[2]; 224 struct spi_message message; 225 unsigned char command[4]; 226 int ret; 227 228 /* Sanity checking */ 229 if (len == 0) 230 return 0; 231 232 if (from + len > flash->mtd.size) 233 return -EINVAL; 234 235 if (retlen) 236 *retlen = 0; 237 238 spi_message_init(&message); 239 memset(&transfer, 0, sizeof(transfer)); 240 241 command[0] = SST25L_CMD_READ; 242 command[1] = from >> 16; 243 command[2] = from >> 8; 244 command[3] = from; 245 246 transfer[0].tx_buf = command; 247 transfer[0].len = sizeof(command); 248 spi_message_add_tail(&transfer[0], &message); 249 250 transfer[1].rx_buf = buf; 251 transfer[1].len = len; 252 spi_message_add_tail(&transfer[1], &message); 253 254 mutex_lock(&flash->lock); 255 256 /* Wait for previous write/erase to complete */ 257 ret = sst25l_wait_till_ready(flash); 258 if (ret) { 259 mutex_unlock(&flash->lock); 260 return ret; 261 } 262 263 spi_sync(flash->spi, &message); 264 265 if (retlen && message.actual_length > sizeof(command)) 266 *retlen += message.actual_length - sizeof(command); 267 268 mutex_unlock(&flash->lock); 269 return 0; 270} 271 272static int sst25l_write(struct mtd_info *mtd, loff_t to, size_t len, 273 size_t *retlen, const unsigned char *buf) 274{ 275 struct sst25l_flash *flash = to_sst25l_flash(mtd); 276 int i, j, ret, bytes, copied = 0; 277 unsigned char command[5]; 278 279 /* Sanity checks */ 280 if (!len) 281 return 0; 282 283 if (to + len > flash->mtd.size) 284 return -EINVAL; 285 286 if ((uint32_t)to % mtd->writesize) 287 return -EINVAL; 288 289 mutex_lock(&flash->lock); 290 291 ret = sst25l_write_enable(flash, 1); 292 if (ret) 293 goto out; 294 295 for (i = 0; i < len; i += mtd->writesize) { 296 ret = sst25l_wait_till_ready(flash); 297 if (ret) 298 goto out; 299 300 /* Write the first byte of the page */ 301 command[0] = SST25L_CMD_AAI_PROGRAM; 302 command[1] = (to + i) >> 16; 303 command[2] = (to + i) >> 8; 304 command[3] = (to + i); 305 command[4] = buf[i]; 306 ret = spi_write(flash->spi, command, 5); 307 if (ret < 0) 308 goto out; 309 copied++; 310 311 /* 312 * Write the remaining bytes using auto address 313 * increment mode 314 */ 315 bytes = min_t(uint32_t, mtd->writesize, len - i); 316 for (j = 1; j < bytes; j++, copied++) { 317 ret = sst25l_wait_till_ready(flash); 318 if (ret) 319 goto out; 320 321 command[1] = buf[i + j]; 322 ret = spi_write(flash->spi, command, 2); 323 if (ret) 324 goto out; 325 } 326 } 327 328out: 329 ret = sst25l_write_enable(flash, 0); 330 331 if (retlen) 332 *retlen = copied; 333 334 mutex_unlock(&flash->lock); 335 return ret; 336} 337 338static struct flash_info *__init sst25l_match_device(struct spi_device *spi) 339{ 340 struct flash_info *flash_info = NULL; 341 struct spi_message m; 342 struct spi_transfer t; 343 unsigned char cmd_resp[6]; 344 int i, err; 345 uint16_t id; 346 347 spi_message_init(&m); 348 memset(&t, 0, sizeof(struct spi_transfer)); 349 350 cmd_resp[0] = SST25L_CMD_READ_ID; 351 cmd_resp[1] = 0; 352 cmd_resp[2] = 0; 353 cmd_resp[3] = 0; 354 cmd_resp[4] = 0xff; 355 cmd_resp[5] = 0xff; 356 t.tx_buf = cmd_resp; 357 t.rx_buf = cmd_resp; 358 t.len = sizeof(cmd_resp); 359 spi_message_add_tail(&t, &m); 360 err = spi_sync(spi, &m); 361 if (err < 0) { 362 dev_err(&spi->dev, "error reading device id\n"); 363 return NULL; 364 } 365 366 id = (cmd_resp[4] << 8) | cmd_resp[5]; 367 368 for (i = 0; i < ARRAY_SIZE(sst25l_flash_info); i++) 369 if (sst25l_flash_info[i].device_id == id) 370 flash_info = &sst25l_flash_info[i]; 371 372 if (!flash_info) 373 dev_err(&spi->dev, "unknown id %.4x\n", id); 374 375 return flash_info; 376} 377 378static int __init sst25l_probe(struct spi_device *spi) 379{ 380 struct flash_info *flash_info; 381 struct sst25l_flash *flash; 382 struct flash_platform_data *data; 383 int ret, i; 384 385 flash_info = sst25l_match_device(spi); 386 if (!flash_info) 387 return -ENODEV; 388 389 flash = kzalloc(sizeof(struct sst25l_flash), GFP_KERNEL); 390 if (!flash) 391 return -ENOMEM; 392 393 flash->spi = spi; 394 mutex_init(&flash->lock); 395 dev_set_drvdata(&spi->dev, flash); 396 397 data = spi->dev.platform_data; 398 if (data && data->name) 399 flash->mtd.name = data->name; 400 else 401 flash->mtd.name = dev_name(&spi->dev); 402 403 flash->mtd.type = MTD_NORFLASH; 404 flash->mtd.flags = MTD_CAP_NORFLASH; 405 flash->mtd.erasesize = flash_info->erase_size; 406 flash->mtd.writesize = flash_info->page_size; 407 flash->mtd.size = flash_info->page_size * flash_info->nr_pages; 408 flash->mtd.erase = sst25l_erase; 409 flash->mtd.read = sst25l_read; 410 flash->mtd.write = sst25l_write; 411 412 dev_info(&spi->dev, "%s (%lld KiB)\n", flash_info->name, 413 (long long)flash->mtd.size >> 10); 414 415 DEBUG(MTD_DEBUG_LEVEL2, 416 "mtd .name = %s, .size = 0x%llx (%lldMiB) " 417 ".erasesize = 0x%.8x (%uKiB) .numeraseregions = %d\n", 418 flash->mtd.name, 419 (long long)flash->mtd.size, (long long)(flash->mtd.size >> 20), 420 flash->mtd.erasesize, flash->mtd.erasesize / 1024, 421 flash->mtd.numeraseregions); 422 423 if (mtd_has_partitions()) { 424 struct mtd_partition *parts = NULL; 425 int nr_parts = 0; 426 427 if (mtd_has_cmdlinepart()) { 428 static const char *part_probes[] = 429 {"cmdlinepart", NULL}; 430 431 nr_parts = parse_mtd_partitions(&flash->mtd, 432 part_probes, 433 &parts, 0); 434 } 435 436 if (nr_parts <= 0 && data && data->parts) { 437 parts = data->parts; 438 nr_parts = data->nr_parts; 439 } 440 441 if (nr_parts > 0) { 442 for (i = 0; i < nr_parts; i++) { 443 DEBUG(MTD_DEBUG_LEVEL2, "partitions[%d] = " 444 "{.name = %s, .offset = 0x%llx, " 445 ".size = 0x%llx (%lldKiB) }\n", 446 i, parts[i].name, 447 (long long)parts[i].offset, 448 (long long)parts[i].size, 449 (long long)(parts[i].size >> 10)); 450 } 451 452 flash->partitioned = 1; 453 return add_mtd_partitions(&flash->mtd, 454 parts, nr_parts); 455 } 456 457 } else if (data && data->nr_parts) { 458 dev_warn(&spi->dev, "ignoring %d default partitions on %s\n", 459 data->nr_parts, data->name); 460 } 461 462 ret = add_mtd_device(&flash->mtd); 463 if (ret == 1) { 464 kfree(flash); 465 dev_set_drvdata(&spi->dev, NULL); 466 return -ENODEV; 467 } 468 469 return 0; 470} 471 472static int __exit sst25l_remove(struct spi_device *spi) 473{ 474 struct sst25l_flash *flash = dev_get_drvdata(&spi->dev); 475 int ret; 476 477 if (mtd_has_partitions() && flash->partitioned) 478 ret = del_mtd_partitions(&flash->mtd); 479 else 480 ret = del_mtd_device(&flash->mtd); 481 if (ret == 0) 482 kfree(flash); 483 return ret; 484} 485 486static struct spi_driver sst25l_driver = { 487 .driver = { 488 .name = "sst25l", 489 .bus = &spi_bus_type, 490 .owner = THIS_MODULE, 491 }, 492 .probe = sst25l_probe, 493 .remove = __exit_p(sst25l_remove), 494}; 495 496static int __init sst25l_init(void) 497{ 498 return spi_register_driver(&sst25l_driver); 499} 500 501static void __exit sst25l_exit(void) 502{ 503 spi_unregister_driver(&sst25l_driver); 504} 505 506module_init(sst25l_init); 507module_exit(sst25l_exit); 508 509MODULE_DESCRIPTION("MTD SPI driver for SST25L Flash chips"); 510MODULE_AUTHOR("Andre Renaud <andre@bluewatersys.com>, " 511 "Ryan Mallon <ryan@bluewatersys.com>"); 512MODULE_LICENSE("GPL"); 513