* Patch by Thomas Frieden, 13 Nov 2002:

  Add code for AmigaOne board
  (preliminary merge to U-Boot, still WIP)

* Patch by Jon Diekema, 12 Nov 2002:
  - Adding URL for IEEE OUI lookup
  - Making the autoboot #defines dependent on CONFIG_AUTOBOOT_KEYED
    being defined.
  - In the CONFIG_EXTRA_ENV_SETTINGS #define, the root-on-initrd and
    root-on-nfs macros are designed to switch how the default boot
    method gets defined.

1 files changed, 480 insertions, 0 deletions

diff --git a/board/MAI/bios_emulator/scitech/src/pm/common.c b/board/MAI/bios_emulator/scitech/src/pm/common.c
new file mode 100644
index 000000000..b100b8ad4
--- /dev/null
+++ b/board/MAI/bios_emulator/scitech/src/pm/common.c
@@ -0,0 +1,480 @@
+/****************************************************************************
+*
+*                   SciTech OS Portability Manager Library
+*
+*  ========================================================================
+*
+*    The contents of this file are subject to the SciTech MGL Public
+*    License Version 1.0 (the "License"); you may not use this file
+*    except in compliance with the License. You may obtain a copy of
+*    the License at http://www.scitechsoft.com/mgl-license.txt
+*
+*    Software distributed under the License is distributed on an
+*    "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+*    implied. See the License for the specific language governing
+*    rights and limitations under the License.
+*
+*    The Original Code is Copyright (C) 1991-1998 SciTech Software, Inc.
+*
+*    The Initial Developer of the Original Code is SciTech Software, Inc.
+*    All Rights Reserved.
+*
+*  ========================================================================
+*
+* Language:     ANSI C
+* Environment:  Any
+*
+* Description:  Module containing code common to all platforms.
+*
+****************************************************************************/
+
+#include "pmapi.h"
+#include "drvlib/os/os.h"
+#if defined(__WIN32_VXD__) || defined(__OS2_VDD__) || defined(__NT_DRIVER__)
+#include "sdd/sddhelp.h"
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#endif
+
+/*---------------------------- Global variables ---------------------------*/
+
+/* {secret} */
+long _VARAPI    ___drv_os_type = _OS_UNSUPPORTED;
+static char     localBPDPath[PM_MAX_PATH] = "";
+
+/*----------------------------- Implementation ----------------------------*/
+
+/****************************************************************************
+PARAMETERS:
+path    - Local path to the Nucleus BPD driver files.
+
+REMARKS:
+This function is used by the application program to override the location
+of the Nucleus driver files that are loaded. Normally the loader code
+will look in the system Nucleus directories first, then in the 'drivers'
+directory relative to the current working directory, and finally relative
+to the MGL_ROOT environment variable. By default the local BPD path is
+always set to the current directory if not initialised.
+****************************************************************************/
+void PMAPI PM_setLocalBPDPath(
+    const char *path)
+{
+    PM_init();
+    strncpy(localBPDPath,path,sizeof(localBPDPath));
+    localBPDPath[sizeof(localBPDPath)-1] = 0;
+}
+
+/****************************************************************************
+PARAMETERS:
+bpdpath     - Place to store the actual path to the file
+cachedpath  - Place to store the cached BPD driver path
+trypath     - Path to try to find the BPD file in
+subpath     - Optional sub path to append to trypath
+dllname     - Name of the Binary Portable DLL to load
+
+RETURNS:
+True if found, false if not.
+
+REMARKS:
+Trys the specified path to see if the BPD file can be found or not. If so,
+the path used is returned in bpdpath and cachedpath.
+****************************************************************************/
+static ibool TryPath(
+    char *bpdpath,
+    char *cachedpath,
+    const char *trypath,
+    const char *subpath,
+    const char *dllname)
+{
+    char    filename[256];
+    FILE    *f;
+
+    strcpy(bpdpath, trypath);
+    PM_backslash(bpdpath);
+    strcat(bpdpath,subpath);
+    PM_backslash(bpdpath);
+    strcpy(filename,bpdpath);
+    strcat(filename,dllname);
+    if ((f = fopen(filename,"rb")) == NULL)
+        return false;
+    if (cachedpath)
+        strcpy(cachedpath,bpdpath);
+    fclose(f);
+    return true;
+}
+
+/****************************************************************************
+RETURNS:
+True if local override enabled, false if not.
+
+REMARKS:
+Tests to see if the local override option is enabled, and if so it will
+look for the Nucleus drivers in the local application directories in
+preference to the Nucleus system directories.
+****************************************************************************/
+static ibool GetLocalOverride(void)
+{
+    char            filename[256];
+    FILE            *f;
+    static ibool    local_override = -1;
+
+    if (local_override == -1) {
+        local_override = false;
+        strcpy(filename,PM_getNucleusPath());
+        PM_backslash(filename);
+        strcat(filename,"graphics.ini");
+        if ((f = fopen(filename,"r")) != NULL) {
+            while (!feof(f) && fgets(filename,sizeof(filename),f)) {
+                if (strnicmp(filename,"uselocal",8) == 0) {
+                    local_override = ((*(filename+9) - '0') == 1);
+                    break;
+                    }
+                }
+            fclose(f);
+            }
+        }
+    return local_override;
+}
+
+/****************************************************************************
+DESCRIPTION:
+Sets the location of the debug log file.
+
+HEADER:
+pmapi.h
+
+PARAMETERS:
+dllname - Name of the Binary Portable DLL to load
+bpdpath - Place to store the actual path to the file
+
+RETURNS:
+True if found, false if not.
+
+REMARKS:
+Finds the location of a specific Binary Portable DLL, by searching all
+the standard SciTech Nucleus driver locations.
+****************************************************************************/
+ibool PMAPI PM_findBPD(
+    const char *dllname,
+    char *bpdpath)
+{
+    static char cachedpath[PM_MAX_PATH] = "";
+
+    /* On the first call determine the path to the Nucleus drivers */
+    if (cachedpath[0] == 0) {
+        /* First try in the global system Nucleus driver path if
+         * the local override setting is not enabled.
+         */
+        PM_init();
+        if (!GetLocalOverride()) {
+            if (TryPath(bpdpath,cachedpath,PM_getNucleusPath(),"",dllname))
+                return true;
+            }
+
+        /* Next try in the local application directory if available */
+        if (localBPDPath[0] != 0) {
+            if (TryPath(bpdpath,cachedpath,localBPDPath,"",dllname))
+                return true;
+            }
+        else {
+#if !defined(__WIN32_VXD__) && !defined(__NT_DRIVER__)
+            char    *mgl_root;
+            if ((mgl_root = getenv("MGL_ROOT")) != NULL) {
+                if (TryPath(bpdpath,cachedpath,mgl_root,"drivers",dllname))
+                    return true;
+                }
+#endif
+            PM_getCurrentPath(bpdpath,PM_MAX_PATH);
+            if (TryPath(bpdpath,cachedpath,bpdpath,"drivers",dllname))
+                return true;
+            }
+
+        /* Finally try in the global system path again so that we
+         * will still find the drivers in the global system path if
+         * the local override option is on, but the application does
+         * not have any local override drivers.
+         */
+        if (TryPath(bpdpath,cachedpath,PM_getNucleusPath(),"",dllname))
+            return true;
+
+        /* Whoops, we can't find the BPD file! */
+        return false;
+        }
+
+    /* Always try in the previously discovered path */
+    return TryPath(bpdpath,NULL,cachedpath,"",dllname);
+}
+
+/****************************************************************************
+REMARKS:
+Copies a string into another, and returns dest + strlen(src).
+****************************************************************************/
+static char *_stpcpy(
+    char *_dest,
+    const char *_src)
+{
+    if (!_dest || !_src)
+        return 0;
+    while ((*_dest++ = *_src++) != 0)
+        ;
+    return --_dest;
+}
+
+/****************************************************************************
+REMARKS:
+Copies a string into another, stopping at the maximum length. The string
+is properly terminated (unlike strncpy).
+****************************************************************************/
+static void safe_strncpy(
+    char *dst,
+    const char *src,
+    unsigned maxlen)
+{
+    if (dst) {
+        if(strlen(src) >= maxlen) {
+            strncpy(dst, src, maxlen);
+            dst[maxlen] = 0;
+            }
+        else
+            strcpy(dst, src);
+        }
+}
+
+/****************************************************************************
+REMARKS:
+Determins if the dot separator is present in the string.
+****************************************************************************/
+static int findDot(
+    char *p)
+{
+    if (*(p-1) == '.')
+        p--;
+    switch (*--p) {
+        case ':':
+            if (*(p-2) != '\0')
+                break;
+        case '/':
+        case '\\':
+        case '\0':
+            return true;
+        }
+    return false;
+}
+
+/****************************************************************************
+DESCRIPTION:
+Make a full pathname from split components.
+
+HEADER:
+pmapi.h
+
+PARAMETERS:
+path    - Place to store full path
+drive   - Drive component for path
+dir     - Directory component for path
+name    - Filename component for path
+ext     - Extension component for path
+
+REMARKS:
+Function to make a full pathname from split components. Under Unix the
+drive component will usually be empty. If the drive, dir, name, or ext
+parameters are null or empty, they are not inserted in the path string.
+Otherwise, if the drive doesn't end with a colon, one is inserted in the
+path. If the dir doesn't end in a slash, one is inserted in the path.
+If the ext doesn't start with a dot, one is inserted in the path.
+
+The maximum sizes for the path string is given by the constant PM_MAX_PATH,
+which includes space for the null-terminator.
+
+SEE ALSO:
+PM_splitPath
+****************************************************************************/
+void PMAPI PM_makepath(
+    char *path,
+    const char *drive,
+    const char *dir,
+    const char *name,
+    const char *ext)
+{
+    if (drive && *drive) {
+        *path++ = *drive;
+        *path++ = ':';
+        }
+    if (dir && *dir) {
+        path = _stpcpy(path,dir);
+        if (*(path-1) != '\\' && *(path-1) != '/')
+#ifdef  __UNIX__
+            *path++ = '/';
+#else
+            *path++ = '\\';
+#endif
+        }
+    if (name)
+        path = _stpcpy(path,name);
+    if (ext && *ext) {
+        if (*ext != '.')
+            *path++ = '.';
+        path = _stpcpy(path,ext);
+        }
+    *path = 0;
+}
+
+/****************************************************************************
+DESCRIPTION:
+Split a full pathname into components.
+
+HEADER:
+pmapi.h
+
+PARAMETERS:
+path    - Full path to split
+drive   - Drive component for path
+dir     - Directory component for path
+name    - Filename component for path
+ext     - Extension component for path
+
+RETURNS:
+Flags indicating what components were parsed.
+
+REMARKS:
+Function to split a full pathmame into separate components in the form
+
+    X:\DIR\SUBDIR\NAME.EXT
+
+and splits path into its four components. It then stores those components
+in the strings pointed to by drive, dir, name and ext. (Each component is
+required but can be a NULL, which means the corresponding component will be
+parsed but not stored).
+
+The maximum sizes for these strings are given by the constants PM_MAX_DRIVE
+and PM_MAX_PATH. PM_MAX_DRIVE is always 4, and PM_MAX_PATH is usually at
+least 256 characters. Under Unix the dir, name and ext components may be
+up to the full path in length.
+
+SEE ALSO:
+PM_makePath
+****************************************************************************/
+int PMAPI PM_splitpath(
+    const char *path,
+    char *drive,
+    char *dir,
+    char *name,
+    char *ext)
+{
+    char    *p;
+    int     temp,ret;
+    char    buf[PM_MAX_PATH+2];
+
+    /* Set all string to default value zero */
+    ret = 0;
+    if (drive)  *drive = 0;
+    if (dir)    *dir = 0;
+    if (name)   *name = 0;
+    if (ext)    *ext = 0;
+
+    /* Copy filename into template up to PM_MAX_PATH characters */
+    p = buf;
+    if ((temp = strlen(path)) > PM_MAX_PATH)
+        temp = PM_MAX_PATH;
+    *p++ = 0;
+    strncpy(p, path, temp);
+    *(p += temp) = 0;
+
+    /* Split the filename and fill corresponding nonzero pointers */
+    temp = 0;
+    for (;;) {
+        switch (*--p) {
+            case '.':
+                if (!temp && (*(p+1) == '\0'))
+                    temp = findDot(p);
+                if ((!temp) && ((ret & PM_HAS_EXTENSION) == 0)) {
+                    ret |= PM_HAS_EXTENSION;
+                    safe_strncpy(ext, p, PM_MAX_PATH - 1);
+                    *p = 0;
+                    }
+                continue;
+            case ':':
+                if (p != &buf[2])
+                    continue;
+            case '\0':
+                if (temp) {
+                    if (*++p)
+                        ret |= PM_HAS_DIRECTORY;
+                    safe_strncpy(dir, p, PM_MAX_PATH - 1);
+                    *p-- = 0;
+                    break;
+                    }
+            case '/':
+            case '\\':
+                if (!temp) {
+                    temp++;
+                    if (*++p)
+                        ret |= PM_HAS_FILENAME;
+                    safe_strncpy(name, p, PM_MAX_PATH - 1);
+                    *p-- = 0;
+                    if (*p == 0 || (*p == ':' && p == &buf[2]))
+                        break;
+                    }
+                continue;
+            case '*':
+            case '?':
+                if (!temp)
+                    ret |= PM_HAS_WILDCARDS;
+            default:
+                continue;
+            }
+        break;
+        }
+    if (*p == ':') {
+        if (buf[1])
+            ret |= PM_HAS_DRIVE;
+        safe_strncpy(drive, &buf[1], PM_MAX_DRIVE - 1);
+        }
+    return ret;
+}
+
+/****************************************************************************
+DESCRIPTION:
+Block until a specific time has elapsed since the last call
+
+HEADER:
+pmapi.h
+
+PARAMETERS:
+milliseconds    - Number of milliseconds for delay
+
+REMARKS:
+This function will block the calling thread or process until the specified
+number of milliseconds have passed since the /last/ call to this function.
+The first time this function is called, it will return immediately. On
+subsquent calls it will block until the specified time has elapsed, or it
+will return immediately if the time has already elapsed.
+
+This function is useful to provide constant time functionality in a
+program, such as a frame rate limiter for graphics applications etc.
+
+SEE ALSO:
+PM_sleep
+****************************************************************************/
+void PMAPI PM_blockUntilTimeout(
+    ulong milliseconds)
+{
+    ulong                   microseconds = milliseconds * 1000L,msDelay;
+    static LZTimerObject    tm;
+    static ibool            firstTime = true;
+
+    if (firstTime) {
+        firstTime = false;
+        LZTimerOnExt(&tm);
+        }
+    else {
+        if ((msDelay = (microseconds - LZTimerLapExt(&tm)) / 1000L) > 0)
+            PM_sleep(msDelay);
+        while (LZTimerLapExt(&tm) < microseconds)
+            ;
+        LZTimerOffExt(&tm);
+        LZTimerOnExt(&tm);
+        }
+}