cdnutter
/
iBoot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
iBoot/drivers/apple/asp/debug.c

4208 lines
135 KiB
C
Raw Blame History

/*
* Copyright (c) 2012 Apple Inc. All rights reserved.
*
* This document is the property of Apple Inc.
* It is considered confidential and proprietary.
*
* This document may not be reproduced or transmitted in any form,
* in whole or in part, without the express written permission of
* Apple Inc.
*/
#define ASP_TARGET_RTXC 1
#define CASSERT(x, name) typedef char __ASP_CASSERT_##name[(x) ? 1 : -1]
#include <debug.h>
#include <sys/menu.h>
#include <lib/env.h>
#include <platform/memmap.h>
#include <platform/soc/hwclocks.h>
#include <stdint.h>
#include <assert.h>
#include <csi_ipc_protocol.h>
#include <arch.h>
#include <aspcore_mbox.h>
#include <aspcore_protocol.h>
#include <aspcore_nand_debug.h>
#include <debug.h>
#include <drivers/asp.h>
#include <drivers/csi.h>
#include <lib/env.h>
#include <lib/heap.h>
#include <lib/partition.h>
#include <libDER/DER_Keys.h>
#include <libDER/DER_Decode.h>
#include <libDER/asn1Types.h>
#include <platform.h>
#include <stdio.h>
#include <sys.h>
#include <platform/timer.h> // ticks
#include "common_util.h"
#include <drivers/usb/usb_debug.h>
#if DEBUG_BUILD && WITH_MENU
#define METADATA_PER_LBA (16)
#define LBA_TOKEN_SIZE (4)
#define TOKEN_TERMINATOR (0xFFFFFFFF)
#define LBA_TOKEN_BASE (0x0FF00000)
#define LBA_TOKEN_BLOG (LBA_TOKEN_BASE + 0x13)
#define BYTES_PER_SEC (4096)
#define BLOG_NUM_ENTRY (BYTES_PER_SEC / sizeof(BlogE_t))
#define MAX_RMA_CHUNK_PAGES (1024)
#define PERFECT_PAGE_SIZE (4112)
#define VENDOR_CODE__MICRON (0x2C)
#define VENDOR_CODE__HYNIX (0xAD)
#define VENDOR_CODE__SANDISK (0x45)
#define SIZE_OF_WFALL_TBL_ENTRY (4)
#define TEST_DATA_PATTERN (0xA5)
#define WATERMARK_PATTERN (0xFF)
#define FLOW_DEAD 12
#define FLOW_UTIL 13
extern aspproto_nand_geom_t nand_info;
extern asp_t asp;
extern struct blockdev *asp_nand_dev;
typedef enum {
NOB_TOKEN_UNMAPPED = 0,
NOB_TOKEN_W_UNC = 1,
NOB_TOKEN_W_UNC_LOG = 2,
NOB_TOKEN_GC_UNC = 3,
NOB_TOKEN_GC_BLANK = 4,
NOB_TOKEN_TRANSLATE = 5,
NUM_NOB_TOKENS = 6,
NOB_TOKEN_MAX = 7
} NOB_TOKEN_e;
#define NOB_BAND_BITS 12
#define NOB_BOFF_BITS (32 - NOB_BAND_BITS)
typedef union {
struct {
uint32_t boff : NOB_BOFF_BITS;
uint32_t band : NOB_BAND_BITS;
};
uint32_t all; // note that the all field is used to acclerate math on the boff field which is assumed to be the least significant bits without risk of roll over.
NOB_TOKEN_e token;
} nob_t;
typedef struct {
uint32_t lba;
uint32_t size;
} BlogE_t;
typedef enum {
BONFIRE_SLC_STATE_NONE = 0,
BONFIRE_SLC_STATE_A = 1,
BONFIRE_SLC_STATE_B = 2
} BONFIRE_SLC_STATE_e;
BONFIRE_SLC_STATE_e bonfire_slc_state = BONFIRE_SLC_STATE_NONE;
typedef enum {
ASP_USER_PARTITION,
ASP_INTERMEDIATE_PARTITION,
NUM_ASP_PARITIONS
} asp_partitions_e;
char partition_names[NUM_ASP_PARITIONS][30] = {
"USER PARTITION",
"INTERMEDIATE PARTITION"
};
#define ROUNDUPTO(num, gran) ((((num) + (gran) - 1) / (gran)) * (gran))
static void usage(void)
{
printf("usage:\n");
printf("asp sync\n");
#if defined(ASP_ENABLE_NEURALIZE) && ASP_ENABLE_NEURALIZE
printf("asp neuralize\n");
#endif
printf("asp readid\n");
printf("asp info\n");
printf("asp debug_counter_supported <channel>\n");
printf("asp get_debug_counter <channel>\n");
printf("asp reset_debug_counter <channel>\n");
printf("asp dies_in_parallel <total dies>\n");
printf("asp dies_in_parallel (for MLC device: <slc_write> <read> <erase> <mlc_write>) (for TLC device: <slc_write> <read> <erase> <tlc_write>)\n");
printf("asp test_scratchpad\n");
printf("asp bonfirereadband <band> <mode(%d for MLC, %d for SLC, %d for TLC)> <display stats (0/1)\n", CELL_TYPE_IS_MLC, CELL_TYPE_IS_SLC, CELL_TYPE_IS_TLC);
printf("asp readband <band> <mode(%d for MLC, %d for SLC, %d for TLC)> < no. of stripes to be issued during 1 read transaction> <Optional: time in seconds to repeatedly read. if 0, then read only once>\n", CELL_TYPE_IS_MLC, CELL_TYPE_IS_SLC, CELL_TYPE_IS_TLC);
printf("asp readrandom <mode(%d for MLC, %d for SLC, %d for TLC, %d for mixed)> <Num of reads (each read is 4k/8k/16k)> <no. of stripes to be issued during 1 read transaction> <num sectors_per_page> <if reads in a stripe should be on same_die (1 for same die, 2 for diff die, 3 for random)> <Optional: time in seconds to repeatedly read. if 0, then read only once>\n", CELL_TYPE_IS_MLC, CELL_TYPE_IS_SLC, CELL_TYPE_IS_TLC, CELL_TYPE_IS_MIXED);
printf("asp readmixedsuperpage <Num stripes> < no. of stripes to be issued during 1 read transaction> <Optional: time in seconds to repeatedly read. if 0, then read only once>\n");
printf("asp secperband <band>\n");
printf("asp v2p <vba>\n");
printf("asp getburnincode\n");
printf("asp cbp2r <cau> <blk> <page>\n");
printf("asp dbp2r <dip> <bork> <page>\n");
printf("asp r2cbp <row_address>\n");
printf("asp l2dbp <lba>\n");
printf("asp getlastfailure\n");
printf("asp set_photoflow_slc\n");
printf("asp set_photoflow_mlc\n");
printf("asp enable_bg\n");
printf("asp disable_bg\n");
printf("asp bbt\n");
printf("asp dm\n");
printf("asp dipinfo\n");
printf("asp read <bus> <ce> <row address> <sector_offset> <no. of %d byte sectors> <0/1/2 for bit flips or in-depth health monitoring> <mode(%d for MLC, %d for SLC, %d for TLC)>\n", ASP_NAND_BLKSZ, CELL_TYPE_IS_MLC, CELL_TYPE_IS_SLC, CELL_TYPE_IS_TLC);
printf("asp readpagemeta <bus> <ce> <row address> <no. of pages>\n");
printf("asp readbandmeta <band> <verbose (0/1)\n");
printf("asp bandstat\n");
printf("asp disableuid\n");
printf("asp dumpblog <band> <audit (0/1)> <verbose (0/1)>\n");
printf("asp vthsweep <channel> <cau> <block> <file_path>\n");
printf("asp rma_configure <channel> <mask>\n");
printf("asp rma_set <channel>\n");
printf("asp rma_get <channel> [file_path]\n");
printf("asp rma_delete <channel>\n");
printf("asp ppn_recover\n");
printf("asp ppn_get_calibration <file_path>\n");
printf("asp waterfall_size\n");
printf("asp waterfall\n");
printf("asp devparam\n");
printf("asp testbdevread\n");
printf("asp setTLCwritestripes <number of stripes that can be programmed together>\n");
printf("asp readverify <band>\n");
printf("asp istlc\n");
printf("asp getlinkclkfreq\n");
printf("asp resetperfticks\n");
printf("asp getperfticks\n");
printf("asp printslcbonfirebands\n");
#if ASP_ENABLE_WRITES
printf("asp setwritable\n");
printf("asp utilFormat\n");
printf("asp lbaFormat\n");
printf("asp register\n");
printf("asp bonfireeraseband <band>\n");
printf("asp bonfirewriteband <band> <mode(%d for MLC, %d for SLC, %d for TLC)> <Optional: 4 byte data pattern. otherwise random>\n", CELL_TYPE_IS_MLC, CELL_TYPE_IS_SLC, CELL_TYPE_IS_TLC);
printf("asp setburnincode <code>\n");
printf("asp eraseband <band> <mode(%d for MLC, %d for SLC, %d for TLC)>\n", CELL_TYPE_IS_MLC, CELL_TYPE_IS_SLC, CELL_TYPE_IS_TLC);
printf("asp writeband <band> <mode(%d for MLC, %d for SLC, %d for TLC)> <Optional: 4 byte data pattern. otherwise random>\n", CELL_TYPE_IS_MLC, CELL_TYPE_IS_SLC, CELL_TYPE_IS_TLC);
printf("asp eploop <band> <mode(%d for MLC, %d for SLC, %d for TLC) <time in seconds to repeatedly Erase+Prog. if 0, then only once> <Optional: 4 byte data pattern. otherwise random>", CELL_TYPE_IS_MLC, CELL_TYPE_IS_SLC, CELL_TYPE_IS_TLC);
printf("asp testwaterfall\n");
printf("asp testbdevwrite\n");
printf("asp groupaslc <seed>\n");
printf("asp groupbslc\n");
printf("asp ungroup\n");
#endif //ASP_ENABLE_WRITES
}
static int asp_nand_info(void)
{
printf("ce_per_bus = %d\n", nand_info.ce_per_bus);
printf("cau_per_die = %d\n", nand_info.cau_per_die);
printf("num_bus = %d\n", nand_info.num_bus);
printf("die_per_bus = %d\n", nand_info.die_per_bus);
printf("num_dip = %d\n", nand_info.num_dip);
printf("num_bands = %d\n", nand_info.num_bands);
printf("sec_per_page = %d\n", nand_info.sec_per_page);
printf("sec_per_full_band = %d\n", nand_info.sec_per_full_band);
printf("sec_per_full_band_slc = %d\n", nand_info.sec_per_full_band_slc);
printf("bytes_per_sec_meta = %d\n", nand_info.bytes_per_sec_meta);
printf("pages_per_block = %d\n", nand_info.pages_per_block);
printf("pages_per_block_slc = %d\n", nand_info.pages_per_block_slc);
printf("cell type = %d. (%d for MLC, %d for TLC)\n", nand_info.cell_type, CELL_TYPE_IS_MLC, CELL_TYPE_IS_TLC);
printf("lastUserBand = %d\n", asp.lastUserBand);
printf("lastBand = %d\n", asp.lastBand);
printf("numVirtualSLCBonfireBands = %d\n", asp.numVirtualSLCBonfireBands);
printf("firstIntermediateBand = %d\n", asp.firstIntermediateBand);
printf("lastIntermediateBand = %d\n", asp.lastIntermediateBand);
return 0;
}
static void asp_print_status_key() {
printf("\nType key: \n0:Success, \n3:UECC/Efail/Pfail, \n5:Refresh, \n6: clean, \n8:Unknown\n\n");
}
static bool asp_format(uint8_t type)
{
aspproto_cmd_t * command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
if(!asp.writable)
{
printf("Need to make system writable. Execute 'asp setwritable' first\n");
return false;
}
if ((asp.state != ASP_STATE_INITIALIZED)
&& (asp.state != ASP_STATE_READY)
&& (asp.state != ASP_STATE_ERROR_NOT_REGISTERED))
{
dprintf(DEBUG_CRITICAL, "ASP is not initialized/ready! Current state is %d\n", asp.state);
return false;
}
if ((type == ASP_FORMAT_UTIL)
|| (type == ASP_FORMAT_ALL))
{
command->op = ASPPROTO_CMD_UTIL_FORMAT;
}
else
{
command->op = ASPPROTO_CMD_LBA_FORMAT;
}
if (asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)
{
// NOTE: If format fails, we maintain the last formatted
// status from asp_get_geomtry()
dprintf(DEBUG_CRITICAL, "ASP Format Failed\n");
return false;
}
if (command->op == ASPPROTO_CMD_UTIL_FORMAT)
{
asp.util_formatted = true;
}
asp.lba_formatted = true;
return true;
}
static void output_nand_die_uid(uint8_t *buffer)
{
uint32_t die_idx, bus_idx, byteIdx;
for(bus_idx = 0; bus_idx < nand_info.num_bus; bus_idx++)
{
for(die_idx = 0; die_idx < nand_info.die_per_bus; die_idx++)
{
printf("CE %d: ", bus_idx);
for(byteIdx = 0; byteIdx < ASPPROTO_DEV_ID_LEN_PPN; byteIdx++)
{
printf("%02X ", buffer[(ASPPROTO_DEV_ID_LEN_PPN*(die_idx + bus_idx * nand_info.die_per_bus)) + byteIdx]);
}
printf("\n");
}
}
}
static void output_nand_uid (uint8_t *buffer, uint32_t size, uint32_t parameter)
{
uint32_t Idx, byteIdx;
for(Idx = 0; Idx < size/ASPPROTO_DEV_ID_LEN_PPN; Idx++)
{
printf("CE %d: ", Idx);
for(byteIdx = 0; byteIdx < ASPPROTO_DEV_ID_LEN_PPN; byteIdx++)
{
if(parameter == ASPPROTO_CMD_FW_VERSION)
{
printf("%c", buffer[(ASPPROTO_DEV_ID_LEN_PPN*Idx) + byteIdx]);
}
else
{
printf("%02X ", buffer[(ASPPROTO_DEV_ID_LEN_PPN*Idx) + byteIdx]);
}
}
printf("\n");
}
}
static int asp_nand_get_uid()
{
aspproto_cmd_t * command;
int status;
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_PKG_ASSEMBLY_CODE;
status = asp_send_command(command->tag);
if (status != ASPPROTO_CMD_STATUS_SUCCESS)
{
dprintf(DEBUG_CRITICAL, "Failed to get package assembly code: %d\n", status);
return -1;
}
printf("\nPackage Assembly Code:\n");
output_nand_uid(command->device_id.id, command->device_id.size, ASPPROTO_CMD_PKG_ASSEMBLY_CODE);
command->op = ASPPROTO_CMD_CONTROLLER_UID;
status = asp_send_command(command->tag);
if (status != ASPPROTO_CMD_STATUS_SUCCESS)
{
dprintf(DEBUG_CRITICAL, "Failed to get controller uid: %d\n", status);
return -1;
}
printf("\nController UID:\n");
output_nand_uid(command->device_id.id, command->device_id.size, ASPPROTO_CMD_CONTROLLER_UID);
command->op = ASPPROTO_CMD_CONTROLLER_HWID;
status = asp_send_command(command->tag);
if (status != ASPPROTO_CMD_STATUS_SUCCESS)
{
dprintf(DEBUG_CRITICAL, "Failed to get controller hwid: %d\n", status);
return -1;
}
printf("\nController HWID:\n");
output_nand_uid(command->device_id.id, command->device_id.size, ASPPROTO_CMD_CONTROLLER_HWID);
command->op = ASPPROTO_CMD_FW_VERSION;
status = asp_send_command(command->tag);
if (status != ASPPROTO_CMD_STATUS_SUCCESS)
{
dprintf(DEBUG_CRITICAL, "Failed to get fw version: %d\n", status);
return -1;
}
printf("\nFW Version:\n");
output_nand_uid(command->device_id.id, command->device_id.size, ASPPROTO_CMD_FW_VERSION);
command->op = ASPPROTO_CMD_DIE_UID;
status = asp_send_command(command->tag);
if (status != ASPPROTO_CMD_STATUS_SUCCESS)
{
dprintf(DEBUG_CRITICAL, "Failed to get die uid: %d\n", status);
return -1;
}
printf("\nDie UID:\n");
output_nand_die_uid(command->device_id.id);
return 0;
}
static uint32_t asp_get_link_clk_freq(bool verbose, uint64_t *freq_ptr) {
aspproto_cmd_t * command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
uint8_t *bounce_buffer;
uint32_t paddr32;
bounce_buffer = memalign(sizeof(uint64_t), ASP_NAND_BLK_ALIGNMENT);
if(!bounce_buffer)
{
printf("unable to allocate bounce buffer\n");
return -1;
}
paddr32 = VADDR_TO_PADDR32(bounce_buffer);
command->op = ASPPROTO_CMD_NAND_DEBUG;
command->tunnel.opcode = NAND_DEBUG_GET_LINK_CLK_FREQ;
command->tunnel.buffer_paddr = paddr32;
command->tunnel.bufferLen = sizeof(uint64_t);
#if WITH_NON_COHERENT_DMA
platform_cache_operation(CACHE_CLEAN | CACHE_INVALIDATE, bounce_buffer, CPU_CACHELINE_SIZE);
#endif
if ((asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)){
dprintf(DEBUG_CRITICAL, "Unable to get link clk freq\n");
return -1;
} else {
#if WITH_NON_COHERENT_DMA
platform_cache_operation(CACHE_CLEAN, bounce_buffer, CPU_CACHELINE_SIZE);
#endif
if(verbose)
{
printf("link clk freq: %lld\n", *(uint64_t *)bounce_buffer);
}
}
if(freq_ptr)
{
*freq_ptr = *(uint64_t *)bounce_buffer;
}
return 0;
}
static uint32_t asp_get_perf_ticks(bool verbose, uint64_t *ticks_ptr, uint32_t channel) {
aspproto_cmd_t * command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
uint8_t *bounce_buffer;
uint32_t paddr32;
bounce_buffer = memalign(sizeof(uint64_t), ASP_NAND_BLK_ALIGNMENT);
if(!bounce_buffer)
{
printf("unable to allocate bounce buffer\n");
return -1;
}
paddr32 = VADDR_TO_PADDR32(bounce_buffer);
command->op = ASPPROTO_CMD_NAND_DEBUG;
command->tunnel.opcode = NAND_DEBUG_GET_PERF_TICKS;
command->tunnel.buffer_paddr = paddr32;
command->tunnel.bufferLen = sizeof(uint64_t);
command->tunnel.options.mask = 1 << channel;
#if WITH_NON_COHERENT_DMA
platform_cache_operation(CACHE_CLEAN | CACHE_INVALIDATE, bounce_buffer, CPU_CACHELINE_SIZE);
#endif
if ((asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)){
dprintf(DEBUG_CRITICAL, "Unable to get perf ticks\n");
return -1;
} else {
#if WITH_NON_COHERENT_DMA
platform_cache_operation(CACHE_CLEAN, bounce_buffer, CPU_CACHELINE_SIZE);
#endif
if(verbose)
{
printf("For channel %d, ticks: %lld\n", channel, *(uint64_t *)bounce_buffer);
}
if(verbose && (0 == (*(uint64_t *)bounce_buffer)))
{
printf("Got 0 ticks. Is ANC_ENABLE_TUNNEL_PERF_COUNTER turned ON?\n");
}
}
if(ticks_ptr)
{
*ticks_ptr = *(uint64_t *)bounce_buffer;
}
return 0;
}
static int asp_get_bonfire_get_phy_band_num(uint32_t virtual_band) {
aspproto_cmd_t * command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_CORE_DEBUG;
command->tunnel.core_opcode = CORE_DEBUG_BONFIRE_GET_PHY_BAND_NUM;
command->tunnel.options.value = virtual_band;
if ((asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)){
dprintf(DEBUG_CRITICAL, "Unable to get actual band number\n");
return -1;
}
return command->tunnel.options.value;
}
static uint32_t asp_print_slc_bonfire_bands() {
uint32_t i;
for(i = 0; i < asp.numVirtualSLCBonfireBands; i++) {
printf("virtual band: %d -> actual band: %d\n", i, asp_get_bonfire_get_phy_band_num(i));
}
return 0;
}
static uint32_t asp_reset_perf_ticks() {
aspproto_cmd_t * command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_NAND_DEBUG;
command->tunnel.opcode = NAND_DEBUG_RESET_PERF_TICKS;
command->tunnel.options.mask = (1 << 0) | (1 << 1);
if ((asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)){
dprintf(DEBUG_CRITICAL, "Unable to reset perf ticks\n");
return -1;
}
return 0;
}
static int asp_cbp2r(uint32_t cau, uint32_t block, uint32_t page)
{
aspproto_cmd_t * command;
int status;
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_CBP_TO_ROW_ADDR;
command->addr_xlate.cau = cau;
command->addr_xlate.block = block;
command->addr_xlate.page = page;
status = asp_send_command(command->tag);
if (status != ASPPROTO_CMD_STATUS_SUCCESS)
{
dprintf(DEBUG_CRITICAL, "Failed to get row address: %d\n", status);
return -1;
}
printf("cau: %d, blk: %d, page: %d --> row_addr: 0x%X\n", cau, block, page, command->addr_xlate.row_addr);
return 0;
}
static int asp_l2dbp(uint32_t lba)
{
nand_debug_lba_map_t *lbaMap;
uint32_t paddr32;
uint32_t lbaMapSize;
aspproto_cmd_t * command;
int status;
lbaMap = NULL;
command = NULL;
lbaMapSize = sizeof(nand_debug_lba_map_t);
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
if(!command)
{
return -1;
}
lbaMap = memalign(lbaMapSize, ASP_NAND_BLK_ALIGNMENT);
if(!lbaMap)
{
dprintf(DEBUG_CRITICAL, "Unable to allocate data_buffer\n");
return -1;
}
memset(lbaMap, 0x00, lbaMapSize);
paddr32 = VADDR_TO_PADDR32(lbaMap);
lbaMap->lba = lba;
#if WITH_NON_COHERENT_DMA
platform_cache_operation(CACHE_CLEAN | CACHE_INVALIDATE, lbaMap, ROUNDUPTO(lbaMapSize,CPU_CACHELINE_SIZE));
#endif
command->op = ASPPROTO_CMD_CORE_DEBUG;
command->tunnel.core_opcode = CORE_DEBUG_LBA_TO_PADDR;
command->tunnel.buffer_paddr = paddr32;
command->tunnel.bufferLen = lbaMapSize;
status = asp_send_command(command->tag);
#if WITH_NON_COHERENT_DMA
platform_cache_operation(CACHE_INVALIDATE, lbaMap, ROUNDUPTO(lbaMapSize,CPU_CACHELINE_SIZE));
#endif
if (status != ASPPROTO_CMD_STATUS_SUCCESS)
{
dprintf(DEBUG_CRITICAL, "Failed to get Physical Address for lba: %d\n", lbaMap->lba);
return -1;
}
printf("lba: 0x%x --> band: 0x%x dip: %d bork: 0x%x page: 0x%x\n", lbaMap->lba, lbaMap->band, lbaMap->dip, lbaMap->bork, lbaMap->page);
return 0;
}
static int asp_r2cbp(uint32_t row_addr)
{
aspproto_cmd_t * command;
int status;
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_ROW_ADDR_TO_CBP;
command->addr_xlate.row_addr = row_addr;
status = asp_send_command(command->tag);
if (status != ASPPROTO_CMD_STATUS_SUCCESS)
{
dprintf(DEBUG_CRITICAL, "Failed to get row address: %d\n", status);
return -1;
}
printf("row_addr: 0x%X --> cau: %d, block: %d, page: %d\n", row_addr, command->addr_xlate.cau, command->addr_xlate.block, command->addr_xlate.page);
return 0;
}
static int asp_set_burnin_code(uint32_t burnin_code)
{
aspproto_cmd_t * command;
int status;
if(!asp.writable)
{
printf("Need to make system writable. Execute 'asp setwritable' first\n");
return -1;
}
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_SET_BURNIN_CODE;
command->lba = burnin_code;
status = asp_send_command(command->tag);
return 0;
}
static int asp_set_tlcwritestripes(uint32_t write_stripes)
{
aspproto_cmd_t * command;
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_SETOPTIONS;
command->opts.TLCwriteStripes = write_stripes;
if ((asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)){
dprintf(DEBUG_CRITICAL, "Unable to set tlc writes stripes\n");
return -1;
}
return 0;
}
static int asp_get_burnin_code()
{
aspproto_cmd_t * command;
int status;
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_GET_BURNIN_CODE;
status = asp_send_command(command->tag);
printf("Burnin Code: %d. Status: 0x%X\n", command->lba, status);
return 0;
}
static int asp_get_last_failure()
{
aspproto_cmd_t * command;
int status;
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_GET_LAST_FAILURE;
status = asp_send_command(command->tag);
printf("Type: %d CE: %d, page: 0x%X\n\n", command->last_failure.failure_mode, command->last_failure.ce, command->last_failure.physical_page);
return 0;
}
static int asp_sectors_per_band(uint32_t band, bool verbose)
{
aspproto_cmd_t * command;
int status;
if((band < 1) || (band > asp.lastBand))
{
printf("Band %d not allowed. Please choose a band between 1 and %d\n", band, asp.lastBand);
return -1;
}
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_SECTORS_PER_BAND;
command->lba = band;
status = asp_send_command(command->tag);
if(verbose)
{
printf("Band: %d has %d sectors.\n", band, command->count);
}
return (int)command->count;
}
static int asp_nand_get_addr(uint32_t vba, uint32_t *bus, uint32_t *row_addr, bool verbose)
{
aspproto_cmd_t * command;
int status;
if(vba < nand_info.sec_per_full_band)
{
printf("Cannot decode vba in band 0: should be >= %d\n", nand_info.sec_per_full_band);
return -1;
}
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_GET_ADDR;
command->addr.vba = vba;
status = asp_send_command(command->tag);
if(verbose)
{
printf("vba: %d -> ce: %d, row_addr: 0x%X, cau: %d, column: %d\n", vba, command->addr.ce, command->addr.row_addr, command->addr.cau, command->addr.column);
}
if(bus)
{
*bus = command->addr.ce;
}
if(row_addr)
{
*row_addr = command->addr.row_addr;
}
return 0;
}
static uint32_t get_num_pages_for_sectors(uint32_t sector_offset, uint32_t num_sectors)
{
uint32_t last_sector = (sector_offset + num_sectors);
uint32_t leading_sectors = 0;
uint32_t trailing_sectors = 0;
uint32_t intermediate_sectors = 0;
if(last_sector >= nand_info.sec_per_page)
{
leading_sectors = sector_offset ? (nand_info.sec_per_page - sector_offset) : 0;
}
else
{
leading_sectors = sector_offset ? (last_sector - sector_offset) : 0;
}
if((!sector_offset) || (last_sector > nand_info.sec_per_page))
{
trailing_sectors = last_sector % nand_info.sec_per_page;
}
intermediate_sectors = num_sectors - (leading_sectors + trailing_sectors);
assert(!(intermediate_sectors % nand_info.sec_per_page));
return (leading_sectors ? 1 : 0) + (trailing_sectors ? 1 : 0) + (intermediate_sectors / nand_info.sec_per_page);
}
/*
Description:
Does a physical NAND read without encryption.
Reads are done one physical page at a time.
Output data is arranged as first all data followed by all metadata.
Metadata will be available only at a full page boundary - even for partial page reads.
For partial page reads, output data is arranged as follows:
Example - For a 16k page with a read of 2 4k sectors starting from offset 1,
data will be available as the first 8k, meta will be available at a 16k offset.
*/
static int asp_physical_read(uint32_t bus,
uint32_t ce,
uint32_t row_addr,
uint32_t sector_offset,
uint32_t num_sectors,
nand_debug_health_monitoring_e health_monitoring,
aspproto_cell_type_t cell_type,
uint8_t * buffer,
bool verbose,
int *status_ptr)
{
aspproto_cmd_t *command = 0;
int status = 0;
uint8_t *bounce_buffer = NULL;
uint32_t paddr32 = 0;
const uint32_t main_size = ASP_NAND_BLKSZ * nand_info.sec_per_page;
const uint32_t meta_size = nand_info.sec_per_page * METADATA_PER_LBA;
const uint32_t num_pages = get_num_pages_for_sectors(sector_offset, num_sectors);
const uint32_t kB_sectors_per_page = main_size / 1024;
uint32_t bytes_per_read = main_size + meta_size;
uint32_t sectors_remaining = num_sectors;
uint32_t offset_cursor = sector_offset;
uint32_t sectors_for_current_page;
uint8_t *data_cursor = buffer;
uint8_t *meta_cursor = buffer + (num_pages * main_size);
uint32_t current_row_addr = row_addr;
uint8_t *buf_stats_cursor = NULL;
uint32_t idx = 0;
uint8_t *value_ptr;
uint64_t perf_ticks;
uint64_t link_clk_freq;
if(0 != asp_reset_perf_ticks())
{
return -1;
}
if((sector_offset > (nand_info.sec_per_page - 1)))
{
printf("sector offset allowed to be only between 0 and %d\n", nand_info.sec_per_page - 1);
return -1;
}
if((NAND_DEBUG_HEALTH_MONITORING_NONE != health_monitoring) && ((sector_offset != 0) || (num_sectors % nand_info.sec_per_page)))
{
printf("health monitoring reads are allowed only for full pages\n");
return -1;
}
if(NAND_DEBUG_HEALTH_MONITORING_COUNT <= health_monitoring)
{
printf("invalid health monitoring option\n");
return -1;
}
if(NAND_DEBUG_HEALTH_MONITORING_NONE != health_monitoring)
{
if (!security_allow_memory(buffer, num_pages * kB_sectors_per_page))
{
printf("Permission Denied\n");
return -1;
}
memset(buffer, 0xA5, num_pages * kB_sectors_per_page);
bytes_per_read = kB_sectors_per_page;
}
else
{
if (!security_allow_memory(buffer, num_pages * bytes_per_read))
{
printf("Permission Denied\n");
return -1;
}
memset(buffer, 0xA5, num_pages * bytes_per_read);
}
bounce_buffer = memalign(bytes_per_read, 4096);
if(!bounce_buffer)
{
dprintf(DEBUG_CRITICAL, "Failed to allocate data buffer\n");
return -1;
}
paddr32 = VADDR_TO_PADDR32(bounce_buffer);
while(sectors_remaining)
{
if (NAND_DEBUG_HEALTH_MONITORING_IN_DEPTH == health_monitoring) {
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_NAND_DEBUG;
command->tunnel.opcode = NAND_DEBUG_ENABLE_IN_DEPTH_HEALTH;
command->tunnel.buffer_paddr = 0;
command->tunnel.bufferLen = 0;
command->tunnel.options.mask = ((1<<ANC_MAX_BUSSES)-1) & (1 << bus);
if ((asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)) {
dprintf(DEBUG_CRITICAL, "Error enabling depth health monitoring for channel %d rowAddr: 0x%x\n", bus, current_row_addr);
}
}
if((offset_cursor % nand_info.sec_per_page) && ((sector_offset + sectors_remaining) > nand_info.sec_per_page))
{
sectors_for_current_page = (offset_cursor % nand_info.sec_per_page) ? (nand_info.sec_per_page - sector_offset) : 0;
}
else
{
sectors_for_current_page = ((sectors_remaining < nand_info.sec_per_page) ? sectors_remaining : nand_info.sec_per_page);
}
memset(bounce_buffer, 0xC7, bytes_per_read);
#if WITH_NON_COHERENT_DMA
platform_cache_operation(CACHE_CLEAN | CACHE_INVALIDATE, bounce_buffer, ROUNDUPTO(bytes_per_read,CPU_CACHELINE_SIZE));
#endif
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_NAND_DEBUG;
command->tunnel.opcode = NAND_DEBUG_READ;
command->tunnel.buffer_paddr = paddr32;
command->tunnel.bufferLen = bytes_per_read;
command->tunnel.options.debug_epr_info.bus = bus;
command->tunnel.options.debug_epr_info.ce = ce;
command->tunnel.options.debug_epr_info.row_addr = current_row_addr;
command->tunnel.options.debug_epr_info.num_sectors = sectors_for_current_page;
command->tunnel.options.debug_epr_info.sector_offset = offset_cursor % nand_info.sec_per_page;
command->tunnel.options.debug_epr_info.health_monitoring = health_monitoring;
command->tunnel.options.debug_epr_info.cell_type = cell_type;
command->tunnel.options.mask = 1 << bus;
command->flags.all = 0;
command->flags.noAesKey = 1;
status = asp_send_command(command->tag);
#if WITH_NON_COHERENT_DMA
platform_cache_operation(CACHE_INVALIDATE, bounce_buffer, ROUNDUPTO(bytes_per_read,CPU_CACHELINE_SIZE));
#endif
if(verbose)
{
printf("Bus: %01d, ce: %02d, row_addr: 0x%08X, num_sectors: %02d, sector_offset: %02d. Status: %02d\t", bus, ce, current_row_addr, sectors_for_current_page, (offset_cursor % nand_info.sec_per_page), status);
}
if(status_ptr)
{
*status_ptr = status;
}
if(NAND_DEBUG_HEALTH_MONITORING_SECTOR_STATS == health_monitoring)
{
// display sector stats
printf("Bitflips: ");
buf_stats_cursor = bounce_buffer;
for(idx = 0; idx < kB_sectors_per_page; idx++)
{
printf("%02X ", *buf_stats_cursor);
buf_stats_cursor++;
}
memcpy(data_cursor, bounce_buffer, kB_sectors_per_page);
data_cursor += kB_sectors_per_page;
}
else if (NAND_DEBUG_HEALTH_MONITORING_IN_DEPTH == health_monitoring)
{
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_NAND_DEBUG;
command->tunnel.opcode = NAND_DEBUG_GET_IN_DEPTH_HEALTH;
command->tunnel.buffer_paddr = 0;
command->tunnel.bufferLen = 0;
command->tunnel.options.mask = ((1<<ANC_MAX_BUSSES)-1) & (1 << bus);
command->tunnel.options.value = 0;
if ((asp_send_command(command->tag) == ASPPROTO_CMD_STATUS_SUCCESS)) {
value_ptr = (uint8_t*) &(command->tunnel.options.value);
printf("Correctability: 0x%x tR-Status: 0x%x",value_ptr[0], value_ptr[1]);
} else {
dprintf(DEBUG_CRITICAL, "Error pulling in depth health monitoring for channel %d rowAddr: 0x%x\n", bus, current_row_addr);
}
}
else
{
memcpy(data_cursor, bounce_buffer, main_size);
memcpy(meta_cursor, (bounce_buffer + main_size), meta_size);
data_cursor += main_size;
meta_cursor += meta_size;
}
if(verbose)
{
printf("\n");
}
sectors_remaining -= sectors_for_current_page;
offset_cursor += sectors_for_current_page;
current_row_addr++;
}
if(verbose)
{
asp_print_status_key();
}
if(0 != asp_get_perf_ticks(false, &perf_ticks, bus))
{
return -1;
}
if(0 != asp_get_link_clk_freq(false, &link_clk_freq))
{
return -1;
}
printf("%u bytes transferred in %llu ticks @ %llu Hz\n\n", (num_sectors * ASP_NAND_BLKSZ),
perf_ticks,
link_clk_freq);
printf("To calculate total throughput in MiB/s: (%u * %llu) / (%llu * 1024 * 1024)\n\n", (num_sectors * ASP_NAND_BLKSZ),
link_clk_freq,
perf_ticks);
printf("Total time taken in us: (%llu) / (%llu / 1000000)\n\n", perf_ticks, link_clk_freq);
printf("Note: This is actual bus utilization with very minimal SW overhead. This command uses only 1 channel at a time\n");
free(bounce_buffer);
return 0;
}
static int asp_read_pagemeta(uint32_t bus, uint32_t ce, uint32_t row_addr, uint32_t num_pages, uint8_t * buffer)
{
uint32_t page_idx = 0;
const uint32_t main_size = ASP_NAND_BLKSZ * nand_info.sec_per_page;
const uint32_t meta_size = nand_info.sec_per_page * METADATA_PER_LBA;
uint8_t *meta_cursor = buffer + (num_pages * main_size);
asp_physical_read(bus, ce, row_addr, 0, (num_pages * nand_info.sec_per_page), false, CELL_TYPE_IS_MLC, buffer, false, NULL);
printf("LBA tokens:\n");
for(page_idx = row_addr; page_idx < row_addr + num_pages; page_idx++)
{
printf("Bus:%01d, ce:%02d, row_addr:0x%08X\t", bus, ce, page_idx);
printf("Meta: %08X %08X %08X %08X\n", *((uint32_t*)meta_cursor), *((uint32_t*)meta_cursor + 4), *((uint32_t*)meta_cursor + 8), *((uint32_t*)meta_cursor + 12));
meta_cursor += meta_size;
}
return 0;
}
static int asp_read_bandmeta(uint32_t band, uint8_t * buffer, bool verbose)
{
uint32_t page_idx = 0;
const uint32_t main_size = ASP_NAND_BLKSZ * nand_info.sec_per_page;
const uint32_t meta_size = nand_info.sec_per_page * METADATA_PER_LBA;
const uint32_t sectors_per_band = asp_sectors_per_band(band, false);
const uint32_t pages_per_band = sectors_per_band / nand_info.sec_per_page;
uint32_t vba = band * nand_info.sec_per_full_band;
uint8_t *meta_cursor = buffer;
uint32_t row_addr = 0;
uint32_t bus = 0;
uint8_t *page_buffer = NULL;
if (!security_allow_memory(buffer, meta_size * pages_per_band))
{
printf("Permission Denied\n");
return -1;
}
memset(buffer, 0xA5, meta_size * pages_per_band);
page_buffer = memalign((main_size + meta_size), 4096);
if(!page_buffer)
{
printf("could not allocate page buffer\n");
return -1;
}
if(verbose)
{
printf("LBA tokens:\n");
}
for(page_idx = 0; page_idx < pages_per_band; page_idx++)
{
asp_nand_get_addr (vba, &bus, &row_addr, false);
asp_physical_read(bus, 0, row_addr, 0, nand_info.sec_per_page, false, CELL_TYPE_IS_MLC, page_buffer, false, NULL);
memcpy(meta_cursor, page_buffer + main_size, meta_size);
if(verbose)
{
printf("Bus:%01d, ce:%02d, row_addr:0x%08X\t", bus, 0, row_addr);
printf("Meta: %08X %08X %08X %08X\n", *((uint32_t*)meta_cursor), *((uint32_t*)meta_cursor + (1 * LBA_TOKEN_SIZE)), *((uint32_t*)meta_cursor + (2 * LBA_TOKEN_SIZE)), *((uint32_t*)meta_cursor + (3 * LBA_TOKEN_SIZE)));
}
vba += nand_info.sec_per_page;
meta_cursor += meta_size;
}
free(page_buffer);
return 0;
}
static int audit_blog(uint32_t band, uint8_t *buffer, uint32_t num_leafs, bool verbose)
{
const uint32_t sectors_per_band = asp_sectors_per_band(band, false);
const uint32_t pages_per_band = sectors_per_band / nand_info.sec_per_page;
BlogE_t *blog_buffer = (BlogE_t *)buffer;
uint32_t current_lba_token;
uint32_t current_size;
uint32_t *lba_token_buffer = NULL;
uint32_t max_blog_entries = 0;
uint32_t blog_entry_idx = 0;
uint32_t *lba_token_cursor = NULL;
uint32_t size_idx;
uint32_t boff_idx = 0;
int status = 0;
assert(buffer);
printf("Auditing Blog entries against LBA's in NAND...\n");
lba_token_buffer = (uint32_t *)malloc(nand_info.sec_per_page * METADATA_PER_LBA * pages_per_band);
if(!lba_token_buffer)
{
printf("Unable to allocate memory for lba token buffer\n");
return -1;
}
if(asp_read_bandmeta(band, (uint8_t *)lba_token_buffer, false))
{
free(lba_token_buffer);
return -1;
}
lba_token_cursor = lba_token_buffer;
max_blog_entries = (num_leafs * ASP_NAND_BLKSZ) / sizeof(BlogE_t);
for(blog_entry_idx = 0; blog_entry_idx < max_blog_entries; blog_entry_idx++)
{
current_lba_token = blog_buffer[blog_entry_idx].lba;
current_size = blog_buffer[blog_entry_idx].size;
if((blog_entry_idx % (ASP_NAND_BLKSZ / sizeof(BlogE_t))) == ((ASP_NAND_BLKSZ / sizeof(BlogE_t)) - 1))
{
if(verbose)
{
printf("End of leaf.\n");
}
assert(current_lba_token == TOKEN_TERMINATOR);
continue;
}
else if(current_lba_token == TOKEN_TERMINATOR)
{
if(verbose)
{
printf("End of blog.\n");
}
break;
}
assert(current_size <= sectors_per_band);
for(size_idx = 0; size_idx < current_size; size_idx++)
{
if(verbose)
{
printf("Blog Entry idx: %04d, Blog Entry LBA: 0x%08X, LBA in NAND: 0x%08X. Boff: %04d\n", blog_entry_idx, current_lba_token, *lba_token_cursor, boff_idx);
}
if((current_lba_token >= LBA_TOKEN_BASE) && (current_lba_token != LBA_TOKEN_BLOG))
{
//Page pads are written slightly differently in NAND and Blog
current_lba_token = LBA_TOKEN_BASE;
}
if(current_lba_token != *lba_token_cursor)
{
printf("Audit failed. Blog says LBA: 0x%08X. NAND says LBA: 0x%08X. boff: %d (vba: %d)\n", current_lba_token, *lba_token_cursor, boff_idx, ((band * nand_info.sec_per_full_band) + boff_idx));
status = -1;
}
lba_token_cursor += LBA_TOKEN_SIZE;
current_lba_token++;
boff_idx++;
}
}
if(status)
{
printf("Audit failed\n");
}
else
{
printf("Audit passed\n");
}
free(lba_token_buffer);
return status;
}
//Dumps the blog and optionally audits if all LBA's in band correspond to blog entries.
static int asp_dump_blog(uint32_t band, uint8_t * buffer, bool audit, bool verbose)
{
const uint32_t main_size = ASP_NAND_BLKSZ * nand_info.sec_per_page;
const uint32_t meta_size = nand_info.sec_per_page * METADATA_PER_LBA;
const uint32_t sectors_per_band = asp_sectors_per_band(band, true);
const uint32_t max_blog_size = sectors_per_band * sizeof(BlogE_t);
const uint32_t max_possible_leafs = (max_blog_size / ASP_NAND_BLKSZ) + 1;
uint32_t *leaf_ptr;
uint32_t vba = band * nand_info.sec_per_full_band;
uint32_t blogdir_vba;
uint32_t row_addr = 0;
uint32_t bus = 0;
uint32_t lba_token;
uint32_t expected_lba_offset = 0;
uint32_t num_leafs = 0;
uint32_t status = 0;
uint8_t *page_buffer = NULL;
bool audit_allowed = true;
int lba_status = ASPPROTO_CMD_STATUS_SUCCESS;
if (!security_allow_memory(buffer, max_blog_size))
{
printf("Permission Denied\n");
return -1;
}
memset(buffer, 0xA5, max_blog_size);
page_buffer = memalign((main_size + meta_size), 4096);
if(!page_buffer)
{
printf("Could not allocate page buffer\n");
return -1;
}
leaf_ptr = malloc(max_possible_leafs * sizeof(uint32_t));
if(!leaf_ptr)
{
printf("Could not allocate leaf pointer array\n");
return -1;
}
//Blog always starts at last sector of band.
vba = vba + sectors_per_band - 1;
blogdir_vba = vba;
asp_nand_get_addr(vba , &bus, &row_addr, false);
expected_lba_offset = vba % nand_info.sec_per_page;
//Physical read of the Blog sector
asp_physical_read(bus, 0, row_addr, expected_lba_offset, 1, false, CELL_TYPE_IS_MLC, page_buffer, false, &lba_status);
if(lba_status != ASPPROTO_CMD_STATUS_SUCCESS)
{
printf("Received a non-success status: %d when reading bus: %d, ce: %d, row_addr: 0x%X, lba offset: %d\n", lba_status, bus, 0, row_addr, expected_lba_offset);
asp_print_status_key();
audit_allowed = false;
goto FreeMemory;
}
lba_token = *((uint32_t*)(page_buffer + main_size));
if(lba_token < LBA_TOKEN_BASE)
{
BlogE_t *ptr = (BlogE_t *)page_buffer;
ptr[0].lba = lba_token - (sectors_per_band - 1);
ptr[0].size = sectors_per_band;
ptr[1].lba = TOKEN_TERMINATOR;
ptr[1].size = 0;
num_leafs = 1;
printf("No blog. The entrire band was written sequentially. lba 0x%x size 0x%x\n ", ptr[0].lba, ptr[0].size);
memcpy(buffer, page_buffer, ASP_NAND_BLKSZ);
}
else
{
if (LBA_TOKEN_BLOG == lba_token)
{
BlogE_t *ptr = (BlogE_t *)page_buffer;
nob_t *nobPtr;
uint32_t i, j;
ptr += BLOG_NUM_ENTRY;
nobPtr = (nob_t*)ptr;
nobPtr--;
i = nobPtr->all;
nobPtr -= i;
printf("Number of leafs is %d\n",i);
num_leafs = i;
if(i == 1)
{
ptr -= BLOG_NUM_ENTRY;
memcpy(buffer, page_buffer, ASP_NAND_BLKSZ);
j = 0;
while (( ptr[j].lba != TOKEN_TERMINATOR) && (ptr[j].size != 0))
{
printf("lba 0x%x count 0x%x\n", ptr[j].lba,ptr[j].size);
j++;
}
}
else
{
nob_t *dir = malloc(sizeof(nob_t) * i);
uint32_t dir_no = i;
if(dir)
{
memcpy(dir, nobPtr, sizeof(nob_t) * dir_no);
}
else
{
printf("cannot allocate memory . getting out\n");
goto FreeMemory;
}
for(j = 0; j < num_leafs; j ++)
{
vba = (dir[j].band * nand_info.sec_per_full_band) + dir[j].boff;
asp_nand_get_addr(vba , &bus, &row_addr, false);
expected_lba_offset = vba % nand_info.sec_per_page;
//Physical read of the Blog sector
asp_physical_read(bus, 0, row_addr, expected_lba_offset, 1, false, CELL_TYPE_IS_MLC, page_buffer, false, &lba_status);
if(lba_status != ASPPROTO_CMD_STATUS_SUCCESS)
{
printf("Received a non-success status: %d when reading bus: %d, ce: %d, row_addr: 0x%X, lba offset: %d\n", lba_status, bus, 0, row_addr, expected_lba_offset);
asp_print_status_key();
audit_allowed = false;
free(dir);
goto FreeMemory;
}
memcpy(buffer + (j * ASP_NAND_BLKSZ), page_buffer, ASP_NAND_BLKSZ);
ptr = (BlogE_t *)page_buffer;
while (( ptr[i].lba != TOKEN_TERMINATOR) && (ptr[i].size != 0))
{
printf("lba 0x%x count 0x%x\n", ptr[i].lba,ptr[i].size);
i++;
}
}
free(dir);
}
}
else
{
goto FreeMemory;
}
}
printf("%d bytes of Blog dumped to %p\n", (num_leafs * ASP_NAND_BLKSZ), buffer);
if(audit && audit_allowed)
{
status = audit_blog(band, buffer, num_leafs, verbose);
}
FreeMemory :
free(page_buffer);
free(leaf_ptr);
return status;
}
static uint32_t asp_istlc(bool verbose) {
aspproto_cmd_t * command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_NAND_DEBUG;
command->tunnel.opcode = NAND_DEBUG_ISTLC;
if ((asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)){
dprintf(DEBUG_CRITICAL, "Unable to get if device is TLC\n");
return -1;
} else {
if(verbose)
{
printf("istlc: %d\n", command->tunnel.options.value);
}
return command->tunnel.options.value;
}
}
static uint32_t get_rma_chunk(uint32_t channel, uint32_t startPage, uint8_t *bounceBuffer, uint32_t buffLen) {
uint32_t paddr32;
paddr32 = VADDR_TO_PADDR32(bounceBuffer);
memset(bounceBuffer, 0xA5, buffLen);
aspproto_cmd_t * command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_NAND_DEBUG;
command->tunnel.opcode = NAND_DEBUG_GET_RMA_DATA;
command->tunnel.buffer_paddr = paddr32;
command->tunnel.bufferLen = buffLen;
command->tunnel.options.mask = ((1<<ANC_MAX_BUSSES)-1) & (1 << channel);
command->tunnel.options.value = startPage;
#if WITH_NON_COHERENT_DMA
platform_cache_operation(CACHE_CLEAN | CACHE_INVALIDATE, bounceBuffer, ROUNDUPTO(buffLen,CPU_CACHELINE_SIZE));
#endif
if ((asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)){
dprintf(DEBUG_CRITICAL, "Unable to pull rma data for channel %d\n",channel);
return -1;
}
#if WITH_NON_COHERENT_DMA
platform_cache_operation(CACHE_INVALIDATE, bounceBuffer, ROUNDUPTO(buffLen,CPU_CACHELINE_SIZE));
#endif
return 0;
}
static uint32_t asp_recover() {
aspproto_cmd_t * command;
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_NAND_DEBUG;
command->tunnel.opcode = NAND_DEBUG_RECOVER;
command->tunnel.buffer_paddr = 0;
command->tunnel.bufferLen = 0;
if ((asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)) {
dprintf(DEBUG_CRITICAL, "Unable to recover NAND\n");
return -1;
}
printf("NAND recovered\n");
return 0;
}
static uint32_t asp_rma_delete(uint32_t channel) {
aspproto_cmd_t * command;
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_NAND_DEBUG;
command->tunnel.opcode = NAND_DEBUG_DELETE_RMA_DATA;
command->tunnel.buffer_paddr = 0;
command->tunnel.bufferLen = 0;
command->tunnel.options.mask = ((1<<ANC_MAX_BUSSES)-1) & (1 << channel);
if ((asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)) {
dprintf(DEBUG_CRITICAL, "Unable to delete rma data for channel %d\n",channel);
return -1;
}
printf("RMA deleted from channel %d\n",channel);
return 0;
}
static uint32_t asp_rma_configure(uint32_t channel, uint32_t mask) {
aspproto_cmd_t * command;
mask &= 0x0F;
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_NAND_DEBUG;
command->tunnel.opcode = NAND_DEBUG_CONFIGURE_RMA_DATA;
command->tunnel.buffer_paddr = 0;
command->tunnel.bufferLen = 0;
command->tunnel.options.mask = ((1<<ANC_MAX_BUSSES)-1) & (1 << channel);
command->tunnel.options.value = mask;
if ((asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)) {
dprintf(DEBUG_CRITICAL, "Unable to configure rma data for channel %d with mask 0x%x\n", channel, mask);
return -1;
}
printf("RMA configured on channel %d with mask 0x%x\n",channel,mask);
return 0;
}
static uint32_t asp_rma_set(uint32_t channel) {
aspproto_cmd_t * command;
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_NAND_DEBUG;
command->tunnel.opcode = NAND_DEBUG_TRIGGER_RMA_DATA;
command->tunnel.buffer_paddr = 0;
command->tunnel.bufferLen = 0;
command->tunnel.options.mask = ((1<<ANC_MAX_BUSSES)-1) & (1 << channel);
if ((asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)) {
dprintf(DEBUG_CRITICAL, "Unable to set RMA data for channel %d\n", channel);
return -1;
}
printf("Set RMA data with address FFh FFh FFh on channel %d\n",channel);
return 0;
}
static uint32_t asp_rma_get(uint32_t channel, char *destFile, uint32_t *failure_type) {
aspproto_cmd_t * command;
uint8_t *bounceBuffer;
uint32_t buffLen;
uint32_t startPage;
uint32_t totalPages;
uint32_t pagesRemaining;
uint32_t numPages;
uint32_t chunkSize;
uint32_t paddr32;
uint32_t status;
buffLen = sizeof(nand_debug_failure_info_t);
bounceBuffer = memalign(buffLen, 4096);
if(!bounceBuffer)
{
dprintf(DEBUG_CRITICAL, "Failed to allocate data buffer\n");
return -1;
}
paddr32 = VADDR_TO_PADDR32(bounceBuffer);
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_NAND_DEBUG;
command->tunnel.opcode = NAND_DEBUG_GET_FAILURE_INFO;
command->tunnel.buffer_paddr = paddr32;
command->tunnel.bufferLen = buffLen;
command->tunnel.options.mask = ((1<<ANC_MAX_BUSSES)-1) & (1 << channel);
#if WITH_NON_COHERENT_DMA
platform_cache_operation(CACHE_CLEAN | CACHE_INVALIDATE, bounceBuffer, ROUNDUPTO(buffLen,CPU_CACHELINE_SIZE));
#endif
if ((asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)) {
dprintf(DEBUG_CRITICAL, "Unable to trigger Debug Data for channel %d\n",channel);
free(bounceBuffer);
return -1;
}
#if WITH_NON_COHERENT_DMA
platform_cache_operation(CACHE_INVALIDATE, bounceBuffer, ROUNDUPTO(buffLen,CPU_CACHELINE_SIZE));
#endif
if (NULL != destFile) {
startPage = ((nand_debug_failure_info_t *)bounceBuffer)->start_page;
totalPages = ((nand_debug_failure_info_t *)bounceBuffer)->page_len;
if (NULL != failure_type) {
*failure_type = ((nand_debug_failure_info_t *)bounceBuffer)->failure_type;
}
//pull the debug data pages
buffLen = MAX_RMA_CHUNK_PAGES * PERFECT_PAGE_SIZE;
free(bounceBuffer);
bounceBuffer = memalign(buffLen, 4096);
if(!bounceBuffer) {
dprintf(DEBUG_CRITICAL, "Failed to allocate data buffer\n");
return -1;
}
printf("\033[1;31m"); // change font color to red & bold
for (pagesRemaining = totalPages; pagesRemaining > 0; pagesRemaining -= numPages) {
printf("Status: %d%%, Pages: %d/%d ", (totalPages - pagesRemaining) * 100 / totalPages, totalPages - pagesRemaining, totalPages);
numPages = MIN(pagesRemaining,MAX_RMA_CHUNK_PAGES);
chunkSize = numPages * PERFECT_PAGE_SIZE;
if (get_rma_chunk(channel, startPage, bounceBuffer, chunkSize) != 0) {
break;
}
addr_t loadAddr = env_get_uint("loadaddr", DEFAULT_LOAD_ADDRESS);
memcpy( ((void*)loadAddr),bounceBuffer,chunkSize);
status = usb_send_data_to_file(destFile, chunkSize, loadAddr, 0);
if (status) {
printf("usb_cmd_put failed ret = 0x%x\n", status);
printf("\033[0m\n"); // change font color back to default
free(bounceBuffer);
return -1;
}
startPage += numPages;
printf("\033[0E\033[2K"); // go to start of line and erase the line respectively
}
printf("Status: %d%%, Pages: %d/%d", (totalPages - pagesRemaining) * 100 / totalPages, totalPages - pagesRemaining, totalPages);
printf("\033[0m\n"); // change font color back to default
}
asp_recover();
free(bounceBuffer);
return 0;
}
static uint32_t asp_ppn_get_calibration(char *destFile) {
aspproto_cmd_t * command;
uint8_t *bounceBuffer;
uint32_t buffLen;
uint32_t paddr32;
uint32_t status;
buffLen = PERFECT_PAGE_SIZE;
bounceBuffer = memalign(buffLen, 4096);
if(!bounceBuffer)
{
dprintf(DEBUG_CRITICAL, "Failed to allocate data buffer\n");
return -1;
}
paddr32 = VADDR_TO_PADDR32(bounceBuffer);
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_NAND_DEBUG;
command->tunnel.opcode = NAND_DEBUG_GET_CALIBRATION;
command->tunnel.buffer_paddr = paddr32;
command->tunnel.bufferLen = buffLen;
command->tunnel.options.mask = ((1<<ANC_MAX_BUSSES)-1) & (1 << 0);
#if WITH_NON_COHERENT_DMA
platform_cache_operation(CACHE_CLEAN | CACHE_INVALIDATE, bounceBuffer, buffLen);
#endif
if ((asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)) {
dprintf(DEBUG_CRITICAL, "Unable to get calibration data\n");
free(bounceBuffer);
return -1;
}
#if WITH_NON_COHERENT_DMA
platform_cache_operation(CACHE_INVALIDATE, bounceBuffer, buffLen);
#endif
addr_t loadAddr = env_get_uint("loadaddr", DEFAULT_LOAD_ADDRESS);
memcpy( ((void*)loadAddr),bounceBuffer,buffLen);
if (NULL != destFile) {
status = usb_send_data_to_file(destFile, buffLen, loadAddr, 0);
if (status) {
printf("usb_cmd_put failed ret = 0x%x\n", status);
free(bounceBuffer);
return -1;
}
} else {
printf("PPN calibration data extraced to address %p. Save to host by running 'usb put <filename> %u'\n",
(void *)loadAddr, buffLen);
}
free(bounceBuffer);
return 0;
}
static uint32_t asp_vth_sweep(uint32_t channel, uint32_t cau, uint32_t block, char *destFile)
{
aspproto_cmd_t * command;
uint32_t rowAddr;
uint32_t status;
uint32_t failure_type;
// bounds check the parameters
if (channel >= nand_info.num_bus || cau >= (nand_info.cau_per_die * nand_info.die_per_bus) || block >= nand_info.num_bands) {
printf("Invalid parameter. Max bus=%d \n", nand_info.num_bus);
return -1;
}
// get manufID to check for supported vendor
if ((asp.mfg_id[0][0] != VENDOR_CODE__HYNIX) && (asp.mfg_id[0][0] != VENDOR_CODE__SANDISK) && (asp.mfg_id[0][0] != VENDOR_CODE__MICRON)) {
printf("Vendor 0x%x not supported!\n", asp.mfg_id[0][0]);
return -1;
}
// get the row address
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_CBP_TO_ROW_ADDR;
command->addr_xlate.cau = cau;
command->addr_xlate.block = block;
command->addr_xlate.page = 0;
status = asp_send_command(command->tag);
if (status != ASPPROTO_CMD_STATUS_SUCCESS) {
dprintf(DEBUG_CRITICAL, "Failed to get row address: %d\n", status);
return -1;
}
rowAddr = command->addr_xlate.row_addr;
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_NAND_DEBUG;
command->tunnel.opcode = NAND_DEBUG_VTH_SWEEP;
command->tunnel.buffer_paddr = 0;
command->tunnel.bufferLen = 0;
command->tunnel.options.mask = ((1<<ANC_MAX_BUSSES)-1) & (1 << channel);
command->tunnel.options.value = rowAddr;
if ((asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)) {
dprintf(DEBUG_CRITICAL, "Unable to perform Vth sweep for channel %d\n",channel);
return -1;
}
status = asp_rma_get(channel, destFile, &failure_type);
if (0 != status) {
printf("Vth sweep failed to get RMA data\n");
return -1;
}
if (PPN_GEB_TYPE_VTHSWEEP != failure_type) {
printf("Vth sweep expected failure type 0x%X, received 0x%X\n", PPN_GEB_TYPE_VTHSWEEP, failure_type);
return -1;
}
return 0;
}
static uint32_t find_sectors_per_stripe (uint32_t sectors_per_band)
{
const uint32_t sec_per_dip = nand_info.sec_per_full_band / nand_info.num_dip;
return (sectors_per_band / sec_per_dip) * nand_info.sec_per_page;
}
#define DEBUG_LARGE_HEAP_HACK (0)
#if DEBUG_LARGE_HEAP_HACK
//***HACK: iBoot does not support such a large heap.
// However it has a large hole of free unmanaged memory below IBOOT_BASE (defined in memmap.h)
// Define IBOOT_HACK_ADDR well below IBOOT_BASE and use it.
#define IBOOT_HACK_ADDR (0x8397FB000) //currently set to 64MB below IBOOT_BASE
#endif // #if DEBUG_LARGE_HEAP_HACK
static int asp_bonfire_write_band(uint32_t band, aspproto_cell_type_t cell_type, bool random_pattern, uint32_t data_pattern)
{
uint8_t *dataBuf = NULL;
uint32_t paddr32;
aspproto_cmd_t * command;
int status;
uint32_t sectors_per_band;
uint32_t band_size;
uint32_t i;
if((band < 1) || (band > asp.lastBand))
{
printf("Band %d not allowed. Please choose a band between 1 and %d\n", band, asp.lastBand);
return -1;
}
sectors_per_band = (uint32_t) asp_sectors_per_band(band, false);
if(0 == sectors_per_band)
{
printf("Cannot program band - It has 0 good sectors.\n");
return -1;
}
band_size = sectors_per_band * ASP_NAND_BLKSZ;
#if DEBUG_LARGE_HEAP_HACK
dataBuf = (uint8_t *)IBOOT_HACK_ADDR;
#else
// Provide a 4k buffer which will be written for the entire band.
band_size = ASP_NAND_BLKSZ;
dataBuf = memalign(band_size, ASP_NAND_BLK_ALIGNMENT);
#endif //#if DEBUG_LARGE_HEAP_HACK
if(!dataBuf)
{
printf("could not allocate stats buffer\n");
return -1;
}
assert((band_size % sizeof(data_pattern)) == 0);
for(i = 0; i < band_size / sizeof(data_pattern); i++)
{
if(!random_pattern)
{
((uint32_t *)dataBuf)[i] = data_pattern;
}
else
{
((uint32_t *)dataBuf)[i] = rand();
}
}
paddr32 = VADDR_TO_PADDR32(dataBuf);
command = asp_get_cmd_for_tag(ASP_TAG_NAND);
command->op = ASPPROTO_CMD_CORE_DEBUG;
command->tunnel.core_opcode = CORE_DEBUG_WRITE_BAND;
command->tunnel.buffer_paddr = (uint64_t) paddr32;
command->tunnel.bufferLen = band_size;
command->tunnel.options.outputLen = 0;
command->tunnel.options.debug_epr_info.band = band;
command->tunnel.options.debug_epr_info.cell_type = cell_type;
command->flags.all = 0;
command->flags.noAesKey = 1;
status = asp_send_command(command->tag);
if (status != ASPPROTO_CMD_STATUS_SUCCESS)
{
dprintf(DEBUG_CRITICAL, "ERROR: Could not write band. Error: %d\n\n", status);
asp_print_status_key();
return -1;
}
#if !DEBUG_LARGE_HEAP_HACK
free(dataBuf);
#endif //#if DEBUG_LARGE_HEAP_HACK
return 0;
}
static int asp_bonfire_erase_band(uint32_t band)
{
aspproto_cmd_t * command;
int status;
if((band < 1) || (band > asp.lastBand))
{
printf("Band %d not allowed. Please choose a band between 1 and %d\n", band, asp.lastBand);
return -1;
}
if(!asp.writable)
{
printf("Need to make system writable. Execute 'asp setwritable' first\n");
return -1;
}
command = asp_get_cmd_for_tag(ASP_TAG_NAND);
command->op = ASPPROTO_CMD_BONFIRE_ERASE;
command->lba = band;
status = asp_send_command(command->tag);
printf("Band: %d erase status: 0x%X. \n", band, status);
return 0;
}
static aspproto_nand_col_t asp_get_single_dip_info(uint32_t dip)
{
aspproto_cmd_t * command;
int status;
command = asp_get_cmd_for_tag(ASP_TAG_NAND);
command->op = ASPPROTO_CMD_GET_DIP_INFO;
command->lba = dip;
status = asp_send_command(command->tag);
if (status != ASPPROTO_CMD_STATUS_SUCCESS)
{
printf("Error getting info for dip %d. status: 0x%X\n", dip, status);
}
return command->dip_info;
}
static int asp_get_all_dip_info(void)
{
uint32_t i = 0;
aspproto_nand_col_t dip_info;
for(i = 0; i < nand_info.num_dip; i++)
{
dip_info = asp_get_single_dip_info(i);
printf("dip: %d - bus: %d, ce: %d, cau: %d\n", i, dip_info.bus, dip_info.ce, dip_info.cau);
}
return 0;
}
static int asp_dbp2r(uint32_t dip, uint32_t bork, uint32_t page)
{
aspproto_nand_col_t dip_info;
aspproto_cmd_t * command;
int status;
if(dip < nand_info.num_dip)
{
dip_info = asp_get_single_dip_info(dip);
}
else
{
dprintf(DEBUG_CRITICAL, "dip: %d exceeds maximum number of dips: %d\n", dip, nand_info.num_dip);
return -1;
}
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_CBP_TO_ROW_ADDR;
command->addr_xlate.cau = dip_info.cau;
command->addr_xlate.block = bork;
command->addr_xlate.page = page;
status = asp_send_command(command->tag);
if (status != ASPPROTO_CMD_STATUS_SUCCESS)
{
dprintf(DEBUG_CRITICAL, "Failed to get row address: %d\n", status);
printf("ce: %d cau: %d, blk: %d, page: %d\n", dip_info.ce, dip_info.cau, bork, page);
return -1;
}
printf("dip: %d, bork: %d, page: %d --> bus: %d row_addr: 0x%X\n",
dip, bork, page, dip_info.bus, command->addr_xlate.row_addr);
return 0;
}
static int asp_get_waterfall_table_size()
{
uint32_t table_size = 0;
aspproto_cmd_t * command;
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_NAND_DEBUG;
command->tunnel.opcode = NAND_DEBUG_GET_WATERFALL_TBL_SIZE;
if (asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)
{
dprintf(DEBUG_CRITICAL, "ERROR: Could not get waterfall table size.\n\n");
return -1;
}
table_size = command->tunnel.options.outputLen;
assert(!(table_size % SIZE_OF_WFALL_TBL_ENTRY));
printf("Waterfall table size: %d bytes\n", table_size);
return table_size;
}
static int asp_erase_band(uint32_t band, aspproto_cell_type_t cell_type, bool verbose)
{
aspproto_cmd_t * command;
int status;
if((band < 1) || (band > asp.lastBand))
{
printf("Band %d not allowed. Please choose a band between 1 and %d\n", band, asp.lastBand);
return -1;
}
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_CORE_DEBUG;
command->tunnel.core_opcode = CORE_DEBUG_ERASE_BAND;
command->tunnel.options.debug_epr_info.band = band;
command->tunnel.options.debug_epr_info.cell_type = cell_type;
status = asp_send_command(command->tag);
if(verbose)
{
printf("Band: %d erase status: 0x%X. \n", band, status);
}
if (status != ASPPROTO_CMD_STATUS_SUCCESS)
{
asp_print_status_key();
dprintf(DEBUG_CRITICAL, "ERROR: Could not erase band %d\n\n", band);
return -1;
}
return 0;
}
static int asp_read_verify(uint32_t band)
{
aspproto_cmd_t * command;
uint64_t perf_ticks0;
uint64_t perf_ticks1;
uint64_t link_clk_freq;
uint32_t pages_verified = 0;
if((band < 1) || (band > asp.lastBand))
{
printf("Band %d not allowed. Please choose a band between 1 and %d\n", band, asp.lastBand);
return -1;
}
if(0 != asp_reset_perf_ticks())
{
return -1;
}
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_CORE_DEBUG;
command->tunnel.core_opcode = CORE_DEBUG_READ_VERIFY_BAND;
command->tunnel.options.debug_epr_info.band = band;
if (asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)
{
dprintf(DEBUG_CRITICAL, "ERROR: Could not read verify band.\n\n");
return -1;
}
pages_verified += command->tunnel.options.debug_epr_info.output_value;
if(0 != asp_get_perf_ticks(false, &perf_ticks0, 0))
{
return -1;
}
if(0 != asp_get_perf_ticks(false, &perf_ticks1, 1))
{
return -1;
}
if(0 != asp_get_link_clk_freq(false, &link_clk_freq))
{
return -1;
}
printf("Ch0: %u bytes verified in %llu ticks @ %llu Hz\n\n", (pages_verified * nand_info.sec_per_page * ASP_NAND_BLKSZ) / 2,
perf_ticks0,
link_clk_freq);
printf("Ch1: %u bytes verified in %llu ticks @ %llu Hz\n\n", (pages_verified * nand_info.sec_per_page * ASP_NAND_BLKSZ) / 2,
perf_ticks1,
link_clk_freq);
printf("Ch0: To calculate total throughput in MiB/s: (%u * %llu) / (%llu * 1024 * 1024)\n\n", (pages_verified * nand_info.sec_per_page * ASP_NAND_BLKSZ) / 2,
link_clk_freq,
perf_ticks0);
printf("Ch1: To calculate total throughput in MiB/s: (%u * %llu) / (%llu * 1024 * 1024)\n\n", (pages_verified * nand_info.sec_per_page * ASP_NAND_BLKSZ) / 2,
link_clk_freq,
perf_ticks1);
printf("Note: This is actual bus utilization with negligible overhead.\n");
return 0;
}
static int asp_get_timing_parameters(aspproto_nand_timing_params_t *buf)
{
uint32_t paddr32;
aspproto_nand_timing_params_t *timing_params = NULL;
aspproto_cmd_t *command;
timing_params = memalign(sizeof(aspproto_nand_timing_params_t), ASP_NAND_BLK_ALIGNMENT);
if(!timing_params)
{
dprintf(DEBUG_CRITICAL, "Unable to allocate data_buffer\n");
return -1;
}
memset(timing_params, 0x00, sizeof(aspproto_nand_timing_params_t));
paddr32 = VADDR_TO_PADDR32(timing_params);
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_NAND_DEBUG;
command->tunnel.opcode = NAND_DEBUG_GET_PPN_TIMING;
command->tunnel.buffer_paddr = paddr32;
command->tunnel.bufferLen = sizeof(aspproto_nand_timing_params_t);
if (asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)
{
dprintf(DEBUG_CRITICAL, "ERROR: Could not get timing parameters.\n\n");
free(timing_params);
return -1;
}
memcpy(buf, timing_params, sizeof(aspproto_nand_timing_params_t));
free(timing_params);
return 0;
}
static int asp_get_device_parameters(aspproto_ppn_device_params_t *buf)
{
uint32_t paddr32;
aspproto_ppn_device_params_t *device_params = NULL;
aspproto_cmd_t * command;
device_params = memalign(sizeof(aspproto_ppn_device_params_t), ASP_NAND_BLK_ALIGNMENT);
if(!device_params)
{
dprintf(DEBUG_CRITICAL, "Unable to allocate data_buffer\n");
return -1;
}
memset(device_params, 0x00, sizeof(aspproto_ppn_device_params_t));
paddr32 = VADDR_TO_PADDR32(device_params);
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_NAND_DEBUG;
command->tunnel.opcode = NAND_DEBUG_GET_PPN_GEOM;
command->tunnel.buffer_paddr = paddr32;
command->tunnel.bufferLen = sizeof(aspproto_ppn_device_params_t);
if (asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)
{
dprintf(DEBUG_CRITICAL, "ERROR: Could not get waterfall table.\n\n");
free(device_params);
return -1;
}
memcpy(buf, device_params, sizeof(aspproto_ppn_device_params_t));
free(device_params);
return 0;
}
static int asp_print_ppn_parameters(void)
{
aspproto_ppn_device_params_t device_params;
aspproto_nand_timing_params_t timing_params;
int status;
status = asp_get_device_parameters(&device_params);
status |= asp_get_timing_parameters(&timing_params);
if(!status)
{
printf("Device parameters:\n");
printf("caus_per_channel: %d\n", device_params.caus_per_channel);
printf("cau_bits: %d\n", device_params.cau_bits);
printf("blocks_per_cau: %d\n", device_params.blocks_per_cau);
printf("block_bits: %d\n", device_params.block_bits);
printf("pages_per_block: %d\n", device_params.pages_per_block);
printf("pages_per_block_slc: %d\n", device_params.pages_per_block_slc);
printf("page_address_bits: %d\n", device_params.page_address_bits);
printf("address_bits_bits_per_cell: %d\n", device_params.address_bits_bits_per_cell);
printf("default_bits_per_cell: %d\n", device_params.default_bits_per_cell);
printf("page_size: %d\n", device_params.page_size);
printf("dies_per_channel: %d\n", device_params.dies_per_channel);
printf("block_pairing_scheme: %d\n", device_params.block_pairing_scheme);
printf("bytes_per_row_address: %d\n", device_params.bytes_per_row_address);
printf("pages_in_block0: %d\n", device_params.pages_in_block0);
printf("pages_in_read_verify: %d\n", device_params.pages_in_read_verify);
printf("multi_cau_bits: %d\n", device_params.multi_cau_bits);
printf("pattern_bits: %d\n", device_params.pattern_bits);
printf("channel0_die: %d\n",device_params.channel0_die);
printf("package_blocks_at_EOL: %d\n", device_params.package_blocks_at_EOL);
printf("tRC: %d\n", timing_params.tRC_ns);
printf("tREA: %d\n", timing_params.tREA_ns);
printf("tREH: %d\n", timing_params.tREH_ns);
printf("tRHOH: %d\n", timing_params.tRHOH_ns);
printf("tRHZ: %d\n", timing_params.tRHZ_ns);
printf("tRLOH: %d\n", timing_params.tRLOH_ns);
printf("tRP: %d\n", timing_params.tRP_ns);
printf("tWC: %d\n", timing_params.tWC_ns);
printf("tWH: %d\n", timing_params.tWH_ns);
printf("tWP: %d\n", timing_params.tWP_ns);
printf("read_queue_size: %d\n", device_params.read_queue_size);
printf("program_queue_size: %d\n", device_params.program_queue_size);
printf("erase_queue_size: %d\n", device_params.erase_queue_size);
printf("prep_function_buffer_size: %d\n", device_params.prep_function_buffer_size);
printf("tRST: %d\n", timing_params.tRST_ms);
printf("tPURST: %d\n", timing_params.tPURST_ms);
printf("tSCE: %d\n", timing_params.tSCE_ms);
printf("tCERDY: %d\n", timing_params.tCERDY_us);
printf("caus_per_package: %d\n", device_params.caus_per_package);
printf("dies_per_package: %d\n", device_params.dies_per_package);
printf("tRC_ddr: %d\n", timing_params.tRC_ddr_ns);
printf("tREH_ddr: %d\n", timing_params.tREH_ddr_ns);
printf("tRP_ddr: %d\n", timing_params.tRP_ddr_ns);
printf("tDQSL: %d\n", timing_params.tDQSL_ps);
printf("tDQSH: %d\n", timing_params.tDQSH_ps);
printf("tDSC: %d\n", timing_params.tDSC_ps);
printf("tDQSRE: %d\n", timing_params.tDQSRE_ps);
printf("tDQSQ: %d\n", timing_params.tDQSQ_ps);
printf("tDVW: %d\n", timing_params.tDVW_ps);
printf("max_interface_speed: %d\n", timing_params.max_interface_speed_mhz);
printf("\n");
printf("num_bus: %d\n", device_params.num_bus);
printf("ces_per_bus: %d\n", device_params.ces_per_bus);
printf("logical_page_size: %d\n", device_params.logical_page_size);
}
return status;
}
static uint32_t tlc_pattern = 0;
static int get_tlc_pattern(void)
{
aspproto_ppn_device_params_t *device_params;
device_params = NULL;
device_params = (aspproto_ppn_device_params_t *) malloc(sizeof(aspproto_ppn_device_params_t));
assert(device_params);
asp_get_device_parameters(device_params);
if((tlc_pattern >= (uint32_t)((1 << device_params->pattern_bits) - 1)))
{
tlc_pattern = 0;
} else {
tlc_pattern++;
}
return tlc_pattern;
}
static uint32_t test_pattern = 0;
static int asp_bonfire_group_a_slc(uint32_t seed)
{
aspproto_cmd_t * command;
printf("Opening ASP\n");
if (!asp_send_open())
{
dprintf(DEBUG_CRITICAL, "Unable to open ASP\n");
return false;
}
printf("Setting writable\n");
if (!asp_set_writable())
{
asp.state = ASP_STATE_ERROR_NOT_WRITABLE;
printf("Unable to set writable\n");
return false;
}
assert(bonfire_slc_state == BONFIRE_SLC_STATE_NONE);
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_CORE_DEBUG;
command->tunnel.core_opcode = CORE_DEBUG_BONFIRE_SLC_GROUP_A;
command->tunnel.options.value = seed;
command->flags.all = 0;
command->flags.noAesKey = 1;
if (asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)
{
dprintf(DEBUG_CRITICAL, "ERROR: Could not group A for SLC Bonfire.\n\n");
return -1;
}
bonfire_slc_state = BONFIRE_SLC_STATE_A;
asp_get_geometry();
return 0;
}
static int asp_bonfire_group_b_slc(void)
{
aspproto_cmd_t * command;
assert(bonfire_slc_state == BONFIRE_SLC_STATE_A);
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_CORE_DEBUG;
command->tunnel.core_opcode = CORE_DEBUG_BONFIRE_SLC_GROUP_B;
command->flags.all = 0;
command->flags.noAesKey = 1;
if (asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)
{
dprintf(DEBUG_CRITICAL, "ERROR: Could not group A for SLC Bonfire.\n\n");
return -1;
}
bonfire_slc_state = BONFIRE_SLC_STATE_B;
asp_get_geometry();
return 0;
}
static int asp_bonfire_ungroup(void)
{
aspproto_cmd_t * command;
assert(bonfire_slc_state == BONFIRE_SLC_STATE_B);
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_CORE_DEBUG;
command->tunnel.core_opcode = CORE_DEBUG_BONFIRE_SLC_UNGROUP;
command->flags.all = 0;
command->flags.noAesKey = 1;
if (asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)
{
dprintf(DEBUG_CRITICAL, "ERROR: Could not group A for SLC Bonfire.\n\n");
return -1;
}
bonfire_slc_state = BONFIRE_SLC_STATE_NONE;
asp_get_geometry();
return 0;
}
static int asp_write_band(uint32_t band, aspproto_cell_type_t cell_type, bool verbose, bool random_pattern, uint32_t data_pattern)
{
aspproto_cmd_t * command;
uint8_t * dataBuf;
uint32_t paddr32;
uint64_t perf_ticks0;
uint64_t perf_ticks1;
uint64_t link_clk_freq;
uint32_t pages_written = 0;
uint32_t pages_in_block;
uint32_t join_program_pages;
aspproto_cmd_status_e status;
uint32_t i;
uint32_t band_size = 0;
uint32_t buffer_length = 0;
uint32_t sectors_per_band;
if((band < 1) || (band > asp.lastBand))
{
printf("Band %d not allowed. Please choose a band between 1 and %d\n", band, asp.lastBand);
return -1;
}
sectors_per_band = (uint32_t) asp_sectors_per_band(band, false);
if(0 == sectors_per_band)
{
printf("Cannot program band - It has 0 good sectors.\n");
return -1;
}
band_size = sectors_per_band * ASP_NAND_BLKSZ;
join_program_pages = (cell_type == CELL_TYPE_IS_TLC) ? 3 : 1;
pages_in_block = (cell_type == CELL_TYPE_IS_SLC) ? nand_info.pages_per_block_slc : nand_info.pages_per_block;
if(0 != asp_reset_perf_ticks())
{
return -1;
}
#if DEBUG_LARGE_HEAP_HACK
buffer_length = band_size;
dataBuf = (uint8_t *)IBOOT_HACK_ADDR;
#else
buffer_length = ASP_NAND_BLKSZ;
dataBuf = memalign(buffer_length, ASP_NAND_BLK_ALIGNMENT);
#endif //#if DEBUG_LARGE_HEAP_HACK
if(!dataBuf)
{
printf("could not allocate data buffer\n");
return -1;
}
assert((buffer_length % sizeof(data_pattern)) == 0);
for(i = 0; i < buffer_length / sizeof(data_pattern); i++)
{
if(!random_pattern)
{
((uint32_t *)dataBuf)[i] = data_pattern;
}
else
{
((uint32_t *)dataBuf)[i] = rand();
}
}
paddr32 = VADDR_TO_PADDR32(dataBuf);
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_CORE_DEBUG;
command->tunnel.core_opcode = CORE_DEBUG_WRITE_BAND;
command->tunnel.options.debug_epr_info.band = band;
command->tunnel.buffer_paddr = paddr32;
command->tunnel.bufferLen = buffer_length;
command->tunnel.options.debug_epr_info.cell_type = cell_type;
command->flags.all = 0;
command->flags.noAesKey = 1;
if(cell_type == CELL_TYPE_IS_TLC)
{
command->tunnel.options.debug_epr_info.tlc_pattern = test_pattern++;
}
status = asp_send_command(command->tag);
if (status != ASPPROTO_CMD_STATUS_SUCCESS)
{
dprintf(DEBUG_CRITICAL, "ERROR: Could not write band. Error: %d\n\n", status);
asp_print_status_key();
return -1;
}
pages_written = command->tunnel.options.debug_epr_info.output_value;
if(0 != asp_get_perf_ticks(false, &perf_ticks0, 0))
{
return -1;
}
if(0 != asp_get_perf_ticks(false, &perf_ticks1, 1))
{
return -1;
}
if(0 != asp_get_link_clk_freq(false, &link_clk_freq))
{
return -1;
}
if(verbose)
{
printf("Ch0: %u bytes transferred in %llu ticks @ %llu Hz\n\n", (pages_written * nand_info.sec_per_page * ASP_NAND_BLKSZ) / 2,
perf_ticks0,
link_clk_freq);
printf("Ch1: %u bytes transferred in %llu ticks @ %llu Hz\n\n", (pages_written * nand_info.sec_per_page * ASP_NAND_BLKSZ) / 2,
perf_ticks1,
link_clk_freq);
printf("Ch0: To calculate total throughput in MiB/s: (%u * %llu) / (%llu * 1024 * 1024)\n\n", (pages_written * nand_info.sec_per_page * ASP_NAND_BLKSZ) / 2,
link_clk_freq,
perf_ticks0);
printf("Ch1: To calculate total throughput in MiB/s: (%u * %llu) / (%llu * 1024 * 1024)\n\n", (pages_written * nand_info.sec_per_page * ASP_NAND_BLKSZ) / 2,
link_clk_freq,
perf_ticks1);
printf("Ch0: Time for each superstripe in us: (%llu / %d) / (%llu / 1000000)\n\n", perf_ticks0, (pages_in_block / join_program_pages), link_clk_freq);
printf("Ch1: Time for each superstripe in us: (%llu / %d) / (%llu / 1000000)\n\n", perf_ticks1, (pages_in_block / join_program_pages), link_clk_freq);
printf("Note: This is actual bus utilization with negligible overhead.\n");
}
return 0;
}
static int asp_eploop_band(uint32_t band, aspproto_cell_type_t cell_type, uint32_t seconds, bool random_pattern, uint32_t data_pattern)
{
uint64_t start_ticks;
uint32_t iterations;
start_ticks = system_time();
if((band < 1) || (band > asp.lastBand))
{
printf("Band %d not allowed. Please choose a band between 1 and %d\n", band, asp.lastBand);
return -1;
}
if(seconds)
{
printf("Going to erase+program band: %d for %d seconds. cell_type: %d\n", band, seconds, cell_type);
}
else
{
printf("Going to erase+program band: %d once. cell_type: %d\n", band, cell_type);
}
iterations = 0;
while(1)
{
if(-1 == asp_erase_band(band, cell_type, false))
{
printf("error erasing band. returning\n");
return -1;
}
if(-1 == asp_write_band(band, cell_type, false, random_pattern, data_pattern))
{
printf("error programming band. returning\n");
return -1;
}
iterations++;
if(0 == seconds)
{
break;
}
else if(time_has_elapsed(start_ticks, (uint64_t)seconds * 1000000))
{
break;
}
}
printf("Completed %d iterations.\n", iterations);
return 0;
}
static int asp_get_waterfall_table(uint8_t *buffer)
{
uint32_t paddr32;
uint32_t table_size = 0;
uint8_t *table = NULL;
aspproto_cmd_t * command;
table_size = asp_get_waterfall_table_size();
if (!security_allow_memory(buffer, table_size))
{
printf("Permission Denied\n");
return -1;
}
memset(buffer, 0xA5, table_size);
table = memalign(table_size, ASP_NAND_BLK_ALIGNMENT);
if(!table)
{
dprintf(DEBUG_CRITICAL, "Unable to allocate data_buffer\n");
return -1;
}
memset(table, 0x00, table_size);
paddr32 = VADDR_TO_PADDR32(table);
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_NAND_DEBUG;
command->tunnel.opcode = NAND_DEBUG_GET_WATERFALL_TABLE;
command->tunnel.buffer_paddr = paddr32;
command->tunnel.bufferLen = table_size;
if (asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)
{
dprintf(DEBUG_CRITICAL, "ERROR: Could not get waterfall table.\n\n");
return -1;
}
memcpy(buffer, table, table_size);
printf("Waterfall table available at address: %p\n", buffer);
free(table);
return 0;
}
static int asp_get_dm(void)
{
uint8_t *dmBuf = NULL;
ExportDefects_t *defects = NULL;
uint32_t dmBufSize;
uint32_t paddr32;
aspproto_cmd_t * command;
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_CORE_DEBUG;
command->tunnel.core_opcode = CORE_DEBUG_EXPORT_BAND_DEFECTS;
command->tunnel.buffer_paddr = 0;
command->tunnel.bufferLen = 0;
command->tunnel.options.outputLen = 0;
command->tunnel.options.flags.forceExport = 1;
command->tunnel.options.flags.sizeOnly = 1;
if (asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)
{
dprintf(DEBUG_CRITICAL, "ERROR: no defect management list found\n\n");
asp.state = ASP_STATE_ERROR_INVALID_PPNFW;
return -1;
}
dmBufSize = command->tunnel.options.outputLen;
if (dmBufSize == 0){
dprintf(DEBUG_CRITICAL, "ERROR: defect management list returned size 0");
return -1;
}
//get the defect list
dmBuf = memalign(dmBufSize, ASP_NAND_BLK_ALIGNMENT);
if(!dmBuf)
{
dprintf(DEBUG_CRITICAL, "Unable to allocate data_buffer\n");
return -1;
}
memset(dmBuf, 0x00, dmBufSize);
paddr32 = VADDR_TO_PADDR32(dmBuf);
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_CORE_DEBUG;
command->tunnel.core_opcode = CORE_DEBUG_EXPORT_BAND_DEFECTS;
command->tunnel.buffer_paddr = paddr32;
command->tunnel.bufferLen = dmBufSize;
command->tunnel.options.flags.forceExport = 1;
command->tunnel.options.flags.sizeOnly = 0;
if (asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS){
dprintf(DEBUG_CRITICAL, "ERROR: failed to get the defect management list\n\n");
asp.state = ASP_STATE_ERROR_INVALID_PPNFW;
free(dmBuf);
return -1;
}
defects = (ExportDefects_t *)dmBuf;
//ensure that grownBadCount doesn't exceed the buffersize
if(defects->grownBadCount * sizeof(ExportDefectEntry_t) + sizeof(ExportDefects_t) - sizeof(uint32_t) > dmBufSize){
dprintf(DEBUG_CRITICAL, "ERROR: number of defects, %d, exceeds buffersize of %d bytes\n",defects->grownBadCount, dmBufSize);
free(dmBuf);
return -1;
}
//print the dm list
if (defects->grownBadCount == 0){
printf("No Grown Bad Blocks Found\n");
} else {
printf("Grown Bad Blocks:\n");
ExportDefectEntry_t * exportDefectEntries = (ExportDefectEntry_t *) &defects->exportDefectEntriesPtr;
for(uint32_t i=0; i < defects->grownBadCount; i++)
{
printf("bus: %d, ce: %d, cau: %d -> block: %d cycles: %d reason: 0x%x\n",
exportDefectEntries[i].bus,
exportDefectEntries[i].ce,
exportDefectEntries[i].cau,
exportDefectEntries[i].band,
exportDefectEntries[i].cycles,
exportDefectEntries[i].reason);
}
}
free(dmBuf);
return 0;
}
static int asp_get_bbt(void)
{
uint8_t *bbtBuf = NULL;
uint32_t paddr32;
uint32_t numSec = 0;
uint32_t numDip = 0;
uint32_t numBand = 0;
uint32_t dip = 0;
uint32_t band = 0;
uint32_t mask = 0;
uint32_t statsBufSize = 0;
uint8_t *dipPtr = NULL;
uint8_t *bandPtr = NULL;
aspproto_nand_col_t dip_info;
aspproto_cmd_t * command;
int status;
numSec = (nand_info.num_bands + 7) / 8; // bit per band round up to number of bytes.
numSec = (numSec + (ASP_NAND_BLKSZ-1)) / ASP_NAND_BLKSZ; // then round number of bytes up to number of sector
numDip = nand_info.num_dip;
numBand = nand_info.num_bands;
statsBufSize = numDip * numSec * ASP_NAND_BLKSZ;
bbtBuf = memalign(statsBufSize, ASP_NAND_BLK_ALIGNMENT);
if(!bbtBuf)
{
printf("could not allocate BBT buffer\n");
return -1;
}
memset(bbtBuf, 0x00, statsBufSize);
paddr32 = VADDR_TO_PADDR32(bbtBuf);
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_GET_BBT;
command->count = numDip * numSec;
command->sglAndIv[0] = paddr32;
status = asp_send_command(command->tag);
if (status != ASPPROTO_CMD_STATUS_SUCCESS)
{
dprintf(DEBUG_CRITICAL, "Failed to get BBT: %d\n", status);
return -1;
}
printf("BBT:\n");
for(dip = 0; dip < numDip; dip++)
{
dip_info = asp_get_single_dip_info(dip);
dipPtr = bbtBuf + (dip *numSec * ASP_NAND_BLKSZ);
for(band=0; band < numBand; band++)
{
bandPtr = dipPtr + (band/8);
mask = (0x80 >> (band % 8));
if (0 == (*bandPtr & mask))
{
printf("bus: %d, ce: %d, cau: %d -> block: %d\n", dip_info.bus, dip_info.ce, dip_info.cau, band);
}
}
printf("\n");
}
free(bbtBuf);
return 0;
}
static void output_band_stats(uint32_t *buf32)
{
uint32_t numBands;
uint32_t band;
uint32_t flags;
uint32_t flow;
uint32_t valid;
uint32_t eraseCycles;
uint32_t age;
uint32_t GCcan;
uint32_t GCmust;
uint32_t GCdone;
uint32_t pFail;
uint32_t mode;
uint32_t maxEraseCnt[NUM_ASP_PARITIONS] = {0, 0};
uint32_t minEraseCnt[NUM_ASP_PARITIONS] = {~0, ~0};
uint32_t avgEraseCnt[NUM_ASP_PARITIONS] = {0, 0};
uint32_t maxAge[NUM_ASP_PARITIONS] = {0, 0};
uint32_t firstBand[NUM_ASP_PARITIONS];
uint32_t lastBand[NUM_ASP_PARITIONS];
uint32_t * statsPtr;
uint32_t partitions = 0;
uint32_t partition;
printf ( "Band stats:\n" );
printf ( "===========\n" );
numBands = *buf32++;
partitions = *buf32++;
assert(partitions <= NUM_ASP_PARITIONS);
for(partition = 0; partition < partitions; partition++) {
firstBand[partition] = *buf32++;
lastBand[partition] = *buf32++;
}
statsPtr = buf32;
for (band = 0; band < numBands; band++)
{
flags = *buf32++;
flow = *buf32++;
valid = *buf32++;
eraseCycles = *buf32++;
age = *buf32++;
for(partition = 0; partition < partitions; partition++) {
if((band >= firstBand[partition]) && (band <= lastBand[partition]))
{
if(band == firstBand[partition])
{
printf("\n%s:\n", partition_names[partition]);
}
break;
}
}
if(partition < partitions)
{
maxAge[partition] = MAX(maxAge[partition], age);
maxEraseCnt[partition] = MAX(maxEraseCnt[partition], eraseCycles);
minEraseCnt[partition] = MIN(minEraseCnt[partition], eraseCycles);
avgEraseCnt[partition] += eraseCycles;
}
GCcan = flags & 1;
GCmust = (flags >> 1) & 1;
GCdone = (flags >> 2) & 1;
pFail = (flags >> 3) & 1;
mode = (flags >> 4) & 0x3;
if (~0U != valid)
{
printf("band:%4d\tflow:%2d\tvalid:%5d\terases:%5d\tage:%5d\tGCcan:%d GCmust:%d GCDone: %d pFail: %d mode:%d\n",
band, flow, valid, eraseCycles, age, GCcan, GCmust, GCdone, pFail, mode);
}
else
{
printf("band:%4d\tflow:%2d\tvalid: NA\terases:%5d\tage:%5d\tGCcan:%d GCmust:%d GCDone: %d pFail: %d mode:%d\n",
band, flow, eraseCycles, age, GCcan, GCmust, GCdone, pFail, mode);
}
}
for(partition = 0; partition < partitions; partition++) {
if(lastBand[partition] >= firstBand[partition]) {
avgEraseCnt[partition] = avgEraseCnt[partition] / (lastBand[partition] + 1 - firstBand[partition]);
printf("%s : Erase Cycles: Max ( %d ) Min ( %d ) Avg ( %d )\n", partition_names[partition],
maxEraseCnt[partition], minEraseCnt[partition], avgEraseCnt[partition]);
printf(" Max band age: ( %d )\n", maxAge[partition]);
}
}
}
static int asp_get_band_stats(void)
{
uint8_t *buffer = NULL;
uint32_t paddr32;
uint32_t statsBufSize = 0;
aspproto_cmd_t * command = NULL;
int status;
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
if(!command)
{
return -1;
}
command->op = ASPPROTO_CMD_CORE_DEBUG;
command->tunnel.core_opcode = CORE_DEBUG_READ_BAND_STATS;
command->tunnel.buffer_paddr = 0;
command->tunnel.bufferLen = 0;
command->tunnel.options.outputLen = 0;
command->tunnel.options.flags.forceExport = 0;
command->tunnel.options.flags.sizeOnly = 1;
status = asp_send_command(command->tag);
if (status != ASPPROTO_CMD_STATUS_SUCCESS)
{
dprintf(DEBUG_CRITICAL, "Failed to get Band Stats 0x%08X\n", status);
return -1;
}
statsBufSize = command->tunnel.options.outputLen;
statsBufSize = ALIGN_UP(statsBufSize, ASP_NAND_BLKSZ);
buffer = memalign(statsBufSize, ASP_NAND_BLK_ALIGNMENT);
if(!buffer)
{
printf("could not allocate Band Stats buffer\n");
return -1;
}
memset(buffer, 0x00, statsBufSize);
paddr32 = VADDR_TO_PADDR32(buffer);
command->op = ASPPROTO_CMD_CORE_DEBUG;
command->tunnel.core_opcode = CORE_DEBUG_READ_BAND_STATS;
command->tunnel.buffer_paddr = paddr32;
command->tunnel.bufferLen = statsBufSize;
command->tunnel.options.flags.forceExport = 0;
command->tunnel.options.flags.sizeOnly = 0;
#if WITH_NON_COHERENT_DMA
platform_cache_operation(CACHE_CLEAN | CACHE_INVALIDATE, buffer, statsBufSize);
#endif
status = asp_send_command(command->tag);
if (status != ASPPROTO_CMD_STATUS_SUCCESS)
{
dprintf(DEBUG_CRITICAL, "Failed to get Band Stats 0x%08X\n", status);
free(buffer);
return -1;
}
#if WITH_NON_COHERENT_DMA
platform_cache_operation(CACHE_INVALIDATE, buffer, statsBufSize);
#endif
output_band_stats((uint32_t *)buffer);
free(buffer);
return 0;
}
static bool debug_counter_supported(uint32_t channel)
{
aspproto_cmd_t * command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_NAND_DEBUG;
command->tunnel.opcode = NAND_DEBUG_DEBUG_COUNTER_SUPPORTED;
command->tunnel.buffer_paddr = 0;
command->tunnel.bufferLen = 0;
command->tunnel.options.mask = ((1<<ANC_MAX_BUSSES)-1) & (1 << channel);
if (nand_info.num_bus==0)
{
return false;
}
command->tunnel.options.value = 0;
if ((asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS) || (command->tunnel.options.value == 0))
{
dprintf(DEBUG_CRITICAL, "Unable to get debug counter for channel %d\n",channel);
return false;
}
else
{
dprintf(DEBUG_CRITICAL, "channel %d debug counter supported: %d\n", channel, command->tunnel.options.value);
}
return true;
}
static bool get_debug_counter(uint32_t channel, uint8_t * buffer)
{
uint8_t *bounce_buffer = NULL;
uint32_t buffer_size = ASP_NAND_BLKSZ;
bool status = false;
if (nand_info.num_bus==0)
{
return false;
}
if (!security_allow_memory(buffer, buffer_size))
{
printf("Permission Denied\n");
return -1;
}
memset(buffer, 0xA5, buffer_size);
bounce_buffer = memalign(buffer_size, ASP_NAND_BLK_ALIGNMENT);
if(!bounce_buffer)
{
dprintf(DEBUG_CRITICAL, "Failed to allocate data buffer\n");
return -1;
}
memset(bounce_buffer, 0xC7, buffer_size);
aspproto_cmd_t * command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_NAND_DEBUG;
command->tunnel.opcode = NAND_DEBUG_GET_DEBUG_COUNTER;
command->tunnel.buffer_paddr = VADDR_TO_PADDR32(bounce_buffer);
command->tunnel.bufferLen = buffer_size;
command->tunnel.options.mask = ((1<<ANC_MAX_BUSSES)-1) & (1 << channel);
command->tunnel.options.value = 0;
if (asp_send_command(command->tag) == ASPPROTO_CMD_STATUS_SUCCESS)
{
memcpy(buffer, bounce_buffer, buffer_size);
status = true;
printf("Debug Counter Buffer extracted for ch %d. Save to host by running 'usb put <filename> %d'\n",
channel, ASP_NAND_BLKSZ);
}
else
{
dprintf(DEBUG_CRITICAL, "Unable to get debug counter for channel %d\n",channel);
}
free(bounce_buffer);
return status;
}
static bool reset_debug_counter(uint32_t channel)
{
aspproto_cmd_t * command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_NAND_DEBUG;
command->tunnel.opcode = NAND_DEBUG_RESET_DEBUG_COUNTER;
command->tunnel.buffer_paddr = 0;
command->tunnel.bufferLen = 0;
command->tunnel.options.mask = ((1<<ANC_MAX_BUSSES)-1) & (1 << channel);
if (nand_info.num_bus==0)
{
return false;
}
command->tunnel.options.value = 0;
if (asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)
{
dprintf(DEBUG_CRITICAL, "Unable to reset debug counter for channel %d\n",channel);
return false;
}
else
{
dprintf(DEBUG_CRITICAL, "debug counter reset for channel %d\n",channel);
}
return true;
}
/*NOTE: This command does not read actual data to host buffer.
It just overwrites a placeholder sector data buffer.
If you need actual data, use 'asp read'
If you need bitflips, use 'asp bonfirereadband'
*/
static int asp_read_band(uint32_t band, aspproto_cell_type_t cell_type, uint32_t num_stripes, uint32_t seconds)
{
aspproto_cmd_t * command;
uint8_t * scratch_buffer; //placeholder for putting in page data. every sector.
uint32_t paddr32;
uint64_t start_ticks;
uint64_t perf_ticks0;
uint64_t perf_ticks1;
uint64_t link_clk_freq;
uint64_t pages_read = 0;
uint32_t pages_in_block;
uint32_t join_program_pages;
int status;
if(band > asp.lastBand)
{
printf("Band %d not allowed. Please choose a band between 1 and %d\n", band, asp.lastBand);
return -1;
}
join_program_pages = (cell_type == CELL_TYPE_IS_TLC) ? 3 : 1;
pages_in_block = (cell_type == CELL_TYPE_IS_SLC) ? nand_info.pages_per_block_slc : nand_info.pages_per_block;
if(0 != asp_reset_perf_ticks())
{
return -1;
}
scratch_buffer = memalign(ASP_NAND_BLKSZ, ASP_NAND_BLK_ALIGNMENT);
paddr32 = VADDR_TO_PADDR32(scratch_buffer);
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_CORE_DEBUG;
command->tunnel.core_opcode = CORE_DEBUG_READ_BAND;
command->tunnel.options.debug_epr_info.band = band;
command->tunnel.options.debug_epr_info.cell_type = cell_type;
command->tunnel.options.debug_epr_info.num_stripes = num_stripes;
command->flags.all = 0;
command->flags.noAesKey = 1;
command->tunnel.buffer_paddr = paddr32;
command->tunnel.bufferLen = ASP_NAND_BLKSZ;
start_ticks = system_time();
while(1)
{
status = asp_send_command(command->tag);
printf("Finished Band read with status: %d\n", status);
if (status != ASPPROTO_CMD_STATUS_SUCCESS)
{
asp_print_status_key();
dprintf(DEBUG_CRITICAL, "ERROR: Could not read band.\n\n");
return -1;
}
pages_read += command->tunnel.options.debug_epr_info.output_value;
if(0 == seconds)
{
break;
}
else if(time_has_elapsed(start_ticks, (uint64_t)seconds * 1000000))
{
break;
}
}
if(0 != asp_get_perf_ticks(false, &perf_ticks0, 0))
{
return -1;
}
if(0 != asp_get_perf_ticks(false, &perf_ticks1, 1))
{
return -1;
}
if(0 != asp_get_link_clk_freq(false, &link_clk_freq))
{
return -1;
}
printf("Ch0: %llu bytes transferred in %llu ticks @ %llu Hz\n\n", (pages_read * nand_info.sec_per_page * ASP_NAND_BLKSZ) / 2,
perf_ticks0,
link_clk_freq);
printf("Ch1: %llu bytes transferred in %llu ticks @ %llu Hz\n\n", (pages_read * nand_info.sec_per_page * ASP_NAND_BLKSZ) / 2,
perf_ticks1,
link_clk_freq);
printf("Ch0: To calculate total throughput in MiB/s: (%llu * %llu) / (%llu * 1024 * 1024)\n\n", (pages_read * nand_info.sec_per_page * ASP_NAND_BLKSZ) / 2,
link_clk_freq,
perf_ticks0);
printf("Ch1: To calculate total throughput in MiB/s: (%llu * %llu) / (%llu * 1024 * 1024)\n\n", (pages_read * nand_info.sec_per_page * ASP_NAND_BLKSZ) / 2,
link_clk_freq,
perf_ticks1);
printf("Ch0: Time for each superstripe in us: (%llu / %d) / (%llu / 1000000)\n\n", perf_ticks0, (pages_in_block / join_program_pages), link_clk_freq);
printf("Ch1: Time for each superstripe in us: (%llu / %d) / (%llu / 1000000)\n\n", perf_ticks1, (pages_in_block / join_program_pages), link_clk_freq);
printf("Note: This is actual bus utilization with negligible overhead.\n");
return 0;
}
//Make sure these macros are the same in AppleStorageProcessor/src/aspcore/core/cmd.c
#define SLC_TEST_BAND_START 101
#define SLC_TEST_BAND_END 110
#define MBC_TEST_BAND_START 111
#define MBC_TEST_BAND_END 120
static bool prefill_complete_slc = false;
static bool prefill_complete_mbc = false;
static void asp_prefill_bands(aspproto_cell_type_t cell_type)
{
uint32_t band_idx;
uint32_t start_band;
uint32_t end_band;
if(cell_type == CELL_TYPE_IS_SLC)
{
if (prefill_complete_slc)
{
return;
}
start_band = SLC_TEST_BAND_START;
end_band = SLC_TEST_BAND_END;
}
else
{
if (prefill_complete_mbc)
{
return;
}
start_band = MBC_TEST_BAND_START;
end_band = MBC_TEST_BAND_END;
}
printf("Prefilling band: %d to band: %d\n", start_band, end_band);
for(band_idx = start_band; band_idx <= end_band; band_idx++)
{
if(-1 == asp_erase_band(band_idx, cell_type, false))
{
panic("error erasing band");
}
if(-1 == (asp_write_band(band_idx, cell_type, false, true, 0)))
{
panic("error writing band");
}
}
//Do prefill only once
if(cell_type == CELL_TYPE_IS_SLC)
{
prefill_complete_slc = true;
}
else
{
prefill_complete_mbc = true;
}
printf("Prefill complete\n");
}
/* This command does superpage reads in a hard coded range of bands.
It goes dip-by-dip and enqueues a page read. Each of that read may be either SLC or TLC/MLC.
NOTE: This command does not read actual data to host buffer.
It just overwrites a placeholder data buffer.
If you need actual data, use 'asp read'
If you need bitflips, use 'asp bonfirereadband'
The band range is first erassed and programmed.
*/
static int asp_read_mixed_superpage(uint32_t num_superpages, uint32_t num_stripes, uint32_t seconds)
{
aspproto_cmd_t * command;
uint8_t * scratch_buffer; //placeholder for putting in page data. every sector.
uint32_t paddr32;
uint64_t start_ticks;
uint32_t iterations = 0;
uint64_t perf_ticks0;
uint64_t perf_ticks1;
uint64_t link_clk_freq;
uint32_t pages_read = 0;
asp_prefill_bands(CELL_TYPE_IS_SLC);
if(asp_istlc(false))
{
asp_prefill_bands(CELL_TYPE_IS_TLC);
}
else
{
asp_prefill_bands(CELL_TYPE_IS_MLC);
}
printf("Will now start the reads\n");
if(0 != asp_reset_perf_ticks())
{
return -1;
}
scratch_buffer = memalign(ASP_NAND_BLKSZ, ASP_NAND_BLK_ALIGNMENT);
paddr32 = VADDR_TO_PADDR32(scratch_buffer);
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_CORE_DEBUG;
command->tunnel.core_opcode = CORE_DEBUG_READ_MIXED_SUPERPAGE;
command->tunnel.options.debug_epr_info.num_sectors = num_superpages;
command->tunnel.options.debug_epr_info.num_stripes = num_stripes;
command->flags.all = 0;
command->flags.noAesKey = 1;
command->tunnel.buffer_paddr = paddr32;
command->tunnel.bufferLen = ASP_NAND_BLKSZ;
start_ticks = system_time();
while(1)
{
iterations++;
if (asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)
{
dprintf(DEBUG_CRITICAL, "ERROR: Could not read band.\n\n");
return -1;
}
pages_read += command->tunnel.options.debug_epr_info.output_value;
if(0 == seconds)
{
break;
}
else if(time_has_elapsed(start_ticks, (uint64_t)seconds * 1000000))
{
break;
}
}
if(0 != asp_get_perf_ticks(false, &perf_ticks0, 0))
{
return -1;
}
if(0 != asp_get_perf_ticks(false, &perf_ticks1 , 1))
{
return -1;
}
if(0 != asp_get_link_clk_freq(false, &link_clk_freq))
{
return -1;
}
printf("Ch0: %u bytes transferred in %llu ticks @ %llu Hz\n\n", (pages_read * nand_info.sec_per_page * ASP_NAND_BLKSZ) / 2,
perf_ticks0,
link_clk_freq);
printf("Ch1: %u bytes transferred in %llu ticks @ %llu Hz\n\n", (pages_read * nand_info.sec_per_page * ASP_NAND_BLKSZ) / 2,
perf_ticks1,
link_clk_freq);
printf("Ch0: To calculate total throughput in MiB/s: (%u * %llu) / (%llu * 1024 * 1024)\n\n", (pages_read * nand_info.sec_per_page * ASP_NAND_BLKSZ) / 2,
link_clk_freq,
perf_ticks0);
printf("Ch1: To calculate total throughput in MiB/s: (%u * %llu) / (%llu * 1024 * 1024)\n\n", (pages_read * nand_info.sec_per_page * ASP_NAND_BLKSZ) / 2,
link_clk_freq,
perf_ticks1);
printf("Note: This is actual bus utilization with negligible overhead.\n");
return 0;
}
/* This command does random reads in a hard coded range of bands.
For every page address, 'sectors_per_page' is the number of sectors of that page that is read.
'num_sectors' is the number of page addresses sent to the NAND.
'num_stripes' is the number of stripes done in one read transaction.
'same_die' determines if in a stripe, pages on the same die are read, or not, or if its random.
NOTE: This command does not read actual data to host buffer.
It just overwrites a placeholder sector data buffer.
If you need actual data, use 'asp read'
If you need bitflips, use 'asp bonfirereadband'
The band range is first erassed and programmed.
*/
static int asp_read_random(aspproto_cell_type_t cell_type, uint32_t num_sectors, uint32_t num_stripes, uint32_t sectors_per_page, uint32_t same_die ,uint32_t seconds)
{
aspproto_cmd_t * command;
uint8_t * scratch_buffer; //placeholder for putting in page data. every sector.
uint32_t paddr32;
uint64_t start_ticks;
uint32_t iterations = 0;
uint64_t perf_ticks0;
uint64_t perf_ticks1;
uint64_t link_clk_freq;
if(sectors_per_page > nand_info.sec_per_page)
{
printf("unit_size (%d) should be < sectors per page (%d)\n", sectors_per_page, nand_info.sec_per_page);
return -1;
}
asp_prefill_bands(cell_type);
printf("Will now start the reads\n");
if(0 != asp_reset_perf_ticks())
{
return -1;
}
scratch_buffer = memalign(ASP_NAND_BLKSZ, ASP_NAND_BLK_ALIGNMENT);
paddr32 = VADDR_TO_PADDR32(scratch_buffer);
command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
command->op = ASPPROTO_CMD_CORE_DEBUG;
command->tunnel.core_opcode = CORE_DEBUG_READ_RANDOM;
command->tunnel.options.debug_epr_info.cell_type = cell_type;
command->tunnel.options.debug_epr_info.num_sectors = num_sectors;
command->tunnel.options.debug_epr_info.num_stripes = num_stripes;
command->tunnel.options.debug_epr_info.same_die = same_die;
command->tunnel.options.debug_epr_info.sectors_per_page = sectors_per_page;
command->flags.all = 0;
command->flags.noAesKey = 1;
command->tunnel.buffer_paddr = paddr32;
command->tunnel.bufferLen = ASP_NAND_BLKSZ;
if(cell_type == CELL_TYPE_IS_MIXED)
{
command->tunnel.options.flags.mixedMode = 1;
}
start_ticks = system_time();
while(1)
{
iterations++;
if (asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)
{
dprintf(DEBUG_CRITICAL, "ERROR: Could not read band.\n\n");
return -1;
}
if(0 == seconds)
{
break;
}
else if(time_has_elapsed(start_ticks, (uint64_t)seconds * 1000000))
{
break;
}
}
if(0 != asp_get_perf_ticks(false, &perf_ticks0, 0))
{
return -1;
}
if(0 != asp_get_perf_ticks(false, &perf_ticks1, 1))
{
return -1;
}
if(0 != asp_get_link_clk_freq(false, &link_clk_freq))
{
return -1;
}
printf("Ch 0: %u bytes transferred in %llu ticks @ %llu Hz\n\n", (iterations * num_sectors * ASP_NAND_BLKSZ) / 2,
perf_ticks0,
link_clk_freq);
printf("Ch 1: %u bytes transferred in %llu ticks @ %llu Hz\n\n", (iterations * num_sectors * ASP_NAND_BLKSZ) / 2,
perf_ticks1,
link_clk_freq);
printf("Ch 0: To calculate total throughput in MiB/s: (%u * %llu) / (%llu * 1024 * 1024)\n\n", (iterations * num_sectors * ASP_NAND_BLKSZ) / 2,
link_clk_freq,
perf_ticks0);
printf("Ch 1: To calculate total throughput in MiB/s: (%u * %llu) / (%llu * 1024 * 1024)\n\n", (iterations * num_sectors * ASP_NAND_BLKSZ) / 2,
link_clk_freq,
perf_ticks1);
printf("Ch 0: Time taken for %d 4k sector in us: (%llu / %d) / (%llu / 1000000)\n\n", sectors_per_page, perf_ticks0, ((iterations * num_sectors) / 2), link_clk_freq); // Divide by 2 is because 2 buses are active at a time
printf("Ch 1: Time taken for %d 4k sector in us: (%llu / %d) / (%llu / 1000000)\n\n", sectors_per_page, perf_ticks1, ((iterations * num_sectors) / 2), link_clk_freq); // Divide by 2 is because 2 buses are active at a time
printf("Note: This is actual bus utilization with negligible overhead.\n");
return 0;
}
static int asp_bonfire_read_band(uint32_t band, aspproto_cell_type_t cell_type, bool stats)
{
uint8_t *statsBuf = NULL;
uint32_t paddr32 = 0;
aspproto_cmd_t * command;
int status;
uint32_t sectors_per_band;
if((band > asp.lastBand))
{
printf("Enter valid band: <= %d.\n", asp.lastBand);
return -1;
}
sectors_per_band = (uint32_t) asp_sectors_per_band(band, false);
if(0 == sectors_per_band)
{
printf("Cannot program band - It has 0 good sectors.\n");
return -1;
}
statsBuf = memalign(sectors_per_band * nand_info.bytes_per_sec_meta, ASP_NAND_BLK_ALIGNMENT);
if(!statsBuf)
{
printf("could not allocate stats buffer\n");
return -1;
}
memset(statsBuf, 0xFF, sectors_per_band * nand_info.bytes_per_sec_meta);
if(stats)
{
paddr32 = VADDR_TO_PADDR32(statsBuf);
}
command = asp_get_cmd_for_tag(ASP_TAG_NAND);
command->flags.all = 0;
command->flags.noAesKey = 1;
command->op = ASPPROTO_CMD_BONFIRE_READ;
command->bonfire_info.num_vpn = sectors_per_band / nand_info.sec_per_page;
if(cell_type == CELL_TYPE_IS_SLC) {
command->bonfire_info.start_vpn = band * (nand_info.sec_per_full_band_slc / nand_info.sec_per_page);
} else {
command->bonfire_info.start_vpn = band * (nand_info.sec_per_full_band / nand_info.sec_per_page);
}
command->bonfire_info.stats_buf32 = paddr32;
command->bonfire_info.cell_type = cell_type;
status = asp_send_command(command->tag);
if(stats)
{
printf("Sector Stats:\n");
uint8_t *page_cursor = statsBuf;
uint8_t *buf_stats_cursor = page_cursor;
bool zero_flips = true;
uint32_t idx = 0, pageIdx = 0;
uint32_t sectors_per_page = 16;
for(pageIdx = 0; pageIdx < command->bonfire_info.num_vpn; pageIdx++)
{
buf_stats_cursor = page_cursor;
for(idx = 0; idx < sectors_per_page; idx++)
{
if(*buf_stats_cursor != 0)
{
zero_flips = false;
break;
}
buf_stats_cursor++;
}
if(!zero_flips)
{
buf_stats_cursor = page_cursor ;
printf("vpn: %d: ", pageIdx);
for(idx = 0; idx < sectors_per_page; idx++)
{
printf("%02X ", *buf_stats_cursor);
buf_stats_cursor++;
}
printf("\n");
}
page_cursor = page_cursor + 16;
}
}
printf("Finished Band read with status: %d\n", status);
asp_print_status_key();
free(statsBuf);
return 0;
}
static int asp_nand_read_id(void)
{
uint32_t i = 0;
printf("\nChip ID:\n");
for(i = 0; i < nand_info.num_bus; i++)
{
printf("Bus %d: %02X %02X %02X %02X %02X %02X\n",
i,
asp.chip_id[i][0], asp.chip_id[i][1], asp.chip_id[i][2],
asp.chip_id[i][3], asp.chip_id[i][4], asp.chip_id[i][5]);
}
printf("\nMfg ID:\n");
for(i = 0; i < nand_info.num_bus; i++)
{
printf("Bus %d: %02X %02X %02X %02X %02X %02X\n",
i,
asp.mfg_id[i][0], asp.mfg_id[i][1], asp.mfg_id[i][2],
asp.mfg_id[i][3], asp.mfg_id[i][4], asp.mfg_id[i][5]);
}
asp_nand_get_uid();
return 0;
}
void asp_test_write_bdev(uint32_t start_lba, int num_lbas)
{
uint8_t *write_ptr;
int result;
if(!asp.writable)
{
panic("Need to make system writable. Execute 'asp setwritable' first\n");
}
printf("Going to do a bdev write\n");
write_ptr = malloc(num_lbas * ASP_NAND_BLKSZ);
if(!write_ptr)
{
panic("Could not allocate memory\n");
}
asp.state = ASP_STATE_READY;
memset(write_ptr, TEST_DATA_PATTERN, num_lbas * ASP_NAND_BLKSZ);
result = asp_write_block(asp_nand_dev, write_ptr, start_lba, num_lbas);
printf("bdev write returned %d\n", result);
if(num_lbas != result)
{
panic("bdev write returned %d instead of %d\n", result, num_lbas);
}
free(write_ptr);
}
void asp_test_read_bdev(uint32_t start_lba, int num_lbas)
{
int result;
uint8_t *read_ptr = (uint8_t *) env_get_uint("loadaddr", DEFAULT_LOAD_ADDRESS);
int i;
printf("Going to do a bdev read\n");
if (!security_allow_memory(read_ptr, num_lbas * ASP_NAND_BLKSZ))
{
panic("Permission Denied\n");
}
asp.state = ASP_STATE_READY;
memset(read_ptr, WATERMARK_PATTERN, num_lbas * ASP_NAND_BLKSZ);
result = asp_read_block(asp_nand_dev, read_ptr, start_lba, num_lbas);
if(num_lbas != result)
{
panic("bdev read returned %d instead of %d\n", result, num_lbas);
}
for(i = 0; i < num_lbas * ASP_NAND_BLKSZ; i++)
{
if(TEST_DATA_PATTERN != read_ptr[i])
{
panic("expected data: 0x%X, read data: 0x%X, byte offset in buffer: %d\n", TEST_DATA_PATTERN, read_ptr[i], i);
}
}
printf("bdev read returned %d\n", result);
}
void asp_test_waterfall_start(void)
{
aspproto_cmd_t * command = asp_get_cmd_for_tag(ASP_TAG_GENERIC);
printf("Going to start waterfall\n");
command->op = ASPPROTO_CMD_WATERFALL_START;
if (asp_send_command(command->tag) != ASPPROTO_CMD_STATUS_SUCCESS)
{
panic("ASP waterfall table start Failed\n");
}
}
bool asp_test_waterfall(void)
{
uint32_t lba = 0;
int count = 256;
printf("Opening ASP\n");
if (!asp_send_open())
{
dprintf(DEBUG_CRITICAL, "Unable to open ASP\n");
return false;
}
printf("Setting writable\n");
if (!asp_set_writable())
{
asp.state = ASP_STATE_ERROR_NOT_WRITABLE;
printf("Unable to set writable\n");
return false;
}
printf("Going to util format\n");
if (!asp_format(ASP_FORMAT_UTIL))
{
printf("Failed to do util format\n");
return false;
}
asp_get_geometry();
asp_test_write_bdev(lba, count);
asp_test_waterfall_start();
asp_test_read_bdev(lba, count);
lba += count;
asp_test_write_bdev(lba, count);
asp_test_waterfall_start();
asp_test_read_bdev(lba, count);
lba += count;
asp_test_write_bdev(lba, count);
asp_test_waterfall_start();
asp_test_read_bdev(lba, count);
return true;
}
static int do_asp(int argc, struct cmd_arg *args)
{
void *buffer;
size_t buffer_len;
int err = 0;
const char *cmd;
if (argc < 2)
{
printf("Not enough arguments\n");
usage();
return 0;
}
buffer = (void *) env_get_uint("loadaddr", DEFAULT_LOAD_ADDRESS);
buffer_len = (size_t) env_get_uint("filesize", 0);
cmd = args[1].str;
if (asp.state == ASP_STATE_ERROR_CRITICAL)
{
printf("Error - ASP has failed to initialize successfully!\n");
return -1;
}
if (!strcmp(args[1].str, "sync"))
{
if (!asp_sync())
{
printf("Failed to sync ASP\n");
return -1;
}
}
#if defined(ASP_ENABLE_NEURALIZE) && ASP_ENABLE_NEURALIZE
else if (!strcmp(args[1].str, "neuralize"))
{
if (!asp_set_writable())
{
asp.state = ASP_STATE_ERROR_NOT_WRITABLE;
printf("Unable to neuralize device; media is not writable\n");
return -1;
}
if (!asp_neuralize())
{
printf("Failed to neuralize\n");
asp.state = ASP_STATE_ERROR_NEURALIZE;
return -1;
}
}
#endif
else if (!strcmp(cmd, "info"))
{
printf("nand info: \n");
err = asp_nand_info();
}
else if (!strcmp(cmd, "readid"))
{
err = asp_nand_read_id();
}
else if (!strcmp(cmd, "istlc"))
{
err = asp_istlc(true);
}
else if(!strcmp(cmd, "getlinkclkfreq"))
{
err = asp_get_link_clk_freq(true, NULL);
}
else if(!strcmp(cmd, "resetperfticks"))
{
err = asp_reset_perf_ticks();
}
else if(!strcmp(cmd, "getperfticks"))
{
err = asp_get_perf_ticks(true, NULL, 0);
err = asp_get_perf_ticks(true, NULL, 1);
}
else if(!strcmp(cmd, "printslcbonfirebands"))
{
err = asp_print_slc_bonfire_bands();
}
else if (!strcmp(cmd, "test_scratchpad"))
{
err = asp_test_scratchpad();
}
else if (!strcmp(cmd, "dies_in_parallel") && argc>=3)
{
if (argc==3)
{
err = asp_set_dies_in_parallel(args[2].u,args[2].u,
args[2].u,args[2].u,
args[2].u,args[2].u,
args[2].u,args[2].u,
CORE_POWERSTATE_HIGH_POWER);
asp_set_power_state(CORE_POWERSTATE_HIGH_POWER);
}
else if (argc == 10)
{
err = asp_set_dies_in_parallel(args[2].u,args[3].u,
args[4].u,args[5].u,
args[6].u,args[7].u,
args[8].u,args[9].u,
CORE_POWERSTATE_HIGH_POWER);
asp_set_power_state(CORE_POWERSTATE_HIGH_POWER);
}
else
{
usage();
return 0;
}
}
else if (!strcmp(cmd, "set_photoflow_slc"))
{
err = asp_set_photoflow_mode(CORE_FLOW_MODE_SLC);
}
else if (!strcmp(cmd, "set_photoflow_mlc"))
{
err = asp_set_photoflow_mode(CORE_FLOW_MODE_MLC);
}
else if (!strcmp(cmd, "enable_bg"))
{
err = asp_enable_bg();
}
else if (!strcmp(cmd, "disable_bg"))
{
err = asp_disable_bg();
}
else if (!strcmp(cmd, "debug_counter_supported"))
{
if(argc < 3)
{
usage();
return 0;
}
err = debug_counter_supported(args[2].u);
}
else if (!strcmp(cmd, "get_debug_counter"))
{
if(argc < 3)
{
usage();
return 0;
}
err = get_debug_counter(args[2].u, (uint8_t *)buffer);
}
else if (!strcmp(cmd, "reset_debug_counter"))
{
if(argc < 3)
{
usage();
return 0;
}
err = reset_debug_counter(args[2].u);
}
else if (!strcmp(cmd, "bonfirereadband"))
{
if(argc < 5)
{
usage();
return 0;
}
err = asp_bonfire_read_band(args[2].u, args[3].u, args[4].u);
}
else if (!strcmp(cmd, "readband"))
{
if(argc < 5)
{
usage();
return 0;
}
if(argc == 5)
{
err = asp_read_band(args[2].u, args[3].u, args[4].u, 0);
}
else
{
err = asp_read_band(args[2].u, args[3].u, args[4].u, args[5].u);
}
}
else if (!strcmp(cmd, "readrandom"))
{
if(argc < 7)
{
usage();
return 0;
}
if(argc == 7)
{
err = asp_read_random(args[2].u, args[3].u, args[4].u, args[5].u, args[6].u, 0);
}
else
{
err = asp_read_random(args[2].u, args[3].u, args[4].u, args[5].u, args[6].u, args[7].u);
}
}
else if (!strcmp(cmd, "readmixedsuperpage"))
{
if(argc < 4)
{
usage();
return 0;
}
if(argc == 4)
{
err = asp_read_mixed_superpage(args[2].u, args[3].u, 0);
}
else
{
err = asp_read_mixed_superpage(args[2].u, args[3].u, args[4].u);
}
}
else if (!strcmp(cmd, "v2p"))
{
if(argc < 3)
{
usage();
return 0;
}
err = asp_nand_get_addr(args[2].u, NULL, NULL, true);
}
else if (!strcmp(cmd, "l2dbp"))
{
if(argc < 3)
{
usage();
return 0;
}
err = asp_l2dbp(args[2].u);
}
else if (!strcmp(cmd, "r2cbp"))
{
if(argc < 3)
{
usage();
return 0;
}
err = asp_r2cbp(args[2].u);
}
else if (!strcmp(cmd, "cbp2r"))
{
if(argc < 5)
{
usage();
return 0;
}
err = asp_cbp2r(args[2].u, args[3].u, args[4].u);
}
else if (!strcmp(cmd, "dbp2r"))
{
if(argc < 5)
{
usage();
return 0;
}
err = asp_dbp2r(args[2].u, args[3].u, args[4].u);
}
else if (!strcmp(cmd, "secperband"))
{
if(argc < 3)
{
usage();
return 0;
}
err = asp_sectors_per_band(args[2].u, true);
}
else if (!strcmp(cmd, "getburnincode"))
{
err = asp_get_burnin_code();
}
else if (!strcmp(cmd, "setTLCwritestripes"))
{
if(argc < 3)
{
usage();
return 0;
}
err = asp_set_tlcwritestripes(args[2].u);
}
else if (!strcmp(cmd, "getlastfailure"))
{
err = asp_get_last_failure();
}
else if (!strcmp(cmd, "bbt"))
{
err = asp_get_bbt();
}
else if (!strcmp(cmd, "dm"))
{
err = asp_get_dm();
}
else if (!strcmp(cmd, "waterfall_size"))
{
err = asp_get_waterfall_table_size();
}
else if (!strcmp(cmd, "waterfall"))
{
err = asp_get_waterfall_table((uint8_t *)buffer);
}
else if (!strcmp(cmd, "devparam"))
{
err = asp_print_ppn_parameters();
}
else if (!strcmp(cmd, "readverify"))
{
if(argc < 3)
{
usage();
return 0;
}
err = asp_read_verify(args[2].u);
}
else if (!strcmp(cmd, "dipinfo"))
{
err = asp_get_all_dip_info();
}
else if (!strcmp(cmd, "read"))
{
if(argc < 9)
{
usage();
return 0;
}
err = asp_physical_read(args[2].u, args[3].u, args[4].u, args[5].u, args[6].u, args[7].u, args[8].u, (uint8_t *)buffer, true, NULL);
}
else if (!strcmp(cmd, "readpagemeta"))
{
if(argc < 6)
{
usage();
return 0;
}
err = asp_read_pagemeta(args[2].u, args[3].u, args[4].u, args[5].u, (uint8_t *)buffer);
}
else if (!strcmp(cmd, "readbandmeta"))
{
if(argc < 4)
{
usage();
return 0;
}
err = asp_read_bandmeta(args[2].u, (uint8_t *)buffer, args[3].u);
}
else if (!strcmp(cmd, "bandstat"))
{
err = asp_get_band_stats();
}
else if (!strcmp(cmd, "disableuid"))
{
err = asp_disable_uid();
}
else if (!strcmp(cmd, "dumpblog"))
{
if(argc < 5)
{
usage();
return 0;
}
err = asp_dump_blog(args[2].u, (uint8_t *)buffer, args[3].u, args[4].u);
}
else if (!strcmp(cmd, "vthsweep"))
{
if(argc < 6)
{
usage();
return 0;
}
err = asp_vth_sweep(args[2].u, args[3].u, args[4].u, args[5].str);
}
else if (!strcmp(cmd, "rma_delete"))
{
if(argc < 3)
{
usage();
return 0;
}
err = asp_rma_delete(args[2].u);
}
else if (!strcmp(cmd, "rma_configure"))
{
if(argc < 4)
{
usage();
return 0;
}
err = asp_rma_configure(args[2].u, args[3].u);
}
else if (!strcmp(cmd, "rma_set"))
{
if(argc < 3)
{
usage();
return 0;
}
err = asp_rma_set(args[2].u);
err &= asp_recover();
}
else if (!strcmp(cmd, "rma_get"))
{
if(argc < 3)
{
usage();
return 0;
} else if(argc == 3) {
err = asp_rma_get(args[2].u, NULL, NULL);
} else {
err = asp_rma_get(args[2].u, args[3].str, NULL);
}
}
else if (!strcmp(cmd, "ppn_recover"))
{
err = asp_recover();
}
else if (!strcmp(cmd, "ppn_get_calibration"))
{
if(argc < 2)
{
usage();
return 0;
} else if(argc == 2) {
err = asp_ppn_get_calibration(NULL);
} else {
err = asp_ppn_get_calibration(args[2].str);
}
}
else if (!strcmp(cmd, "testbdevread"))
{
if(argc < 4)
{
usage();
return 0;
}
asp_test_read_bdev(args[2].u, args[3].u);
}
#if ASP_ENABLE_WRITES
else if (!strcmp(args[1].str, "utilFormat"))
{
if (!asp_format(ASP_FORMAT_UTIL))
{
printf("Failed to format media\n");
return -1;
}
return 0;
}
else if (!strcmp(args[1].str, "lbaFormat"))
{
if (!asp_format(ASP_FORMAT_LBA))
{
printf("Failed to format media\n");
return -1;
}
return 0;
}
else if (!strcmp(args[1].str, "register"))
{
if(!asp.writable)
{
printf("Need to make system writable. Execute 'asp setwritable' first\n");
return -1;
}
if (!asp_get_geometry())
{
asp.state = ASP_STATE_ERROR_CRITICAL;
printf("Unable to register device; media is unformatted\n");
return -1;
}
if (!asp_create_block_device(ASP_NVRAM))
{
asp.state = ASP_STATE_ERROR_NOT_REGISTERED;
printf("Failed to create ASP_NVRAM block device\n");
return -1;
}
if (!asp_create_block_device(ASP_NAND))
{
asp.state = ASP_STATE_ERROR_NOT_REGISTERED;
printf("Failed to create ASP_NAND block device\n");
return -1;
}
if (!asp_create_block_device(ASP_FIRMWARE))
{
asp.state = ASP_STATE_ERROR_NOT_REGISTERED;
printf("Failed to create ASP_FIRMWARE block device\n");
return -1;
}
if (!asp_create_block_device(ASP_LLB))
{
asp.state = ASP_STATE_ERROR_NOT_REGISTERED;
printf("Failed to create ASP_LLB block device\n");
return -1;
}
if (!asp_create_block_device(ASP_EFFACEABLE))
{
asp.state = ASP_STATE_ERROR_NOT_REGISTERED;
printf("Failed to create ASP_EFFACEABLE block device\n");
return -1;
}
if (!asp_create_block_device(ASP_SYSCFG))
{
asp.state = ASP_STATE_ERROR_NOT_REGISTERED;
printf("Failed to create ASP_SYSCFG block device\n");
return -1;
}
if (!asp_create_block_device(ASP_PANICLOG))
{
asp.state = ASP_STATE_ERROR_NOT_REGISTERED;
printf("Failed to create ASP_PANICLOG block device\n");
return -1;
}
asp.state = ASP_STATE_READY;
partition_scan_and_publish_subdevices("asp_nand");
return 0;
}
else if (!strcmp(cmd, "bonfirewriteband"))
{
bool random_pattern = true;
uint32_t data_pattern = 0;
if(argc < 4)
{
usage();
return 0;
}
if(argc > 4)
{
data_pattern = args[4].u;
random_pattern = false;
}
err = asp_bonfire_write_band(args[2].u, args[3].u, random_pattern, data_pattern);
}
else if (!strcmp(cmd, "bonfireeraseband"))
{
if(argc < 3)
{
usage();
return 0;
}
err = asp_bonfire_erase_band(args[2].u);
}
else if (!strcmp(cmd, "groupaslc"))
{
if(argc < 3)
{
usage();
return 0;
}
err = asp_bonfire_group_a_slc(args[2].u);
}
else if (!strcmp(cmd, "groupbslc"))
{
err = asp_bonfire_group_b_slc();
}
else if (!strcmp(cmd, "ungroup"))
{
err = asp_bonfire_ungroup();
}
else if (!strcmp(cmd, "writeband"))
{
bool random_pattern = true;
uint32_t data_pattern = 0;
if(argc < 4)
{
usage();
return 0;
}
if(argc > 4)
{
data_pattern = args[4].u;
random_pattern = false;
}
err = asp_write_band(args[2].u, args[3].u, true, random_pattern, data_pattern);
}
else if (!strcmp(cmd, "eploop"))
{
bool random_pattern = true;
uint32_t data_pattern = 0;
if(argc < 5)
{
usage();
return 0;
}
if(argc > 5)
{
data_pattern = args[5].u;
random_pattern = false;
}
err = asp_eploop_band(args[2].u, args[3].u, args[4].u, random_pattern, data_pattern);
}
else if (!strcmp(cmd, "eraseband"))
{
if(argc < 4)
{
usage();
return 0;
}
err = asp_erase_band(args[2].u, args[3].u, true);
}
else if (!strcmp(cmd, "testwaterfall"))
{
err = asp_test_waterfall();
}
else if (!strcmp(cmd, "testbdevwrite"))
{
if(argc < 4)
{
usage();
return 0;
}
asp_test_write_bdev(args[2].u, args[3].u);
}
else if (!strcmp(cmd, "setwritable"))
{
err = asp_set_writable();
}
else if (!strcmp(cmd, "setburnincode"))
{
if(argc < 3)
{
usage();
return 0;
}
err = asp_set_burnin_code(args[2].u);
}
#endif // ASP_ENABLE_WRITES
else
{
printf("invalid command\n");
usage();
err = -1;
}
return err;
}
MENU_COMMAND_DEVELOPMENT(asp, do_asp, "ASP maintenance and failure analysis commands", NULL);
#endif // DEBUG_BUILD && WITH_MENU
#if !RELEASE_BUILD && WITH_MENU
static bool find_blobs(void *src_buffer, UInt32 src_length, void **fw, UInt32 *fw_len)
{
DERReturn drtn;
DERSequence rdn;
DERItem seq, top = { src_buffer, src_length };
DERDecodedInfo topDecode, keyC, valC;
if (DR_Success != DERDecodeItem(&top, &topDecode)) {
printf("couldn't crack top level\n");
return false;
}
if ((ASN1_CONSTRUCTED|ASN1_APPLICATION) != ((ASN1_CONSTRUCTED|ASN1_APPLICATION) & topDecode.tag)) {
printf("top should be cons app\n");
return false;
}
seq.length = topDecode.content.length;
seq.data = topDecode.content.data;
if (DR_Success != DERDecodeSeqContentInit(&seq, &rdn)) {
printf("could not initialize DER decode\n");
return false;
}
while ((drtn = DERDecodeSeqNext(&rdn, &keyC)) == DR_Success) {
// Got key UTF8-str, check
if (ASN1_UTF8_STRING != keyC.tag) {
printf("key invalid: %lld\n", keyC.tag);
return false;
}
// Get value Octet-str
if (DR_Success != ((drtn = DERDecodeSeqNext(&rdn, &valC)))) {
printf("no value found for key %lld\n", keyC.tag);
return false;
}
// Check value tag
if (ASN1_OCTET_STRING != valC.tag) {
printf("value invalid: %lld\n", valC.tag);
return false;
}
// Decode
if ((6 == keyC.content.length) && (0 == strncmp((char*)keyC.content.data, "ppn-fw", 6))) {
*fw = valC.content.data;
*fw_len = valC.content.length;
} else {
printf("unknown key\n");
return false;
}
}
return true;
}
static int do_ppnfw(int argc, struct cmd_arg *args)
{
addr_t buf_ptr;
size_t buf_len;
void *fw_buffer = NULL;
uint32_t fw_length;
if (argc > 3)
{
return -1;
}
buf_ptr = (argc > 1) ? args[1].u : env_get_uint("loadaddr", DEFAULT_LOAD_ADDRESS);
buf_len = (argc > 2) ? args[2].u : env_get_uint("filesize", 0);
if (!security_allow_memory((void*)buf_ptr, buf_len))
{
return -2;
}
fw_buffer = NULL;
fw_length = 0;
find_blobs((void*)buf_ptr, buf_len, &fw_buffer, &fw_length);
if ((NULL == fw_buffer))
{
printf("couldn't find the fw payload\n");
return -3;
}
return asp_update_ppn_firmware(fw_buffer, fw_length);
}
MENU_COMMAND_DEVELOPMENT(ppnfw, do_ppnfw, "Update PPN controller firmware", NULL);
#endif // #if !RELEASE_BUILD && WITH_MENU
Reference in New Issue View Git Blame Copy Permalink