// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#pragma once

#include <inc/config.h>

#include <errno.h>
#include <string.h>
#include <ftl_private.h>
#include <fsprivate.h>
#include <kprivate/ndm.h>
#include <ftl_mc.h>

//
// Configuration.
//
#define FTLN_LEGACY TRUE // TRUE to be backward compatible
#define INC_ELIST TRUE   // if true, write erased blocks list
#define DEBUG_ELIST FALSE
#ifndef FTLN_DEBUG
#define FTLN_DEBUG TRUE
#endif
#ifndef FTLN_DEBUG_PTR
#define FTLN_DEBUG_PTR FALSE
#endif
#if !FTLN_LEGACY
#define FTLN_3B_PN TRUE // if true, use 3B page numbers
#endif

//
// Symbol Definitions.
//
#define FTLN_MIN_FREE_BLKS 4

//
// FTL meta-page information
//
#define FTLN_META_VER1 20180423  // current metapage version
#define FTLN_META_VER_LOC 0      // version location in page
#define FTLN_META_TYP_LOC 4      // page type location
#define FTLN_META_DATA_BEG 8     // starting data offset

//
// Meta-Page Types
//
#define CONT_FORMAT 0
#define ERASED_LIST 1

//
// Macro Definitions.
//
//
// Block Array Definitions
//
// A bdata entry is a 32 bit value that holds block metadata in RAM
// Bit 31 indicates if a block is free (1) or used (0)
// For free blocks:
//   Bit 30 indicates if a free block is erased (1) or not (0)
// For used blocks:
//   Bit 30 - indicates if a block is map (1) or volume (0) block
//   Bits 29 through 20 - number of used pages in block
//   Bits 19 through  0 - block read count
//
// 0xC0000000 - free/erased block
// 0x80000000 - free block
// 0x7XXXXXXX-0x4XXXXXXX - map block
// 0x3XXXXXXX-0x0XXXXXXX - used block
//
#define BLK_STATE_MASK 0xC0000000
#define FREE_BLK_FLAG 0x80000000
#define ERASED_BLK_FLAG 0x40000000  // applies only to free blocks
#define MAP_BLK_STATE 0x40000000
#define USED_MASK 0x3FF00000  // applies to map/vol blocks
#define RC_MASK 0x000FFFFF    // applies to map/vol blocks

#define PGS_PER_BLK_MAX (USED_MASK >> 20)

#define IS_FREE(b) ((b)&FREE_BLK_FLAG)
#define IS_ERASED(b) (((b)&BLK_STATE_MASK) == (FREE_BLK_FLAG | ERASED_BLK_FLAG))
#define IS_MAP_BLK(b) (((b)&BLK_STATE_MASK) == MAP_BLK_STATE)
#define SET_MAP_BLK(bd) (bd = MAP_BLK_STATE)

#define NUM_USED(bd) (((bd)&USED_MASK) >> 20)
#define DEC_USED(bd) ((bd) -= (1 << 20))
#define INC_USED(bd) ((bd) += (1 << 20))
#define GET_RC(bd) ((bd)&RC_MASK)
#define SET_RC(bd, n) ((bd) = ((bd) & ~RC_MASK) | n)
#define INC_RC(ftl, bdp, c)               \
    do {                                  \
        ui32 rc = GET_RC(*bdp) + c;       \
                                          \
        if (rc > RC_MASK)                 \
            rc = RC_MASK;                 \
        *bdp = rc | (*bdp & ~RC_MASK);    \
        if (rc >= (ftl)->max_rc)          \
            (ftl)->max_rc_blk = (ui32)-2; \
    } /*lint !e717*/ \
    while (0)
#define SET_MAX_RC(ftl, bdp)                      \
    do {                                          \
        (ftl)->max_rc_blk = (ui32)-2;             \
        *bdp = (ftl)->max_rc | (*bdp & ~RC_MASK); \
    } /*lint !e717*/ \
    while (0)


// Map Page Array Definitions
//
// Get/set the physical page corresponding to a VPN
//
#if FTLN_3B_PN
#define FTLN_PN_SZ 3
#define UNMAPPED_PN 0x00FFFFFF
#define GET_MAP_PPN(maddr) RD24_LE(maddr)
#define SET_MAP_PPN(maddr, pn) WR24_LE(pn, maddr)
#else
#define FTLN_PN_SZ 4
#define UNMAPPED_PN 0xFFFFFFFF
#define GET_MAP_PPN(maddr) RD32_LE(maddr)
#define SET_MAP_PPN(maddr, pn) WR32_LE(pn, maddr)
#endif

//
// Spare Area Access Definitions.
//
// Layout of Spare Area (Extra Bytes)
//  - byte   0: bad block mark byte - unused by the FTL
//  - bytes  1 -  4: virtual page number
//  - bytes  5 -  8: block count (BC)
//  - bytes  9 - 11 and MSH of 12: block wear count (WC)
//  - bytes LSH of 12 and 13 - 14: page validity check
//  - byte  15: NDM control page mark byte
//
//
// Get/set virtual page number from spare area (bytes 1 - 4)
//
#define GET_SA_VPN(spare) RD32_LE(&spare[1])
#define SET_SA_VPN(vpn, spare) WR32_LE(vpn, &spare[1])

