drivers/mtd/spi/ramtron.c

   1 /*
   2  * (C) Copyright 2010
   3  * Reinhard Meyer, EMK Elektronik, reinhard.meyer@emk-elektronik.de
   4  *
   5  * SPDX-License-Identifier:     GPL-2.0+
   6  */
   7
   8 /*
   9  * Note: RAMTRON SPI FRAMs are ferroelectric, nonvolatile RAMs
  10  * with an interface identical to SPI flash devices.
  11  * However since they behave like RAM there are no delays or
  12  * busy polls required. They can sustain read or write at the
  13  * allowed SPI bus speed, which can be 40 MHz for some devices.
  14  *
  15  * Unfortunately some RAMTRON devices do not have a means of
  16  * identifying them. They will leave the SO line undriven when
  17  * the READ-ID command is issued. It is therefore mandatory
  18  * that the MISO line has a proper pull-up, so that READ-ID
  19  * will return a row of 0xff. This 0xff pseudo-id will cause
  20  * probes by all vendor specific functions that are designed
  21  * to handle it. If the MISO line is not pulled up, READ-ID
  22  * could return any random noise, even mimicking another
  23  * device.
  24  *
  25  * We use CONFIG_SPI_FRAM_RAMTRON_NON_JEDEC
  26  * to define which device will be assumed after a simple status
  27  * register verify. This method is prone to false positive
  28  * detection and should therefore be the last to be tried.
  29  * Enter it in the last position in the table in spi_flash.c!
  30  *
  31  * The define CONFIG_SPI_FRAM_RAMTRON_NON_JEDEC both activates
  32  * compilation of the special handler and defines the device
  33  * to assume.
  34  */
  35
  36 #include <common.h>
  37 #include <malloc.h>
  38 #include <spi_flash.h>
  39 #include "sf_internal.h"
  40
  41 /*
  42  * Properties of supported FRAMs
  43  * Note: speed is currently not used because we have no method to deliver that
  44  * value to the upper layers
  45  */
  46 struct ramtron_spi_fram_params {
  47         u32     size;           /* size in bytes */
  48         u8      addr_len;       /* number of address bytes */
  49         u8      merge_cmd;      /* some address bits are in the command byte */
  50         u8      id1;            /* device ID 1 (family, density) */
  51         u8      id2;            /* device ID 2 (sub, rev, rsvd) */
  52         u32     speed;          /* max. SPI clock in Hz */
  53         const char *name;       /* name for display and/or matching */
  54 };
  55
  56 struct ramtron_spi_fram {
  57         struct spi_flash flash;
  58         const struct ramtron_spi_fram_params *params;
  59 };
  60
  61 static inline struct ramtron_spi_fram *to_ramtron_spi_fram(struct spi_flash
  62                                                              *flash)
  63 {
  64         return container_of(flash, struct ramtron_spi_fram, flash);
  65 }
  66
  67 /*
  68  * table describing supported FRAM chips:
  69  * chips without RDID command must have the values 0xff for id1 and id2
  70  */
  71 static const struct ramtron_spi_fram_params ramtron_spi_fram_table[] = {
  72         {
  73                 .size = 32*1024,
  74                 .addr_len = 2,
  75                 .merge_cmd = 0,
  76                 .id1 = 0x22,
  77                 .id2 = 0x00,
  78                 .speed = 40000000,
  79                 .name = "FM25V02",
  80         },
  81         {
  82                 .size = 32*1024,
  83                 .addr_len = 2,
  84                 .merge_cmd = 0,
  85                 .id1 = 0x22,
  86                 .id2 = 0x01,
  87                 .speed = 40000000,
  88                 .name = "FM25VN02",
  89         },
  90         {
  91                 .size = 64*1024,
  92                 .addr_len = 2,
  93                 .merge_cmd = 0,
  94                 .id1 = 0x23,
  95                 .id2 = 0x00,
  96                 .speed = 40000000,
  97                 .name = "FM25V05",
  98         },
  99         {
 100                 .size = 64*1024,
 101                 .addr_len = 2,
 102                 .merge_cmd = 0,
 103                 .id1 = 0x23,
 104                 .id2 = 0x01,
 105                 .speed = 40000000,
 106                 .name = "FM25VN05",
 107         },
 108         {
 109                 .size = 128*1024,
 110                 .addr_len = 3,
 111                 .merge_cmd = 0,
 112                 .id1 = 0x24,
 113                 .id2 = 0x00,
 114                 .speed = 40000000,
 115                 .name = "FM25V10",
 116         },
 117         {
 118                 .size = 128*1024,
 119                 .addr_len = 3,
 120                 .merge_cmd = 0,
 121                 .id1 = 0x24,
 122                 .id2 = 0x01,
 123                 .speed = 40000000,
 124                 .name = "FM25VN10",
 125         },
 126 #ifdef CONFIG_SPI_FRAM_RAMTRON_NON_JEDEC
 127         {
 128                 .size = 256*1024,
 129                 .addr_len = 3,
 130                 .merge_cmd = 0,
 131                 .id1 = 0xff,
 132                 .id2 = 0xff,
 133                 .speed = 40000000,
 134                 .name = "FM25H20",
 135         },
 136 #endif
 137 };
 138
 139 static int ramtron_common(struct spi_flash *flash,
 140                 u32 offset, size_t len, void *buf, u8 command)
 141 {
 142         struct ramtron_spi_fram *sn = to_ramtron_spi_fram(flash);
 143         u8 cmd[4];
 144         int cmd_len;
 145         int ret;
 146
 147         if (sn->params->addr_len == 3 && sn->params->merge_cmd == 0) {
 148                 cmd[0] = command;
 149                 cmd[1] = offset >> 16;
 150                 cmd[2] = offset >> 8;
 151                 cmd[3] = offset;
 152                 cmd_len = 4;
 153         } else if (sn->params->addr_len == 2 && sn->params->merge_cmd == 0) {
 154                 cmd[0] = command;
 155                 cmd[1] = offset >> 8;
 156                 cmd[2] = offset;
 157                 cmd_len = 3;
 158         } else {
 159                 printf("SF: unsupported addr_len or merge_cmd\n");
 160                 return -1;
 161         }
 162
 163         /* claim the bus */
 164         ret = spi_claim_bus(flash->spi);
 165         if (ret) {
 166                 debug("SF: Unable to claim SPI bus\n");
 167                 return ret;
 168         }
 169
 170         if (command == CMD_PAGE_PROGRAM) {
 171                 /* send WREN */
 172                 ret = spi_flash_cmd_write_enable(flash);
 173                 if (ret < 0) {
 174                         debug("SF: Enabling Write failed\n");
 175                         goto releasebus;
 176                 }
 177         }
 178
 179         /* do the transaction */
 180         if (command == CMD_PAGE_PROGRAM)
 181                 ret = spi_flash_cmd_write(flash->spi, cmd, cmd_len, buf, len);
 182         else
 183                 ret = spi_flash_cmd_read(flash->spi, cmd, cmd_len, buf, len);
 184         if (ret < 0)
 185                 debug("SF: Transaction failed\n");
 186
 187 releasebus:
 188         /* release the bus */
 189         spi_release_bus(flash->spi);
 190         return ret;
 191 }
 192
 193 static int ramtron_read(struct spi_flash *flash,
 194                 u32 offset, size_t len, void *buf)
 195 {
 196         return ramtron_common(flash, offset, len, buf,
 197                 CMD_READ_ARRAY_SLOW);
 198 }
 199
 200 static int ramtron_write(struct spi_flash *flash,
 201                 u32 offset, size_t len, const void *buf)
 202 {
 203         return ramtron_common(flash, offset, len, (void *)buf,
 204                 CMD_PAGE_PROGRAM);
 205 }
 206
 207 static int ramtron_erase(struct spi_flash *flash, u32 offset, size_t len)
 208 {
 209         debug("SF: Erase of RAMTRON FRAMs is pointless\n");
 210         return -1;
 211 }
 212
 213 /*
 214  * nore: we are called here with idcode pointing to the first non-0x7f byte
 215  * already!
 216  */
 217 static struct spi_flash *spi_fram_probe_ramtron(struct spi_slave *spi,
 218                 u8 *idcode)
 219 {
 220         const struct ramtron_spi_fram_params *params;
 221         struct ramtron_spi_fram *sn;
 222         unsigned int i;
 223 #ifdef CONFIG_SPI_FRAM_RAMTRON_NON_JEDEC
 224         int ret;
 225         u8 sr;
 226 #endif
 227
 228         /* NOTE: the bus has been claimed before this function is called! */
 229         switch (idcode[0]) {
 230         case 0xc2:
 231                 /* JEDEC conformant RAMTRON id */
 232                 for (i = 0; i < ARRAY_SIZE(ramtron_spi_fram_table); i++) {
 233                         params = &ramtron_spi_fram_table[i];
 234                         if (idcode[1] == params->id1 &&
 235                             idcode[2] == params->id2)
 236                                 goto found;
 237                 }
 238                 break;
 239 #ifdef CONFIG_SPI_FRAM_RAMTRON_NON_JEDEC
 240         case 0xff:
 241                 /*
 242                  * probably open MISO line, pulled up.
 243                  * We COULD have a non JEDEC conformant FRAM here,
 244                  * read the status register to verify
 245                  */
 246                 ret = spi_flash_cmd(spi, CMD_READ_STATUS, &sr, 1);
 247                 if (ret)
 248                         return NULL;
 249
 250                 /* Bits 5,4,0 are fixed 0 for all devices */
 251                 if ((sr & 0x31) != 0x00)
 252                         return NULL;
 253                 /* now find the device */
 254                 for (i = 0; i < ARRAY_SIZE(ramtron_spi_fram_table); i++) {
 255                         params = &ramtron_spi_fram_table[i];
 256                         if (!strcmp(params->name,
 257                                     CONFIG_SPI_FRAM_RAMTRON_NON_JEDEC))
 258                                 goto found;
 259                 }
 260                 debug("SF: Unsupported non-JEDEC RAMTRON device "
 261                         CONFIG_SPI_FRAM_RAMTRON_NON_JEDEC "\n");
 262                 break;
 263 #endif
 264         default:
 265                 break;
 266         }
 267
 268         /* arriving here means no method has found a device we can handle */
 269         debug("SF/ramtron: unsupported device id0=%02x id1=%02x id2=%02x\n",
 270               idcode[0], idcode[1], idcode[2]);
 271         return NULL;
 272
 273 found:
 274         sn = malloc(sizeof(*sn));
 275         if (!sn) {
 276                 debug("SF: Failed to allocate memory\n");
 277                 return NULL;
 278         }
 279
 280         sn->params = params;
 281
 282         sn->flash.write = ramtron_write;
 283         sn->flash.read = ramtron_read;
 284         sn->flash.erase = ramtron_erase;
 285         sn->flash.size = params->size;
 286
 287         return &sn->flash;
 288 }
 289
 290 /*
 291  * The following table holds all device probe functions
 292  * (All flashes are removed and implemented a common probe at
 293  *  spi_flash_probe.c)
 294  *
 295  * shift:  number of continuation bytes before the ID
 296  * idcode: the expected IDCODE or 0xff for non JEDEC devices
 297  * probe:  the function to call
 298  *
 299  * Non JEDEC devices should be ordered in the table such that
 300  * the probe functions with best detection algorithms come first.
 301  *
 302  * Several matching entries are permitted, they will be tried
 303  * in sequence until a probe function returns non NULL.
 304  *
 305  * IDCODE_CONT_LEN may be redefined if a device needs to declare a
 306  * larger "shift" value.  IDCODE_PART_LEN generally shouldn't be
 307  * changed.  This is the max number of bytes probe functions may
 308  * examine when looking up part-specific identification info.
 309  *
 310  * Probe functions will be given the idcode buffer starting at their
 311  * manu id byte (the "idcode" in the table below).  In other words,
 312  * all of the continuation bytes will be skipped (the "shift" below).
 313  */
 314 #define IDCODE_CONT_LEN 0
 315 #define IDCODE_PART_LEN 5
 316 static const struct {
 317         const u8 shift;
 318         const u8 idcode;
 319         struct spi_flash *(*probe) (struct spi_slave *spi, u8 *idcode);
 320 } flashes[] = {
 321         /* Keep it sorted by define name */
 322 #ifdef CONFIG_SPI_FRAM_RAMTRON
 323         { 6, 0xc2, spi_fram_probe_ramtron, },
 324 # undef IDCODE_CONT_LEN
 325 # define IDCODE_CONT_LEN 6
 326 #endif
 327 #ifdef CONFIG_SPI_FRAM_RAMTRON_NON_JEDEC
 328         { 0, 0xff, spi_fram_probe_ramtron, },
 329 #endif
 330 };
 331 #define IDCODE_LEN (IDCODE_CONT_LEN + IDCODE_PART_LEN)
 332
 333 struct spi_flash *spi_flash_probe(unsigned int bus, unsigned int cs,
 334                 unsigned int max_hz, unsigned int spi_mode)
 335 {
 336         struct spi_slave *spi;
 337         struct spi_flash *flash = NULL;
 338         int ret, i, shift;
 339         u8 idcode[IDCODE_LEN], *idp;
 340
 341         spi = spi_setup_slave(bus, cs, max_hz, spi_mode);
 342         if (!spi) {
 343                 printf("SF: Failed to set up slave\n");
 344                 return NULL;
 345         }
 346
 347         ret = spi_claim_bus(spi);
 348         if (ret) {
 349                 debug("SF: Failed to claim SPI bus: %d\n", ret);
 350                 goto err_claim_bus;
 351         }
 352
 353         /* Read the ID codes */
 354         ret = spi_flash_cmd(spi, CMD_READ_ID, idcode, sizeof(idcode));
 355         if (ret)
 356                 goto err_read_id;
 357
 358 #ifdef DEBUG
 359         printf("SF: Got idcodes\n");
 360         print_buffer(0, idcode, 1, sizeof(idcode), 0);
 361 #endif
 362
 363         /* count the number of continuation bytes */
 364         for (shift = 0, idp = idcode;
 365              shift < IDCODE_CONT_LEN && *idp == 0x7f;
 366              ++shift, ++idp)
 367                 continue;
 368
 369         /* search the table for matches in shift and id */
 370         for (i = 0; i < ARRAY_SIZE(flashes); ++i)
 371                 if (flashes[i].shift == shift && flashes[i].idcode == *idp) {
 372                         /* we have a match, call probe */
 373                         flash = flashes[i].probe(spi, idp);
 374                         if (flash)
 375                                 break;
 376                 }
 377
 378         if (!flash) {
 379                 printf("SF: Unsupported manufacturer %02x\n", *idp);
 380                 goto err_manufacturer_probe;
 381         }
 382
 383         printf("SF: Detected %s with total size ", flash->name);
 384         print_size(flash->size, "");
 385         puts("\n");
 386
 387         spi_release_bus(spi);
 388
 389         return flash;
 390
 391 err_manufacturer_probe:
 392 err_read_id:
 393         spi_release_bus(spi);
 394 err_claim_bus:
 395         spi_free_slave(spi);
 396         return NULL;
 397 }
 398
 399 void spi_flash_free(struct spi_flash *flash)
 400 {
 401         spi_free_slave(flash->spi);
 402         free(flash);
 403 }