boolean _29wsxxxN_erase
(
/* [IN] the flash information structure */
IO_FLASHX_STRUCT_PTR dev_ptr,
/* [IN] the sector to erase */
char _PTR_ input_sect_ptr,
/* [IN] the sector size */
_mem_size sector_size
)
{ /* Body */
volatile uint_16 _PTR_ sect16_ptr;
uint_32 result = FLASH_READY;
uint_32 tmp1;
uint_32 time0;
/* test for flash write protect */
if (_29wsxxxN_test_lock_bits(dev_ptr) == LOCKED) {
return FLASH_WRITE_PROTECT;
}/* Endif */
if (dev_ptr->WIDTH == 16) {
sect16_ptr = (volatile uint_16 _PTR_)input_sect_ptr;
_int_disable();
/* unlock flash */
*( sect16_ptr + 0x555 ) = 0x00AA;
*( sect16_ptr + 0x2AA ) = 0x0055;
/* setup command */
*( sect16_ptr + 0x555 ) = 0x0080;
/* unlock */
*( sect16_ptr + 0x555 ) = 0x00AA;
*( sect16_ptr +0x2AA ) = 0x0055;
/* Sector erase */
*( sect16_ptr ) = 0x0030;
_int_enable();
/* erase check */
tmp1 = *sect16_ptr;
/* wait, until DQ3 = 0 or tSEA=50us */
time0 = _time_get_microseconds();
while(!(tmp1 & DQ3) && (_time_get_microseconds()-time0)<50) {
tmp1 = *sect16_ptr;
}
_io_flashx_wait_us(4);
result = _29wsxxxN_test_erase_cmd(input_sect_ptr, (uint_16)0xFFFF);
}
else {
result = FLASH_UNSUPPORTED_BUS_SIZE;
}
return result == FLASH_READY;
} /* Endbody */
void _io_flashx_wait_us
(
/* [IN] the time to spin wait for */
_mqx_int wait_us
)
{/* Body */
_mqx_int total_us = 0;
_mqx_int start_us;
_mqx_int end_us;
start_us = (int_32) _time_get_microseconds();
while (total_us < wait_us) {
end_us = (int_32) _time_get_microseconds();
if (end_us > start_us) {
total_us += (end_us - start_us);
} /* Endif */
start_us = end_us;
} /* Endwhile */
} /* Endbody */
/*!
* \private
*
* \brief Writes data to the lightweight log.
*
* \param[in] log_number Log number of a previously created lightweight log.
* \param[in] p1 Data to be written into the log entry.
* \param[in] p2 Data to be written into the log entry.
* \param[in] p3 Data to be written into the log entry.
* \param[in] p4 Data to be written into the log entry.
* \param[in] p5 Data to be written into the log entry.
* \param[in] p6 Data to be written into the log entry.
* \param[in] p7 Data to be written into the log entry.
*
* \return MQX_OK
* \return LOG_FULL (Log is full and LOG_OVERWRITE is not set.)
* \return LOG_DISABLED (Log is disabled.)
* \return LOG_DOES_NOT_EXIST (Log_number was not created.)
* \return MQX_INVALID_COMPONENT_HANDLE (Log component data is not valid.)
*
* \see _lwlog_write
*/
_mqx_uint _lwlog_write_internal
(
_mqx_uint log_number,
_mqx_max_type p1,
_mqx_max_type p2,
_mqx_max_type p3,
_mqx_max_type p4,
_mqx_max_type p5,
_mqx_max_type p6,
_mqx_max_type p7
)
{ /* Body */
KERNEL_DATA_STRUCT_PTR kernel_data;
LWLOG_COMPONENT_STRUCT_PTR log_component_ptr;
LWLOG_HEADER_STRUCT_PTR log_header_ptr;
_mqx_max_type *data_ptr;
LWLOG_ENTRY_STRUCT_PTR log_ptr;
#if MQX_LWLOG_TIME_STAMP_IN_TICKS == 0
TIME_STRUCT time;
MQX_TICK_STRUCT ticks;
#endif
_GET_KERNEL_DATA(kernel_data);
log_component_ptr = (LWLOG_COMPONENT_STRUCT_PTR) kernel_data->KERNEL_COMPONENTS[KERNEL_LWLOG];
log_header_ptr = log_component_ptr->LOGS[log_number];
#if MQX_CHECK_VALIDITY
if (log_component_ptr->VALID != LWLOG_VALID)
{
return (MQX_INVALID_COMPONENT_HANDLE);
} /* Endif */
#endif
#if MQX_CHECK_ERRORS
if (log_header_ptr == NULL)
{
return (LOG_DOES_NOT_EXIST);
} /* Endif */
#endif
if (!(log_header_ptr->FLAGS & LWLOG_ENABLED))
{
return (LOG_DISABLED);
} /* Endif */
log_ptr = log_header_ptr->WRITE_PTR->NEXT_PTR;
if (log_header_ptr->CURRENT_ENTRIES >= log_header_ptr->MAX_ENTRIES)
{
if (log_header_ptr->FLAGS & LOG_OVERWRITE)
{
if (log_ptr == log_header_ptr->READ_PTR)
{
log_header_ptr->READ_PTR = log_ptr->NEXT_PTR;
} /* Endif */
log_header_ptr->OLDEST_PTR = log_ptr->NEXT_PTR;
}
else
{
return (LOG_FULL);
} /* Endif */
}
else
{
log_header_ptr->CURRENT_ENTRIES++;
} /* Endif */
#if MQX_LWLOG_TIME_STAMP_IN_TICKS == 0
log_ptr->MICROSECONDS = (uint32_t)_time_get_microseconds();
PSP_ADD_TICKS(&kernel_data->TIME, &kernel_data->TIME_OFFSET, &ticks);
PSP_TICKS_TO_TIME(&ticks, &time);
log_ptr->SECONDS = time.SECONDS;
log_ptr->MILLISECONDS = time.MILLISECONDS;
#else
log_ptr->TIMESTAMP = kernel_data->TIME;
log_ptr->TIMESTAMP.HW_TICKS = _time_get_hwticks();
PSP_ADD_TICKS(&log_ptr->TIMESTAMP, &kernel_data->TIME_OFFSET,
&log_ptr->TIMESTAMP);
#endif
log_ptr->SEQUENCE_NUMBER = log_header_ptr->NUMBER++;
data_ptr = &log_ptr->DATA[0];
*data_ptr++ = p1;
*data_ptr++ = p2;
*data_ptr++ = p3;
*data_ptr++ = p4;
*data_ptr++ = p5;
*data_ptr++ = p6;
*data_ptr = p7;
log_header_ptr->WRITE_PTR = log_ptr;
return (MQX_OK);
} /* Endbody */
/*!
* \brief Writes data to the log.
*
* The function writes the log entry only if it returns MQX_OK.
*
* \param[in] log_number Log number of a previously created log.
* \param[in] number_of_parameters Number of parameters to write.
*
* \return MQX_OK
* \return MQX_COMPONENT_DOES_NOT_EXIST (Log component is not created.)
* \return MQX_INVALID_COMPONENT_HANDLE (Log component data is not valid.)
* \return LOG_INVALID (Log_number is out of range.)
* \return LOG_DOES_NOT_EXIST (Log_number was not created.)
* \return LOG_DISABLED (Log is disabled.)
* \return LOG_FULL (Log is full and LOG_OVERWRITE is not set.)
*/
_mqx_uint _log_write
(
_mqx_uint log_number,
_mqx_uint number_of_parameters,
...
)
{ /* Body */
MQX_TICK_STRUCT ticks;
TIME_STRUCT time;
KERNEL_DATA_STRUCT_PTR kernel_data;
LOG_COMPONENT_STRUCT_PTR log_component_ptr;
LOG_HEADER_STRUCT_PTR log_header_ptr;
_mqx_uint_ptr data_ptr;
va_list param_ptr;
_mqx_uint us;
_mqx_uint i;
_mqx_uint size;
_mqx_uint old_size;
_GET_KERNEL_DATA(kernel_data);
#if MQX_CHECK_ERRORS
if (kernel_data->KERNEL_COMPONENTS[KERNEL_LOG] == NULL)
{
return(MQX_COMPONENT_DOES_NOT_EXIST);
} /* Endif */
#endif
log_component_ptr = (LOG_COMPONENT_STRUCT_PTR)
kernel_data->KERNEL_COMPONENTS[KERNEL_LOG];
#if MQX_CHECK_VALIDITY
if (log_component_ptr->VALID != LOG_VALID)
{
return(MQX_INVALID_COMPONENT_HANDLE);
} /* Endif */
#endif
#if MQX_CHECK_ERRORS
if (log_number >= LOG_MAXIMUM_NUMBER)
{
return(LOG_INVALID);
} /* Endif */
#endif
log_header_ptr = log_component_ptr->LOGS[log_number];
#if MQX_CHECK_ERRORS
if (log_header_ptr == NULL)
{
return(LOG_DOES_NOT_EXIST);
} /* Endif */
#endif
if (! (log_header_ptr->FLAGS & LOG_ENABLED))
{
return(LOG_DISABLED);
} /* Endif */
size = sizeof(LOG_ENTRY_STRUCT)/sizeof(_mqx_uint) + number_of_parameters;
#if MQX_CHECK_ERRORS
if (size > log_header_ptr->MAX)
{
/*
* The request is to log an entry larger than the
* entire log. Reject this.
*/
return(LOG_FULL);
} /* Endif */
#endif
va_start(param_ptr, number_of_parameters);
i = number_of_parameters + 1;
_INT_DISABLE();
if ((log_header_ptr->SIZE + size) > log_header_ptr->MAX)
{
if (log_header_ptr->FLAGS & LOG_OVERWRITE)
{
/* Remove leading elements until it can fit */
while ((log_header_ptr->SIZE + size) > log_header_ptr->MAX)
{
data_ptr = log_header_ptr->LOG_READ;
old_size = *data_ptr;
log_header_ptr->SIZE -= old_size;
data_ptr += old_size;
if (data_ptr >= log_header_ptr->LOG_END)
{
data_ptr = log_header_ptr->LOG_START +
(data_ptr - log_header_ptr->LOG_END);
} /* Endif */
if (log_header_ptr->LOG_NEXT == log_header_ptr->LOG_READ)
{
/* Move up the next read pointer */
log_header_ptr->LOG_NEXT = data_ptr;
} /* Endif */
log_header_ptr->LOG_READ = data_ptr;
} /* Endwhile */
}
else
{
_INT_ENABLE();
va_end(param_ptr);
return(LOG_FULL);
} /* Endif */
} /* Endif */
log_header_ptr->SIZE += size;
data_ptr = log_header_ptr->LOG_WRITE;
log_header_ptr->LAST_LOG = data_ptr;
*data_ptr++ = size;
if (data_ptr == log_header_ptr->LOG_END)
{
data_ptr = log_header_ptr->LOG_START;
} /* Endif */
*data_ptr++ = log_header_ptr->NUMBER++;
if (data_ptr == log_header_ptr->LOG_END)
{
data_ptr = log_header_ptr->LOG_START;
} /* Endif */
us = (_mqx_uint)_time_get_microseconds();
PSP_ADD_TICKS(&kernel_data->TIME, &kernel_data->TIME_OFFSET, &ticks);
PSP_TICKS_TO_TIME(&ticks, &time);
#if MQX_INT_SIZE_IN_BITS >= 32
*data_ptr++ = (_mqx_uint)time.SECONDS;
#else
#if PSP_ENDIAN == MQX_BIG_ENDIAN
*data_ptr++ = (_mqx_uint)((time.SECONDS >> MQX_INT_SIZE_IN_BITS) &
MAX_MQX_UINT);
if (data_ptr == log_header_ptr->LOG_END)
{
data_ptr = log_header_ptr->LOG_START;
} /* Endif */
*data_ptr++ = (_mqx_uint)(time.SECONDS & MAX_MQX_UINT);
#else
*data_ptr++ = (_mqx_uint)(time.SECONDS & MAX_MQX_UINT);
if (data_ptr == log_header_ptr->LOG_END)
{
data_ptr = log_header_ptr->LOG_START;
} /* Endif */
*data_ptr++ = (_mqx_uint)((time.SECONDS >> MQX_INT_SIZE_IN_BITS) &
MAX_MQX_UINT);
#endif
#endif
if (data_ptr >= log_header_ptr->LOG_END)
{
data_ptr = log_header_ptr->LOG_START;
} /* Endif */
#if PSP_MEMORY_ADDRESSING_CAPABILITY >= 32
*data_ptr++ = time.MILLISECONDS;
if (data_ptr == log_header_ptr->LOG_END)
{
data_ptr = log_header_ptr->LOG_START;
} /* Endif */
*data_ptr++ = us;
#elif MQX_INT_SIZE_IN_BITS == 32
#if PSP_ENDIAN == MQX_LITTLE_ENDIAN
*data_ptr++ = time.MILLISECONDS | (us << 16);
#else
*data_ptr++ = us | (time.MILLISECONDS << 16);
#endif
#else
*data_ptr++ = (_mqx_uint)time.MILLISECONDS;
if (data_ptr == log_header_ptr->LOG_END)
{
data_ptr = log_header_ptr->LOG_START;
} /* Endif */
*data_ptr++ = us;
#endif
if (data_ptr >= log_header_ptr->LOG_END)
{
data_ptr = log_header_ptr->LOG_START;
} /* Endif */
while (--i)
{
*data_ptr++ = (_mqx_uint)va_arg(param_ptr, _mqx_uint);
if (data_ptr == log_header_ptr->LOG_END)
{
data_ptr = log_header_ptr->LOG_START;
} /* Endif */
} /* Endwhile */
log_header_ptr->LOG_WRITE = data_ptr;
_INT_ENABLE();
va_end(param_ptr);
return(MQX_OK);
} /* Endbody */
