direct/test-framework/yaffs_nand_drv.c

   1 /*
   2  * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
   3  *
   4  * Copyright (C) 2002-2018 Aleph One Ltd.
   5  *
   6  * Created by Charles Manning <charles@aleph1.co.uk>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  */
  12
  13 /*
  14  * This is an interface module for handling NAND in yaffs2 mode.
  15  */
  16
  17 /* This code calls a driver that accesses "generic" NAND. In the simulator
  18  * this is direceted at a file-backed NAND simulator. The NAND access functions
  19  * should also work with real NAND.
  20  *
  21  * This driver is designed for use in yaffs2 mode with a 2k page size and
  22  * 64 bytes of spare.
  23  *
  24  * The spare ares is used as follows:
  25  * offset 0: 2 bytes bad block marker.
  26  * offset 2: 8x3 bytes of ECC over the data.
  27  * offset 26: rest available to store Yaffs tags etc.
  28  */
  29
  30 #include "yaffs_nand_drv.h"
  31 #include "yportenv.h"
  32 #include "yaffs_trace.h"
  33
  34 #include "nand_store.h"
  35 #include "yaffs_flashif.h"
  36 #include "yaffs_guts.h"
  37 #include "nanddrv.h"
  38 #include "yaffs_ecc.h"
  39
  40 struct nand_context {
  41         struct nand_chip *chip;
  42         u8 *buffer;
  43 };
  44
  45
  46 static inline struct nand_chip *dev_to_chip(struct yaffs_dev *dev)
  47 {
  48         struct nand_context *ctxt =
  49                 (struct nand_context *)(dev->driver_context);
  50         return ctxt->chip;
  51 }
  52
  53 static inline u8 *dev_to_buffer(struct yaffs_dev *dev)
  54 {
  55         struct nand_context *ctxt =
  56                 (struct nand_context *)(dev->driver_context);
  57         return ctxt->buffer;
  58 }
  59
  60 static int yaffs_nand_drv_WriteChunk(struct yaffs_dev *dev, int nand_chunk,
  61                                    const u8 *data, int data_len,
  62                                    const u8 *oob, int oob_len)
  63 {
  64         struct nand_chip *chip = dev_to_chip(dev);
  65         u8 *buffer = dev_to_buffer(dev);
  66         u8 *e;
  67         struct nanddrv_transfer tr[2];
  68         int i;
  69
  70         if(!data)
  71                 return YAFFS_FAIL;
  72
  73
  74         /* Calc ECC and marshall the oob bytes into the buffer */
  75
  76         memset(buffer, 0xff, chip->spare_bytes_per_page);
  77
  78         for(i = 0, e = buffer + 2; i < chip->data_bytes_per_page; i+=256, e+=3)
  79                 yaffs_ecc_calc(data + i, e);
  80
  81         if (oob)
  82                 memcpy(buffer + 26, oob, oob_len);
  83
  84         /* Set up and execute transfer */
  85
  86         tr[0].buffer = (u8 *)data;
  87         tr[0].offset = 0;
  88         tr[0].nbytes = data_len;
  89
  90         tr[1].buffer = buffer;
  91         tr[1].offset = chip->data_bytes_per_page;
  92         tr[1].nbytes = chip->spare_bytes_per_page;
  93
  94         if(nanddrv_write_tr(chip, nand_chunk, tr, 2) == 0)
  95                 return YAFFS_OK;
  96         else
  97                 return YAFFS_FAIL;
  98 }
  99
 100 static int yaffs_nand_drv_ReadChunk(struct yaffs_dev *dev, int nand_chunk,
 101                                    u8 *data, int data_len,
 102                                    u8 *oob, int oob_len,
 103                                    enum yaffs_ecc_result *ecc_result_out)
 104 {
 105         struct nand_chip *chip = dev_to_chip(dev);
 106         u8 *buffer = dev_to_buffer(dev);
 107         struct nanddrv_transfer tr[2];
 108         struct nanddrv_transfer *trp = tr;
 109         int n_tr = 0;
 110         int ret;
 111         enum yaffs_ecc_result ecc_result;
 112         int i;
 113         u8 *e;
 114         u8 read_ecc[3];
 115
 116         if(data) {
 117                 trp->buffer = data;
 118                 trp->offset = 0;
 119                 trp->nbytes = data_len;
 120                 n_tr++;
 121                 trp++;
 122         }
 123
 124
 125         trp->buffer = buffer;
 126         trp->offset = chip->data_bytes_per_page;
 127         trp->nbytes = chip->spare_bytes_per_page;
 128         n_tr++;
 129         trp++;
 130
 131
 132         ret = nanddrv_read_tr(chip, nand_chunk, tr, n_tr);
 133
 134         if(ret < 0) {
 135                 if (ecc_result_out)
 136                         *ecc_result_out = YAFFS_ECC_RESULT_UNKNOWN;
 137                 return YAFFS_FAIL;
 138         }
 139
 140         /* Do ECC and marshalling */
 141         if(oob)
 142                 memcpy(oob, buffer + 26, oob_len);
 143
 144         ecc_result = YAFFS_ECC_RESULT_NO_ERROR;
 145
 146         if(data) {
 147                 for(i = 0, e = buffer + 2; i < chip->data_bytes_per_page; i+=256, e+=3) {
 148                         yaffs_ecc_calc(data + i, read_ecc);
 149                         ret = yaffs_ecc_correct(data + i, e, read_ecc);
 150                         if (ret < 0)
 151                                 ecc_result = YAFFS_ECC_RESULT_UNFIXED;
 152                         else if( ret > 0 && ecc_result == YAFFS_ECC_RESULT_NO_ERROR)
 153                                 ecc_result = YAFFS_ECC_RESULT_FIXED;
 154                 }
 155         }
 156
 157         if (ecc_result_out)
 158                 *ecc_result_out = ecc_result;
 159
 160         return YAFFS_OK;
 161 }
 162
 163 static int yaffs_nand_drv_EraseBlock(struct yaffs_dev *dev, int block_no)
 164 {
 165         struct nand_chip *chip = dev_to_chip(dev);
 166
 167         if(nanddrv_erase(chip, block_no) == 0)
 168                 return YAFFS_OK;
 169         else
 170                 return YAFFS_FAIL;
 171 }
 172
 173 static int yaffs_nand_drv_MarkBad(struct yaffs_dev *dev, int block_no)
 174 {
 175         struct nand_chip *chip = dev_to_chip(dev);
 176         u8 *buffer = dev_to_buffer(dev);
 177         int nand_chunk = block_no * chip->pages_per_block;
 178         struct nanddrv_transfer tr[1];
 179
 180         memset(buffer, 0xff, chip->spare_bytes_per_page);
 181         buffer[0] = 'Y';
 182         buffer[1] = 'Y';
 183
 184         tr[0].buffer = buffer;
 185         tr[0].offset = chip->data_bytes_per_page;
 186         tr[0].nbytes = chip->spare_bytes_per_page;
 187
 188         if(nanddrv_write_tr(chip, nand_chunk, tr, 1) == 0)
 189                 return YAFFS_OK;
 190         else
 191                 return YAFFS_FAIL;
 192 }
 193
 194 static int yaffs_nand_drv_CheckBad(struct yaffs_dev *dev, int block_no)
 195 {
 196         struct nand_chip *chip = dev_to_chip(dev);
 197         u8 *buffer = dev_to_buffer(dev);
 198         int nand_chunk = block_no * chip->pages_per_block;
 199         struct nanddrv_transfer tr[1];
 200
 201         memset(buffer, 0, chip->spare_bytes_per_page);
 202
 203         tr[0].buffer = buffer;
 204         tr[0].offset = chip->data_bytes_per_page;
 205         tr[0].nbytes = chip->spare_bytes_per_page;
 206
 207         nanddrv_read_tr(chip, nand_chunk, tr, 1);
 208
 209         /* Check that bad block marker is not set */
 210         if(yaffs_hweight8(buffer[0]) + yaffs_hweight8(buffer[1]) < 14)
 211                 return YAFFS_FAIL;
 212         else
 213                 return YAFFS_OK;
 214
 215 }
 216
 217 static int yaffs_nand_drv_Initialise(struct yaffs_dev *dev)
 218 {
 219         struct nand_chip *chip = dev_to_chip(dev);
 220
 221         (void)chip;
 222         return YAFFS_OK;
 223 }
 224
 225 static int yaffs_nand_drv_Deinitialise(struct yaffs_dev *dev)
 226 {
 227         struct nand_chip *chip = dev_to_chip(dev);
 228
 229         (void) chip;
 230         return YAFFS_OK;
 231 }
 232
 233
 234 int yaffs_nand_install_drv(struct yaffs_dev *dev, struct nand_chip *chip)
 235 {
 236         struct yaffs_driver *drv = &dev->drv;
 237         u8 *buffer = NULL;
 238         struct nand_context *ctxt = NULL;
 239
 240         ctxt = malloc(sizeof(struct nand_context));
 241         buffer = malloc(chip->spare_bytes_per_page);
 242
 243         if(!buffer || !ctxt)
 244                 goto fail;
 245
 246         drv->drv_write_chunk_fn = yaffs_nand_drv_WriteChunk;
 247         drv->drv_read_chunk_fn = yaffs_nand_drv_ReadChunk;
 248         drv->drv_erase_fn = yaffs_nand_drv_EraseBlock;
 249         drv->drv_mark_bad_fn = yaffs_nand_drv_MarkBad;
 250         drv->drv_check_bad_fn = yaffs_nand_drv_CheckBad;
 251         drv->drv_initialise_fn = yaffs_nand_drv_Initialise;
 252         drv->drv_deinitialise_fn = yaffs_nand_drv_Deinitialise;
 253
 254         ctxt->chip = chip;
 255         ctxt->buffer = buffer;
 256         dev->driver_context = (void *) ctxt;
 257         return YAFFS_OK;
 258
 259 fail:
 260         free(ctxt);
 261         free(buffer);
 262         return YAFFS_FAIL;
 263 }