void ResourceManager::killAll(bool wantInfo) {
int nuked = 0;
// We need to clear the FX queue, because otherwise the sound system
// will still believe that the sound resources are in memory. We also
// need to kill the movie lead-in/out.
_vm->_sound->clearFxQueue(true);
for (uint i = 0; i < _totalResFiles; i++) {
// Don't nuke the global variables or the player object!
if (i == 1 || i == CUR_PLAYER_ID)
continue;
if (_resList[i].ptr) {
if (wantInfo)
Debug_Printf("Nuked %5d: %s\n", i, fetchName(_resList[i].ptr));
remove(i);
nuked++;
}
}
if (wantInfo)
Debug_Printf("Expelled %d resources\n", nuked);
}
/******** Transceiver_Receive **********************************************
// Hardware trigger on IRQ occurred, change the state for transceiver state
// machine in order to read message into microcontroller
// Input: none
// Output: none
// ------------------------------------------------------------------------*/
void Transceiver_Receive ( void )
{
portBASE_TYPE xHigherPriorityTaskWoken;
unsigned char rx[TRANSCEIVER_MAX_PAYLOAD];
if ( !( nrf24l01_irq_pin_active() && nrf24l01_irq_rx_dr_active() ) )
{
// ERROR: we got interupt but the interupt is not packet received
Debug_Printf ( "Transceiver_Receive: Error 0x%x\n", nrf24l01_get_status()&nrf24l01_STATUS_INTERRUPT );
goto exit;
}
//get the payload into data
nrf24l01_read_rx_payload ( rx, TRANSCEIVER_MAX_PAYLOAD );
Debug_NetworkTransceiver_PrintPayload(rx);
if ( pdTRUE != xQueueSendFromISR(Transceiver_RX_Queue, rx, &xHigherPriorityTaskWoken) )
{
// ERROR: Queue is full
Debug_Printf ("Transceiver_Receive: Error 0x%x\n", ERROR_QUEUE_FULL);
if ( FullQueueCallBack != NULL )
xTaskCreate( Transceiver_FullQueueCallBack, ( signed portCHAR * ) "Transceiver_FullQueueCallBack",
DEFAULT_STACK_SIZE, NULL, DEFAULT_PRIORITY, NULL );
goto exit;
}
exit:
nrf24l01_irq_clear_all();
Delay_US(130);
}
/******** Transceiver_SendMessage *******************************************
// unpack transceiver packet and send out
// Input:
// pkt - transceiver packet to be sent
// Output: status
// ------------------------------------------------------------------------*/
unsigned char Transceiver_SendMessage ( TransceiverPacket pkt )
{
unsigned char tx[TRANSCEIVER_MAX_PAYLOAD];
unsigned char index, length;
unsigned char status = SUCCESS;
// validate packet
Debug_NetworkTransceiver_PrintPacket(&pkt);
if ( MAX_DATA_SIZE < pkt.dataSize )
{
status = ERROR_INVALID_PAKCET;
Debug_Printf ("Transceiver_SendMessage: Error 0x%x\n", status);
goto exit;
}
// unpack transceiver packet
tx[SOURCE_ID_INDEX] = pkt.srcID;
tx[DEST_ID_INDEX] = pkt.destID;
tx[MSG_ID_INDEX] = pkt.msgID;
tx[DATA_SIZE_INDEX] = pkt.dataSize;
length = DATA_INDEX;
for ( index = 0; index < pkt.dataSize; index++,length++ )
{
tx[length] = pkt.data[index];
}
Debug_NetworkTransceiver_PrintPayload(tx);
// lock transceiver
while ( xSemaphoreTake(Transceiver_Mutex, portMAX_DELAY) != pdTRUE );
GPIOPinIntDisable ( nrf24l01_IRQ_IOREGISTER, nrf24l01_IRQ_PIN );
nrf24l01_set_as_tx();
nrf24l01_write_tx_payload ( tx, TRANSCEIVER_MAX_PAYLOAD, true );
//wait until the packet has been sent or the maximum number of retries has been active
while( !( nrf24l01_irq_pin_active() && (nrf24l01_irq_tx_ds_active()||nrf24l01_irq_max_rt_active()) ) );
if ( nrf24l01_irq_max_rt_active() )
{
// hit maximum number of retries
nrf24l01_flush_tx();
status = ERROR_MAX_RETRIES;
Debug_Printf ("Transceiver_SendMessage: Error 0x%x\n", status);
}
// reset transceiver
nrf24l01_irq_clear_all();
nrf24l01_set_as_rx(true);
Delay_US(130);
//unlock transceiver
GPIOPinIntEnable ( nrf24l01_IRQ_IOREGISTER, nrf24l01_IRQ_PIN );
while ( xSemaphoreGive(Transceiver_Mutex) != pdTRUE );
exit:
return status;
}
static void initAndroidAudio(_THIS, Uint16 format, int freq, int channels, int bufSizeBytes)
{
JNIEnv *j_env = g_jniAudioInterface.android_env;
if (j_env)
{
int bits = 16;
int bytes = 2;
switch (format)
{
case AUDIO_U8:
case AUDIO_S8:
{
bits = 8;
bytes = 1;
break;
}
}
Debug_Printf("SDL_Audio Native->Java AudioInit_callback");
jint minBufSize = (*j_env)->CallIntMethod(j_env,
g_jniAudioInterface.android_mainActivity, g_jniAudioInterface.getMinBufSize,
freq, bits, channels);
float scale = (SdlDeviceBufferSizeScale<=0) ? 1 : ((SdlDeviceBufferSizeScale > 50) ? 50 : SdlDeviceBufferSizeScale);
scale *= 1.0f/100.0f;
const int roundSize = 1024; // pow2
int reqBufSize = (int)((freq * bytes * channels) * (scale));
reqBufSize = (reqBufSize + (roundSize-1)) & ~(roundSize-1);
Debug_Printf("SDL_Audio Requested BufSize: %d", reqBufSize);
int deviceBufSize = reqBufSize;
if (deviceBufSize < bufSizeBytes)
{
deviceBufSize = bufSizeBytes;
}
if (deviceBufSize < minBufSize)
{
Debug_Printf("Device MinBufSize: %d", minBufSize);
deviceBufSize = minBufSize;
}
Debug_Printf("SDL_Audio Native->Java AudioInit_callback");
(*j_env)->CallVoidMethod(j_env,
g_jniAudioInterface.android_mainActivity, g_jniAudioInterface.initAudio,
freq, bits, channels,
deviceBufSize);
//(freq == 44100) ? (32 * 1024) : (16*1024));
this->hidden->numjShorts = bufSizeBytes/2;
}
}
int ata_sw_reset_dev(ATA_Device_t *ata_dev)
{
int error;
#ifdef ATA_DEBUG
Debug_Printf("ATA reset processing...\n");
#endif
ata_write_reg(ATA_DEVICE_CONTROL_REG, ATA_DEV_CTL_nIEN | ATA_DEV_CTL_SRST);
ata_delay_ms(2);
ata_write_reg(ATA_DEVICE_CONTROL_REG, ATA_DEV_CTL_nIEN);
ata_delay_ms(2);
ata_write_reg(ATA_DEVICE_HEAD_REG, ata_dev->current_dev ? ATA_DRIVE1_MASK : ATA_DRIVE0_MASK);
ata_delay_100ns(ATA_CMD_ISSUE_DELAY);
error = ata_wait_status_bits(ATA_STATUS_BSY|ATA_STATUS_DRDY, ATA_STATUS_DRDY, ATA_CMD_INIT_TIMEOUT);
if(error)
return error;
ata_write_reg(ATA_DEVICE_HEAD_REG, ata_dev->current_dev? ATA_DRIVE1_MASK : ATA_DRIVE0_MASK);
ata_delay_100ns(ATA_CMD_ISSUE_DELAY);
return ATA_NO_ERROR;
}
/******** Transceiver_receiveMessage *****************************************
// dequeue transceiver packet
// Input:
// *pkt - pointer to received message
// Output: status
// ------------------------------------------------------------------------*/
unsigned char Transceiver_ReceiveMessage ( TransceiverPacket *pkt )
{
unsigned char rx[TRANSCEIVER_MAX_PAYLOAD];
unsigned char index;
unsigned char status = SUCCESS;
GPIOPinIntDisable ( nrf24l01_IRQ_IOREGISTER, nrf24l01_IRQ_PIN );
if ( pdPASS == xQueueReceive(Transceiver_RX_Queue, rx, (portTickType)0) )
{
pkt->srcID = rx[SOURCE_ID_INDEX];
pkt->destID = rx[DEST_ID_INDEX];
pkt->msgID = rx[MSG_ID_INDEX];
pkt->dataSize = rx[DATA_SIZE_INDEX];
for ( index = 0; index < pkt->dataSize; index++ )
{
pkt->data[index] = rx[index+PACKET_HEADER_SIZE];
}
Debug_NetworkTransceiver_PrintPacket(pkt);
}
else
{
// empty queue
status = ERROR_QUEUE_EMPTY;
Debug_Printf ("Transceiver_ReceiveMessage 0x%x\n", status);
if ( EmptyQueueCallBack != NULL )
xTaskCreate( Transceiver_EmptyQueueCallBack, ( signed portCHAR * ) "Transceiver_EmptyQueueCallBack",
DEFAULT_STACK_SIZE, NULL, DEFAULT_PRIORITY, NULL );
}
GPIOPinIntEnable ( nrf24l01_IRQ_IOREGISTER, nrf24l01_IRQ_PIN );
return status;
}
static void deinitAndroidAudio(_THIS)
{
JNIEnv *j_env = g_jniAudioInterface.android_env;
if (j_env)
{
Debug_Printf("SDL_Audio Native->Java AudioDeinit_callback");
(*j_env)->CallVoidMethod(j_env,
g_jniAudioInterface.android_mainActivity, g_jniAudioInterface.deinitAudio);
}
}
void Sound::printFxQueue() {
int freeSlots = 0;
for (int i = 0; i < FXQ_LENGTH; i++) {
if (_fxQueue[i].resource) {
const char *type;
switch (_fxQueue[i].type) {
case FX_SPOT:
type = "SPOT";
break;
case FX_LOOP:
type = "LOOP";
break;
case FX_RANDOM:
type = "RANDOM";
break;
case FX_SPOT2:
type = "SPOT2";
break;
case FX_LOOPING:
type = "LOOPING";
break;
default:
type = "UNKNOWN";
break;
}
Debug_Printf("%d: res: %d ('%s') %s (%d) delay: %d vol: %d pan: %d\n",
i, _fxQueue[i].resource,
_vm->_resman->fetchName(_fxQueue[i].resource),
type, _fxQueue[i].type, _fxQueue[i].delay,
_fxQueue[i].volume, _fxQueue[i].pan);
} else {
freeSlots++;
}
}
Debug_Printf("Free slots: %d\n", freeSlots);
}
void ResourceManager::killAllObjects(bool wantInfo) {
int nuked = 0;
for (uint i = 0; i < _totalResFiles; i++) {
// Don't nuke the global variables or the player object!
if (i == 1 || i == CUR_PLAYER_ID)
continue;
if (_resList[i].ptr) {
if (fetchType(_resList[i].ptr) == GAME_OBJECT) {
if (wantInfo)
Debug_Printf("Nuked %5d: %s\n", i, fetchName(_resList[i].ptr));
remove(i);
nuked++;
}
}
}
if (wantInfo)
Debug_Printf("Expelled %d resources\n", nuked);
}
static void ANDROIDAUDIOTRACK_ThreadDeinit(_THIS)
{
Debug_Printf("SDL_Audio Native Audio Thread DeInit");
JNIEnv *j_env = this->hidden->playThreadjenv;
(*j_env)->DeleteGlobalRef(j_env, this->hidden->playThreadjavaSendBuf);
this->hidden->playThreadjavaSendBuf = 0;
if (this->hidden->playThreadEnvAttached)
{
(*g_jvm)->DetachCurrentThread(g_jvm);
}
this->hidden->playThreadEnvAttached = 0;
this->hidden->playThreadjenv = 0;
}
int cf_write_data(unsigned long lba, unsigned long byte_cnt, unsigned char * data_buf)
{
int error;
cf_atapi_enable();
ata_dev->current_dev = ata_cf_info->dev_no;
ata_dev->current_addr_mode = ata_cf_info->addr_mode;
error = ata_write_data_pio(lba, byte_cnt, data_buf);
if(error)
{
#ifdef ATA_DEBUG
Debug_Printf("#%s occured in cf_write_data()!\n", ata_error_to_string(error));
#endif
return error;
}
return ATA_NO_ERROR;
}
static void ANDROIDAUDIOTRACK_ThreadInit(_THIS)
{
Debug_Printf("SDL_Audio Native->Java Audio Thread Init");
JNIEnv *env = NULL;
int status = (*g_jvm)->GetEnv(g_jvm, (void**)&env, JNI_VERSION_1_6);
int attached = 0;
if(status < 0)
{
status = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
attached = 1;
}
this->hidden->playThreadEnvAttached = attached;
this->hidden->playThreadjenv = env;
jshortArray sendBuf = (*env)->NewShortArray(env, this->hidden->numjShorts);
this->hidden->playThreadjavaSendBuf = (*env)->NewGlobalRef(env, sendBuf);
(*env)->DeleteLocalRef(env, sendBuf);
}
int xd_sm_card_indentification(void)
{
int err;
XD_ID_9A_t id_9a;
if(xd_sm_info->card_type == CARD_TYPE_SM)
return XD_SM_NO_ERROR;
err = xd_sm_id_read(XD_ID_READ9A, (unsigned char *)&id_9a);
if(err)
return err;
if(id_9a.XD_CARD_ID != 0xB5)
{
#ifdef XD_SM_DEBUG
Debug_Printf("#XD_CARD_ID error\n");
#endif
//return XD_SM_ERROR_CARD_ID;
}
xd_sm_info->raw_cid = id_9a;
return XD_SM_NO_ERROR;
}
int ata_init_device(ATA_Device_t *ata_dev)
{
/*_phymem_node_t *memmap = Am_GetSystemMem(MEMMAP_DEFAULT, MEMITEM_DMA_DRAM);
if(memmap != NULL)
{
ata_dma_buf = (void *)(memmap->start);
ata_dma_buf_size = memmap->end - memmap->start + 1;
}*/
//memset(ata_dev, 0, sizeof(ATA_Device_t));
int error = ATA_NO_ERROR, dev, dev_existed = 0;
unsigned char reg_data, device_head = 0;
ata_dev->master_disabled = ATA_MASTER_DISABLED;
ata_dev->slave_enabled = ATA_SLAVE_ENABLED;
#ifdef ATA_DEBUG
Debug_Printf("Start to poll ATA status, wait BUSY cleared to zero...\n");
#endif
ata_write_reg(ATA_DEVICE_CONTROL_REG, ATA_DEV_CTL_nIEN);
ata_delay_100ns(ATA_CMD_ISSUE_DELAY);
for(dev=0; dev<2; dev++)
{
if(!dev && ata_dev->master_disabled)
continue;
else if(dev && !ata_dev->slave_enabled)
continue;
if(ata_dev->device_info[dev].device_existed)
{
dev_existed = 1;
continue;
}
reg_data = dev ? ATA_DRIVE1_MASK : ATA_DRIVE0_MASK;
ata_write_reg(ATA_DEVICE_HEAD_REG, reg_data);
ata_delay_ms(2);
error = ata_wait_status_bits(ATA_STATUS_BSY|ATA_STATUS_DRDY, ATA_STATUS_DRDY, ATA_CMD_INIT_TIMEOUT);
if(error)
{
ata_dev->device_info[dev].device_inited = 0;
continue;
}
ata_write_reg(ATA_SECTOR_COUNT_REG, 0x55);
ata_delay_100ns(ATA_CMD_ISSUE_DELAY);
reg_data = ata_read_reg(ATA_SECTOR_COUNT_REG);
if(reg_data != 0x55)
{
ata_dev->device_info[dev].device_inited = 0;
error = ATA_ERROR_HARDWARE_FAILURE;
continue;
}
ata_write_reg(ATA_SECTOR_NUMBER_REG, 0xAA);
ata_delay_100ns(ATA_CMD_ISSUE_DELAY);
reg_data = ata_read_reg(ATA_SECTOR_NUMBER_REG);
if(reg_data != 0xAA)
{
ata_dev->device_info[dev].device_inited = 0;
error = ATA_ERROR_HARDWARE_FAILURE;
continue;
}
ata_dev->device_info[dev].device_existed = 1;
dev_existed = 1;
if(ATA_EIGHT_BIT_ENABLED)
{
device_head = dev ? ATA_DRIVE1_MASK : ATA_DRIVE0_MASK;
ata_dev->ata_param.Device_Head = device_head;
ata_dev->ata_param.Features = 0x01;
ata_dev->ata_param.Command = ATA_SET_FEATURES;
error = ata_set_features(ata_dev);
if(error)
return error;
}
}
if(dev_existed)
{
#if ((defined CF_USE_PIO_DMA) || (defined HD_USE_DMA))
atapi_dma_init();
if (!atapi_dma_done_event)
atapi_dma_done_event = AVSemCreate(0);
#endif
return ATA_NO_ERROR;
}
else
return error;
}
/******** Transceiver_Init *************************************************
// Initialize Transceiver using SPI1
// Input: none
// Output: status
// ------------------------------------------------------------------------*/
unsigned char Transceiver_Init ( void )
{
unsigned char status = SUCCESS;
// create RX queues
Transceiver_RX_Queue = xQueueCreate ( 10, sizeof( unsigned char [TRANSCEIVER_MAX_PAYLOAD] ) );
if ( NULL == Transceiver_RX_Queue )
{
status = ERROR_QUEUE_NOT_CREATED;
Debug_Printf ("Transceiver_Init: Error 0x%x\n", status);
goto exit;
}
// create lock
vSemaphoreCreateBinary(Transceiver_Mutex);
if ( NULL == Transceiver_Mutex )
{
status = ERROR_LOCK_NOT_CREATED;
Debug_Printf ("Transceiver_Init: Error 0x%x\n", status);
goto exit;
}
// initialize spi1
SPI_Init ( SPI1 );
// CE and CSN are output
GPIO_Init ( nrf24l01_CE_PORT, nrf24l01_CE_PIN | nrf24l01_CSN_PIN,
GPIO_DIR_MODE_OUT, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU );
// IRQ is input and interrupt-enabled
GPIO_Init ( nrf24l01_IRQ_PORT, nrf24l01_IRQ_PIN,
GPIO_DIR_MODE_IN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU );
// initialize nRF24L01+, initialize device as receiver, auto-ack
nrf24l01_initialize (
nrf24l01_CONFIG_DEFAULT_VAL | nrf24l01_CONFIG_PWR_UP | nrf24l01_CONFIG_PRIM_RX,
true,
nrf24l01_EN_AA_ENAA_P0,
nrf24l01_EN_RXADDR_DEFAULT_VAL,
nrf24l01_SETUP_AW_DEFAULT_VAL,
nrf24l01_SETUP_RETR_ARD | nrf24l01_SETUP_RETR_ARC_5,
nrf24l01_RF_CH_DEFAULT_VAL,
nrf24l01_RF_SETUP_DEFAULT_VAL,
NULL,
NULL,
nrf24l01_RX_ADDR_P2_DEFAULT_VAL,
nrf24l01_RX_ADDR_P3_DEFAULT_VAL,
nrf24l01_RX_ADDR_P4_DEFAULT_VAL,
nrf24l01_RX_ADDR_P5_DEFAULT_VAL,
NULL,
TRANSCEIVER_MAX_PAYLOAD,
nrf24l01_RX_PW_P1_DEFAULT_VAL,
nrf24l01_RX_PW_P2_DEFAULT_VAL,
nrf24l01_RX_PW_P3_DEFAULT_VAL,
nrf24l01_RX_PW_P4_DEFAULT_VAL,
nrf24l01_RX_PW_P5_DEFAULT_VAL );
// enable IRQ interrupt, active low
GPIO_SetInterruptTask ( nrf24l01_IRQ_PORT, nrf24l01_IRQ_PIN,
GPIO_FALLING_EDGE, 2, Transceiver_Receive );
exit:
return status;
}
int cf_card_init(CF_Card_Info_t * card_info)
{
int error, dev;
//cf_atapi_enable();
//set_atapi_enable(0,cf_m2_enabled);
//set_atapi_enable(0,0);
if(ata_cf_info->inited_flag && !ata_cf_info->removed_flag)
{
cf_atapi_enable();
error = cf_cmd_test();
if(!error)
return error;
}
if(++ata_cf_info->init_retry > CF_INIT_RETRY)
return ATA_ERROR_HARDWARE_FAILURE;
#ifdef ATA_DEBUG
Debug_Printf("\nCF initialization started......\n");
#endif
//save_atapi_io_status();
//if(cf_retry_init)
//set_atapi_io_low();
cf_staff_init();
#ifdef ATA_DEBUG
Debug_Printf("Start to power on and hardware reset...\n");
#endif
cf_hw_reset();
cf_atapi_enable();
//restore_atapi_io_status();
error = ata_init_device(ata_dev);
if(error)
{
#ifdef ATA_DEBUG
Debug_Printf("#%s occured in ata_init_device()!\n", ata_error_to_string(error));
#endif
return error;
}
card_in_event_status[CARD_COMPACT_FLASH] = CARD_EVENT_INSERTED;
error = ata_identify_device(ata_dev);
if(error)
{
#ifdef ATA_DEBUG
Debug_Printf("#%s occured in ata_identify_device()!\n", ata_error_to_string(error));
#endif
return error;
}
for(dev=0; dev<2; dev++)
{
if(!ata_dev->device_info[dev].device_existed || !ata_dev->device_info[dev].device_inited)
continue;
//if((ata_dev->device_info[dev].identify_info.general_configuration != 0x848A)
// && !(ata_dev->device_info[dev].identify_info.general_configuration & 0x0080)) // Bit7: removable media device
// continue;
ata_cf_info->inited_flag = 1;
ata_cf_info->dev_no = dev;
break;
}
if(!ata_cf_info->inited_flag)
{
ata_remove_device(ata_dev, ata_cf_info->dev_no);
error = ATA_ERROR_DEVICE_TYPE;
#ifdef ATA_DEBUG
Debug_Printf("#%s occured in cf_card_init()!\n", ata_error_to_string(error));
#endif
return error;
}
strcpy(ata_cf_info->serial_number, ata_dev->device_info[ata_cf_info->dev_no].serial_number);
strcpy(ata_cf_info->model_number, ata_dev->device_info[ata_cf_info->dev_no].model_number);
#ifdef ATA_DEBUG
Debug_Printf("ATA device%d detected!\n", ata_cf_info->dev_no);
Debug_Printf("Serial Number: %s\n", ata_cf_info->serial_number);
Debug_Printf("Model Number: %s\n", ata_cf_info->model_number);
#endif
ata_cf_info->blk_len = ata_dev->device_info[ata_cf_info->dev_no].sector_size;
ata_cf_info->blk_nums = ata_dev->device_info[ata_cf_info->dev_no].sector_nums;
ata_dev->current_dev = ata_cf_info->dev_no;
ata_dev->current_addr_mode = ata_cf_info->addr_mode;
error = ata_check_data_consistency(ata_dev);
if(error)
{
ata_remove_device(ata_dev, ata_cf_info->dev_no);
ata_cf_info->inited_flag = 0;
#ifdef ATA_DEBUG
Debug_Printf("#%s occured in ata_check_data_consistency()!\n", ata_error_to_string(error));
#endif
return error;
}
#ifdef ATA_DEBUG
Debug_Printf("cf_card_init() is completed successfully!\n\n");
#endif
ata_cf_info->inited_flag = 1;
ata_cf_info->init_retry = 0;
memcpy(card_info, ata_cf_info, sizeof(CF_Card_Info_t));
return ATA_NO_ERROR;
}
//XD Initialization...
int xd_sm_init(XD_SM_Card_Info_t * card_info)
{
int error;
xd_sm_function_init();
#ifdef XD_CARD_SUPPORTED
if(xd_sm_info->card_type == CARD_TYPE_XD)
{
if(xd_sm_info->xd_inited_flag && !xd_sm_info->xd_removed_flag)
{
error = xd_sm_cmd_test();
if(!error)
return error;
}
if(++xd_sm_info->xd_init_retry > XD_SM_INIT_RETRY)
return XD_SM_ERROR_DRIVER_FAILURE;
}
#endif
#ifdef SM_CARD_SUPPORTED
if(xd_sm_info->card_type == CARD_TYPE_SM)
{
if(xd_sm_info->sm_inited_flag && !xd_sm_info->sm_removed_flag)
{
error = xd_sm_cmd_test();
if(!error)
return error;
}
if(++xd_sm_info->sm_init_retry > XD_SM_INIT_RETRY)
return XD_SM_ERROR_DRIVER_FAILURE;
}
#endif
#ifdef XD_SM_DEBUG
Debug_Printf("\nXD/SM initialization started......\n");
#endif
xd_sm_staff_init();
error = xd_sm_reset();
if(error)
{
#ifdef XD_SM_DEBUG
Debug_Printf("#%s error occured in xd_sm_reset()\n", xd_sm_error_to_string(error));
#endif
return error;
}
error = xd_sm_card_capacity_determin();
if(error)
{
#ifdef XD_SM_DEBUG
Debug_Printf("#%s error occured in xd_sm_card_capacity_determin()\n", xd_sm_error_to_string(error));
#endif
return error;
}
#ifdef XD_SM_DEBUG
#ifdef XD_CARD_SUPPORTED
if(xd_sm_info->card_type == CARD_TYPE_XD)
Debug_Printf("The capacitty of this XD card is %s!\n", xd_sm_buf->capacity_str);
#endif
#ifdef SM_CARD_SUPPORTED
if(xd_sm_info->card_type == CARD_TYPE_SM)
Debug_Printf("The capacitty of this SM card is %s!\n", xd_sm_buf->capacity_str);
#endif
#endif
error = xd_sm_card_indentification();
if(error)
{
#ifdef XD_SM_DEBUG
Debug_Printf("#%s error occured in xd_sm_card_indentification()\n", xd_sm_error_to_string(error));
#endif
return error;
}
error = xd_sm_physical_format_determin();
if(error)
{
#ifdef XD_SM_DEBUG
Debug_Printf("#%s error occured in xd_sm_physical_format_determin()\n", xd_sm_error_to_string(error));
#endif
//return error;
}
error = xd_sm_create_logical_physical_table();
if(error)
{
#ifdef XD_SM_DEBUG
Debug_Printf("#%s error occured in xd_sm_create_logical_physical_table()\n", xd_sm_error_to_string(error));
#endif
#if 0
#ifdef XD_SM_DEBUG
Debug_Printf("Try to reconstruct logical-physical convertsion table...\n");
#endif
error = xd_sm_reconstruct_logical_physical_table();
if(error)
{
#ifdef XD_SM_DEBUG
Debug_Printf("Reconstruct logical-physical convertsion table faild!\n");
#endif
return error;
}
#else
return error;
#endif
}
error = xd_sm_check_data_consistency();
if(error)
{
#ifdef XD_SM_DEBUG
Debug_Printf("#%s error occured in xd_sm_check_data_consistency()\n", xd_sm_error_to_string(error));
#endif
return error;
}
error = xd_sm_logical_format_determin();
if(error)
{
#ifdef XD_SM_DEBUG
Debug_Printf("#%s error occured in xd_sm_logical_format_determin()\n", xd_sm_error_to_string(error));
#endif
//return error;
}
#ifdef XD_SM_DEBUG
Debug_Printf("xd_sm_init() is completed successfully!\n\n");
#endif
#ifdef XD_CARD_SUPPORTED
if(xd_sm_info->card_type == CARD_TYPE_XD)
{
xd_sm_info->xd_inited_flag = 1;
xd_sm_info->xd_init_retry = 0;
}
#endif
#ifdef SM_CARD_SUPPORTED
if(xd_sm_info->card_type == CARD_TYPE_SM)
{
xd_sm_info->sm_inited_flag = 1;
xd_sm_info->sm_init_retry = 0;
}
#endif
memcpy(card_info, xd_sm_info, sizeof(XD_SM_Card_Info_t));
return XD_SM_NO_ERROR;
}
//Read data from XD card
int xd_sm_read_data(unsigned long lba, unsigned long byte_cnt, unsigned char * data_buf)
{
int error;
unsigned long data_offset,page_addr;
unsigned short logical_no,physical_no,page_no,page_nums,zone_no,page_cnt;
if(byte_cnt == 0)
{
error = XD_SM_ERROR_PARAMETER;
#ifdef XD_SM_DEBUG
Debug_Printf("#%s error occured in xd_sm_read_data()\n", xd_sm_error_to_string(error));
#endif
return error;
}
if(xd_reset_flag_read)
{
xd_power_on();
}
xd_sm_io_config();
if(xd_reset_flag_read)
{
error = xd_sm_reset();
if (error)
return error;
}
data_offset = 0;
page_nums = (byte_cnt + xd_sm_page_size - 1) / xd_sm_page_size;
while(page_nums)
{
logical_no = lba / xd_sm_pages_per_blk;
zone_no = logical_no / xd_sm_logical_blks_perzone;
logical_no %= xd_sm_logical_blks_perzone;
if((logical_no >= xd_sm_logical_blks_perzone) || (zone_no >= xd_sm_actually_zones))
{
error = XD_SM_ERROR_PARAMETER;
#ifdef XD_SM_DEBUG
Debug_Printf("#%s error occured in xd_sm_read_data()\n", xd_sm_error_to_string(error));
#endif
return error;
}
physical_no = xd_sm_buf->logical_physical_table[zone_no][logical_no];
page_no = lba % xd_sm_pages_per_blk;
page_cnt = page_nums > (xd_sm_pages_per_blk - page_no) ? (xd_sm_pages_per_blk - page_no) : page_nums;
page_addr = (zone_no * xd_sm_physical_blks_perzone + physical_no) * xd_sm_pages_per_blk + page_no;
//In a flash memory device, there might be a logic block that is not allocate to a physcial
//block due to the block not being used. all data shoude be set to FFH when access this logical block
if(physical_no == INVALID_BLOCK_ADDRESS && xd_sm_search_free_block())
{
memset(data_buf+data_offset, 0xFF, page_cnt*xd_sm_page_size);
data_offset += page_cnt*xd_sm_page_size;
lba += page_cnt;
page_nums -= page_cnt;
continue;
}
if(physical_no >= xd_sm_physical_blks_perzone)
{
error = XD_SM_ERROR_PARAMETER;
#ifdef XD_SM_DEBUG
Debug_Printf("#%s error occured in xd_sm_read_data()\n", xd_sm_error_to_string(error));
#endif
return error;
}
error = xd_sm_read_cycle1(0, page_addr, data_buf+data_offset, page_cnt*xd_sm_page_size, xd_sm_buf->redundant_buf);
if(error)
{
#ifdef XD_SM_DEBUG
Debug_Printf("#%s error occured in xd_sm_read_data()\n", xd_sm_error_to_string(error));
#endif
return error;
}
#ifdef AMLOGIC_CHIP_SUPPORT
data_offset += ((unsigned long)data_buf == 0x3400000) ? 0 : page_cnt*xd_sm_page_size;
#else
data_offset += page_cnt*xd_sm_page_size;
#endif
lba += page_cnt;
page_nums -= page_cnt;
}
return XD_SM_NO_ERROR;
}
int xd_sm_read_cycle2(unsigned char column_addr, unsigned long page_addr, unsigned char *data_buf, unsigned long data_cnt, unsigned char *redundant_buf)
{
int err;
unsigned long data_nums = 0, data_offset = 0, read_cnt;
if(xd_sm_page_size != XD_SM_SECTOR_SIZE)
return XD_SM_ERROR_PARAMETER;
xd_sm_cmd_input_cycle(XD_SM_READ2, XD_SM_WRITE_DISABLED);
xd_sm_addr_input_cycle((page_addr << 8)|column_addr, xd_sm_buf->addr_cycles);
#ifdef XD_CARD_SUPPORTED
if(xd_sm_info->card_type == CARD_TYPE_XD)
{
xd_set_dat0_7_input();
xd_sm_delay_60ns(); // Tar2 = 50ns
}
#endif
#ifdef SM_CARD_SUPPORTED
if(xd_sm_info->card_type == CARD_TYPE_SM)
{
sm_set_dat0_7_input();
xd_sm_delay_100ns(2); // Tar2 = 150ns
}
#endif
read_cnt = xd_sm_page_size - (XD_SM_SECTOR_SIZE/2 + column_addr);
while(data_nums < data_cnt)
{
err = xd_sm_wait_ready(XD_BUSY_TIME_R);
if(err)
{
#ifdef XD_CARD_SUPPORTED
if(xd_sm_info->card_type == CARD_TYPE_XD)
xd_set_ce_disable();
#endif
#ifdef SM_CARD_SUPPORTED
if(xd_sm_info->card_type == CARD_TYPE_SM)
sm_set_ce_disable();
#endif
return err;
}
xd_sm_delay_20ns(); // Trr = 20ns
#ifdef XD_SM_ECC_CHECK
xd_sm_serial_read_cycle(xd_sm_buf->page_buf, read_cnt, redundant_buf, xd_sm_redundant_size);
err = xd_sm_check_page_ecc(xd_sm_buf->page_buf, redundant_buf);
if(err)
{
if(err == ECC_ERROR_CORRECTED)
{
#ifdef XD_SM_DEBUG
Debug_Printf("Data ECC error occured, but corrected!\n");
#endif
}
else
{
#ifdef XD_SM_DEBUG
err = XD_SM_ERROR_ECC;
Debug_Printf("#%s error occured in xd_sm_read_data()\n", xd_sm_error_to_string(err));
#endif
}
}
#ifdef AMLOGIC_CHIP_SUPPORT
if((unsigned long)data_buf == 0x3400000)
{
for(int i=0; i<read_cnt; i++)
{
WRITE_BYTE_TO_FIFO(xd_sm_buf->page_buf[i]);
xd_sm_delay_100ns(1);
}
}
else
#endif
{
memcpy(data_buf+data_offset, xd_sm_buf->page_buf, read_cnt);
}
#else
xd_sm_serial_read_cycle(data_buf+data_offset, read_cnt, redundant_buf, xd_sm_redundant_size);
#endif
#ifdef AMLOGIC_CHIP_SUPPORT
data_offset += ((unsigned long)data_buf == 0x3400000 ? 0 : read_cnt);
#else
data_offset += read_cnt;
#endif
redundant_buf += xd_sm_redundant_size;
data_nums += read_cnt;
read_cnt = xd_sm_page_size;
}
#ifdef XD_CARD_SUPPORTED
if(xd_sm_info->card_type == CARD_TYPE_XD)
{
xd_set_ce_disable();
xd_sm_delay_100ns(1); // Tceh = 100ns
}
#endif
#ifdef SM_CARD_SUPPORTED
if(xd_sm_info->card_type == CARD_TYPE_SM)
{
sm_set_ce_disable();
xd_sm_delay_100ns(3); // Tceh = 250ns
}
#endif
err = xd_sm_wait_ready(BUSY_TIME_TCRY);
return err;
}
//Write data to XD card
int xd_sm_write_data(unsigned long lba, unsigned long byte_cnt, unsigned char * data_buf)
{
int error,i,j,k;
unsigned long data_offset,page_addr,offset;
unsigned short logical_no,physical_no,page_no,page_nums,zone_no,page_max,page_cnt;
unsigned short free_blk_no,block_addr;
unsigned char *page_buf;
if(byte_cnt == 0)
{
error = XD_SM_ERROR_PARAMETER;
#ifdef XD_SM_DEBUG
Debug_Printf("#%s error occured in xd_sm_write_data()\n", xd_sm_error_to_string(error));
#endif
return error;
}
if(xd_sm_info->read_only_flag)
{
error = XD_SM_ERROR_DRIVER_FAILURE;
#ifdef XD_SM_DEBUG
Debug_Printf("#%s error occured in xd_sm_write_data()\n", xd_sm_error_to_string(error));
#endif
return error;
}
if(xd_reset_flag_write)
{
xd_power_on();
}
xd_sm_io_config();
if(xd_reset_flag_write)
{
error = xd_sm_reset();
if (error)
return error;
}
data_offset = 0;
page_nums = (byte_cnt + xd_sm_page_size - 1) / xd_sm_page_size;
while(page_nums)
{
logical_no = lba / xd_sm_pages_per_blk;
zone_no = logical_no / xd_sm_logical_blks_perzone;
logical_no %= xd_sm_logical_blks_perzone;
page_no = lba % xd_sm_pages_per_blk;
block_addr = xd_sm_trans_logical_address(logical_no);
if((logical_no >= xd_sm_logical_blks_perzone) || (zone_no >= xd_sm_actually_zones))
{
error = XD_SM_ERROR_PARAMETER;
#ifdef XD_SM_DEBUG
Debug_Printf("#%s error occured in xd_sm_write_data()\n", xd_sm_error_to_string(error));
#endif
return error;
}
free_blk_no = xd_sm_find_free_block(zone_no);
if(free_blk_no == INVALID_BLOCK_ADDRESS)
{
error = XD_SM_ERROR_NO_FREE_BLOCK;
#ifdef XD_SM_DEBUG
Debug_Printf("#%s error occured in xd_sm_write_data()\n", xd_sm_error_to_string(error));
#endif
return error;
}
page_addr = (zone_no * xd_sm_physical_blks_perzone + free_blk_no) * xd_sm_pages_per_blk;
error = xd_sm_auto_block_erase(page_addr);
if(error)
{
xd_sm_clear_block_free(zone_no, free_blk_no);
//continue;
return error;
}
physical_no = xd_sm_buf->logical_physical_table[zone_no][logical_no];
if(physical_no == INVALID_BLOCK_ADDRESS)
{
memset(xd_sm_buf->page_buf, 0xFF, xd_sm_page_size);
page_max = (page_no+page_nums) < xd_sm_pages_per_blk ? (page_no+page_nums) : xd_sm_pages_per_blk;
page_cnt = 0;
offset = data_offset;
for(i=0; i<xd_sm_pages_per_blk; i++)
{
page_addr = (zone_no * xd_sm_physical_blks_perzone + free_blk_no) * xd_sm_pages_per_blk + i;
if((i >= page_no) && (i < page_max))
{
page_buf = data_buf+offset;
offset += xd_sm_page_size;
page_cnt++;
}
else
{
page_buf = xd_sm_buf->page_buf;
}
xd_sm_format_redundant_area(page_buf, xd_sm_buf->redundant_buf, block_addr);
error = xd_sm_auto_page_program(page_addr, page_buf, xd_sm_buf->redundant_buf);
if(error)
{
#ifdef XD_SM_DEBUG
Debug_Printf("#%s error occured in xd_sm_write_data()\n", xd_sm_error_to_string(error));
#endif
//return error;
break;
}
}
if(error)
continue;
data_offset = offset;
lba += page_cnt;
page_nums -= page_cnt;
xd_sm_clear_block_free(zone_no, free_blk_no);
xd_sm_buf->logical_physical_table[zone_no][logical_no] = free_blk_no;
}
else
{
page_max = (page_no+page_nums) < xd_sm_pages_per_blk ? (page_no+page_nums) : xd_sm_pages_per_blk;
page_cnt = 0;
offset = data_offset;
for(i=0; i<page_no; i++)
{
error = xd_sm_copy_page(zone_no, physical_no, i, free_blk_no, i);
if(error)
{
error = XD_SM_ERROR_COPY_PAGE;
#ifdef XD_SM_DEBUG
Debug_Printf("#%s error occured in xd_sm_write_data()\n", xd_sm_error_to_string(error));
#endif
//return error;
break;
}
}
for(j=page_no; j<page_max; j++)
{
xd_sm_format_redundant_area(data_buf+offset, xd_sm_buf->redundant_buf, block_addr);
page_addr = (zone_no * xd_sm_physical_blks_perzone + free_blk_no) * xd_sm_pages_per_blk + j;
error = xd_sm_auto_page_program(page_addr, data_buf+offset, xd_sm_buf->redundant_buf);
if(error)
{
#ifdef XD_SM_DEBUG
Debug_Printf("#%s error occured in xd_sm_write_data()\n", xd_sm_error_to_string(error));
#endif
//return error;
break;
}
offset += xd_sm_page_size;
page_cnt++;
}
if(error)
continue;
for(k=page_max; k<xd_sm_pages_per_blk; k++)
{
error = xd_sm_copy_page(zone_no, physical_no, k, free_blk_no, k);
if(error)
{
error = XD_SM_ERROR_COPY_PAGE;
#ifdef XD_SM_DEBUG
Debug_Printf("#%s error occured in xd_sm_write_data()\n", xd_sm_error_to_string(error));
#endif
//return error;
break;
}
}
if(error)
continue;
data_offset = offset;
lba += page_cnt;
page_nums -= page_cnt;
page_addr = (zone_no * xd_sm_physical_blks_perzone + physical_no) * xd_sm_pages_per_blk;
error = xd_sm_auto_block_erase(page_addr);
if(error)
{
error = XD_SM_ERROR_BLOCK_ERASE;
#ifdef XD_SM_DEBUG
Debug_Printf("#%s error occured in xd_sm_write_data()\n", xd_sm_error_to_string(error));
#endif
//return error;
}
xd_sm_set_block_free(zone_no, physical_no);
xd_sm_clear_block_free(zone_no, free_blk_no);
xd_sm_buf->logical_physical_table[zone_no][logical_no] = free_blk_no;
}
}
return XD_SM_NO_ERROR;
}
