Changeset 679 for GPL/trunk/drv32


Ignore:
Timestamp:
Mar 18, 2021, 8:57:36 PM (5 years ago)
Author:
David Azarewicz
Message:

Merge changes from Paul's uniaud32next branch.

Location:
GPL/trunk
Files:
5 deleted
15 edited

Legend:

Unmodified
Added
Removed
  • GPL/trunk

  • GPL/trunk/drv32/Makefile

    r604 r679  
    5454#===================================================================
    5555
    56 FILES = begin.obj startup.obj &
    57   strategy.obj read.obj &
    58   init.obj parse.obj &
    59   devhlp.obj &
    60   idc.obj dispatch.obj &
    61   rmhelp.obj irq.obj util.obj &
    62   impdos.lib
    63 !if "$(KEE)" == "1"
    64 FILES += impkee.lib
    65 !endif
    66 FILES += end.obj
     56FILES = startup.obj strategy.obj read.obj init.obj parse.obj idc.obj &
     57        dispatch.obj rmhelp.obj irq.obj impdos.lib impkee.lib
    6758
    6859LIBS = $(ALSA_LIB)\linuxlib.lib $(ALSA_LIB)\core.lib $(ALSA_LIB)\ac97.lib $(ALSA_LIB)\pci.lib &
     
    7061 $(ALSA_LIB)\mpu401.lib $(ALSA_LIB)\synth.lib $(ALSA_LIB)\cs46xx.lib $(ALSA_LIB)\cs5535audio.lib &
    7162 $(ALSA_LIB)\emu10k1.lib $(ALSA_LIB)\ymfpci.lib $(ALSA_LIB)\ali5451.lib $(ALSA_LIB)\trident.lib &
    72  $(ALSA_LIB)\nm256.lib $(ALSA_LIB)\sb.lib $(ALSA_LIB)\core_oss.lib
     63 $(ALSA_LIB)\nm256.lib $(ALSA_LIB)\sb.lib $(ALSA_LIB)\core_oss.lib $(ALSA_LIB)\hdac.lib
    7364WMAPNAME = $(OBJDIR)\$(TARGET).wmap
    7465
     
    9485  @for %f in ($(LIBS)) do @%append $^@ library %f
    9586  @%write $^@ library $(WATCOM)\lib386\os2\clib3r.lib
    96   @%write $^@ library $(WATCOM)\lib386\os2\os2386.lib
    9787!else
    9888$(LNKFILE): $(MAKEFILE)
     
    10292  @for %f in ($(LIBS)) do @%append $^@ %f
    10393  @%write $^@ $(WATCOM)\lib386\os2\clib3r.lib
    104   @%write $^@ $(WATCOM)\lib386\os2\os2386.lib
    10594!ifdef %DRV32KIT
    10695  @%write $^@ $(%DRV32KIT)\drv32.lib
     
    123112  cd ..\..
    124113  copy $(OBJDIR)\$(TARGET).sym $(ALSA_BIN)
     114  copy $(OBJDIR)\$(TARGET).map $(ALSA_BIN)
    125115
    126116clean: .SYMBOLIC
  • GPL/trunk/drv32/devown.h

    r32 r679  
    2323 */
    2424
    25 
    26 extern WORD32 deviceOwner;
    27 extern WORD32 numOS2Opens;
    28 
    2925#define DEV_NO_OWNER            0
    3026#define DEV_PDD_OWNER           1       //owner is still unknown
  • GPL/trunk/drv32/dispatch.c

    r598 r679  
    2828
    2929#include <dbgos2.h>
    30 #include <devhelp.h>
    31 #include <devtype.h>
    32 #include <strategy.h>
    33 #include "devown.h"
    3430#include <ossidc.h>
    3531#include <ossidc32.h>
    3632#include <version.h>
    37 
    38 extern int cdecl printk(const char * fmt, ...);
    39 //******************************************************************************
    40 // Dispatch IOCtl requests received from the Strategy routine
    41 //******************************************************************************
    42 extern int GetUniaudCardInfo(ULONG deviceid, void *info);
    43 extern int GetUniaudControlNum(ULONG deviceid);
    44 extern int GetUniaudControls(ULONG deviceid, void *pids);
    45 extern int GetUniaudControlInfo(ULONG deviceid, ULONG id, void *info);
    46 extern int GetUniaudControlValueGet(ULONG deviceid, ULONG id, void *value);
    47 extern int GetUniaudControlValuePut(ULONG deviceid, ULONG id, void *value);
    48 extern int GetNumberOfPcm(int card_id);
    49 extern int GetUniaudPcmCaps(ULONG deviceid, void *caps);
    50 extern int SetPCMInstance(int card_id, int pcm);
    51 extern int WaitForControlChange(int card_id, int timeout);
    52 extern int GetNumberOfCards(void);
    53 extern OSSRET OSS32_WaveOpen(ULONG deviceid, ULONG streamtype, OSSSTREAMID *pStreamId, int pcm, USHORT fileid);
    54 extern OSSRET OSS32_WaveClose(OSSSTREAMID streamid);
    55 extern int UniaudIoctlHWRefine(OSSSTREAMID streamid, void *pHwParams);
    56 extern int UniaudIoctlHWParamSet(OSSSTREAMID streamid, void *pHwParams);
    57 extern int UniaudIoctlSWParamSet(OSSSTREAMID streamid, void *pSwParams);
    58 extern int UniaudIoctlPCMStatus(OSSSTREAMID streamid, void *pstatus);
    59 extern int UniaudIoctlPCMWrite(OSSSTREAMID streamid, char *buf, int size);
    60 extern int UniaudIoctlPCMRead(OSSSTREAMID streamid, char *buf, int size);
    61 extern int UniaudIoctlPCMPrepare(OSSSTREAMID streamid);
    62 extern int UniaudIoctlPCMStart(OSSSTREAMID streamid);
    63 extern int UniaudIoctlPCMDrop(OSSSTREAMID streamid);
    64 extern int UniaudIoctlPCMResume(OSSSTREAMID streamid, int pause);
    65 extern void UniaudCloseAll(USHORT fileid);
    66 extern int WaitForPCMInterrupt(void *file, int timeout);
    67 extern int unlock_all;
    68 extern int OSS32_CloseUNI16(void);
    69 extern int UniaudCtlGetPowerState(ULONG deviceid, void *state);
    70 extern int UniaudCtlSetPowerState(ULONG deviceid, void *state);
    71 
    72 typedef UCHAR LOCKHANDLE[12];
     33#include <kee.h>
     34#include <u32ioctl.h>
     35#include "strategy.h"
    7336
    7437/*
     
    8750ULONG StratIOCtl(REQPACKET __far* rp)
    8851{
    89     USHORT rc = 0;;
    90     LOCKHANDLE lhParm, lhData;
    91     LINEAR linParm, linData;
    92     ULONG pages;
     52    USHORT rc = 0;
     53    KEEVMLock lhParm, lhData;
     54    char  *linParm;
     55    char  *linData;
    9356    ULONG *pData;
    9457    ULONG card_id;
     
    11275    {
    11376        // got Parm Packet
    114         rc = DevVirtToLin((USHORT)((ULONG)(rp->ioctl.pvParm) >> 16),
    115                           (ULONG)((USHORT)(rp->ioctl.pvParm)),
    116                           (UCHAR * __far *)&linParm);
    117 
    118         if (rc == 0)
    119         {
    120             if (rp->ioctl.bFunction == IOCTL_OSS32_ATTACH)
    121             {
    122                 rc = DevVMLock(VMDHL_LONG, (ULONG)linParm, 4, (LINEAR)-1L, lhParm, (UCHAR*)&pages);
    123             }
    124             else
    125             {
    126                 rc = DevVMLock(VMDHL_LONG, (ULONG)linParm, rp->ioctl.usParmLen, (LINEAR)-1L, lhParm, (UCHAR*)&pages);
    127             }
    128 
    129             if (rc != 0)
    130             {
    131                 printk("error in DevVMLock rc = %i\n",rc);
    132                 return (RPERR_PARAMETER | RPDONE);
    133             }
    134         } else
    135         {
    136             printk("error in VirtToLin rc = %i\n",rc);
     77        linParm = (char*)KernSelToFlat(rp->ioctl.pvParm);
     78
     79        if (rp->ioctl.bFunction == IOCTL_OSS32_ATTACH)
     80        {
     81            rc = KernVMLock(KEE_VML_LONGLOCK, (PVOID)linParm, 4, &lhParm, (KEEVMPageList*)-1, 0);
     82        }
     83        else
     84        {
     85            rc = KernVMLock(KEE_VML_LONGLOCK, (PVOID)linParm, rp->ioctl.usParmLen, &lhParm, (KEEVMPageList*)-1, 0);
     86        }
     87
     88        if (rc != 0)
     89        {
     90            printk("error in KernVMLock rc = %i\n",rc);
    13791            return (RPERR_PARAMETER | RPDONE);
    13892        }
    139     } else
     93    }
     94    else
    14095    {
    14196        // no Parm Packet
     
    148103    {
    149104        // got Data Packet
    150         rc = DevVirtToLin((USHORT)((ULONG)(rp->ioctl.pvData) >> 16),
    151                           (ULONG)((USHORT)(rp->ioctl.pvData)),
    152                           (UCHAR * __far *)&linData);
    153         if (rc == 0)
    154         {
    155             rc = DevVMLock(VMDHL_LONG, (ULONG)linData, rp->ioctl.usDataLen, (LINEAR)-1L, lhData,
    156                            (UCHAR*)&pages);
    157         } else
    158             printk("error in VirtToLin rc = %i\n",rc);
    159 
     105        linData = (char*)KernSelToFlat(rp->ioctl.pvData);
     106
     107        rc = KernVMLock(KEE_VML_LONGLOCK, (PVOID)linData, rp->ioctl.usDataLen, &lhData, (KEEVMPageList*)-1, 0);
    160108        if (rc != 0)
    161109        {
    162 
    163             printk("error in DevVMLock rc = %i\n",rc);
    164             // error in VirtToLin or DevVMLock
     110            printk("error in KernVMLock rc = %i\n",rc);
    165111            if (linParm != NULL)
    166112            {
    167113                // linParm present & locked, must to unlock it
    168                 DevVMUnLock(lhParm);
     114                KernVMUnlock(&lhParm);
    169115            }
    170116            return (RPERR_PARAMETER | RPDONE);
     
    577523    {
    578524        // linParm present & locked, must to unlock it
    579         DevVMUnLock(lhParm);
     525        KernVMUnlock(&lhParm);
    580526    }
    581527    if (linData != NULL)
    582528    {
    583529        // linData present & locked, must to unlock it
    584         DevVMUnLock(lhData);
     530        KernVMUnlock(&lhData);
    585531    }
    586532
     
    588534    return (rc);
    589535}
    590 
    591 //******************************************************************************
    592 // Dispatch Close requests received from the strategy routine
    593 //******************************************************************************
    594 ULONG StratClose(REQPACKET __far* rp)
    595 {
    596   // only called if device successfully opened
    597   //  printk("strat close\n");
    598   numOS2Opens--;
    599 
    600   UniaudCloseAll(rp->open_close.usSysFileNum);
    601 
    602   if (numOS2Opens == 0) {
    603           deviceOwner = DEV_NO_OWNER;
    604   }
    605   return(RPDONE);
    606 }
    607 
  • GPL/trunk/drv32/idc.c

    r591 r679  
    2929//DAZ }
    3030#include <devtype.h>
    31 #include <devhelp.h>
    32 //#include <strategy.h>
     31#include <stacktoflat.h>
    3332#include <ossidc32.h>
    3433#include <irqos2.h>
    35 #include <stacktoflat.h>
    3634#include <dbgos2.h>
    3735
     
    3937IDC16_HANDLER idc16_PddHandler = 0;
    4038extern int pcm_device;
    41 WORD32 OSS32IDC(ULONG cmd, PIDC32_PACKET pPacket);
     39OSSRET OSS32IDC(ULONG cmd, PIDC32_PACKET pPacket);
    4240
    4341//packet pointer must reference a structure on the stack
  • GPL/trunk/drv32/impdos.def

    r32 r679  
    1 ;*
    2 ;* Import definitions for DOSCALLS APIs
    3 ;*
    4 ;* (C) 2000-2002 InnoTek Systemberatung GmbH
    5 ;* (C) 2000-2001 Sander van Leeuwen (sandervl@xs4all.nl)
    6 ;*
    7 ;* This program is free software; you can redistribute it and/or
    8 ;* modify it under the terms of the GNU General Public License as
    9 ;* published by the Free Software Foundation; either version 2 of
    10 ;* the License, or (at your option) any later version.
    11 ;*
    12 ;* This program is distributed in the hope that it will be useful,
    13 ;* but WITHOUT ANY WARRANTY; without even the implied warranty of
    14 ;* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    15 ;* GNU General Public License for more details.
    16 ;*
    17 ;* You should have received a copy of the GNU General Public
    18 ;* License along with this program; if not, write to the Free
    19 ;* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
    20 ;* USA.
    21 ;*
    22 
    23 
    24 ;; ImpDos.def
    25 ;;
    26 ;; Export/import information for DOS* APIs callable at Init time.
    27 ;;
    28 ;; History:
    29 ;;
    30 ;; Sep 30, 94  David Bollo         Initial version
    31 ;; Jan 22, 97  Sander van Leeuwen  Added DOSFLATCS & DOSFLATDS
    32 
    331LIBRARY DOSCALLS
    342
    353EXPORTS
    36     DOSBEEP                   @50
    37     DOSCHGFILEPTR             @58
    384    DOSCLOSE                  @59
    395    DOSOPEN                   @70
    40     DOSDELETE                 @60
    41     DOSDEVCONFIG              @52
    42     DOSDEVIOCTL               @53
    43     DOSFINDCLOSE              @63
    44     DOSFINDFIRST              @64
    45     DOSFINDNEXT               @65
    46     DOSGETENV                 @91
    47     DOSGETHUGESHIFT           @41
    48     DOSGETMACHINEMODE         @49
    49     DOSGETVERSION             @92
    50     DOSQCURDIR                @71
    51     DOSQCURDISK               @72
    52     DOSQFILEINFO              @74
    53     DOSQFILEMODE              @75
    54     DOSREAD                   @137
    55     DOSWRITE                  @138
     6    _DOSWRITE                 @138
     7    DosExit                   @234
     8    DosWrite                  @282
     9    DosQueryCp                @291
     10    DosQuerySysInfo           @348
    5611    DOS32FLATDS               @370
    57     DOS32FLATCS               @369
     12    DosQueryDBCSEnv           @396
    5813    DOSIODELAYCNT             @427
  • GPL/trunk/drv32/init.c

    r587 r679  
    2929
    3030// Device support
    31 #include <devhelp.h>
    3231#include <devtype.h>
    33 //DAZ #include <devrp.h>
    34 #include <strategy.h>
    35 #include "devown.h"
     32#include <stacktoflat.h>
    3633#include <version.h>
    3734#include <ossidc32.h>
    3835#include <dbgos2.h>
    39 #include <irqos2.h>
    40 //#include <bsedos16.h>
    41 #ifdef KEE
     36#include <osspci.h>
    4237#include <kee.h>
    43 #endif
     38#include <malloc.h>
    4439#include "parse.h"
    45 #include "malloc.h"
     40#include "sound/version.h"
     41#include "strategy.h"
    4642
    4743const char ERR_ERROR[]   = "ERROR: ";
     
    5046const char ERR_NAMES[]    = "Query names failed\r\r\n";
    5147#ifdef DEBUG
    52 const char szALSA[]      = "\r\n"PRODUCT_NAME" v"UNIAUD_VERSION"-DEBUG\r\nBased on ALSA "ALSA_VERSION"\r\n";
     48const char szALSA[]      = "\r\n"PRODUCT_NAME" v"UNIAUD_VERSION"-DEBUG\r\nBased on Linux "ALSA_VERSION"\r\n";
    5349#else
    54 const char szALSA[]      = "\r\n"PRODUCT_NAME" v"UNIAUD_VERSION"\r\nBased on ALSA "ALSA_VERSION"\r\n";
     50const char szALSA[]      = "\r\n"PRODUCT_NAME" v"UNIAUD_VERSION"\r\nBased on Linux "ALSA_VERSION"\r\n";
    5551#endif
    5652
    5753//const char szCopyRight1[]= "Copyright 2000-2002 InnoTek Systemberatung GmbH\r\n";
    58 const char szCopyRight2[]= "Copyright 2000-2010 The ALSA Project\r\n\r\n";
    59 const char szCopyRight3[]= "Copyright 2005-2010 Netlabs http://www.netlabs.org\r\n";
     54const char szCopyRight2[]= "Copyright 2000-2021 The ALSA Project\r\n\r\n";
     55const char szCopyRight3[]= "Copyright 2005-2021 Netlabs http://www.netlabs.org\r\n";
    6056
    6157const char szCodeStartEnd[] = "Code 0x%0x - 0x%0x\r\n\r\n";
     
    10197int LockSegments(void)
    10298{
    103 #ifdef KEE
    10499    KEEVMLock lock;
    105 #else
    106     char   lock[12];
    107     ULONG  PgCount;
    108 #endif
    109100    ULONG  segsize;
    110101
     
    120111    }
    121112    segsize &= ~0xFFF;
    122 #ifdef KEE
    123     if(KernVMLock(VMDHL_LONG,
     113
     114    if(KernVMLock(KEE_VML_LONGLOCK,
    124115                  (PVOID)((OffsetBeginDS32) & ~0xFFF),
    125116                  segsize,
     
    127118                  (KEEVMPageList*)-1,
    128119                  0)) {
    129 #else
    130     if(DevVMLock(VMDHL_LONG,
    131                    ((OffsetBeginDS32) & ~0xFFF),
    132                    segsize,
    133                    (LINEAR)-1,
    134                    (LINEAR)lock,
    135                    (LINEAR)&PgCount)) {
    136 #endif
    137120      return(1);
    138121    }
     
    145128    }
    146129    segsize &= ~0xFFF;
    147 #ifdef KEE
    148     if(KernVMLock(VMDHL_LONG,
     130
     131    if(KernVMLock(KEE_VML_LONGLOCK,
    149132                  (PVOID)((OffsetBeginCS32) & ~0xFFF),
    150133                  segsize,
     
    152135                  (KEEVMPageList*)-1,
    153136                  0)) {
    154 #else
    155     if(DevVMLock(VMDHL_LONG,
    156                  ((OffsetBeginCS32) & ~0xFFF),
    157                  segsize,
    158                  (LINEAR)-1,
    159                  (LINEAR)lock,
    160                  (LINEAR)&PgCount)) {
    161 #endif
    162137      return(1);
    163138    }
     
    201176  char FAR48 *args;
    202177
    203 #ifdef KEE
    204   GetTKSSBase();
    205 #endif
     178  DebugLevel = 1;
     179  rp->init_out.usCodeEnd = 0;
     180  rp->init_out.usDataEnd = 0;
    206181
    207182  if(LockSegments())
     
    212187  }
    213188
    214   DebugLevel = 1;
    215   rp->init_out.usCodeEnd = 0;
    216   rp->init_out.usDataEnd = 0;
     189  RMCreateDriverU32(); // register driver in  Resource Manager
    217190
    218191  if ( szprintBuf == 0 )
     
    238211  rprintf(("Uniaud32 version %s",UNIAUD_VERSION));
    239212  #endif
     213  rprintf(("Based on linux %s",CONFIG_SND_VERSION));
    240214
    241215  if(fVerbose)
     
    251225    WriteString(debugmsg, strlen(debugmsg));
    252226  }
    253 
    254   //get the current time (to force retrieval of GIS pointer)
    255   os2gettimemsec();
    256227
    257228  char szMixerName[64];
     
    323294  return RPDONE;
    324295}
    325 
  • GPL/trunk/drv32/irq.c

    r604 r679  
    2626#include <os2.h>
    2727
    28 #include <devtype.h>
    29 #include <devinfo.h>
    3028#include <devhelp.h>
    3129#include <include.h>            // Defn's for WatCom based drivers.
  • GPL/trunk/drv32/parse.c

    r607 r679  
    3232#endif
    3333
    34 #include <devhelp.h>
    3534#include <devtype.h>
    36 #include <unicard.h>
     35#include <string.h>
    3736#include "parse.h"         // NUM_DEVICES
    38 #include <string.h>
    3937
    4038#define COMM_DEBUG
  • GPL/trunk/drv32/read.c

    r587 r679  
    11#define INCL_NOPMAPI
    22#include <os2.h>
    3 #include <devhelp.h>
    4 #include <strategy.h>
    53#include <dbgos2.h>
    64#include <string.h> // memcpy
     5#include "strategy.h"
    76
    87int   rdOffset= 0;
  • GPL/trunk/drv32/rmhelp.c

    r587 r679  
    1313#include <os2.h>
    1414
    15 #include <devhelp.h>
    16 #include <devinfo.h>
    17 
    18 #include <rmbase.h>             // Resource manager definitions.
    19 #include "rmcalls.h"
    20 #include <rmioctl.h>
    21 
     15#include <devtype.h>
     16#include <stacktoflat.h>
    2217#include <version.h>
    2318#include <dbgos2.h>
    24 #include <unicard.h>
    2519#include <osspci.h>
    2620#include <ossidc32.h>
     21#include <string.h>
     22#include "rmbase.h"             // Resource manager definitions.
     23#include "rmcalls.h"
    2724#include "pciids.h"
    2825
    29 #include <string.h>
    30 
    3126#define MAX_RESHANDLES  16
    3227
    33 //******************************************************************************
    34 
    35 //extern PFN                    RM_Help;
    36 //extern PFN                    RM_Help0;
    37 //extern PFN                    RM_Help3;
    38 //extern ULONG                  RMFlags;
    39 
    40 static HDRIVER DriverHandle = (HDRIVER)-1;
    41 static HDEVICE DeviceHandle = 0;
     28static HDRIVER  DriverHandle  = (HDRIVER)-1;
    4229static HADAPTER AdapterHandle = 0;
    43 static ULONG ctResHandles = 0;
    44 static HRESOURCE arResHandles[MAX_RESHANDLES];
    45 
    46 //******************************************************************************
    47 VOID RMInit(VOID)
    48 {
    49   APIRET        rc;
    50   HDRIVER       hDriver;
    51   DRIVERSTRUCT  DriverStruct;
    52   char          DriverName[sizeof(RM_DRIVER_NAME)];
    53   char          VendorName[sizeof(RM_DRIVER_VENDORNAME)];
    54   char          DriverDesc[sizeof(RM_DRIVER_DESCRIPTION)];
    55 
    56   if( DriverHandle == (HDRIVER)-1 )
    57   {
    58      memset( (PVOID) &DriverStruct, 0, sizeof(DriverStruct) );
    59 
    60      //copy strings to stack, because we need to give RM 16:16 pointers
    61      //(which can only be (easily) generated from 32 bits stack addresses)
    62      strcpy(DriverName, RM_DRIVER_NAME);
    63      strcpy(VendorName, RM_DRIVER_VENDORNAME);
    64      strcpy(DriverDesc, RM_DRIVER_DESCRIPTION);
    65 
    66      DriverStruct.DrvrName     = FlatToSel((ULONG)DriverName);        /* ### IHV */
    67      DriverStruct.DrvrDescript = FlatToSel((ULONG)DriverDesc);        /* ### IHV */
    68      DriverStruct.VendorName   = FlatToSel((ULONG)VendorName);        /* ### IHV */
    69      DriverStruct.MajorVer     = CMVERSION_MAJOR;          //rmbase.h /* ### IHV */
    70      DriverStruct.MinorVer     = CMVERSION_MINOR;          //rmbase.h /* ### IHV */
    71      DriverStruct.Date.Year    = RM_DRIVER_BUILDYEAR;                    /* ### IHV */
    72      DriverStruct.Date.Month   = RM_DRIVER_BUILDMONTH;                   /* ### IHV */
    73      DriverStruct.Date.Day     = RM_DRIVER_BUILDDAY;                     /* ### IHV */
    74      DriverStruct.DrvrType     = DRT_AUDIO;
    75      DriverStruct.DrvrSubType  = 0;
    76      DriverStruct.DrvrCallback = 0;
    77 
    78      rc = RMCreateDriver( FlatToSel((ULONG)&DriverStruct), FlatToSel((ULONG)&hDriver) );
    79 
    80      if( rc == RMRC_SUCCESS )   DriverHandle = hDriver;
    81      dprintf(("RMCreateDriver rc=%d DriverHandle=%x", rc, DriverHandle));
    82   }
    83 
    84   while( ctResHandles )
    85     RMDeallocResource(DriverHandle, arResHandles[--ctResHandles]);
    86 }
    87 
     30
     31typedef struct
     32{
     33    ULONG     NumResource;
     34    HRESOURCE hResource[MAX_RESHANDLES];
     35} RESOURCES;
     36
     37static RESOURCES Resource_stt = {0};
     38
     39//******************************************************************************
     40//******************************************************************************
     41VOID RMCreateDriverU32(VOID)
     42{
     43    HDRIVER      hDriver;
     44    DRIVERSTRUCT DriverStruct;
     45    char         DriverName[sizeof(RM_DRIVER_NAME)];
     46    char         VendorName[sizeof(RM_DRIVER_VENDORNAME)];
     47    char         DriverDesc[sizeof(RM_DRIVER_DESCRIPTION)];
     48
     49    //copy strings to stack, because we need to give RM 16:16 pointers
     50    //(which can only be (easily) generated from 32 bits stack addresses)
     51    strcpy(DriverName, RM_DRIVER_NAME);
     52    strcpy(VendorName, RM_DRIVER_VENDORNAME);
     53    strcpy(DriverDesc, RM_DRIVER_DESCRIPTION);
     54
     55    DriverStruct.DrvrName     = FlatToSel((ULONG)DriverName);
     56    DriverStruct.DrvrDescript = FlatToSel((ULONG)DriverDesc);
     57    DriverStruct.VendorName   = FlatToSel((ULONG)VendorName);
     58    DriverStruct.MajorVer     = RM_VMAJOR;
     59    DriverStruct.MinorVer     = RM_VMINOR;
     60    DriverStruct.Date.Year    = RM_DRIVER_BUILDYEAR;
     61    DriverStruct.Date.Month   = RM_DRIVER_BUILDMONTH;
     62    DriverStruct.Date.Day     = RM_DRIVER_BUILDDAY;
     63    DriverStruct.DrvrFlags    = 0;
     64    DriverStruct.DrvrType     = DRT_AUDIO;
     65    DriverStruct.DrvrSubType  = 0;
     66    DriverStruct.DrvrCallback = 0;
     67
     68    APIRET rc = RMCreateDriver( FlatToSel((ULONG)&DriverStruct),
     69                                FlatToSel((ULONG)&hDriver) );
     70
     71    if( rc == RMRC_SUCCESS )
     72    {
     73        DriverHandle = hDriver;
     74    }
     75    dprintf(("RMCreateDriver rc=%d DriverHandle=%x", rc, DriverHandle));
     76}
     77
     78//******************************************************************************
     79//******************************************************************************
     80VOID RMCreateAdapterU32(ULONG DevID, ULONG *phAdapter, USHORT BusDevFunc, ULONG CardNum)
     81{
     82    APIRET rc;
     83    char   szAdapterName[128];
     84    char   szMixerName[64];
     85
     86    szAdapterName[0] = szMixerName[0] = '\0';
     87
     88    if(OSS32_QueryNames(CardNum, szAdapterName, sizeof(szAdapterName),
     89                        szMixerName, sizeof(szMixerName), FALSE) != OSSERR_SUCCESS )
     90    {
     91        return; // error
     92    }
     93
     94    switch(DevID)
     95    {
     96        case PCIID_VIA_686A:
     97        case PCIID_VIA_8233:
     98        case PCIID_SI_7012:
     99        case PCIID_INTEL_82801:
     100        case PCIID_INTEL_82901:
     101        case PCIID_INTEL_92801BA:
     102        case PCIID_INTEL_440MX:
     103        case PCIID_INTEL_ICH3:
     104        case PCIID_INTEL_ICH4:
     105        case PCIID_INTEL_ICH5:
     106        case PCIID_INTEL_ICH6:
     107        case PCIID_INTEL_ICH7:
     108        case PCIID_NVIDIA_MCP_AUDIO:
     109        case PCIID_NVIDIA_MCP2_AUDIO:
     110        case PCIID_NVIDIA_MCP3_AUDIO:
     111        case PCIID_NVIDIA_CK8S_AUDIO:
     112        case PCIID_NVIDIA_CK8_AUDIO:
     113            strcat(szAdapterName, " with ");
     114            strcat(szAdapterName, szMixerName);
     115            break;
     116/*
     117        case PCIID_CREATIVELABS_SBLIVE:
     118        case PCIID_ALS4000:
     119        case PCIID_CMEDIA_CM8338A:
     120        case PCIID_CMEDIA_CM8338B:
     121        case PCIID_CMEDIA_CM8738:
     122        case PCIID_CMEDIA_CM8738B:
     123        case PCIID_CIRRUS_4281:
     124        case PCIID_CIRRUS_4280:
     125        case PCIID_CIRRUS_4612:
     126        case PCIID_CIRRUS_4615:
     127        case PCIID_ESS_ALLEGRO_1:
     128        case PCIID_ESS_ALLEGRO:
     129        case PCIID_ESS_MAESTRO3:
     130        case PCIID_ESS_MAESTRO3_1:
     131        case PCIID_ESS_MAESTRO3_HW:
     132        case PCIID_ESS_MAESTRO3_2:
     133        case PCIID_ESS_CANYON3D_2LE:
     134        case PCIID_ESS_CANYON3D_2:
     135        case PCIID_ESS_ES1938:
     136        case PCIID_AUREAL_VORTEX:
     137        case PCIID_AUREAL_VORTEX2:
     138        case PCIID_AUREAL_ADVANTAGE:
     139        case PCIID_ENSONIQ_CT5880:
     140        case PCIID_ENSONIQ_ES1371:
     141        case PCIID_YAMAHA_YMF724:
     142        case PCIID_YAMAHA_YMF724F:
     143        case PCIID_YAMAHA_YMF740:
     144        case PCIID_YAMAHA_YMF740C:
     145        case PCIID_YAMAHA_YMF744:
     146        case PCIID_YAMAHA_YMF754:
     147        case PCIID_ESS_M2E:
     148        case PCIID_ESS_M2:
     149        case PCIID_ESS_M1:
     150        case PCIID_ALI_5451:
     151        case PCIID_TRIDENT_4DWAVE_DX:
     152        case PCIID_TRIDENT_4DWAVE_NX:
     153        case PCIID_SI_7018:
     154        case PCIID_FM801:
     155        case PCIID_ATIIXP_SB200:
     156        case PCIID_ATIIXP_SB300:
     157        case PCIID_ATIIXP_SB400:
     158        case PCIID_AUDIGYLS:
     159        case PCIID_AUDIGYLS1:
     160        case PCIID_AUDIGYLS2:
     161            break;
     162*/
     163    }
     164
     165    if( !szAdapterName[0] )
     166    {
     167        strcpy(szAdapterName, "Unknown");
     168    }
     169
     170    //copy to stack, because we need to give RM 16:16 pointers
     171    //(which can only be (easily) generated from 32 bits stack addresses)
     172    RESOURCES Resource_loc;
     173    // is any resoures detected and registered in RM ?
     174    if( Resource_stt.NumResource )
     175    {
     176        memcpy( &Resource_loc, &Resource_stt, sizeof(Resource_loc) );
     177    }
     178    else
     179    {
     180        dprintf(("No resources allocated !!!"));
     181        Resource_loc.NumResource = 0;
     182    }
     183
     184    ADJUNCT adjBusDevFunc;
     185    adjBusDevFunc.pNextAdj    = NULL;
     186    adjBusDevFunc.AdjLength   = sizeof(adjBusDevFunc);
     187    adjBusDevFunc.AdjType     = ADJ_PCI_DEVFUNC;
     188    adjBusDevFunc.PCI_DevFunc = BusDevFunc;
     189
     190    ADAPTERSTRUCT AdapterStruct;
     191    AdapterStruct.AdaptDescriptName = FlatToSel((ULONG)szAdapterName);                      /* ### IHV */
     192    AdapterStruct.AdaptFlags        = AS_16MB_ADDRESS_LIMIT;           // AdaptFlags         /* ### IHV */
     193    AdapterStruct.BaseType          = AS_BASE_MMEDIA;                  // BaseType
     194    AdapterStruct.SubType           = AS_SUB_MM_AUDIO;                 // SubType
     195    AdapterStruct.InterfaceType     = AS_INTF_GENERIC;                 // InterfaceType
     196    AdapterStruct.HostBusType       = AS_HOSTBUS_PCI;                  // HostBusType        /* ### IHV */
     197    AdapterStruct.HostBusWidth      = AS_BUSWIDTH_32BIT;               // HostBusWidth       /* ### IHV */
     198    AdapterStruct.pAdjunctList      = FlatToSel((ULONG)&adjBusDevFunc);// pAdjunctList       /* ### IHV */
     199    AdapterStruct.Reserved          = 0;
     200
     201    //--- Register adapter.  We'll record any error code, but won't fail
     202    // the driver initialization and won't return resources.
     203    //NOTE: hAdapter must be used as FlatToSel only works for stack variables
     204    HADAPTER hAdapter;
     205    rc = RMCreateAdapter(DriverHandle,                     // Handle to driver
     206                         FlatToSel((ULONG)&hAdapter),      // (OUT) Handle to adapter
     207                         FlatToSel((ULONG)&AdapterStruct), // Adapter structure
     208                         0,                                // Parent device (defaults OK)
     209                         Resource_loc.NumResource ? (FlatToSel((ULONG)&Resource_loc)) : 0); // Allocated resources.
     210
     211    dprintf(("RMCreateAdapter rc=%d", rc));
     212
     213    if( rc == 0 )
     214    {
     215        AdapterHandle = hAdapter;
     216        *phAdapter    = hAdapter;
     217        Resource_stt.NumResource = 0;  // no resource handles to be freed
     218    }
     219    else
     220    {
     221        RMDeallocRes();
     222    }
     223}
    88224
    89225//******************************************************************************
     
    105241                       FlatToSel((ULONG)&Resource));    // Resource to allocate.
    106242
    107   if( rc == 0 && ctResHandles < MAX_RESHANDLES )
     243  if( rc == 0 && Resource_stt.NumResource < MAX_RESHANDLES )
    108244  {
    109     arResHandles[ctResHandles++] = hres;        return TRUE;
     245    Resource_stt.hResource[Resource_stt.NumResource++] = hres;  return TRUE;
    110246  }
    111247
    112   dprintf(("RMAllocResource[%d] IO rc = %d", ctResHandles, rc));
     248  dprintf(("RMAllocResource[%d] IO rc = %d", Resource_stt.NumResource, rc));
    113249
    114250  return FALSE;
     
    133269                       FlatToSel((ULONG)&Resource));    // Resource to allocate.
    134270
    135   if( rc == 0 && ctResHandles < MAX_RESHANDLES )
     271  if( rc == 0 && Resource_stt.NumResource < MAX_RESHANDLES )
    136272  {
    137     arResHandles[ctResHandles++] = hres;        return TRUE;
     273    Resource_stt.hResource[Resource_stt.NumResource++] = hres;  return TRUE;
    138274  }
    139275
    140   dprintf(("RMAllocResource[%d] MEM rc = %d", ctResHandles, rc));
     276  dprintf(("RMAllocResource[%d] MEM rc = %d", Resource_stt.NumResource, rc));
    141277
    142278  return rc == 0;
     
    148284BOOL RMRequestIRQ(ULONG ulIrq, BOOL fShared, PHRESOURCE phRes)
    149285{
    150         RESOURCESTRUCT  Resource;
    151         HRESOURCE               hRes;
    152         APIRET          rc;
    153 
    154         Resource.ResourceType          = RS_TYPE_IRQ;
    155         Resource.IRQResource.IRQLevel  = (USHORT)ulIrq & 0xff;
    156         Resource.IRQResource.PCIIrqPin = 0;
    157         Resource.IRQResource.IRQFlags  = ( fShared ) ? RS_IRQ_SHARED : RS_IRQ_EXCLUSIVE;
    158 
    159         rc = RMAllocResource(DriverHandle,                      // Handle to driver.
    160                        FlatToSel((ULONG)&hRes),                 // OUT:  "allocated" resource node handle
    161                        FlatToSel((ULONG)&Resource));    // Resource to allocate.
    162 
    163 
    164         if (rc == 0) {
    165                 *phRes = hRes;
    166                 if (DeviceHandle) {
    167                         dprintf(("RMRequestIRQ: DriverHandle=%x DeviceHandle=%x hRes=%x", DriverHandle, DeviceHandle, hRes));
    168                         rc = RMModifyResources(DriverHandle, DeviceHandle, RM_MODIFY_ADD, hRes);
    169                 } else {
    170                         if (ctResHandles < MAX_RESHANDLES ) arResHandles[ctResHandles++] = hRes;
    171                 }
     286    RESOURCESTRUCT Resource;
     287    HRESOURCE      hRes;
     288    APIRET         rc;
     289
     290    memset( &Resource, 0, sizeof(Resource) );
     291    Resource.ResourceType          = RS_TYPE_IRQ;
     292    Resource.IRQResource.IRQLevel  = (USHORT)ulIrq & 0xff;
     293    Resource.IRQResource.PCIIrqPin = 0;
     294    Resource.IRQResource.IRQFlags  = ( fShared ) ? RS_IRQ_SHARED : RS_IRQ_EXCLUSIVE;
     295
     296    rc = RMAllocResource(DriverHandle,                 // Handle to driver.
     297                         FlatToSel((ULONG)&hRes),      // OUT:  "allocated" resource node handle
     298                         FlatToSel((ULONG)&Resource)); // Resource to allocate.
     299
     300    if (rc == 0)
     301    {
     302        *phRes = hRes;
     303        if (AdapterHandle)
     304        {
     305            dprintf(("RMRequestIRQ: DriverHandle=%x AdapterHandle=%x hRes=%x", DriverHandle, AdapterHandle, hRes));
     306            rc = RMModifyResources(DriverHandle, AdapterHandle, RM_MODIFY_ADD, hRes);
     307        }
     308        else
     309        {
     310            if (Resource_stt.NumResource < MAX_RESHANDLES )
     311            {
     312                Resource_stt.hResource[Resource_stt.NumResource++] = hRes;
     313            }
    172314        }
    173 
    174         dprintf(("RMAllocResource[%d] IRQ=%d rc=%d", ctResHandles, ulIrq, rc));
     315    }
     316    dprintf(("RMAllocResource[%d] IRQ=%d rc=%d", Resource_stt.NumResource, ulIrq, rc));
     317    return rc == 0;
     318}
     319
     320//******************************************************************************
     321//******************************************************************************
     322BOOL RMDeallocateIRQ(HRESOURCE hRes)
     323{
     324        APIRET rc;
     325
     326        dprintf(("RMDeallocateIRQ: DriverHandle=%x AdapterHandle=%x hRes=%x", DriverHandle, AdapterHandle, hRes));
     327        rc = RMModifyResources(DriverHandle, AdapterHandle, RM_MODIFY_DELETE, hRes);
    175328
    176329        return rc == 0;
     
    179332//******************************************************************************
    180333//******************************************************************************
    181 BOOL RMDeallocateIRQ(HRESOURCE hRes)
    182 {
    183         APIRET rc;
    184 
    185         dprintf(("RMDeallocateIRQ: DriverHandle=%x DeviceHandle=%x hRes=%x", DriverHandle, DeviceHandle, hRes));
    186         rc = RMModifyResources(DriverHandle, DeviceHandle, RM_MODIFY_DELETE, hRes);
    187 
    188         return rc == 0;
    189 }
    190 
    191 
    192 //******************************************************************************
    193 //******************************************************************************
    194 VOID RMDone(ULONG DevID, PHADAPTER phAdapter, PHDEVICE phDevice)
    195 {
    196   APIRET        rc;
    197   HDEVICE       hDevice;
    198   HADAPTER      hAdapter;
    199   ADAPTERSTRUCT AdapterStruct;
    200   DEVICESTRUCT  DeviceStruct;
    201   char          AdapterName[sizeof(RM_ADAPTER_NAME)];
    202   char          szDeviceName[128];
    203   char          szMixerName[64];
    204   struct {
    205     ULONG       NumResource;
    206     HRESOURCE   hResource[MAX_RESHANDLES];
    207   } ahResource;
    208 
    209   szDeviceName[0] = szMixerName[0] = '\0';
    210 
    211   if( DevID && OSS32_QueryNames(OSS32_DEFAULT_DEVICE,
    212                 szDeviceName, sizeof(szDeviceName),
    213                 szMixerName, sizeof(szMixerName), FALSE) == OSSERR_SUCCESS )
    214   {
    215     switch(DevID) {
    216     case PCIID_VIA_686A:
    217     case PCIID_VIA_8233:
    218     case PCIID_SI_7012:
    219     case PCIID_INTEL_82801:
    220     case PCIID_INTEL_82901:
    221     case PCIID_INTEL_92801BA:
    222     case PCIID_INTEL_440MX:
    223     case PCIID_INTEL_ICH3:
    224     case PCIID_INTEL_ICH4:
    225     case PCIID_INTEL_ICH5:
    226     case PCIID_INTEL_ICH6:
    227     case PCIID_INTEL_ICH7:
    228     case PCIID_NVIDIA_MCP_AUDIO:
    229     case PCIID_NVIDIA_MCP2_AUDIO:
    230     case PCIID_NVIDIA_MCP3_AUDIO:
    231     case PCIID_NVIDIA_CK8S_AUDIO:
    232     case PCIID_NVIDIA_CK8_AUDIO:
    233         strcat(szDeviceName, " with ");
    234         strcat(szDeviceName, szMixerName);
    235         break;
    236 /*
    237     case PCIID_CREATIVELABS_SBLIVE:
    238     case PCIID_ALS4000:
    239     case PCIID_CMEDIA_CM8338A:
    240     case PCIID_CMEDIA_CM8338B:
    241     case PCIID_CMEDIA_CM8738:
    242     case PCIID_CMEDIA_CM8738B:
    243     case PCIID_CIRRUS_4281:
    244     case PCIID_CIRRUS_4280:
    245     case PCIID_CIRRUS_4612:
    246     case PCIID_CIRRUS_4615:
    247     case PCIID_ESS_ALLEGRO_1:
    248     case PCIID_ESS_ALLEGRO:
    249     case PCIID_ESS_MAESTRO3:
    250     case PCIID_ESS_MAESTRO3_1:
    251     case PCIID_ESS_MAESTRO3_HW:
    252     case PCIID_ESS_MAESTRO3_2:
    253     case PCIID_ESS_CANYON3D_2LE:
    254     case PCIID_ESS_CANYON3D_2:
    255     case PCIID_ESS_ES1938:
    256     case PCIID_AUREAL_VORTEX:
    257     case PCIID_AUREAL_VORTEX2:
    258     case PCIID_AUREAL_ADVANTAGE:
    259     case PCIID_ENSONIQ_CT5880:
    260     case PCIID_ENSONIQ_ES1371:
    261     case PCIID_YAMAHA_YMF724:
    262     case PCIID_YAMAHA_YMF724F:
    263     case PCIID_YAMAHA_YMF740:
    264     case PCIID_YAMAHA_YMF740C:
    265     case PCIID_YAMAHA_YMF744:
    266     case PCIID_YAMAHA_YMF754:
    267     case PCIID_ESS_M2E:
    268     case PCIID_ESS_M2:
    269     case PCIID_ESS_M1:
    270     case PCIID_ALI_5451:
    271     case PCIID_TRIDENT_4DWAVE_DX:
    272     case PCIID_TRIDENT_4DWAVE_NX:
    273     case PCIID_SI_7018:
    274     case PCIID_FM801:
    275     case PCIID_ATIIXP_SB200:
    276     case PCIID_ATIIXP_SB300:
    277     case PCIID_ATIIXP_SB400:
    278     case PCIID_AUDIGYLS:
    279     case PCIID_AUDIGYLS1:
    280     case PCIID_AUDIGYLS2:
    281         break;
    282 */
    283     } /* switch */
    284 
    285 
    286     if( ctResHandles )
    287     {
    288       ahResource.NumResource = ctResHandles;
    289       memcpy(ahResource.hResource,
    290              arResHandles, ctResHandles * sizeof(arResHandles[0]));
    291 
    292       //copy string to stack, because we need to give RM 16:16 pointers
    293       //(which can only be (easily) generated from 32 bits stack addresses)
    294       strcpy(AdapterName, RM_ADAPTER_NAME);
    295 
    296       memset( (PVOID) &AdapterStruct, 0, sizeof(AdapterStruct) );
    297       AdapterStruct.AdaptDescriptName = FlatToSel((ULONG)AdapterName);        /* ### IHV */
    298       AdapterStruct.AdaptFlags        = AS_16MB_ADDRESS_LIMIT;    // AdaptFlags         /* ### IHV */
    299       AdapterStruct.BaseType          = AS_BASE_MMEDIA;           // BaseType
    300       AdapterStruct.SubType           = AS_SUB_MM_AUDIO;          // SubType
    301       AdapterStruct.InterfaceType     = AS_INTF_GENERIC;          // InterfaceType
    302       AdapterStruct.HostBusType       = AS_HOSTBUS_PCI;           // HostBusType        /* ### IHV */
    303       AdapterStruct.HostBusWidth      = AS_BUSWIDTH_32BIT;        // HostBusWidth       /* ### IHV */
    304       AdapterStruct.pAdjunctList      = 0;                        // pAdjunctList       /* ### IHV */
    305 
    306       //--- Register adapter.  We'll record any error code, but won't fail
    307       // the driver initialization and won't return resources.
    308       //NOTE: hAdapter must be used as FlatToSel only works for stack variables
    309       rc = RMCreateAdapter(DriverHandle,                        // Handle to driver
    310                            FlatToSel((ULONG)&hAdapter),         // (OUT) Handle to adapter
    311                            FlatToSel((ULONG)&AdapterStruct),    // Adapter structure
    312                            0,                           // Parent device (defaults OK)
    313                            0);                          // Allocated resources.
    314 
    315       dprintf(("RMCreateAdapter rc=%d", rc));
    316 
    317       if( rc == 0 )
    318       {
    319                 AdapterHandle = hAdapter;
    320                 if (phAdapter) *phAdapter = hAdapter;
    321                 if( !szDeviceName[0] )  strcpy(szDeviceName, "Unknown");
    322 
    323                 //NOTE: Assumes szDeviceName is a stack pointer!!
    324                 memset( (PVOID) &DeviceStruct, 0, sizeof(DeviceStruct) );
    325                 DeviceStruct.DevDescriptName = FlatToSel((ULONG)szDeviceName);
    326                 DeviceStruct.DevFlags        = DS_FIXED_LOGICALNAME;
    327                 DeviceStruct.DevType         = DS_TYPE_AUDIO;
    328                 DeviceStruct.pAdjunctList    = 0;
    329 
    330                 rc = RMCreateDevice(DriverHandle,                       // Handle to driver
    331                             FlatToSel((ULONG)&hDevice),         // (OUT) Handle to device, unused.
    332                             FlatToSel((ULONG)&DeviceStruct),    // Device structure
    333                             hAdapter,                           // Parent adapter
    334                             FlatToSel((ULONG)&ahResource));     // Allocated resources
    335 
    336                 dprintf(("RMCreateDevice rc=%d", rc));
    337 
    338                 if( rc == 0 )
    339                 {
    340                   DeviceHandle = hDevice;
    341                   if (phDevice) *phDevice = hDevice;
    342                   ctResHandles = 0;  // no resource handles to be freed
    343                         dprintf(("RMDone: DriverHandle=%x DeviceHandle=%x", DriverHandle, DeviceHandle));
    344                   return;
    345                 }
    346 
    347                 // !!! Not implemented in startup.asm
    348                 //      RMDestroyAdapter(DriverHandle, hAdapter);
    349       } /* if rc == 0 */
    350     } /* ctResHandles */
    351     else        dprintf(("No resources allocated !!!"));
    352   } /* if DevID */
    353 
    354 
    355   // free resource handles
    356   while( ctResHandles )
    357     RMDeallocResource(DriverHandle, arResHandles[--ctResHandles]);
    358 }
    359 
     334VOID RMDeallocRes(VOID)
     335{
     336    // free resource handles
     337    while( Resource_stt.NumResource )
     338    {
     339        RMDeallocResource(DriverHandle, Resource_stt.hResource[--Resource_stt.NumResource]);
     340    }
     341}
    360342
    361343/* DAZ - dirty hack so that resource manager is updated correctly
    362344 * when using APIC and multiple adapters */
    363 VOID RMSetHandles(HADAPTER hAdapter, HDEVICE hDevice)
     345VOID RMSetHandles(HADAPTER hAdapter)
    364346{
    365347        AdapterHandle = hAdapter;
    366         DeviceHandle = hDevice;
    367 }
    368 
     348}
  • GPL/trunk/drv32/segments.inc

    r32 r679  
    3838_TEXT ends
    3939
     40BEGTEXT segment dword public use32 'CODE'
     41BEGTEXT ends
     42
    4043LASTCODE32 segment dword public use32 'CODE'
    4144LASTCODE32 ends
     
    6871CONST2  ENDS
    6972
    70 IFDEF KEE
    7173LASTDATA32 SEGMENT DWORD PUBLIC USE32 'DATA'
    7274LASTDATA32 ENDS
    73 ELSE
    74 LASTDATA32 SEGMENT DWORD PUBLIC USE32 'BSS'
    75 LASTDATA32 ENDS
    76 ENDIF
    7775
    7876;order is important!
    79 IFDEF KEE
    8077DGROUP  group BSS32, DATA32, _DATA, CONST32, C_COMMON, c_common, CONST2, CONST, _BSS, LASTDATA32
    81 ELSE
    82 DGROUP  group DATA32, CONST32, C_COMMON, c_common, CONST2, CONST, _BSS, BSS32, _DATA, LASTDATA32
    83 ENDIF
    8478
    85 CGROUP  group FIRSTCODE32, CODE32, _TEXT, LASTCODE32
     79CGROUP  group FIRSTCODE32, CODE32, _TEXT, BEGTEXT, LASTCODE32
  • GPL/trunk/drv32/startup.asm

    r577 r679  
    3737DATA16 segment
    3838                extrn DOS32FLATDS : abs                ; ring 0 FLAT kernel data selector
    39                 public __OffFinalDS16
    40                 public help_header
    41                 public uniaud_header
    42                 public _MSG_TABLE16
    43                 public DevHelpInit
    44                 public fOpen   
    45                 public InitPktSeg
    46                 public InitPktOff
    47                 public _MESSAGE_STR
    48                 public pddname16
    49                 public FileName
    50                 public _RM_Help0
    51                 public _RM_Help1
    52                 public _RM_Help3
    53                 public _RMFlags
    54 IFDEF DEBUG
    55                 public DbgU32TimerCnt
    56                 public DbgU32IntCnt
    57 ENDIF
    58 
    5939;*********************************************************************************************
    6040;************************* Device Driver Header **********************************************
    6141;*********************************************************************************************
     42                public help_header
    6243help_header     dw OFFSET DATA16:uniaud_header         ; Pointer to next driver
    6344                dw SEG DATA16:uniaud_header
     
    9273                dw 0000000000000000b
    9374
    94 uniaud_header    dd -1
     75                public uniaud_header
     76uniaud_header   dd -1
    9577                dw 1101100110000000b            ; Device attributes
    9678;                  ||||| +-+   ||||
     
    123105                dw 0000000000000000b
    124106
     107
     108                public DevHelpInit
    125109DevHelpInit     dd 0
     110
     111                public fOpen   
    126112fOpen           dd 0
     113
     114                public InitPktSeg
     115                public InitPktOff
    127116InitPktSeg      dw 0
    128117InitPktOff      dw 0
     118
    129119IFDEF DEBUG
    130 DbgU32TimerCnt dd 0
    131 DbgU32IntCnt dd 0
     120                public DbgU32TimerCnt
     121                public DbgU32IntCnt
     122DbgU32TimerCnt  dd 0
     123DbgU32IntCnt    dd 0
    132124ENDIF
     125
    133126;needed for rmcalls.lib
     127                public _RM_Help0
     128                public _RM_Help1
     129                public _RM_Help3
     130                public _RMFlags
    134131_RM_Help0       dd 0
    135132_RM_Help1       dd 0
    136133_RM_Help3       dd 0
    137134_RMFlags        dd 0
     135
     136                public _MESSAGE_STR
     137                public _MSG_TABLE16
    138138_MESSAGE_STR    db 1024 dup (0)
    139139_MSG_TABLE16    dw 0    ;message length
     
    141141                dw SEG    _MESSAGE_STR
    142142
    143 pddname16       db 'ALSA32$'
    144 FileName        db "ALSAHLP$", 0
    145 ResMgr          DB  52H,45H,53H,4dH,47H,52H,24H,20H
    146                 DB  00H
     143FileName        db 'ALSAHLP$', 0
     144ResMgr          db 'RESMGR$ ',0
     145
    147146_RMIDCTable     DB  00H,00H,00H,00H,00H,00H,00H,00H
    148147                DB  00H,00H,00H,00H
    149148
    150149;last byte in 16 bits data segment
    151 __OffFinalDS16 label byte
     150                public __OffFinalDS16
     151__OffFinalDS16  label byte
    152152
    153153DATA16 ends
    154 
     154; ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ
    155155CODE16 segment
    156156        assume cs:CODE16, ds:DATA16
    157157
    158         public __OffFinalCS16
    159 
    160         public help_stub_strategy
    161         public uniaud_stub_strategy
    162         public uniaud_stub_idc
    163         public uniaud_stub_timer
    164         public thunk3216_devhelp
    165         public thunk3216_devhelp_modified_ds
    166158        extrn DOSOPEN       : far
    167         extrn DOSWRITE      : far
     159        extrn _DOSWRITE     : far
    168160        extrn DOSCLOSE      : far
    169161
     
    394386        lea     dx, [bp - 2]
    395387        push    dx
    396         call    DOSWRITE
     388        call    _DOSWRITE
    397389
    398390        pop     eax
     
    413405        ALIGN   2
    414406;use devhlp pointer stored in 16 bits code segment
     407        public thunk3216_devhelp
    415408thunk3216_devhelp:
    416409        push    ds
     
    419412        call    dword ptr DevHelpInit
    420413        pop     ds
    421 
    422414        jmp     far ptr FLAT:thunk1632_devhelp
    423415
    424416        ALIGN   2
     417        public thunk3216_devhelp_modified_ds
    425418thunk3216_devhelp_modified_ds:
    426419        push    gs
     
    10201013
    10211014;end of 16 bits code segment
     1015               public __OffFinalCS16
    10221016__OffFinalCS16 label byte
    10231017
    10241018CODE16 ends
    1025 
     1019; ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ
     1020;Label to mark start of 32 bits code section
     1021FIRSTCODE32 segment
     1022               public __OffBeginCS32
     1023__OffBeginCS32 label byte
     1024FIRSTCODE32 ends
     1025; ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ
    10261026CODE32 segment
    10271027ASSUME CS:FLAT, DS:FLAT, ES:FLAT
    10281028
    1029         public __GETDS
    1030         public thunk1632_devhelp
    1031         public thunk1632_devhelp_modified_ds   
    1032         public DevHlp
    1033         public DevHlp_ModifiedDS
    1034         public STRATEGY_
    1035         public IDC_
    1036         public TIMER_
    10371029        extrn  ALSA_STRATEGY  : near
    10381030        extrn  ALSA_IDC : near
    10391031        extrn  ALSA_TIMER_ : near
    10401032        extrn  ALSA_Interrupt : near
    1041         extrn  GetTKSSBase : near
    10421033        extrn  _rdOffset: dword
    1043 
    1044 IFDEF KEE
    10451034        extrn  KernThunkStackTo16 : near
    10461035        extrn  KernThunkStackTo32 : near
    1047 ELSE
    1048         extrn  StackAlloc : near
    1049         extrn  StackFree  : near
    1050 ENDIF
    10511036
    10521037;Called by Watcom to set the DS
     
    10671052DevHelpDebug  endp
    10681053
    1069         ALIGN   4
    1070 
    1071         ALIGN 4
     1054        ALIGN 4
     1055        public DevHlp
    10721056DevHlp proc near
    1073 IFDEF FLATSTACK
    10741057        DevThunkStackTo16_Int
    1075 ENDIF
    1076 
    10771058        jmp     far ptr CODE16:thunk3216_devhelp
    10781059        ALIGN 4
    10791060thunk1632_devhelp:
    1080 IFDEF FLATSTACK
    10811061        DevThunkStackTo32_Int
    1082 ENDIF
    10831062        ret
    10841063DevHlp endp
     
    10861065        ALIGN   4
    10871066DevHlp_ModifiedDS proc near
    1088 IFDEF FLATSTACK
    10891067        DevThunkStackTo16_Int
    1090 ENDIF
    10911068        jmp     far ptr CODE16:thunk3216_devhelp_modified_ds
    10921069        ALIGN 4
    10931070thunk1632_devhelp_modified_ds:
    1094 IFDEF FLATSTACK
    10951071        DevThunkStackTo32_Int
    1096 ENDIF
    10971072        ret
    10981073DevHlp_ModifiedDS endp
    1099 
    1100 
    1101 IFNDEF KEE
    1102 ;;******************************************************************************
    1103 ;FixSelDPL:
    1104 ;
    1105 ; Set DPL of DOS32FLATDS selector to 0 or else we'll get a trap D when loading
    1106 ; it into the SS register (DPL must equal CPL when loading a selector into SS)
    1107 ;;******************************************************************************
    1108         PUBLIC FixSelDPL
    1109         ALIGN  4
    1110 FixSelDPL proc near
    1111         cmp     fWrongDPL, 1
    1112         jne     short @@fixdpl_end
    1113         cmp     SelRef, 0
    1114         jne     short @@fixdpl_endfix
    1115         push    eax
    1116         push    ebx
    1117         push    edx
    1118         sgdt    fword ptr [gdtsave]             ; access the GDT ptr
    1119         mov     ebx, dword ptr [gdtsave+2]      ; get lin addr of GDT
    1120         mov     eax, ds                         ; build offset into table
    1121         and     eax, 0fffffff8h                 ; mask away DPL
    1122         add     ebx, eax                        ; build address
    1123 
    1124         mov     eax, dword ptr [ebx+4]
    1125         mov     edx, eax
    1126         shr     edx, 13
    1127         and     edx, 3
    1128 
    1129         ;has the OS/2 kernel finally changed the DPL to 0?
    1130         cmp     edx, 0
    1131         jne     @@changedpl
    1132         mov     fWrongDPL, 0            ;don't bother anymore
    1133         mov     SelRef, 0
    1134         jmp     short @@endchange
    1135 
    1136 @@changedpl:
    1137         mov     oldDPL, eax
    1138         and     eax, NOT 6000h          ;clear bits 5 & 6 in the high word (DPL)
    1139         mov     dword ptr [ebx+4], eax
    1140 @@endchange:
    1141         pop     edx
    1142         pop     ebx
    1143         pop     eax
    1144 @@fixdpl_endfix:
    1145         inc     SelRef
    1146 @@fixdpl_end:
    1147         ret
    1148 FixSelDPL endp
    1149 ;;******************************************************************************
    1150 ; RestoreSelDPL:
    1151 ;
    1152 ;  Restore DPL of DOS32FLATDS selector or else OS/2 kernel code running in ring 3
    1153 ;  will trap (during booting only; this sel has a DPL of 0 when PM starts up)
    1154 ;;******************************************************************************
    1155         PUBLIC RestoreSelDPL
    1156         ALIGN  4
    1157 RestoreSelDPL proc near
    1158         cmp     fWrongDPL, 1
    1159         jne     short @@restdpl_end
    1160 
    1161         cmp     SelRef, 1
    1162         jne     short @@restdpl_endrest
    1163         push    eax
    1164         push    ebx
    1165         sgdt    fword ptr [gdtsave]             ; access the GDT ptr
    1166         mov     ebx, dword ptr [gdtsave+2]      ; get lin addr of GDT
    1167         mov     eax, ds                         ; build offset into table
    1168         and     eax, 0fffffff8h                 ; mask away DPL
    1169         add     ebx, eax                        ; build address
    1170 
    1171         mov     eax, oldDPL
    1172         mov     dword ptr [ebx+4], eax
    1173         pop     ebx
    1174         pop     eax
    1175 @@restdpl_endrest:
    1176         dec     SelRef
    1177 @@restdpl_end:
    1178         ret
    1179 RestoreSelDPL endp
    1180 ENDIF
    11811074
    11821075;*******************************************************************************
     
    11941087        mov  ebp, esp
    11951088        push ebx
    1196 
    11971089        lea  ebx, [ebp+8]
    11981090        DevThunkStackTo16_Int
    1199 
    12001091        push dword ptr [ebx+16]    ;param2
    12011092        push dword ptr [ebx+12]    ;param1
     
    12031094        call fword ptr [ebx]
    12041095        add  sp, 12
    1205 
    12061096        DevThunkStackTo32_Int
    1207 
    12081097        pop  ebx
    12091098        pop  ebp
     
    12221111        push    fs
    12231112        push    gs
    1224 
    12251113        mov     eax, DOS32FLATDS
    12261114        mov     ds, eax
    12271115        mov     es, eax
    1228 
    1229 IFDEF FLATSTACK
    1230 
    1231 IFNDEF KEE
    1232         ;done in init.cpp for the KEE version
    1233         cmp     dword ptr [intSwitchStack], 0
    1234         jne     stratcontinue
    1235 
    1236         ;get TKSSBase & intSwitchStack pointers
    1237         call    GetTKSSBase
    1238 stratcontinue:
    1239 ENDIF
    1240 
    12411116        DevThunkStackTo32
    1242         cmp     eax, 0
    1243         jne     @@stackswitchfail_strat
    1244 
    12451117        call    ALSA_STRATEGY
    1246 
    12471118        DevThunkStackTo16
    1248 
    1249 @@stackswitchfail_strat:
    1250 ELSE
    1251         int     3
    1252         call    ALSA_STRATEGY
    1253 ENDIF
    1254 
    12551119        pop     gs
    12561120        pop     fs
     
    12731137        push    fs
    12741138        push    gs
    1275 
    12761139        mov     eax, DOS32FLATDS
    12771140        mov     ds, eax
    12781141        mov     es, eax
    1279 
    1280 IFDEF FLATSTACK
    12811142        DevThunkStackTo32
    1282         cmp     eax, 0
    1283         jne     @@stackswitchfail_idc
    1284 
    12851143        call    ALSA_IDC
    1286 
    12871144        DevThunkStackTo16
    1288 
    1289 @@stackswitchfail_idc:
    1290 
    1291 ELSE
    1292         int     3
    1293         call    ALSA_IDC
    1294 ENDIF
    1295 
    12961145        pop     gs
    12971146        pop     fs
     
    13101159        push    fs
    13111160        push    gs
    1312 
    13131161        mov     eax, DOS32FLATDS
    13141162        mov     ds, eax
    13151163        mov     es, eax
    1316 
    13171164IFDEF DEBUG
    13181165        add     DbgU32TimerCnt, 1
    13191166ENDIF
    1320 
    1321 IFDEF FLATSTACK
    13221167        DevThunkStackTo32
    1323         cmp     eax, 0
    1324         jne     @@stackswitchfail_timer
    1325 
    13261168        call    ALSA_TIMER_
    1327 
    13281169        DevThunkStackTo16
    1329 
    1330 @@stackswitchfail_timer:
    1331 
    1332 ELSE
    1333         int     3
    1334         call    ALSA_TIMER_
    1335 ENDIF
    13361170IFDEF DEBUG
    13371171        add     DbgU32TimerCnt, -1
    13381172ENDIF
    1339 
    13401173        pop     gs
    13411174        pop     fs
     
    13551188        enter   0, 0
    13561189        and     sp, 0fffch                      ; align stack
    1357 
    13581190        pushad
    13591191        push    ds
     
    13611193        push    fs
    13621194        push    gs
    1363 
    13641195        mov     eax, DOS32FLATDS
    13651196        mov     ds, eax
    13661197        mov     es, eax
    1367 
    13681198        pushfd
    1369 
    13701199IFDEF DEBUG
    13711200                add         DbgU32IntCnt, 1
    13721201ENDIF
    1373 
    13741202        ; At this point a cli is redundant
    13751203        ; we enter the interrupt handler with interrupts disabled.
    13761204        ;cli
    1377 
    1378 IFDEF FLATSTACK
    13791205        DevThunkStackTo32
    1380         cmp     eax, 0
    1381         jne     @@stackswitchfail_irq
    1382 
    13831206        ;returns irq status in eax (1=handled; 0=unhandled)
    13841207        call    ALSA_Interrupt
    1385 
    13861208        DevThunkStackTo16
    1387 
    1388 @@stackswitchfail_irq:
    1389 ELSE
    1390         int     3
    1391         call    ALSA_Interrupt
    1392 ENDIF
    1393 
    13941209IFDEF DEBUG
    13951210                add         DbgU32IntCnt, -1
    13961211ENDIF
    1397 
    13981212        ;restore flags
    13991213        popfd
    1400 
    14011214        cmp     eax, 1
    14021215        je      irqhandled
    14031216        stc                     ;tell OS/2 kernel we didn't handle this interrupt
    14041217        jmp     short endofirq
    1405 
    14061218irqhandled:
    14071219        clc                     ;tell OS/2 kernel this interrupt was ours
    1408 
    14091220endofirq:
    1410 
    14111221        pop     gs
    14121222        pop     fs
     
    14141224        pop     ds
    14151225        popad
    1416 
    14171226        leave
    14181227        retf
     
    15721381_RMHandleToResourceHandleList endp
    15731382
     1383; shifted from devhlp.asm
     1384        extrn  DOSIODELAYCNT : ABS
     1385        ALIGN 4
     1386        public iodelay32_
     1387iodelay32_ proc near
     1388        mov   eax, DOSIODELAYCNT
     1389        align 4
     1390@@:     dec   eax
     1391        jnz   @b
     1392        loop  iodelay32_
     1393        ret
     1394iodelay32_ endp
    15741395
    15751396CODE32 ends
    1576 
     1397; ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ
     1398;Label to mark end of 32 bits code section
     1399LASTCODE32 segment
     1400       public __OffFinalCS32
     1401__OffFinalCS32 label byte
     1402LASTCODE32 ends
     1403; ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ
     1404;Label to mark start of 32 bits data section
     1405BSS32 segment
     1406    public  __OffBeginDS32
     1407    __OffBeginDS32   dd 0
     1408BSS32 ends
     1409; ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ
    15771410DATA32  segment
     1411
     1412    public  stackbase
     1413    public  stacksel
     1414    stackbase dd 0
     1415    stacksel  dd 0
     1416
    15781417    public  __OffsetFinalCS16
    15791418    public  __OffsetFinalDS16
    1580     public  PDDName
     1419    __OffsetFinalCS16 dw OFFSET CODE16:__OffFinalCS16
     1420    __OffsetFinalDS16 dw OFFSET DATA16:__OffFinalDS16
     1421
    15811422    public  _MSG_TABLE32
     1423    _MSG_TABLE32     dw OFFSET  DATA16:_MSG_TABLE16
     1424                     dw SEG     DATA16:_MSG_TABLE16
     1425
     1426;16:32 addresses of resource manager functions in 16 bits code segment
    15821427    public  RMAllocResource1632
    15831428    public  RMModifyResources1632
     
    15901435    public  RMDevIDToHandleList1632
    15911436    public  RMHandleToResourceHandleList1632
    1592     public  _TimerHandler16
    1593     public  _ISR00
    1594     public  _ISR01
    1595     public  _ISR02
    1596     public  _ISR03
    1597     public  _ISR04
    1598     public  _ISR05
    1599     public  _ISR06
    1600     public  _ISR07
    1601 
    1602 IFDEF FLATSTACK
    1603     extrn   intSwitchStack : dword
    1604 ENDIF
    1605 
    1606 IFDEF KEE
    1607     public  stackbase
    1608     public  stacksel
    1609 
    1610     stackbase dd 0
    1611     stacksel  dd 0
    1612 ELSE
    1613 
    1614     public  gdtsave
    1615     public  fWrongDPL
    1616     public  oldDPL
    1617     public  SelRef
    1618 
    1619     tempeax          dd 0
    1620     tempedx          dd 0
    1621     tempesi          dd 0
    1622     cpuflags         dd 0
    1623 
    1624     gdtsave          dq 0
    1625     fWrongDPL        dd 1       ;DOS32FLATDS has the wrong DPL for SS
    1626     SelRef           dd 0
    1627     oldDPL           dd 0
    1628 
    1629     fInitStack       dd 0
    1630 ENDIF
    1631 
    1632     __OffsetFinalCS16 dw OFFSET CODE16:__OffFinalCS16
    1633     __OffsetFinalDS16 dw OFFSET DATA16:__OffFinalDS16
    1634 
    1635     _MSG_TABLE32     dw OFFSET  DATA16:_MSG_TABLE16
    1636                      dw SEG     DATA16:_MSG_TABLE16
    1637 
    1638 ;16:16 address of driver name
    1639     PDDName          dw OFFSET  DATA16:pddname16
    1640                      dw SEG     DATA16:pddname16
    1641 
    1642 ;16:32 addresses of resource manager functions in 16 bits code segment
    16431437    RMAllocResource1632  dd OFFSET CODE16:_RMAllocResource16
    16441438                         dw SEG CODE16:_RMAllocResource16
     
    16741468
    16751469;16:16 address of uniaud_stub_timer
     1470    public  _TimerHandler16
    16761471    _TimerHandler16      dd OFFSET CODE16:uniaud_stub_timer
    16771472                         dw OFFSET CODE16:uniaud_stub_timer
    16781473
    16791474;16:16 addresses of interrupt dispatchers
     1475    public  _ISR00
     1476    public  _ISR01
     1477    public  _ISR02
     1478    public  _ISR03
     1479    public  _ISR04
     1480    public  _ISR05
     1481    public  _ISR06
     1482    public  _ISR07
    16801483    _ISR00               dw OFFSET CODE16:ISR00_16
    16811484                         dw SEG CODE16:ISR00_16
     
    16941497    _ISR07               dw OFFSET CODE16:ISR07_16
    16951498                         dw SEG CODE16:ISR07_16
    1696 DATA32 ends
    1697 
    1698 end
    1699 
     1499DATA32     ends
     1500; ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ
     1501;Label to mark end of 32 bits data section
     1502LASTDATA32 segment
     1503    public __OffFinalDS32
     1504    __OffFinalDS32 dd 0
     1505LASTDATA32 ends
     1506
     1507           end
  • GPL/trunk/drv32/startup.inc

    r32 r679  
    5353                ENDM
    5454
    55 
    56 IFDEF KEE
    5755;pushfd/popfd trashed by fucking BUGY KernThunkStackTo32
    5856;fix idea by zuko
     
    6462        push    stacksel
    6563        push    stackbase
    66 
    6764        push    edx
    6865        mov     edx, ss
    6966        mov     stacksel, edx
    7067        pushfd
    71 
    7268        call    KernThunkStackTo32
    7369        popfd
    7470        mov     stackbase, edx
    75         pop     edx     ;trashed by KernThunkStackTo32
    76         xor     eax, eax ; mark success
     71        pop     edx      ;trashed by KernThunkStackTo32
    7772        ENDM
     73
    7874;;******************************************************************************
    7975;;******************************************************************************
     
    8783        pop     eax     ;trashed by KernThunkStackTo32
    8884        ENDM
     85
    8986;;******************************************************************************
    9087;;******************************************************************************
     
    9794        pop     eax     ;trashed by KernThunkStackTo16
    9895        pop     edx     ;trashed by KernThunkStackTo16 when called in interrupt context
    99 
    10096        pop     stackbase
    10197        pop     stacksel
     
    113109        pop     edx     ;trashed by KernThunkStackTo16 when called in interrupt context
    114110        ENDM
    115 ;;******************************************************************************
    116 ;;******************************************************************************
    117111
    118 ELSE
    119 
    120 ;;******************************************************************************
    121 ;;Need to preserve fs:ebx!! (all other registers must be saved by the caller)
    122 ;;******************************************************************************
    123 DevThunkStackTo32 MACRO
    124         LOCAL @@stackok, @@stackchangeend
    125 
    126 ;;;;        int     3
    127        
    128         pushfd
    129         cli
    130         pop     dword ptr [cpuflags]
    131 
    132         ;check if kernel DS selector DPL == 3; if so, change to 0       
    133         call    FixSelDPL
    134 
    135         ;allocate private stack
    136         push    fs
    137         call    StackAlloc
    138         pop     fs                             ;trashed by StackAlloc
    139         mov     dword ptr [fInitStack], 1
    140 
    141         cmp     eax, 0
    142         jne     @@stackok
    143        
    144 IFDEF DEBUG
    145         int     3   ;this is very fatal
    146 ENDIF
    147         call    RestoreSelDPL
    148         mov     eax, -1                         ;mark failure
    149 
    150         push    dword ptr [cpuflags]
    151         popfd
    152         jmp     short @@stackchangeend
    153        
    154 @@stackok:
    155         ;stack ptr in eax
    156         call    dword ptr [intSwitchStack]
    157 
    158         push    dword ptr [cpuflags]
    159         popfd
    160 
    161         mov     eax, 0                          ;mark success
    162 @@stackchangeend:
    163         ENDM
    164        
    165 ;;******************************************************************************
    166 ;;******************************************************************************
    167 DevThunkStackTo32_Int MACRO
    168         LOCAL @@cont32
    169 
    170         cmp     dword ptr [fInitStack], 0
    171         je      @@cont32
    172 
    173 ;;;;        int     3
    174         pushfd
    175         cli
    176         pop     dword ptr [cpuflags]
    177 
    178         mov     dword ptr [tempeax], eax        ;save eax
    179 
    180         pop     eax             ;pop saved flat stack pointer
    181 
    182         ;and switch back to our flat stack again
    183         call    dword ptr [intSwitchStack]
    184 
    185         mov     eax, dword ptr [tempeax]        ;restore eax
    186         push    dword ptr [cpuflags]
    187         popfd
    188 
    189 @@cont32:
    190         ENDM
    191        
    192 ;;******************************************************************************
    193 ;;******************************************************************************
    194 DevThunkStackTo16 MACRO
    195 ;;;;        int     3
    196 
    197         pushfd
    198         cli
    199         pop     dword ptr [cpuflags]
    200 
    201         mov     dword ptr [tempeax], eax        ;save eax
    202         mov     dword ptr [tempesi], esi        ;save esi
    203 
    204         mov     esi, esp
    205         xor     eax, eax        ;switch to 16 bits stack
    206         call    dword ptr [intSwitchStack]
    207 
    208         mov     eax, esi       
    209         call    StackFree
    210 
    211         call    RestoreSelDPL
    212 
    213         mov     eax, dword ptr [tempeax]
    214         mov     esi, dword ptr [tempesi]
    215                
    216         push    dword ptr [cpuflags]
    217         popfd
    218        
    219         ENDM
    220        
    221 ;;******************************************************************************
    222 ;;******************************************************************************
    223 DevThunkStackTo16_Int MACRO
    224         LOCAL @@cont16
    225 
    226         cmp     dword ptr [fInitStack], 0
    227         je      @@cont16
    228 
    229 ;;;;        int     3
    230         pushfd
    231         cli
    232         pop     dword ptr [cpuflags]
    233 
    234         mov     dword ptr [tempeax], eax        ;save eax
    235         mov     dword ptr [tempesi], esi        ;save esi
    236         mov     esi, esp
    237         xor     eax, eax        ;switch to 16 bits stack
    238         call    dword ptr [intSwitchStack]
    239         push    esi             ;flat stack ptr (popped before switching back to flat)
    240 
    241         mov     eax, dword ptr [tempeax]
    242         mov     esi, dword ptr [tempesi]
    243         push    dword ptr [cpuflags]
    244         popfd
    245 
    246 @@cont16:
    247         ENDM
    248 
    249 ENDIF ;KEE
    250 
    251 IFDEF FLATSTACK       
    252112;*******************************************************************************
    253113;enter a function that needs to switch to a 16 bits stack
     
    263123                push    esi
    264124                push    edi
    265 
    266125                ;to access the parameters on the 32 bits stack, once we've switched
    267126                mov     edi, ebp
    268 
    269127                DevThunkStackTo16_Int
    270128                ENDM
     129
    271130;*******************************************************************************
    272131;switch stack from 16 bits to 32 bits and return
     
    288147;;******************************************************************************
    289148
    290 ENDIF
    291149
    292150;Constants and structure definitions
    293 
    294 DevHlp_VirtToLin        EQU     5Bh
    295 DevHlp_VMLock           EQU     55h
    296151
    297152; Status word masks
     
    330185o_status        dw ?
    331186rpInitOut       ends
    332 
    333 
    334 ; definitions for 16 bits resource manager buffers
    335 ; (also in rm.hpp!!)
    336 MAXSIZE_RMNodeData     EQU 1024
    337 MAXSIZE_RMResources    EQU 128
    338 MAXSIZE_RMHandleList   EQU 128
    339 MAXSIZE_RMResourceList EQU 256
  • GPL/trunk/drv32/strategy.c

    r591 r679  
    2424 */
    2525
    26 #define INCL_NOPMAPI
    27 #define INCL_DOSINFOSEG    // Need Global info seg in rm.cpp algorithms
    2826#include <os2.h>
    29 
    3027#include <devhelp.h>
    31 //DAZ #include <devrp.h>
    32 #include <devown.h>
    33 #include "strategy.h"
    3428#include <ossidc32.h>
    3529#include <dbgos2.h>
    3630#include <string.h>
     31#include <u32ioctl.h>
     32#include "devown.h"
     33#include "strategy.h"
    3734
    3835ULONG StratRead(REQPACKET __far *_rp);
    3936ULONG StratIOCtl(REQPACKET __far *_rp);
    40 ULONG StratClose(REQPACKET __far *_rp);
    4137
    4238ULONG DiscardableInit(REQPACKET __far*);
     
    5450  }
    5551  numOS2Opens++;
     52  return RPDONE;
     53}
     54
     55//******************************************************************************
     56ULONG StratClose(REQPACKET __far* rp)
     57{
     58  // only called if device successfully opened
     59  //  printk("strat close\n");
     60  numOS2Opens--;
     61
     62  UniaudCloseAll(rp->open_close.usSysFileNum);
     63
     64  if (numOS2Opens == 0)
     65  {
     66    deviceOwner = DEV_NO_OWNER;
     67  }
    5668  return RPDONE;
    5769}
     
    172184  else return(RPERR_BADCOMMAND | RPDONE);
    173185}
    174 
Note: See TracChangeset for help on using the changeset viewer.