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