drivers/mtd/spi/sandbox.c

   1 /*
   2  * Simulate a SPI flash
   3  *
   4  * Copyright (c) 2011-2013 The Chromium OS Authors.
   5  * See file CREDITS for list of people who contributed to this
   6  * project.
   7  *
   8  * Licensed under the GPL-2 or later.
   9  */
  10
  11 #define LOG_CATEGORY UCLASS_SPI_FLASH
  12
  13 #include <common.h>
  14 #include <dm.h>
  15 #include <log.h>
  16 #include <malloc.h>
  17 #include <spi.h>
  18 #include <os.h>
  19
  20 #include <spi_flash.h>
  21 #include "sf_internal.h"
  22
  23 #include <asm/getopt.h>
  24 #include <asm/spi.h>
  25 #include <asm/state.h>
  26 #include <dm/device-internal.h>
  27 #include <dm/lists.h>
  28 #include <dm/uclass-internal.h>
  29
  30 /*
  31  * The different states that our SPI flash transitions between.
  32  * We need to keep track of this across multiple xfer calls since
  33  * the SPI bus could possibly call down into us multiple times.
  34  */
  35 enum sandbox_sf_state {
  36         SF_CMD,   /* default state -- we're awaiting a command */
  37         SF_ID,    /* read the flash's (jedec) ID code */
  38         SF_ADDR,  /* processing the offset in the flash to read/etc... */
  39         SF_READ,  /* reading data from the flash */
  40         SF_WRITE, /* writing data to the flash, i.e. page programming */
  41         SF_ERASE, /* erase the flash */
  42         SF_READ_STATUS, /* read the flash's status register */
  43         SF_READ_STATUS1, /* read the flash's status register upper 8 bits*/
  44         SF_WRITE_STATUS, /* write the flash's status register */
  45 };
  46
  47 static const char *sandbox_sf_state_name(enum sandbox_sf_state state)
  48 {
  49         static const char * const states[] = {
  50                 "CMD", "ID", "ADDR", "READ", "WRITE", "ERASE", "READ_STATUS",
  51                 "READ_STATUS1", "WRITE_STATUS",
  52         };
  53         return states[state];
  54 }
  55
  56 /* Bits for the status register */
  57 #define STAT_WIP        (1 << 0)
  58 #define STAT_WEL        (1 << 1)
  59 #define STAT_BP_SHIFT   2
  60 #define STAT_BP_MASK    (7 << STAT_BP_SHIFT)
  61
  62 /* Assume all SPI flashes have 3 byte addresses since they do atm */
  63 #define SF_ADDR_LEN     3
  64
  65 #define IDCODE_LEN 3
  66
  67 /* Used to quickly bulk erase backing store */
  68 static u8 sandbox_sf_0xff[0x1000];
  69
  70 /* Internal state data for each SPI flash */
  71 struct sandbox_spi_flash {
  72         unsigned int cs;        /* Chip select we are attached to */
  73         /*
  74          * As we receive data over the SPI bus, our flash transitions
  75          * between states.  For example, we start off in the SF_CMD
  76          * state where the first byte tells us what operation to perform
  77          * (such as read or write the flash).  But the operation itself
  78          * can go through a few states such as first reading in the
  79          * offset in the flash to perform the requested operation.
  80          * Thus "state" stores the exact state that our machine is in
  81          * while "cmd" stores the overall command we're processing.
  82          */
  83         enum sandbox_sf_state state;
  84         uint cmd;
  85         /* Erase size of current erase command */
  86         uint erase_size;
  87         /* Current position in the flash; used when reading/writing/etc... */
  88         uint off;
  89         /* How many address bytes we've consumed */
  90         uint addr_bytes, pad_addr_bytes;
  91         /* The current flash status (see STAT_XXX defines above) */
  92         u16 status;
  93         /* Data describing the flash we're emulating */
  94         const struct flash_info *data;
  95         /* The file on disk to serv up data from */
  96         int fd;
  97 };
  98
  99 struct sandbox_spi_flash_plat_data {
 100         const char *filename;
 101         const char *device_name;
 102         int bus;
 103         int cs;
 104 };
 105
 106 void sandbox_sf_set_block_protect(struct udevice *dev, int bp_mask)
 107 {
 108         struct sandbox_spi_flash *sbsf = dev_get_priv(dev);
 109
 110         sbsf->status &= ~STAT_BP_MASK;
 111         sbsf->status |= bp_mask << STAT_BP_SHIFT;
 112 }
 113
 114 /**
 115  * This is a very strange probe function. If it has platform data (which may
 116  * have come from the device tree) then this function gets the filename and
 117  * device type from there.
 118  */
 119 static int sandbox_sf_probe(struct udevice *dev)
 120 {
 121         /* spec = idcode:file */
 122         struct sandbox_spi_flash *sbsf = dev_get_priv(dev);
 123         size_t len, idname_len;
 124         const struct flash_info *data;
 125         struct sandbox_spi_flash_plat_data *pdata = dev_get_platdata(dev);
 126         struct sandbox_state *state = state_get_current();
 127         struct dm_spi_slave_platdata *slave_plat;
 128         struct udevice *bus = dev->parent;
 129         const char *spec = NULL;
 130         struct udevice *emul;
 131         int ret = 0;
 132         int cs = -1;
 133
 134         debug("%s: bus %d, looking for emul=%p: ", __func__, bus->seq, dev);
 135         ret = sandbox_spi_get_emul(state, bus, dev, &emul);
 136         if (ret) {
 137                 printf("Error: Unknown chip select for device '%s'\n",
 138                         dev->name);
 139                 return ret;
 140         }
 141         slave_plat = dev_get_parent_platdata(dev);
 142         cs = slave_plat->cs;
 143         debug("found at cs %d\n", cs);
 144
 145         if (!pdata->filename) {
 146                 printf("Error: No filename available\n");
 147                 return -EINVAL;
 148         }
 149         spec = strchr(pdata->device_name, ',');
 150         if (spec)
 151                 spec++;
 152         else
 153                 spec = pdata->device_name;
 154         idname_len = strlen(spec);
 155         debug("%s: device='%s'\n", __func__, spec);
 156
 157         for (data = spi_nor_ids; data->name; data++) {
 158                 len = strlen(data->name);
 159                 if (idname_len != len)
 160                         continue;
 161                 if (!strncasecmp(spec, data->name, len))
 162                         break;
 163         }
 164         if (!data->name) {
 165                 printf("%s: unknown flash '%*s'\n", __func__, (int)idname_len,
 166                        spec);
 167                 ret = -EINVAL;
 168                 goto error;
 169         }
 170
 171         if (sandbox_sf_0xff[0] == 0x00)
 172                 memset(sandbox_sf_0xff, 0xff, sizeof(sandbox_sf_0xff));
 173
 174         sbsf->fd = os_open(pdata->filename, 02);
 175         if (sbsf->fd == -1) {
 176                 printf("%s: unable to open file '%s'\n", __func__,
 177                        pdata->filename);
 178                 ret = -EIO;
 179                 goto error;
 180         }
 181
 182         sbsf->data = data;
 183         sbsf->cs = cs;
 184
 185         return 0;
 186
 187  error:
 188         debug("%s: Got error %d\n", __func__, ret);
 189         return ret;
 190 }
 191
 192 static int sandbox_sf_remove(struct udevice *dev)
 193 {
 194         struct sandbox_spi_flash *sbsf = dev_get_priv(dev);
 195
 196         os_close(sbsf->fd);
 197
 198         return 0;
 199 }
 200
 201 static void sandbox_sf_cs_activate(struct udevice *dev)
 202 {
 203         struct sandbox_spi_flash *sbsf = dev_get_priv(dev);
 204
 205         log_content("sandbox_sf: CS activated; state is fresh!\n");
 206
 207         /* CS is asserted, so reset state */
 208         sbsf->off = 0;
 209         sbsf->addr_bytes = 0;
 210         sbsf->pad_addr_bytes = 0;
 211         sbsf->state = SF_CMD;
 212         sbsf->cmd = SF_CMD;
 213 }
 214
 215 static void sandbox_sf_cs_deactivate(struct udevice *dev)
 216 {
 217         log_content("sandbox_sf: CS deactivated; cmd done processing!\n");
 218 }
 219
 220 /*
 221  * There are times when the data lines are allowed to tristate.  What
 222  * is actually sensed on the line depends on the hardware.  It could
 223  * always be 0xFF/0x00 (if there are pull ups/downs), or things could
 224  * float and so we'd get garbage back.  This func encapsulates that
 225  * scenario so we can worry about the details here.
 226  */
 227 static void sandbox_spi_tristate(u8 *buf, uint len)
 228 {
 229         /* XXX: make this into a user config option ? */
 230         memset(buf, 0xff, len);
 231 }
 232
 233 /* Figure out what command this stream is telling us to do */
 234 static int sandbox_sf_process_cmd(struct sandbox_spi_flash *sbsf, const u8 *rx,
 235                                   u8 *tx)
 236 {
 237         enum sandbox_sf_state oldstate = sbsf->state;
 238
 239         /* We need to output a byte for the cmd byte we just ate */
 240         if (tx)
 241                 sandbox_spi_tristate(tx, 1);
 242
 243         sbsf->cmd = rx[0];
 244         switch (sbsf->cmd) {
 245         case SPINOR_OP_RDID:
 246                 sbsf->state = SF_ID;
 247                 sbsf->cmd = SF_ID;
 248                 break;
 249         case SPINOR_OP_READ_FAST:
 250                 sbsf->pad_addr_bytes = 1;
 251         case SPINOR_OP_READ:
 252         case SPINOR_OP_PP:
 253                 sbsf->state = SF_ADDR;
 254                 break;
 255         case SPINOR_OP_WRDI:
 256                 debug(" write disabled\n");
 257                 sbsf->status &= ~STAT_WEL;
 258                 break;
 259         case SPINOR_OP_RDSR:
 260                 sbsf->state = SF_READ_STATUS;
 261                 break;
 262         case SPINOR_OP_RDSR2:
 263                 sbsf->state = SF_READ_STATUS1;
 264                 break;
 265         case SPINOR_OP_WREN:
 266                 debug(" write enabled\n");
 267                 sbsf->status |= STAT_WEL;
 268                 break;
 269         case SPINOR_OP_WRSR:
 270                 sbsf->state = SF_WRITE_STATUS;
 271                 break;
 272         default: {
 273                 int flags = sbsf->data->flags;
 274
 275                 /* we only support erase here */
 276                 if (sbsf->cmd == SPINOR_OP_CHIP_ERASE) {
 277                         sbsf->erase_size = sbsf->data->sector_size *
 278                                 sbsf->data->n_sectors;
 279                 } else if (sbsf->cmd == SPINOR_OP_BE_4K && (flags & SECT_4K)) {
 280                         sbsf->erase_size = 4 << 10;
 281                 } else if (sbsf->cmd == SPINOR_OP_SE && !(flags & SECT_4K)) {
 282                         sbsf->erase_size = 64 << 10;
 283                 } else {
 284                         debug(" cmd unknown: %#x\n", sbsf->cmd);
 285                         return -EIO;
 286                 }
 287                 sbsf->state = SF_ADDR;
 288                 break;
 289         }
 290         }
 291
 292         if (oldstate != sbsf->state)
 293                 log_content(" cmd: transition to %s state\n",
 294                             sandbox_sf_state_name(sbsf->state));
 295
 296         return 0;
 297 }
 298
 299 int sandbox_erase_part(struct sandbox_spi_flash *sbsf, int size)
 300 {
 301         int todo;
 302         int ret;
 303
 304         while (size > 0) {
 305                 todo = min(size, (int)sizeof(sandbox_sf_0xff));
 306                 ret = os_write(sbsf->fd, sandbox_sf_0xff, todo);
 307                 if (ret != todo)
 308                         return ret;
 309                 size -= todo;
 310         }
 311
 312         return 0;
 313 }
 314
 315 static int sandbox_sf_xfer(struct udevice *dev, unsigned int bitlen,
 316                            const void *rxp, void *txp, unsigned long flags)
 317 {
 318         struct sandbox_spi_flash *sbsf = dev_get_priv(dev);
 319         const uint8_t *rx = rxp;
 320         uint8_t *tx = txp;
 321         uint cnt, pos = 0;
 322         int bytes = bitlen / 8;
 323         int ret;
 324
 325         log_content("sandbox_sf: state:%x(%s) bytes:%u\n", sbsf->state,
 326                     sandbox_sf_state_name(sbsf->state), bytes);
 327
 328         if ((flags & SPI_XFER_BEGIN))
 329                 sandbox_sf_cs_activate(dev);
 330
 331         if (sbsf->state == SF_CMD) {
 332                 /* Figure out the initial state */
 333                 ret = sandbox_sf_process_cmd(sbsf, rx, tx);
 334                 if (ret)
 335                         return ret;
 336                 ++pos;
 337         }
 338
 339         /* Process the remaining data */
 340         while (pos < bytes) {
 341                 switch (sbsf->state) {
 342                 case SF_ID: {
 343                         u8 id;
 344
 345                         log_content(" id: off:%u tx:", sbsf->off);
 346                         if (sbsf->off < IDCODE_LEN) {
 347                                 /* Extract correct byte from ID 0x00aabbcc */
 348                                 id = ((JEDEC_MFR(sbsf->data) << 16) |
 349                                         JEDEC_ID(sbsf->data)) >>
 350                                         (8 * (IDCODE_LEN - 1 - sbsf->off));
 351                         } else {
 352                                 id = 0;
 353                         }
 354                         log_content("%d %02x\n", sbsf->off, id);
 355                         tx[pos++] = id;
 356                         ++sbsf->off;
 357                         break;
 358                 }
 359                 case SF_ADDR:
 360                         log_content(" addr: bytes:%u rx:%02x ",
 361                                     sbsf->addr_bytes, rx[pos]);
 362
 363                         if (sbsf->addr_bytes++ < SF_ADDR_LEN)
 364                                 sbsf->off = (sbsf->off << 8) | rx[pos];
 365                         log_content("addr:%06x\n", sbsf->off);
 366
 367                         if (tx)
 368                                 sandbox_spi_tristate(&tx[pos], 1);
 369                         pos++;
 370
 371                         /* See if we're done processing */
 372                         if (sbsf->addr_bytes <
 373                                         SF_ADDR_LEN + sbsf->pad_addr_bytes)
 374                                 break;
 375
 376                         /* Next state! */
 377                         if (os_lseek(sbsf->fd, sbsf->off, OS_SEEK_SET) < 0) {
 378                                 puts("sandbox_sf: os_lseek() failed");
 379                                 return -EIO;
 380                         }
 381                         switch (sbsf->cmd) {
 382                         case SPINOR_OP_READ_FAST:
 383                         case SPINOR_OP_READ:
 384                                 sbsf->state = SF_READ;
 385                                 break;
 386                         case SPINOR_OP_PP:
 387                                 sbsf->state = SF_WRITE;
 388                                 break;
 389                         default:
 390                                 /* assume erase state ... */
 391                                 sbsf->state = SF_ERASE;
 392                                 goto case_sf_erase;
 393                         }
 394                         log_content(" cmd: transition to %s state\n",
 395                                     sandbox_sf_state_name(sbsf->state));
 396                         break;
 397                 case SF_READ:
 398                         /*
 399                          * XXX: need to handle exotic behavior:
 400                          *      - reading past end of device
 401                          */
 402
 403                         cnt = bytes - pos;
 404                         log_content(" tx: read(%u)\n", cnt);
 405                         assert(tx);
 406                         ret = os_read(sbsf->fd, tx + pos, cnt);
 407                         if (ret < 0) {
 408                                 puts("sandbox_sf: os_read() failed\n");
 409                                 return -EIO;
 410                         }
 411                         pos += ret;
 412                         break;
 413                 case SF_READ_STATUS:
 414                         log_content(" read status: %#x\n", sbsf->status);
 415                         cnt = bytes - pos;
 416                         memset(tx + pos, sbsf->status, cnt);
 417                         pos += cnt;
 418                         break;
 419                 case SF_READ_STATUS1:
 420                         log_content(" read status: %#x\n", sbsf->status);
 421                         cnt = bytes - pos;
 422                         memset(tx + pos, sbsf->status >> 8, cnt);
 423                         pos += cnt;
 424                         break;
 425                 case SF_WRITE_STATUS:
 426                         log_content(" write status: %#x (ignored)\n", rx[pos]);
 427                         pos = bytes;
 428                         break;
 429                 case SF_WRITE:
 430                         /*
 431                          * XXX: need to handle exotic behavior:
 432                          *      - unaligned addresses
 433                          *      - more than a page (256) worth of data
 434                          *      - reading past end of device
 435                          */
 436                         if (!(sbsf->status & STAT_WEL)) {
 437                                 puts("sandbox_sf: write enable not set before write\n");
 438                                 goto done;
 439                         }
 440
 441                         cnt = bytes - pos;
 442                         log_content(" rx: write(%u)\n", cnt);
 443                         if (tx)
 444                                 sandbox_spi_tristate(&tx[pos], cnt);
 445                         ret = os_write(sbsf->fd, rx + pos, cnt);
 446                         if (ret < 0) {
 447                                 puts("sandbox_spi: os_write() failed\n");
 448                                 return -EIO;
 449                         }
 450                         pos += ret;
 451                         sbsf->status &= ~STAT_WEL;
 452                         break;
 453                 case SF_ERASE:
 454  case_sf_erase: {
 455                         if (!(sbsf->status & STAT_WEL)) {
 456                                 puts("sandbox_sf: write enable not set before erase\n");
 457                                 goto done;
 458                         }
 459
 460                         /* verify address is aligned */
 461                         if (sbsf->off & (sbsf->erase_size - 1)) {
 462                                 log_content(" sector erase: cmd:%#x needs align:%#x, but we got %#x\n",
 463                                             sbsf->cmd, sbsf->erase_size,
 464                                             sbsf->off);
 465                                 sbsf->status &= ~STAT_WEL;
 466                                 goto done;
 467                         }
 468
 469                         log_content(" sector erase addr: %u, size: %u\n",
 470                                     sbsf->off, sbsf->erase_size);
 471
 472                         cnt = bytes - pos;
 473                         if (tx)
 474                                 sandbox_spi_tristate(&tx[pos], cnt);
 475                         pos += cnt;
 476
 477                         /*
 478                          * TODO([email protected]): latch WIP in status, and
 479                          * delay before clearing it ?
 480                          */
 481                         ret = sandbox_erase_part(sbsf, sbsf->erase_size);
 482                         sbsf->status &= ~STAT_WEL;
 483                         if (ret) {
 484                                 log_content("sandbox_sf: Erase failed\n");
 485                                 goto done;
 486                         }
 487                         goto done;
 488                 }
 489                 default:
 490                         log_content(" ??? no idea what to do ???\n");
 491                         goto done;
 492                 }
 493         }
 494
 495  done:
 496         if (flags & SPI_XFER_END)
 497                 sandbox_sf_cs_deactivate(dev);
 498         return pos == bytes ? 0 : -EIO;
 499 }
 500
 501 int sandbox_sf_ofdata_to_platdata(struct udevice *dev)
 502 {
 503         struct sandbox_spi_flash_plat_data *pdata = dev_get_platdata(dev);
 504
 505         pdata->filename = dev_read_string(dev, "sandbox,filename");
 506         pdata->device_name = dev_read_string(dev, "compatible");
 507         if (!pdata->filename || !pdata->device_name) {
 508                 debug("%s: Missing properties, filename=%s, device_name=%s\n",
 509                       __func__, pdata->filename, pdata->device_name);
 510                 return -EINVAL;
 511         }
 512
 513         return 0;
 514 }
 515
 516 static const struct dm_spi_emul_ops sandbox_sf_emul_ops = {
 517         .xfer          = sandbox_sf_xfer,
 518 };
 519
 520 #ifdef CONFIG_SPI_FLASH
 521 int sandbox_sf_bind_emul(struct sandbox_state *state, int busnum, int cs,
 522                          struct udevice *bus, ofnode node, const char *spec)
 523 {
 524         struct udevice *emul;
 525         char name[20], *str;
 526         struct driver *drv;
 527         int ret;
 528
 529         /* now the emulator */
 530         strncpy(name, spec, sizeof(name) - 6);
 531         name[sizeof(name) - 6] = '\0';
 532         strcat(name, "-emul");
 533         drv = lists_driver_lookup_name("sandbox_sf_emul");
 534         if (!drv) {
 535                 puts("Cannot find sandbox_sf_emul driver\n");
 536                 return -ENOENT;
 537         }
 538         str = strdup(name);
 539         if (!str)
 540                 return -ENOMEM;
 541         ret = device_bind(bus, drv, str, NULL, node, &emul);
 542         if (ret) {
 543                 free(str);
 544                 printf("Cannot create emul device for spec '%s' (err=%d)\n",
 545                        spec, ret);
 546                 return ret;
 547         }
 548         state->spi[busnum][cs].emul = emul;
 549
 550         return 0;
 551 }
 552
 553 void sandbox_sf_unbind_emul(struct sandbox_state *state, int busnum, int cs)
 554 {
 555         struct udevice *dev;
 556
 557         dev = state->spi[busnum][cs].emul;
 558         device_remove(dev, DM_REMOVE_NORMAL);
 559         device_unbind(dev);
 560         state->spi[busnum][cs].emul = NULL;
 561 }
 562
 563 int sandbox_spi_get_emul(struct sandbox_state *state,
 564                          struct udevice *bus, struct udevice *slave,
 565                          struct udevice **emulp)
 566 {
 567         struct sandbox_spi_info *info;
 568         int busnum = bus->seq;
 569         int cs = spi_chip_select(slave);
 570         int ret;
 571
 572         info = &state->spi[busnum][cs];
 573         if (!info->emul) {
 574                 /* Use the same device tree node as the SPI flash device */
 575                 debug("%s: busnum=%u, cs=%u: binding SPI flash emulation: ",
 576                       __func__, busnum, cs);
 577                 ret = sandbox_sf_bind_emul(state, busnum, cs, bus,
 578                                            dev_ofnode(slave), slave->name);
 579                 if (ret) {
 580                         debug("failed (err=%d)\n", ret);
 581                         return ret;
 582                 }
 583                 debug("OK\n");
 584         }
 585         *emulp = info->emul;
 586
 587         return 0;
 588 }
 589 #endif
 590
 591 static const struct udevice_id sandbox_sf_ids[] = {
 592         { .compatible = "sandbox,spi-flash" },
 593         { }
 594 };
 595
 596 U_BOOT_DRIVER(sandbox_sf_emul) = {
 597         .name           = "sandbox_sf_emul",
 598         .id             = UCLASS_SPI_EMUL,
 599         .of_match       = sandbox_sf_ids,
 600         .ofdata_to_platdata = sandbox_sf_ofdata_to_platdata,
 601         .probe          = sandbox_sf_probe,
 602         .remove         = sandbox_sf_remove,
 603         .priv_auto      = sizeof(struct sandbox_spi_flash),
 604         .platdata_auto  = sizeof(struct sandbox_spi_flash_plat_data),
 605         .ops            = &sandbox_sf_emul_ops,
 606 };