//
// Get/set block count from spare area (bytes 5 - 8)
//
#define GET_SA_BC(spare) RD32_LE(&spare[5])
#define SET_SA_BC(bc, spare) WR32_LE(bc, &spare[5])

//
// Get/set block wear count from spare area (bytes 9 - 11 and MSH of 12)
//
#define GET_SA_WC(spare) (RD24_LE(&spare[9]) | ((spare[12] & 0xF0) << 20))
#define SET_SA_WC(wc, spare)                                 \
    {                                                        \
        WR24_LE(wc, &spare[9]);                              \
        spare[12] = (spare[12] & 0xF) | ((wc >> 20) & 0xF0); \
    }

//
// Type Declarations.
//
//
// The TargetFTL-NDM volume type
//
typedef struct ftln* FTLN;
typedef const struct ftln* CFTLN;
struct ftln {
    CircLink link;          // volume list link

    // Driver Dependent Variables
    ui32 num_pages;         // total number of pages
    ui32 pgs_per_blk;       // number of pages in a block
    ui32 block_size;        // block size in bytes
    ui32 num_blks;          // number of blocks
    ui32 page_size;         // page size in bytes
    ui32 start_pn;          // first page on device for volume
    void* ndm;              // pointer to NDM this FTL belongs to

    ui32 flags;             // holds various FTL flags
    ui32* bdata;            // block metadata: flags and counts
    ui8* blk_wc_lag;        // amount block erase counts lag 'high_wc'
    ui32* mpns;             // array holding phy page # of map pages

    FTLMC* map_cache;       // handle to map page cache
    ui32 free_vpn;          // next free page for volume page write
    ui32 free_mpn;          // next free page for map page write
    ui32 mappings_per_mpg;  // number of phys page numbers per map page
    ui32 num_vpages;        // number of volume pages
    ui32 num_free_blks;     // number of free blocks
    ui32 num_map_pgs;       // number of pages holding map data
    ui32 high_wc;           // highest block wear count
    ui32 high_bc;           // highest map block write count
    ui32 max_rc;            // per block read wear limit
    ui32 max_rc_blk;        // if not -1, # of block w/high read cnt
    ui32 high_bc_mblk;      // last map block
    ui32 high_bc_mblk_po;   // used page offset on last map block
    ui32 resume_vblk;       // vblk in interrupted recycle recovery
    ui32 resume_tblk;       // tmp blk for interrupted recycle recovery
    ui32 resume_po;         // resume vblk's highest used page offset
#if INC_ELIST
    ui32 elist_blk;         // if valid, # of block holding erased list
#endif
    ftl_ndm_stats stats;    // driver call counts

    ui8* main_buf;          // NAND main page buffer
    ui8* spare_buf;         // spare buffer for single/multi-pg access

    ui8 eb_size;            // spare area size in bytes
    ui8 copy_end_found;     // vblk resume copy-end mark found
    ui8 deferment;          // # of recycles before applying wear limit
#if FTLN_DEBUG
    ui8 max_wc_lag;         // maximum observed lag below hi wear count
    ui8 max_wc_over;        // # of times max WC (0xFF) was exceeded
#endif
#if FS_ASSERT
    ui8 assert_no_recycle;  // test no recycle changes physical page #
#endif
    char vol_name[FILENAME_MAX]; // volume name
};

//
// Variable Declarations.
//
extern CircLink FtlnVols;
#if FTLN_DEBUG_PTR
extern FTLN Ftln;
#endif

//
// Function Prototypes.
//
int FtlnDelVol(FTLN ftl);
int FtlnWrPages(const void* buf, ui32 first, int count, void* vol);
int FtlnRdPages(void* buf, ui32 first, int count, void* vol);
int FtlnReport(void* vol, ui32 msg, ...);
ui32 FtlnGarbLvl(CFTLN ftl);
int FtlnVclean(FTLN ftl);
int FtlnMapGetPpn(CFTLN ftl, ui32 vpn, ui32* pnp);
int FtlnMapSetPpn(CFTLN ftl, ui32 vpn, ui32 ppn);
int FtlnRecCheck(FTLN ftl, int wr_cnt);
int FtlnRecNeeded(CFTLN ftl, int wr_cnt);
int FtlnRdPage(FTLN ftl, ui32 pn, void* buf);

int FtlnMapWr(void* vol, ui32 mpn, void* buf);
int FtlnMetaWr(FTLN ftl, ui32 type);

void FtlnDecUsed(FTLN ftl, ui32 pn, ui32 vpn);
int FtlnFormat(FTLN ftl, ui32 meta_block);
void FtlnStateRst(FTLN ftl);
int FtlnEraseBlk(FTLN ftl, ui32 b);
ui32 FtlnLoWcFreeBlk(CFTLN ftl);
ui32 FtlnHiWcFreeBlk(CFTLN ftl);
int FtlnRecycleMapBlk(FTLN ftl, ui32 recycle_b);

int FtlnSetClustSect1(FTLN ftl, const ui8* bpb, int format_req);
int FtlnFatErr(FTLN ftl);

#if INC_FTL_NDM_MLC
void FtlnMlcSafeFreeVpn(FTLN ftl);
#endif

void FtlnBlkStats(CFTLN ftl);
void FtlnStats(FTLN ftl);
void FtlnShowBlks(void);
void FtlnCheckBlank(FTLN ftl, ui32 b);