void _reentrant USBInsertionMonitorTask(void) { USHORT usStatus; BOOL bInserted = FALSE; WORD i,j; WORD iWaitCount; // Check for USB disconnect while(1) { usb_device_get_status(USB_STATUS_CONNECTION,&usStatus); switch(usStatus) { case USB_CONNECTED: bInserted=TRUE; break; default: if(bInserted)//if we've been inserted, and now we're not, lets shut down { // #ifdef DEVICE_3410 // 3410 still has power when removed from usb. #ifdef CHKDSK UsbMscCheckDiskAll(); #endif // #endif // TODO - put this back in later if needed // Clear the display // ClearDisplay(); // We need to immediately pull Write Protect low to protect the NANDs and // to reset the Renesas part (same line). HW_GPFLASH_CSR1R.B.WP0 = 0; // We need to clean up any media transactions that may be hanging // As best we can :) // stmp4770 and stmp4795, Remove drive flush on USB disconnect for NAND devices. // Drive flush still necessary for MMC media, to properly close multi-writes // that may be pending between SCSI commands. for(i=0;i<g_wUsbMscNumDevices;i++) { for(j=0;j<UsbMscDevice[i].wNumLunsSupported;j++) { if(UsbMscDevice[i].Lun[j].bMediaIsRemovable == TRUE) { DriveFlush(UsbMscDevice[i].Lun[j].wFileSystemDriveNumber); } } } //Do not leave. Wait for 5V to be removed. //Monitor D+/- and reset if it returns. HW_USBCSR.B.PLUGGEDIN_EN = 1; iWaitCount = 0; //ensure 5V Disconnect IRQ is enabled SysSetIrqLevel(HW_SR_IM_L2_SETMASK); while(HW_USBCSR.B.VBUSSENSE) { //if USB is plugged-in. Break loop and reset to return to USBMSC. if(HW_USBCSR.B.PLUGGEDIN) { break; } //wait a bit SysWait(200); if(iWaitCount > 10) { break; // if we waited a couple secs, time to break } else { iWaitCount++; //increment wait count } } SysWait(200); // Shut down SystemShutdown(); // Reset the device SystemReset(); } } SysWait(USB_WATCH_CALL_BACK_DELAY); } }
; they are included in dcc.xref #pragma endasm //////////////////////////////////////////////////////////////////////////////// // Code //////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////// // //> Name: Project_Startup // // Type: Function // // Description: A main entry point called by the kernel // // Inputs: none // // Outputs: none // // Notes: none //< //////////////////////////////////////////////////////////////////////////////// //int jCurrLimEntry=1; void Project_Startup(void) { //BOOL bDone; WORD i; //WORD j; //DWORD wTime; //WORD wCount = 5000; //RETCODE retCode; USHORT usStatus; BOOL bLowPowerUsbStickyBitReadResult = FALSE; //bDone = FALSE; // Startup // Run debug initialization (DebugInit()== SUCCESS); // Let's start with a clean system SystemShutdown(); #pragma asm extern FTimeInit jsr FTimeInit #pragma endasm // In order to free up P memory space, we're doing the same trick as above for // some other initialization functions. { unsigned int ClearSize = (unsigned int)(&_lc_u_y_MMC_bssclear_end-&_lc_u_y_MMC_bssclear_start); unsigned int CopySize = (unsigned int)(&_lc_u_y_OVLY_copy_end-&_lc_u_y_OVLY_copy_start); CopyCodeIntoBootmanagerArea((_Y WORD *)&_lc_u_y_OVLY_copy_start, (_P WORD * _P)&_lc_u_p_OVLY_start, CopySize); // In either case(MMC or NAND only), clear the bss section. ClearMemory((_Y WORD *)&_lc_u_y_MMC_bssclear_start, ClearSize); }
/*------------------------------------------------------------------------------ FUNCTION NAME: Main_EndApp DESCRIPTION: Application end procedure PARAMETERS: - INPUT: - OUTPUT: RETURN: NOTES: ------------------------------------------------------------------------------*/ void Main_EndApp (t_uchar With_Confirmation, t_uchar Do_Exit) { int LCDContrastOffset; /* Pedido de confirmacion para cierre del sistema */ if (With_Confirmation) { char Key; Key = Display_Aviso (S4160, S4161, NULL, NULL, 80, (t_uchar) AVISO_BEEP, TRUE); if (Key == KEY_ESC) return; } /* Save global database */ DB_SaveDBGlobal (); /* Ramdisk exit function */ RamDisk_End (); /* Restore LCD contrast */ DB_GetLCDContrastOffset (&LCDContrastOffset); Util_SetLCDContrast (-LCDContrastOffset); #if !defined (NT_VERSION) GrphDisp_End(); #endif /* MAEL Version */ #if defined (FEDORA_VERSION) TCPIP_Close(); #else #if defined(PC_TERMINAL) && !defined(NT_VERSION) /* Disable graphics */ closegraph(); /* Disable serial port communications */ Uart_DisChannels (); #if defined (DOSX286) /* Restore Ctrl-Break handler */ DosSetRealProtVec (0x1B, OldCtrlBrkProt, OldCtrlBrkReal, NULL, NULL); DosSetRealProtVec (0x23, OldCtrlCProt, OldCtrlCReal, NULL, NULL); #endif #endif #endif /* MAEL Version */ /* Keyboard exit function */ Kb_End (); /* MAEL Version */ #if defined (FEDORA_VERSION) Devices_CD_Close (); Devices_Scanner_Close (); #if !defined(DEBUG) /* Shutdown */ if (!DB_AutoRestartAppFlag ()) SystemShutdown(); #endif #endif if (Do_Exit) exit(0); } /* Main_EndApp */
// Function Description: // Inputs: no parameters // Returns: no register returns // Notes: void _reentrant UserInterfaceTask(void) { USHORT usStatus; //int iTransferRate; WORD State=SCSI_IDLE; //Message Msg; int iDelay = HALF_SEC_UPDATE_RATE; BOOL bNeedToReEnable = FALSE; int Write_State_Persisten_Time = WRITE_STATE_PERSISTENT_TIME; int i; for (i=10;i< USER_INTERFACE_STACK_SIZE;i++ ) { g_UserInterfaceStack[i]=0xc0ffee; } Init5VSense(); USBLCDDisplayInit(); SysWait(250); while(1) { #if (NUM_REMOVABLE_MEDIA == 1) // Wait until we have decided whether device is in MTP vs. MSC mode // Media detection uses different code for the two modes if(g_MtpArbitrationDone) { if(MTPDetected) { MtpCheckExternalMedia(); } else { ScsiInsertionRemovalCode(); } } #endif usb_device_get_status(USB_STATUS, &usStatus); if(usStatus == USB_STATE_SUSPENDED) { SysWait(UPDATE_RATE); } else { SysPostMessage(2,LCD_END_FRAME); SysWait(UPDATE_RATE); SysPostMessage(2,LCD_BEGIN_FRAME); USBLCDCheckForTransfers(); if(g_bServiceDCDC) { ServiceDCDC(); //Service DCDC converter } #ifdef BATTERY_CHARGE // For 3500 Battery Monitoring must be done only during battery charging // The rest of the time the system operates from USB +5V // and battery monitoring does not make any sense. // Also, battery brownout always triggered if sys operates w/ no battery. //Only charge if we're in high usb current mode. March 11 2005 addition if(usb_get_current_limit() <= 100) //mA { BatteryChargeDisableCharging(TRUE); // until next stmp bootup } else { if(usStatus != USB_STATE_CONFIGURED) { if(bNeedToReEnable == FALSE) { BatteryChargeDisableCharging(FALSE); bNeedToReEnable = TRUE; } } else { if(bNeedToReEnable == TRUE) { BatteryChargeEnableCharging(); bNeedToReEnable = FALSE; } BatteryChargeStateMachine(); } } #endif #if defined(BATTERY_CHARGE) // I only want to update the Battery icon once per 1/2 second // but always check and average battery level. USBLCDCheckBatteryLevel(); #endif if (iDelay-- <= 0) { #if defined(BATTERY_CHARGE) USBLCDDisplayBatteryLevel(); #endif USBLCDCheckDBStoreDirty(); iDelay = HALF_SEC_UPDATE_RATE; } // g_wActivityState - This global is set by other code to indicate the state of the // system. // Can be set by SCSI code, or MTP code (depending on the connection) // Modification added for MTP/MSC system // In MTP/MSC, MSC uses overlays thus we need to be careful yielding to the kernel for display updates. // This can not be done in the middle of a multi write sequence. // The code was modified and uses the same technique as a monostable device. Each time scsi write is entered // the global g_wActivityStateMultiWrite is set to SCSI_WRITING. This will trigger the monostable for // WRITE_STATE_PERSISTENT_TIME miliseconds. If a new scsi write command arrives prior WRITE_STATE_PERSISTENT_TIME // expires, the new scsi write command re-starts the monostable for a new full WRITE_STATE_PERSISTENT_TIME ms. // Once the monostable time expires without no new SCSI write commands, the state will switch to IDLE and display // will return to the READY state. // The display task has a chance to run everytime a new SCSI write command arrives. There is no display refresh // during mutltiwrites. if((g_wActivityStateMultiWrite == SCSI_WRITING) || (Write_State_Persisten_Time < WRITE_STATE_PERSISTENT_TIME)) { if(g_wActivityStateMultiWrite == SCSI_WRITING) { g_wActivityStateMultiWrite = SCSI_IDLE; Write_State_Persisten_Time = 0; if(State != SCSI_WRITING) { State = SCSI_WRITING; USBLCDWriting(); } } else { Write_State_Persisten_Time += UPDATE_RATE; } } else { if(State!= g_wActivityState ) { State = g_wActivityState; switch(State) { case SCSI_IDLE: USBLCDIdle(); break; case SCSI_READING: USBLCDReading(); break; case SCSI_WRITING: USBLCDWriting(); break; default : USBLCDIdle(); } } } } // end else !suspended { USHORT usStatus; // fixes 8777 (0 or 2 usb unplug tries out of 20 would not // boot player & mtp was still running due to rare irq loss) usb_device_get_status(USB_STATUS_CONNECTION,&usStatus); //we could just check the usb 5v bit instead of calling this. if( usStatus == USB_DISCONNECTED ) { // Restart the MTP device and re-enumerate //DebugBuildAssert(0); //During JLN verification, this hit & the reset started player. StorFlush(); // flush the database first SystemShutdown();// we could use pragma asm to jump to the missed isr instead which resets also. SystemReset(); } } // Update the count if it is not disabled( negative means disabled). if (g_StoreWatchDogCount >= 0) { g_StoreWatchDogCount++; } } // while(1) } // void _reentrant UserInterfaceTask(void)