source: cmedia/trunk/Drv32/init.c

/* $Id: init.c,v 1.3 2001/04/14 17:03:35 sandervl Exp $ */

//******************************************************************************
// Init strategy handler
//
// Copyright 2000 Sander van Leeuwen (sandervl@xs4all.nl)
//
//     This program is free software; you can redistribute it and/or
//     modify it under the terms of the GNU General Public License as
//     published by the Free Software Foundation; either version 2 of
//     the License, or (at your option) any later version.
//
//     This program is distributed in the hope that it will be useful,
//     but WITHOUT ANY WARRANTY; without even the implied warranty of
//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//     GNU General Public License for more details.
//
//     You should have received a copy of the GNU General Public
//     License along with this program; if not, write to the Free
//     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
//     USA.
//
//******************************************************************************
extern "C" {               // 16-bit header files are not C++ aware
#define INCL_NOPMAPI
#define INCL_DOSMISC
#include <os2.h>
}
#include <string.h>

// Device support
#include <devhelp.h>
#include <devtype.h>
#include <devrp.h>
#include "devown.h"
#include <sbversion.h>
#include <dbgos2.h>
#ifdef KEE
#include <kee.h>
#endif

const char ERR_ERROR[]   = "\r\nERROR: ";
const char ERR_LOCK[]    = "Unable to lock 32 bit data & code segments, exiting...\r\n";
#ifdef KEE
const char szSBLive[]    = "\r\n\r\n"PRODUCT_NAME" Audio Driver v"PRODUCT_VERSION" (32 Bits KEE)\r\n";
#else
const char szSBLive[]    = "\r\n\r\n"PRODUCT_NAME" Audio Driver v"PRODUCT_VERSION" (32 Bits)\r\n";
#endif
const char szCopyRight[] = "Copyright 1999 ChenLi Tien (Linux Version)\r\n"
                           "Copyright 2000-2001 Sander van Leeuwen (OS/2 Port)\r\n"
                           "Copyright 2001-2005 Rdiger Ihle (OS/2 Port)\r\n\r\n";
const char szCodeStartEnd[] = "Code 0x%0x - 0x%0x\r\n\r\n";

typedef struct {
 USHORT MsgLength;
 WORD32 MsgPtr;
} MSG_TABLE;


extern "C" {
  //Messages
  extern WORD32 MSG_TABLE32;

  //Module parameters
  extern int    use_line_as_rear;
  extern int    use_line_as_bass;
  extern int    joystick;
  extern int    spdif_inverse;
  extern int    spdif_5v;
  extern int    spdif_src;
  extern int    spdif_copyright;
  extern int    spdif_enable;
  extern int    spdif_loop;
  extern int    mic_boost;

  int sprintf (char *buffer, const char *format, ...);
};


//Print messages with DosWrite when init is done or has failed (see startup.asm)
void DevSaveMessage(char __far *str, int length)
{
  MSG_TABLE __far       *msg = (MSG_TABLE __far *)__Make48Pointer(MSG_TABLE32);
  char __far            *str16 = (char __far *)__Make48Pointer(msg->MsgPtr);

  if( length >= 0 ) {
        _fmemcpy(str16 + msg->MsgLength, str, length);
        msg->MsgLength += length;
  } else {
        msg->MsgLength = 0;
  }

  str16[msg->MsgLength] = 0;
}

