workbench/libs/gl/gl_init.c

   1 /*
   2     Copyright 2015, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 //#define DEBUG 1
   7 #include <aros/debug.h>
   8
   9 #include <proto/exec.h>
  10 #include <proto/dos.h>
  11
  12 #include <proto/alib.h>
  13
  14 #include <aros/libcall.h>
  15 #include <exec/resident.h>
  16 #include <libraries/dos.h>
  17
  18 #include <stdio.h>
  19 #include <string.h>
  20
  21 #include "gl_intern.h"
  22
  23 #define DOSBase GLB(base)->glb_DOS
  24
  25 static AROS_UFP3 (struct Library *, GM_UNIQUENAME(LibInit),
  26                   AROS_UFPA(struct Library *, base, D0),
  27                   AROS_UFPA(BPTR, librarySegment, A0),
  28                   AROS_UFPA(struct ExecBase *, sysBase, A6)
  29 );
  30 static AROS_LD1 (struct Library *, GM_UNIQUENAME(LibOpen),
  31                  AROS_LPA (ULONG, version, D0),
  32                  struct Library *, base, 1, GL
  33 );
  34 static AROS_LD0 (BPTR, GM_UNIQUENAME(LibClose),
  35                  struct Library *, base, 2, GL
  36 );
  37 static AROS_LD1(BPTR, GM_UNIQUENAME(LibExpunge),
  38                 AROS_LPA(struct Library *, __extrabase, D0),
  39                 struct Library *, base, 3, GL
  40 );
  41
  42 __startup int Main(void)
  43 {
  44     return RETURN_FAIL;
  45 }
  46
  47 struct ExecBase *SysBase = NULL;
  48
  49 static const char GM_UNIQUENAME(LibName)[] = MOD_NAME_STRING;
  50 static const char GM_UNIQUENAME(LibID)[]   = VERSION_STRING;
  51
  52 static IPTR GM_UNIQUENAME(LibNull)(VOID)
  53 {
  54     return(0);
  55 }
  56
  57 STATIC CONST CONST_APTR GM_UNIQUENAME(LibVectors)[] =
  58 {
  59     (CONST_APTR)AROS_SLIB_ENTRY(GM_UNIQUENAME(LibOpen), GL, 1),
  60     (CONST_APTR)AROS_SLIB_ENTRY(GM_UNIQUENAME(LibClose), GL, 2),
  61     (CONST_APTR)AROS_SLIB_ENTRY(GM_UNIQUENAME(LibExpunge), GL, 3),
  62     (CONST_APTR)GM_UNIQUENAME(LibNull),
  63     (CONST_APTR)-1
  64 };
  65
  66 STATIC CONST IPTR GM_UNIQUENAME(LibInitTab)[] =
  67 {
  68     sizeof(struct LIBBASE),
  69     (IPTR)GM_UNIQUENAME(LibVectors),
  70     (IPTR)NULL,
  71     (IPTR)GM_UNIQUENAME(LibInit)
  72 };
  73
  74 static const struct Resident ROMTag =
  75 {
  76     RTC_MATCHWORD,
  77     (struct Resident *)&ROMTag,
  78     (struct Resident *)(&ROMTag + 1),
  79     RESIDENTFLAGS,
  80     VERSION_NUMBER,
  81     NT_LIBRARY,
  82     0,
  83     (char *)GM_UNIQUENAME(LibName),
  84     (char *)(GM_UNIQUENAME(LibID) + 6),          // +6 to skip '$VER: '
  85     (APTR)GM_UNIQUENAME(LibInitTab),
  86     REVISION_NUMBER,
  87     0
  88 };
  89
  90 #define BUFFER_SIZE 256
  91
  92 char *GetGLVarPath(struct Library *base)
  93 {
  94     char pathBuff[BUFFER_SIZE];
  95     BPTR pathLock = BNULL;
  96
  97     D(bug("[GL] %s()\n", __PRETTY_FUNCTION__));
  98
  99     if ((pathLock = Lock("ENV:SYS", SHARED_LOCK)) != BNULL)
 100     {
 101         if (NameFromLock(pathLock, pathBuff, BUFFER_SIZE))
 102         {
 103             GLB(base)->glb_Notify.nr_Name = AllocVec(strlen(pathBuff) + 4, MEMF_PUBLIC);
 104             sprintf(GLB(base)->glb_Notify.nr_Name, "%s/GL", pathBuff);
 105             D(bug("[GL] %s: using '%s'\n", __PRETTY_FUNCTION__, GLB(base)->glb_Notify.nr_Name));
 106         }
 107         UnLock(pathLock);
 108     }
 109     return GLB(base)->glb_Notify.nr_Name;
 110 }
 111
 112 void GetGLVar(struct Library *base)
 113 {
 114     LONG            Var_Length;
 115     char            Var_Value[BUFFER_SIZE];
 116
 117     D(bug("[GL] %s()\n", __PRETTY_FUNCTION__));
 118
 119     FreeVec(GLB(base)->glb_GLImpl);
 120
 121     Var_Length = GetVar((STRPTR)"SYS/GL",
 122               &Var_Value[0],
 123               BUFFER_SIZE,
 124               GVF_GLOBAL_ONLY | LV_VAR
 125      );
 126
 127     if (Var_Length != -1)
 128     {
 129         if ((GLB(base)->glb_GLImpl = AllocVec(strlen(Var_Value) + strlen(".library") + 1, MEMF_PUBLIC)) != NULL)
 130         {
 131             sprintf(GLB(base)->glb_GLImpl, "%s.library", Var_Value);
 132             D(bug("[GL] %s: using '%s' for %s\n", __PRETTY_FUNCTION__, GLB(base)->glb_GLImpl, Var_Value));
 133         }
 134    }
 135 }
 136
 137 void gl_EnvNotifyProc(void)
 138 {
 139     struct Process *pr = (struct Process *) FindTask (NULL);
 140     struct Library *base = ((struct Task *)pr)->tc_UserData;
 141     struct Message *msg;
 142
 143     D(bug("[GL] %s()\n", __PRETTY_FUNCTION__));
 144
 145     while (TRUE)
 146     {
 147         WaitPort (&pr->pr_MsgPort);
 148         while ((msg = GetMsg (&pr->pr_MsgPort)))
 149             ReplyMsg(msg);
 150
 151         GetGLVar(base);
 152     }
 153 }
 154
 155 void SetupGLVarNotification(struct Library *base)
 156 {
 157     D(bug("[GL] %s()\n", __PRETTY_FUNCTION__));
 158
 159     if (!GLB(base)->glb_Notify.nr_Name)
 160         GetGLVarPath(base);
 161
 162     if (GLB(base)->glb_Notify.nr_Name)
 163     {
 164         if (!GLB(base)->glb_Notify.nr_stuff.nr_Msg.nr_Port)
 165         {
 166             struct TagItem enprocTags[] =
 167             {
 168                 { NP_Entry,         (IPTR)gl_EnvNotifyProc  },
 169                 { NP_UserData,      (IPTR)base              },
 170                 { TAG_END,          0                       }
 171             };
 172             struct Process *enProc;
 173             if ((enProc = CreateNewProc(enprocTags)) != NULL)
 174             {
 175                 D(bug("[GL] %s: FS Notification Proc @ 0x%p for '%s'\n", __PRETTY_FUNCTION__, enProc, GLB(base)->glb_Notify.nr_Name));
 176
 177                 GLB(base)->glb_Notify.nr_stuff.nr_Msg.nr_Port   = &enProc->pr_MsgPort;
 178             }
 179             D(bug("[GL] %s: MsgPort @ 0x%p\n", __PRETTY_FUNCTION__,GLB(base)->glb_Notify.nr_stuff.nr_Msg.nr_Port));
 180         }
 181
 182         if (GLB(base)->glb_Notify.nr_stuff.nr_Msg.nr_Port && !GLB(base)->glb_Notify.nr_FullName)
 183         {
 184             GLB(base)->glb_Notify.nr_Flags                      = NRF_SEND_MESSAGE|NRB_NOTIFY_INITIAL;
 185             StartNotify(&GLB(base)->glb_Notify);
 186             D(bug("[GL] %s: Started FS Notification for '%s'\n", __PRETTY_FUNCTION__, GLB(base)->glb_Notify.nr_FullName));
 187         }
 188     }
 189 }
 190
 191 static AROS_UFH3(struct Library *, GM_UNIQUENAME(LibInit),
 192                  AROS_UFHA(struct Library *, base, D0),
 193                  AROS_UFHA(BPTR, librarySegment, A0),
 194                  AROS_UFHA(struct ExecBase *, sysBase, A6)
 195 )
 196 {
 197     AROS_USERFUNC_INIT
 198
 199     SysBase = sysBase;
 200
 201     D(bug("[GL] %s()\n", __PRETTY_FUNCTION__));
 202
 203     D(bug("[GL] %s: base @ 0x%p, SysBase @ 0x%p\n", __PRETTY_FUNCTION__, base, SysBase));
 204
 205     // setup the library structure.
 206     GLB(base)->glb_Lib.lib_Node.ln_Type = NT_LIBRARY;
 207     GLB(base)->glb_Lib.lib_Node.ln_Pri  = 0;
 208     GLB(base)->glb_Lib.lib_Node.ln_Name = (char *)GM_UNIQUENAME(LibName);
 209     GLB(base)->glb_Lib.lib_Flags        = LIBF_CHANGED | LIBF_SUMUSED;
 210     GLB(base)->glb_Lib.lib_Version      = VERSION_NUMBER;
 211     GLB(base)->glb_Lib.lib_Revision     = REVISION_NUMBER;
 212     GLB(base)->glb_Lib.lib_IdString     = (char *)(GM_UNIQUENAME(LibID) + 6);
 213
 214     GLB(base)->glb_DOS = OpenLibrary("dos.library", 0);
 215
 216     D(bug("[GL] %s: DOSBase @ 0x%p\n", __PRETTY_FUNCTION__, DOSBase));
 217
 218     memset(&GLB(base)->glb_Sem, 0,
 219         sizeof(struct SignalSemaphore) + sizeof(struct NotifyRequest));
 220     InitSemaphore(&GLB(base)->glb_Sem);
 221
 222     SetupGLVarNotification(base);
 223
 224     // return the library base as success
 225     return base;
 226
 227     AROS_USERFUNC_EXIT
 228 }
 229
 230 static AROS_LH1(struct Library *, GM_UNIQUENAME(LibOpen),
 231                 AROS_LHA(ULONG, version, D0),
 232                 struct Library *, base, 1, GL
 233 )
 234 {
 235     AROS_LIBFUNC_INIT
 236
 237     struct Library *res = NULL;
 238     char *glImplementation;
 239
 240     D(bug("[GL] %s()\n", __PRETTY_FUNCTION__));
 241
 242     // delete the late expunge flag
 243     GLB(base)->glb_Lib.lib_Flags &= ~LIBF_DELEXP;
 244
 245     if (GLB(base)->glb_GLImpl)
 246         glImplementation = GLB(base)->glb_GLImpl;
 247     else
 248         glImplementation = "mesa3dgl.library";
 249
 250     D(bug("[GL] %s: Attempting to use '%s' version %d\n", __PRETTY_FUNCTION__, glImplementation, version));
 251
 252     res = OpenLibrary(glImplementation, version);
 253
 254     return res;
 255
 256     AROS_LIBFUNC_EXIT
 257 }
 258
 259 /* NB: we dont ever really close */
 260
 261 static AROS_LH0(BPTR, GM_UNIQUENAME(LibClose),
 262                 struct Library *, base, 2, GL
 263 )
 264 {
 265     AROS_LIBFUNC_INIT
 266
 267     BPTR rc = 0;
 268
 269     D(bug("[GL] %s()\n", __PRETTY_FUNCTION__));
 270
 271     return rc;
 272
 273     AROS_LIBFUNC_EXIT
 274 }
 275
 276 static AROS_LH1(BPTR, GM_UNIQUENAME(LibExpunge),
 277   AROS_LHA(struct Library *, __extrabase, D0),
 278   struct Library *, base, 3, GL
 279 )
 280 {
 281     AROS_LIBFUNC_INIT
 282
 283     BPTR rc = 0;
 284
 285     D(bug("[GL] %s()\n", __PRETTY_FUNCTION__));
 286
 287     return rc;
 288
 289     AROS_LIBFUNC_EXIT
 290 }