[363] | 1 | /*
|
---|
| 2 | * TOPPERS/JSP Kernel
|
---|
| 3 | * Toyohashi Open Platform for Embedded Real-Time Systems/
|
---|
| 4 | * Just Standard Profile Kernel
|
---|
| 5 | *
|
---|
| 6 | * Copyright (C) 2000-2003 by Embedded and Real-Time Systems Laboratory
|
---|
| 7 | * Toyohashi Univ. of Technology, JAPAN
|
---|
| 8 | *
|
---|
| 9 | * ä¸è¨èä½æ¨©è
|
---|
| 10 | ã¯ï¼ä»¥ä¸ã® (1)ã(4) ã®æ¡ä»¶ãï¼Free Software Foundation
|
---|
| 11 | * ã«ãã£ã¦å
|
---|
| 12 | ¬è¡¨ããã¦ãã GNU General Public License ã® Version 2 ã«è¨
|
---|
| 13 | * è¿°ããã¦ããæ¡ä»¶ãæºããå ´åã«éãï¼æ¬ã½ããã¦ã§ã¢ï¼æ¬ã½ããã¦ã§ã¢
|
---|
| 14 | * ãæ¹å¤ãããã®ãå«ãï¼ä»¥ä¸åãï¼ã使ç¨ã»è¤è£½ã»æ¹å¤ã»åé
|
---|
| 15 | å¸ï¼ä»¥ä¸ï¼
|
---|
| 16 | * å©ç¨ã¨å¼ã¶ï¼ãããã¨ãç¡åã§è¨±è«¾ããï¼
|
---|
| 17 | * (1) æ¬ã½ããã¦ã§ã¢ãã½ã¼ã¹ã³ã¼ãã®å½¢ã§å©ç¨ããå ´åã«ã¯ï¼ä¸è¨ã®èä½
|
---|
| 18 | * 権表示ï¼ãã®å©ç¨æ¡ä»¶ããã³ä¸è¨ã®ç¡ä¿è¨¼è¦å®ãï¼ãã®ã¾ã¾ã®å½¢ã§ã½ã¼
|
---|
| 19 | * ã¹ã³ã¼ãä¸ã«å«ã¾ãã¦ãããã¨ï¼
|
---|
| 20 | * (2) æ¬ã½ããã¦ã§ã¢ãï¼ã©ã¤ãã©ãªå½¢å¼ãªã©ï¼ä»ã®ã½ããã¦ã§ã¢éçºã«ä½¿
|
---|
| 21 | * ç¨ã§ããå½¢ã§åé
|
---|
| 22 | å¸ããå ´åã«ã¯ï¼åé
|
---|
| 23 | å¸ã«ä¼´ãããã¥ã¡ã³ãï¼å©ç¨
|
---|
| 24 | * è
|
---|
| 25 | ããã¥ã¢ã«ãªã©ï¼ã«ï¼ä¸è¨ã®èä½æ¨©è¡¨ç¤ºï¼ãã®å©ç¨æ¡ä»¶ããã³ä¸è¨
|
---|
| 26 | * ã®ç¡ä¿è¨¼è¦å®ãæ²è¼ãããã¨ï¼
|
---|
| 27 | * (3) æ¬ã½ããã¦ã§ã¢ãï¼æ©å¨ã«çµã¿è¾¼ããªã©ï¼ä»ã®ã½ããã¦ã§ã¢éçºã«ä½¿
|
---|
| 28 | * ç¨ã§ããªãå½¢ã§åé
|
---|
| 29 | å¸ããå ´åã«ã¯ï¼æ¬¡ã®ããããã®æ¡ä»¶ãæºããã
|
---|
| 30 | * ã¨ï¼
|
---|
| 31 | * (a) åé
|
---|
| 32 | å¸ã«ä¼´ãããã¥ã¡ã³ãï¼å©ç¨è
|
---|
| 33 | ããã¥ã¢ã«ãªã©ï¼ã«ï¼ä¸è¨ã®è
|
---|
| 34 | * ä½æ¨©è¡¨ç¤ºï¼ãã®å©ç¨æ¡ä»¶ããã³ä¸è¨ã®ç¡ä¿è¨¼è¦å®ãæ²è¼ãããã¨ï¼
|
---|
| 35 | * (b) åé
|
---|
| 36 | å¸ã®å½¢æ
|
---|
| 37 | ãï¼å¥ã«å®ããæ¹æ³ã«ãã£ã¦ï¼TOPPERSããã¸ã§ã¯ãã«
|
---|
| 38 | * å ±åãããã¨ï¼
|
---|
| 39 | * (4) æ¬ã½ããã¦ã§ã¢ã®å©ç¨ã«ããç´æ¥çã¾ãã¯éæ¥çã«çãããããªãæ
|
---|
| 40 | * 害ãããï¼ä¸è¨èä½æ¨©è
|
---|
| 41 | ããã³TOPPERSããã¸ã§ã¯ããå
|
---|
| 42 | 責ãããã¨ï¼
|
---|
| 43 | *
|
---|
| 44 | * æ¬ã½ããã¦ã§ã¢ã¯ï¼ç¡ä¿è¨¼ã§æä¾ããã¦ãããã®ã§ããï¼ä¸è¨èä½æ¨©è
|
---|
| 45 | ã
|
---|
| 46 | * ãã³TOPPERSããã¸ã§ã¯ãã¯ï¼æ¬ã½ããã¦ã§ã¢ã«é¢ãã¦ï¼ãã®é©ç¨å¯è½æ§ã
|
---|
| 47 | * å«ãã¦ï¼ãããªãä¿è¨¼ãè¡ããªãï¼ã¾ãï¼æ¬ã½ããã¦ã§ã¢ã®å©ç¨ã«ããç´
|
---|
| 48 | * æ¥çã¾ãã¯éæ¥çã«çãããããªãæ害ã«é¢ãã¦ãï¼ãã®è²¬ä»»ãè² ããªãï¼
|
---|
| 49 | *
|
---|
| 50 | * @(#) $Id: cpu_defs.c,v 1.14 2003/12/15 07:19:22 takayuki Exp $
|
---|
| 51 | */
|
---|
| 52 |
|
---|
| 53 | #define _WIN32_WINNT 0x400
|
---|
| 54 |
|
---|
| 55 | #include <s_services.h>
|
---|
| 56 | #include <hal_msg.h>
|
---|
| 57 |
|
---|
| 58 | /*
|
---|
| 59 | * m68kã£ã½ãå²è¾¼ã¿ã¨ãã¥ã¬ã¼ã¿ (Windows HAL)
|
---|
| 60 | */
|
---|
| 61 |
|
---|
| 62 | /* ç¾å¨ã®å²è¾¼ã¿ãã¹ã¯ã¬ãã« */
|
---|
| 63 | unsigned int CurrentInterruptLevel;
|
---|
| 64 |
|
---|
| 65 | /* å²è¾¼ã¿ç®¡çãã¼ãã« */
|
---|
| 66 | static struct tagInterruptLevel InterruptLevel[INT_NUMINTERRUPTS];
|
---|
| 67 |
|
---|
| 68 | /* å²è¾¼ã¿ãã¹ã¯ã¬ãã«ã®æå¹ç¯å²ãã§ã㯠*/
|
---|
| 69 | #define CHECK_IMS(x) ( (x) != 0 && (x) <= INT_NUMINTERRUPTS )
|
---|
| 70 |
|
---|
| 71 | /* ä¾å¤ç®¡çãã¼ãã« */
|
---|
| 72 | struct tagExceptionLevel ExceptionLevel[EXC_MAXITEMS];
|
---|
| 73 |
|
---|
| 74 | /* èªåã®åã«ç»é²ããã¦ããæ§é åä¾å¤ãã³ãã©ã®ã¢ãã¬ã¹ */
|
---|
| 75 | static LPTOP_LEVEL_EXCEPTION_FILTER AnotherExceptionFilter;
|
---|
| 76 |
|
---|
| 77 | /*
|
---|
| 78 | * ã·ã¹ãã å
|
---|
| 79 | ¨ä½ã®ã¯ãªãã£ã«ã«ã»ã¯ã·ã§ã³çæã«ã¼ãã³
|
---|
| 80 | * ã»ã©ããã¦CRITICAL_SECTIONã使ãã®ããããã®ã
|
---|
| 81 | * -> Windowsã®ã¯ãªãã£ã«ã«ã»ã¯ã·ã§ã³ã¯ãITRONã§è¨ãã¨ããã®ãã£ã¹ãããç¦æ¢ã§å®è£
|
---|
| 82 | ãã¦ãããããã
|
---|
| 83 | * å¤é¨ã¤ãã³ãã§èµ·åºãã¦ãã¾ã£ãã¹ã¬ãããã¯ãªãã£ã«ã«ã»ã¯ã·ã§ã³å
|
---|
| 84 | ã«ããã¹ã¬ããã®åä½ã
|
---|
| 85 | * åæ¢ããã¦ãã¾ããã¨ãã§ãããããããªã®ã§CPUããã¯ã®ã¤ããã§ã¯ãªãã£ã«ã«ã»ã¯ã·ã§ã³ã使ã£ã¦ããã¨ã
|
---|
| 86 | * å®ã¯ãã ã®ãã£ã¹ãããç¦æ¢ãªã®ã§ãã³ãã©ãèµ·åãã¦ãã¾ããPrimaryThreadãSuspendThreadãçºè¡ãã¦ãããããã¯ãã¦ãã¾ãã
|
---|
| 87 | * ãã®åé¡ã¯æã
|
---|
| 88 | çºçããé常ã«åä»ãªåé¡ã ã£ãããã¾ãããããªãã¨ãåå ã ã¨ã¯æãããããªãã£ãã
|
---|
| 89 | * WinProgç³»ã®MLã§ããåå ä¸æã®ä¸æ£åæãã¤ã¤ãªãã¯ãªãã£ã«ã«ã»ã¯ã·ã§ã³ã¯ä½¿ããªãã»ãããããã¨ãã£ã¦ããã
|
---|
| 90 | */
|
---|
| 91 |
|
---|
| 92 | static HANDLE SystemMutex = NULL; //ã·ã¹ãã ããã¯ç¨ã®ãã¥ã¼ããã¯ã¹ãªãã¸ã§ã¯ã
|
---|
| 93 | static DWORD SystemMutexOwnerThreadID = 0; //ã·ã¹ãã ããã¯ãåå¾ããã¹ã¬ããã®ID
|
---|
| 94 | static DWORD SystemMutexLastOwnerThreadID = 0; //æå¾ã«ã·ã¹ãã ããã¯ãåå¾ãã¦ããã¹ã¬ããã®ID (ãããã°ç¨)
|
---|
| 95 |
|
---|
| 96 | /*
|
---|
| 97 | * enter_system_critical_section : ã·ã¹ãã ã®ããã¯æ¨©ãç²å¾ãã
|
---|
| 98 | * BOOL * lock : ã¯ããã¼(èªåãå§ãã¦ããã¯æ¨©ãç²å¾ããã¨TRUEãè¿ã)
|
---|
| 99 | */
|
---|
| 100 | void enter_system_critical_section(BOOL * lock)
|
---|
| 101 | {
|
---|
| 102 | if(SystemMutex != NULL && SystemMutexOwnerThreadID != GetCurrentThreadId())
|
---|
| 103 | {
|
---|
| 104 | WaitForSingleObject(SystemMutex, INFINITE);
|
---|
| 105 | if(lock != NULL)
|
---|
| 106 | *lock = TRUE;
|
---|
| 107 | SystemMutexOwnerThreadID = GetCurrentThreadId();
|
---|
| 108 | }else
|
---|
| 109 | {
|
---|
| 110 | if(lock != NULL)
|
---|
| 111 | *lock = FALSE;
|
---|
| 112 | }
|
---|
| 113 | }
|
---|
| 114 |
|
---|
| 115 | /*
|
---|
| 116 | * leave_system_critical_section : ã·ã¹ãã ã®ããã¯æ¨©ãéæ¾ãã
|
---|
| 117 | * BOOL * lock : enter_system_critical_sectionã§ä½¿ç¨ããã¯ããã¼
|
---|
| 118 | */
|
---|
| 119 | void leave_system_critiacl_section(BOOL * lock)
|
---|
| 120 | {
|
---|
| 121 | assert(lock != NULL);
|
---|
| 122 |
|
---|
| 123 | if(*lock == TRUE)
|
---|
| 124 | {
|
---|
| 125 | SystemMutexLastOwnerThreadID = SystemMutexOwnerThreadID;
|
---|
| 126 | SystemMutexOwnerThreadID = 0;
|
---|
| 127 | if(SystemMutex != NULL)
|
---|
| 128 | ReleaseMutex(SystemMutex);
|
---|
| 129 | }
|
---|
| 130 | }
|
---|
| 131 |
|
---|
| 132 | /*
|
---|
| 133 | * wait_for_thread_suspension_completion : ã¹ã¬ãããããã¯æ¨©éæ¾ç¶æ
|
---|
| 134 | ã§åæ¢ããã
|
---|
| 135 | */
|
---|
| 136 | ER wait_for_thread_suspension_completion(HANDLE thread)
|
---|
| 137 | {
|
---|
| 138 | BOOL lock;
|
---|
| 139 |
|
---|
| 140 | if(thread == 0 || thread == NULL)
|
---|
| 141 | return E_PAR;
|
---|
| 142 |
|
---|
| 143 | enter_system_critical_section(&lock);
|
---|
| 144 | SuspendThread(thread);
|
---|
| 145 | leave_system_critiacl_section(&lock);
|
---|
| 146 |
|
---|
| 147 | return 0;
|
---|
| 148 | }
|
---|
| 149 |
|
---|
| 150 |
|
---|
| 151 |
|
---|
| 152 | /*
|
---|
| 153 | * 次ã«å®è¡ãã¹ãå²è¾¼ã¿ãã³ãã©ã®ããã¬ãã«ãåå¾ãã
|
---|
| 154 | * ipl : å²è¾¼ã¿ãã¹ã¯ã¬ãã«
|
---|
| 155 | *
|
---|
| 156 | * å²ãè¾¼ã¿ã¬ãã«ãã¹ã¯ãiplã¾ã§ä¸ãã£ãã¨ãã«ã次ã«åããã¹ãå²è¾¼ã¿ãé¸æããã
|
---|
| 157 | * ãã¹ã¯ã¬ãã«ãããä¸ä½ã®å²è¾¼ã¿ã®å ´åããã³ãã£ã³ã°ãããè¦æ± or æ¢ã«å®è¡ã
|
---|
| 158 | * å§ã¾ã£ã¦ãããã³ãã© ãå®è¡ããããã¹ã¯ã¬ãã«ä»¥ä¸ã®å ´åãæ¢ã«åãã¦ãã
|
---|
| 159 | * ãã³ãã©ãããå ´åã®ã¿å®è¡ãããä½ããªãå ´åã¯0ãè¿ãã
|
---|
| 160 | */
|
---|
| 161 | static unsigned int
|
---|
| 162 | isns_int( unsigned int ipl )
|
---|
| 163 | {
|
---|
| 164 | unsigned int result = INT_NUMINTERRUPTS;
|
---|
| 165 |
|
---|
| 166 | if((CPUStatus & CPU_STAT_LOCK) != 0)
|
---|
| 167 | return 0;
|
---|
| 168 |
|
---|
| 169 | while(result > ipl)
|
---|
| 170 | {
|
---|
| 171 | result --;
|
---|
| 172 | if( (InterruptLevel[result].Flags & (INT_STAT_PENDING|INT_STAT_RUNNING)) != 0)
|
---|
| 173 | return result+1;
|
---|
| 174 | }
|
---|
| 175 | while(result > 0)
|
---|
| 176 | {
|
---|
| 177 | result --;
|
---|
| 178 | if( (InterruptLevel[result].Flags & INT_STAT_RUNNING) != 0)
|
---|
| 179 | return result+1;
|
---|
| 180 | }
|
---|
| 181 | return 0;
|
---|
| 182 | }
|
---|
| 183 |
|
---|
| 184 | static DWORD WINAPI
|
---|
| 185 | InterruptHandlerWrapper(LPVOID param)
|
---|
| 186 | {
|
---|
| 187 | unsigned int i;
|
---|
| 188 | unsigned int PrevLevel;
|
---|
| 189 | BOOL systemLock;
|
---|
| 190 |
|
---|
| 191 | struct tagInterruptLevel * intlv = (struct tagInterruptLevel *)param;
|
---|
| 192 |
|
---|
| 193 | TlsAlloc();
|
---|
| 194 |
|
---|
| 195 | kprintf(("InterruptHandlerWrapper (%d) : start\n", (intlv - InterruptLevel) + 1 ));
|
---|
| 196 |
|
---|
| 197 | while(1==1)
|
---|
| 198 | {
|
---|
| 199 | /* å²è¾¼ã¿åå¦ç */
|
---|
| 200 |
|
---|
| 201 | set_logcontrol((intlv->Flags & INT_MOD_LOGMASK) != 0);
|
---|
| 202 | LOG_INH_ENTER((intlv - InterruptLevel)+1);
|
---|
| 203 |
|
---|
| 204 | assert((CPUStatus & CPU_STAT_LOCK) == 0);
|
---|
| 205 | enter_system_critical_section(&systemLock);
|
---|
| 206 | PrevLevel = CurrentInterruptLevel;
|
---|
| 207 | CurrentInterruptLevel = (unsigned int)(intlv - InterruptLevel)+1;
|
---|
| 208 | intlv->Flags &= ~INT_STAT_PENDING;
|
---|
| 209 | intlv->Flags |= INT_STAT_RUNNING;
|
---|
| 210 | leave_system_critiacl_section(&systemLock);
|
---|
| 211 |
|
---|
| 212 | ( (void (*)(void) )(intlv->Routine))();
|
---|
| 213 |
|
---|
| 214 | /* å²è¾¼ã¿å¾å¦ç
|
---|
| 215 | * ããã§ä¸æ°ã«PrevLevelã¾ã§è½ã¨ãã¦ã¯ãããªã.
|
---|
| 216 | * å²ãè¾¼ã¿ã®å
|
---|
| 217 | ¥ãæ¹ã«ãã£ã¦ã¯ãåªå
|
---|
| 218 | 度ã®ä½ãå²è¾¼ã¿ã®è±åºå¦çãåªå
|
---|
| 219 | 度ã®é«ãå²ãè¾¼ã¿ã®é²å
|
---|
| 220 | ¥å¦çã®ç´å¾ã«å®è¡ããã
|
---|
| 221 | * éãæªãã¨åªå
|
---|
| 222 | 度ã®é«ãå²è¾¼ã¿ãCurrentInterruptLevel = 0ã®ç¶æ
|
---|
| 223 | ã§èµ°ã£ã¦ãã¾ããã¨ã«ãªãã
|
---|
| 224 | */
|
---|
| 225 | enter_system_critical_section(&systemLock);
|
---|
| 226 | intlv->Flags &= ~INT_STAT_RUNNING;
|
---|
| 227 | i = isns_int(PrevLevel);
|
---|
| 228 | if(i > PrevLevel)
|
---|
| 229 | CurrentInterruptLevel = i - 1;
|
---|
| 230 | else
|
---|
| 231 | CurrentInterruptLevel = PrevLevel;
|
---|
| 232 | leave_system_critiacl_section(&systemLock);
|
---|
| 233 |
|
---|
| 234 | LOG_INH_LEAVE((intlv - InterruptLevel)+1);
|
---|
| 235 |
|
---|
| 236 | /* 次ã®å²è¾¼ã¿ãå¦çããããã«éç¥ */
|
---|
| 237 | HALInterruptRequestAndWait();
|
---|
| 238 | }
|
---|
| 239 |
|
---|
| 240 | kprintf(("InterruptHandlerWrapper (%d) : exit\n", (intlv - InterruptLevel) + 1 ));
|
---|
| 241 |
|
---|
| 242 | ExitThread(0);
|
---|
| 243 | return 0;
|
---|
| 244 | }
|
---|
| 245 |
|
---|
| 246 | BOOL
|
---|
| 247 | def_int(unsigned int ims, void * rtn)
|
---|
| 248 | {
|
---|
| 249 | BOOL lock;
|
---|
| 250 |
|
---|
| 251 | if(!CHECK_IMS(ims) || rtn == NULL)
|
---|
| 252 | return FALSE;
|
---|
| 253 |
|
---|
| 254 | kprintf(("def_int : [ims:%d]\n", ims));
|
---|
| 255 |
|
---|
| 256 | ims--;
|
---|
| 257 |
|
---|
| 258 | enter_system_critical_section(&lock);
|
---|
| 259 | if(InterruptLevel[ims].ThreadHandle != NULL)
|
---|
| 260 | {
|
---|
| 261 | TerminateThread(InterruptLevel[ims].ThreadHandle,0);
|
---|
| 262 | CloseHandle(InterruptLevel[ims].ThreadHandle);
|
---|
| 263 | }
|
---|
| 264 | InterruptLevel[ims].Routine = rtn;
|
---|
| 265 | InterruptLevel[ims].ThreadHandle = CreateThread(NULL,0,InterruptHandlerWrapper,(LPVOID)&InterruptLevel[ims],CREATE_SUSPENDED,&InterruptLevel[ims].ThreadID);
|
---|
| 266 | leave_system_critiacl_section(&lock);
|
---|
| 267 |
|
---|
| 268 | return TRUE;
|
---|
| 269 | }
|
---|
| 270 |
|
---|
| 271 | BOOL
|
---|
| 272 | ini_int(void)
|
---|
| 273 | {
|
---|
| 274 | int i;
|
---|
| 275 |
|
---|
| 276 | kprintf(("ini_int : [Start]\n"));
|
---|
| 277 |
|
---|
| 278 | SystemMutex = CreateMutex(NULL,TRUE,NULL);
|
---|
| 279 |
|
---|
| 280 | for(i=0;i<INT_NUMINTERRUPTS;i++)
|
---|
| 281 | {
|
---|
| 282 | InterruptLevel[i].Routine = (void *)0l;
|
---|
| 283 | InterruptLevel[i].ThreadHandle = NULL;
|
---|
| 284 | InterruptLevel[i].ThreadID = 0;
|
---|
| 285 | InterruptLevel[i].Flags = INT_MOD_LOGMASK;
|
---|
| 286 | }
|
---|
| 287 |
|
---|
| 288 | /* åæèµ·åã§CPUããã¯ç¶æ
|
---|
| 289 | ã¸ç§»è¡ããã */
|
---|
| 290 | CurrentInterruptLevel = 0; //å²è¾¼ã¿ãã¹ã¯ã¯å
|
---|
| 291 | ¨è¨±å¯
|
---|
| 292 | CPUStatus |= CPU_STAT_LOCK; //CPUã§å²è¾¼ã¿ç¦æ¢ã«
|
---|
| 293 |
|
---|
| 294 | ReleaseMutex(SystemMutex);
|
---|
| 295 |
|
---|
| 296 | kprintf(("ini_int : [Exit]\n"));
|
---|
| 297 |
|
---|
| 298 | return TRUE;
|
---|
| 299 | }
|
---|
| 300 |
|
---|
| 301 | void
|
---|
| 302 | fin_int(void)
|
---|
| 303 | {
|
---|
| 304 | int i;
|
---|
| 305 | HANDLE work;
|
---|
| 306 |
|
---|
| 307 | kprintf(("fin_int : [Start]\n"));
|
---|
| 308 |
|
---|
| 309 | enter_system_critical_section(NULL);
|
---|
| 310 |
|
---|
| 311 | for(i=0;i<INT_NUMINTERRUPTS;i++)
|
---|
| 312 | {
|
---|
| 313 | if(InterruptLevel[i].ThreadHandle != NULL)
|
---|
| 314 | {
|
---|
| 315 | TerminateThread(InterruptLevel[i].ThreadHandle,0);
|
---|
| 316 | CloseHandle(InterruptLevel[i].ThreadHandle);
|
---|
| 317 | }
|
---|
| 318 | InterruptLevel[i].Routine = (void *)0l;
|
---|
| 319 | InterruptLevel[i].ThreadHandle = NULL;
|
---|
| 320 | InterruptLevel[i].ThreadID = 0;
|
---|
| 321 | InterruptLevel[i].Flags = 0;
|
---|
| 322 | }
|
---|
| 323 | CurrentInterruptLevel = 0;
|
---|
| 324 |
|
---|
| 325 | /* CloseHandle(SystemMutex), SystemMutex = INVALID_HANDLE; ãå®å
|
---|
| 326 | ¨ã«ãã */
|
---|
| 327 | work = SystemMutex;
|
---|
| 328 | SystemMutex = NULL;
|
---|
| 329 | CloseHandle(work);
|
---|
| 330 |
|
---|
| 331 | //ãã以éã¯CPUããã¯ç¶æ
|
---|
| 332 | ã ã¨æãè¾¼ã
|
---|
| 333 | CPUStatus |= CPU_STAT_LOCK;
|
---|
| 334 |
|
---|
| 335 | kprintf(("fin_int : [Exit]\n"));
|
---|
| 336 | }
|
---|
| 337 |
|
---|
| 338 | BOOL
|
---|
| 339 | ras_int(unsigned int ims)
|
---|
| 340 | {
|
---|
| 341 | BOOL lock;
|
---|
| 342 | BOOL result = TRUE;
|
---|
| 343 |
|
---|
| 344 | if(!CHECK_IMS(ims))
|
---|
| 345 | return FALSE;
|
---|
| 346 |
|
---|
| 347 | ims --;
|
---|
| 348 |
|
---|
| 349 | enter_system_critical_section(&lock);
|
---|
| 350 | if(InterruptLevel[ims].ThreadHandle == NULL)
|
---|
| 351 | {
|
---|
| 352 | result = FALSE;
|
---|
| 353 | }else
|
---|
| 354 | InterruptLevel[ims].Flags |= INT_STAT_PENDING;
|
---|
| 355 | leave_system_critiacl_section(&lock);
|
---|
| 356 | return result;
|
---|
| 357 | }
|
---|
| 358 |
|
---|
| 359 | unsigned int
|
---|
| 360 | sns_int( void )
|
---|
| 361 | {
|
---|
| 362 | BOOL lock;
|
---|
| 363 | int result;
|
---|
| 364 |
|
---|
| 365 | if(sense_lock() == TRUE)
|
---|
| 366 | return 0;
|
---|
| 367 |
|
---|
| 368 | enter_system_critical_section(&lock);
|
---|
| 369 | result = isns_int(CurrentInterruptLevel);
|
---|
| 370 | leave_system_critiacl_section(&lock);
|
---|
| 371 | return result;
|
---|
| 372 | }
|
---|
| 373 |
|
---|
| 374 | HANDLE
|
---|
| 375 | sch_int( void )
|
---|
| 376 | {
|
---|
| 377 | BOOL lock;
|
---|
| 378 | HANDLE result;
|
---|
| 379 | unsigned int level;
|
---|
| 380 |
|
---|
| 381 | if(sense_lock() == TRUE)
|
---|
| 382 | return NULL;
|
---|
| 383 |
|
---|
| 384 | enter_system_critical_section(&lock);
|
---|
| 385 | level = isns_int(CurrentInterruptLevel);
|
---|
| 386 | if(level != 0)
|
---|
| 387 | {
|
---|
| 388 | result = InterruptLevel[level-1].ThreadHandle;
|
---|
| 389 | }else
|
---|
| 390 | result = NULL;
|
---|
| 391 | leave_system_critiacl_section(&lock);
|
---|
| 392 |
|
---|
| 393 | return result;
|
---|
| 394 | }
|
---|
| 395 |
|
---|
| 396 | DWORD LockerThreadID = 0;
|
---|
| 397 |
|
---|
| 398 | ER
|
---|
| 399 | ena_int(unsigned int ims)
|
---|
| 400 | {
|
---|
| 401 | BOOL lock;
|
---|
| 402 | int i;
|
---|
| 403 |
|
---|
| 404 | enter_system_critical_section(&lock);
|
---|
| 405 | i = isns_int(CurrentInterruptLevel);
|
---|
| 406 | CPUStatus &= ~CPU_STAT_LOCK;
|
---|
| 407 | LockerThreadID = 0;
|
---|
| 408 | leave_system_critiacl_section(&lock);
|
---|
| 409 |
|
---|
| 410 | if(i != 0)
|
---|
| 411 | HALInterruptRequest(0);
|
---|
| 412 |
|
---|
| 413 | return 0 /*E_OK*/;
|
---|
| 414 | }
|
---|
| 415 |
|
---|
| 416 | ER
|
---|
| 417 | dis_int(unsigned int ims)
|
---|
| 418 | {
|
---|
| 419 | BOOL lock;
|
---|
| 420 |
|
---|
| 421 | enter_system_critical_section(&lock);
|
---|
| 422 | CPUStatus |= CPU_STAT_LOCK;
|
---|
| 423 | if(LockerThreadID == 0)
|
---|
| 424 | {
|
---|
| 425 | LockerThreadID = GetCurrentThreadId();
|
---|
| 426 | }else
|
---|
| 427 | {
|
---|
| 428 | DWORD newThreadID = GetCurrentThreadId();
|
---|
| 429 | LockerThreadID = GetCurrentThreadId(); //ãã¬ã¼ã¯ç½®ãå ´
|
---|
| 430 | }
|
---|
| 431 | leave_system_critiacl_section(&lock);
|
---|
| 432 |
|
---|
| 433 | return 0;
|
---|
| 434 | }
|
---|
| 435 |
|
---|
| 436 | ER
|
---|
| 437 | chg_ims(unsigned int ims)
|
---|
| 438 | {
|
---|
| 439 | BOOL lock;
|
---|
| 440 | int i;
|
---|
| 441 |
|
---|
| 442 | //chg_ims 㯠ims==0 ã許ã
|
---|
| 443 | if(ims != 0 && !CHECK_IMS(ims))
|
---|
| 444 | return -17 /*E_PAR*/;
|
---|
| 445 |
|
---|
| 446 | enter_system_critical_section(&lock);
|
---|
| 447 | CurrentInterruptLevel = ims;
|
---|
| 448 | if(CurrentInterruptLevel == INT_NUMINTERRUPTS)
|
---|
| 449 | CPUStatus |= CPU_STAT_LOCK;
|
---|
| 450 | else
|
---|
| 451 | CPUStatus &= ~CPU_STAT_LOCK;
|
---|
| 452 | i = isns_int(ims);
|
---|
| 453 | leave_system_critiacl_section(&lock);
|
---|
| 454 |
|
---|
| 455 | if(i != 0)
|
---|
| 456 | HALInterruptRequest(0);
|
---|
| 457 |
|
---|
| 458 | return 0 /*E_OK*/;
|
---|
| 459 | }
|
---|
| 460 |
|
---|
| 461 | ER
|
---|
| 462 | get_ims(unsigned int *p_ims)
|
---|
| 463 | {
|
---|
| 464 | BOOL lock;
|
---|
| 465 |
|
---|
| 466 | if(p_ims == (void *)0l)
|
---|
| 467 | return -17 /*E_PAR*/;
|
---|
| 468 |
|
---|
| 469 | enter_system_critical_section(&lock);
|
---|
| 470 | if((CPUStatus & CPU_STAT_LOCK) != 0)
|
---|
| 471 | *p_ims = INT_NUMINTERRUPTS;
|
---|
| 472 | else
|
---|
| 473 | *p_ims = CurrentInterruptLevel;
|
---|
| 474 | leave_system_critiacl_section(&lock);
|
---|
| 475 | return 0 /*E_OK*/;
|
---|
| 476 | }
|
---|
| 477 |
|
---|
| 478 | ER
|
---|
| 479 | vget_ims(unsigned int *p_ims)
|
---|
| 480 | {
|
---|
| 481 | BOOL lock;
|
---|
| 482 |
|
---|
| 483 | if(p_ims == (void *)0l)
|
---|
| 484 | return -17 /*E_PAR*/;
|
---|
| 485 |
|
---|
| 486 | enter_system_critical_section(&lock);
|
---|
| 487 | *p_ims = CurrentInterruptLevel;
|
---|
| 488 | leave_system_critiacl_section(&lock);
|
---|
| 489 | return 0 /*E_OK*/;
|
---|
| 490 | }
|
---|
| 491 |
|
---|
| 492 | /*
|
---|
| 493 | * æä¸ä½ã¬ãã«Windowsæ§é åä¾å¤ãã³ãã©
|
---|
| 494 | */
|
---|
| 495 |
|
---|
| 496 | LONG WINAPI
|
---|
| 497 | HALExceptionHandler( EXCEPTION_POINTERS * exc )
|
---|
| 498 | {
|
---|
| 499 | int i;
|
---|
| 500 | int result;
|
---|
| 501 |
|
---|
| 502 | if((CPUStatus & CPU_STAT_EXC) == 0)
|
---|
| 503 | CPUStatus |= CPU_STAT_DOUBLEFAULT;
|
---|
| 504 |
|
---|
| 505 | /* 馬鹿ãµã¼ã (空éããã¾ããã...) */
|
---|
| 506 | CPUStatus |= CPU_STAT_EXC;
|
---|
| 507 | for(i=0;i<EXC_MAXITEMS;i++)
|
---|
| 508 | {
|
---|
| 509 | if(ExceptionLevel[i].ExceptionCode == exc->ExceptionRecord->ExceptionCode)
|
---|
| 510 | {
|
---|
| 511 | result = EXCEPTION_CONTINUE_SEARCH;
|
---|
| 512 |
|
---|
| 513 | LOG_EXC_ENTER(i);
|
---|
| 514 | ( * ((void (*)(void *,int *))ExceptionLevel[i].Routine)) (exc,&i);
|
---|
| 515 | LOG_EXC_LEAVE(i);
|
---|
| 516 |
|
---|
| 517 | CPUStatus &= ~CPU_STAT_EXC;
|
---|
| 518 | return result;
|
---|
| 519 | }
|
---|
| 520 | }
|
---|
| 521 | CPUStatus &= ~CPU_STAT_EXC;
|
---|
| 522 | return EXCEPTION_CONTINUE_SEARCH;
|
---|
| 523 | }
|
---|
| 524 |
|
---|
| 525 | BOOL
|
---|
| 526 | ini_exc(void)
|
---|
| 527 | {
|
---|
| 528 | int i;
|
---|
| 529 |
|
---|
| 530 | for(i=0;i<EXC_MAXITEMS;i++)
|
---|
| 531 | {
|
---|
| 532 | ExceptionLevel[i].ExceptionCode = 0;
|
---|
| 533 | ExceptionLevel[i].Routine = 0l;
|
---|
| 534 | }
|
---|
| 535 |
|
---|
| 536 | AnotherExceptionFilter = SetUnhandledExceptionFilter(HALExceptionHandler);
|
---|
| 537 |
|
---|
| 538 | return TRUE;
|
---|
| 539 | }
|
---|
| 540 |
|
---|
| 541 | void
|
---|
| 542 | fin_exc(void)
|
---|
| 543 | {
|
---|
| 544 | SetUnhandledExceptionFilter(AnotherExceptionFilter);
|
---|
| 545 | }
|
---|
| 546 |
|
---|
| 547 | BOOL
|
---|
| 548 | def_exc(DWORD exc, void * routine)
|
---|
| 549 | {
|
---|
| 550 | int j;
|
---|
| 551 | int i;
|
---|
| 552 |
|
---|
| 553 | /* 解é¤ã«ã¼ãã³ */
|
---|
| 554 | if(routine == 0l)
|
---|
| 555 | {
|
---|
| 556 | kprintf(("def_exc : [UNREG] 0x%08x\n", exc));
|
---|
| 557 |
|
---|
| 558 | for(i=0;i<EXC_MAXITEMS;i++)
|
---|
| 559 | if(ExceptionLevel[i].ExceptionCode == exc)
|
---|
| 560 | {
|
---|
| 561 | ExceptionLevel[i].ExceptionCode = 0;
|
---|
| 562 | ExceptionLevel[i].Routine = 0;
|
---|
| 563 | return TRUE;
|
---|
| 564 | }
|
---|
| 565 | return FALSE;
|
---|
| 566 | }
|
---|
| 567 |
|
---|
| 568 | /* ç»é²ã«ã¼ãã³ */
|
---|
| 569 |
|
---|
| 570 | kprintf(("def_exc : [REG] 0x%08x\n", exc));
|
---|
| 571 |
|
---|
| 572 | j = EXC_MAXITEMS;
|
---|
| 573 | for(i=0;i<EXC_MAXITEMS;i++)
|
---|
| 574 | {
|
---|
| 575 | if(ExceptionLevel[i].ExceptionCode != 0)
|
---|
| 576 | {
|
---|
| 577 | /* ç»é²ãããã¨ãã¦ããçªå·ãæ¢ã«ç»é²ããã¦ããªããã©ãã調ã¹ã */
|
---|
| 578 | if(ExceptionLevel[i].ExceptionCode == exc)
|
---|
| 579 | return FALSE;
|
---|
| 580 | }else
|
---|
| 581 | {
|
---|
| 582 | /* 空ãçªå·ã®æå°ãè¦ãã */
|
---|
| 583 | if(j > i)
|
---|
| 584 | j = i;
|
---|
| 585 |
|
---|
| 586 | /* æ¢ç»é²ãã§ãã¯ãããã®ã§ãããã§breakãã¦ã¯ãã¡ */
|
---|
| 587 | }
|
---|
| 588 | }
|
---|
| 589 |
|
---|
| 590 | FatalAssertion(i == EXC_MAXITEMS, "No available exception slots left.");
|
---|
| 591 |
|
---|
| 592 | //This sequence will never change
|
---|
| 593 | ExceptionLevel[j].Routine = routine;
|
---|
| 594 | ExceptionLevel[j].ExceptionCode = exc;
|
---|
| 595 |
|
---|
| 596 | return TRUE;
|
---|
| 597 | }
|
---|
| 598 |
|
---|
| 599 | ER set_intlogmask( unsigned int ims, BOOL mask )
|
---|
| 600 | {
|
---|
| 601 | BOOL lock;
|
---|
| 602 |
|
---|
| 603 | if( !CHECK_IMS(ims) )
|
---|
| 604 | return FALSE;
|
---|
| 605 |
|
---|
| 606 | -- ims;
|
---|
| 607 |
|
---|
| 608 | enter_system_critical_section(&lock);
|
---|
| 609 | if(mask == TRUE)
|
---|
| 610 | InterruptLevel[ims].Flags |= INT_MOD_LOGMASK;
|
---|
| 611 | else
|
---|
| 612 | InterruptLevel[ims].Flags &= ~INT_MOD_LOGMASK;
|
---|
| 613 | leave_system_critiacl_section(&lock);
|
---|
| 614 |
|
---|
| 615 | return TRUE;
|
---|
| 616 | }
|
---|
| 617 |
|
---|
| 618 | unsigned int current_timer_clock_unit = TIMER_CLOCK_WINDOWS;
|
---|
| 619 |
|
---|
| 620 | ER set_clk(unsigned int clk)
|
---|
| 621 | {
|
---|
| 622 | BOOL lock;
|
---|
| 623 |
|
---|
| 624 | if(clk == 0)
|
---|
| 625 | clk = TIMER_CLOCK_WINDOWS;
|
---|
| 626 |
|
---|
| 627 | hw_timer_terminate();
|
---|
| 628 | enter_system_critical_section(&lock);
|
---|
| 629 | current_timer_clock_unit = clk;
|
---|
| 630 | leave_system_critiacl_section(&lock);
|
---|
| 631 | hw_timer_initialize();
|
---|
| 632 |
|
---|
| 633 | return E_OK;
|
---|
| 634 | }
|
---|