rom/filesys/pfs3/fs/ks13wrapper.c

   1
   2 #include <aros/debug.h>
   3 #include <exec/types.h>
   4 #include <exec/memory.h>
   5 #include <proto/exec.h>
   6
   7 #include <string.h>
   8 #include <stdio.h>
   9
  10 #include "ks13wrapper.h"
  11
  12 #ifdef KS13WRAPPER
  13
  14 #if KS13WRAPPER_DEBUG
  15
  16 #include <hardware/intbits.h>
  17
  18 #ifndef D
  19 #define D(x) ;
  20 #endif
  21
  22 #define SERDATR                 0x18
  23 #define SERDAT                  0x30
  24 #define INTREQ                  0x9c
  25 #define SERDATR_TBE             (1 << 13)       /* Tx Buffer Empty */
  26 #define SERDAT_STP8             (1 << 8)
  27 #define SERDAT_DB8(x)           ((x) & 0xff)
  28
  29 #endif
  30
  31 /* Must use DOSBase, CDTV extended ROM 2.x includes v37 SysBase replacement */
  32 #define ISKS20 (DOSBase->dl_lib.lib_Version >= 37)
  33
  34 #define MIN_STACKSIZE 8000
  35
  36 AROS_UFP2(void, StackSwap,
  37     AROS_UFPA(struct StackSwapStruct*, stack, A0),
  38     AROS_UFPA(struct ExecBase*, SysBase, A6));
  39
  40 #if KS13WRAPPER_DEBUG
  41
  42 static inline void reg_w(ULONG reg, UWORD val)
  43 {
  44         volatile UWORD *r = (void *)(0xdff000 + reg);
  45
  46         *r = val;
  47 }
  48 static inline UWORD reg_r(ULONG reg)
  49 {
  50         volatile UWORD *r = (void *)(0xdff000 + reg);
  51
  52         return *r;
  53 }
  54 static void DebugPutChar(register int chr)
  55 {
  56         if (chr == '\n')
  57                 DebugPutChar('\r');
  58
  59         while ((reg_r(SERDATR) & SERDATR_TBE) == 0);
  60         reg_w(INTREQ, INTF_TBE);
  61
  62         /* Output a char to the debug UART */
  63         reg_w(SERDAT, SERDAT_STP8 | SERDAT_DB8(chr));
  64 }
  65 void DebugPutStr(register const char *buff)
  66 {
  67         for (; *buff != 0; buff++)
  68                 DebugPutChar(*buff);
  69 }
  70 void DebugPutDec(const char *what, ULONG val)
  71 {
  72         int i, num;
  73         BOOL leadingzero = TRUE;
  74
  75         DebugPutStr(what);
  76         DebugPutStr(": ");
  77         if (val == 0) {
  78             DebugPutChar('0');
  79             DebugPutChar('\n');
  80             return;
  81         }
  82
  83         for (i = 1000000000; i > 0; i /= 10) {
  84             if (val == 0) {
  85                 DebugPutChar('0');
  86                 continue;
  87             }
  88
  89             num = val / i;
  90             if (num == 0 && leadingzero)
  91                 continue;
  92             leadingzero = FALSE;
  93
  94             DebugPutChar("0123456789"[num]);
  95             val -= num * i;
  96         }
  97         DebugPutChar('\n');
  98 }
  99 void DebugPutHex(const char *what, ULONG val)
 100 {
 101         int i;
 102         DebugPutStr(what);
 103         DebugPutStr(": ");
 104         for (i = 0; i < 8; i ++) {
 105                 DebugPutChar("0123456789abcdef"[(val >> (28 - (i * 4))) & 0xf]);
 106         }
 107         DebugPutChar('\n');
 108 }
 109 void DebugPutHexVal(ULONG val)
 110 {
 111         int i;
 112         for (i = 0; i < 8; i ++) {
 113                 DebugPutChar("0123456789abcdef"[(val >> (28 - (i * 4))) & 0xf]);
 114         }
 115         DebugPutChar(' ');
 116 }
 117
 118 void Trace(ULONG id, const UBYTE *title, const UBYTE *format, ...)
 119 {
 120         UBYTE buffer[256];
 121         va_list parms;
 122         va_start(parms, format);
 123         vsnprintf(buffer, sizeof buffer - 1, format, parms);
 124         DebugPutStr(title);
 125         DebugPutStr(":");
 126         DebugPutStr(buffer);
 127         DebugPutStr("\n");
 128         va_end(parms);
 129 }
 130
 131 #endif
 132
 133 APTR W_AllocVec(ULONG size, ULONG flags, struct globaldata *g)
 134 {
 135     ULONG *mem;
 136
 137     if (!size)
 138         return NULL;
 139     size += sizeof(ULONG);
 140     mem = AllocMem(size, flags);
 141     if (!mem)
 142         return NULL;
 143     mem[0] = size;
 144     mem++;
 145     return mem;
 146 }
 147 void W_FreeVec(APTR mem, struct globaldata *g)
 148 {
 149     ULONG *p = mem;
 150     if (!p)
 151         return;
 152     p--;
 153     FreeMem(p, p[0]);
 154 }
 155
 156 APTR W_CreateIORequest(struct MsgPort *ioReplyPort, ULONG size, struct globaldata *g)
 157 {
 158     struct IORequest *ret=NULL;
 159     if(ioReplyPort==NULL)
 160         return NULL;
 161     ret=(struct IORequest *)AllocMem(size,MEMF_PUBLIC|MEMF_CLEAR);
 162     if(ret!=NULL)
 163     {
 164         ret->io_Message.mn_ReplyPort=ioReplyPort;
 165         ret->io_Message.mn_Length=size;
 166     }
 167     return ret;
 168 }
 169
 170 void W_DeleteIORequest(APTR iorequest, struct globaldata *g)
 171 {
 172     if(iorequest != NULL)
 173         FreeMem(iorequest, ((struct Message *)iorequest)->mn_Length);
 174 }
 175
 176 struct MsgPort *W_CreateMsgPort(struct globaldata *g)
 177 {
 178     struct MsgPort *ret;
 179     ret=(struct MsgPort *)AllocMem(sizeof(struct MsgPort),MEMF_PUBLIC|MEMF_CLEAR);
 180     if(ret!=NULL)
 181     {
 182         BYTE sb;
 183         sb=AllocSignal(-1);
 184         if (sb != -1)
 185         {
 186             ret->mp_Flags = PA_SIGNAL;
 187             ret->mp_Node.ln_Type = NT_MSGPORT;
 188             NEWLIST(&ret->mp_MsgList);
 189             ret->mp_SigBit=sb;
 190             ret->mp_SigTask=FindTask(NULL);
 191             return ret;
 192         }
 193         FreeMem(ret,sizeof(struct MsgPort));
 194     }
 195     return NULL;
 196 }
 197
 198 void W_DeleteMsgPort(struct MsgPort *port, struct globaldata *g)
 199 {
 200     if(port!=NULL)
 201     {
 202         FreeSignal(port->mp_SigBit);
 203         FreeMem(port,sizeof(struct MsgPort));
 204     }
 205 }
 206
 207 BOOL W_MatchPatternNoCase(CONST_STRPTR pat, CONST_STRPTR str, struct globaldata *g)
 208 {
 209     if (ISKS20)
 210         return AROS_LVO_CALL2(BOOL,
 211                 AROS_LCA(CONST_STRPTR, pat, D1),
 212                 AROS_LCA(CONST_STRPTR, str, D2),
 213                 struct DosLibrary*, DOSBase, 162, );
 214     /* Used by ACTION_EXAMINE_ALL which is 2.0+ only packet */
 215     return FALSE;
 216 }
 217
 218 STRPTR FilePart(CONST_STRPTR path)
 219 {
 220     if(path)
 221     {
 222         CONST_STRPTR i;
 223         if (!*path)
 224           return (STRPTR)path;
 225         i = path + strlen (path) -1;
 226         while ((*i != ':') && (*i != '/') && (i != path))
 227             i--;
 228         if ((*i == ':')) i++;
 229         if ((*i == '/')) i++;
 230         return (STRPTR)i;
 231     }
 232     return NULL;
 233 }
 234
 235 STRPTR PathPart(CONST_STRPTR path)
 236 {
 237     const char *ptr;
 238
 239     while (*path == '/')
 240     {
 241         ++path;
 242     }
 243     ptr = path;
 244     while (*ptr)
 245     {
 246         if (*ptr == '/')
 247         {
 248             path = ptr;
 249         }
 250         else if (*ptr == ':')
 251         {
 252             path = ptr + 1;
 253         }
 254         ptr++;
 255     }
 256     return (STRPTR)path;
 257 }
 258
 259 static BOOL CMPBSTR(BSTR s1, BSTR s2)
 260 {
 261     UBYTE *ss1 = BADDR(s1);
 262     UBYTE *ss2 = BADDR(s2);
 263     return memcmp(ss1, ss2, ss1[0] + 1);
 264 }
 265 static struct DosList *getdoslist(struct globaldata *g)
 266 {
 267     struct DosInfo *di;
 268
 269     di = BADDR(DOSBase->dl_Root->rn_Info);
 270     Forbid();
 271     return (struct DosList *)&di->di_DevInfo;
 272 }
 273 static void freedoslist(struct globaldata *g)
 274 {
 275     Permit();
 276 }
 277
 278 struct DosList *W_MakeDosEntry(CONST_STRPTR name, LONG type, struct globaldata *g)
 279 {
 280     ULONG len;
 281     STRPTR s2;
 282     struct DosList *dl;
 283
 284     if (ISKS20)
 285         return AROS_LVO_CALL2(struct DosList*,
 286                 AROS_LCA(CONST_STRPTR, name, D1),
 287                 AROS_LCA(LONG, type, D2),
 288                 struct DosLibrary*, DOSBase, 116, );
 289
 290     len = strlen(name);
 291     dl = (struct DosList *)AllocVec(sizeof(struct DosList),
 292                                     MEMF_PUBLIC | MEMF_CLEAR);
 293
 294     if (dl != NULL)
 295     {
 296         /* Binary compatibility for BCPL string.
 297          * First byte is the length then comes the string.
 298          * For ease of use a zero is put at the end so it can be used as a
 299          * C string
 300          */
 301         s2 = (STRPTR)AllocVec(len+2, MEMF_PUBLIC | MEMF_CLEAR);
 302         dl->dol_Name = MKBADDR(s2);
 303         if (s2 != NULL)
 304             *s2++ = (UBYTE)(len > 255 ? 255 : len);
 305         if (s2 != NULL)
 306         {
 307             strcpy(s2, name);
 308             dl->dol_Type = type;
 309             return dl;
 310         }
 311         FreeVec(dl);
 312     }
 313     return NULL;
 314 }
 315
 316 LONG W_RemDosEntry(struct DosList *dlist, struct globaldata *g)
 317 {
 318     struct DosList *dl;
 319
 320     if (ISKS20)
 321         return AROS_LVO_CALL1(LONG,
 322                 AROS_LCA(struct DosList*, dlist, D1),
 323                 struct DosLibrary*, DOSBase, 112, );
 324
 325     if(dlist == NULL)
 326         return 0;
 327
 328     dl = getdoslist(g);
 329
 330     while(dl->dol_Next)
 331     {
 332         struct DosList *dl2 = BADDR(dl->dol_Next);
 333
 334         if(dl2 == dlist)
 335         {
 336             dl->dol_Next = dlist->dol_Next;
 337             break;
 338         }
 339
 340         dl = dl2;
 341     }
 342
 343     freedoslist(g);
 344
 345     return 1;
 346 }
 347
 348 void W_FreeDosEntry(struct DosList *dlist, struct globaldata *g)
 349 {
 350     if (ISKS20) {
 351         AROS_LVO_CALL1(void,
 352                 AROS_LCA(struct DosList*, dlist, D1),
 353                 struct DosLibrary*, DOSBase, 117, );
 354         return;
 355     }
 356     if (dlist == NULL)
 357         return;
 358     FreeVec(BADDR(dlist->dol_Name));
 359     FreeVec(dlist);
 360 }
 361
 362 LONG W_AddDosEntry(struct DosList *dlist, struct globaldata *g)
 363 {
 364     LONG success = DOSTRUE;
 365     struct DosList *dl;
 366
 367     if (ISKS20)
 368         return AROS_LVO_CALL1(LONG,
 369                 AROS_LCA(struct DosList*, dlist, D1),
 370                 struct DosLibrary*, DOSBase, 113, );
 371
 372     if (dlist == NULL)
 373         return success;
 374
 375     D(bug("[AddDosEntry] Adding '%b' type %d from addr %x Task '%s'\n",
 376         dlist->dol_Name, dlist->dol_Type, dlist,
 377         FindTask(NULL)->tc_Node.ln_Name));
 378
 379     dl = getdoslist(g);
 380
 381     if(dlist->dol_Type != DLT_VOLUME)
 382     {
 383         while(TRUE)
 384         {
 385             dl = BADDR(dl->dol_Next);
 386
 387             if(dl == NULL)
 388                 break;
 389
 390             if(dl->dol_Type != DLT_VOLUME && !CMPBSTR(dl->dol_Name, dlist->dol_Name))
 391             {
 392                 D(bug("[AddDosEntry] Name clash for %08lx->dol_Name: %b and %08lx->dol_Name %b\n", dl, dl->dol_Name, dlist, dlist->dol_Name));
 393                 success = DOSFALSE;
 394                 break;
 395             }
 396         }
 397     }
 398
 399     if(success)
 400     {
 401         struct DosInfo *dinf = BADDR(DOSBase->dl_Root->rn_Info);
 402
 403         dlist->dol_Next = dinf->di_DevInfo;
 404         dinf->di_DevInfo = MKBADDR(dlist);
 405     }
 406
 407     freedoslist(g);
 408
 409     return success;
 410 }
 411
 412 IPTR CallHookPkt(struct Hook *hook, APTR object, APTR paramPacket)
 413 {
 414     return CALLHOOKPKT(hook, object, paramPacket);
 415 }
 416
 417 BOOL W_ErrorReport(LONG code, LONG type, IPTR arg1, struct MsgPort *device, struct globaldata *g)
 418 {
 419     if (ISKS20)
 420         return AROS_LVO_CALL4(BOOL,
 421                 AROS_LCA(LONG, code, D1),
 422                 AROS_LCA(LONG, type, D2),
 423                 AROS_LCA(IPTR, arg1, D3),
 424                 AROS_LCA(struct MsgPort*, device, D4),
 425                 struct DosLibrary*, DOSBase, 80, );
 426
 427     return FALSE;
 428 }
 429
 430 LONG W_EasyRequestArgs(struct Window *window, struct EasyStruct *easyStruct, ULONG *IDCMP_ptr, APTR argList, struct globaldata *g)
 431 {
 432     if (ISKS20)
 433         return AROS_LVO_CALL4(LONG,
 434                 AROS_LCA(struct Window*, window, A0),
 435                 AROS_LCA(struct EasyStruct*, easyStruct, A1),
 436                 AROS_LCA(ULONG*, IDCMP_ptr, A2),
 437                 AROS_LCA(APTR, argList, A3),
 438                 APTR, IntuitionBase, 98, );
 439     return 1;
 440 }
 441
 442 struct Window *W_BuildEasyRequestArgs(struct Window *RefWindow, struct EasyStruct *easyStruct, ULONG IDCMP, APTR Args, struct globaldata *g)
 443 {
 444     if (ISKS20)
 445         return AROS_LVO_CALL4(struct Window*,
 446                 AROS_LCA(struct Window*, RefWindow, A0),
 447                 AROS_LCA(struct EasyStruct*, easyStruct, A1),
 448                 AROS_LCA(ULONG, IDCMP, D0),
 449                 AROS_LCA(APTR, Args, A3),
 450                 APTR, IntuitionBase, 99, );
 451     return NULL;
 452 }
 453
 454 LONG W_SysReqHandler(struct Window *window, ULONG *IDCMPFlagsPtr, BOOL WaitInput, struct globaldata *g)
 455 {
 456     if (ISKS20)
 457         return AROS_LVO_CALL3(LONG,
 458                 AROS_LCA(struct Window*, window, A0),
 459                 AROS_LCA(ULONG*, IDCMPFlagsPtr, A1),
 460                 AROS_LCA(BOOL, WaitInput, D0),
 461                 APTR, IntuitionBase, 100, );
 462     return 0;
 463 }
 464
 465 #undef SysBase
 466 #undef DOSBase
 467
 468 void FixStartupPacket(struct DosPacket *pkt, struct globaldata *g)
 469 {
 470         if (pkt->dp_Arg3)
 471                 return;
 472         /* Fix 1.3 bad boot time ACTION_STARTUP: dp_Arg3 = NULL, dp_Arg1 = uninitialized data */
 473         struct DosList *dl = getdoslist(g);
 474         while(dl->dol_Next)
 475         {
 476                 dl = BADDR(dl->dol_Next);
 477                 if (dl->dol_Type == DLT_DEVICE && dl->dol_misc.dol_handler.dol_Startup == pkt->dp_Arg2) {
 478                         /* This is safe, Startup Packet is allocated from BCPL stack
 479                          * that goes away after DOS gets message reply.
 480                          */
 481                         pkt->dp_Arg1 = dl->dol_Name;
 482                         pkt->dp_Arg3 = MKBADDR(dl);
 483                         break;
 484                 }
 485         }
 486         freedoslist(g);
 487 }
 488
 489 LONG wrapper_stackswap(LONG (*func)(struct ExecBase *), struct ExecBase *SysBase)
 490 {
 491         struct DosLibrary *DOSBase;
 492     ULONG stacksize;
 493     APTR stackptr;
 494     struct Task *tc;
 495     struct StackSwapStruct *stack;
 496     LONG ret;
 497
 498     tc = FindTask(NULL);
 499     stacksize = (UBYTE *)tc->tc_SPUpper - (UBYTE *)tc->tc_SPLower;
 500     if (stacksize >= MIN_STACKSIZE) {
 501         ret = func(SysBase);
 502         return ret;
 503     }
 504
 505     stack = AllocMem(sizeof(struct StackSwapStruct) + MIN_STACKSIZE, MEMF_CLEAR | MEMF_PUBLIC);
 506     if (!stack) {
 507         Alert(AT_DeadEnd | AG_NoMemory);
 508         return RETURN_FAIL;
 509     }
 510     stackptr = stack + 1;
 511     stack->stk_Lower = stackptr;
 512     stack->stk_Upper = (APTR)((IPTR)stack->stk_Lower + MIN_STACKSIZE);
 513     stack->stk_Pointer = (APTR)stack->stk_Upper;
 514
 515         DOSBase = (struct DosLibrary *)OpenLibrary ("dos.library", MIN_LIB_VERSION);
 516     if (ISKS20) {
 517         AROS_LVO_CALL1(void,
 518             AROS_LCA(struct StackSwapStruct*, stack, A0),
 519             struct ExecBase*, SysBase, 122, );
 520         ret = func(SysBase);
 521         AROS_LVO_CALL1(void,
 522             AROS_LCA(struct StackSwapStruct*, stack, A0),
 523             struct ExecBase*, SysBase, 122, );
 524     } else {
 525         AROS_UFC2(void, StackSwap,
 526             AROS_UFCA(struct StackSwapStruct*, stack, A0),
 527             AROS_UFCA(struct ExecBase*, SysBase, A6));
 528         ret = func(SysBase);
 529         AROS_UFC2(void, StackSwap,
 530             AROS_UFCA(struct StackSwapStruct*, stack, A0),
 531             AROS_UFCA(struct ExecBase*, SysBase, A6));
 532     }
 533     FreeMem(stack, sizeof(struct StackSwapStruct) + MIN_STACKSIZE);
 534     CloseLibrary((struct Library*)DOSBase);
 535
 536     return ret;
 537 }
 538
 539 #endif
 540
 541 size_t strcspn (const char * str, const char * reject)
 542 {
 543     size_t n = 0; /* Must set this to zero */
 544
 545     while (*str && !strchr (reject, *str))
 546     {
 547         str ++;
 548         n ++;
 549     }
 550
 551     return n;
 552 }
 553