//SvL: Lock our 32 bits data & code segments
int LockSegments(void)
{
#ifdef KEE
 KEEVMLock lock;
#else
 char   lock[12];
 ULONG  PgCount;
#endif
 ULONG  segsize;

    /*
     * Locks DGROUP into physical memory
     */
    //NOTE: VMLock rounds base address down to nearest page
    //      So we MUST take this into account when calculating the
    //      size of our code/data
    segsize = OffsetFinalDS32 - ((OffsetBeginDS32) & ~0xFFF);
    if(segsize & 0xFFF) {
        segsize += PAGE_SIZE;
    }
    segsize &= ~0xFFF;
#ifdef KEE
    if(KernVMLock(VMDHL_LONG,
                  (PVOID)((OffsetBeginDS32) & ~0xFFF),
                  segsize,
                  &lock,
                  (KEEVMPageList*)-1,
                  0)) {
#else
    if(DevVMLock(VMDHL_LONG,
                   ((OffsetBeginDS32) & ~0xFFF),
                   segsize,
                   (LINEAR)-1,
                   __StackToFlat((ULONG)lock),
                   (LINEAR)__StackToFlat((ULONG)&PgCount))) {
#endif
        return(1);
    }
    /*
     * Locks CODE32 into physical memory
     */
    segsize = OffsetFinalCS32 - ((OffsetBeginCS32) & ~0xFFF);
    if(segsize & 0xFFF) {
        segsize += PAGE_SIZE;
    }
    segsize &= ~0xFFF;
#ifdef KEE
    if(KernVMLock(VMDHL_LONG,
                  (PVOID)((OffsetBeginCS32) & ~0xFFF),
                  segsize,
                  &lock,
                  (KEEVMPageList*)-1,
                  0)) {
#else
    if(DevVMLock(VMDHL_LONG,
                 ((OffsetBeginCS32) & ~0xFFF),
                 segsize,
                 (LINEAR)-1,
                 __StackToFlat((ULONG)lock),
                 (LINEAR)__StackToFlat((ULONG)&PgCount))) {
#endif
        return(1);
    }
    return 0;
}


// Write a string of specified length
static VOID WriteString(const char __far* str, int length)
{
  // Write the string
  DevSaveMessage((char __far *)str, length);
  return;
}

// Initialize device driver
WORD32 DiscardableInit(RPInit __far* rp)
{
  unsigned      twochars, options;
  char          debugmsg[64];
  char FAR48    *args;
  char          ch;

  GetTKSSBase();

  WriteString(szSBLive, sizeof(szSBLive)-1);

  if(LockSegments()) {
        WriteString(ERR_ERROR, sizeof(ERR_ERROR)-1);
        WriteString(ERR_LOCK, sizeof(ERR_LOCK)-1);

        rp->Out.FinalCS = rp->Out.FinalDS = 0;
        return RPDONE | RPERR;
  }

  WriteString(szCopyRight, sizeof(szCopyRight)-1);

  //Do you init here:

  args = __Make48Pointer(rp->In.Args);
  while(*args && *args == ' ') args++;
  while(*args && *args != ' ') args++;

  twochars = options = 0;
  while( (ch = *args++) != '\0' ) {
    if( ch >= 'a' && ch <= 'z' )        ch &= 0x5f;
    twochars = (twochars << 8) | ch;
    switch( twochars & 0xffff ) {
      case ('/' << 8) | 'D' :   options |= 3;           break;
      case ('/' << 8) | 'V' :   options |= 2;           break;
      case ('/' << 8) | 'R' :   use_line_as_rear ^= 1;  break;
      case ('/' << 8) | 'B' :   use_line_as_bass ^= 1;  break;
      case ('/' << 8) | 'N' :   joystick ^= 1;          break;
      case ('/' << 8) | 'I' :   spdif_inverse ^= 1;     break;
      case ('/' << 8) | '0' :   spdif_5v ^= 1;          break;
      case ('/' << 8) | '2' :   spdif_src ^= 1;         break;
      case ('/' << 8) | 'C' :   spdif_copyright ^= 1;   break;
      case ('/' << 8) | 'S' :   spdif_enable ^= 1;      break;
      case ('/' << 8) | 'L' :   spdif_loop ^= 1;        break;
      case ('/' << 8) | 'M' :   mic_boost ^= 1;         break;
    }
  }

  if( options & 1 ) {
        WriteString(debugmsg,
           sprintf(debugmsg, szCodeStartEnd, OffsetBeginCS32, OffsetFinalCS32));
  }

  if( !(options & 2) ) {
        WriteString(NULL, -1);
  }

  // Complete the installation
  rp->Out.FinalCS = _OffsetFinalCS16;
  rp->Out.FinalDS = _OffsetFinalDS16;

  // Confirm a successful installation
  return RPDONE;
}