LCOV - code coverage report
Current view: top level - libflash/test - test-flash.c (source / functions) Hit Total Coverage
Test: skiboot.info Lines: 173 260 66.5 %
Date: 2024-01-02 21:04:04 Functions: 11 11 100.0 %
Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
       2                 :            : /* Copyright 2013-2017 IBM Corp. */
       3                 :            : 
       4                 :            : #include <stdio.h>
       5                 :            : #include <stdlib.h>
       6                 :            : #include <stdint.h>
       7                 :            : #include <string.h>
       8                 :            : 
       9                 :            : #include <libflash/libflash.h>
      10                 :            : #include <libflash/libflash-priv.h>
      11                 :            : 
      12                 :            : #include "../libflash.c"
      13                 :            : #include "../ecc.c"
      14                 :            : 
      15                 :            : #define __unused                __attribute__((unused))
      16                 :            : 
      17                 :            : #define ERR(fmt...) fprintf(stderr, fmt)
      18                 :            : 
      19                 :            : /* Flash commands */
      20                 :            : #define CMD_PP          0x02
      21                 :            : #define CMD_READ        0x03
      22                 :            : #define CMD_WRDI        0x04
      23                 :            : #define CMD_RDSR        0x05
      24                 :            : #define CMD_WREN        0x06
      25                 :            : #define CMD_SE          0x20
      26                 :            : #define CMD_RDSCUR      0x2b
      27                 :            : #define CMD_BE32K       0x52
      28                 :            : #define CMD_CE          0x60
      29                 :            : #define CMD_RDID        0x9f
      30                 :            : #define CMD_EN4B        0xb7
      31                 :            : #define CMD_BE          0xd8
      32                 :            : #define CMD_RDDPB       0xe0
      33                 :            : #define CMD_RDSPB       0xe2
      34                 :            : #define CMD_EX4B        0xe9
      35                 :            : 
      36                 :            : /* Flash status bits */
      37                 :            : #define STAT_WIP        0x01
      38                 :            : #define STAT_WEN        0x02
      39                 :            : 
      40                 :            : static uint8_t *sim_image;
      41                 :            : static uint32_t sim_image_sz = 0x100000;
      42                 :            : static uint32_t sim_index;
      43                 :            : static uint32_t sim_addr;
      44                 :            : static uint32_t sim_er_size;
      45                 :            : static uint8_t sim_sr;
      46                 :            : static bool sim_fl_4b;
      47                 :            : static bool sim_ct_4b;
      48                 :            : 
      49                 :            : static enum sim_state {
      50                 :            :         sim_state_idle,
      51                 :            :         sim_state_rdid,
      52                 :            :         sim_state_rdsr,
      53                 :            :         sim_state_read_addr,
      54                 :            :         sim_state_read_data,
      55                 :            :         sim_state_write_addr,
      56                 :            :         sim_state_write_data,
      57                 :            :         sim_state_erase_addr,
      58                 :            :         sim_state_erase_done,
      59                 :            : } sim_state;
      60                 :            : 
      61                 :            : /*
      62                 :            :  * Simulated flash & controller
      63                 :            :  */
      64                 :      40590 : static int sim_start_cmd(uint8_t cmd)
      65                 :            : {
      66                 :      40590 :         if (sim_state != sim_state_idle) {
      67                 :          0 :                 ERR("SIM: Command %02x in wrong state %d\n", cmd, sim_state);
      68                 :          0 :                 return -1;
      69                 :            :         }
      70                 :            : 
      71                 :      40590 :         sim_index = 0;
      72                 :      40590 :         sim_addr = 0;
      73                 :            : 
      74                 :      40590 :         switch(cmd) {
      75                 :          1 :         case CMD_RDID:
      76                 :          1 :                 sim_state = sim_state_rdid;
      77                 :          1 :                 break;
      78                 :      24353 :         case CMD_RDSR:
      79                 :      24353 :                 sim_state = sim_state_rdsr;
      80                 :      24353 :                 break;
      81                 :          1 :         case CMD_EX4B:
      82                 :          1 :                 sim_fl_4b = false;
      83                 :          1 :                 break;
      84                 :          0 :         case CMD_EN4B:
      85                 :          0 :                 sim_fl_4b = true;
      86                 :          0 :                 break;
      87                 :       8118 :         case CMD_WREN:
      88                 :       8118 :                 sim_sr |= STAT_WEN;
      89                 :       8118 :                 break;
      90                 :          0 :         case CMD_READ:
      91                 :          0 :                 sim_state = sim_state_read_addr;
      92                 :          0 :                 if (sim_ct_4b != sim_fl_4b)
      93                 :          0 :                         ERR("SIM: 4b mode mismatch in READ !\n");
      94                 :          0 :                 break;
      95                 :       8098 :         case CMD_PP:
      96                 :       8098 :                 sim_state = sim_state_write_addr;
      97                 :       8098 :                 if (sim_ct_4b != sim_fl_4b)
      98                 :          0 :                         ERR("SIM: 4b mode mismatch in PP !\n");
      99                 :       8098 :                 if (!(sim_sr & STAT_WEN))
     100                 :          0 :                         ERR("SIM: PP without WEN, ignoring... \n");
     101                 :       8098 :                 break;
     102                 :         19 :         case CMD_SE:
     103                 :            :         case CMD_BE32K:
     104                 :            :         case CMD_BE:
     105                 :         19 :                 if (sim_ct_4b != sim_fl_4b)
     106                 :          0 :                         ERR("SIM: 4b mode mismatch in SE/BE !\n");
     107                 :         19 :                 if (!(sim_sr & STAT_WEN))
     108                 :          0 :                         ERR("SIM: SE/BE without WEN, ignoring... \n");
     109                 :         19 :                 sim_state = sim_state_erase_addr;
     110                 :         19 :                 switch(cmd) {
     111                 :         18 :                 case CMD_SE:    sim_er_size = 0x1000; break;
     112                 :          0 :                 case CMD_BE32K: sim_er_size = 0x8000; break;
     113                 :          1 :                 case CMD_BE:    sim_er_size = 0x10000; break;
     114                 :            :                 }
     115                 :         19 :                 break;
     116                 :          0 :         case CMD_CE:
     117                 :          0 :                 if (!(sim_sr & STAT_WEN)) {
     118                 :          0 :                         ERR("SIM: CE without WEN, ignoring... \n");
     119                 :          0 :                         break;
     120                 :            :                 }
     121                 :          0 :                 memset(sim_image, 0xff, sim_image_sz);
     122                 :          0 :                 sim_sr |= STAT_WIP;
     123                 :          0 :                 sim_sr &= ~STAT_WEN;
     124                 :          0 :                 break;
     125                 :          0 :         default:
     126                 :          0 :                 ERR("SIM: Unsupported command %02x\n", cmd);
     127                 :          0 :                 return -1;
     128                 :            :         }
     129                 :      40590 :         return 0;
     130                 :            : }
     131                 :            : 
     132                 :      40590 : static void sim_end_cmd(void)
     133                 :            : {
     134                 :            :         /* For write and sector/block erase, set WIP & clear WEN here */
     135                 :      40590 :         if (sim_state == sim_state_write_data) {
     136                 :       8098 :                 sim_sr |= STAT_WIP;
     137                 :       8098 :                 sim_sr &= ~STAT_WEN;
     138                 :            :         }
     139                 :      40590 :         sim_state = sim_state_idle;
     140                 :      40590 : }
     141                 :            : 
     142                 :       8117 : static bool sim_do_address(const uint8_t **buf, uint32_t *len)
     143                 :            : {
     144                 :       8117 :         uint8_t asize = sim_fl_4b ? 4 : 3;
     145                 :       8117 :         const uint8_t *p = *buf;
     146                 :            : 
     147                 :      24351 :         while(*len) {
     148                 :      24351 :                 sim_addr = (sim_addr << 8) | *(p++);
     149                 :      24351 :                 *buf = p;
     150                 :      24351 :                 *len = *len - 1;
     151                 :      24351 :                 sim_index++;
     152                 :      24351 :                 if (sim_index >= asize)
     153                 :       8117 :                         return true;
     154                 :            :         }
     155                 :          0 :         return false;
     156                 :            : }
     157                 :            :                         
     158                 :      16215 : static int sim_wbytes(const void *buf, uint32_t len)
     159                 :            : {
     160                 :      16215 :         const uint8_t *b = buf;
     161                 :            :         bool addr_complete;
     162                 :            : 
     163                 :      16215 :  again:
     164                 :      16215 :         switch(sim_state) {
     165                 :          0 :         case sim_state_read_addr:
     166                 :          0 :                 addr_complete = sim_do_address(&b, &len);
     167                 :          0 :                 if (addr_complete) {
     168                 :          0 :                         sim_state = sim_state_read_data;
     169                 :          0 :                         sim_index = 0;
     170                 :          0 :                         if (len)
     171                 :          0 :                                 goto again;
     172                 :            :                 }
     173                 :          0 :                 break;
     174                 :       8098 :         case sim_state_write_addr:
     175                 :       8098 :                 addr_complete = sim_do_address(&b, &len);
     176                 :       8098 :                 if (addr_complete) {
     177                 :       8098 :                         sim_state = sim_state_write_data;
     178                 :       8098 :                         sim_index = 0;
     179                 :       8098 :                         if (len)
     180                 :          0 :                                 goto again;
     181                 :            :                 }
     182                 :       8098 :                 break;
     183                 :       8098 :         case sim_state_write_data:
     184                 :       8098 :                 if (!(sim_sr & STAT_WEN))
     185                 :          0 :                         break;
     186                 :     224283 :                 while(len--) {
     187                 :     216185 :                         uint8_t c = *(b++);
     188                 :     216185 :                         if (sim_addr >= sim_image_sz) {
     189                 :          0 :                                 ERR("SIM: Write past end of flash\n");
     190                 :          0 :                                 return -1;
     191                 :            :                         }
     192                 :            :                         /* Flash write only clears bits */
     193                 :     216185 :                         sim_image[sim_addr] &= c;
     194                 :     216185 :                         sim_addr = (sim_addr & 0xffffff00) |
     195                 :     216185 :                                 ((sim_addr + 1) & 0xff);
     196                 :            :                 }
     197                 :       8098 :                 break;
     198                 :         19 :         case sim_state_erase_addr:
     199                 :         19 :                 if (!(sim_sr & STAT_WEN))
     200                 :          0 :                         break;
     201                 :         19 :                 addr_complete = sim_do_address(&b, &len);
     202                 :         19 :                 if (addr_complete) {
     203                 :         19 :                         memset(sim_image + sim_addr, 0xff, sim_er_size);
     204                 :         19 :                         sim_sr |= STAT_WIP;
     205                 :         19 :                         sim_sr &= ~STAT_WEN;
     206                 :         19 :                         sim_state = sim_state_erase_done;
     207                 :            :                 }
     208                 :         19 :                 break;
     209                 :          0 :         default:
     210                 :          0 :                 ERR("SIM: Write in wrong state %d\n", sim_state);
     211                 :          0 :                 return -1;
     212                 :            :         }
     213                 :      16215 :         return 0;
     214                 :            : }
     215                 :            : 
     216                 :      24354 : static int sim_rbytes(void *buf, uint32_t len)
     217                 :            : {
     218                 :      24354 :         uint8_t *b = buf;
     219                 :            : 
     220                 :      24354 :         switch(sim_state) {
     221                 :          1 :         case sim_state_rdid:
     222                 :          4 :                 while(len--) {
     223                 :          3 :                         switch(sim_index) {
     224                 :          1 :                         case 0:
     225                 :          1 :                                 *(b++) = 0x55;
     226                 :          1 :                                 break;
     227                 :          1 :                         case 1:
     228                 :          1 :                                 *(b++) = 0xaa;
     229                 :          1 :                                 break;
     230                 :          1 :                         case 2:
     231                 :          1 :                                 *(b++) = 0x55;
     232                 :          1 :                                 break;
     233                 :          0 :                         default:
     234                 :          0 :                                 ERR("SIM: RDID index %d\n", sim_index);
     235                 :          0 :                                 *(b++) = 0;
     236                 :          0 :                                 break;
     237                 :            :                         }
     238                 :          3 :                         sim_index++;
     239                 :            :                 }
     240                 :          1 :                 break;
     241                 :      24353 :         case sim_state_rdsr:
     242                 :      48706 :                 while(len--) {
     243                 :      24353 :                         *(b++) = sim_sr;
     244                 :      24353 :                         if (sim_index > 0)
     245                 :          0 :                                 ERR("SIM: RDSR index %d\n", sim_index);
     246                 :      24353 :                         sim_index++;
     247                 :            : 
     248                 :            :                         /* If WIP was 1, clear it, ie, simulate write/erase
     249                 :            :                          * completion
     250                 :            :                          */
     251                 :      24353 :                         sim_sr &= ~STAT_WIP;
     252                 :            :                 }
     253                 :      24353 :                 break;
     254                 :          0 :         case sim_state_read_data:
     255                 :          0 :                 while(len--) {
     256                 :          0 :                         if (sim_addr >= sim_image_sz) {
     257                 :          0 :                                 ERR("SIM: Read past end of flash\n");
     258                 :          0 :                                 return -1;
     259                 :            :                         }
     260                 :          0 :                         *(b++) = sim_image[sim_addr++];
     261                 :            :                 }
     262                 :          0 :                 break;
     263                 :          0 :         default:
     264                 :          0 :                 ERR("SIM: Read in wrong state %d\n", sim_state);
     265                 :          0 :                 return -1;
     266                 :            :         }
     267                 :      24354 :         return 0;
     268                 :            : }
     269                 :            : 
     270                 :       8117 : static int sim_send_addr(uint32_t addr)
     271                 :            : {
     272                 :            :         const void *ap;
     273                 :            : 
     274                 :            :         /* Layout address MSB first in memory */
     275                 :       8117 :         addr = cpu_to_be32(addr);
     276                 :            : 
     277                 :            :         /* Send the right amount of bytes */
     278                 :       8117 :         ap = (char *)&addr;
     279                 :            : 
     280                 :       8117 :         if (sim_ct_4b)
     281                 :          0 :                 return sim_wbytes(ap, 4);
     282                 :            :         else
     283                 :       8117 :                 return sim_wbytes(ap + 1, 3);
     284                 :            : }
     285                 :            : 
     286                 :      24354 : static int sim_cmd_rd(struct spi_flash_ctrl *ctrl __unused, uint8_t cmd,
     287                 :            :                       bool has_addr, uint32_t addr, void *buffer,
     288                 :            :                       uint32_t size)
     289                 :            : {
     290                 :            :         int rc;
     291                 :            : 
     292                 :      24354 :         rc = sim_start_cmd(cmd);
     293                 :      24354 :         if (rc)
     294                 :          0 :                 goto bail;
     295                 :      24354 :         if (has_addr) {
     296                 :          0 :                 rc = sim_send_addr(addr);
     297                 :          0 :                 if (rc)
     298                 :          0 :                         goto bail;
     299                 :            :         }
     300                 :      24354 :         if (buffer && size)
     301                 :      24354 :                 rc = sim_rbytes(buffer, size);
     302                 :          0 :  bail:
     303                 :      24354 :         sim_end_cmd();
     304                 :      24354 :         return rc;
     305                 :            : }
     306                 :            : 
     307                 :      16236 : static int sim_cmd_wr(struct spi_flash_ctrl *ctrl __unused, uint8_t cmd,
     308                 :            :                       bool has_addr, uint32_t addr, const void *buffer,
     309                 :            :                       uint32_t size)
     310                 :            : {
     311                 :            :         int rc;
     312                 :            : 
     313                 :      16236 :         rc = sim_start_cmd(cmd);
     314                 :      16236 :         if (rc)
     315                 :          0 :                 goto bail;
     316                 :      16236 :         if (has_addr) {
     317                 :       8117 :                 rc = sim_send_addr(addr);
     318                 :       8117 :                 if (rc)
     319                 :          0 :                         goto bail;
     320                 :            :         }
     321                 :      16236 :         if (buffer && size)
     322                 :       8098 :                 rc = sim_wbytes(buffer, size);
     323                 :       8138 :  bail:
     324                 :      16236 :         sim_end_cmd();
     325                 :      16236 :         return rc;
     326                 :            : }
     327                 :            : 
     328                 :          1 : static int sim_set_4b(struct spi_flash_ctrl *ctrl __unused, bool enable)
     329                 :            : {
     330                 :          1 :         sim_ct_4b = enable;
     331                 :            : 
     332                 :          1 :         return 0;
     333                 :            : }
     334                 :            : 
     335                 :        869 : static int sim_read(struct spi_flash_ctrl *ctrl __unused, uint32_t pos,
     336                 :            :                     void *buf, uint32_t len)
     337                 :            : {
     338                 :        869 :         if (sim_ct_4b != sim_fl_4b)
     339                 :          0 :                 ERR("SIM: 4b mode mismatch in autoread !\n");
     340                 :        869 :         if ((pos + len) < pos)
     341                 :          0 :                 return -1;
     342                 :        869 :         if ((pos + len) > sim_image_sz)
     343                 :          0 :                 return -1;
     344                 :        869 :         memcpy(buf, sim_image + pos, len);
     345                 :        869 :         return 0;
     346                 :            : };
     347                 :            : 
     348                 :            : struct spi_flash_ctrl sim_ctrl = {
     349                 :            :         .cmd_wr = sim_cmd_wr,
     350                 :            :         .cmd_rd = sim_cmd_rd,
     351                 :            :         .set_4b = sim_set_4b,
     352                 :            :         .read = sim_read,
     353                 :            : };
     354                 :            : 
     355                 :          1 : int main(void)
     356                 :            : {
     357                 :            :         struct blocklevel_device *bl;
     358                 :            :         uint64_t total_size;
     359                 :            :         uint32_t erase_granule;
     360                 :            :         const char *name;
     361                 :            :         uint16_t *test;
     362                 :            :         struct ecc64 *ecc_test;
     363                 :            :         uint64_t *test64;
     364                 :            :         int i, rc;
     365                 :            : 
     366                 :          1 :         sim_image = malloc(sim_image_sz);
     367                 :          1 :         memset(sim_image, 0xff, sim_image_sz);
     368                 :          1 :         test = malloc(0x10000 * 2);
     369                 :            : 
     370                 :          1 :         rc = flash_init(&sim_ctrl, &bl, NULL);
     371                 :          1 :         if (rc) {
     372                 :          0 :                 ERR("flash_init failed with err %d\n", rc);
     373                 :          0 :                 exit(1);
     374                 :            :         }
     375                 :          1 :         rc = flash_get_info(bl, &name, &total_size, &erase_granule);
     376                 :          1 :         if (rc) {
     377                 :          0 :                 ERR("flash_get_info failed with err %d\n", rc);
     378                 :          0 :                 exit(1);
     379                 :            :         }
     380                 :            : 
     381                 :            :         /* Make up a test pattern */
     382                 :      65537 :         for (i=0; i<0x10000;i++)
     383                 :      65536 :                 test[i] = cpu_to_be16(i);
     384                 :            : 
     385                 :            :         /* Write 64k of stuff at 0 and at 128k */
     386                 :          1 :         printf("Writing test patterns...\n");
     387                 :          1 :         flash_smart_write(bl, 0, test, 0x10000);
     388                 :          1 :         flash_smart_write(bl, 0x20000, test, 0x10000);
     389                 :            : 
     390                 :            :         /* Write "Hello world" straddling the 64k boundary */
     391                 :            : #define HW "Hello World"
     392                 :          1 :         printf("Writing test string...\n");
     393                 :          1 :         flash_smart_write(bl, 0xfffc, HW, sizeof(HW));
     394                 :            : 
     395                 :            :         /* Check result */
     396                 :          1 :         if (memcmp(sim_image + 0xfffc, HW, sizeof(HW))) {
     397                 :          0 :                 ERR("Test string mismatch !\n");
     398                 :          0 :                 exit(1);
     399                 :            :         }
     400                 :          1 :         printf("Test string pass\n");
     401                 :          1 :         if (memcmp(sim_image, test, 0xfffc)) {
     402                 :          0 :                 ERR("Test pattern mismatch !\n");
     403                 :          0 :                 exit(1);
     404                 :            :         }
     405                 :          1 :         printf("Test pattern pass\n");
     406                 :            : 
     407                 :          1 :         printf("Test ECC interfaces\n");
     408                 :          1 :         flash_smart_write_corrected(bl, 0, test, 0x10000, 1);
     409                 :          1 :         ecc_test = (struct ecc64 *)sim_image;
     410                 :          1 :         test64 = (uint64_t *)test;
     411                 :       7282 :         for (i = 0; i < 0x10000 / sizeof(*ecc_test); i++) {
     412                 :       7281 :                 if (test64[i] != ecc_test[i].data) {
     413                 :          0 :                         ERR("flash_smart_write_corrected() pattern missmatch at %d: 0x%016lx vs 0x%016lx\n",
     414                 :            :                                         i, test64[i], ecc_test[i].data);
     415                 :          0 :                         exit(1);
     416                 :            :                 }
     417                 :       7281 :                 if (ecc_test[i].ecc != eccgenerate(be64toh(test64[i]))) {
     418                 :          0 :                         ERR("ECCs don't match 0x%02x vs 0x%02x\n", ecc_test[i].ecc, eccgenerate(test64[i]));
     419                 :          0 :                         exit(1);
     420                 :            :                 }
     421                 :            :         }
     422                 :          1 :         printf("Test ECC interface pass\n");
     423                 :            : 
     424                 :          1 :         printf("Test ECC erase\n");
     425                 :          1 :         if (flash_erase(bl, 0, 0x10000) != 0) {
     426                 :          0 :                 ERR("flash_erase didn't return 0\n");
     427                 :          0 :                 exit(1);
     428                 :            :         }
     429                 :            : 
     430                 :       7282 :         for (i = 0; i < 0x10000 / sizeof(*ecc_test); i++) {
     431                 :       7281 :                 uint8_t zero = 0;
     432                 :       7281 :                 if (ecc_test[i].data != 0xFFFFFFFFFFFFFFFF) {
     433                 :          0 :                         ERR("Data not properly cleared at %d\n", i);
     434                 :          0 :                         exit(1);
     435                 :            :                 }
     436                 :       7281 :                 rc = flash_write(bl, i * sizeof(*ecc_test) + 8, &zero, 1, 0);
     437                 :       7281 :                 if (rc || ecc_test[i].ecc != 0) {
     438                 :          0 :                         ERR("Cleared data not correctly ECCed: 0x%02x (0x%016lx) expecting 0 at %d\n", ecc_test[i].ecc, ecc_test[i].data, i);
     439                 :          0 :                         exit(1);
     440                 :            :                 }
     441                 :            :         }
     442                 :          1 :         printf("Test ECC erase pass\n");
     443                 :            : 
     444                 :          1 :         flash_exit(bl);
     445                 :          1 :         free(test);
     446                 :            : 
     447                 :          1 :         return 0;
     448                 :            : }

Generated by: LCOV version 1.14