432 lines
12 KiB
C
432 lines
12 KiB
C
/***************************************************************************
|
|
*
|
|
* Copyright 2015-2019 BES.
|
|
* All rights reserved. All unpublished rights reserved.
|
|
*
|
|
* No part of this work may be used or reproduced in any form or by any
|
|
* means, or stored in a database or retrieval system, without prior written
|
|
* permission of BES.
|
|
*
|
|
* Use of this work is governed by a license granted by BES.
|
|
* This work contains confidential and proprietary information of
|
|
* BES. which is protected by copyright, trade secret,
|
|
* trademark and other intellectual property rights.
|
|
*
|
|
****************************************************************************/
|
|
#if (CHIP_FLASH_CTRL_VER <= 1)
|
|
|
|
#include "plat_types.h"
|
|
#include "plat_addr_map.h"
|
|
#include "reg_norflaship_v1.h"
|
|
#include "hal_norflaship.h"
|
|
#ifdef PROGRAMMER
|
|
#include "task_schedule.h"
|
|
#else
|
|
#define TASK_SCHEDULE true
|
|
#endif
|
|
|
|
//====================================================================================
|
|
// Flash IP Operations
|
|
//====================================================================================
|
|
|
|
/*
|
|
Supported Command List (Based on GD25Q32C):
|
|
|
|
parameter NOP = 8'h00 ;
|
|
parameter WRR = 8'h01 ;
|
|
parameter PP = 8'h02 ;
|
|
parameter READ = 8'h03 ;
|
|
parameter WRDI = 8'h04 ;
|
|
parameter RDSR = 8'h05 ;
|
|
parameter WREN = 8'h06 ;
|
|
parameter FAST_READ = 8'h0B ;
|
|
parameter P4E = 8'h20 ;
|
|
parameter SE2 = 8'h20 ;
|
|
parameter CLSR = 8'h30 ;
|
|
parameter QPP = 8'h32 ;
|
|
parameter RCR = 8'h35 ;
|
|
parameter DOR = 8'h3B ;
|
|
parameter P8E = 8'h40 ;
|
|
parameter OTPP = 8'h42 ;
|
|
parameter PSR = 8'h42 ;
|
|
parameter ESR = 8'h44 ;
|
|
parameter RSR = 8'h48 ;
|
|
parameter OTPR = 8'h4B ;
|
|
parameter BE32 = 8'h52 ;
|
|
parameter CE = 8'h60 ;
|
|
parameter QOR = 8'h6B ;
|
|
parameter PES = 8'h75 ;
|
|
parameter PER = 8'h7A ;
|
|
parameter READ_ID = 8'h90 ;
|
|
parameter RDID = 8'h9F ;
|
|
parameter HPM = 8'hA3 ;
|
|
parameter RES = 8'hAB ;
|
|
parameter DP = 8'hB9 ;
|
|
parameter DIOR = 8'hBB ;
|
|
parameter BE = 8'hC7 ;
|
|
parameter BE64 = 8'hD8 ;
|
|
parameter SE = 8'hD8 ;
|
|
parameter QIOWR = 8'hE7 ;
|
|
parameter QIOR = 8'hEB ;
|
|
parameter CRR = 8'hFF ;
|
|
*/
|
|
|
|
/* register memory address */
|
|
#define NORFLASHIP_BASEADDR FLASH_CTRL_BASE
|
|
|
|
#define norflaship_readb(a) \
|
|
(*(volatile unsigned char*)(NORFLASHIP_BASEADDR+a))
|
|
|
|
#define norflaship_read32(a) \
|
|
(*(volatile unsigned int *)(NORFLASHIP_BASEADDR+a))
|
|
|
|
#define norflaship_write32(v,a) \
|
|
((*(volatile unsigned int *)(NORFLASHIP_BASEADDR+a)) = v)
|
|
|
|
/* ip ops */
|
|
uint8_t norflaship_continuous_read_mode_bit(uint8_t mode_bit)
|
|
{
|
|
uint32_t val = 0;
|
|
norflaship_busy_wait();
|
|
val = norflaship_read32(TX_CONFIG2_BASE);
|
|
val &= ~(TX_MODBIT_MASK);
|
|
val |= (mode_bit<<TX_MODBIT_SHIFT)&TX_MODBIT_MASK;
|
|
norflaship_write32(val, TX_CONFIG2_BASE);
|
|
return 0;
|
|
}
|
|
uint8_t norflaship_continuous_read_off(void)
|
|
{
|
|
uint32_t val = 0;
|
|
norflaship_busy_wait();
|
|
val = norflaship_read32(TX_CONFIG2_BASE);
|
|
val &= ~(TX_CONMOD_MASK);
|
|
norflaship_write32(val, TX_CONFIG2_BASE);
|
|
return 0;
|
|
}
|
|
uint8_t norflaship_continuous_read_on(void)
|
|
{
|
|
uint32_t val = 0;
|
|
norflaship_busy_wait();
|
|
val = norflaship_read32(TX_CONFIG2_BASE);
|
|
val |= (TX_CONMOD_MASK);
|
|
norflaship_write32(val, TX_CONFIG2_BASE);
|
|
return 0;
|
|
}
|
|
uint32_t norflaship_write_txfifo(const uint8_t *val, uint32_t len)
|
|
{
|
|
uint32_t i = 0;
|
|
for (i = 0; i < len; ++i) {
|
|
norflaship_write32(val[i], TXDATA_BASE);
|
|
}
|
|
return 0;
|
|
}
|
|
uint32_t norflaship_v1_write_txfifo_safe(const uint8_t *val, uint32_t len)
|
|
{
|
|
uint32_t i;
|
|
uint32_t st;
|
|
for (i = 0; i < len; ++i) {
|
|
st = norflaship_read32(INT_STATUS_BASE);
|
|
if (st & TXFIFOFULL_MASK) {
|
|
break;
|
|
}
|
|
norflaship_write32(val[i], TXDATA_BASE);
|
|
}
|
|
return len - i;
|
|
}
|
|
uint32_t norflaship_v1_write_txfifo_all(const uint8_t *val, uint32_t len)
|
|
{
|
|
uint32_t st;
|
|
while (len > 0) {
|
|
st = norflaship_read32(INT_STATUS_BASE);
|
|
if (st & TXFIFOFULL_MASK) {
|
|
continue;
|
|
}
|
|
norflaship_write32(*val, TXDATA_BASE);
|
|
val++;
|
|
len--;
|
|
}
|
|
return 0;
|
|
}
|
|
uint8_t norflaship_read_rxfifo_count(void)
|
|
{
|
|
uint32_t val = 0;
|
|
val = norflaship_readb(INT_STATUS_BASE);
|
|
return ((val&RXFIFOCOUNT_MASK)>>RXFIFOCOUNT_SHIFT);
|
|
}
|
|
uint8_t norflaship_read_rxfifo(void)
|
|
{
|
|
uint32_t val = 0;
|
|
val = norflaship_readb(RXDATA_BASE);
|
|
return val&0xff;
|
|
}
|
|
void norflaship_blksize(uint32_t blksize)
|
|
{
|
|
uint32_t val = 0;
|
|
val = norflaship_read32(TX_CONFIG2_BASE);
|
|
val = ((~(TX_BLKSIZE_MASK))&val) | (blksize<<TX_BLKSIZE_SHIFT);
|
|
norflaship_write32(val, TX_CONFIG2_BASE);
|
|
}
|
|
void norflaship_cmd_addr(uint8_t cmd, uint32_t address)
|
|
{
|
|
norflaship_busy_wait();
|
|
norflaship_write32(address<<TX_ADDR_SHIFT|(cmd<<TX_CMD_SHIFT), TX_CONFIG1_BASE);
|
|
}
|
|
void norflaship_ext_tx_cmd(uint8_t cmd, uint32_t tx_len)
|
|
{
|
|
norflaship_busy_wait();
|
|
norflaship_write32(cmd<<EXT_CMD_SHIFT, TX_CONFIG1_BASE);
|
|
}
|
|
void norflaship_ext_rx_cmd(uint8_t cmd, uint32_t tx_len, uint32_t rx_len)
|
|
{
|
|
norflaship_busy_wait();
|
|
norflaship_blksize(rx_len);
|
|
norflaship_write32(EXT_CMD_RX_MASK|(cmd<<EXT_CMD_SHIFT), TX_CONFIG1_BASE);
|
|
}
|
|
void norflaship_cmd_done(void)
|
|
{
|
|
norflaship_busy_wait();
|
|
}
|
|
void norflaship_rxfifo_count_wait(uint8_t cnt)
|
|
{
|
|
uint32_t st = 0;
|
|
do {
|
|
st = norflaship_read32(INT_STATUS_BASE);
|
|
} while ((((st&RXFIFOCOUNT_MASK)>>RXFIFOCOUNT_SHIFT) < cnt) && TASK_SCHEDULE);
|
|
}
|
|
void norflaship_rxfifo_empty_wait(void)
|
|
{
|
|
uint32_t st = 0;
|
|
do {
|
|
st = norflaship_read32(INT_STATUS_BASE);
|
|
} while ((st&RXFIFOEMPTY_MASK) && TASK_SCHEDULE);
|
|
}
|
|
void norflaship_busy_wait(void)
|
|
{
|
|
uint32_t st = 0;
|
|
do {
|
|
st = norflaship_read32(INT_STATUS_BASE);
|
|
} while ((st&BUSY_MASK) && TASK_SCHEDULE);
|
|
}
|
|
int norflaship_is_busy(void)
|
|
{
|
|
uint32_t st = 0;
|
|
st = norflaship_read32(INT_STATUS_BASE);
|
|
return !!(st&BUSY_MASK);
|
|
}
|
|
void norflaship_clear_fifos(void)
|
|
{
|
|
norflaship_busy_wait();
|
|
norflaship_write32(RXFIFOCLR_MASK|TXFIFOCLR_MASK, FIFO_CONFIG_BASE);
|
|
norflaship_busy_wait();
|
|
}
|
|
void norflaship_clear_rxfifo(void)
|
|
{
|
|
norflaship_busy_wait();
|
|
norflaship_write32(RXFIFOCLR_MASK, FIFO_CONFIG_BASE);
|
|
norflaship_busy_wait();
|
|
}
|
|
void norflaship_clear_txfifo(void)
|
|
{
|
|
norflaship_busy_wait();
|
|
norflaship_write32(TXFIFOCLR_MASK, FIFO_CONFIG_BASE);
|
|
norflaship_busy_wait();
|
|
}
|
|
void norflaship_div(uint32_t div)
|
|
{
|
|
uint32_t val = 0;
|
|
norflaship_busy_wait();
|
|
val = norflaship_read32(MODE1_CONFIG_BASE);
|
|
val = (~(CLKDIV_MASK) & val) | (div<<CLKDIV_SHIFT);
|
|
norflaship_write32(val, MODE1_CONFIG_BASE);
|
|
}
|
|
uint32_t norflaship_get_div(void)
|
|
{
|
|
uint32_t val = 0;
|
|
val = norflaship_read32(MODE1_CONFIG_BASE);
|
|
return (val & CLKDIV_MASK) >> CLKDIV_SHIFT;
|
|
}
|
|
void norflaship_cmdquad(uint32_t v)
|
|
{
|
|
uint32_t val = 0;
|
|
norflaship_busy_wait();
|
|
val = norflaship_read32(MODE1_CONFIG_BASE);
|
|
if (v)
|
|
val |= CMDQUAD_MASK;
|
|
else
|
|
val &= ~CMDQUAD_MASK;
|
|
norflaship_write32(val, MODE1_CONFIG_BASE);
|
|
}
|
|
uint32_t norflaship_get_pos_neg(void)
|
|
{
|
|
uint32_t val = 0;
|
|
val = norflaship_read32(MODE1_CONFIG_BASE);
|
|
return !!(val & POS_NEG_MASK);
|
|
}
|
|
void norflaship_pos_neg(uint32_t v)
|
|
{
|
|
uint32_t val = 0;
|
|
norflaship_busy_wait();
|
|
val = norflaship_read32(MODE1_CONFIG_BASE);
|
|
if (v)
|
|
val |= POS_NEG_MASK;
|
|
else
|
|
val &= ~POS_NEG_MASK;
|
|
norflaship_write32(val, MODE1_CONFIG_BASE);
|
|
}
|
|
uint32_t norflaship_get_neg_phase(void)
|
|
{
|
|
uint32_t val = 0;
|
|
val = norflaship_read32(MODE1_CONFIG_BASE);
|
|
return !!(val & NEG_PHASE_MASK);
|
|
}
|
|
void norflaship_neg_phase(uint32_t v)
|
|
{
|
|
uint32_t val = 0;
|
|
norflaship_busy_wait();
|
|
val = norflaship_read32(MODE1_CONFIG_BASE);
|
|
if (v)
|
|
val |= NEG_PHASE_MASK;
|
|
else
|
|
val &= ~NEG_PHASE_MASK;
|
|
norflaship_write32(val, MODE1_CONFIG_BASE);
|
|
}
|
|
uint32_t norflaship_get_samdly(void)
|
|
{
|
|
uint32_t val = 0;
|
|
val = norflaship_read32(MODE1_CONFIG_BASE);
|
|
return (val & SAMDLY_MASK) >> SAMDLY_SHIFT;
|
|
}
|
|
void norflaship_samdly(uint32_t v)
|
|
{
|
|
uint32_t val = 0;
|
|
norflaship_busy_wait();
|
|
val = norflaship_read32(MODE1_CONFIG_BASE);
|
|
val = (~(SAMDLY_MASK) & val) | (v<<SAMDLY_SHIFT);
|
|
norflaship_write32(val, MODE1_CONFIG_BASE);
|
|
}
|
|
void norflaship_dual_mode(uint32_t v)
|
|
{
|
|
uint32_t val = 0;
|
|
norflaship_busy_wait();
|
|
val = norflaship_read32(MODE1_CONFIG_BASE);
|
|
if (v)
|
|
val |= DUALMODE_MASK;
|
|
else
|
|
val &= ~DUALMODE_MASK;
|
|
norflaship_write32(val, MODE1_CONFIG_BASE);
|
|
}
|
|
void norflaship_hold_pin(uint32_t v)
|
|
{
|
|
uint32_t val = 0;
|
|
val = norflaship_read32(MODE1_CONFIG_BASE);
|
|
if (v)
|
|
val |= HOLDPIN_MASK;
|
|
else
|
|
val &= ~HOLDPIN_MASK;
|
|
norflaship_write32(val, MODE1_CONFIG_BASE);
|
|
}
|
|
void norflaship_wpr_pin(uint32_t v)
|
|
{
|
|
uint32_t val = 0;
|
|
val = norflaship_read32(MODE1_CONFIG_BASE);
|
|
if (v)
|
|
val |= WPRPIN_MASK;
|
|
else
|
|
val &= ~WPRPIN_MASK;
|
|
norflaship_write32(val, MODE1_CONFIG_BASE);
|
|
}
|
|
void norflaship_quad_mode(uint32_t v)
|
|
{
|
|
uint32_t val = 0;
|
|
norflaship_busy_wait();
|
|
val = norflaship_read32(MODE1_CONFIG_BASE);
|
|
if (v)
|
|
val |= QUADMODE_MASK;
|
|
else
|
|
val &= ~QUADMODE_MASK;
|
|
norflaship_write32(val, MODE1_CONFIG_BASE);
|
|
}
|
|
void norflaship_dummyclc(uint32_t v)
|
|
{
|
|
uint32_t val = 0;
|
|
val = norflaship_read32(MODE1_CONFIG_BASE);
|
|
val = (~(DUMMYCLC_MASK) & val) | (v<<DUMMYCLC_SHIFT);
|
|
norflaship_write32(val, MODE1_CONFIG_BASE);
|
|
}
|
|
void norflaship_dummyclcen(uint32_t v)
|
|
{
|
|
uint32_t val = 0;
|
|
val = norflaship_read32(MODE1_CONFIG_BASE);
|
|
if (v)
|
|
val |= DUMMYCLCEN_MASK;
|
|
else
|
|
val &= ~DUMMYCLCEN_MASK;
|
|
norflaship_write32(val, MODE1_CONFIG_BASE);
|
|
}
|
|
void norflaship_addrbyte4(uint32_t v)
|
|
{
|
|
uint32_t val = 0;
|
|
val = norflaship_read32(MODE1_CONFIG_BASE);
|
|
if (v)
|
|
val |= ADDRBYTE4_MASK;
|
|
else
|
|
val &= ~ADDRBYTE4_MASK;
|
|
norflaship_write32(val, MODE1_CONFIG_BASE);
|
|
}
|
|
void norflaship_ruen(uint32_t v)
|
|
{
|
|
uint32_t val = 0;
|
|
val = norflaship_read32(PULL_UP_DOWN_CONFIG_BASE);
|
|
val = (~(SPIRUEN_MASK) & val) | (v<<SPIRUEN_SHIFT);
|
|
norflaship_write32(val, PULL_UP_DOWN_CONFIG_BASE);
|
|
}
|
|
void norflaship_rden(uint32_t v)
|
|
{
|
|
uint32_t val = 0;
|
|
val = norflaship_read32(PULL_UP_DOWN_CONFIG_BASE);
|
|
val = (~(SPIRDEN_MASK) & val) | (v<<SPIRDEN_SHIFT);
|
|
norflaship_write32(val, PULL_UP_DOWN_CONFIG_BASE);
|
|
}
|
|
void norflaship_dualiocmd(uint32_t v)
|
|
{
|
|
uint32_t val = 0;
|
|
val = norflaship_read32(MODE2_CONFIG_BASE);
|
|
val = (~(DUALIOCMD_MASK) & val) | (v<<DUALIOCMD_SHIFT);
|
|
norflaship_write32(val, MODE2_CONFIG_BASE);
|
|
}
|
|
void norflaship_rdcmd(uint32_t v)
|
|
{
|
|
uint32_t val = 0;
|
|
val = norflaship_read32(MODE2_CONFIG_BASE);
|
|
val = (~(RDCMD_MASK) & val) | (v<<RDCMD_SHIFT);
|
|
norflaship_write32(val, MODE2_CONFIG_BASE);
|
|
}
|
|
void norflaship_frdcmd(uint32_t v)
|
|
{
|
|
uint32_t val = 0;
|
|
val = norflaship_read32(MODE2_CONFIG_BASE);
|
|
val = (~(FRDCMD_MASK) & val) | (v<<FRDCMD_SHIFT);
|
|
norflaship_write32(val, MODE2_CONFIG_BASE);
|
|
}
|
|
void norflaship_qrdcmd(uint32_t v)
|
|
{
|
|
uint32_t val = 0;
|
|
val = norflaship_read32(MODE2_CONFIG_BASE);
|
|
val = (~(QRDCMDBIT_MASK) & val) | (v<<QRDCMDBIT_SHIFT);
|
|
norflaship_write32(val, MODE2_CONFIG_BASE);
|
|
}
|
|
uint32_t norflaship_get_rdcmd(void)
|
|
{
|
|
uint32_t val;
|
|
val = norflaship_read32(MODE2_CONFIG_BASE);
|
|
return ((RDCMD_MASK & val) >> RDCMD_SHIFT);
|
|
}
|
|
void norflaship_sleep(void)
|
|
{
|
|
}
|
|
void norflaship_wakeup(void)
|
|
{
|
|
}
|
|
|
|
#endif
|